Merge branch 'DigitalSequence_PulseReader' into ISO15693

applications/debug/direct_draw/application.fam

@@ -0,0 +1,10 @@
+App(
+    appid="direct_draw",
+    name="Direct Draw",
+    apptype=FlipperAppType.DEBUG,
+    entry_point="direct_draw_app",
+    requires=["gui", "input"],
+    stack_size=2 * 1024,
+    order=70,
+    fap_category="Debug",
+)

applications/debug/direct_draw/direct_draw.c

@@ -0,0 +1,112 @@
+#include <furi.h>
+#include <gui/gui.h>
+#include <gui/canvas_i.h>
+#include <input/input.h>
+
+#define BUFFER_SIZE (32U)
+
+typedef struct {
+    FuriPubSub* input;
+    FuriPubSubSubscription* input_subscription;
+    Gui* gui;
+    Canvas* canvas;
+    bool stop;
+    uint32_t counter;
+} DirectDraw;
+
+static void gui_input_events_callback(const void* value, void* ctx) {
+    furi_assert(value);
+    furi_assert(ctx);
+
+    DirectDraw* instance = ctx;
+    const InputEvent* event = value;
+
+    if(event->key == InputKeyBack && event->type == InputTypeShort) {
+        instance->stop = true;
+    }
+}
+
+static DirectDraw* direct_draw_alloc() {
+    DirectDraw* instance = malloc(sizeof(DirectDraw));
+
+    instance->input = furi_record_open(RECORD_INPUT_EVENTS);
+    instance->gui = furi_record_open(RECORD_GUI);
+    instance->canvas = gui_direct_draw_acquire(instance->gui);
+
+    instance->input_subscription =
+        furi_pubsub_subscribe(instance->input, gui_input_events_callback, instance);
+
+    return instance;
+}
+
+static void direct_draw_free(DirectDraw* instance) {
+    furi_pubsub_unsubscribe(instance->input, instance->input_subscription);
+
+    instance->canvas = NULL;
+    gui_direct_draw_release(instance->gui);
+    furi_record_close(RECORD_GUI);
+    furi_record_close(RECORD_INPUT_EVENTS);
+}
+
+static void direct_draw_block(Canvas* canvas, uint32_t size, uint32_t counter) {
+    size += 16;
+    uint8_t width = canvas_width(canvas) - size;
+    uint8_t height = canvas_height(canvas) - size;
+
+    uint8_t x = counter % width;
+    if((counter / width) % 2) {
+        x = width - x;
+    }
+
+    uint8_t y = counter % height;
+    if((counter / height) % 2) {
+        y = height - y;
+    }
+
+    canvas_draw_box(canvas, x, y, size, size);
+}
+
+static void direct_draw_run(DirectDraw* instance) {
+    size_t start = DWT->CYCCNT;
+    size_t counter = 0;
+    float fps = 0;
+
+    vTaskPrioritySet(furi_thread_get_current_id(), FuriThreadPriorityIdle);
+
+    do {
+        size_t elapsed = DWT->CYCCNT - start;
+        char buffer[BUFFER_SIZE] = {0};
+
+        if(elapsed >= 64000000) {
+            fps = (float)counter / ((float)elapsed / 64000000.0f);
+
+            start = DWT->CYCCNT;
+            counter = 0;
+        }
+        snprintf(buffer, BUFFER_SIZE, "FPS: %.1f", (double)fps);
+
+        canvas_reset(instance->canvas);
+        canvas_set_color(instance->canvas, ColorXOR);
+        direct_draw_block(instance->canvas, instance->counter % 16, instance->counter);
+        direct_draw_block(instance->canvas, instance->counter * 2 % 16, instance->counter * 2);
+        direct_draw_block(instance->canvas, instance->counter * 3 % 16, instance->counter * 3);
+        direct_draw_block(instance->canvas, instance->counter * 4 % 16, instance->counter * 4);
+        direct_draw_block(instance->canvas, instance->counter * 5 % 16, instance->counter * 5);
+        canvas_draw_str(instance->canvas, 10, 10, buffer);
+        canvas_commit(instance->canvas);
+
+        counter++;
+        instance->counter++;
+        furi_thread_yield();
+    } while(!instance->stop);
+}
+
+int32_t direct_draw_app(void* p) {
+    UNUSED(p);
+
+    DirectDraw* instance = direct_draw_alloc();
+    direct_draw_run(instance);
+    direct_draw_free(instance);
+
+    return 0;
+}

applications/main/lfrfid/scenes/lfrfid_scene_save_type.c

@@ -1,7 +1,6 @@
 #include "../lfrfid_i.h"
 
 typedef struct {
-    FuriString* menu_item_name[LFRFIDProtocolMax];
     uint32_t line_sel;
 } SaveTypeCtx;
 
