Mirrors/unleashed-firmware
2
0
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware synced 2024-11-27 15:00:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #76 from derskythe/subbrute-deep-refactor

Browse source 
Fix speed problems with linear and some bugs
This commit is contained in:
MX 2022-09-26 23:09:13 +03:00 committed by GitHub
commit 1f8a034a71
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 339 additions and 199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
applications/plugins/subbrute/helpers/subbrute_worker.c
View file

@ -3,14 +3,16 @@
#include <subghz/environment.h> #include <subghz/environment.h>
#include <subghz/transmitter.h> #include <subghz/transmitter.h>
#include <flipper_format_i.h> #include <flipper_format_i.h>
#include <lib/subghz/subghz_tx_rx_worker.h>
#define TAG "SubBruteWorker" #define TAG "SubBruteWorker"
struct SubBruteWorker { struct SubBruteWorker {
FuriThread* thread; SubGhzTxRxWorker* subghz_txrx;
volatile bool worker_running; volatile bool worker_running;
volatile bool worker_manual_mode; volatile bool worker_manual_mode;
bool is_manual_init; bool is_manual_init;
bool is_continuous_worker;
SubGhzEnvironment* environment; SubGhzEnvironment* environment;
SubGhzTransmitter* transmitter; SubGhzTransmitter* transmitter;
@ -31,80 +33,25 @@ struct SubBruteWorker {
#define SUBBRUTE_TXRX_WORKER_BUF_SIZE 2048 #define SUBBRUTE_TXRX_WORKER_BUF_SIZE 2048
#define SUBBRUTE_TXRX_WORKER_MAX_TXRX_SIZE 60 #define SUBBRUTE_TXRX_WORKER_MAX_TXRX_SIZE 60
#define SUBBRUTE_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF 40 #define SUBBRUTE_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF 40
#define SUBBRUTE_TX_TIMEOUT 50 #define SUBBRUTE_TX_TIMEOUT 5
#define SUBBRUTE_SEND_DELAY 260 #define SUBBRUTE_SEND_DELAY 20
/**
* Entrypoint for worker
*
* @param context SubBruteWorker*
* @return 0 if ok
*/
int32_t subbrute_worker_thread(void* context) {
furi_assert(context);
SubBruteWorker* instance = (SubBruteWorker*)context;
if(!instance->worker_running) {
FURI_LOG_W(TAG, "Worker is not set to running state!");
return -1;
}
#ifdef FURI_DEBUG
FURI_LOG_I(TAG, "Worker start");
#endif
instance->environment = subghz_environment_alloc();
instance->transmitter = subghz_transmitter_alloc_init(
instance->environment, string_get_cstr(instance->protocol_name));
furi_hal_subghz_reset();
furi_hal_subghz_load_preset(instance->preset);
instance->frequency = furi_hal_subghz_set_frequency_and_path(instance->frequency);
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
furi_hal_gpio_write(&gpio_cc1101_g0, true);
// Set ready to transmit value
instance->last_time_tx_data = furi_get_tick() - SUBBRUTE_SEND_DELAY;
while(instance->worker_running) {
// Transmit
if(!furi_hal_subghz_tx()) {
FURI_LOG_E(TAG, "Cannot transmit!");
break;
}
furi_delay_ms(SUBBRUTE_TX_TIMEOUT);
}
furi_hal_subghz_set_path(FuriHalSubGhzPathIsolate);
furi_hal_subghz_sleep();
subghz_transmitter_free(instance->transmitter);
instance->transmitter = NULL;
subghz_environment_free(instance->environment);
instance->environment = NULL;
#ifdef FURI_DEBUG
FURI_LOG_I(TAG, "Worker stop");
#endif
return 0;
}
SubBruteWorker* subbrute_worker_alloc() { SubBruteWorker* subbrute_worker_alloc() {
SubBruteWorker* instance = malloc(sizeof(SubBruteWorker)); SubBruteWorker* instance = malloc(sizeof(SubBruteWorker));
instance->thread = furi_thread_alloc();
furi_thread_set_name(instance->thread, "SubBruteAttackWorker");
furi_thread_set_stack_size(instance->thread, 2048);
furi_thread_set_context(instance->thread, instance);
furi_thread_set_callback(instance->thread, subbrute_worker_thread);
//instance->status = SubBruteWorkerStatusIDLE; //instance->status = SubBruteWorkerStatusIDLE;
instance->worker_running = false; instance->worker_running = false;
instance->worker_manual_mode = false; instance->worker_manual_mode = false;
//instance->environment = subghz_environment_alloc();
instance->transmitter = NULL;
instance->flipper_format = flipper_format_string_alloc(); instance->flipper_format = flipper_format_string_alloc();
string_init(instance->protocol_name); string_init(instance->protocol_name);
// SubGhzTxRxWorker
instance->subghz_txrx = subghz_tx_rx_worker_alloc();
return instance; return instance;
} }
@ -117,16 +64,18 @@ void subbrute_worker_free(SubBruteWorker* instance) {
instance->transmitter = NULL; instance->transmitter = NULL;
} }
if(instance->environment != NULL) { /*if(instance->environment != NULL) {
subghz_environment_free(instance->environment); subghz_environment_free(instance->environment);
instance->environment = NULL; instance->environment = NULL;
} }*/
furi_thread_free(instance->thread);
flipper_format_free(instance->flipper_format); flipper_format_free(instance->flipper_format);
string_clear(instance->protocol_name); string_clear(instance->protocol_name);
// SubGhzTxRxWorker
subghz_tx_rx_worker_free(instance->subghz_txrx);
free(instance); free(instance);
} }
@ -138,6 +87,7 @@ bool subbrute_worker_start(
furi_assert(instance); furi_assert(instance);
if(instance->worker_manual_mode) { if(instance->worker_manual_mode) {
FURI_LOG_W(TAG, "Invalid mode for starting worker!");
return false; return false;
} }
@ -166,9 +116,10 @@ bool subbrute_worker_start(
FURI_LOG_I(TAG, "Frequency: %d", frequency); FURI_LOG_I(TAG, "Frequency: %d", frequency);
#endif #endif
instance->preset = preset; instance->preset = preset;
if(res) {
furi_thread_start(instance->thread); instance->worker_running = res =
subghz_tx_rx_worker_start(instance->subghz_txrx, frequency);
}
return res; return res;
} }
@ -177,10 +128,21 @@ void subbrute_worker_stop(SubBruteWorker* instance) {
instance->worker_running = false; instance->worker_running = false;
furi_thread_join(instance->thread); if(subghz_tx_rx_worker_is_running(instance->subghz_txrx)) {
subghz_tx_rx_worker_stop(instance->subghz_txrx);
}
}
furi_hal_subghz_set_path(FuriHalSubGhzPathIsolate); void subbrute_worker_set_continuous_worker(SubBruteWorker* instance, bool is_continuous_worker) {
furi_hal_subghz_sleep(); furi_assert(instance);
instance->is_continuous_worker = is_continuous_worker;
}
bool subbrute_worker_get_continuous_worker(SubBruteWorker* instance) {
furi_assert(instance);
return instance->is_continuous_worker;
} }
bool subbrute_worker_is_running(SubBruteWorker* instance) { bool subbrute_worker_is_running(SubBruteWorker* instance) {
@ -195,6 +157,18 @@ bool subbrute_worker_can_transmit(SubBruteWorker* instance) {
return (furi_get_tick() - instance->last_time_tx_data) > SUBBRUTE_SEND_DELAY; return (furi_get_tick() - instance->last_time_tx_data) > SUBBRUTE_SEND_DELAY;
} }
bool subbrute_worker_can_manual_transmit(SubBruteWorker* instance, bool is_button_pressed) {
furi_assert(instance);
if(is_button_pressed) {
// It's human pressed, trying to reset twice pressing
return !instance->worker_manual_mode &&
(furi_get_tick() - instance->last_time_tx_data) > 500;
} else {
return !instance->worker_manual_mode;
}
}
bool subbrute_worker_transmit(SubBruteWorker* instance, const char* payload) { bool subbrute_worker_transmit(SubBruteWorker* instance, const char* payload) {
furi_assert(instance); furi_assert(instance);
furi_assert(instance->worker_running); furi_assert(instance->worker_running);
@ -210,14 +184,20 @@ bool subbrute_worker_transmit(SubBruteWorker* instance, const char* payload) {
//FURI_LOG_D(TAG, "payload: %s", payload); //FURI_LOG_D(TAG, "payload: %s", payload);
#endif #endif
Stream* stream = flipper_format_get_raw_stream(instance->flipper_format); while(!subghz_tx_rx_worker_write(instance->subghz_txrx, (uint8_t*)payload, strlen(payload))) {
stream_clean(stream); furi_delay_ms(10);
stream_write_cstring(stream, payload); }
subghz_transmitter_deserialize(instance->transmitter, instance->flipper_format);
furi_hal_subghz_flush_tx();
// Stream* stream = flipper_format_get_raw_stream(instance->flipper_format);
// stream_clean(stream);
// stream_write_cstring(stream, payload);
// subghz_transmitter_deserialize(instance->transmitter, instance->flipper_format);
return true; return true;
} }
// Init MANUAL
bool subbrute_worker_init_manual_transmit( bool subbrute_worker_init_manual_transmit(
SubBruteWorker* instance, SubBruteWorker* instance,
uint32_t frequency, uint32_t frequency,
@ -230,7 +210,8 @@ bool subbrute_worker_init_manual_transmit(
frequency, frequency,
protocol_name); protocol_name);
#endif #endif
if(instance->worker_manual_mode || !subbrute_worker_can_transmit(instance)) { if(instance->worker_manual_mode || !subbrute_worker_can_manual_transmit(instance, false) ||
instance->worker_running) {
#ifdef FURI_DEBUG #ifdef FURI_DEBUG
FURI_LOG_D(TAG, "cannot transmit"); FURI_LOG_D(TAG, "cannot transmit");
#endif #endif
@ -276,7 +257,6 @@ bool subbrute_worker_init_manual_transmit(
FURI_LOG_I(TAG, "Frequency: %d", frequency); FURI_LOG_I(TAG, "Frequency: %d", frequency);
#endif #endif
instance->environment = subghz_environment_alloc();
instance->transmitter = subghz_transmitter_alloc_init( instance->transmitter = subghz_transmitter_alloc_init(
instance->environment, string_get_cstr(instance->protocol_name)); instance->environment, string_get_cstr(instance->protocol_name));
@ -310,8 +290,6 @@ void subbrute_worker_manual_transmit_stop(SubBruteWorker* instance) {
subghz_transmitter_free(instance->transmitter); subghz_transmitter_free(instance->transmitter);
instance->transmitter = NULL; instance->transmitter = NULL;
} }
subghz_environment_free(instance->environment);
instance->environment = NULL;
instance->is_manual_init = false; instance->is_manual_init = false;
} }
@ -326,9 +304,7 @@ bool subbrute_worker_manual_transmit(SubBruteWorker* instance, const char* paylo
return false; return false;
} }
if(instance->worker_running) { if(instance->worker_running) {
#ifdef FURI_DEBUG FURI_LOG_W(TAG, "Worker was working for manual mode. Shutdown thread");
FURI_LOG_D(TAG, "subbrute_worker_stop");
#endif
subbrute_worker_stop(instance); subbrute_worker_stop(instance);
} }
if(!instance->is_manual_init) { if(!instance->is_manual_init) {

12
applications/plugins/subbrute/helpers/subbrute_worker.h
View file

@ -23,13 +23,17 @@ bool subbrute_worker_start(
FuriHalSubGhzPreset preset, FuriHalSubGhzPreset preset,
const char* protocol_name); const char* protocol_name);
void subbrute_worker_stop(SubBruteWorker* instance); void subbrute_worker_stop(SubBruteWorker* instance);
bool subbrute_worker_get_continuous_worker(SubBruteWorker* instance);
void subbrute_worker_set_continuous_worker(SubBruteWorker* instance, bool is_continuous_worker);
//bool subbrute_worker_write(SubBruteWorker* instance, uint8_t* data, size_t size); //bool subbrute_worker_write(SubBruteWorker* instance, uint8_t* data, size_t size);
bool subbrute_worker_is_running(SubBruteWorker* instance); bool subbrute_worker_is_running(SubBruteWorker* instance);
bool subbrute_worker_can_transmit(SubBruteWorker* instance); bool subbrute_worker_can_transmit(SubBruteWorker* instance);
bool subbrute_worker_can_manual_transmit(SubBruteWorker* instance, bool is_button_pressed);
bool subbrute_worker_transmit(SubBruteWorker* instance, const char* payload); bool subbrute_worker_transmit(SubBruteWorker* instance, const char* payload);
bool subbrute_worker_init_manual_transmit(SubBruteWorker* instance, bool subbrute_worker_init_manual_transmit(
uint32_t frequency, SubBruteWorker* instance,
FuriHalSubGhzPreset preset, uint32_t frequency,
const char* protocol_name); FuriHalSubGhzPreset preset,
const char* protocol_name);
bool subbrute_worker_manual_transmit(SubBruteWorker* instance, const char* payload); bool subbrute_worker_manual_transmit(SubBruteWorker* instance, const char* payload);
void subbrute_worker_manual_transmit_stop(SubBruteWorker* instance); void subbrute_worker_manual_transmit_stop(SubBruteWorker* instance);

25
applications/plugins/subbrute/scenes/subbrute_scene_load_file.c
View file

@ -45,19 +45,22 @@ void subbrute_scene_load_file_on_enter(void* context) {
res = true; res = true;
} }
} }
}
if(load_result == SubBruteFileResultOk) { if(load_result == SubBruteFileResultOk) {
scene_manager_next_scene(instance->scene_manager, SubBruteSceneLoadSelect); scene_manager_next_scene(instance->scene_manager, SubBruteSceneLoadSelect);
} else {
FURI_LOG_E(TAG, "Returned error: %d", load_result);
string_t dialog_msg;
string_init(dialog_msg);
string_cat_printf(
dialog_msg, "Cannot parse\nfile: %s", subbrute_device_error_get_desc(load_result));
dialog_message_show_storage_error(instance->dialogs, string_get_cstr(dialog_msg));
string_clear(dialog_msg);
scene_manager_search_and_switch_to_previous_scene(
instance->scene_manager, SubBruteSceneStart);
}
} else { } else {
FURI_LOG_E(TAG, "Returned error: %d", load_result);
string_t dialog_msg;
string_init(dialog_msg);
string_cat_printf(
dialog_msg, "Cannot parse\nfile: %s", subbrute_device_error_get_desc(load_result));
dialog_message_show_storage_error(instance->dialogs, string_get_cstr(dialog_msg));
string_clear(dialog_msg);
scene_manager_search_and_switch_to_previous_scene( scene_manager_search_and_switch_to_previous_scene(
instance->scene_manager, SubBruteSceneStart); instance->scene_manager, SubBruteSceneStart);
} }

