Improved extra settings

helpers/subbrute_worker.c

@@ -453,18 +453,38 @@ uint8_t subbrute_worker_get_timeout(SubBruteWorker* instance) {
     return instance->tx_timeout_ms;
 }
 
-void subbrute_worker_timeout_inc(SubBruteWorker* instance) {
-    if(instance->tx_timeout_ms < 255) {
-        instance->tx_timeout_ms++;
-    }
+void subbrute_worker_set_timeout(SubBruteWorker* instance, uint8_t timeout) {
+    instance->tx_timeout_ms = timeout;
 }
 
-void subbrute_worker_timeout_dec(SubBruteWorker* instance) {
-    if(instance->tx_timeout_ms > 0) {
-        instance->tx_timeout_ms--;
-    }
+uint8_t subbrute_worker_get_repeats(SubBruteWorker* instance) {
+    return instance->repeat;
 }
 
+void subbrute_worker_set_repeats(SubBruteWorker* instance, uint8_t repeats) {
+    instance->repeat = repeats;
+}
+
+uint32_t subbrute_worker_get_te(SubBruteWorker* instance) {
+    return instance->te;
+}
+
+void subbrute_worker_set_te(SubBruteWorker* instance, uint32_t te) {
+    instance->te = te;
+}
+
+// void subbrute_worker_timeout_inc(SubBruteWorker* instance) {
+//     if(instance->tx_timeout_ms < 255) {
+//         instance->tx_timeout_ms++;
+//     }
+// }
+
+// void subbrute_worker_timeout_dec(SubBruteWorker* instance) {
+//     if(instance->tx_timeout_ms > 0) {
+//         instance->tx_timeout_ms--;
+//     }
+// }
+
 bool subbrute_worker_is_tx_allowed(SubBruteWorker* instance, uint32_t value) {
     furi_assert(instance);
     bool res = false;

helpers/subbrute_worker.h

@@ -43,9 +43,14 @@ void subbrute_worker_set_callback(
     void* context);
 
 uint8_t subbrute_worker_get_timeout(SubBruteWorker* instance);
+void subbrute_worker_set_timeout(SubBruteWorker* instance, uint8_t timeout);
+uint8_t subbrute_worker_get_repeats(SubBruteWorker* instance);
+void subbrute_worker_set_repeats(SubBruteWorker* instance, uint8_t repeats);
+uint32_t subbrute_worker_get_te(SubBruteWorker* instance);
+void subbrute_worker_set_te(SubBruteWorker* instance, uint32_t te);
 
-void subbrute_worker_timeout_inc(SubBruteWorker* instance);
+// void subbrute_worker_timeout_inc(SubBruteWorker* instance);
 
-void subbrute_worker_timeout_dec(SubBruteWorker* instance);
+// void subbrute_worker_timeout_dec(SubBruteWorker* instance);
 
 bool subbrute_worker_is_tx_allowed(SubBruteWorker* instance, uint32_t value);

scenes/subbrute_scene_setup_attack.c

@@ -46,7 +46,7 @@ void subbrute_scene_setup_attack_on_enter(void* context) {
         instance->device->max_value,
         instance->device->current_step,
         false,
-        instance->device->extra_repeats);
+        subbrute_worker_get_repeats(instance->worker));
 
     instance->current_view = SubBruteViewAttack;
     subbrute_attack_view_set_callback(view, subbrute_scene_setup_attack_callback, instance);

scenes/subbrute_scene_setup_extra.c

@@ -3,43 +3,260 @@
 
 #define TAG "SubBruteSceneLoadFile"
 
-void setup_extra_widget_callback(GuiButtonType result, InputType type, void* context);
+#define MIN_TD 0
+#define MAX_TD 255
+#define MIN_REP 1
+#define MAX_REP 100
+#define MIN_TE 100
+#define MAX_TE 600
 
-static void setup_extra_widget_draw(void* context) {
-    furi_assert(context);
-    SubBruteState* instance = context;
+enum SubBruteVarListIndex {
+    SubBruteVarListIndexTimeDelay,
+    SubBruteVarListIndexRepeat_or_OnExtra,
+    SubBruteVarListIndexTe,
+};
+
+static void setup_extra_enter_callback(void* context, uint32_t index);
+
+static void setup_extra_td_callback(VariableItem* item) {
+    furi_assert(item);
+    SubBruteState* instance = variable_item_get_context(item);
+    furi_assert(instance);
+    char buf[6];
+
+    const uint8_t index = variable_item_get_current_value_index(item);
+    uint8_t val = subbrute_worker_get_timeout(instance->worker);
+
+    if(index == 0) {
+        if(val > MIN_TD) {
+            val--;
+            subbrute_worker_set_timeout(instance->worker, val);
+            snprintf(&buf[0], 5, "%d", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MIN_TD) {
+                variable_item_set_current_value_index(item, 0);
+            }
+        }
+    } else if(index == 2) {
+        if(val < MAX_TD) {
+            val++;
+            subbrute_worker_set_timeout(instance->worker, val);
+            snprintf(&buf[0], 5, "%d", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MAX_TD) {
+                variable_item_set_current_value_index(item, 2);
+            }
+        }
+    } else if(index == 1) {
+        if(val == MIN_TD) {
+            val++;
+            subbrute_worker_set_timeout(instance->worker, val);
+            snprintf(&buf[0], 5, "%d", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MAX_TD) {
+                variable_item_set_current_value_index(item, 2);
+            }
+        } else if(val == MAX_TD) {
+            val--;
+            subbrute_worker_set_timeout(instance->worker, val);
+            snprintf(&buf[0], 5, "%d", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MIN_TD) {
+                variable_item_set_current_value_index(item, 0);
+            }
+        }
+    }
+}
+
+static void setup_extra_rep_callback(VariableItem* item) {
+    furi_assert(item);
+    SubBruteState* instance = variable_item_get_context(item);
+    furi_assert(instance);
+    char buf[6];
+
+    const uint8_t index = variable_item_get_current_value_index(item);
+    uint8_t val = subbrute_worker_get_repeats(instance->worker);
+
+    if(index == 0) {
+        if(val > MIN_REP) {
+            val--;
+            subbrute_worker_set_repeats(instance->worker, val);
+            snprintf(&buf[0], 5, "%d", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MIN_REP) {
+                variable_item_set_current_value_index(item, 0);
+            }
+        }
+    } else if(index == 2) {
+        if(val < MAX_REP) {
+            val++;
+            subbrute_worker_set_repeats(instance->worker, val);
+            snprintf(&buf[0], 5, "%d", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MAX_REP) {
+                variable_item_set_current_value_index(item, 2);
+            }
+        }
+    } else if(index == 1) {
+        if(val == MIN_REP) {
+            val++;
+            subbrute_worker_set_repeats(instance->worker, val);
+            snprintf(&buf[0], 5, "%d", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MAX_REP) {
+                variable_item_set_current_value_index(item, 2);
+            }
+        } else if(val == MAX_REP) {
+            val--;
+            subbrute_worker_set_repeats(instance->worker, val);
+            snprintf(&buf[0], 5, "%d", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MIN_REP) {
+                variable_item_set_current_value_index(item, 0);
+            }
+        }
+    }
+}
 
-    Widget* widget = instance->widget;
+static void setup_extra_te_callback(VariableItem* item) {
+    furi_assert(item);
+    SubBruteState* instance = variable_item_get_context(item);
+    furi_assert(instance);
+    char buf[6];
 
-    widget_add_button_element(
-        widget, GuiButtonTypeLeft, "-TD", setup_extra_widget_callback, instance);
-    widget_add_button_element(
-        widget, GuiButtonTypeRight, "TD+", setup_extra_widget_callback, instance);
+    const uint8_t index = variable_item_get_current_value_index(item);
+    uint32_t val = subbrute_worker_get_te(instance->worker);
 
-    char str[20];
-    snprintf(&str[0], 20, "%d", subbrute_worker_get_timeout(instance->worker));
+    if(index == 0) {
+        if(val > MIN_TE) {
+            val--;
+            subbrute_worker_set_te(instance->worker, val);
+            snprintf(&buf[0], 5, "%ld", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MIN_TE) {
+                variable_item_set_current_value_index(item, 0);
+            }
+        }
+    } else if(index == 2) {
+        if(val < MAX_TE) {
+            val++;
+            subbrute_worker_set_te(instance->worker, val);
+            snprintf(&buf[0], 5, "%ld", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MAX_TE) {
+                variable_item_set_current_value_index(item, 2);
+            }
+        }
+    } else if(index == 1) {
+        if(val == MIN_TE) {
+            val++;
+            subbrute_worker_set_te(instance->worker, val);
+            snprintf(&buf[0], 5, "%ld", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MAX_TE) {
+                variable_item_set_current_value_index(item, 2);
+            }
+        } else if(val == MAX_TE) {
+            val--;
+            subbrute_worker_set_te(instance->worker, val);
+            snprintf(&buf[0], 5, "%ld", val);
+            variable_item_set_current_value_text(item, &buf[0]);
+            variable_item_set_current_value_index(item, 1);
+            if(val == MIN_TE) {
+                variable_item_set_current_value_index(item, 0);
+            }
+        }
+    }
+}
+
+static void subbrute_scene_setup_extra_init_var_list(SubBruteState* instance, bool on_extra) {
+    furi_assert(instance);
+    char str[6];
+    VariableItem* item;
+    static bool extra = false;
+    if(on_extra) {
+        extra = true;
+    }
 
-    widget_add_string_element(
-        instance->widget, 64, 15, AlignCenter, AlignCenter, FontPrimary, "Time Delay");
+    VariableItemList* var_list = instance->var_list;
 
-    widget_add_string_element(
-        instance->widget, 64, 32, AlignCenter, AlignCenter, FontBigNumbers, &str[0]);
+    variable_item_list_reset(var_list);
+
+    item = variable_item_list_add(var_list, "TimeDelay", 3, setup_extra_td_callback, instance);
+    snprintf(&str[0], 5, "%d", subbrute_worker_get_timeout(instance->worker));
+    variable_item_set_current_value_text(item, &str[0]);
+    switch(subbrute_worker_get_timeout(instance->worker)) {
+    case MIN_TD:
+        variable_item_set_current_value_index(item, 0);
+        break;
+    case MAX_TD:
+        variable_item_set_current_value_index(item, 2);
+        break;
+
+    default:
+        variable_item_set_current_value_index(item, 1);
+        break;
+    }
+
+    if(extra) {
+        item = variable_item_list_add(var_list, "Repeats", 3, setup_extra_rep_callback, instance);
+        snprintf(&str[0], 5, "%d", subbrute_worker_get_repeats(instance->worker));
+        variable_item_set_current_value_text(item, &str[0]);
+        switch(subbrute_worker_get_repeats(instance->worker)) {
+        case MIN_REP:
+            variable_item_set_current_value_index(item, 0);
+            break;
+        case MAX_REP:
+            variable_item_set_current_value_index(item, 2);
+            break;
+
+        default:
+            variable_item_set_current_value_index(item, 1);
+            break;
+        }
+        const uint32_t te = subbrute_worker_get_te(instance->worker);
+        if(te != 0) {
+            item = variable_item_list_add(var_list, "Te", 3, setup_extra_te_callback, instance);
+            snprintf(&str[0], 5, "%ld", te);
+            variable_item_set_current_value_text(item, &str[0]);
+            switch(te) {
+            case MIN_TE:
+                variable_item_set_current_value_index(item, 0);
+                break;
+            case MAX_TE:
+                variable_item_set_current_value_index(item, 2);
+                break;
+
+            default:
+                variable_item_set_current_value_index(item, 1);
+                break;
+            }
+        }
+    } else {
+        item = variable_item_list_add(var_list, "Show Extra", 0, NULL, NULL);
+    }
+
+    variable_item_list_set_enter_callback(var_list, setup_extra_enter_callback, instance);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, SubBruteViewVarList);
 }
 
-void setup_extra_widget_callback(GuiButtonType result, InputType type, void* context) {
+static void setup_extra_enter_callback(void* context, uint32_t index) {
     furi_assert(context);
     SubBruteState* instance = context;
 
-    if((result == GuiButtonTypeLeft) && ((type == InputTypeShort) || (type == InputTypeRepeat))) {
-        widget_reset(instance->widget);
-        subbrute_worker_timeout_dec(instance->worker);
-        setup_extra_widget_draw(instance);
-    } else if(
-        (result == GuiButtonTypeRight) &&
-        ((type == InputTypeShort) || (type == InputTypeRepeat))) {
-        widget_reset(instance->widget);
-        subbrute_worker_timeout_inc(instance->worker);
-        setup_extra_widget_draw(instance);
+    if(index == SubBruteVarListIndexRepeat_or_OnExtra) {
+        subbrute_scene_setup_extra_init_var_list(instance, true);
     }
 }
 
@@ -47,16 +264,14 @@ void subbrute_scene_setup_extra_on_enter(void* context) {
     furi_assert(context);
     SubBruteState* instance = context;
 
-    setup_extra_widget_draw(instance);
-
-    view_dispatcher_switch_to_view(instance->view_dispatcher, SubBruteViewWidget);
+    subbrute_scene_setup_extra_init_var_list(instance, false);
 }
 
 void subbrute_scene_setup_extra_on_exit(void* context) {
     furi_assert(context);
     SubBruteState* instance = context;
 
-    widget_reset(instance->widget);
+    variable_item_list_reset(instance->var_list);
 }
 
 bool subbrute_scene_setup_extra_on_event(void* context, SceneManagerEvent event) {

subbrute.c

@@ -75,6 +75,13 @@ SubBruteState* subbrute_alloc() {
     view_dispatcher_add_view(
         instance->view_dispatcher, SubBruteViewWidget, widget_get_view(instance->widget));
 
+    // VarList
+    instance->var_list = variable_item_list_alloc();
+    view_dispatcher_add_view(
+        instance->view_dispatcher,
+        SubBruteViewVarList,
+        variable_item_list_get_view(instance->var_list));
+
     // Popup
     instance->popup = popup_alloc();
     view_dispatcher_add_view(
@@ -144,6 +151,10 @@ void subbrute_free(SubBruteState* instance) {
     view_dispatcher_remove_view(instance->view_dispatcher, SubBruteViewWidget);
     widget_free(instance->widget);
 
+    // VarList
+    view_dispatcher_remove_view(instance->view_dispatcher, SubBruteViewVarList);
+    variable_item_list_free(instance->var_list);
+
     // Popup
     view_dispatcher_remove_view(instance->view_dispatcher, SubBruteViewPopup);
     popup_free(instance->popup);

subbrute_i.h

@@ -15,6 +15,7 @@
 #include <gui/modules/popup.h>
 #include <gui/modules/widget.h>
 #include <gui/modules/loading.h>
+#include <gui/modules/variable_item_list.h>
 
 #include "subghz_bruteforcer_icons.h"
 
@@ -44,6 +45,7 @@ typedef enum {
     SubBruteViewPopup,
     SubBruteViewWidget,
     SubBruteViewStack,
+    SubBruteViewVarList,
 } SubBruteView;
 
 struct SubBruteState {
@@ -55,6 +57,7 @@ struct SubBruteState {
     TextInput* text_input;
     Popup* popup;
     Widget* widget;
+    VariableItemList* var_list;
     DialogsApp* dialogs;
     const SubGhzDevice* radio_device;
 

views/subbrute_attack_view.c

@@ -19,7 +19,7 @@ struct SubBruteAttackView {
     uint64_t max_value;
     uint64_t current_step;
     bool is_attacking;
-    uint8_t extra_repeats;
+    // uint8_t extra_repeats;
 };
 
 typedef struct {
@@ -226,7 +226,7 @@ void subbrute_attack_view_init_values(
     instance->max_value = max_value;
     instance->current_step = current_step;
     instance->is_attacking = is_attacking;
-    instance->extra_repeats = extra_repeats;
+    // instance->extra_repeats = extra_repeats;
 
     with_view_model(
         instance->view,
@@ -308,7 +308,7 @@ void subbrute_attack_view_draw(Canvas* canvas, void* context) {
             buffer,
             sizeof(buffer),
             "x%d",
-            model->extra_repeats + subbrute_protocol_repeats_count(model->attack_type));
+            model->extra_repeats); // + subbrute_protocol_repeats_count(model->attack_type));
         canvas_draw_str_aligned(canvas, 60, 6, AlignCenter, AlignCenter, buffer);
 
         elements_button_left(canvas, "-1");
@@ -335,7 +335,7 @@ void subbrute_attack_view_draw(Canvas* canvas, void* context) {
             buffer,
             sizeof(buffer),
             "x%d",
-            model->extra_repeats + subbrute_protocol_repeats_count(model->attack_type));
+            model->extra_repeats); // + subbrute_protocol_repeats_count(model->attack_type));
         canvas_draw_str(canvas, 4, y - 8, buffer);
         canvas_draw_str(canvas, 4, y - 1, "repeats");