@@ -16,25 +15,27 @@ void lfrfid_scene_save_type_on_enter(void* context) {
     Submenu* submenu = app->submenu;
 
     SaveTypeCtx* state = malloc(sizeof(SaveTypeCtx));
+    FuriString* protocol_string = furi_string_alloc();
     for(uint8_t i = 0; i < LFRFIDProtocolMax; i++) {
         if(strcmp(
                protocol_dict_get_manufacturer(app->dict, i),
                protocol_dict_get_name(app->dict, i)) != 0) {
-            state->menu_item_name[i] = furi_string_alloc_printf(
+            furi_string_printf(
+                protocol_string,
                 "%s %s",
                 protocol_dict_get_manufacturer(app->dict, i),
                 protocol_dict_get_name(app->dict, i));
         } else {
-            state->menu_item_name[i] =
+            furi_string_printf(protocol_string, "%s", protocol_dict_get_name(app->dict, i));
-                furi_string_alloc_printf("%s", protocol_dict_get_name(app->dict, i));
         }
         submenu_add_item(
             submenu,
-            furi_string_get_cstr(state->menu_item_name[i]),
+            furi_string_get_cstr(protocol_string),
             i,
             lfrfid_scene_save_type_submenu_callback,
             app);
     }
+    furi_string_free(protocol_string);
 
     submenu_set_selected_item(
         submenu, scene_manager_get_scene_state(app->scene_manager, LfRfidSceneSaveType));
@@ -73,13 +74,7 @@ void lfrfid_scene_save_type_on_exit(void* context) {
 
     submenu_reset(app->submenu);
 
-    for(uint8_t i = 0; i < LFRFIDProtocolMax; i++) {
-        furi_string_free(state->menu_item_name[i]);
-    }
-
     uint32_t line_sel = state->line_sel;
-
     free(state);
-
     scene_manager_set_scene_state(app->scene_manager, LfRfidSceneSaveType, line_sel);
 }

applications/main/nfc/scenes/nfc_scene_mf_desfire_app.c

@@ -51,23 +51,18 @@ void nfc_scene_mf_desfire_app_on_enter(void* context) {
             nfc_scene_mf_desfire_app_submenu_callback,
             nfc);
 
-        uint16_t cap = NFC_TEXT_STORE_SIZE;
+        FuriString* label = furi_string_alloc();
-        char* buf = nfc->text_store;
         int idx = SubmenuIndexDynamic;
         for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
-            int size = snprintf(buf, cap, "File %d", file->id);
+            furi_string_printf(label, "File %d", file->id);
-            if(size < 0 || size >= cap) {
-                FURI_LOG_W(
-                    TAG,
-                    "Exceeded NFC_TEXT_STORE_SIZE when preparing file id strings; menu truncated");
-                break;
-            }
-            char* label = buf;
-            cap -= size + 1;
-            buf += size + 1;
             submenu_add_item(
-                nfc->submenu, label, idx++, nfc_scene_mf_desfire_app_submenu_callback, nfc);
+                nfc->submenu,
+                furi_string_get_cstr(label),
+                idx++,
+                nfc_scene_mf_desfire_app_submenu_callback,
+                nfc);
         }
+        furi_string_free(label);
 
         view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
     }

applications/main/nfc/scenes/nfc_scene_mf_desfire_data.c

@@ -33,21 +33,18 @@ void nfc_scene_mf_desfire_data_on_enter(void* context) {
         nfc_scene_mf_desfire_data_submenu_callback,
         nfc);
 
-    uint16_t cap = NFC_TEXT_STORE_SIZE;
+    FuriString* label = furi_string_alloc();
-    char* buf = nfc->text_store;
     int idx = SubmenuIndexDynamic;
     for(MifareDesfireApplication* app = data->app_head; app; app = app->next) {
-        int size = snprintf(buf, cap, "App %02x%02x%02x", app->id[0], app->id[1], app->id[2]);
+        furi_string_printf(label, "App %02x%02x%02x", app->id[0], app->id[1], app->id[2]);
-        if(size < 0 || size >= cap) {
+        submenu_add_item(
-            FURI_LOG_W(
+            submenu,
-                TAG, "Exceeded NFC_TEXT_STORE_SIZE when preparing app id strings; menu truncated");
+            furi_string_get_cstr(label),
-            break;
+            idx++,
-        }
+            nfc_scene_mf_desfire_data_submenu_callback,
-        char* label = buf;
+            nfc);
-        cap -= size + 1;
-        buf += size + 1;
-        submenu_add_item(submenu, label, idx++, nfc_scene_mf_desfire_data_submenu_callback, nfc);
     }