163
applications/plugins/subbrute/scenes/subbrute_scene_run_attack.c
View file

@ -3,6 +3,8 @@
#include "../views/subbrute_attack_view.h" #include "../views/subbrute_attack_view.h"
#include "../helpers/subbrute_worker.h" #include "../helpers/subbrute_worker.h"
#define TAG "SubBruteSceneRunAttack"
static void subbrute_scene_run_attack_callback(SubBruteCustomEvent event, void* context) { static void subbrute_scene_run_attack_callback(SubBruteCustomEvent event, void* context) {
furi_assert(context); furi_assert(context);
@ -10,10 +12,57 @@ static void subbrute_scene_run_attack_callback(SubBruteCustomEvent event, void*
view_dispatcher_send_custom_event(instance->view_dispatcher, event); view_dispatcher_send_custom_event(instance->view_dispatcher, event);
} }
//static void subbrute_scene_run_attack_worker_callback(void* context) {
// SubBruteState* instance = (SubBruteState*)context;
//
// if(instance->locked || instance->device->key_index + 1 > instance->device->max_value) {
// return;
// }
// instance->locked = true;
//
// if(subbrute_worker_can_manual_transmit(instance->worker)) {
// // Blink
// notification_message(instance->notifications, &sequence_blink_yellow_100);
// subbrute_device_create_packet_parsed(instance->device, instance->device->key_index, true);
//
//#ifdef FURI_DEBUG
// FURI_LOG_I(TAG, "subbrute_worker_manual_transmit");
//#endif
// if(subbrute_worker_manual_transmit(instance->worker, instance->device->payload)) {
//#ifdef FURI_DEBUG
// FURI_LOG_I(TAG, "transmit ok");
//#endif
// // Make payload for new iteration or exit
// if(instance->device->key_index + 1 <= instance->device->max_value) {
// instance->device->key_index++;
// } else {
// view_dispatcher_send_custom_event(
// instance->view_dispatcher, SubBruteCustomEventTypeTransmitFinished);
// }
// }
//
// // Stop
// notification_message(instance->notifications, &sequence_blink_stop);
// }
//
// instance->locked = false;
// subbrute_attack_view_set_current_step(instance->view_attack, instance->device->key_index);
//}
void subbrute_scene_run_attack_on_exit(void* context) { void subbrute_scene_run_attack_on_exit(void* context) {
furi_assert(context); furi_assert(context);
SubBruteState* instance = (SubBruteState*)context; SubBruteState* instance = (SubBruteState*)context;
// SubBruteAttackState* state = (SubBruteAttackState*)scene_manager_get_scene_state(
// instance->scene_manager, SubBruteSceneRunAttack);
// furi_assert(state);
//
// furi_timer_free(state->timer);
// free(state);
if(subbrute_worker_get_continuous_worker(instance->worker)) {
subbrute_worker_stop(instance->worker);
}
notification_message(instance->notifications, &sequence_blink_stop); notification_message(instance->notifications, &sequence_blink_stop);
} }
@ -21,6 +70,10 @@ void subbrute_scene_run_attack_on_enter(void* context) {
furi_assert(context); furi_assert(context);
SubBruteState* instance = (SubBruteState*)context; SubBruteState* instance = (SubBruteState*)context;
SubBruteAttackView* view = instance->view_attack; SubBruteAttackView* view = instance->view_attack;
//
// SubBruteAttackState* state = malloc(sizeof(SubBruteAttackState));
// scene_manager_set_scene_state(
// instance->scene_manager, SubBruteSceneRunAttack, (uint32_t)state);
instance->current_view = SubBruteViewAttack; instance->current_view = SubBruteViewAttack;
subbrute_attack_view_set_callback(view, subbrute_scene_run_attack_callback, instance); subbrute_attack_view_set_callback(view, subbrute_scene_run_attack_callback, instance);
@ -33,47 +86,107 @@ void subbrute_scene_run_attack_on_enter(void* context) {
instance->device->key_index, instance->device->key_index,
true); true);
// Start worker if not started if(subbrute_worker_get_continuous_worker(instance->worker)) {
subbrute_worker_init_manual_transmit( // Init Continuous worker with values!
instance->worker, if(!subbrute_worker_start(
instance->device->frequency, instance->worker,
instance->device->preset, instance->device->frequency,
string_get_cstr(instance->device->protocol_name)); instance->device->preset,
string_get_cstr(instance->device->protocol_name))) {
FURI_LOG_W(TAG, "Worker Continuous init failed!");
}
} else {
// Init worker with values
if(!subbrute_worker_init_manual_transmit(
instance->worker,
instance->device->frequency,
instance->device->preset,
string_get_cstr(instance->device->protocol_name))) {
FURI_LOG_W(TAG, "Worker init failed!");
}
// state->timer = furi_timer_alloc(
// subbrute_scene_run_attack_worker_callback, FuriTimerTypePeriodic, instance);
// furi_timer_start(state->timer, pdMS_TO_TICKS(100)); // 20 ms
}
} }
bool subbrute_scene_run_attack_on_event(void* context, SceneManagerEvent event) { bool subbrute_scene_run_attack_on_event(void* context, SceneManagerEvent event) {
SubBruteState* instance = (SubBruteState*)context; SubBruteState* instance = (SubBruteState*)context;
SubBruteAttackView* view = instance->view_attack; // SubBruteAttackState* state = (SubBruteAttackState*)scene_manager_get_scene_state(
// instance->scene_manager, SubBruteSceneRunAttack);
// furi_assert(state);
bool consumed = false; bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) { if(event.type == SceneManagerEventTypeCustom) {
SubBruteAttackView* view = instance->view_attack;
if(event.event == SubBruteCustomEventTypeTransmitNotStarted || if(event.event == SubBruteCustomEventTypeTransmitNotStarted ||
event.event == SubBruteCustomEventTypeTransmitFinished || event.event == SubBruteCustomEventTypeTransmitFinished ||
event.event == SubBruteCustomEventTypeBackPressed) { event.event == SubBruteCustomEventTypeBackPressed) {
// furi_timer_stop(state->timer);
// Stop transmit // Stop transmit
scene_manager_next_scene(instance->scene_manager, SubBruteSceneSetupAttack); notification_message(instance->notifications, &sequence_display_backlight_on);
notification_message(instance->notifications, &sequence_single_vibro);
subbrute_attack_view_set_current_step(view, instance->device->key_index);
scene_manager_search_and_switch_to_previous_scene(
instance->scene_manager, SubBruteSceneSetupAttack);
consumed = true; consumed = true;
} else if(event.event == SubBruteCustomEventTypeUpdateView) {
subbrute_attack_view_set_current_step(view, instance->device->key_index);
} }
} else if(event.type == SceneManagerEventTypeTick) { } else if(event.type == SceneManagerEventTypeTick) {
if(subbrute_worker_can_transmit(instance->worker)) { if(subbrute_worker_get_continuous_worker(instance->worker)) {
// Blink if(subbrute_worker_can_transmit(instance->worker)) {
notification_message(instance->notifications, &sequence_blink_yellow_100); // Blink
notification_message(instance->notifications, &sequence_blink_yellow_100);
if(subbrute_worker_manual_transmit(instance->worker, instance->device->payload)) { subbrute_device_create_packet_parsed(
// Make payload for new iteration or exit instance->device, instance->device->key_index, true);
if(instance->device->key_index + 1 > instance->device->max_value) {
// End of list if(subbrute_worker_transmit(instance->worker, instance->device->payload)) {
scene_manager_next_scene(instance->scene_manager, SubBruteSceneSetupAttack); // Make payload for new iteration or exit
} else { if(instance->device->key_index + 1 > instance->device->max_value) {
instance->device->key_index++; // End of list
subbrute_attack_view_set_current_step(view, instance->device->key_index); view_dispatcher_send_custom_event(
subbrute_device_create_packet_parsed( instance->view_dispatcher, SubBruteCustomEventTypeTransmitFinished);
instance->device, instance->device->key_index); } else {
instance->device->key_index++;
view_dispatcher_send_custom_event(
instance->view_dispatcher, SubBruteCustomEventTypeUpdateView);
//subbrute_attack_view_set_current_step(view, instance->device->key_index);
}
} }
}
// Stop // Stop
notification_message(instance->notifications, &sequence_blink_stop); notification_message(instance->notifications, &sequence_blink_stop);
}
} else {
if(subbrute_worker_can_manual_transmit(instance->worker, false)) {
// Blink
notification_message(instance->notifications, &sequence_blink_yellow_100);
subbrute_device_create_packet_parsed(
instance->device, instance->device->key_index, true);
if(subbrute_worker_manual_transmit(instance->worker, instance->device->payload)) {
// Make payload for new iteration or exit
if(instance->device->key_index + 1 > instance->device->max_value) {
// End of list
view_dispatcher_send_custom_event(
instance->view_dispatcher, SubBruteCustomEventTypeTransmitFinished);
} else {
instance->device->key_index++;
view_dispatcher_send_custom_event(
instance->view_dispatcher, SubBruteCustomEventTypeUpdateView);
//subbrute_attack_view_set_current_step(view, instance->device->key_index);
}
}
// Stop
notification_message(instance->notifications, &sequence_blink_stop);
}
} }
consumed = true; consumed = true;

32
applications/plugins/subbrute/scenes/subbrute_scene_setup_attack.c
View file

@ -27,11 +27,13 @@ void subbrute_scene_setup_attack_on_enter(void* context) {
instance->device->key_index, instance->device->key_index,
false); false);
subbrute_worker_init_manual_transmit( if(!subbrute_worker_init_manual_transmit(
instance->worker, instance->worker,
instance->device->frequency, instance->device->frequency,
instance->device->preset, instance->device->preset,
string_get_cstr(instance->device->protocol_name)); string_get_cstr(instance->device->protocol_name))) {
FURI_LOG_W(TAG, "Worker init failed!");
}
instance->current_view = SubBruteViewAttack; instance->current_view = SubBruteViewAttack;
subbrute_attack_view_set_callback(view, subbrute_scene_setup_attack_callback, instance); subbrute_attack_view_set_callback(view, subbrute_scene_setup_attack_callback, instance);
@ -55,7 +57,13 @@ bool subbrute_scene_setup_attack_on_event(void* context, SceneManagerEvent event
if(event.type == SceneManagerEventTypeCustom) { if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubBruteCustomEventTypeTransmitStarted) { if(event.event == SubBruteCustomEventTypeTransmitStarted) {
subbrute_device_create_packet_parsed(instance->device, instance->device->key_index); subbrute_worker_set_continuous_worker(instance->worker, false);
subbrute_attack_view_set_worker_type(view, false);
scene_manager_next_scene(instance->scene_manager, SubBruteSceneRunAttack);
} else if(event.event == SubBruteCustomEventTypeTransmitContinuousStarted) {
// Setting different type of worker
subbrute_worker_set_continuous_worker(instance->worker, true);
subbrute_attack_view_set_worker_type(view, true);
scene_manager_next_scene(instance->scene_manager, SubBruteSceneRunAttack); scene_manager_next_scene(instance->scene_manager, SubBruteSceneRunAttack);
} else if(event.event == SubBruteCustomEventTypeSaveFile) { } else if(event.event == SubBruteCustomEventTypeSaveFile) {
subbrute_worker_manual_transmit_stop(instance->worker); subbrute_worker_manual_transmit_stop(instance->worker);
@ -94,8 +102,8 @@ bool subbrute_scene_setup_attack_on_event(void* context, SceneManagerEvent event
} }
subbrute_attack_view_set_current_step(view, instance->device->key_index); subbrute_attack_view_set_current_step(view, instance->device->key_index);
} else if(event.event == SubBruteCustomEventTypeChangeStepUpMore) { } else if(event.event == SubBruteCustomEventTypeChangeStepUpMore) {
// +100 // +50
uint64_t value = instance->device->key_index + 100; uint64_t value = instance->device->key_index + 50;
if(value == instance->device->max_value) { if(value == instance->device->max_value) {
instance->device->key_index += value; instance->device->key_index += value;
} else { } else {
@ -118,8 +126,8 @@ bool subbrute_scene_setup_attack_on_event(void* context, SceneManagerEvent event
} }
subbrute_attack_view_set_current_step(view, instance->device->key_index); subbrute_attack_view_set_current_step(view, instance->device->key_index);
} else if(event.event == SubBruteCustomEventTypeChangeStepDownMore) { } else if(event.event == SubBruteCustomEventTypeChangeStepDownMore) {
// -100 // -50
uint64_t value = ((instance->device->key_index - 100) + instance->device->max_value); uint64_t value = ((instance->device->key_index - 50) + instance->device->max_value);
if(value == instance->device->max_value) { if(value == instance->device->max_value) {
instance->device->key_index = value; instance->device->key_index = value;
} else { } else {
@ -127,7 +135,7 @@ bool subbrute_scene_setup_attack_on_event(void* context, SceneManagerEvent event
} }
subbrute_attack_view_set_current_step(view, instance->device->key_index); subbrute_attack_view_set_current_step(view, instance->device->key_index);
} else if(event.event == SubBruteCustomEventTypeTransmitCustom) { } else if(event.event == SubBruteCustomEventTypeTransmitCustom) {
if(subbrute_worker_can_transmit(instance->worker)) { if(subbrute_worker_can_manual_transmit(instance->worker, true)) {
// Blink // Blink
notification_message(instance->notifications, &sequence_blink_green_100); notification_message(instance->notifications, &sequence_blink_green_100);
@ -139,7 +147,7 @@ bool subbrute_scene_setup_attack_on_event(void* context, SceneManagerEvent event
// string_get_cstr(instance->device->protocol_name)); // string_get_cstr(instance->device->protocol_name));
// } // }
subbrute_device_create_packet_parsed( subbrute_device_create_packet_parsed(
instance->device, instance->device->key_index); instance->device, instance->device->key_index, false);
subbrute_worker_manual_transmit(instance->worker, instance->device->payload); subbrute_worker_manual_transmit(instance->worker, instance->device->payload);
// Stop // Stop

15
applications/plugins/subbrute/subbrute.c
View file

@ -81,7 +81,7 @@ SubBruteState* subbrute_alloc() {
view_dispatcher_set_navigation_event_callback( view_dispatcher_set_navigation_event_callback(
instance->view_dispatcher, subbrute_back_event_callback); instance->view_dispatcher, subbrute_back_event_callback);
view_dispatcher_set_tick_event_callback( view_dispatcher_set_tick_event_callback(
instance->view_dispatcher, subbrute_tick_event_callback, 100); instance->view_dispatcher, subbrute_tick_event_callback, 10);
//Dialog //Dialog
instance->dialogs = furi_record_open(RECORD_DIALOGS); instance->dialogs = furi_record_open(RECORD_DIALOGS);
@ -142,12 +142,6 @@ SubBruteState* subbrute_alloc() {
void subbrute_free(SubBruteState* instance) { void subbrute_free(SubBruteState* instance) {
furi_assert(instance); furi_assert(instance);
// SubBruteDevice
#ifdef FURI_DEBUG
FURI_LOG_D(TAG, "free SubBruteDevice");
#endif
subbrute_device_free(instance->device);
// SubBruteWorker // SubBruteWorker
#ifdef FURI_DEBUG #ifdef FURI_DEBUG
FURI_LOG_D(TAG, "free SubBruteDevice"); FURI_LOG_D(TAG, "free SubBruteDevice");
@ -155,6 +149,12 @@ void subbrute_free(SubBruteState* instance) {
subbrute_worker_stop(instance->worker); subbrute_worker_stop(instance->worker);
subbrute_worker_free(instance->worker); subbrute_worker_free(instance->worker);
// SubBruteDevice
#ifdef FURI_DEBUG
FURI_LOG_D(TAG, "free SubBruteDevice");
#endif
subbrute_device_free(instance->device);
// Notifications // Notifications
#ifdef FURI_DEBUG #ifdef FURI_DEBUG
FURI_LOG_D(TAG, "free Notifications"); FURI_LOG_D(TAG, "free Notifications");
@ -297,6 +297,7 @@ int32_t subbrute_app(void* p) {
scene_manager_next_scene(instance->scene_manager, SubBruteSceneStart); scene_manager_next_scene(instance->scene_manager, SubBruteSceneStart);
furi_hal_power_suppress_charge_enter(); furi_hal_power_suppress_charge_enter();
notification_message(instance->notifications, &sequence_display_backlight_on);
view_dispatcher_run(instance->view_dispatcher); view_dispatcher_run(instance->view_dispatcher);
furi_hal_power_suppress_charge_exit(); furi_hal_power_suppress_charge_exit();
subbrute_free(instance); subbrute_free(instance);

3
applications/plugins/subbrute/subbrute_custom_event.h
View file

@ -10,11 +10,12 @@ typedef enum {
SubBruteCustomEventTypeBackPressed, SubBruteCustomEventTypeBackPressed,
SubBruteCustomEventTypeIndexSelected, SubBruteCustomEventTypeIndexSelected,
SubBruteCustomEventTypeTransmitStarted, SubBruteCustomEventTypeTransmitStarted,
SubBruteCustomEventTypeTransmitContinuousStarted,
SubBruteCustomEventTypeTransmitFinished, SubBruteCustomEventTypeTransmitFinished,
SubBruteCustomEventTypeTransmitNotStarted, SubBruteCustomEventTypeTransmitNotStarted,
SubBruteCustomEventTypeTransmitCustom, SubBruteCustomEventTypeTransmitCustom,
SubBruteCustomEventTypeSaveFile, SubBruteCustomEventTypeSaveFile,
SubBruteCustomEventTypeSaveSuccess, SubBruteCustomEventTypeUpdateView,
SubBruteCustomEventTypeChangeStepUp, SubBruteCustomEventTypeChangeStepUp,
SubBruteCustomEventTypeChangeStepDown, SubBruteCustomEventTypeChangeStepDown,
SubBruteCustomEventTypeChangeStepUpMore, SubBruteCustomEventTypeChangeStepUpMore,

72
applications/plugins/subbrute/subbrute_device.c
View file

@ -37,6 +37,8 @@ static const char* subbrute_key_file_start =
"Filetype: Flipper SubGhz Key File\nVersion: 1\nFrequency: %u\nPreset: %s\nProtocol: %s\nBit: %d"; "Filetype: Flipper SubGhz Key File\nVersion: 1\nFrequency: %u\nPreset: %s\nProtocol: %s\nBit: %d";
static const char* subbrute_key_file_key = "%s\nKey: %s\n"; static const char* subbrute_key_file_key = "%s\nKey: %s\n";
static const char* subbrute_key_file_princeton_end = "%s\nKey: %s\nTE: %d\n"; static const char* subbrute_key_file_princeton_end = "%s\nKey: %s\nTE: %d\n";
static const char* subbrute_key_small_no_tail = "Bit: %d\nKey: %s\n";
static const char* subbrute_key_small_with_tail = "Bit: %d\nKey: %s\nTE: %d\n";
// Why nobody set in as const in all codebase? // Why nobody set in as const in all codebase?
static const char* preset_ook270_async = "FuriHalSubGhzPresetOok270Async"; static const char* preset_ook270_async = "FuriHalSubGhzPresetOok270Async";
@ -58,7 +60,7 @@ SubBruteDevice* subbrute_device_alloc() {
instance->decoder_result = NULL; instance->decoder_result = NULL;
instance->receiver = NULL; instance->receiver = NULL;
instance->environment = NULL; instance->environment = subghz_environment_alloc();
subbrute_device_attack_set_default_values(instance, SubBruteAttackCAME12bit307); subbrute_device_attack_set_default_values(instance, SubBruteAttackCAME12bit307);
@ -82,13 +84,8 @@ void subbrute_device_free(SubBruteDevice* instance) {
instance->receiver = NULL; instance->receiver = NULL;
} }
if(instance->environment != NULL) { subghz_environment_free(instance->environment);
#ifdef FURI_DEBUG instance->environment = NULL;
FURI_LOG_D(TAG, "subghz_environment_free");
#endif
subghz_environment_free(instance->environment);
instance->environment = NULL;
}
#ifdef FURI_DEBUG #ifdef FURI_DEBUG
FURI_LOG_D(TAG, "before free"); FURI_LOG_D(TAG, "before free");
@ -107,7 +104,7 @@ bool subbrute_device_save_file(SubBruteDevice* instance, const char* dev_file_na
#ifdef FURI_DEBUG #ifdef FURI_DEBUG
FURI_LOG_D(TAG, "subbrute_device_save_file: %s", dev_file_name); FURI_LOG_D(TAG, "subbrute_device_save_file: %s", dev_file_name);
#endif #endif
bool result = subbrute_device_create_packet_parsed(instance, instance->key_index); bool result = subbrute_device_create_packet_parsed(instance, instance->key_index, false);
if(!result) { if(!result) {
FURI_LOG_E(TAG, "subbrute_device_create_packet_parsed failed!"); FURI_LOG_E(TAG, "subbrute_device_create_packet_parsed failed!");
@ -191,7 +188,7 @@ const char* subbrute_device_error_get_desc(SubBruteFileResult error_id) {
return result; return result;
} }
bool subbrute_device_create_packet_parsed(SubBruteDevice* instance, uint64_t step) { bool subbrute_device_create_packet_parsed(SubBruteDevice* instance, uint64_t step, bool small) {
furi_assert(instance); furi_assert(instance);
//char step_payload[32]; //char step_payload[32];
@ -234,21 +231,40 @@ bool subbrute_device_create_packet_parsed(SubBruteDevice* instance, uint64_t ste
FURI_LOG_D(TAG, "candidate: %s, step: %d", string_get_cstr(candidate), step); FURI_LOG_D(TAG, "candidate: %s, step: %d", string_get_cstr(candidate), step);
#endif #endif
if(instance->has_tail) { if(small) {
snprintf( if(instance->has_tail) {
instance->payload, snprintf(
sizeof(instance->payload), instance->payload,
subbrute_key_file_princeton_end, sizeof(instance->payload),
instance->file_template, subbrute_key_small_with_tail,
string_get_cstr(candidate), instance->bit,
instance->te); string_get_cstr(candidate),
instance->te);
} else {
snprintf(
instance->payload,
sizeof(instance->payload),
subbrute_key_small_no_tail,
instance->bit,
string_get_cstr(candidate));
}
} else { } else {
snprintf( if(instance->has_tail) {
instance->payload, snprintf(
sizeof(instance->payload), instance->payload,
subbrute_key_file_key, sizeof(instance->payload),
instance->file_template, subbrute_key_file_princeton_end,
string_get_cstr(candidate)); instance->file_template,
string_get_cstr(candidate),
instance->te);
} else {
snprintf(
instance->payload,
sizeof(instance->payload),
subbrute_key_file_key,
instance->file_template,
string_get_cstr(candidate));
}
} }
#ifdef FURI_DEBUG #ifdef FURI_DEBUG
@ -337,7 +353,6 @@ SubBruteFileResult subbrute_device_attack_set(SubBruteDevice* instance, SubBrute
} }
// For non-file types we didn't set SubGhzProtocolDecoderBase // For non-file types we didn't set SubGhzProtocolDecoderBase
instance->environment = subghz_environment_alloc();
instance->receiver = subghz_receiver_alloc_init(instance->environment); instance->receiver = subghz_receiver_alloc_init(instance->environment);
subghz_receiver_set_filter(instance->receiver, SubGhzProtocolFlag_Decodable); subghz_receiver_set_filter(instance->receiver, SubGhzProtocolFlag_Decodable);
furi_hal_subghz_reset(); furi_hal_subghz_reset();
@ -359,10 +374,8 @@ SubBruteFileResult subbrute_device_attack_set(SubBruteDevice* instance, SubBrute
protocol_check_result = SubBruteFileResultOk; protocol_check_result = SubBruteFileResultOk;
} }
subghz_environment_free(instance->environment);
subghz_receiver_free(instance->receiver); subghz_receiver_free(instance->receiver);
instance->receiver = NULL; instance->receiver = NULL;
instance->environment = NULL;
if(protocol_check_result != SubBruteFileResultOk) { if(protocol_check_result != SubBruteFileResultOk) {
return SubBruteFileResultProtocolNotFound; return SubBruteFileResultProtocolNotFound;
@ -407,7 +420,7 @@ SubBruteFileResult subbrute_device_attack_set(SubBruteDevice* instance, SubBrute
#endif #endif
// Init payload // Init payload
subbrute_device_create_packet_parsed(instance, instance->key_index); subbrute_device_create_packet_parsed(instance, instance->key_index, false);
return SubBruteFileResultOk; return SubBruteFileResultOk;
} }
@ -426,7 +439,6 @@ uint8_t subbrute_device_load_from_file(SubBruteDevice* instance, string_t file_p
string_init(temp_str); string_init(temp_str);
uint32_t temp_data32; uint32_t temp_data32;
instance->environment = subghz_environment_alloc();
instance->receiver = subghz_receiver_alloc_init(instance->environment); instance->receiver = subghz_receiver_alloc_init(instance->environment);
subghz_receiver_set_filter(instance->receiver, SubGhzProtocolFlag_Decodable); subghz_receiver_set_filter(instance->receiver, SubGhzProtocolFlag_Decodable);
furi_hal_subghz_reset(); furi_hal_subghz_reset();
@ -561,12 +573,10 @@ uint8_t subbrute_device_load_from_file(SubBruteDevice* instance, string_t file_p
flipper_format_free(fff_data_file); flipper_format_free(fff_data_file);
furi_record_close(RECORD_STORAGE); furi_record_close(RECORD_STORAGE);
subghz_environment_free(instance->environment);
subghz_receiver_free(instance->receiver); subghz_receiver_free(instance->receiver);
instance->decoder_result = NULL; instance->decoder_result = NULL;
instance->receiver = NULL; instance->receiver = NULL;
instance->environment = NULL;
if(result == SubBruteFileResultOk) { if(result == SubBruteFileResultOk) {
#ifdef FURI_DEBUG #ifdef FURI_DEBUG

2
applications/plugins/subbrute/subbrute_device.h
View file

@ -92,7 +92,7 @@ SubBruteDevice* subbrute_device_alloc();
void subbrute_device_free(SubBruteDevice* instance); void subbrute_device_free(SubBruteDevice* instance);
bool subbrute_device_save_file(SubBruteDevice* instance, const char* key_name); bool subbrute_device_save_file(SubBruteDevice* instance, const char* key_name);
const char* subbrute_device_error_get_desc(SubBruteFileResult error_id); const char* subbrute_device_error_get_desc(SubBruteFileResult error_id);
bool subbrute_device_create_packet_parsed(SubBruteDevice* context, uint64_t step); bool subbrute_device_create_packet_parsed(SubBruteDevice* context, uint64_t step, bool small);
SubBruteFileResult subbrute_device_attack_set(SubBruteDevice* context, SubBruteAttacks type); SubBruteFileResult subbrute_device_attack_set(SubBruteDevice* context, SubBruteAttacks type);
uint8_t subbrute_device_load_from_file(SubBruteDevice* context, string_t file_path); uint8_t subbrute_device_load_from_file(SubBruteDevice* context, string_t file_path);
FuriHalSubGhzPreset subbrute_device_convert_preset(const char* preset); FuriHalSubGhzPreset subbrute_device_convert_preset(const char* preset);

60
applications/plugins/subbrute/views/subbrute_attack_view.c
View file

@ -20,6 +20,7 @@ typedef struct {
uint64_t max_value; uint64_t max_value;
uint64_t current_step; uint64_t current_step;
bool is_attacking; bool is_attacking;
bool is_continuous_worker;
IconAnimation* icon; IconAnimation* icon;
} SubBruteAttackViewModel; } SubBruteAttackViewModel;
@ -47,6 +48,7 @@ bool subbrute_attack_view_input(InputEvent* event, void* context) {
with_view_model( with_view_model(
instance->view, (SubBruteAttackViewModel * model) { instance->view, (SubBruteAttackViewModel * model) {
model->is_attacking = false; model->is_attacking = false;
model->is_continuous_worker = false;
return true; return true;
}); });
return true; return true;
@ -67,25 +69,45 @@ bool subbrute_attack_view_input(InputEvent* event, void* context) {
// } // }
if(!is_attacking) { if(!is_attacking) {
if((event->type == InputTypeShort || event->type == InputTypeRepeat) && if(event->type == InputTypeShort && event->key == InputKeyOk) {
event->key == InputKeyOk) {
#ifdef FURI_DEBUG #ifdef FURI_DEBUG
FURI_LOG_D(TAG, "InputKey: %d OK", event->key); FURI_LOG_D(TAG, "InputKey: %d OK", event->key);
#endif #endif
with_view_model( with_view_model(
instance->view, (SubBruteAttackViewModel * model) { instance->view, (SubBruteAttackViewModel * model) {
model->is_attacking = true; model->is_attacking = true;
model->is_continuous_worker = false;
icon_animation_stop(model->icon); icon_animation_stop(model->icon);
icon_animation_start(model->icon); icon_animation_start(model->icon);
return true; return true;
}); });
instance->callback(SubBruteCustomEventTypeTransmitStarted, instance->context); instance->callback(SubBruteCustomEventTypeTransmitStarted, instance->context);
// } else if(event->key == InputKeyBack) { /*if(event->type == InputTypeRepeat && event->key == InputKeyOk) {
// if(previous_scene == SubBruteSceneLoadFile) { #ifdef FURI_DEBUG
// instance->callback(SubBruteCustomEventTypeLoadFile, instance->context); FURI_LOG_D(TAG, "InputKey: %d OK. SubBruteCustomEventTypeTransmitContinuousStarted", event->key);
// } else { #endif
// instance->callback(SubBruteCustomEventTypeBackPressed, instance->context); with_view_model(
// } instance->view, (SubBruteAttackViewModel * model) {
model->is_attacking = true;
model->is_continuous_worker = true;
icon_animation_stop(model->icon);
icon_animation_start(model->icon);
return true;
});
instance->callback(SubBruteCustomEventTypeTransmitContinuousStarted, instance->context);
} else if(event->type == InputTypeShort && event->key == InputKeyOk) {
#ifdef FURI_DEBUG
FURI_LOG_D(TAG, "InputKey: %d OK", event->key);
#endif
with_view_model(
instance->view, (SubBruteAttackViewModel * model) {
model->is_attacking = true;
model->is_continuous_worker = false;
icon_animation_stop(model->icon);
icon_animation_start(model->icon);
return true;
});
instance->callback(SubBruteCustomEventTypeTransmitStarted, instance->context);*/
} else if(event->key == InputKeyUp) { } else if(event->key == InputKeyUp) {
instance->callback(SubBruteCustomEventTypeSaveFile, instance->context); instance->callback(SubBruteCustomEventTypeSaveFile, instance->context);
} else if(event->key == InputKeyDown) { } else if(event->key == InputKeyDown) {
@ -131,6 +153,7 @@ bool subbrute_attack_view_input(InputEvent* event, void* context) {
with_view_model( with_view_model(
instance->view, (SubBruteAttackViewModel * model) { instance->view, (SubBruteAttackViewModel * model) {
model->is_attacking = false; model->is_attacking = false;
model->is_continuous_worker = false;
icon_animation_stop(model->icon); icon_animation_stop(model->icon);
icon_animation_start(model->icon); icon_animation_start(model->icon);
return true; return true;
@ -161,7 +184,6 @@ SubBruteAttackView* subbrute_attack_view_alloc() {
view_set_enter_callback(instance->view, subbrute_attack_view_enter); view_set_enter_callback(instance->view, subbrute_attack_view_enter);
view_set_exit_callback(instance->view, subbrute_attack_view_exit); view_set_exit_callback(instance->view, subbrute_attack_view_exit);
return instance; return instance;
} }
@ -198,7 +220,7 @@ View* subbrute_attack_view_get_view(SubBruteAttackView* instance) {
void subbrute_attack_view_set_current_step(SubBruteAttackView* instance, uint64_t current_step) { void subbrute_attack_view_set_current_step(SubBruteAttackView* instance, uint64_t current_step) {
furi_assert(instance); furi_assert(instance);
#ifdef FURI_DEBUG #ifdef FURI_DEBUG
FURI_LOG_D(TAG, "Set step: %d", current_step); //FURI_LOG_D(TAG, "Set step: %d", current_step);
#endif #endif
with_view_model( with_view_model(
instance->view, (SubBruteAttackViewModel * model) { instance->view, (SubBruteAttackViewModel * model) {
@ -207,17 +229,13 @@ void subbrute_attack_view_set_current_step(SubBruteAttackView* instance, uint64_
}); });
} }
uint64_t subbrute_attack_view_get_current_step(SubBruteAttackView* instance) { void subbrute_attack_view_set_worker_type(SubBruteAttackView* instance, bool is_continuous_worker) {
uint64_t current_step; furi_assert(instance);
with_view_model( with_view_model(
instance->view, (SubBruteAttackViewModel * model) { instance->view, (SubBruteAttackViewModel * model) {
current_step = model->current_step; model->is_continuous_worker = is_continuous_worker;
return false; return true;
}); });
#ifdef FURI_DEBUG
FURI_LOG_D(TAG, "Get step: %d", current_step);
#endif
return current_step;
} }
// We need to call init every time, because not every time we calls enter // We need to call init every time, because not every time we calls enter
@ -356,6 +374,9 @@ void subbrute_attack_view_draw(Canvas* canvas, void* context) {
elements_button_top_left(canvas, "Save"); elements_button_top_left(canvas, "Save");
elements_button_top_right(canvas, "Resend"); elements_button_top_right(canvas, "Resend");
} else { } else {
if (model->is_continuous_worker) {
canvas_invert_color(canvas);
}
// canvas_draw_icon_animation // canvas_draw_icon_animation
const uint8_t icon_h_offset = 0; const uint8_t icon_h_offset = 0;
const uint8_t icon_width_with_offset = model->icon->icon->width + icon_h_offset; const uint8_t icon_width_with_offset = model->icon->icon->width + icon_h_offset;
@ -370,5 +391,8 @@ void subbrute_attack_view_draw(Canvas* canvas, void* context) {
elements_progress_bar(canvas, 8, 37, 110, progress_value > 1 ? 1 : progress_value); elements_progress_bar(canvas, 8, 37, 110, progress_value > 1 ? 1 : progress_value);
elements_button_center(canvas, "Stop"); elements_button_center(canvas, "Stop");
if (model->is_continuous_worker) {
canvas_invert_color(canvas);
}
} }
} }

2
applications/plugins/subbrute/views/subbrute_attack_view.h
View file

@ -19,7 +19,7 @@ SubBruteAttackView* subbrute_attack_view_alloc();
void subbrute_attack_view_free(SubBruteAttackView* instance); void subbrute_attack_view_free(SubBruteAttackView* instance);
View* subbrute_attack_view_get_view(SubBruteAttackView* instance); View* subbrute_attack_view_get_view(SubBruteAttackView* instance);
void subbrute_attack_view_set_current_step(SubBruteAttackView* instance, uint64_t current_step); void subbrute_attack_view_set_current_step(SubBruteAttackView* instance, uint64_t current_step);
uint64_t subbrute_attack_view_get_current_step(SubBruteAttackView* instance); void subbrute_attack_view_set_worker_type(SubBruteAttackView* instance, bool is_continuous_worker);
void subbrute_attack_view_init_values( void subbrute_attack_view_init_values(
SubBruteAttackView* instance, SubBruteAttackView* instance,
uint8_t index, uint8_t index,

8
applications/plugins/subbrute/views/subbrute_main_view.c
View file

@ -127,9 +127,9 @@ void subbrute_main_view_draw(Canvas* canvas, SubBruteMainViewModel* model) {
if(m->index == position) { if(m->index == position) {
canvas_draw_str_aligned( canvas_draw_str_aligned(
canvas, canvas,
64, 4,
9 + (item_position * item_height) + STATUS_BAR_Y_SHIFT, 9 + (item_position * item_height) + STATUS_BAR_Y_SHIFT,
AlignCenter, AlignLeft,
AlignCenter, AlignCenter,
str); str);
elements_frame( elements_frame(
@ -137,9 +137,9 @@ void subbrute_main_view_draw(Canvas* canvas, SubBruteMainViewModel* model) {
} else { } else {
canvas_draw_str_aligned( canvas_draw_str_aligned(
canvas, canvas,
64, 4,
9 + (item_position * item_height) + STATUS_BAR_Y_SHIFT, 9 + (item_position * item_height) + STATUS_BAR_Y_SHIFT,
AlignCenter, AlignLeft,
AlignCenter, AlignCenter,
str); str);
} }