+    furi_string_free(label);
 
     if(state >= MifareDesfireDataStateItem) {
         submenu_set_selected_item(

applications/services/gui/canvas.h

@@ -67,6 +67,18 @@ typedef struct {
 /** Canvas anonymous structure */
 typedef struct Canvas Canvas;
 
+/** Reset canvas drawing tools configuration
+ *
+ * @param      canvas  Canvas instance
+ */
+void canvas_reset(Canvas* canvas);
+
+/** Commit canvas. Send buffer to display
+ *
+ * @param      canvas  Canvas instance
+ */
+void canvas_commit(Canvas* canvas);
+
 /** Get Canvas width
  *
  * @param      canvas  Canvas instance

applications/services/gui/canvas_i.h

@@ -31,18 +31,6 @@ Canvas* canvas_init();
  */
 void canvas_free(Canvas* canvas);
 
-/** Reset canvas drawing tools configuration
- *
- * @param      canvas  Canvas instance
- */
-void canvas_reset(Canvas* canvas);
-
-/** Commit canvas. Send buffer to display
- *
- * @param      canvas  Canvas instance
- */
-void canvas_commit(Canvas* canvas);
-
 /** Get canvas buffer.
  *
  * @param      canvas  Canvas instance

applications/services/gui/gui.c

@@ -20,7 +20,7 @@ ViewPort* gui_view_port_find_enabled(ViewPortArray_t array) {
 
 void gui_update(Gui* gui) {
     furi_assert(gui);
-    furi_thread_flags_set(gui->thread_id, GUI_THREAD_FLAG_DRAW);
+    if(!gui->direct_draw) furi_thread_flags_set(gui->thread_id, GUI_THREAD_FLAG_DRAW);
 }
 
 void gui_input_events_callback(const void* value, void* ctx) {
@@ -34,7 +34,7 @@ void gui_input_events_callback(const void* value, void* ctx) {
 }
 
 // Only Fullscreen supports vertical display for now
-bool gui_redraw_fs(Gui* gui) {
+static bool gui_redraw_fs(Gui* gui) {
     canvas_set_orientation(gui->canvas, CanvasOrientationHorizontal);
     canvas_frame_set(gui->canvas, 0, 0, GUI_DISPLAY_WIDTH, GUI_DISPLAY_HEIGHT);
     ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]);
@@ -192,7 +192,7 @@ static void gui_redraw_status_bar(Gui* gui, bool need_attention) {
     }
 }
 
-bool gui_redraw_window(Gui* gui) {
+static bool gui_redraw_window(Gui* gui) {
     canvas_set_orientation(gui->canvas, CanvasOrientationHorizontal);
     canvas_frame_set(gui->canvas, GUI_WINDOW_X, GUI_WINDOW_Y, GUI_WINDOW_WIDTH, GUI_WINDOW_HEIGHT);
     ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerWindow]);
@@ -203,7 +203,7 @@ bool gui_redraw_window(Gui* gui) {
     return false;
 }
 
-bool gui_redraw_desktop(Gui* gui) {
+static bool gui_redraw_desktop(Gui* gui) {
     canvas_set_orientation(gui->canvas, CanvasOrientationHorizontal);
     canvas_frame_set(gui->canvas, 0, 0, GUI_DISPLAY_WIDTH, GUI_DISPLAY_HEIGHT);
     ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]);
@@ -215,37 +215,44 @@ bool gui_redraw_desktop(Gui* gui) {
     return false;
 }
 
-void gui_redraw(Gui* gui) {
+static void gui_redraw(Gui* gui) {
     furi_assert(gui);
     gui_lock(gui);
 
-    canvas_reset(gui->canvas);
+    do {
+        if(gui->direct_draw) break;
 
-    if(gui->lockdown) {
+        canvas_reset(gui->canvas);
-        gui_redraw_desktop(gui);
+
-        bool need_attention =
+        if(gui->lockdown) {
-            (gui_view_port_find_enabled(gui->layers[GuiLayerWindow]) != 0 ||
+            gui_redraw_desktop(gui);
-             gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]) != 0);
+            bool need_attention =
-        gui_redraw_status_bar(gui, need_attention);
+                (gui_view_port_find_enabled(gui->layers[GuiLayerWindow]) != 0 ||
-    } else {
+                 gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]) != 0);
-        if(!gui_redraw_fs(gui)) {
+            gui_redraw_status_bar(gui, need_attention);
-            if(!gui_redraw_window(gui)) {
+        } else {
-                gui_redraw_desktop(gui);
+            if(!gui_redraw_fs(gui)) {
+                if(!gui_redraw_window(gui)) {
+                    gui_redraw_desktop(gui);
+                }
+                gui_redraw_status_bar(gui, false);
             }
-            gui_redraw_status_bar(gui, false);
         }
-    }
 
-    canvas_commit(gui->canvas);
+        canvas_commit(gui->canvas);
-    for
+        for
-        M_EACH(p, gui->canvas_callback_pair, CanvasCallbackPairArray_t) {
+            M_EACH(p, gui->canvas_callback_pair, CanvasCallbackPairArray_t) {
-            p->callback(
+                p->callback(
-                canvas_get_buffer(gui->canvas), canvas_get_buffer_size(gui->canvas), p->context);
+                    canvas_get_buffer(gui->canvas),
-        }
+                    canvas_get_buffer_size(gui->canvas),
+                    p->context);
+            }
+    } while(false);
+
     gui_unlock(gui);
 }
 
-void gui_input(Gui* gui, InputEvent* input_event) {
+static void gui_input(Gui* gui, InputEvent* input_event) {
     furi_assert(gui);
     furi_assert(input_event);
 
@@ -267,42 +274,48 @@ void gui_input(Gui* gui, InputEvent* input_event) {
 
     gui_lock(gui);
 
-    ViewPort* view_port = NULL;
+    do {
+        if(gui->direct_draw && !gui->ongoing_input_view_port) {
+            break;
+        }
 
-    if(gui->lockdown) {
+        ViewPort* view_port = NULL;
-        view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]);
-    } else {
-        view_port = gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]);
-        if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerWindow]);
-        if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]);
-    }
 
-    if(!(gui->ongoing_input & ~key_bit) && input_event->type == InputTypePress) {
+        if(gui->lockdown) {
-        gui->ongoing_input_view_port = view_port;
+            view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]);
-    }
+        } else {
+            view_port = gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]);
+            if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerWindow]);
+            if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]);
+        }
 
-    if(view_port && view_port == gui->ongoing_input_view_port) {
+        if(!(gui->ongoing_input & ~key_bit) && input_event->type == InputTypePress) {
-        view_port_input(view_port, input_event);
+            gui->ongoing_input_view_port = view_port;
-    } else if(gui->ongoing_input_view_port && input_event->type == InputTypeRelease) {
+        }
-        FURI_LOG_D(
+
-            TAG,
+        if(view_port && view_port == gui->ongoing_input_view_port) {
-            "ViewPort changed while key press %p -> %p. Sending key: %s, type: %s, sequence: %p to previous view port",
+            view_port_input(view_port, input_event);
-            gui->ongoing_input_view_port,
+        } else if(gui->ongoing_input_view_port && input_event->type == InputTypeRelease) {
-            view_port,
+            FURI_LOG_D(
-            input_get_key_name(input_event->key),
+                TAG,
-            input_get_type_name(input_event->type),
+                "ViewPort changed while key press %p -> %p. Sending key: %s, type: %s, sequence: %p to previous view port",
-            (void*)input_event->sequence);
+                gui->ongoing_input_view_port,
-        view_port_input(gui->ongoing_input_view_port, input_event);
+                view_port,
-    } else {
+                input_get_key_name(input_event->key),
-        FURI_LOG_D(
+                input_get_type_name(input_event->type),
-            TAG,
+                (void*)input_event->sequence);
-            "ViewPort changed while key press %p -> %p. Discarding key: %s, type: %s, sequence: %p",
+            view_port_input(gui->ongoing_input_view_port, input_event);
-            gui->ongoing_input_view_port,
+        } else {
-            view_port,
+            FURI_LOG_D(
-            input_get_key_name(input_event->key),
+                TAG,
-            input_get_type_name(input_event->type),
+                "ViewPort changed while key press %p -> %p. Discarding key: %s, type: %s, sequence: %p",
-            (void*)input_event->sequence);
+                gui->ongoing_input_view_port,
-    }
+                view_port,
+                input_get_key_name(input_event->key),
+                input_get_type_name(input_event->type),
+                (void*)input_event->sequence);
+        }
+    } while(false);
 
     gui_unlock(gui);
 }
@@ -471,6 +484,31 @@ void gui_set_lockdown(Gui* gui, bool lockdown) {
     gui_update(gui);
 }
 
+Canvas* gui_direct_draw_acquire(Gui* gui) {
+    furi_assert(gui);
+    gui_lock(gui);
+    gui->direct_draw = true;
+    gui_unlock(gui);
+
+    canvas_reset(gui->canvas);
+    canvas_commit(gui->canvas);
+
+    return gui->canvas;
+}
+
+void gui_direct_draw_release(Gui* gui) {
+    furi_assert(gui);
+
+    canvas_reset(gui->canvas);
+    canvas_commit(gui->canvas);
+
+    gui_lock(gui);
+    gui->direct_draw = false;
+    gui_unlock(gui);
+
+    gui_update(gui);
+}
+
 Gui* gui_alloc() {
     Gui* gui = malloc(sizeof(Gui));
     // Thread ID

applications/services/gui/gui.h

@@ -106,6 +106,28 @@ size_t gui_get_framebuffer_size(Gui* gui);
  */
 void gui_set_lockdown(Gui* gui, bool lockdown);
 
+/** Acquire Direct Draw lock and get Canvas instance
+ *
+ * This method return Canvas instance for use in monopoly mode. Direct draw lock
+ * disables input and draw call dispatch functions in GUI service. No other
+ * applications or services will be able to draw until gui_direct_draw_release
+ * call.
+ *
+ * @param      gui   The graphical user interface
+ *
+ * @return     Canvas instance
+ */
+Canvas* gui_direct_draw_acquire(Gui* gui);
+
+/** Release Direct Draw Lock
+ *
+ * Release Direct Draw Lock, enables Input and Draw call processing. Canvas
+ * acquired in gui_direct_draw_acquire will become invalid after this call.
+ *
+ * @param      gui   Gui instance
+ */
+void gui_direct_draw_release(Gui* gui);
+
 #ifdef __cplusplus
 }
 #endif

applications/services/gui/gui_i.h

@@ -62,6 +62,7 @@ struct Gui {
 
     // Layers and Canvas
     bool lockdown;
+    bool direct_draw;
     ViewPortArray_t layers[GuiLayerMAX];
     Canvas* canvas;
     CanvasCallbackPairArray_t canvas_callback_pair;

applications/services/gui/modules/submenu.c

@@ -9,17 +9,48 @@ struct Submenu {
 };
 
 typedef struct {
-    const char* label;
+    FuriString* label;
     uint32_t index;
     SubmenuItemCallback callback;
     void* callback_context;
 } SubmenuItem;
 
-ARRAY_DEF(SubmenuItemArray, SubmenuItem, M_POD_OPLIST);
+static void SubmenuItem_init(SubmenuItem* item) {
+    item->label = furi_string_alloc();
+    item->index = 0;
+    item->callback = NULL;
+    item->callback_context = NULL;
+}
+
+static void SubmenuItem_init_set(SubmenuItem* item, const SubmenuItem* src) {
+    item->label = furi_string_alloc_set(src->label);
+    item->index = src->index;
+    item->callback = src->callback;
+    item->callback_context = src->callback_context;
+}
+
+static void SubmenuItem_set(SubmenuItem* item, const SubmenuItem* src) {
+    furi_string_set(item->label, src->label);
+    item->index = src->index;
+    item->callback = src->callback;
+    item->callback_context = src->callback_context;
+}
+
+static void SubmenuItem_clear(SubmenuItem* item) {
+    furi_string_free(item->label);
+}
+
+ARRAY_DEF(
+    SubmenuItemArray,
+    SubmenuItem,
+    (INIT(API_2(SubmenuItem_init)),
+     SET(API_6(SubmenuItem_set)),
+     INIT_SET(API_6(SubmenuItem_init_set)),
+     CLEAR(API_2(SubmenuItem_clear))))
 
 typedef struct {
     SubmenuItemArray_t items;
-    const char* header;
+    FuriString* header;
     size_t position;
     size_t window_position;
 } SubmenuModel;
@@ -36,9 +67,9 @@ static void submenu_view_draw_callback(Canvas* canvas, void* _model) {
 
     canvas_clear(canvas);
 
-    if(model->header) {
+    if(!furi_string_empty(model->header)) {
         canvas_set_font(canvas, FontPrimary);
-        canvas_draw_str(canvas, 4, 11, model->header);
+        canvas_draw_str(canvas, 4, 11, furi_string_get_cstr(model->header));
     }
 
     canvas_set_font(canvas, FontSecondary);
@@ -48,8 +79,8 @@ static void submenu_view_draw_callback(Canvas* canvas, void* _model) {
     for(SubmenuItemArray_it(it, model->items); !SubmenuItemArray_end_p(it);
         SubmenuItemArray_next(it)) {
         const size_t item_position = position - model->window_position;
-        const size_t items_on_screen = model->header ? 3 : 4;
+        const size_t items_on_screen = furi_string_empty(model->header) ? 4 : 3;
-        uint8_t y_offset = model->header ? 16 : 0;
+        uint8_t y_offset = furi_string_empty(model->header) ? 0 : 16;
 
         if(item_position < items_on_screen) {
             if(position == model->position) {
@@ -134,7 +165,7 @@ Submenu* submenu_alloc() {
             SubmenuItemArray_init(model->items);
             model->position = 0;
             model->window_position = 0;
-            model->header = NULL;
+            model->header = furi_string_alloc();
         },
         true);
 
@@ -145,7 +176,13 @@ void submenu_free(Submenu* submenu) {
     furi_assert(submenu);
 
     with_view_model(
-        submenu->view, SubmenuModel * model, { SubmenuItemArray_clear(model->items); }, true);
+        submenu->view,
+        SubmenuModel * model,
+        {
+            furi_string_free(model->header);
+            SubmenuItemArray_clear(model->items);
+        },
+        true);
     view_free(submenu->view);
     free(submenu);
 }
@@ -170,7 +207,7 @@ void submenu_add_item(
         SubmenuModel * model,
         {
             item = SubmenuItemArray_push_new(model->items);
-            item->label = label;
+            furi_string_set_str(item->label, label);
             item->index = index;
             item->callback = callback;
             item->callback_context = callback_context;
@@ -188,7 +225,7 @@ void submenu_reset(Submenu* submenu) {
             SubmenuItemArray_reset(model->items);
             model->position = 0;
             model->window_position = 0;
-            model->header = NULL;
+            furi_string_reset(model->header);
         },
         true);
 }
@@ -221,7 +258,7 @@ void submenu_set_selected_item(Submenu* submenu, uint32_t index) {
                 model->window_position -= 1;
             }
 
-            const size_t items_on_screen = model->header ? 3 : 4;
+            const size_t items_on_screen = furi_string_empty(model->header) ? 4 : 3;
 
             if(items_size <= items_on_screen) {
                 model->window_position = 0;
@@ -240,7 +277,7 @@ void submenu_process_up(Submenu* submenu) {
         submenu->view,
         SubmenuModel * model,
         {
-            const size_t items_on_screen = model->header ? 3 : 4;
+            const size_t items_on_screen = furi_string_empty(model->header) ? 4 : 3;
             const size_t items_size = SubmenuItemArray_size(model->items);
 
             if(model->position > 0) {
@@ -263,7 +300,7 @@ void submenu_process_down(Submenu* submenu) {
         submenu->view,
         SubmenuModel * model,
         {
-            const size_t items_on_screen = model->header ? 3 : 4;
+            const size_t items_on_screen = furi_string_empty(model->header) ? 4 : 3;
             const size_t items_size = SubmenuItemArray_size(model->items);
 
             if(model->position < items_size - 1) {
@@ -303,5 +340,14 @@ void submenu_set_header(Submenu* submenu, const char* header) {
     furi_assert(submenu);
 
     with_view_model(
-        submenu->view, SubmenuModel * model, { model->header = header; }, true);
+        submenu->view,
+        SubmenuModel * model,
+        {
+            if(header == NULL) {
+                furi_string_reset(model->header);
+            } else {
+                furi_string_set_str(model->header, header);
+            }
+        },
+        true);
 }

firmware/targets/f7/api_symbols.csv

@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,11.3,,
+Version,+,11.4,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
 Header,+,applications/services/cli/cli_vcp.h,,
@@ -594,6 +594,7 @@ Function,+,byte_input_set_result_callback,void,"ByteInput*, ByteInputCallback, B
 Function,-,bzero,void,"void*, size_t"
 Function,-,calloc,void*,"size_t, size_t"
 Function,+,canvas_clear,void,Canvas*
+Function,+,canvas_commit,void,Canvas*
 Function,+,canvas_current_font_height,uint8_t,Canvas*
 Function,+,canvas_draw_bitmap,void,"Canvas*, uint8_t, uint8_t, uint8_t, uint8_t, const uint8_t*"
 Function,+,canvas_draw_box,void,"Canvas*, uint8_t, uint8_t, uint8_t, uint8_t"
@@ -615,6 +616,7 @@ Function,+,canvas_get_font_params,CanvasFontParameters*,"Canvas*, Font"
 Function,+,canvas_glyph_width,uint8_t,"Canvas*, char"
 Function,+,canvas_height,uint8_t,Canvas*
 Function,+,canvas_invert_color,void,Canvas*
+Function,+,canvas_reset,void,Canvas*
 Function,+,canvas_set_bitmap_mode,void,"Canvas*, _Bool"
 Function,+,canvas_set_color,void,"Canvas*, Color"
 Function,+,canvas_set_font,void,"Canvas*, Font"
@@ -1564,6 +1566,8 @@ Function,-,gmtime,tm*,const time_t*
 Function,-,gmtime_r,tm*,"const time_t*, tm*"
 Function,+,gui_add_framebuffer_callback,void,"Gui*, GuiCanvasCommitCallback, void*"
 Function,+,gui_add_view_port,void,"Gui*, ViewPort*, GuiLayer"
+Function,+,gui_direct_draw_acquire,Canvas*,Gui*
+Function,+,gui_direct_draw_release,void,Gui*
 Function,+,gui_get_framebuffer_size,size_t,Gui*
 Function,+,gui_remove_framebuffer_callback,void,"Gui*, GuiCanvasCommitCallback, void*"
 Function,+,gui_remove_view_port,void,"Gui*, ViewPort*"
@@ -1864,6 +1868,7 @@ Function,+,menu_set_selected_item,void,"Menu*, uint32_t"
 Function,-,mf_classic_auth_attempt,_Bool,"FuriHalNfcTxRxContext*, MfClassicAuthContext*, uint64_t"
 Function,-,mf_classic_auth_init_context,void,"MfClassicAuthContext*, uint8_t"
 Function,-,mf_classic_authenticate,_Bool,"FuriHalNfcTxRxContext*, uint8_t, uint64_t, MfClassicKey"
+Function,-,mf_classic_authenticate_skip_activate,_Bool,"FuriHalNfcTxRxContext*, uint8_t, uint64_t, MfClassicKey, _Bool, uint32_t"
 Function,-,mf_classic_check_card_type,_Bool,"uint8_t, uint8_t, uint8_t"
 Function,-,mf_classic_dict_add_key,_Bool,"MfClassicDict*, uint8_t*"
 Function,-,mf_classic_dict_add_key_str,_Bool,"MfClassicDict*, FuriString*"

lib/digital_signal/digital_signal.c

@@ -342,70 +342,81 @@ void digital_sequence_add(DigitalSequence* sequence, uint8_t signal_index) {
     sequence->sequence[sequence->sequence_used++] = signal_index;
 }
 
-#if defined(DIGITAL_SIGNAL_PORTABLE_CODE)
+bool digital_signal_optimization = true;
 
-static void digital_signal_update_dma(DigitalSignal* signal) {
+static void digital_signal_update_dma_c(DigitalSignal* signal) {
-    LL_DMA_SetMemoryAddress(DMA1, LL_DMA_CHANNEL_1, (uint32_t)signal->internals->gpio_buff);
+    /* if transfer was already active, wait till DMA is done and the last timer ticks are running */
+    while(LL_DMA_GetDataLength(DMA1, LL_DMA_CHANNEL_2)) {
+    }
+
+    LL_DMA_DisableChannel(DMA1, LL_DMA_CHANNEL_2);
     LL_DMA_SetMemoryAddress(DMA1, LL_DMA_CHANNEL_2, (uint32_t)signal->reload_reg_buff);
-    LL_DMA_SetDataLength(DMA1, LL_DMA_CHANNEL_1, 2);
     LL_DMA_SetDataLength(DMA1, LL_DMA_CHANNEL_2, signal->internals->reload_reg_entries);
-
-    LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);
     LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2);
-}
+    LL_DMA_DisableChannel(DMA1, LL_DMA_CHANNEL_1);
-
+    LL_DMA_SetMemoryAddress(DMA1, LL_DMA_CHANNEL_1, (uint32_t)signal->internals->gpio_buff);
-#else
+    LL_DMA_SetDataLength(DMA1, LL_DMA_CHANNEL_1, 2);
-
+    LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);
-static void digital_signal_update_dma(DigitalSignal* signal) {
-    volatile uint32_t dma1_data[] = {
-        /* R6  */ (uint32_t) & (DMA1_Channel1->CCR),
-        /* R7  */ DMA1_Channel1->CCR & ~DMA_CCR_EN,
-        /* R8  */ 2,
-        /* R9  */ (uint32_t) & (signal->internals->gpio->port->BSRR),
-        /* R10 */ (uint32_t)signal->internals->gpio_buff,
-        /* R11 */ DMA1_Channel1->CCR | DMA_CCR_EN};
-
-    volatile uint32_t dma2_data[] = {
-        /* R0 */ (uint32_t) & (DMA1_Channel2->CCR),
-        /* R1 */ DMA1_Channel2->CCR & ~DMA_CCR_EN,
-        /* R2 */ (uint32_t)signal->internals->reload_reg_entries,
-        /* R3 */ (uint32_t) & (TIM2->ARR),
-        /* R4 */ (uint32_t)signal->reload_reg_buff,
-        /* R5 */ DMA1_Channel2->CCR | DMA_CCR_EN};
-
-    /* hurry when setting up next transfer */
-    asm volatile(
-        "\t"
-        "MOV     r6, %[data1]\n\t"
-        "MOV     r7, %[data2]\n\t"
-
-        "PUSH    {r0-r12}\n\t"
-
-        "LDM     r7, {r0-r5}\n\t" /* prepare registers with values to write into DMA config */
-        "LDM     r6, {r6-r11}\n\t"
-
-        "loop:\n\t"
-        "LDR     r12, [r0, #4]\n\t" /* read DMA_CNDTRx to get remaining transfers */
-        "CMP     r12, #0\n\t"
-        "BNE     loop\n\t"
-
-        "STM     r6, {r7-r10}\n\t" /* disable channel and set up new parameters */
-        "STR     r11, [r6, #0]\n\t" /* enable channel again */
-        "STM     r0, {r1-r4}\n\t" /* disable channel and set up new parameters */
-        "STR     r5, [r0, #0]\n\t" /* enable channel again */
-
-        "POP     {r0-r12}\n\t"
-
-        : /* no outputs*/
-        : /* inputs */
-        [data1] "r"(dma1_data), [data2] "r"(dma2_data)
-        : "r6", "r7");
 
     LL_DMA_ClearFlag_TC1(DMA1);
     LL_DMA_ClearFlag_TC2(DMA1);
 }
 
-#endif
+static void digital_signal_update_dma_asm(DigitalSignal* signal) {
+    /* this is an "already-prepared" buffer of all DMA channel configs to write */
+    const volatile uint32_t dma_data[] = {
+        /* DMA channel 2 data */
+        /* R0 */ (uint32_t) & (DMA1_Channel2->CCR), /* base address of DMA channel 2 */
+        /* R1 */ DMA1_Channel2->CCR & ~DMA_CCR_EN, /* CCR value to write first */
+        /* R2 */ (uint32_t)signal->internals->reload_reg_entries, /* CNDTR to write */
+        /* R3 */ (uint32_t) & (TIM2->ARR), /* CPAR to write */
+        /* R4 */ (uint32_t)signal->reload_reg_buff, /* CMAR to write */
+        /* R5 */ DMA1_Channel2->CCR | DMA_CCR_EN, /* and CCR again to write after finished */
+
+        /* DMA channel 1 data */
+        /* R6  */ (uint32_t) & (DMA1_Channel1->CCR), /* base address of DMA channel 1 */
+        /* R7  */ DMA1_Channel1->CCR & ~DMA_CCR_EN, /* CCR value to write first */
+        /* R8  */ 2, /* CNDTR to write */
+        /* R9  */ (uint32_t) & (signal->internals->gpio->port->BSRR), /* CPAR to write */
+        /* R10 */ (uint32_t)signal->internals->gpio_buff, /* CMAR to write */
+        /* R11 */ DMA1_Channel1->CCR | DMA_CCR_EN}; /* and CCR again to write after finished */
+
+    /* now wait for the DMA finishing and instantly reconfigure it with as few instructions as possible */
+    asm volatile(
+        "\t"
+        "PUSH    {r0-r12}\n\t"
+
+        "LDM     %[data], {r0-r11}\n\t" /* prepare registers with values to write into DMA config */
+
+        "wait_for_dma_finished:\n\t"
+        "LDR     r12, [r0, #4]\n\t" /* read DMA_CNDTRx to get remaining transfers */
+        "CMP     r12, #0\n\t"
+        "BNE     wait_for_dma_finished\n\t"
+
+        /* no transfers left, the DMA has finished. now quickly re-enable with new settings.
+           the next 4 instructions are the critical part */
+        "STM     r6, {r7-r10}\n\t" /* disable channel and set up new parameters */
+        "STR     r11, [r6, #0]\n\t" /* enable channel again by writing CCR */
+        "STM     r0, {r1-r4}\n\t" /* disable channel and set up new parameters */
+        "STR     r5, [r0, #0]\n\t" /* enable channel again by writing CCR */
+
+        "POP     {r0-r12}\n\t"
+
+        : /* no outputs*/
+        : /* inputs */
+        [data] "r"(dma_data));
+
+    LL_DMA_ClearFlag_TC1(DMA1);
+    LL_DMA_ClearFlag_TC2(DMA1);
+}
+
+void digital_signal_update_dma(DigitalSignal* signal) {
+    if(digital_signal_optimization) {
+        digital_signal_update_dma_asm(signal);
+    } else {
+        digital_signal_update_dma_c(signal);
+    }
+}
 
 static bool digital_sequence_send_signal(DigitalSequence* sequence, DigitalSignal* signal) {
     furi_assert(sequence);

lib/nfc/nfc_worker.c

@@ -896,13 +896,15 @@ void nfc_worker_mf_classic_dict_attack(NfcWorker* nfc_worker) {
                 nfc_worker->callback(NfcWorkerEventNewDictKeyBatch, nfc_worker->context);
             }
             furi_hal_nfc_sleep();
-            if(furi_hal_nfc_activate_nfca(200, NULL)) {
+            uint32_t cuid;
-                furi_hal_nfc_sleep();
+            if(furi_hal_nfc_activate_nfca(200, &cuid)) {
+                bool deactivated = false;
                 if(!card_found_notified) {
                     nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
                     card_found_notified = true;
                     card_removed_notified = false;
                     nfc_worker_mf_classic_key_attack(nfc_worker, prev_key, &tx_rx, i);
+                    deactivated = true;
                 }
                 FURI_LOG_D(
                     TAG,
@@ -912,22 +914,26 @@ void nfc_worker_mf_classic_dict_attack(NfcWorker* nfc_worker) {
                     (uint32_t)key);
                 if(!is_key_a_found) {
                     is_key_a_found = mf_classic_is_key_found(data, i, MfClassicKeyA);
-                    if(mf_classic_authenticate(&tx_rx, block_num, key, MfClassicKeyA)) {
+                    if(mf_classic_authenticate_skip_activate(
+                           &tx_rx, block_num, key, MfClassicKeyA, !deactivated, cuid)) {
                         mf_classic_set_key_found(data, i, MfClassicKeyA, key);
                         FURI_LOG_D(TAG, "Key found");
                         nfc_worker->callback(NfcWorkerEventFoundKeyA, nfc_worker->context);
                         nfc_worker_mf_classic_key_attack(nfc_worker, key, &tx_rx, i + 1);
                     }
                     furi_hal_nfc_sleep();
+                    deactivated = true;
                 }
                 if(!is_key_b_found) {
                     is_key_b_found = mf_classic_is_key_found(data, i, MfClassicKeyB);
-                    if(mf_classic_authenticate(&tx_rx, block_num, key, MfClassicKeyB)) {
+                    if(mf_classic_authenticate_skip_activate(
+                           &tx_rx, block_num, key, MfClassicKeyB, !deactivated, cuid)) {
                         FURI_LOG_D(TAG, "Key found");
                         mf_classic_set_key_found(data, i, MfClassicKeyB, key);
                         nfc_worker->callback(NfcWorkerEventFoundKeyB, nfc_worker->context);
                         nfc_worker_mf_classic_key_attack(nfc_worker, key, &tx_rx, i + 1);
                     }
+                    deactivated = true;
                 }
                 if(is_key_a_found && is_key_b_found) break;
                 if(nfc_worker->state != NfcWorkerStateMfClassicDictAttack) break;

lib/nfc/protocols/mifare_classic.c

@@ -403,15 +403,16 @@ static bool mf_classic_auth(
     uint32_t block,
     uint64_t key,
     MfClassicKey key_type,
-    Crypto1* crypto) {
+    Crypto1* crypto,
+    bool skip_activate,
+    uint32_t cuid) {
     bool auth_success = false;
-    uint32_t cuid = 0;
     memset(tx_rx->tx_data, 0, sizeof(tx_rx->tx_data));
     memset(tx_rx->tx_parity, 0, sizeof(tx_rx->tx_parity));
     tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
 
     do {
-        if(!furi_hal_nfc_activate_nfca(200, &cuid)) break;
+        if(!skip_activate && !furi_hal_nfc_activate_nfca(200, &cuid)) break;
         if(key_type == MfClassicKeyA) {
             tx_rx->tx_data[0] = MF_CLASSIC_AUTH_KEY_A_CMD;
         } else {
@@ -460,7 +461,23 @@ bool mf_classic_authenticate(
     furi_assert(tx_rx);
 
     Crypto1 crypto = {};
-    bool key_found = mf_classic_auth(tx_rx, block_num, key, key_type, &crypto);
+    bool key_found = mf_classic_auth(tx_rx, block_num, key, key_type, &crypto, false, 0);
+    furi_hal_nfc_sleep();
+    return key_found;
+}
+
+bool mf_classic_authenticate_skip_activate(
+    FuriHalNfcTxRxContext* tx_rx,
+    uint8_t block_num,
+    uint64_t key,
+    MfClassicKey key_type,
+    bool skip_activate,
+    uint32_t cuid) {
+    furi_assert(tx_rx);
+
+    Crypto1 crypto = {};
+    bool key_found =
+        mf_classic_auth(tx_rx, block_num, key, key_type, &crypto, skip_activate, cuid);
     furi_hal_nfc_sleep();
     return key_found;
 }
@@ -483,7 +500,9 @@ bool mf_classic_auth_attempt(
                mf_classic_get_first_block_num_of_sector(auth_ctx->sector),
                key,
                MfClassicKeyA,
-               &crypto)) {
+               &crypto,
+               false,
+               0)) {
             auth_ctx->key_a = key;
             found_key = true;
         }
@@ -500,7 +519,9 @@ bool mf_classic_auth_attempt(
                mf_classic_get_first_block_num_of_sector(auth_ctx->sector),
                key,
                MfClassicKeyB,
-               &crypto)) {
+               &crypto,
+               false,
+               0)) {
             auth_ctx->key_b = key;
             found_key = true;
         }
@@ -568,7 +589,7 @@ void mf_classic_read_sector(FuriHalNfcTxRxContext* tx_rx, MfClassicData* data, u
         if(!key_a_found) break;
         FURI_LOG_D(TAG, "Try to read blocks with key A");
         key = nfc_util_bytes2num(sec_tr->key_a, sizeof(sec_tr->key_a));
-        if(!mf_classic_auth(tx_rx, start_block, key, MfClassicKeyA, &crypto)) break;
+        if(!mf_classic_auth(tx_rx, start_block, key, MfClassicKeyA, &crypto, false, 0)) break;
         for(size_t i = start_block; i < start_block + total_blocks; i++) {
             if(!mf_classic_is_block_read(data, i)) {
                 if(mf_classic_read_block(tx_rx, &crypto, i, &block_tmp)) {
@@ -587,7 +608,7 @@ void mf_classic_read_sector(FuriHalNfcTxRxContext* tx_rx, MfClassicData* data, u
         FURI_LOG_D(TAG, "Try to read blocks with key B");
         key = nfc_util_bytes2num(sec_tr->key_b, sizeof(sec_tr->key_b));
         furi_hal_nfc_sleep();
-        if(!mf_classic_auth(tx_rx, start_block, key, MfClassicKeyB, &crypto)) break;
+        if(!mf_classic_auth(tx_rx, start_block, key, MfClassicKeyB, &crypto, false, 0)) break;
         for(size_t i = start_block; i < start_block + total_blocks; i++) {
             if(!mf_classic_is_block_read(data, i)) {
                 if(mf_classic_read_block(tx_rx, &crypto, i, &block_tmp)) {
@@ -631,7 +652,7 @@ static bool mf_classic_read_sector_with_reader(
         }
 
         // Auth to first block in sector
-        if(!mf_classic_auth(tx_rx, first_block, key, key_type, crypto)) {
+        if(!mf_classic_auth(tx_rx, first_block, key, key_type, crypto, false, 0)) {
             // Set key to MF_CLASSIC_NO_KEY to prevent further attempts
             if(key_type == MfClassicKeyA) {
                 sector_reader->key_a = MF_CLASSIC_NO_KEY;
@@ -961,7 +982,7 @@ bool mf_classic_write_block(
 
     do {
         furi_hal_nfc_sleep();
-        if(!mf_classic_auth(tx_rx, block_num, key, key_type, &crypto)) {
+        if(!mf_classic_auth(tx_rx, block_num, key, key_type, &crypto, false, 0)) {
             FURI_LOG_D(TAG, "Auth fail");
             break;
         }

lib/nfc/protocols/mifare_classic.h

@@ -156,6 +156,14 @@ bool mf_classic_authenticate(
     uint64_t key,
     MfClassicKey key_type);
 
+bool mf_classic_authenticate_skip_activate(
+    FuriHalNfcTxRxContext* tx_rx,
+    uint8_t block_num,
+    uint64_t key,
+    MfClassicKey key_type,
+    bool skip_activate,
+    uint32_t cuid);
+
 bool mf_classic_auth_attempt(
     FuriHalNfcTxRxContext* tx_rx,
     MfClassicAuthContext* auth_ctx,

lib/subghz/protocols/came.c

@@ -119,7 +119,9 @@ static bool subghz_protocol_encoder_came_get_upload(SubGhzProtocolEncoderCame* i
     //Send header
     instance->encoder.upload[index++] = level_duration_make(
         false,
-        ((instance->generic.data_count_bit == CAME_24_COUNT_BIT) ?
+        (((instance->generic.data_count_bit == CAME_24_COUNT_BIT) ||
+          (instance->generic.data_count_bit ==
+           subghz_protocol_came_const.min_count_bit_for_found)) ?
              (uint32_t)subghz_protocol_came_const.te_short * 76 :
              (uint32_t)subghz_protocol_came_const.te_short * 39));
     //Send start bit