Merge branch 'dev-master' into subbrute-rev3

applications/plugins/arkanoid/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="arkanoid_game",
+    appid="Arkanoid",
     name="Arkanoid",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="arkanoid_game_app",

applications/plugins/barcode_generator/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="barcode_generator",
+    appid="Barcode_Generator",
     name="UPC-A Generator",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="barcode_UPCA_generator_app",

applications/plugins/bt_hid_app/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="bt_hid",
+    appid="Bluetooth_Remote",
     name="Bluetooth Remote",
     apptype=FlipperAppType.PLUGIN,
     entry_point="bt_hid_app",

applications/plugins/bt_hid_app/views/bt_hid_keyboard.c

@@ -209,6 +209,11 @@ static void bt_hid_keyboard_draw_callback(Canvas* canvas, void* context) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
         canvas_set_font(canvas, FontPrimary);
         elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Keyboard");
+
+        canvas_draw_icon(canvas, 68, 3, &I_Pin_back_arrow_10x8);
+        canvas_set_font(canvas, FontSecondary);
+        elements_multiline_text_aligned(canvas, 127, 4, AlignRight, AlignTop, "Hold to exit");
+
         elements_multiline_text_aligned(
             canvas, 4, 60, AlignLeft, AlignBottom, "Waiting for Connection...");
         return; // Dont render the keyboard if we are not yet connected

applications/plugins/doom/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="game_doom",
+    appid="DOOM",
     name="DOOM",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="doom_app",

applications/plugins/doom/doom_music_player_worker.c

@@ -258,7 +258,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             if(!is_valid) {
                 FURI_LOG_E(
                     TAG,
-                    "Invalid note: %u%c%c%u.%u",
+                    "Invalid note: %lu%c%c%lu.%lu",
                     duration,
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
@@ -281,7 +281,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             if(music_player_worker_add_note(instance, semitone, duration, dots)) {
                 FURI_LOG_D(
                     TAG,
-                    "Added note: %c%c%u.%u = %u %u",
+                    "Added note: %c%c%lu.%lu = %u %lu",
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
                     octave,
@@ -291,7 +291,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             } else {
                 FURI_LOG_E(
                     TAG,
-                    "Invalid note: %c%c%u.%u = %u %u",
+                    "Invalid note: %c%c%lu.%lu = %u %lu",
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
                     octave,
@@ -326,8 +326,8 @@ bool music_player_worker_load_fmf_from_file(MusicPlayerWorker* instance, const c
     furi_assert(file_path);
 
     bool result = false;
-    string_t temp_str;
-    string_init(temp_str);
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
     FlipperFormat* file = flipper_format_file_alloc(storage);
@@ -337,7 +337,8 @@ bool music_player_worker_load_fmf_from_file(MusicPlayerWorker* instance, const c
 
         uint32_t version = 0;
         if(!flipper_format_read_header(file, temp_str, &version)) break;
-        if(string_cmp_str(temp_str, MUSIC_PLAYER_FILETYPE) || (version != MUSIC_PLAYER_VERSION)) {
+        if(furi_string_cmp_str(temp_str, MUSIC_PLAYER_FILETYPE) ||
+           (version != MUSIC_PLAYER_VERSION)) {
             FURI_LOG_E(TAG, "Incorrect file format or version");
             break;
         }
@@ -360,7 +361,7 @@ bool music_player_worker_load_fmf_from_file(MusicPlayerWorker* instance, const c
             break;
         }
 
-        if(!music_player_worker_parse_notes(instance, string_get_cstr(temp_str))) {
+        if(!music_player_worker_parse_notes(instance, furi_string_get_cstr(temp_str))) {
             break;
         }
 
@@ -369,7 +370,7 @@ bool music_player_worker_load_fmf_from_file(MusicPlayerWorker* instance, const c
 
     furi_record_close(RECORD_STORAGE);
     flipper_format_free(file);
-    string_clear(temp_str);
+    furi_string_free(temp_str);
 
     return result;
 }
@@ -379,8 +380,8 @@ bool music_player_worker_load_rtttl_from_file(MusicPlayerWorker* instance, const
     furi_assert(file_path);
 
     bool result = false;
-    string_t content;
-    string_init(content);
+    FuriString* content;
+    content = furi_string_alloc();
     Storage* storage = furi_record_open(RECORD_STORAGE);
     File* file = storage_file_alloc(storage);
 
@@ -395,17 +396,17 @@ bool music_player_worker_load_rtttl_from_file(MusicPlayerWorker* instance, const
             uint8_t buffer[65] = {0};
             ret = storage_file_read(file, buffer, sizeof(buffer) - 1);
             for(size_t i = 0; i < ret; i++) {
-                string_push_back(content, buffer[i]);
+                furi_string_push_back(content, buffer[i]);
             }
         } while(ret > 0);
 
-        string_strim(content);
-        if(!string_size(content)) {
+        furi_string_trim(content);
+        if(!furi_string_size(content)) {
             FURI_LOG_E(TAG, "Empty file");
             break;
         }
 
-        if(!music_player_worker_load_rtttl_from_string(instance, string_get_cstr(content))) {
+        if(!music_player_worker_load_rtttl_from_string(instance, furi_string_get_cstr(content))) {
             FURI_LOG_E(TAG, "Invalid file content");
             break;
         }
@@ -415,7 +416,7 @@ bool music_player_worker_load_rtttl_from_file(MusicPlayerWorker* instance, const
 
     storage_file_free(file);
     furi_record_close(RECORD_STORAGE);
-    string_clear(content);
+    furi_string_free(content);
 
     return result;
 }

applications/plugins/doom/sound.h

@@ -1,6 +1,5 @@
 #ifndef sound_h
 #define sound_h
-#include <m-string.h>
 #include <furi.h>
 #include <furi_hal.h>
 #include <stdint.h>

applications/plugins/esp8266_deauth/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="esp8266_deauth",
+    appid="ESP8266_Deauther",
     name="[ESP8266] Deauther",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="esp8266_deauth_app",

applications/plugins/esp8266_deauth/esp8266_deauth.c

@@ -6,12 +6,11 @@
 #include <gui/canvas_i.h>
 #include <gui/gui.h>
 #include <input/input.h>
-//#include <m-string.h>
 //#include <math.h>
 //#include <notification/notification.h>
 //#include <notification/notification_messages.h>
 //#include <stdlib.h>
-#include <stream_buffer.h>
+
 #include <u8g2.h>
 
 #include "FlipperZeroWiFiDeauthModuleDefines.h"
@@ -66,7 +65,7 @@ typedef struct SWiFiDeauthApp {
     Gui* m_gui;
     FuriThread* m_worker_thread;
     //NotificationApp* m_notification;
-    StreamBufferHandle_t m_rx_stream;
+    FuriStreamBuffer* m_rx_stream;
     SGpioButtons m_GpioButtons;
 
     bool m_wifiDeauthModuleInitialized;
@@ -220,7 +219,6 @@ static void
 
 static void uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
     furi_assert(context);
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 
     SWiFiDeauthApp* app = context;
 
@@ -228,9 +226,8 @@ static void uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
 
     if(ev == UartIrqEventRXNE) {
         DEAUTH_APP_LOG_I("ev == UartIrqEventRXNE");
-        xStreamBufferSendFromISR(app->m_rx_stream, &data, 1, &xHigherPriorityTaskWoken);
+        furi_stream_buffer_send(app->m_rx_stream, &data, 1, 0);
         furi_thread_flags_set(furi_thread_get_id(app->m_worker_thread), WorkerEventRx);
-        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
     }
 }
 
@@ -243,15 +240,15 @@ static int32_t uart_worker(void* context) {
         return 1;
     }
 
-    StreamBufferHandle_t rx_stream = app->m_rx_stream;
+    FuriStreamBuffer* rx_stream = app->m_rx_stream;
 
     release_mutex((ValueMutex*)context, app);
 
 #if ENABLE_MODULE_POWER
     bool initialized = false;
 
-    string_t receivedString;
-    string_init(receivedString);
+    FuriString* receivedString;
+    receivedString = furi_string_alloc();
 #endif // ENABLE_MODULE_POWER
 
     while(true) {
@@ -273,14 +270,14 @@ static int32_t uart_worker(void* context) {
                 const uint8_t dataBufferSize = 64;
                 uint8_t dataBuffer[dataBufferSize];
                 dataReceivedLength =
-                    xStreamBufferReceive(rx_stream, dataBuffer, dataBufferSize, 25);
+                    furi_stream_buffer_receive(rx_stream, dataBuffer, dataBufferSize, 25);
                 if(dataReceivedLength > 0) {
 #if ENABLE_MODULE_POWER
                     if(!initialized) {
                         if(!(dataReceivedLength > strlen(MODULE_CONTEXT_INITIALIZATION))) {
                             DEAUTH_APP_LOG_I("[UART] Found possible init candidate");
                             for(uint16_t i = 0; i < dataReceivedLength; i++) {
-                                string_push_back(receivedString, dataBuffer[i]);
+                                furi_string_push_back(receivedString, dataBuffer[i]);
                             }
                         }
                     } else
@@ -297,15 +294,15 @@ static int32_t uart_worker(void* context) {
 
 #if ENABLE_MODULE_POWER
             if(!app->m_wifiDeauthModuleInitialized) {
-                if(string_cmp_str(receivedString, MODULE_CONTEXT_INITIALIZATION) == 0) {
+                if(furi_string_cmp_str(receivedString, MODULE_CONTEXT_INITIALIZATION) == 0) {
                     DEAUTH_APP_LOG_I("[UART] Initialized");
                     initialized = true;
                     app->m_wifiDeauthModuleInitialized = true;
                     app->m_context = ModuleActive;
-                    string_clear(receivedString);
+                    furi_string_free(receivedString);
                 } else {
                     DEAUTH_APP_LOG_I("[UART] Not an initialization command");
-                    string_reset(receivedString);
+                    furi_string_reset(receivedString);
                 }
             }
 #endif // ENABLE_MODULE_POWER
@@ -368,7 +365,7 @@ int32_t esp8266_deauth_app(void* p) {
 
     DEAUTH_APP_LOG_I("Mutex created");
 
-    app->m_rx_stream = xStreamBufferCreate(1 * 1024, 1);
+    app->m_rx_stream = furi_stream_buffer_alloc(1 * 1024, 1);
 
     //app->m_notification = furi_record_open("notification");
 
@@ -519,7 +516,7 @@ int32_t esp8266_deauth_app(void* p) {
 
     furi_message_queue_free(event_queue);
 
-    vStreamBufferDelete(app->m_rx_stream);
+    furi_stream_buffer_free(app->m_rx_stream);
 
     delete_mutex(&app_data_mutex);
 

applications/plugins/flappy_bird/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="game_flappybird",
+    appid="FlappyBird",
     name="Flappy Bird",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="flappy_game_app",

applications/plugins/flipfrid/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="flipfrid",
+    appid="RFID_Fuzzer",
     name="RFID Fuzzer",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="flipfrid_start",

applications/plugins/flipfrid/flipfrid.c

@@ -55,8 +55,10 @@ static void flipfrid_timer_callback(FuriMessageQueue* event_queue) {
 
 FlipFridState* flipfrid_alloc() {
     FlipFridState* flipfrid = malloc(sizeof(FlipFridState));
-    string_init(flipfrid->notification_msg);
-    string_init(flipfrid->attack_name);
+    flipfrid->notification_msg = furi_string_alloc();
+    flipfrid->attack_name = furi_string_alloc();
+    flipfrid->proto_name = furi_string_alloc();
+    flipfrid->data_str = furi_string_alloc();
 
     flipfrid->previous_scene = NoneScene;
     flipfrid->current_scene = SceneEntryPoint;
@@ -95,8 +97,10 @@ void flipfrid_free(FlipFridState* flipfrid) {
     notification_message(flipfrid->notify, &sequence_blink_stop);
 
     // Strings
-    string_clear(flipfrid->notification_msg);
-    string_clear(flipfrid->attack_name);
+    furi_string_free(flipfrid->notification_msg);
+    furi_string_free(flipfrid->attack_name);
+    furi_string_free(flipfrid->proto_name);
+    furi_string_free(flipfrid->data_str);
 
     free(flipfrid->data);
     free(flipfrid->payload);
@@ -120,8 +124,7 @@ int32_t flipfrid_start(void* p) {
         FURI_LOG_E(TAG, "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         furi_record_close(RECORD_NOTIFICATION);
-        furi_record_close(RECORD_DIALOGS);
-        free(flipfrid_state);
+        flipfrid_free(flipfrid_state);
         return 255;
     }
 

applications/plugins/flipfrid/flipfrid.h

@@ -4,7 +4,6 @@
 #include <input/input.h>
 #include <gui/gui.h>
 #include <gui/modules/submenu.h>
-#include <m-string.h>
 #include <dialogs/dialogs.h>
 #include <notification/notification.h>
 #include <notification/notification_messages.h>
@@ -31,6 +30,8 @@ typedef enum {
 typedef enum {
     EM4100,
     HIDProx,
+    PAC,
+    H10301,
 } FlipFridProtos;
 
 typedef enum {
@@ -63,22 +64,24 @@ typedef struct {
     u_int8_t menu_index;
     u_int8_t menu_proto_index;
 
-    string_t data_str;
+    FuriString* data_str;
     uint8_t data[6];
     uint8_t payload[6];
     uint8_t attack_step;
     FlipFridAttacks attack;
     FlipFridProtos proto;
-    string_t attack_name;
-    string_t proto_name;
+    FuriString* attack_name;
+    FuriString* proto_name;
 
     DialogsApp* dialogs;
-    string_t notification_msg;
+    FuriString* notification_msg;
     uint8_t key_index;
     LFRFIDWorker* worker;
     ProtocolDict* dict;
     ProtocolId protocol;
 
+    uint8_t time_between_cards;
+
     // Used for custom dictionnary
     Stream* uids_stream;
 } FlipFridState;

applications/plugins/flipfrid/scene/flipfrid_scene_entrypoint.c

@@ -1,7 +1,7 @@
 #include "flipfrid_scene_entrypoint.h"
 
-string_t menu_items[4];
-string_t menu_proto_items[2];
+FuriString* main_menu_items[4];
+FuriString* main_menu_proto_items[4];
 
 void flipfrid_scene_entrypoint_menu_callback(
     FlipFridState* context,
@@ -11,22 +11,22 @@ void flipfrid_scene_entrypoint_menu_callback(
     case FlipFridAttackDefaultValues:
         context->attack = FlipFridAttackDefaultValues;
         context->current_scene = SceneAttack;
-        string_set_str(context->attack_name, "Default Values");
+        furi_string_set(context->attack_name, "Default Values");
         break;
     case FlipFridAttackBfCustomerId:
         context->attack = FlipFridAttackBfCustomerId;
         context->current_scene = SceneAttack;
-        string_set_str(context->attack_name, "Bad Customer ID");
+        furi_string_set(context->attack_name, "Bad Customer ID");
         break;
     case FlipFridAttackLoadFile:
         context->attack = FlipFridAttackLoadFile;
         context->current_scene = SceneSelectFile;
-        string_set_str(context->attack_name, "Load File");
+        furi_string_set(context->attack_name, "Load File");
         break;
     case FlipFridAttackLoadFileCustomUids:
         context->attack = FlipFridAttackLoadFileCustomUids;
         context->current_scene = SceneLoadCustomUids;
-        string_set_str(context->attack_name, "Load Custom UIDs");
+        furi_string_set(context->attack_name, "Load Custom UIDs");
         break;
     default:
         break;
@@ -35,11 +35,19 @@ void flipfrid_scene_entrypoint_menu_callback(
     switch(proto_index) {
     case EM4100:
         context->proto = EM4100;
-        string_set_str(context->proto_name, "EM4100");
+        furi_string_set(context->proto_name, "EM4100");
         break;
     case HIDProx:
         context->proto = HIDProx;
-        string_set_str(context->proto_name, "HIDProx");
+        furi_string_set(context->proto_name, "HIDProx");
+        break;
+    case PAC:
+        context->proto = PAC;
+        furi_string_set(context->proto_name, "PAC/Stanley");
+        break;
+    case H10301:
+        context->proto = H10301;
+        furi_string_set(context->proto_name, "H10301");
         break;
     default:
         break;
@@ -56,32 +64,34 @@ void flipfrid_scene_entrypoint_on_enter(FlipFridState* context) {
     context->payload[5] = 0x00;
 
     context->menu_index = 0;
-    for(uint32_t i = 0; i < 4; i++) {
-        string_init(menu_items[i]);
-    }
+    /*for(uint32_t i = 0; i < 4; i++) {
+        menu_items[i] = furi_string_alloc();
+    }*/
 
-    string_set(menu_items[0], "Default Values");
-    string_set(menu_items[1], "BF Customer ID");
-    string_set(menu_items[2], "Load File");
-    string_set(menu_items[3], "Load uids from file");
+    main_menu_items[0] = furi_string_alloc_set("Default Values");
+    main_menu_items[1] = furi_string_alloc_set("BF Customer ID");
+    main_menu_items[2] = furi_string_alloc_set("Load File");
+    main_menu_items[3] = furi_string_alloc_set("Load uids from file");
 
     context->menu_proto_index = 0;
-    for(uint32_t i = 0; i < 2; i++) {
-        string_init(menu_proto_items[i]);
-    }
+    /*for(uint32_t i = 0; i < 4; i++) {
+        menu_proto_items[i] = furi_string_alloc();
+    }*/
 
-    string_set(menu_proto_items[0], "EM4100");
-    string_set(menu_proto_items[1], "HIDProx");
+    main_menu_proto_items[0] = furi_string_alloc_set("EM4100");
+    main_menu_proto_items[1] = furi_string_alloc_set("HIDProx");
+    main_menu_proto_items[2] = furi_string_alloc_set("PAC/Stanley");
+    main_menu_proto_items[3] = furi_string_alloc_set("H10301");
 }
 
 void flipfrid_scene_entrypoint_on_exit(FlipFridState* context) {
     UNUSED(context);
     for(uint32_t i = 0; i < 4; i++) {
-        string_clear(menu_items[i]);
+        furi_string_free(main_menu_items[i]);
     }
 
-    for(uint32_t i = 0; i < 2; i++) {
-        string_clear(menu_proto_items[i]);
+    for(uint32_t i = 0; i < 4; i++) {
+        furi_string_free(main_menu_proto_items[i]);
     }
 }
 
@@ -106,11 +116,15 @@ void flipfrid_scene_entrypoint_on_event(FlipFridEvent event, FlipFridState* cont
             case InputKeyLeft:
                 if(context->menu_proto_index > EM4100) {
                     context->menu_proto_index--;
+                } else if(context->menu_proto_index == EM4100) {
+                    context->menu_proto_index = H10301;
                 }
                 break;
             case InputKeyRight:
-                if(context->menu_proto_index < HIDProx) {
+                if(context->menu_proto_index < H10301) {
                     context->menu_proto_index++;
+                } else if(context->menu_proto_index == H10301) {
+                    context->menu_proto_index = EM4100;
                 }
                 break;
             case InputKeyOk:
@@ -129,66 +143,73 @@ void flipfrid_scene_entrypoint_on_draw(Canvas* canvas, FlipFridState* context) {
     canvas_clear(canvas);
     canvas_set_color(canvas, ColorBlack);
 
-    if(context->menu_index > FlipFridAttackDefaultValues) {
-        canvas_set_font(canvas, FontSecondary);
+    if(main_menu_items[context->menu_index] != NULL) {
+        if(context->menu_index > FlipFridAttackDefaultValues) {
+            canvas_set_font(canvas, FontSecondary);
+            canvas_draw_str_aligned(
+                canvas,
+                64,
+                24,
+                AlignCenter,
+                AlignTop,
+                furi_string_get_cstr(main_menu_items[context->menu_index - 1]));
+        }
+
+        canvas_set_font(canvas, FontPrimary);
         canvas_draw_str_aligned(
             canvas,
             64,
-            24,
+            36,
             AlignCenter,
             AlignTop,
-            string_get_cstr(menu_items[context->menu_index - 1]));
-    }
+            furi_string_get_cstr(main_menu_items[context->menu_index]));
 
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(
-        canvas, 64, 36, AlignCenter, AlignTop, string_get_cstr(menu_items[context->menu_index]));
+        if(context->menu_index < FlipFridAttackLoadFileCustomUids) {
+            canvas_set_font(canvas, FontSecondary);
+            canvas_draw_str_aligned(
+                canvas,
+                64,
+                48,
+                AlignCenter,
+                AlignTop,
+                furi_string_get_cstr(main_menu_items[context->menu_index + 1]));
+        }
 
-    if(context->menu_index < FlipFridAttackLoadFileCustomUids) {
-        canvas_set_font(canvas, FontSecondary);
+        if(context->menu_proto_index > EM4100) {
+            canvas_set_font(canvas, FontSecondary);
+            canvas_draw_str_aligned(
+                canvas,
+                64,
+                -12,
+                AlignCenter,
+                AlignTop,
+                furi_string_get_cstr(main_menu_proto_items[context->menu_proto_index - 1]));
+        }
+
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 27, 4, AlignCenter, AlignTop, "<");
+
+        canvas_set_font(canvas, FontPrimary);
         canvas_draw_str_aligned(
             canvas,
             64,
-            48,
+            4,
             AlignCenter,
             AlignTop,
-            string_get_cstr(menu_items[context->menu_index + 1]));
-    }
+            furi_string_get_cstr(main_menu_proto_items[context->menu_proto_index]));
 
-    if(context->menu_proto_index > EM4100) {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(
-            canvas,
-            64,
-            -12,
-            AlignCenter,
-            AlignTop,
-            string_get_cstr(menu_proto_items[context->menu_proto_index - 1]));
-    }
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 101, 4, AlignCenter, AlignTop, ">");
 
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 34, 4, AlignCenter, AlignTop, "<");
-
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(
-        canvas,
-        64,
-        4,
-        AlignCenter,
-        AlignTop,
-        string_get_cstr(menu_proto_items[context->menu_proto_index]));
-
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 94, 4, AlignCenter, AlignTop, ">");
-
-    if(context->menu_proto_index < HIDProx) {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(
-            canvas,
-            64,
-            -12,
-            AlignCenter,
-            AlignTop,
-            string_get_cstr(menu_proto_items[context->menu_proto_index + 1]));
+        if(context->menu_proto_index < H10301) {
+            canvas_set_font(canvas, FontSecondary);
+            canvas_draw_str_aligned(
+                canvas,
+                64,
+                -12,
+                AlignCenter,
+                AlignTop,
+                furi_string_get_cstr(main_menu_proto_items[context->menu_proto_index + 1]));
+        }
     }
 }

applications/plugins/flipfrid/scene/flipfrid_scene_load_custom_uids.c

@@ -21,9 +21,9 @@ bool flipfrid_load_uids(FlipFridState* context, const char* file_path) {
 
 bool flipfrid_load_custom_uids_from_file(FlipFridState* context) {
     // Input events and views are managed by file_select
-    string_t uid_path;
-    string_init(uid_path);
-    string_set_str(uid_path, RFIDFUZZER_APP_PATH_FOLDER);
+    FuriString* uid_path;
+    uid_path = furi_string_alloc();
+    furi_string_set(uid_path, RFIDFUZZER_APP_PATH_FOLDER);
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(&browser_options, LFRFID_UIDS_EXTENSION, &I_125_10px);
@@ -32,10 +32,10 @@ bool flipfrid_load_custom_uids_from_file(FlipFridState* context) {
     bool res = dialog_file_browser_show(context->dialogs, uid_path, uid_path, &browser_options);
 
     if(res) {
-        res = flipfrid_load_uids(context, string_get_cstr(uid_path));
+        res = flipfrid_load_uids(context, furi_string_get_cstr(uid_path));
     }
 
-    string_clear(uid_path);
+    furi_string_free(uid_path);
 
     return res;
 }

applications/plugins/flipfrid/scene/flipfrid_scene_load_file.c

@@ -8,47 +8,61 @@ bool flipfrid_load(FlipFridState* context, const char* file_path) {
     bool result = false;
     Storage* storage = furi_record_open(RECORD_STORAGE);
     FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
-    string_t temp_str;
-    string_init(temp_str);
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
     do {
         if(!flipper_format_file_open_existing(fff_data_file, file_path)) {
             FURI_LOG_E(TAG, "Error open file %s", file_path);
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Error open file");
+            furi_string_reset(context->notification_msg);
+            furi_string_set(context->notification_msg, "Error open file");
             break;
         }
 
         // FileType
         if(!flipper_format_read_string(fff_data_file, "Filetype", temp_str)) {
             FURI_LOG_E(TAG, "Missing or incorrect Filetype");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Missing or incorrect Filetypes");
+            furi_string_reset(context->notification_msg);
+            furi_string_set(context->notification_msg, "Missing or incorrect Filetypes");
             break;
         } else {
-            FURI_LOG_I(TAG, "Filetype: %s", string_get_cstr(temp_str));
+            FURI_LOG_I(TAG, "Filetype: %s", furi_string_get_cstr(temp_str));
         }
 
         // Key type
         if(!flipper_format_read_string(fff_data_file, "Key type", temp_str)) {
             FURI_LOG_E(TAG, "Missing or incorrect Key type");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Missing or incorrect Key type");
+            furi_string_reset(context->notification_msg);
+            furi_string_set(context->notification_msg, "Missing or incorrect Key type");
             break;
         } else {
-            FURI_LOG_I(TAG, "Key type: %s", string_get_cstr(temp_str));
+            FURI_LOG_I(TAG, "Key type: %s", furi_string_get_cstr(temp_str));
 
             if(context->proto == EM4100) {
-                if(strcmp(string_get_cstr(temp_str), "EM4100") != 0) {
+                if(strcmp(furi_string_get_cstr(temp_str), "EM4100") != 0) {
                     FURI_LOG_E(TAG, "Unsupported Key type");
-                    string_reset(context->notification_msg);
-                    string_set_str(context->notification_msg, "Unsupported Key type");
+                    furi_string_reset(context->notification_msg);
+                    furi_string_set(context->notification_msg, "Unsupported Key type");
+                    break;
+                }
+            } else if(context->proto == PAC) {
+                if(strcmp(furi_string_get_cstr(temp_str), "PAC/Stanley") != 0) {
+                    FURI_LOG_E(TAG, "Unsupported Key type");
+                    furi_string_reset(context->notification_msg);
+                    furi_string_set(context->notification_msg, "Unsupported Key type");
+                    break;
+                }
+            } else if(context->proto == H10301) {
+                if(strcmp(furi_string_get_cstr(temp_str), "H10301") != 0) {
+                    FURI_LOG_E(TAG, "Unsupported Key type");
+                    furi_string_reset(context->notification_msg);
+                    furi_string_set(context->notification_msg, "Unsupported Key type");
                     break;
                 }
             } else {
-                if(strcmp(string_get_cstr(temp_str), "HIDProx") != 0) {
+                if(strcmp(furi_string_get_cstr(temp_str), "HIDProx") != 0) {
                     FURI_LOG_E(TAG, "Unsupported Key type");
-                    string_reset(context->notification_msg);
-                    string_set_str(context->notification_msg, "Unsupported Key type");
+                    furi_string_reset(context->notification_msg);
+                    furi_string_set(context->notification_msg, "Unsupported Key type");
                     break;
                 }
             }
@@ -57,24 +71,38 @@ bool flipfrid_load(FlipFridState* context, const char* file_path) {
         // Data
         if(!flipper_format_read_string(fff_data_file, "Data", context->data_str)) {
             FURI_LOG_E(TAG, "Missing or incorrect Data");
-            string_reset(context->notification_msg);
-            string_set_str(context->notification_msg, "Missing or incorrect Key");
+            furi_string_reset(context->notification_msg);
+            furi_string_set(context->notification_msg, "Missing or incorrect Key");
             break;
         } else {
-            FURI_LOG_I(TAG, "Key: %s", string_get_cstr(context->data_str));
+            FURI_LOG_I(TAG, "Key: %s", furi_string_get_cstr(context->data_str));
 
             if(context->proto == EM4100) {
-                if(string_size(context->data_str) != 14) {
+                if(furi_string_size(context->data_str) != 14) {
                     FURI_LOG_E(TAG, "Incorrect Key length");
-                    string_reset(context->notification_msg);
-                    string_set_str(context->notification_msg, "Incorrect Key length");
+                    furi_string_reset(context->notification_msg);
+                    furi_string_set(context->notification_msg, "Incorrect Key length");
+                    break;
+                }
+            } else if(context->proto == PAC) {
+                if(furi_string_size(context->data_str) != 11) {
+                    FURI_LOG_E(TAG, "Incorrect Key length");
+                    furi_string_reset(context->notification_msg);
+                    furi_string_set(context->notification_msg, "Incorrect Key length");
+                    break;
+                }
+            } else if(context->proto == H10301) {
+                if(furi_string_size(context->data_str) != 8) {
+                    FURI_LOG_E(TAG, "Incorrect Key length");
+                    furi_string_reset(context->notification_msg);
+                    furi_string_set(context->notification_msg, "Incorrect Key length");
                     break;
                 }
             } else {
-                if(string_size(context->data_str) != 17) {
+                if(furi_string_size(context->data_str) != 17) {
                     FURI_LOG_E(TAG, "Incorrect Key length");
-                    string_reset(context->notification_msg);
-                    string_set_str(context->notification_msg, "Incorrect Key length");
+                    furi_string_reset(context->notification_msg);
+                    furi_string_set(context->notification_msg, "Incorrect Key length");
                     break;
                 }
             }
@@ -82,8 +110,8 @@ bool flipfrid_load(FlipFridState* context, const char* file_path) {
             // String to uint8_t
             for(uint8_t i = 0; i < 6; i++) {
                 char temp_str2[3];
-                temp_str2[0] = string_get_cstr(context->data_str)[i * 3];
-                temp_str2[1] = string_get_cstr(context->data_str)[i * 3 + 1];
+                temp_str2[0] = furi_string_get_cstr(context->data_str)[i * 3];
+                temp_str2[1] = furi_string_get_cstr(context->data_str)[i * 3 + 1];
                 temp_str2[2] = '\0';
                 context->data[i] = (uint8_t)strtol(temp_str2, NULL, 16);
             }
@@ -91,12 +119,12 @@ bool flipfrid_load(FlipFridState* context, const char* file_path) {
 
         result = true;
     } while(0);
-    string_clear(temp_str);
+    furi_string_free(temp_str);
     flipper_format_free(fff_data_file);
     if(result) {
         FURI_LOG_I(TAG, "Loaded successfully");
-        string_reset(context->notification_msg);
-        string_set_str(context->notification_msg, "Source loaded.");
+        furi_string_reset(context->notification_msg);
+        furi_string_set(context->notification_msg, "Source loaded.");
     }
     return result;
 }
@@ -141,9 +169,9 @@ void flipfrid_scene_load_file_on_draw(Canvas* canvas, FlipFridState* context) {
 }
 
 bool flipfrid_load_protocol_from_file(FlipFridState* context) {
-    string_t user_file_path;
-    string_init(user_file_path);
-    string_set_str(user_file_path, LFRFID_APP_PATH_FOLDER);
+    FuriString* user_file_path;
+    user_file_path = furi_string_alloc();
+    furi_string_set(user_file_path, LFRFID_APP_PATH_FOLDER);
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(&browser_options, LFRFID_APP_EXTENSION, &I_125_10px);
@@ -153,10 +181,10 @@ bool flipfrid_load_protocol_from_file(FlipFridState* context) {
         context->dialogs, user_file_path, user_file_path, &browser_options);
 
     if(res) {
-        res = flipfrid_load(context, string_get_cstr(user_file_path));
+        res = flipfrid_load(context, furi_string_get_cstr(user_file_path));
     }
 
-    string_clear(user_file_path);
+    furi_string_free(user_file_path);
 
     return res;
 }

applications/plugins/flipfrid/scene/flipfrid_scene_run_attack.c

@@ -2,7 +2,7 @@
 #include <gui/elements.h>
 
 uint8_t counter = 0;
-#define TIME_BETWEEN_CARDS 6
+
 uint8_t id_list[17][5] = {
     {0x00, 0x00, 0x00, 0x00, 0x00}, // Null bytes
     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, // Only FF
@@ -40,12 +40,54 @@ uint8_t id_list_hid[14][6] = {
     {0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA}, // From arha
 };
 
+uint8_t id_list_pac[17][4] = {
+    {0x00, 0x00, 0x00, 0x00}, // Null bytes
+    {0xFF, 0xFF, 0xFF, 0xFF}, // Only FF
+    {0x11, 0x11, 0x11, 0x11}, // Only 11
+    {0x22, 0x22, 0x22, 0x22}, // Only 22
+    {0x33, 0x33, 0x33, 0x33}, // Only 33
+    {0x44, 0x44, 0x44, 0x44}, // Only 44
+    {0x55, 0x55, 0x55, 0x55}, // Only 55
+    {0x66, 0x66, 0x66, 0x66}, // Only 66
+    {0x77, 0x77, 0x77, 0x77}, // Only 77
+    {0x88, 0x88, 0x88, 0x88}, // Only 88
+    {0x99, 0x99, 0x99, 0x99}, // Only 99
+    {0x12, 0x34, 0x56, 0x78}, // Incremental UID
+    {0x9A, 0x78, 0x56, 0x34}, // Decremental UID
+    {0x04, 0xd0, 0x9b, 0x0d}, // From arha
+    {0x34, 0x00, 0x29, 0x3d}, // From arha
+    {0x04, 0xdf, 0x00, 0x00}, // From arha
+    {0xCA, 0xCA, 0xCA, 0xCA}, // From arha
+};
+
+uint8_t id_list_h[14][3] = {
+    {0x00, 0x00, 0x00}, // Null bytes
+    {0xFF, 0xFF, 0xFF}, // Only FF
+    {0x11, 0x11, 0x11}, // Only 11
+    {0x22, 0x22, 0x22}, // Only 22
+    {0x33, 0x33, 0x33}, // Only 33
+    {0x44, 0x44, 0x44}, // Only 44
+    {0x55, 0x55, 0x55}, // Only 55
+    {0x66, 0x66, 0x66}, // Only 66
+    {0x77, 0x77, 0x77}, // Only 77
+    {0x88, 0x88, 0x88}, // Only 88
+    {0x99, 0x99, 0x99}, // Only 99
+    {0x12, 0x34, 0x56}, // Incremental UID
+    {0x56, 0x34, 0x12}, // Decremental UID
+    {0xCA, 0xCA, 0xCA}, // From arha
+};
+
 void flipfrid_scene_run_attack_on_enter(FlipFridState* context) {
+    context->time_between_cards = 10;
     context->attack_step = 0;
     context->dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
     context->worker = lfrfid_worker_alloc(context->dict);
     if(context->proto == HIDProx) {
         context->protocol = protocol_dict_get_protocol_by_name(context->dict, "HIDProx");
+    } else if(context->proto == PAC) {
+        context->protocol = protocol_dict_get_protocol_by_name(context->dict, "PAC/Stanley");
+    } else if(context->proto == H10301) {
+        context->protocol = protocol_dict_get_protocol_by_name(context->dict, "H10301");
     } else {
         context->protocol = protocol_dict_get_protocol_by_name(context->dict, "EM4100");
     }
@@ -79,7 +121,38 @@ void flipfrid_scene_run_attack_on_tick(FlipFridState* context) {
                     context->payload[3] = id_list[context->attack_step][3];
                     context->payload[4] = id_list[context->attack_step][4];
 
-                    if(context->attack_step == 15) {
+                    if(context->attack_step == 16) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                } else if(context->proto == PAC) {
+                    context->payload[0] = id_list_pac[context->attack_step][0];
+                    context->payload[1] = id_list_pac[context->attack_step][1];
+                    context->payload[2] = id_list_pac[context->attack_step][2];
+                    context->payload[3] = id_list_pac[context->attack_step][3];
+
+                    if(context->attack_step == 16) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                } else if(context->proto == H10301) {
+                    context->payload[0] = id_list_h[context->attack_step][0];
+                    context->payload[1] = id_list_h[context->attack_step][1];
+                    context->payload[2] = id_list_h[context->attack_step][2];
+
+                    if(context->attack_step == 13) {
                         context->attack_step = 0;
                         counter = 0;
                         context->is_attacking = false;
@@ -97,7 +170,7 @@ void flipfrid_scene_run_attack_on_tick(FlipFridState* context) {
                     context->payload[4] = id_list_hid[context->attack_step][4];
                     context->payload[5] = id_list_hid[context->attack_step][5];
 
-                    if(context->attack_step == 15) {
+                    if(context->attack_step == 13) {
                         context->attack_step = 0;
                         counter = 0;
                         context->is_attacking = false;
@@ -118,6 +191,37 @@ void flipfrid_scene_run_attack_on_tick(FlipFridState* context) {
                     context->payload[3] = 0x00;
                     context->payload[4] = 0x00;
 
+                    if(context->attack_step == 255) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                } else if(context->proto == PAC) {
+                    context->payload[0] = context->attack_step;
+                    context->payload[1] = 0x00;
+                    context->payload[2] = 0x00;
+                    context->payload[3] = 0x00;
+
+                    if(context->attack_step == 255) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                } else if(context->proto == H10301) {
+                    context->payload[0] = context->attack_step;
+                    context->payload[1] = 0x00;
+                    context->payload[2] = 0x00;
+
                     if(context->attack_step == 255) {
                         context->attack_step = 0;
                         counter = 0;
@@ -158,6 +262,43 @@ void flipfrid_scene_run_attack_on_tick(FlipFridState* context) {
 
                     context->payload[context->key_index] = context->attack_step;
 
+                    if(context->attack_step == 255) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                        break;
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                } else if(context->proto == PAC) {
+                    context->payload[0] = context->data[0];
+                    context->payload[1] = context->data[1];
+                    context->payload[2] = context->data[2];
+                    context->payload[3] = context->data[3];
+
+                    context->payload[context->key_index] = context->attack_step;
+
+                    if(context->attack_step == 255) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_single_vibro);
+                        break;
+                    } else {
+                        context->attack_step++;
+                    }
+                    break;
+                } else if(context->proto == H10301) {
+                    context->payload[0] = context->data[0];
+                    context->payload[1] = context->data[1];
+                    context->payload[2] = context->data[2];
+
+                    context->payload[context->key_index] = context->attack_step;
+
                     if(context->attack_step == 255) {
                         context->attack_step = 0;
                         counter = 0;
@@ -194,53 +335,153 @@ void flipfrid_scene_run_attack_on_tick(FlipFridState* context) {
 
             case FlipFridAttackLoadFileCustomUids:
                 if(context->proto == EM4100) {
+                    bool end_of_list = false;
                     while(true) {
-                        string_reset(context->data_str);
+                        furi_string_reset(context->data_str);
                         if(!stream_read_line(context->uids_stream, context->data_str)) {
                             context->attack_step = 0;
                             counter = 0;
                             context->is_attacking = false;
                             notification_message(context->notify, &sequence_blink_stop);
                             notification_message(context->notify, &sequence_single_vibro);
+                            stream_rewind(context->uids_stream);
+                            end_of_list = true;
                             break;
                         };
-                        if(string_get_char(context->data_str, 0) == '#') continue;
-                        if(string_size(context->data_str) != 11) continue;
+                        if(furi_string_get_char(context->data_str, 0) == '#') continue;
+                        if(furi_string_size(context->data_str) != 11) break;
                         break;
                     }
-                    FURI_LOG_D(TAG, string_get_cstr(context->data_str));
+                    if(end_of_list) break;
+                    FURI_LOG_D(TAG, furi_string_get_cstr(context->data_str));
+                    if(furi_string_size(context->data_str) != 11) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_error);
+                        break;
+                    };
 
                     // string is valid, parse it in context->payload
                     for(uint8_t i = 0; i < 5; i++) {
                         char temp_str[3];
-                        temp_str[0] = string_get_cstr(context->data_str)[i * 2];
-                        temp_str[1] = string_get_cstr(context->data_str)[i * 2 + 1];
+                        temp_str[0] = furi_string_get_cstr(context->data_str)[i * 2];
+                        temp_str[1] = furi_string_get_cstr(context->data_str)[i * 2 + 1];
+                        temp_str[2] = '\0';
+                        context->payload[i] = (uint8_t)strtol(temp_str, NULL, 16);
+                    }
+                    break;
+                } else if(context->proto == PAC) {
+                    bool end_of_list = false;
+                    while(true) {
+                        furi_string_reset(context->data_str);
+                        if(!stream_read_line(context->uids_stream, context->data_str)) {
+                            context->attack_step = 0;
+                            counter = 0;
+                            context->is_attacking = false;
+                            notification_message(context->notify, &sequence_blink_stop);
+                            notification_message(context->notify, &sequence_single_vibro);
+                            stream_rewind(context->uids_stream);
+                            end_of_list = true;
+                            break;
+                        };
+                        if(furi_string_get_char(context->data_str, 0) == '#') continue;
+                        if(furi_string_size(context->data_str) != 9) break;
+                        break;
+                    }
+                    if(end_of_list) break;
+                    FURI_LOG_D(TAG, furi_string_get_cstr(context->data_str));
+                    if(furi_string_size(context->data_str) != 9) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_error);
+                        break;
+                    };
+
+                    // string is valid, parse it in context->payload
+                    for(uint8_t i = 0; i < 4; i++) {
+                        char temp_str[3];
+                        temp_str[0] = furi_string_get_cstr(context->data_str)[i * 2];
+                        temp_str[1] = furi_string_get_cstr(context->data_str)[i * 2 + 1];
+                        temp_str[2] = '\0';
+                        context->payload[i] = (uint8_t)strtol(temp_str, NULL, 16);
+                    }
+                    break;
+                } else if(context->proto == H10301) {
+                    bool end_of_list = false;
+                    while(true) {
+                        furi_string_reset(context->data_str);
+                        if(!stream_read_line(context->uids_stream, context->data_str)) {
+                            context->attack_step = 0;
+                            counter = 0;
+                            context->is_attacking = false;
+                            notification_message(context->notify, &sequence_blink_stop);
+                            notification_message(context->notify, &sequence_single_vibro);
+                            stream_rewind(context->uids_stream);
+                            end_of_list = true;
+                            break;
+                        };
+                        if(furi_string_get_char(context->data_str, 0) == '#') continue;
+                        if(furi_string_size(context->data_str) != 7) break;
+                        break;
+                    }
+                    if(end_of_list) break;
+                    FURI_LOG_D(TAG, furi_string_get_cstr(context->data_str));
+                    if(furi_string_size(context->data_str) != 7) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_error);
+                        break;
+                    };
+
+                    // string is valid, parse it in context->payload
+                    for(uint8_t i = 0; i < 3; i++) {
+                        char temp_str[3];
+                        temp_str[0] = furi_string_get_cstr(context->data_str)[i * 2];
+                        temp_str[1] = furi_string_get_cstr(context->data_str)[i * 2 + 1];
                         temp_str[2] = '\0';
                         context->payload[i] = (uint8_t)strtol(temp_str, NULL, 16);
                     }
                     break;
                 } else {
+                    bool end_of_list = false;
                     while(true) {
-                        string_reset(context->data_str);
+                        furi_string_reset(context->data_str);
                         if(!stream_read_line(context->uids_stream, context->data_str)) {
                             context->attack_step = 0;
                             counter = 0;
                             context->is_attacking = false;
                             notification_message(context->notify, &sequence_blink_stop);
                             notification_message(context->notify, &sequence_single_vibro);
+                            stream_rewind(context->uids_stream);
+                            end_of_list = true;
                             break;
                         };
-                        if(string_get_char(context->data_str, 0) == '#') continue;
-                        if(string_size(context->data_str) != 13) continue;
+                        if(furi_string_get_char(context->data_str, 0) == '#') continue;
+                        if(furi_string_size(context->data_str) != 13) break;
                         break;
                     }
-                    FURI_LOG_D(TAG, string_get_cstr(context->data_str));
+                    FURI_LOG_D(TAG, furi_string_get_cstr(context->data_str));
+                    if(end_of_list) break;
+                    if(furi_string_size(context->data_str) != 13) {
+                        context->attack_step = 0;
+                        counter = 0;
+                        context->is_attacking = false;
+                        notification_message(context->notify, &sequence_blink_stop);
+                        notification_message(context->notify, &sequence_error);
+                        break;
+                    };
 
                     // string is valid, parse it in context->payload
                     for(uint8_t i = 0; i < 6; i++) {
                         char temp_str[3];
-                        temp_str[0] = string_get_cstr(context->data_str)[i * 2];
-                        temp_str[1] = string_get_cstr(context->data_str)[i * 2 + 1];
+                        temp_str[0] = furi_string_get_cstr(context->data_str)[i * 2];
+                        temp_str[1] = furi_string_get_cstr(context->data_str)[i * 2 + 1];
                         temp_str[2] = '\0';
                         context->payload[i] = (uint8_t)strtol(temp_str, NULL, 16);
                     }
@@ -249,7 +490,7 @@ void flipfrid_scene_run_attack_on_tick(FlipFridState* context) {
             }
         }
 
-        if(counter > TIME_BETWEEN_CARDS) {
+        if(counter > context->time_between_cards) {
             counter = 0;
         } else {
             counter++;
@@ -262,9 +503,22 @@ void flipfrid_scene_run_attack_on_event(FlipFridEvent event, FlipFridState* cont
         if(event.input_type == InputTypeShort) {
             switch(event.key) {
             case InputKeyDown:
+                break;
             case InputKeyUp:
+                break;
             case InputKeyLeft:
+                if(!context->is_attacking) {
+                    if(context->time_between_cards > 0) {
+                        context->time_between_cards--;
+                    }
+                }
+                break;
             case InputKeyRight:
+                if(!context->is_attacking) {
+                    if(context->time_between_cards < 60) {
+                        context->time_between_cards++;
+                    }
+                }
                 break;
             case InputKeyOk:
                 counter = 0;
@@ -284,7 +538,7 @@ void flipfrid_scene_run_attack_on_event(FlipFridEvent event, FlipFridState* cont
 
                 context->attack_step = 0;
                 context->is_attacking = false;
-                string_reset(context->notification_msg);
+                furi_string_reset(context->notification_msg);
                 context->current_scene = SceneEntryPoint;
                 notification_message(context->notify, &sequence_blink_stop);
                 break;
@@ -303,9 +557,10 @@ void flipfrid_scene_run_attack_on_draw(Canvas* canvas, FlipFridState* context) {
     // Title
     canvas_set_font(canvas, FontPrimary);
     canvas_draw_str_aligned(
-        canvas, 64, 8, AlignCenter, AlignTop, string_get_cstr(context->attack_name));
+        canvas, 64, 2, AlignCenter, AlignTop, furi_string_get_cstr(context->attack_name));
 
     char uid[18];
+    char speed[16];
     if(context->proto == HIDProx) {
         snprintf(
             uid,
@@ -317,6 +572,23 @@ void flipfrid_scene_run_attack_on_draw(Canvas* canvas, FlipFridState* context) {
             context->payload[3],
             context->payload[4],
             context->payload[5]);
+    } else if(context->proto == PAC) {
+        snprintf(
+            uid,
+            sizeof(uid),
+            "%02X:%02X:%02X:%02X",
+            context->payload[0],
+            context->payload[1],
+            context->payload[2],
+            context->payload[3]);
+    } else if(context->proto == H10301) {
+        snprintf(
+            uid,
+            sizeof(uid),
+            "%02X:%02X:%02X",
+            context->payload[0],
+            context->payload[1],
+            context->payload[2]);
     } else {
         snprintf(
             uid,
@@ -329,15 +601,25 @@ void flipfrid_scene_run_attack_on_draw(Canvas* canvas, FlipFridState* context) {
             context->payload[4]);
     }
 
-    canvas_draw_str_aligned(canvas, 64, 24, AlignCenter, AlignTop, uid);
+    canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignTop, uid);
 
     canvas_set_font(canvas, FontSecondary);
+
+    canvas_draw_str_aligned(
+        canvas, 64, 26, AlignCenter, AlignTop, furi_string_get_cstr(context->proto_name));
+
+    snprintf(speed, sizeof(speed), "Time delay: %d", context->time_between_cards);
+
+    //canvas_draw_str_aligned(canvas, 0, 22, AlignLeft, AlignTop, "Speed:");
+    canvas_draw_str_aligned(canvas, 64, 14, AlignCenter, AlignTop, speed);
     //char start_stop_msg[20];
     if(context->is_attacking) {
         elements_button_center(canvas, "Stop");
         //snprintf(start_stop_msg, sizeof(start_stop_msg), " Press OK to stop ");
     } else {
         elements_button_center(canvas, "Start");
+        elements_button_left(canvas, "TD -");
+        elements_button_right(canvas, "+ TD");
     }
     //canvas_draw_str_aligned(canvas, 64, 44, AlignCenter, AlignTop, start_stop_msg);
 }

applications/plugins/flipfrid/scene/flipfrid_scene_select_field.c

@@ -1,8 +1,31 @@
 #include "flipfrid_scene_select_field.h"
 
 void flipfrid_center_displayed_key(FlipFridState* context, uint8_t index) {
-    const char* key_cstr = string_get_cstr(context->data_str);
+    char key_cstr[18];
+    uint8_t key_len = 18;
     uint8_t str_index = (index * 3);
+    int data_len = sizeof(context->data) / sizeof(context->data[0]);
+    int key_index = 0;
+
+    if(context->proto == EM4100) {
+        key_len = 16;
+    }
+    if(context->proto == PAC) {
+        key_len = 13;
+    }
+    if(context->proto == H10301) {
+        key_len = 10;
+    }
+
+    for(uint8_t i = 0; i < data_len; i++) {
+        if(context->data[i] < 9) {
+            key_index +=
+                snprintf(&key_cstr[key_index], key_len - key_index, "0%X ", context->data[i]);
+        } else {
+            key_index +=
+                snprintf(&key_cstr[key_index], key_len - key_index, "%X ", context->data[i]);
+        }
+    }
 
     char display_menu[17] = {
         'X', 'X', ' ', 'X', 'X', ' ', '<', 'X', 'X', '>', ' ', 'X', 'X', ' ', 'X', 'X', '\0'};
@@ -42,12 +65,12 @@ void flipfrid_center_displayed_key(FlipFridState* context, uint8_t index) {
         display_menu[15] = ' ';
     }
 
-    string_reset(context->notification_msg);
-    string_set_str(context->notification_msg, display_menu);
+    furi_string_reset(context->notification_msg);
+    furi_string_set(context->notification_msg, display_menu);
 }
 
 void flipfrid_scene_select_field_on_enter(FlipFridState* context) {
-    string_clear(context->notification_msg);
+    furi_string_reset(context->notification_msg);
 }
 
 void flipfrid_scene_select_field_on_exit(FlipFridState* context) {
@@ -61,7 +84,8 @@ void flipfrid_scene_select_field_on_tick(FlipFridState* context) {
 void flipfrid_scene_select_field_on_event(FlipFridEvent event, FlipFridState* context) {
     if(event.evt_type == EventTypeKey) {
         if(event.input_type == InputTypeShort) {
-            const char* key_cstr = string_get_cstr(context->data_str);
+            const char* key_cstr = furi_string_get_cstr(context->data_str);
+            int data_len = sizeof(context->data) / sizeof(context->data[0]);
 
             // don't look, it's ugly but I'm a python dev so...
             uint8_t nb_bytes = 0;
@@ -73,7 +97,18 @@ void flipfrid_scene_select_field_on_event(FlipFridEvent event, FlipFridState* co
 
             switch(event.key) {
             case InputKeyDown:
+                for(uint8_t i = 0; i < data_len; i++) {
+                    if(context->key_index == i) {
+                        context->data[i] = (context->data[i] - 1);
+                    }
+                }
+                break;
             case InputKeyUp:
+                for(uint8_t i = 0; i < data_len; i++) {
+                    if(context->key_index == i) {
+                        context->data[i] = (context->data[i] + 1);
+                    }
+                }
                 break;
             case InputKeyLeft:
                 if(context->key_index > 0) {
@@ -86,11 +121,12 @@ void flipfrid_scene_select_field_on_event(FlipFridEvent event, FlipFridState* co
                 }
                 break;
             case InputKeyOk:
-                string_reset(context->notification_msg);
+                furi_string_reset(context->notification_msg);
                 context->current_scene = SceneAttack;
                 break;
             case InputKeyBack:
-                string_reset(context->notification_msg);
+                context->key_index = 0;
+                furi_string_reset(context->notification_msg);
                 context->current_scene = SceneSelectFile;
                 break;
             }
@@ -106,16 +142,17 @@ void flipfrid_scene_select_field_on_draw(Canvas* canvas, FlipFridState* context)
     // Frame
     //canvas_draw_frame(canvas, 0, 0, 128, 64);
 
-    // Title
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 64, 10, AlignCenter, AlignTop, "Use < > to select byte.");
+    canvas_set_font(canvas, FontSecondary);
+    canvas_draw_str_aligned(canvas, 12, 5, AlignLeft, AlignTop, "Left and right: select byte");
+    canvas_draw_str_aligned(canvas, 12, 15, AlignLeft, AlignTop, "Up and down: adjust byte");
 
     char msg_index[18];
+    canvas_set_font(canvas, FontPrimary);
     snprintf(msg_index, sizeof(msg_index), "Field index : %d", context->key_index);
-    canvas_draw_str_aligned(canvas, 64, 26, AlignCenter, AlignTop, msg_index);
+    canvas_draw_str_aligned(canvas, 64, 30, AlignCenter, AlignTop, msg_index);
 
     flipfrid_center_displayed_key(context, context->key_index);
     canvas_set_font(canvas, FontSecondary);
     canvas_draw_str_aligned(
-        canvas, 64, 40, AlignCenter, AlignTop, string_get_cstr(context->notification_msg));
+        canvas, 64, 45, AlignCenter, AlignTop, furi_string_get_cstr(context->notification_msg));
 }

applications/plugins/mousejacker/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="mouse_jacker",
+    appid="NRF24_Mouse_Jacker",
     name="[NRF24] Mouse Jacker",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="mousejacker_app",

applications/plugins/mousejacker/mousejacker.c

@@ -104,9 +104,9 @@ static void hexlify(uint8_t* in, uint8_t size, char* out) {
 static bool open_ducky_script(Stream* stream, PluginState* plugin_state) {
     DialogsApp* dialogs = furi_record_open("dialogs");
     bool result = false;
-    string_t path;
-    string_init(path);
-    string_set_str(path, MOUSEJACKER_APP_PATH_FOLDER);
+    FuriString* path;
+    path = furi_string_alloc();
+    furi_string_set(path, MOUSEJACKER_APP_PATH_FOLDER);
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(
@@ -117,13 +117,13 @@ static bool open_ducky_script(Stream* stream, PluginState* plugin_state) {
 
     furi_record_close("dialogs");
     if(ret) {
-        if(!file_stream_open(stream, string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
-            FURI_LOG_D(TAG, "Cannot open file \"%s\"", (path));
+        if(!file_stream_open(stream, furi_string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
+            FURI_LOG_D(TAG, "Cannot open file \"%s\"", furi_string_get_cstr(path));
         } else {
             result = true;
         }
     }
-    string_clear(path);
+    furi_string_free(path);
 
     plugin_state->is_ducky_running = true;
 
@@ -133,9 +133,9 @@ static bool open_ducky_script(Stream* stream, PluginState* plugin_state) {
 static bool open_addrs_file(Stream* stream) {
     DialogsApp* dialogs = furi_record_open("dialogs");
     bool result = false;
-    string_t path;
-    string_init(path);
-    string_set_str(path, NRFSNIFF_APP_PATH_FOLDER);
+    FuriString* path;
+    path = furi_string_alloc();
+    furi_string_set(path, NRFSNIFF_APP_PATH_FOLDER);
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(
@@ -146,13 +146,13 @@ static bool open_addrs_file(Stream* stream) {
 
     furi_record_close("dialogs");
     if(ret) {
-        if(!file_stream_open(stream, string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
-            FURI_LOG_D(TAG, "Cannot open file \"%s\"", (path));
+        if(!file_stream_open(stream, furi_string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
+            FURI_LOG_D(TAG, "Cannot open file \"%s\"", furi_string_get_cstr(path));
         } else {
             result = true;
         }
     }
-    string_clear(path);
+    furi_string_free(path);
     return result;
 }
 

applications/plugins/mousejacker/mousejacker_ducky.c

@@ -261,7 +261,7 @@ static bool mj_process_ducky_line(
         repeat_cnt = atoi(line_tmp);
         if(repeat_cnt < 2) return false;
 
-        FURI_LOG_D(TAG, "repeating %s %d times", prev_line, repeat_cnt);
+        FURI_LOG_D(TAG, "repeating %s %ld times", prev_line, repeat_cnt);
         for(uint32_t i = 0; i < repeat_cnt; i++)
             mj_process_ducky_line(handle, addr, addr_size, rate, prev_line, NULL, plugin_state);
 

applications/plugins/multi_converter/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="multi_converter",
+    appid="Multi_Converter",
     name="Multi Converter",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="multi_converter_app",

applications/plugins/music_player/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="music_player",
+    appid="Music_Player",
     name="Music Player",
     apptype=FlipperAppType.PLUGIN,
     entry_point="music_player_app",

applications/plugins/music_player/music_player.c

@@ -8,8 +8,6 @@
 #include <dialogs/dialogs.h>
 #include <storage/storage.h>
 
-#include <m-string.h>
-
 #define TAG "MusicPlayer"
 
 #define MUSIC_PLAYER_APP_PATH_FOLDER ANY_PATH("music_player")
@@ -296,14 +294,14 @@ void music_player_free(MusicPlayer* instance) {
 int32_t music_player_app(void* p) {
     MusicPlayer* music_player = music_player_alloc();
 
-    string_t file_path;
-    string_init(file_path);
+    FuriString* file_path;
+    file_path = furi_string_alloc();
 
     do {
         if(p && strlen(p)) {
-            string_cat_str(file_path, p);
+            furi_string_cat(file_path, (const char*)p);
         } else {
-            string_set_str(file_path, MUSIC_PLAYER_APP_PATH_FOLDER);
+            furi_string_set(file_path, MUSIC_PLAYER_APP_PATH_FOLDER);
 
             DialogsFileBrowserOptions browser_options;
             dialog_file_browser_set_basic_options(
@@ -320,7 +318,7 @@ int32_t music_player_app(void* p) {
             }
         }
 
-        if(!music_player_worker_load(music_player->worker, string_get_cstr(file_path))) {
+        if(!music_player_worker_load(music_player->worker, furi_string_get_cstr(file_path))) {
             FURI_LOG_E(TAG, "Unable to load file");
             break;
         }
@@ -354,7 +352,7 @@ int32_t music_player_app(void* p) {
         music_player_worker_stop(music_player->worker);
     } while(0);
 
-    string_clear(file_path);
+    furi_string_free(file_path);
     music_player_free(music_player);
 
     return 0;

applications/plugins/music_player/music_player_cli.c

@@ -3,20 +3,20 @@
 #include <storage/storage.h>
 #include "music_player_worker.h"
 
-static void music_player_cli(Cli* cli, string_t args, void* context) {
+static void music_player_cli(Cli* cli, FuriString* args, void* context) {
     UNUSED(context);
     MusicPlayerWorker* music_player_worker = music_player_worker_alloc();
     Storage* storage = furi_record_open(RECORD_STORAGE);
 
     do {
-        if(storage_common_stat(storage, string_get_cstr(args), NULL) == FSE_OK) {
-            if(!music_player_worker_load(music_player_worker, string_get_cstr(args))) {
-                printf("Failed to open file %s\r\n", string_get_cstr(args));
+        if(storage_common_stat(storage, furi_string_get_cstr(args), NULL) == FSE_OK) {
+            if(!music_player_worker_load(music_player_worker, furi_string_get_cstr(args))) {
+                printf("Failed to open file %s\r\n", furi_string_get_cstr(args));
                 break;
             }
         } else {
             if(!music_player_worker_load_rtttl_from_string(
-                   music_player_worker, string_get_cstr(args))) {
+                   music_player_worker, furi_string_get_cstr(args))) {
                 printf("Argument is not a file or RTTTL\r\n");
                 break;
             }

applications/plugins/music_player/music_player_worker.c

@@ -258,7 +258,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             if(!is_valid) {
                 FURI_LOG_E(
                     TAG,
-                    "Invalid note: %u%c%c%u.%u",
+                    "Invalid note: %lu%c%c%lu.%lu",
                     duration,
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
@@ -281,7 +281,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             if(music_player_worker_add_note(instance, semitone, duration, dots)) {
                 FURI_LOG_D(
                     TAG,
-                    "Added note: %c%c%u.%u = %u %u",
+                    "Added note: %c%c%lu.%lu = %u %lu",
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
                     octave,
@@ -291,7 +291,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             } else {
                 FURI_LOG_E(
                     TAG,
-                    "Invalid note: %c%c%u.%u = %u %u",
+                    "Invalid note: %c%c%lu.%lu = %u %lu",
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
                     octave,
@@ -326,8 +326,8 @@ bool music_player_worker_load_fmf_from_file(MusicPlayerWorker* instance, const c
     furi_assert(file_path);
 
     bool result = false;
-    string_t temp_str;
-    string_init(temp_str);
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
     FlipperFormat* file = flipper_format_file_alloc(storage);
@@ -337,7 +337,8 @@ bool music_player_worker_load_fmf_from_file(MusicPlayerWorker* instance, const c
 
         uint32_t version = 0;
         if(!flipper_format_read_header(file, temp_str, &version)) break;
-        if(string_cmp_str(temp_str, MUSIC_PLAYER_FILETYPE) || (version != MUSIC_PLAYER_VERSION)) {
+        if(furi_string_cmp_str(temp_str, MUSIC_PLAYER_FILETYPE) ||
+           (version != MUSIC_PLAYER_VERSION)) {
             FURI_LOG_E(TAG, "Incorrect file format or version");
             break;
         }
@@ -360,7 +361,7 @@ bool music_player_worker_load_fmf_from_file(MusicPlayerWorker* instance, const c
             break;
         }
 
-        if(!music_player_worker_parse_notes(instance, string_get_cstr(temp_str))) {
+        if(!music_player_worker_parse_notes(instance, furi_string_get_cstr(temp_str))) {
             break;
         }
 
@@ -369,7 +370,7 @@ bool music_player_worker_load_fmf_from_file(MusicPlayerWorker* instance, const c
 
     furi_record_close(RECORD_STORAGE);
     flipper_format_free(file);
-    string_clear(temp_str);
+    furi_string_free(temp_str);
 
     return result;
 }
@@ -379,8 +380,8 @@ bool music_player_worker_load_rtttl_from_file(MusicPlayerWorker* instance, const
     furi_assert(file_path);
 
     bool result = false;
-    string_t content;
-    string_init(content);
+    FuriString* content;
+    content = furi_string_alloc();
     Storage* storage = furi_record_open(RECORD_STORAGE);
     File* file = storage_file_alloc(storage);
 
@@ -395,17 +396,17 @@ bool music_player_worker_load_rtttl_from_file(MusicPlayerWorker* instance, const
             uint8_t buffer[65] = {0};
             ret = storage_file_read(file, buffer, sizeof(buffer) - 1);
             for(size_t i = 0; i < ret; i++) {
-                string_push_back(content, buffer[i]);
+                furi_string_push_back(content, buffer[i]);
             }
         } while(ret > 0);
 
-        string_strim(content);
-        if(!string_size(content)) {
+        furi_string_trim(content);
+        if(!furi_string_size(content)) {
             FURI_LOG_E(TAG, "Empty file");
             break;
         }
 
-        if(!music_player_worker_load_rtttl_from_string(instance, string_get_cstr(content))) {
+        if(!music_player_worker_load_rtttl_from_string(instance, furi_string_get_cstr(content))) {
             FURI_LOG_E(TAG, "Invalid file content");
             break;
         }
@@ -415,7 +416,7 @@ bool music_player_worker_load_rtttl_from_file(MusicPlayerWorker* instance, const
 
     storage_file_free(file);
     furi_record_close(RECORD_STORAGE);
-    string_clear(content);
+    furi_string_free(content);
 
     return result;
 }

applications/plugins/nrfsniff/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="nrf_sniff",
+    appid="NRF24_Sniffer",
     name="[NRF24] Sniffer",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="nrfsniff_app",

applications/plugins/picopass/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="picopass",
+    appid="Picopass",
     name="PicoPass Reader",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="picopass_app",
@@ -10,8 +10,11 @@ App(
     stack_size=4 * 1024,
     order=30,
     fap_icon="../../../assets/icons/Archive/125_10px.png",
-    fap_libs=[
-        "mbedtls",
-    ],
     fap_category="Tools",
+    fap_libs=["mbedtls"],
+    fap_private_libs=[
+        Lib(
+            name="loclass",
+        ),
+    ],
 )

applications/plugins/picopass/picopass_device.c

@@ -18,7 +18,7 @@ PicopassDevice* picopass_device_alloc() {
     picopass_dev->dev_data.pacs.pin_length = 0;
     picopass_dev->storage = furi_record_open(RECORD_STORAGE);
     picopass_dev->dialogs = furi_record_open(RECORD_DIALOGS);
-    string_init(picopass_dev->load_path);
+    picopass_dev->load_path = furi_string_alloc();
     return picopass_dev;
 }
 
@@ -40,25 +40,25 @@ static bool picopass_device_save_file(
     FlipperFormat* file = flipper_format_file_alloc(dev->storage);
     PicopassPacs* pacs = &dev->dev_data.pacs;
     PicopassBlock* AA1 = dev->dev_data.AA1;
-    string_t temp_str;
-    string_init(temp_str);
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
 
     do {
-        if(use_load_path && !string_empty_p(dev->load_path)) {
+        if(use_load_path && !furi_string_empty(dev->load_path)) {
             // Get directory name
-            path_extract_dirname(string_get_cstr(dev->load_path), temp_str);
+            path_extract_dirname(furi_string_get_cstr(dev->load_path), temp_str);
             // Create picopass directory if necessary
-            if(!storage_simply_mkdir(dev->storage, string_get_cstr(temp_str))) break;
+            if(!storage_simply_mkdir(dev->storage, furi_string_get_cstr(temp_str))) break;
             // Make path to file to save
-            string_cat_printf(temp_str, "/%s%s", dev_name, extension);
+            furi_string_cat_printf(temp_str, "/%s%s", dev_name, extension);
         } else {
             // Create picopass directory if necessary
             if(!storage_simply_mkdir(dev->storage, PICOPASS_APP_FOLDER)) break;
             // First remove picopass device file if it was saved
-            string_printf(temp_str, "%s/%s%s", folder, dev_name, extension);
+            furi_string_printf(temp_str, "%s/%s%s", folder, dev_name, extension);
         }
         // Open file
-        if(!flipper_format_file_open_always(file, string_get_cstr(temp_str))) break;
+        if(!flipper_format_file_open_always(file, furi_string_get_cstr(temp_str))) break;
 
         if(dev->format == PicopassDeviceSaveFormatHF) {
             uint32_t fc = pacs->record.FacilityCode;
@@ -87,9 +87,9 @@ static bool picopass_device_save_file(
                                    AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0] :
                                    PICOPASS_MAX_APP_LIMIT;
             for(size_t i = 0; i < app_limit; i++) {
-                string_printf(temp_str, "Block %d", i);
+                furi_string_printf(temp_str, "Block %d", i);
                 if(!flipper_format_write_hex(
-                       file, string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
+                       file, furi_string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
                     block_saved = false;
                     break;
                 }
@@ -117,7 +117,7 @@ static bool picopass_device_save_file(
     if(!saved) {
         dialog_message_show_storage_error(dev->dialogs, "Can not save\nfile");
     }
-    string_clear(temp_str);
+    furi_string_free(temp_str);
     flipper_format_free(file);
     return saved;
 }
@@ -132,13 +132,13 @@ bool picopass_device_save(PicopassDevice* dev, const char* dev_name) {
     return false;
 }
 
-static bool picopass_device_load_data(PicopassDevice* dev, string_t path, bool show_dialog) {
+static bool picopass_device_load_data(PicopassDevice* dev, FuriString* path, bool show_dialog) {
     bool parsed = false;
     FlipperFormat* file = flipper_format_file_alloc(dev->storage);
     PicopassBlock* AA1 = dev->dev_data.AA1;
     PicopassPacs* pacs = &dev->dev_data.pacs;
-    string_t temp_str;
-    string_init(temp_str);
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
     bool deprecated_version = false;
 
     if(dev->loading_cb) {
@@ -146,12 +146,13 @@ static bool picopass_device_load_data(PicopassDevice* dev, string_t path, bool s
     }
 
     do {
-        if(!flipper_format_file_open_existing(file, string_get_cstr(path))) break;
+        if(!flipper_format_file_open_existing(file, furi_string_get_cstr(path))) break;
 
         // Read and verify file header
         uint32_t version = 0;
         if(!flipper_format_read_header(file, temp_str, &version)) break;
-        if(string_cmp_str(temp_str, picopass_file_header) || (version != picopass_file_version)) {
+        if(furi_string_cmp_str(temp_str, picopass_file_header) ||
+           (version != picopass_file_version)) {
             deprecated_version = true;
             break;
         }
@@ -159,9 +160,9 @@ static bool picopass_device_load_data(PicopassDevice* dev, string_t path, bool s
         // Parse header blocks
         bool block_read = true;
         for(size_t i = 0; i < 6; i++) {
-            string_printf(temp_str, "Block %d", i);
+            furi_string_printf(temp_str, "Block %d", i);
             if(!flipper_format_read_hex(
-                   file, string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
+                   file, furi_string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
                 block_read = false;
                 break;
             }
@@ -169,9 +170,9 @@ static bool picopass_device_load_data(PicopassDevice* dev, string_t path, bool s
 
         size_t app_limit = AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0];
         for(size_t i = 6; i < app_limit; i++) {
-            string_printf(temp_str, "Block %d", i);
+            furi_string_printf(temp_str, "Block %d", i);
             if(!flipper_format_read_hex(
-                   file, string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
+                   file, furi_string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
                 block_read = false;
                 break;
             }
@@ -196,7 +197,7 @@ static bool picopass_device_load_data(PicopassDevice* dev, string_t path, bool s
         }
     }
 
-    string_clear(temp_str);
+    furi_string_free(temp_str);
     flipper_format_free(file);
 
     return parsed;
@@ -208,7 +209,7 @@ void picopass_device_clear(PicopassDevice* dev) {
     picopass_device_data_clear(&dev->dev_data);
     memset(&dev->dev_data, 0, sizeof(dev->dev_data));
     dev->format = PicopassDeviceSaveFormatHF;
-    string_reset(dev->load_path);
+    furi_string_reset(dev->load_path);
 }
 
 void picopass_device_free(PicopassDevice* picopass_dev) {
@@ -216,7 +217,7 @@ void picopass_device_free(PicopassDevice* picopass_dev) {
     picopass_device_clear(picopass_dev);
     furi_record_close(RECORD_STORAGE);
     furi_record_close(RECORD_DIALOGS);
-    string_clear(picopass_dev->load_path);
+    furi_string_free(picopass_dev->load_path);
     free(picopass_dev);
 }
 
@@ -224,8 +225,8 @@ bool picopass_file_select(PicopassDevice* dev) {
     furi_assert(dev);
 
     // Input events and views are managed by file_browser
-    string_t picopass_app_folder;
-    string_init_set_str(picopass_app_folder, PICOPASS_APP_FOLDER);
+    FuriString* picopass_app_folder;
+    picopass_app_folder = furi_string_alloc_set(PICOPASS_APP_FOLDER);
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(&browser_options, PICOPASS_APP_EXTENSION, &I_Nfc_10px);
@@ -233,17 +234,17 @@ bool picopass_file_select(PicopassDevice* dev) {
     bool res = dialog_file_browser_show(
         dev->dialogs, dev->load_path, picopass_app_folder, &browser_options);
 
-    string_clear(picopass_app_folder);
+    furi_string_free(picopass_app_folder);
     if(res) {
-        string_t filename;
-        string_init(filename);
+        FuriString* filename;
+        filename = furi_string_alloc();
         path_extract_filename(dev->load_path, filename, true);
-        strncpy(dev->dev_name, string_get_cstr(filename), PICOPASS_DEV_NAME_MAX_LEN);
+        strncpy(dev->dev_name, furi_string_get_cstr(filename), PICOPASS_DEV_NAME_MAX_LEN);
         res = picopass_device_load_data(dev, dev->load_path, true);
         if(res) {
             picopass_device_set_name(dev, dev->dev_name);
         }
-        string_clear(filename);
+        furi_string_free(filename);
     }
 
     return res;
@@ -262,18 +263,18 @@ bool picopass_device_delete(PicopassDevice* dev, bool use_load_path) {
     furi_assert(dev);
 
     bool deleted = false;
-    string_t file_path;
-    string_init(file_path);
+    FuriString* file_path;
+    file_path = furi_string_alloc();
 
     do {
         // Delete original file
-        if(use_load_path && !string_empty_p(dev->load_path)) {
-            string_set(file_path, dev->load_path);
+        if(use_load_path && !furi_string_empty(dev->load_path)) {
+            furi_string_set(file_path, dev->load_path);
         } else {
-            string_printf(
+            furi_string_printf(
                 file_path, "%s/%s%s", PICOPASS_APP_FOLDER, dev->dev_name, PICOPASS_APP_EXTENSION);
         }
-        if(!storage_simply_remove(dev->storage, string_get_cstr(file_path))) break;
+        if(!storage_simply_remove(dev->storage, furi_string_get_cstr(file_path))) break;
         deleted = true;
     } while(0);
 
@@ -281,7 +282,7 @@ bool picopass_device_delete(PicopassDevice* dev, bool use_load_path) {
         dialog_message_show_storage_error(dev->dialogs, "Can not remove file");
     }
 
-    string_clear(file_path);
+    furi_string_free(file_path);
     return deleted;
 }
 

applications/plugins/picopass/picopass_device.h

@@ -7,8 +7,8 @@
 #include <mbedtls/des.h>
 
 #include "rfal_picopass.h"
-#include "loclass/optimized_ikeys.h"
-#include "loclass/optimized_cipher.h"
+#include <optimized_ikeys.h>
+#include <optimized_cipher.h>
 
 #define PICOPASS_DEV_NAME_MAX_LEN 22
 #define PICOPASS_READER_DATA_MAX_SIZE 64
@@ -71,7 +71,7 @@ typedef struct {
     DialogsApp* dialogs;
     PicopassDeviceData dev_data;
     char dev_name[PICOPASS_DEV_NAME_MAX_LEN + 1];
-    string_t load_path;
+    FuriString* load_path;
     PicopassDeviceSaveFormat format;
     PicopassLoadingCallback loading_cb;
     void* loading_cb_ctx;

applications/plugins/picopass/picopass_i.h

@@ -51,7 +51,7 @@ struct Picopass {
     PicopassDevice* dev;
 
     char text_store[PICOPASS_TEXT_STORE_SIZE + 1];
-    string_t text_box_store;
+    FuriString* text_box_store;
 
     // Common Views
     Submenu* submenu;

applications/plugins/picopass/scenes/picopass_scene_device_info.c

@@ -14,10 +14,10 @@ void picopass_scene_device_info_widget_callback(
 void picopass_scene_device_info_on_enter(void* context) {
     Picopass* picopass = context;
 
-    string_t credential_str;
-    string_t wiegand_str;
-    string_init(credential_str);
-    string_init(wiegand_str);
+    FuriString* credential_str;
+    FuriString* wiegand_str;
+    credential_str = furi_string_alloc();
+    wiegand_str = furi_string_alloc();
 
     DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
 
@@ -26,25 +26,31 @@ void picopass_scene_device_info_on_enter(void* context) {
     Widget* widget = picopass->widget;
 
     size_t bytesLength = 1 + pacs->record.bitLength / 8;
-    string_set_str(credential_str, "");
+    furi_string_set(credential_str, "");
     for(uint8_t i = PICOPASS_BLOCK_LEN - bytesLength; i < PICOPASS_BLOCK_LEN; i++) {
-        string_cat_printf(credential_str, " %02X", pacs->credential[i]);
+        furi_string_cat_printf(credential_str, " %02X", pacs->credential[i]);
     }
 
     if(pacs->record.valid) {
-        string_cat_printf(
+        furi_string_cat_printf(
             wiegand_str, "FC: %u CN: %u", pacs->record.FacilityCode, pacs->record.CardNumber);
     } else {
-        string_cat_printf(wiegand_str, "%d bits", pacs->record.bitLength);
+        furi_string_cat_printf(wiegand_str, "%d bits", pacs->record.bitLength);
     }
 
     widget_add_string_element(
-        widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, string_get_cstr(wiegand_str));
+        widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, furi_string_get_cstr(wiegand_str));
     widget_add_string_element(
-        widget, 64, 32, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(credential_str));
+        widget,
+        64,
+        32,
+        AlignCenter,
+        AlignCenter,
+        FontSecondary,
+        furi_string_get_cstr(credential_str));
 
-    string_clear(credential_str);
-    string_clear(wiegand_str);
+    furi_string_free(credential_str);
+    furi_string_free(wiegand_str);
 
     widget_add_button_element(
         picopass->widget,

applications/plugins/picopass/scenes/picopass_scene_read_card_success.c

@@ -15,12 +15,12 @@ void picopass_scene_read_card_success_widget_callback(
 
 void picopass_scene_read_card_success_on_enter(void* context) {
     Picopass* picopass = context;
-    string_t credential_str;
-    string_t wiegand_str;
-    string_t sio_str;
-    string_init(credential_str);
-    string_init(wiegand_str);
-    string_init(sio_str);
+    FuriString* credential_str;
+    FuriString* wiegand_str;
+    FuriString* sio_str;
+    credential_str = furi_string_alloc();
+    wiegand_str = furi_string_alloc();
+    sio_str = furi_string_alloc();
 
     DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
 
@@ -32,10 +32,10 @@ void picopass_scene_read_card_success_on_enter(void* context) {
     Widget* widget = picopass->widget;
 
     if(pacs->record.bitLength == 0) {
-        string_cat_printf(wiegand_str, "Read Failed");
+        furi_string_cat_printf(wiegand_str, "Read Failed");
 
         if(pacs->se_enabled) {
-            string_cat_printf(credential_str, "SE enabled");
+            furi_string_cat_printf(credential_str, "SE enabled");
         }
 
         widget_add_button_element(
@@ -47,20 +47,20 @@ void picopass_scene_read_card_success_on_enter(void* context) {
 
     } else {
         size_t bytesLength = 1 + pacs->record.bitLength / 8;
-        string_set_str(credential_str, "");
+        furi_string_set(credential_str, "");
         for(uint8_t i = PICOPASS_BLOCK_LEN - bytesLength; i < PICOPASS_BLOCK_LEN; i++) {
-            string_cat_printf(credential_str, " %02X", pacs->credential[i]);
+            furi_string_cat_printf(credential_str, " %02X", pacs->credential[i]);
         }
 
         if(pacs->record.valid) {
-            string_cat_printf(
+            furi_string_cat_printf(
                 wiegand_str, "FC: %u CN: %u", pacs->record.FacilityCode, pacs->record.CardNumber);
         } else {
-            string_cat_printf(wiegand_str, "%d bits", pacs->record.bitLength);
+            furi_string_cat_printf(wiegand_str, "%d bits", pacs->record.bitLength);
         }
 
         if(pacs->sio) {
-            string_cat_printf(sio_str, "+SIO");
+            furi_string_cat_printf(sio_str, "+SIO");
         }
 
         widget_add_button_element(
@@ -79,15 +79,21 @@ void picopass_scene_read_card_success_on_enter(void* context) {
     }
 
     widget_add_string_element(
-        widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, string_get_cstr(wiegand_str));
+        widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, furi_string_get_cstr(wiegand_str));
     widget_add_string_element(
-        widget, 64, 32, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(credential_str));
+        widget,
+        64,
+        32,
+        AlignCenter,
+        AlignCenter,
+        FontSecondary,
+        furi_string_get_cstr(credential_str));
     widget_add_string_element(
-        widget, 64, 42, AlignCenter, AlignCenter, FontSecondary, string_get_cstr(sio_str));
+        widget, 64, 42, AlignCenter, AlignCenter, FontSecondary, furi_string_get_cstr(sio_str));
 
-    string_clear(credential_str);
-    string_clear(wiegand_str);
-    string_clear(sio_str);
+    furi_string_free(credential_str);
+    furi_string_free(wiegand_str);
+    furi_string_free(sio_str);
 
     view_dispatcher_switch_to_view(picopass->view_dispatcher, PicopassViewWidget);
 }

applications/plugins/picopass/scenes/picopass_scene_save_name.c

@@ -1,5 +1,4 @@
 #include "../picopass_i.h"
-#include "m-string.h"
 #include <lib/toolbox/random_name.h>
 #include <gui/modules/validators.h>
 #include <toolbox/path.h>
@@ -31,22 +30,22 @@ void picopass_scene_save_name_on_enter(void* context) {
         PICOPASS_DEV_NAME_MAX_LEN,
         dev_name_empty);
 
-    string_t folder_path;
-    string_init(folder_path);
+    FuriString* folder_path;
+    folder_path = furi_string_alloc();
 
-    if(string_end_with_str_p(picopass->dev->load_path, PICOPASS_APP_EXTENSION)) {
-        path_extract_dirname(string_get_cstr(picopass->dev->load_path), folder_path);
+    if(furi_string_end_with(picopass->dev->load_path, PICOPASS_APP_EXTENSION)) {
+        path_extract_dirname(furi_string_get_cstr(picopass->dev->load_path), folder_path);
     } else {
-        string_set_str(folder_path, PICOPASS_APP_FOLDER);
+        furi_string_set(folder_path, PICOPASS_APP_FOLDER);
     }
 
     ValidatorIsFile* validator_is_file = validator_is_file_alloc_init(
-        string_get_cstr(folder_path), PICOPASS_APP_EXTENSION, picopass->dev->dev_name);
+        furi_string_get_cstr(folder_path), PICOPASS_APP_EXTENSION, picopass->dev->dev_name);
     text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
 
     view_dispatcher_switch_to_view(picopass->view_dispatcher, PicopassViewTextInput);
 
-    string_clear(folder_path);
+    furi_string_free(folder_path);
 }
 
 bool picopass_scene_save_name_on_event(void* context, SceneManagerEvent event) {

applications/plugins/playlist/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="sub_playlist",
+    appid="SubGHz_Playlist",
     name="Sub-GHz Playlist",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="playlist_app",

applications/plugins/playlist/playlist.c

@@ -39,10 +39,10 @@ typedef struct {
     int current_playlist_repetition; // current playlist repetition
 
     // last 3 files
-    string_t prev_0_path; // current file
-    string_t prev_1_path; // previous file
-    string_t prev_2_path; // previous previous file
-    string_t prev_3_path; // you get the idea
+    FuriString* prev_0_path; // current file
+    FuriString* prev_1_path; // previous file
+    FuriString* prev_2_path; // previous previous file
+    FuriString* prev_3_path; // you get the idea
 
     int state; // current state
 
@@ -56,7 +56,7 @@ typedef struct {
 
     DisplayMeta* meta;
 
-    string_t file_path; // path to the playlist file
+    FuriString* file_path; // path to the playlist file
 
     bool ctl_request_exit; // can be set to true if the worker should exit
     bool ctl_pause; // can be set to true if the worker should pause
@@ -73,7 +73,7 @@ typedef struct {
     DisplayMeta* meta;
     PlaylistWorker* worker;
 
-    string_t file_path; // Path to the playlist file
+    FuriString* file_path; // Path to the playlist file
 } Playlist;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -83,23 +83,23 @@ void meta_set_state(DisplayMeta* meta, int state) {
     view_port_update(meta->view_port);
 }
 
-static FuriHalSubGhzPreset str_to_preset(string_t preset) {
-    if(string_cmp_str(preset, "FuriHalSubGhzPresetOok270Async") == 0) {
+static FuriHalSubGhzPreset str_to_preset(FuriString* preset) {
+    if(furi_string_cmp_str(preset, "FuriHalSubGhzPresetOok270Async") == 0) {
         return FuriHalSubGhzPresetOok270Async;
     }
-    if(string_cmp_str(preset, "FuriHalSubGhzPresetOok650Async") == 0) {
+    if(furi_string_cmp_str(preset, "FuriHalSubGhzPresetOok650Async") == 0) {
         return FuriHalSubGhzPresetOok650Async;
     }
-    if(string_cmp_str(preset, "FuriHalSubGhzPreset2FSKDev238Async") == 0) {
+    if(furi_string_cmp_str(preset, "FuriHalSubGhzPreset2FSKDev238Async") == 0) {
         return FuriHalSubGhzPreset2FSKDev238Async;
     }
-    if(string_cmp_str(preset, "FuriHalSubGhzPreset2FSKDev476Async") == 0) {
+    if(furi_string_cmp_str(preset, "FuriHalSubGhzPreset2FSKDev476Async") == 0) {
         return FuriHalSubGhzPreset2FSKDev476Async;
     }
-    if(string_cmp_str(preset, "FuriHalSubGhzPresetMSK99_97KbAsync") == 0) {
+    if(furi_string_cmp_str(preset, "FuriHalSubGhzPresetMSK99_97KbAsync") == 0) {
         return FuriHalSubGhzPresetMSK99_97KbAsync;
     }
-    if(string_cmp_str(preset, "FuriHalSubGhzPresetMSK99_97KbAsync") == 0) {
+    if(furi_string_cmp_str(preset, "FuriHalSubGhzPresetMSK99_97KbAsync") == 0) {
         return FuriHalSubGhzPresetMSK99_97KbAsync;
     }
     return FuriHalSubGhzPresetCustom;
@@ -117,8 +117,8 @@ static int playlist_worker_process(
     FlipperFormat* fff_file,
     FlipperFormat* fff_data,
     const char* path,
-    string_t preset,
-    string_t protocol) {
+    FuriString* preset,
+    FuriString* protocol) {
     // actual sending of .sub file
 
     if(!flipper_format_file_open_existing(fff_file, path)) {
@@ -148,7 +148,7 @@ static int playlist_worker_process(
         return -4;
     }
 
-    if(!string_cmp_str(protocol, "RAW")) {
+    if(!furi_string_cmp_str(protocol, "RAW")) {
         subghz_protocol_raw_gen_fff_data(fff_data, path);
     } else {
         stream_copy_full(
@@ -159,7 +159,7 @@ static int playlist_worker_process(
     // (try to) send file
     SubGhzEnvironment* environment = subghz_environment_alloc();
     SubGhzTransmitter* transmitter =
-        subghz_transmitter_alloc_init(environment, string_get_cstr(protocol));
+        subghz_transmitter_alloc_init(environment, furi_string_get_cstr(protocol));
 
     subghz_transmitter_deserialize(transmitter, fff_data);
 
@@ -216,9 +216,9 @@ static bool playlist_worker_play_playlist_once(
     Storage* storage,
     FlipperFormat* fff_head,
     FlipperFormat* fff_data,
-    string_t data,
-    string_t preset,
-    string_t protocol) {
+    FuriString* data,
+    FuriString* preset,
+    FuriString* protocol) {
     //
     if(!flipper_format_rewind(fff_head)) {
         FURI_LOG_E(TAG, "Failed to rewind file");
@@ -233,17 +233,20 @@ static bool playlist_worker_play_playlist_once(
         meta_set_state(worker->meta, STATE_SENDING);
 
         ++worker->meta->current_count;
-        const char* str = string_get_cstr(data);
+        const char* str = furi_string_get_cstr(data);
 
         // it's not fancy, but it works for now :)
-        string_reset(worker->meta->prev_3_path);
-        string_set_str(worker->meta->prev_3_path, string_get_cstr(worker->meta->prev_2_path));
-        string_reset(worker->meta->prev_2_path);
-        string_set_str(worker->meta->prev_2_path, string_get_cstr(worker->meta->prev_1_path));
-        string_reset(worker->meta->prev_1_path);
-        string_set_str(worker->meta->prev_1_path, string_get_cstr(worker->meta->prev_0_path));
-        string_reset(worker->meta->prev_0_path);
-        string_set_str(worker->meta->prev_0_path, str);
+        furi_string_reset(worker->meta->prev_3_path);
+        furi_string_set(
+            worker->meta->prev_3_path, furi_string_get_cstr(worker->meta->prev_2_path));
+        furi_string_reset(worker->meta->prev_2_path);
+        furi_string_set(
+            worker->meta->prev_2_path, furi_string_get_cstr(worker->meta->prev_1_path));
+        furi_string_reset(worker->meta->prev_1_path);
+        furi_string_set(
+            worker->meta->prev_1_path, furi_string_get_cstr(worker->meta->prev_0_path));
+        furi_string_reset(worker->meta->prev_0_path);
+        furi_string_set(worker->meta->prev_0_path, str);
         view_port_update(worker->meta->view_port);
 
         for(int i = 0; i < 1; i++) {
@@ -285,8 +288,8 @@ static int32_t playlist_worker_thread(void* ctx) {
     FlipperFormat* fff_head = flipper_format_file_alloc(storage);
 
     PlaylistWorker* worker = ctx;
-    if(!flipper_format_file_open_existing(fff_head, string_get_cstr(worker->file_path))) {
-        FURI_LOG_E(TAG, "Failed to open %s", string_get_cstr(worker->file_path));
+    if(!flipper_format_file_open_existing(fff_head, furi_string_get_cstr(worker->file_path))) {
+        FURI_LOG_E(TAG, "Failed to open %s", furi_string_get_cstr(worker->file_path));
         worker->is_running = false;
 
         furi_record_close(RECORD_STORAGE);
@@ -297,10 +300,12 @@ static int32_t playlist_worker_thread(void* ctx) {
     playlist_worker_wait_pause(worker);
     FlipperFormat* fff_data = flipper_format_string_alloc();
 
-    string_t data, preset, protocol;
-    string_init(data);
-    string_init(preset);
-    string_init(protocol);
+    FuriString* data;
+    FuriString* preset;
+    FuriString* protocol;
+    data = furi_string_alloc();
+    preset = furi_string_alloc();
+    protocol = furi_string_alloc();
 
     for(int i = 0; i < MAX(1, worker->meta->playlist_repetitions); i++) {
         // infinite repetitions if playlist_repetitions is 0
@@ -330,9 +335,9 @@ static int32_t playlist_worker_thread(void* ctx) {
     furi_record_close(RECORD_STORAGE);
     flipper_format_free(fff_head);
 
-    string_clear(data);
-    string_clear(preset);
-    string_clear(protocol);
+    furi_string_free(data);
+    furi_string_free(preset);
+    furi_string_free(protocol);
 
     flipper_format_free(fff_data);
 
@@ -351,18 +356,18 @@ void playlist_meta_reset(DisplayMeta* instance) {
     instance->current_count = 0;
     instance->current_playlist_repetition = 0;
 
-    string_reset(instance->prev_0_path);
-    string_reset(instance->prev_1_path);
-    string_reset(instance->prev_2_path);
-    string_reset(instance->prev_3_path);
+    furi_string_reset(instance->prev_0_path);
+    furi_string_reset(instance->prev_1_path);
+    furi_string_reset(instance->prev_2_path);
+    furi_string_reset(instance->prev_3_path);
 }
 
 DisplayMeta* playlist_meta_alloc() {
     DisplayMeta* instance = malloc(sizeof(DisplayMeta));
-    string_init(instance->prev_0_path);
-    string_init(instance->prev_1_path);
-    string_init(instance->prev_2_path);
-    string_init(instance->prev_3_path);
+    instance->prev_0_path = furi_string_alloc();
+    instance->prev_1_path = furi_string_alloc();
+    instance->prev_2_path = furi_string_alloc();
+    instance->prev_3_path = furi_string_alloc();
     playlist_meta_reset(instance);
     instance->state = STATE_NONE;
     instance->playlist_repetitions = 1;
@@ -370,10 +375,10 @@ DisplayMeta* playlist_meta_alloc() {
 }
 
 void playlist_meta_free(DisplayMeta* instance) {
-    string_clear(instance->prev_0_path);
-    string_clear(instance->prev_1_path);
-    string_clear(instance->prev_2_path);
-    string_clear(instance->prev_3_path);
+    furi_string_free(instance->prev_0_path);
+    furi_string_free(instance->prev_1_path);
+    furi_string_free(instance->prev_2_path);
+    furi_string_free(instance->prev_3_path);
     free(instance);
 }
 
@@ -391,7 +396,7 @@ PlaylistWorker* playlist_worker_alloc(DisplayMeta* meta) {
     instance->meta = meta;
     instance->ctl_pause = true; // require the user to manually start the worker
 
-    string_init(instance->file_path);
+    instance->file_path = furi_string_alloc();
 
     return instance;
 }
@@ -399,7 +404,7 @@ PlaylistWorker* playlist_worker_alloc(DisplayMeta* meta) {
 void playlist_worker_free(PlaylistWorker* instance) {
     furi_assert(instance);
     furi_thread_free(instance->thread);
-    string_clear(instance->file_path);
+    furi_string_free(instance->file_path);
     free(instance);
 }
 
@@ -420,7 +425,7 @@ void playlist_worker_start(PlaylistWorker* instance, const char* file_path) {
     furi_assert(instance);
     furi_assert(!instance->is_running);
 
-    string_set_str(instance->file_path, file_path);
+    furi_string_set(instance->file_path, file_path);
     instance->is_running = true;
 
     // reset meta (current/total)
@@ -440,8 +445,8 @@ static void render_callback(Canvas* canvas, void* ctx) {
     canvas_set_color(canvas, ColorBlack);
     canvas_set_font(canvas, FontSecondary);
 
-    string_t temp_str;
-    string_init(temp_str);
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
 
     switch(app->meta->state) {
     case STATE_NONE:
@@ -456,24 +461,26 @@ static void render_callback(Canvas* canvas, void* ctx) {
             path_extract_filename(app->file_path, temp_str, true);
 
             canvas_set_font(canvas, FontPrimary);
-            draw_centered_boxed_str(canvas, 1, 1, 15, 6, string_get_cstr(temp_str));
+            draw_centered_boxed_str(canvas, 1, 1, 15, 6, furi_string_get_cstr(temp_str));
         }
 
         canvas_set_font(canvas, FontSecondary);
 
         // draw loaded count
         {
-            string_printf(temp_str, "%d Items in playlist", app->meta->total_count);
-            canvas_draw_str_aligned(canvas, 1, 19, AlignLeft, AlignTop, string_get_cstr(temp_str));
+            furi_string_printf(temp_str, "%d Items in playlist", app->meta->total_count);
+            canvas_draw_str_aligned(
+                canvas, 1, 19, AlignLeft, AlignTop, furi_string_get_cstr(temp_str));
 
             if(app->meta->playlist_repetitions <= 0) {
-                string_printf(temp_str, "Repeat: inf", app->meta->playlist_repetitions);
+                furi_string_set(temp_str, "Repeat: inf");
             } else if(app->meta->playlist_repetitions == 1) {
-                string_printf(temp_str, "Repeat: no", app->meta->playlist_repetitions);
+                furi_string_set(temp_str, "Repeat: no");
             } else {
-                string_printf(temp_str, "Repeat: %dx", app->meta->playlist_repetitions);
+                furi_string_printf(temp_str, "Repeat: %dx", app->meta->playlist_repetitions);
             }
-            canvas_draw_str_aligned(canvas, 1, 29, AlignLeft, AlignTop, string_get_cstr(temp_str));
+            canvas_draw_str_aligned(
+                canvas, 1, 29, AlignLeft, AlignTop, furi_string_get_cstr(temp_str));
         }
 
         // draw buttons
@@ -511,11 +518,12 @@ static void render_callback(Canvas* canvas, void* ctx) {
         // draw progress text
         {
             canvas_set_font(canvas, FontSecondary);
-            string_printf(temp_str, "[%d/%d]", app->meta->current_count, app->meta->total_count);
+            furi_string_printf(
+                temp_str, "[%d/%d]", app->meta->current_count, app->meta->total_count);
             canvas_draw_str_aligned(
-                canvas, 11, HEIGHT - 8, AlignLeft, AlignTop, string_get_cstr(temp_str));
+                canvas, 11, HEIGHT - 8, AlignLeft, AlignTop, furi_string_get_cstr(temp_str));
 
-            int h = canvas_string_width(canvas, string_get_cstr(temp_str));
+            int h = canvas_string_width(canvas, furi_string_get_cstr(temp_str));
             int xs = 11 + h + 2;
             int w = WIDTH - xs - 1;
             canvas_draw_box(canvas, xs, HEIGHT - 5, w, 1);
@@ -527,20 +535,20 @@ static void render_callback(Canvas* canvas, void* ctx) {
 
         {
             if(app->meta->playlist_repetitions <= 0) {
-                string_printf(temp_str, "[%d/Inf]", app->meta->current_playlist_repetition);
+                furi_string_printf(temp_str, "[%d/Inf]", app->meta->current_playlist_repetition);
             } else {
-                string_printf(
+                furi_string_printf(
                     temp_str,
                     "[%d/%d]",
                     app->meta->current_playlist_repetition,
                     app->meta->playlist_repetitions);
             }
             canvas_set_color(canvas, ColorBlack);
-            int w = canvas_string_width(canvas, string_get_cstr(temp_str));
+            int w = canvas_string_width(canvas, furi_string_get_cstr(temp_str));
             draw_corner_aligned(canvas, w + 6, 13, AlignRight, AlignTop);
             canvas_set_color(canvas, ColorWhite);
             canvas_draw_str_aligned(
-                canvas, WIDTH - 3, 3, AlignRight, AlignTop, string_get_cstr(temp_str));
+                canvas, WIDTH - 3, 3, AlignRight, AlignTop, furi_string_get_cstr(temp_str));
         }
 
         // draw last and current file
@@ -549,41 +557,41 @@ static void render_callback(Canvas* canvas, void* ctx) {
             canvas_set_font(canvas, FontSecondary);
 
             // current
-            if(!string_empty_p(app->meta->prev_0_path)) {
+            if(!furi_string_empty(app->meta->prev_0_path)) {
                 path_extract_filename(app->meta->prev_0_path, temp_str, true);
-                int w = canvas_string_width(canvas, string_get_cstr(temp_str));
+                int w = canvas_string_width(canvas, furi_string_get_cstr(temp_str));
                 canvas_set_color(canvas, ColorBlack);
                 canvas_draw_rbox(canvas, 1, 1, w + 4, 12, 2);
                 canvas_set_color(canvas, ColorWhite);
                 canvas_draw_str_aligned(
-                    canvas, 3, 3, AlignLeft, AlignTop, string_get_cstr(temp_str));
+                    canvas, 3, 3, AlignLeft, AlignTop, furi_string_get_cstr(temp_str));
             }
 
             // last 3
             canvas_set_color(canvas, ColorBlack);
 
-            if(!string_empty_p(app->meta->prev_1_path)) {
+            if(!furi_string_empty(app->meta->prev_1_path)) {
                 path_extract_filename(app->meta->prev_1_path, temp_str, true);
                 canvas_draw_str_aligned(
-                    canvas, 3, 15, AlignLeft, AlignTop, string_get_cstr(temp_str));
+                    canvas, 3, 15, AlignLeft, AlignTop, furi_string_get_cstr(temp_str));
             }
 
-            if(!string_empty_p(app->meta->prev_2_path)) {
+            if(!furi_string_empty(app->meta->prev_2_path)) {
                 path_extract_filename(app->meta->prev_2_path, temp_str, true);
                 canvas_draw_str_aligned(
-                    canvas, 3, 26, AlignLeft, AlignTop, string_get_cstr(temp_str));
+                    canvas, 3, 26, AlignLeft, AlignTop, furi_string_get_cstr(temp_str));
             }
 
-            if(!string_empty_p(app->meta->prev_3_path)) {
+            if(!furi_string_empty(app->meta->prev_3_path)) {
                 path_extract_filename(app->meta->prev_3_path, temp_str, true);
                 canvas_draw_str_aligned(
-                    canvas, 3, 37, AlignLeft, AlignTop, string_get_cstr(temp_str));
+                    canvas, 3, 37, AlignLeft, AlignTop, furi_string_get_cstr(temp_str));
             }
         }
         break;
     }
 
-    string_clear(temp_str);
+    furi_string_free(temp_str);
     furi_mutex_release(app->mutex);
 }
 
@@ -596,8 +604,8 @@ static void input_callback(InputEvent* event, void* ctx) {
 
 Playlist* playlist_alloc(DisplayMeta* meta) {
     Playlist* app = malloc(sizeof(Playlist));
-    string_init(app->file_path);
-    string_set_str(app->file_path, PLAYLIST_FOLDER);
+    app->file_path = furi_string_alloc();
+    furi_string_set(app->file_path, PLAYLIST_FOLDER);
 
     app->meta = meta;
     app->worker = NULL;
@@ -623,15 +631,15 @@ void playlist_start_worker(Playlist* app, DisplayMeta* meta) {
     // count playlist items
     Storage* storage = furi_record_open(RECORD_STORAGE);
     app->meta->total_count =
-        playlist_count_playlist_items(storage, string_get_cstr(app->file_path));
+        playlist_count_playlist_items(storage, furi_string_get_cstr(app->file_path));
     furi_record_close(RECORD_STORAGE);
 
     // start thread
-    playlist_worker_start(app->worker, string_get_cstr(app->file_path));
+    playlist_worker_start(app->worker, furi_string_get_cstr(app->file_path));
 }
 
 void playlist_free(Playlist* app) {
-    string_clear(app->file_path);
+    furi_string_free(app->file_path);
 
     gui_remove_view_port(app->gui, app->view_port);
     furi_record_close(RECORD_GUI);
@@ -715,7 +723,7 @@ int32_t playlist_app(void* p) {
                 if(!app->worker->is_running) {
                     app->worker->ctl_pause = false;
                     app->worker->ctl_request_exit = false;
-                    playlist_worker_start(app->worker, string_get_cstr(app->file_path));
+                    playlist_worker_start(app->worker, furi_string_get_cstr(app->file_path));
                 } else {
                     app->worker->ctl_pause = !app->worker->ctl_pause;
                 }

applications/plugins/playlist/playlist_file.c

@@ -9,13 +9,13 @@ int playlist_count_playlist_items(Storage* storage, const char* file_path) {
         return -1;
     }
     int count = 0;
-    string_t data;
-    string_init(data);
+    FuriString* data;
+    data = furi_string_alloc();
     while(flipper_format_read_string(format, "sub", data)) {
         ++count;
     }
     flipper_format_file_close(format);
     flipper_format_free(format);
-    string_clear(data);
+    furi_string_free(data);
     return count;
 }

applications/plugins/sentry_safe/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="sentry_safe",
+    appid="GPIO_Sentry_Safe",
     name="[GPIO] Sentry Safe",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="sentry_safe_app",

applications/plugins/signal_generator/application.fam

@@ -0,0 +1,12 @@
+App(
+    appid="Signal_Generator",
+    name="Signal Generator",
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="signal_gen_app",
+    cdefines=["APP_SIGNAL_GEN"],
+    requires=["gui"],
+    stack_size=1 * 1024,
+    order=50,
+    fap_icon="signal_gen_10px.png",
+    fap_category="Tools",
+)

applications/plugins/signal_generator/scenes/signal_gen_scene.c

@@ -0,0 +1,30 @@
+#include "../signal_gen_app_i.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const signal_gen_scene_on_enter_handlers[])(void*) = {
+#include "signal_gen_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
+bool (*const signal_gen_scene_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "signal_gen_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
+void (*const signal_gen_scene_on_exit_handlers[])(void* context) = {
+#include "signal_gen_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers signal_gen_scene_handlers = {
+    .on_enter_handlers = signal_gen_scene_on_enter_handlers,
+    .on_event_handlers = signal_gen_scene_on_event_handlers,
+    .on_exit_handlers = signal_gen_scene_on_exit_handlers,
+    .scene_num = SignalGenSceneNum,
+};

applications/plugins/signal_generator/scenes/signal_gen_scene.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) SignalGenScene##id,
+typedef enum {
+#include "signal_gen_scene_config.h"
+    SignalGenSceneNum,
+} SignalGenScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers signal_gen_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "signal_gen_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_event handlers declaration
+#define ADD_SCENE(prefix, name, id) \
+    bool prefix##_scene_##name##_on_event(void* context, SceneManagerEvent event);
+#include "signal_gen_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* context);
+#include "signal_gen_scene_config.h"
+#undef ADD_SCENE

applications/plugins/signal_generator/scenes/signal_gen_scene_config.h

@@ -0,0 +1,3 @@
+ADD_SCENE(signal_gen, start, Start)
+ADD_SCENE(signal_gen, pwm, Pwm)
+ADD_SCENE(signal_gen, mco, Mco)

applications/plugins/signal_generator/scenes/signal_gen_scene_mco.c

@@ -0,0 +1,145 @@
+#include "../signal_gen_app_i.h"
+
+typedef enum {
+    LineIndexPin,
+    LineIndexSource,
+    LineIndexDivision,
+} LineIndex;
+
+static const char* const mco_pin_names[] = {
+    "13(Tx)",
+};
+
+static const char* const mco_source_names[] = {
+    "32768Hz",
+    "64MHz",
+    "~100K",
+    "~200K",
+    "~400K",
+    "~800K",
+    "~1MHz",
+    "~2MHz",
+    "~4MHz",
+    "~8MHz",
+    "~16MHz",
+    "~24MHz",
+    "~32MHz",
+    "~48MHz",
+};
+
+static const FuriHalClockMcoSourceId mco_sources[] = {
+    FuriHalClockMcoLse,
+    FuriHalClockMcoSysclk,
+    FuriHalClockMcoMsi100k,
+    FuriHalClockMcoMsi200k,
+    FuriHalClockMcoMsi400k,
+    FuriHalClockMcoMsi800k,
+    FuriHalClockMcoMsi1m,
+    FuriHalClockMcoMsi2m,
+    FuriHalClockMcoMsi4m,
+    FuriHalClockMcoMsi8m,
+    FuriHalClockMcoMsi16m,
+    FuriHalClockMcoMsi24m,
+    FuriHalClockMcoMsi32m,
+    FuriHalClockMcoMsi48m,
+};
+
+static const char* const mco_divisor_names[] = {
+    "1",
+    "2",
+    "4",
+    "8",
+    "16",
+};
+
+static const FuriHalClockMcoDivisorId mco_divisors[] = {
+    FuriHalClockMcoDiv1,
+    FuriHalClockMcoDiv2,
+    FuriHalClockMcoDiv4,
+    FuriHalClockMcoDiv8,
+    FuriHalClockMcoDiv16,
+};
+
+static void mco_source_list_change_callback(VariableItem* item) {
+    SignalGenApp* app = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, mco_source_names[index]);
+
+    app->mco_src = mco_sources[index];
+
+    view_dispatcher_send_custom_event(app->view_dispatcher, SignalGenMcoEventUpdate);
+}
+
+static void mco_divisor_list_change_callback(VariableItem* item) {
+    SignalGenApp* app = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, mco_divisor_names[index]);
+
+    app->mco_div = mco_divisors[index];
+
+    view_dispatcher_send_custom_event(app->view_dispatcher, SignalGenMcoEventUpdate);
+}
+
+void signal_gen_scene_mco_on_enter(void* context) {
+    SignalGenApp* app = context;
+    VariableItemList* var_item_list = app->var_item_list;
+
+    VariableItem* item;
+
+    item = variable_item_list_add(var_item_list, "GPIO Pin", COUNT_OF(mco_pin_names), NULL, NULL);
+    variable_item_set_current_value_index(item, 0);
+    variable_item_set_current_value_text(item, mco_pin_names[0]);
+
+    item = variable_item_list_add(
+        var_item_list,
+        "Frequency",
+        COUNT_OF(mco_source_names),
+        mco_source_list_change_callback,
+        app);
+    variable_item_set_current_value_index(item, 0);
+    variable_item_set_current_value_text(item, mco_source_names[0]);
+
+    item = variable_item_list_add(
+        var_item_list,
+        "Freq. divider",
+        COUNT_OF(mco_divisor_names),
+        mco_divisor_list_change_callback,
+        app);
+    variable_item_set_current_value_index(item, 0);
+    variable_item_set_current_value_text(item, mco_divisor_names[0]);
+
+    variable_item_list_set_selected_item(var_item_list, LineIndexSource);
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, SignalGenViewVarItemList);
+
+    app->mco_src = FuriHalClockMcoLse;
+    app->mco_div = FuriHalClockMcoDiv1;
+    furi_hal_clock_mco_enable(app->mco_src, app->mco_div);
+    furi_hal_gpio_init_ex(
+        &gpio_usart_tx, GpioModeAltFunctionPushPull, GpioPullUp, GpioSpeedVeryHigh, GpioAltFn0MCO);
+}
+
+bool signal_gen_scene_mco_on_event(void* context, SceneManagerEvent event) {
+    SignalGenApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SignalGenMcoEventUpdate) {
+            consumed = true;
+            furi_hal_clock_mco_enable(app->mco_src, app->mco_div);
+        }
+    }
+    return consumed;
+}
+
+void signal_gen_scene_mco_on_exit(void* context) {
+    SignalGenApp* app = context;
+    variable_item_list_reset(app->var_item_list);
+    furi_hal_gpio_init_ex(
+        &gpio_usart_tx,
+        GpioModeAltFunctionPushPull,
+        GpioPullUp,
+        GpioSpeedVeryHigh,
+        GpioAltFn7USART1);
+    furi_hal_clock_mco_disable();
+}

applications/plugins/signal_generator/scenes/signal_gen_scene_pwm.c

@@ -0,0 +1,60 @@
+#include "../signal_gen_app_i.h"
+
+static const FuriHalPwmOutputId pwm_ch_id[] = {
+    FuriHalPwmOutputIdTim1PA7,
+    FuriHalPwmOutputIdLptim2PA4,
+};
+
+#define DEFAULT_FREQ 1000
+#define DEFAULT_DUTY 50
+
+static void
+    signal_gen_pwm_callback(uint8_t channel_id, uint32_t freq, uint8_t duty, void* context) {
+    SignalGenApp* app = context;
+
+    app->pwm_freq = freq;
+    app->pwm_duty = duty;
+
+    if(app->pwm_ch != pwm_ch_id[channel_id]) {
+        app->pwm_ch_prev = app->pwm_ch;
+        app->pwm_ch = pwm_ch_id[channel_id];
+        view_dispatcher_send_custom_event(app->view_dispatcher, SignalGenPwmEventChannelChange);
+    } else {
+        app->pwm_ch = pwm_ch_id[channel_id];
+        view_dispatcher_send_custom_event(app->view_dispatcher, SignalGenPwmEventUpdate);
+    }
+}
+
+void signal_gen_scene_pwm_on_enter(void* context) {
+    SignalGenApp* app = context;
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, SignalGenViewPwm);
+
+    signal_gen_pwm_set_callback(app->pwm_view, signal_gen_pwm_callback, app);
+
+    signal_gen_pwm_set_params(app->pwm_view, 0, DEFAULT_FREQ, DEFAULT_DUTY);
+    furi_hal_pwm_start(pwm_ch_id[0], DEFAULT_FREQ, DEFAULT_DUTY);
+}
+
+bool signal_gen_scene_pwm_on_event(void* context, SceneManagerEvent event) {
+    SignalGenApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SignalGenPwmEventUpdate) {
+            consumed = true;
+            furi_hal_pwm_set_params(app->pwm_ch, app->pwm_freq, app->pwm_duty);
+        } else if(event.event == SignalGenPwmEventChannelChange) {
+            consumed = true;
+            furi_hal_pwm_stop(app->pwm_ch_prev);
+            furi_hal_pwm_start(app->pwm_ch, app->pwm_freq, app->pwm_duty);
+        }
+    }
+    return consumed;
+}
+
+void signal_gen_scene_pwm_on_exit(void* context) {
+    SignalGenApp* app = context;
+    variable_item_list_reset(app->var_item_list);
+    furi_hal_pwm_stop(app->pwm_ch);
+}

applications/plugins/signal_generator/scenes/signal_gen_scene_start.c

@@ -0,0 +1,55 @@
+#include "../signal_gen_app_i.h"
+
+typedef enum {
+    SubmenuIndexPwm,
+    SubmenuIndexClockOutput,
+} SubmenuIndex;
+
+void signal_gen_scene_start_submenu_callback(void* context, uint32_t index) {
+    SignalGenApp* app = context;
+
+    view_dispatcher_send_custom_event(app->view_dispatcher, index);
+}
+
+void signal_gen_scene_start_on_enter(void* context) {
+    SignalGenApp* app = context;
+    Submenu* submenu = app->submenu;
+
+    submenu_add_item(
+        submenu, "PWM Generator", SubmenuIndexPwm, signal_gen_scene_start_submenu_callback, app);
+    submenu_add_item(
+        submenu,
+        "Clock Generator",
+        SubmenuIndexClockOutput,
+        signal_gen_scene_start_submenu_callback,
+        app);
+
+    submenu_set_selected_item(
+        submenu, scene_manager_get_scene_state(app->scene_manager, SignalGenSceneStart));
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, SignalGenViewSubmenu);
+}
+
+bool signal_gen_scene_start_on_event(void* context, SceneManagerEvent event) {
+    SignalGenApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexPwm) {
+            scene_manager_next_scene(app->scene_manager, SignalGenScenePwm);
+            consumed = true;
+        } else if(event.event == SubmenuIndexClockOutput) {
+            scene_manager_next_scene(app->scene_manager, SignalGenSceneMco);
+            consumed = true;
+        }
+        scene_manager_set_scene_state(app->scene_manager, SignalGenSceneStart, event.event);
+    }
+
+    return consumed;
+}
+
+void signal_gen_scene_start_on_exit(void* context) {
+    SignalGenApp* app = context;
+
+    submenu_reset(app->submenu);
+}

applications/plugins/signal_generator/signal_gen_app.c

@@ -0,0 +1,93 @@
+#include "signal_gen_app_i.h"
+
+#include <furi.h>
+#include <furi_hal.h>
+
+static bool signal_gen_app_custom_event_callback(void* context, uint32_t event) {
+    furi_assert(context);
+    SignalGenApp* app = context;
+    return scene_manager_handle_custom_event(app->scene_manager, event);
+}
+
+static bool signal_gen_app_back_event_callback(void* context) {
+    furi_assert(context);
+    SignalGenApp* app = context;
+    return scene_manager_handle_back_event(app->scene_manager);
+}
+
+static void signal_gen_app_tick_event_callback(void* context) {
+    furi_assert(context);
+    SignalGenApp* app = context;
+    scene_manager_handle_tick_event(app->scene_manager);
+}
+
+SignalGenApp* signal_gen_app_alloc() {
+    SignalGenApp* app = malloc(sizeof(SignalGenApp));
+
+    app->gui = furi_record_open(RECORD_GUI);
+
+    app->view_dispatcher = view_dispatcher_alloc();
+    app->scene_manager = scene_manager_alloc(&signal_gen_scene_handlers, app);
+    view_dispatcher_enable_queue(app->view_dispatcher);
+    view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
+
+    view_dispatcher_set_custom_event_callback(
+        app->view_dispatcher, signal_gen_app_custom_event_callback);
+    view_dispatcher_set_navigation_event_callback(
+        app->view_dispatcher, signal_gen_app_back_event_callback);
+    view_dispatcher_set_tick_event_callback(
+        app->view_dispatcher, signal_gen_app_tick_event_callback, 100);
+
+    view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
+
+    app->var_item_list = variable_item_list_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        SignalGenViewVarItemList,
+        variable_item_list_get_view(app->var_item_list));
+
+    app->submenu = submenu_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, SignalGenViewSubmenu, submenu_get_view(app->submenu));
+
+    app->pwm_view = signal_gen_pwm_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, SignalGenViewPwm, signal_gen_pwm_get_view(app->pwm_view));
+
+    scene_manager_next_scene(app->scene_manager, SignalGenSceneStart);
+
+    return app;
+}
+
+void signal_gen_app_free(SignalGenApp* app) {
+    furi_assert(app);
+
+    // Views
+    view_dispatcher_remove_view(app->view_dispatcher, SignalGenViewVarItemList);
+    view_dispatcher_remove_view(app->view_dispatcher, SignalGenViewSubmenu);
+    view_dispatcher_remove_view(app->view_dispatcher, SignalGenViewPwm);
+
+    submenu_free(app->submenu);
+    variable_item_list_free(app->var_item_list);
+    signal_gen_pwm_free(app->pwm_view);
+
+    // View dispatcher
+    view_dispatcher_free(app->view_dispatcher);
+    scene_manager_free(app->scene_manager);
+
+    // Close records
+    furi_record_close(RECORD_GUI);
+
+    free(app);
+}
+
+int32_t signal_gen_app(void* p) {
+    UNUSED(p);
+    SignalGenApp* signal_gen_app = signal_gen_app_alloc();
+
+    view_dispatcher_run(signal_gen_app->view_dispatcher);
+
+    signal_gen_app_free(signal_gen_app);
+
+    return 0;
+}

applications/plugins/signal_generator/signal_gen_app_i.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "scenes/signal_gen_scene.h"
+
+#include "furi_hal_clock.h"
+#include "furi_hal_pwm.h"
+
+#include <gui/gui.h>
+#include <gui/view_dispatcher.h>
+#include <gui/scene_manager.h>
+#include <gui/modules/submenu.h>
+#include <gui/modules/variable_item_list.h>
+#include <gui/modules/submenu.h>
+#include "views/signal_gen_pwm.h"
+
+typedef struct SignalGenApp SignalGenApp;
+
+struct SignalGenApp {
+    Gui* gui;
+    ViewDispatcher* view_dispatcher;
+    SceneManager* scene_manager;
+
+    VariableItemList* var_item_list;
+    Submenu* submenu;
+    SignalGenPwm* pwm_view;
+
+    FuriHalClockMcoSourceId mco_src;
+    FuriHalClockMcoDivisorId mco_div;
+
+    FuriHalPwmOutputId pwm_ch_prev;
+    FuriHalPwmOutputId pwm_ch;
+    uint32_t pwm_freq;
+    uint8_t pwm_duty;
+};
+
+typedef enum {
+    SignalGenViewVarItemList,
+    SignalGenViewSubmenu,
+    SignalGenViewPwm,
+} SignalGenAppView;
+
+typedef enum {
+    SignalGenMcoEventUpdate,
+    SignalGenPwmEventUpdate,
+    SignalGenPwmEventChannelChange,
+} SignalGenCustomEvent;

applications/plugins/signal_generator/views/signal_gen_pwm.c

@@ -0,0 +1,301 @@
+#include "../signal_gen_app_i.h"
+#include "furi_hal.h"
+#include <gui/elements.h>
+
+typedef enum {
+    LineIndexChannel,
+    LineIndexFrequency,
+    LineIndexDuty,
+    LineIndexTotalCount
+} LineIndex;
+
+static const char* const pwm_ch_names[] = {"2(A7)", "4(A4)"};
+
+struct SignalGenPwm {
+    View* view;
+    SignalGenPwmViewCallback callback;
+    void* context;
+};
+
+typedef struct {
+    LineIndex line_sel;
+    bool edit_mode;
+    uint8_t edit_digit;
+
+    uint8_t channel_id;
+    uint32_t freq;
+    uint8_t duty;
+
+} SignalGenPwmViewModel;
+
+#define ITEM_H 64 / 3
+#define ITEM_W 128
+
+#define VALUE_X 100
+#define VALUE_W 45
+
+#define FREQ_VALUE_X 62
+#define FREQ_MAX 1000000UL
+#define FREQ_DIGITS_NB 7
+
+static void pwm_set_config(SignalGenPwm* pwm) {
+    FuriHalPwmOutputId channel;
+    uint32_t freq;
+    uint8_t duty;
+
+    with_view_model(
+        pwm->view, (SignalGenPwmViewModel * model) {
+            channel = model->channel_id;
+            freq = model->freq;
+            duty = model->duty;
+            return false;
+        });
+
+    furi_assert(pwm->callback);
+    pwm->callback(channel, freq, duty, pwm->context);
+}
+
+static void pwm_channel_change(SignalGenPwmViewModel* model, InputEvent* event) {
+    if(event->key == InputKeyLeft) {
+        if(model->channel_id > 0) {
+            model->channel_id--;
+        }
+    } else if(event->key == InputKeyRight) {
+        if(model->channel_id < (COUNT_OF(pwm_ch_names) - 1)) {
+            model->channel_id++;
+        }
+    }
+}
+
+static void pwm_duty_change(SignalGenPwmViewModel* model, InputEvent* event) {
+    if(event->key == InputKeyLeft) {
+        if(model->duty > 0) {
+            model->duty--;
+        }
+    } else if(event->key == InputKeyRight) {
+        if(model->duty < 100) {
+            model->duty++;
+        }
+    }
+}
+
+static bool pwm_freq_edit(SignalGenPwmViewModel* model, InputEvent* event) {
+    bool consumed = false;
+    if((event->type == InputTypeShort) || (event->type == InputTypeRepeat)) {
+        if(event->key == InputKeyRight) {
+            if(model->edit_digit > 0) {
+                model->edit_digit--;
+            }
+            consumed = true;
+        } else if(event->key == InputKeyLeft) {
+            if(model->edit_digit < (FREQ_DIGITS_NB - 1)) {
+                model->edit_digit++;
+            }
+            consumed = true;
+        } else if(event->key == InputKeyUp) {
+            uint32_t step = 1;
+            for(uint8_t i = 0; i < model->edit_digit; i++) {
+                step *= 10;
+            }
+            if((model->freq + step) < FREQ_MAX) {
+                model->freq += step;
+            } else {
+                model->freq = FREQ_MAX;
+            }
+            consumed = true;
+        } else if(event->key == InputKeyDown) {
+            uint32_t step = 1;
+            for(uint8_t i = 0; i < model->edit_digit; i++) {
+                step *= 10;
+            }
+            if(model->freq > (step + 1)) {
+                model->freq -= step;
+            } else {
+                model->freq = 1;
+            }
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+static void signal_gen_pwm_draw_callback(Canvas* canvas, void* _model) {
+    SignalGenPwmViewModel* model = _model;
+    char* line_label = NULL;
+    char val_text[16];
+
+    for(uint8_t line = 0; line < LineIndexTotalCount; line++) {
+        if(line == LineIndexChannel) {
+            line_label = "GPIO Pin";
+        } else if(line == LineIndexFrequency) {
+            line_label = "Frequency";
+        } else if(line == LineIndexDuty) {
+            line_label = "Pulse width";
+        }
+
+        canvas_set_color(canvas, ColorBlack);
+        if(line == model->line_sel) {
+            elements_slightly_rounded_box(canvas, 0, ITEM_H * line + 1, ITEM_W, ITEM_H - 1);
+            canvas_set_color(canvas, ColorWhite);
+        }
+
+        uint8_t text_y = ITEM_H * line + ITEM_H / 2 + 2;
+
+        canvas_draw_str_aligned(canvas, 6, text_y, AlignLeft, AlignCenter, line_label);
+
+        if(line == LineIndexChannel) {
+            snprintf(val_text, sizeof(val_text), "%s", pwm_ch_names[model->channel_id]);
+            canvas_draw_str_aligned(canvas, VALUE_X, text_y, AlignCenter, AlignCenter, val_text);
+            if(model->channel_id != 0) {
+                canvas_draw_str_aligned(
+                    canvas, VALUE_X - VALUE_W / 2, text_y, AlignCenter, AlignCenter, "<");
+            }
+            if(model->channel_id != (COUNT_OF(pwm_ch_names) - 1)) {
+                canvas_draw_str_aligned(
+                    canvas, VALUE_X + VALUE_W / 2, text_y, AlignCenter, AlignCenter, ">");
+            }
+        } else if(line == LineIndexFrequency) {
+            snprintf(val_text, sizeof(val_text), "%7lu Hz", model->freq);
+            canvas_set_font(canvas, FontKeyboard);
+            canvas_draw_str_aligned(
+                canvas, FREQ_VALUE_X, text_y, AlignLeft, AlignCenter, val_text);
+            canvas_set_font(canvas, FontSecondary);
+
+            if(model->edit_mode) {
+                uint8_t icon_x = (FREQ_VALUE_X) + (FREQ_DIGITS_NB - model->edit_digit - 1) * 6;
+                canvas_draw_icon(canvas, icon_x, text_y - 9, &I_SmallArrowUp_3x5);
+                canvas_draw_icon(canvas, icon_x, text_y + 5, &I_SmallArrowDown_3x5);
+            }
+        } else if(line == LineIndexDuty) {
+            snprintf(val_text, sizeof(val_text), "%d%%", model->duty);
+            canvas_draw_str_aligned(canvas, VALUE_X, text_y, AlignCenter, AlignCenter, val_text);
+            if(model->duty != 0) {
+                canvas_draw_str_aligned(
+                    canvas, VALUE_X - VALUE_W / 2, text_y, AlignCenter, AlignCenter, "<");
+            }
+            if(model->duty != 100) {
+                canvas_draw_str_aligned(
+                    canvas, VALUE_X + VALUE_W / 2, text_y, AlignCenter, AlignCenter, ">");
+            }
+        }
+    }
+}
+
+static bool signal_gen_pwm_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    SignalGenPwm* pwm = context;
+    bool consumed = false;
+    bool need_update = false;
+
+    with_view_model(
+        pwm->view, (SignalGenPwmViewModel * model) {
+            if(model->edit_mode == false) {
+                if((event->type == InputTypeShort) || (event->type == InputTypeRepeat)) {
+                    if(event->key == InputKeyUp) {
+                        if(model->line_sel == 0) {
+                            model->line_sel = LineIndexTotalCount - 1;
+                        } else {
+                            model->line_sel =
+                                CLAMP(model->line_sel - 1, LineIndexTotalCount - 1, 0);
+                        }
+                        consumed = true;
+                    } else if(event->key == InputKeyDown) {
+                        if(model->line_sel == LineIndexTotalCount - 1) {
+                            model->line_sel = 0;
+                        } else {
+                            model->line_sel =
+                                CLAMP(model->line_sel + 1, LineIndexTotalCount - 1, 0);
+                        }
+                        consumed = true;
+                    } else if((event->key == InputKeyLeft) || (event->key == InputKeyRight)) {
+                        if(model->line_sel == LineIndexChannel) {
+                            pwm_channel_change(model, event);
+                            need_update = true;
+                        } else if(model->line_sel == LineIndexDuty) {
+                            pwm_duty_change(model, event);
+                            need_update = true;
+                        } else if(model->line_sel == LineIndexFrequency) {
+                            model->edit_mode = true;
+                        }
+                        consumed = true;
+                    } else if(event->key == InputKeyOk) {
+                        if(model->line_sel == LineIndexFrequency) {
+                            model->edit_mode = true;
+                        }
+                        consumed = true;
+                    }
+                }
+            } else {
+                if((event->key == InputKeyOk) || (event->key == InputKeyBack)) {
+                    if(event->type == InputTypeShort) {
+                        model->edit_mode = false;
+                        consumed = true;
+                    }
+                } else {
+                    if(model->line_sel == LineIndexFrequency) {
+                        consumed = pwm_freq_edit(model, event);
+                        need_update = consumed;
+                    }
+                }
+            }
+            return true;
+        });
+
+    if(need_update) {
+        pwm_set_config(pwm);
+    }
+
+    return consumed;
+}
+
+SignalGenPwm* signal_gen_pwm_alloc() {
+    SignalGenPwm* pwm = malloc(sizeof(SignalGenPwm));
+
+    pwm->view = view_alloc();
+    view_allocate_model(pwm->view, ViewModelTypeLocking, sizeof(SignalGenPwmViewModel));
+    view_set_context(pwm->view, pwm);
+    view_set_draw_callback(pwm->view, signal_gen_pwm_draw_callback);
+    view_set_input_callback(pwm->view, signal_gen_pwm_input_callback);
+
+    return pwm;
+}
+
+void signal_gen_pwm_free(SignalGenPwm* pwm) {
+    furi_assert(pwm);
+    view_free(pwm->view);
+    free(pwm);
+}
+
+View* signal_gen_pwm_get_view(SignalGenPwm* pwm) {
+    furi_assert(pwm);
+    return pwm->view;
+}
+
+void signal_gen_pwm_set_callback(
+    SignalGenPwm* pwm,
+    SignalGenPwmViewCallback callback,
+    void* context) {
+    furi_assert(pwm);
+    furi_assert(callback);
+
+    with_view_model(
+        pwm->view, (SignalGenPwmViewModel * model) {
+            UNUSED(model);
+            pwm->callback = callback;
+            pwm->context = context;
+            return false;
+        });
+}
+
+void signal_gen_pwm_set_params(SignalGenPwm* pwm, uint8_t channel_id, uint32_t freq, uint8_t duty) {
+    with_view_model(
+        pwm->view, (SignalGenPwmViewModel * model) {
+            model->channel_id = channel_id;
+            model->freq = freq;
+            model->duty = duty;
+            return true;
+        });
+
+    furi_assert(pwm->callback);
+    pwm->callback(channel_id, freq, duty, pwm->context);
+}

applications/plugins/signal_generator/views/signal_gen_pwm.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <gui/view.h>
+#include "../signal_gen_app_i.h"
+
+typedef struct SignalGenPwm SignalGenPwm;
+typedef void (
+    *SignalGenPwmViewCallback)(uint8_t channel_id, uint32_t freq, uint8_t duty, void* context);
+
+SignalGenPwm* signal_gen_pwm_alloc();
+
+void signal_gen_pwm_free(SignalGenPwm* pwm);
+
+View* signal_gen_pwm_get_view(SignalGenPwm* pwm);
+
+void signal_gen_pwm_set_callback(
+    SignalGenPwm* pwm,
+    SignalGenPwmViewCallback callback,
+    void* context);
+
+void signal_gen_pwm_set_params(SignalGenPwm* pwm, uint8_t channel_id, uint32_t freq, uint8_t duty);

applications/plugins/snake_game/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="snake_game",
+    appid="Snake",
     name="Snake Game",
     apptype=FlipperAppType.PLUGIN,
     entry_point="snake_game_app",

applications/plugins/snake_game/snake_game.c

@@ -61,12 +61,32 @@ typedef struct {
     InputEvent input;
 } SnakeEvent;
 
-static const NotificationSequence sequence_short_vibro_and_sound = {
+const NotificationSequence sequence_fail = {
     &message_vibro_on,
-    &message_note_c5,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_vibro_off,
+    NULL,
+};
+
+const NotificationSequence sequence_eat = {
+    &message_note_c7,
     &message_delay_50,
     &message_sound_off,
-    &message_vibro_off,
     NULL,
 };
 
@@ -95,12 +115,6 @@ static void snake_game_render_callback(Canvas* const canvas, void* ctx) {
         canvas_draw_box(canvas, p.x, p.y, 4, 4);
     }
 
-    // Show score on the game field
-    if(snake_state->state != GameStateGameOver) {
-        char buffer2[6];
-        snprintf(buffer2, sizeof(buffer2), "%u", snake_state->len - 7);
-        canvas_draw_str_aligned(canvas, 124, 10, AlignRight, AlignBottom, buffer2);
-    }
     // Game Over banner
     if(snake_state->state == GameStateGameOver) {
         // Screen is 128x64 px
@@ -247,7 +261,8 @@ static void snake_game_move_snake(SnakeState* const snake_state, Point const nex
     snake_state->points[0] = next_step;
 }
 
-static void snake_game_process_game_step(SnakeState* const snake_state, NotificationApp* notify) {
+static void
+    snake_game_process_game_step(SnakeState* const snake_state, NotificationApp* notification) {
     if(snake_state->state == GameStateGameOver) {
         return;
     }
@@ -266,6 +281,7 @@ static void snake_game_process_game_step(SnakeState* const snake_state, Notifica
             return;
         } else if(snake_state->state == GameStateLastChance) {
             snake_state->state = GameStateGameOver;
+            notification_message_block(notification, &sequence_fail);
             return;
         }
     } else {
@@ -277,17 +293,16 @@ static void snake_game_process_game_step(SnakeState* const snake_state, Notifica
     crush = snake_game_collision_with_tail(snake_state, next_step);
     if(crush) {
         snake_state->state = GameStateGameOver;
+        notification_message_block(notification, &sequence_fail);
         return;
     }
 
     bool eatFruit = (next_step.x == snake_state->fruit.x) && (next_step.y == snake_state->fruit.y);
     if(eatFruit) {
-        notification_message(notify, &sequence_short_vibro_and_sound);
-        //notification_message(notify, &sequence_blink_white_100);
-
         snake_state->len++;
         if(snake_state->len >= MAX_SNAKE_LEN) {
             snake_state->state = GameStateGameOver;
+            notification_message_block(notification, &sequence_fail);
             return;
         }
     }
@@ -296,6 +311,7 @@ static void snake_game_process_game_step(SnakeState* const snake_state, Notifica
 
     if(eatFruit) {
         snake_state->fruit = snake_game_get_new_fruit(snake_state);
+        notification_message(notification, &sequence_eat);
     }
 }
 
@@ -327,9 +343,10 @@ int32_t snake_game_app(void* p) {
     // Open GUI and register view_port
     Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
-
     NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
 
+    notification_message_block(notification, &sequence_display_backlight_enforce_on);
+
     SnakeEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
@@ -374,6 +391,9 @@ int32_t snake_game_app(void* p) {
         release_mutex(&state_mutex, snake_state);
     }
 
+    // Wait for all notifications to be played and return backlight to normal state
+    notification_message_block(notification, &sequence_display_backlight_enforce_auto);
+
     furi_timer_free(timer);
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);

applications/plugins/spectrum_analyzer/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="spectrum_analyzer",
+    appid="Spectrum_Analyzer",
     name="Spectrum Analyzer",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="spectrum_analyzer_app",

applications/plugins/spectrum_analyzer/spectrum_analyzer.c

@@ -326,7 +326,7 @@ void spectrum_analyzer_calculate_frequencies(SpectrumAnalyzerModel* model) {
     model->max_rssi = -200.0;
     model->max_rssi_dec = 0;
 
-    FURI_LOG_D("Spectrum", "setup_frequencies - max_hz: %u - min_hz: %u", max_hz, min_hz);
+    FURI_LOG_D("Spectrum", "setup_frequencies - max_hz: %lu - min_hz: %lu", max_hz, min_hz);
     FURI_LOG_D("Spectrum", "center_freq: %u", model->center_freq);
     FURI_LOG_D(
         "Spectrum",
@@ -450,7 +450,7 @@ int32_t spectrum_analyzer_app(void* p) {
             break;
         case InputKeyRight:
             model->center_freq += hstep;
-            FURI_LOG_D("Spectrum", "center_freq: %lu", model->center_freq);
+            FURI_LOG_D("Spectrum", "center_freq: %u", model->center_freq);
             spectrum_analyzer_calculate_frequencies(model);
             spectrum_analyzer_worker_set_frequencies(
                 spectrum_analyzer->worker, model->channel0_frequency, model->spacing, model->width);
@@ -460,7 +460,7 @@ int32_t spectrum_analyzer_app(void* p) {
             spectrum_analyzer_calculate_frequencies(model);
             spectrum_analyzer_worker_set_frequencies(
                 spectrum_analyzer->worker, model->channel0_frequency, model->spacing, model->width);
-            FURI_LOG_D("Spectrum", "center_freq: %lu", model->center_freq);
+            FURI_LOG_D("Spectrum", "center_freq: %u", model->center_freq);
             break;
         case InputKeyOk: {
             switch(model->width) {

applications/plugins/spectrum_analyzer/spectrum_analyzer_worker.c

@@ -168,7 +168,7 @@ void spectrum_analyzer_worker_set_frequencies(
 
     FURI_LOG_D(
         "SpectrumWorker",
-        "spectrum_analyzer_worker_set_frequencies - channel0_frequency= %u - spacing = %u - width = %u",
+        "spectrum_analyzer_worker_set_frequencies - channel0_frequency= %lu - spacing = %lu - width = %u",
         channel0_frequency,
         spacing,
         width);

applications/plugins/subbrute/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="subbrute",
+    appid="SubGHz_Bruteforcer",
     name="Sub-GHz Bruteforcer",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="subbrute_app",

applications/plugins/subbrute/scenes/subbrute_scene_load_file.c

@@ -15,10 +15,10 @@ void subbrute_scene_load_file_on_enter(void* context) {
     SubBruteState* instance = (SubBruteState*)context;
 
     // Input events and views are managed by file_browser
-    string_t app_folder;
-    string_t load_path;
-    string_init(load_path);
-    string_init_set_str(app_folder, SUBBRUTE_PATH);
+    FuriString* app_folder;
+    FuriString* load_path;
+    load_path = furi_string_alloc();
+    app_folder = furi_string_alloc_set(SUBBRUTE_PATH);
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(&browser_options, SUBBRUTE_FILE_EXT, &I_sub1_10px);
@@ -30,8 +30,8 @@ void subbrute_scene_load_file_on_enter(void* context) {
     FURI_LOG_D(
         TAG,
         "load_path: %s, app_folder: %s",
-        string_get_cstr(load_path),
-        string_get_cstr(app_folder));
+        furi_string_get_cstr(load_path),
+        furi_string_get_cstr(app_folder));
 #endif
     if(res) {
         load_result = subbrute_device_load_from_file(instance->device, load_path);
@@ -49,12 +49,12 @@ void subbrute_scene_load_file_on_enter(void* context) {
         } else {
             FURI_LOG_E(TAG, "Returned error: %d", load_result);
 
-            string_t dialog_msg;
-            string_init(dialog_msg);
-            string_cat_printf(
+            FuriString* dialog_msg;
+            dialog_msg = furi_string_alloc();
+            furi_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);
+            dialog_message_show_storage_error(instance->dialogs, furi_string_get_cstr(dialog_msg));
+            furi_string_free(dialog_msg);
             scene_manager_search_and_switch_to_previous_scene(
                 instance->scene_manager, SubBruteSceneStart);
         }
@@ -63,8 +63,8 @@ void subbrute_scene_load_file_on_enter(void* context) {
             instance->scene_manager, SubBruteSceneStart);
     }
 
-    string_clear(app_folder);
-    string_clear(load_path);
+    furi_string_free(app_folder);
+    furi_string_free(load_path);
 }
 
 void subbrute_scene_load_file_on_exit(void* context) {

applications/plugins/subbrute/scenes/subbrute_scene_save_name.c

@@ -44,7 +44,7 @@ bool subbrute_scene_save_name_on_event(void* context, SceneManagerEvent event) {
 #endif
         bool success = false;
         if(strcmp(instance->text_store, "")) {
-            string_cat_printf(
+            furi_string_cat_printf(
                 instance->file_path, "/%s%s", instance->text_store, SUBBRUTE_FILE_EXT);
 
             if(subbrute_device_save_file(instance->device, string_get_cstr(instance->file_path))) {

applications/plugins/subbrute/scenes/subbrute_scene_start.c

@@ -41,7 +41,7 @@ bool subbrute_scene_start_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
 #ifdef FURI_DEBUG
-        FURI_LOG_D(TAG, "Event: %d", event.event);
+        FURI_LOG_D(TAG, "Event: %ld", event.event);
 #endif
         if(event.event == SubBruteCustomEventTypeMenuSelected) {
             SubBruteAttacks attack = subbrute_main_view_get_index(instance->view_main);

applications/plugins/subbrute/subbrute_device.c

@@ -351,41 +351,39 @@ bool subbrute_device_create_packet_parsed(
     bool small) {
     furi_assert(instance);
 
-    string_t candidate;
-    string_init(candidate);
+    FuriString* candidate = furi_string_alloc();
 
     if(instance->attack == SubBruteAttackLoadFile) {
         if(step >= sizeof(instance->file_key)) {
             return false;
         }
         char subbrute_payload_byte[4];
-        string_set_str(candidate, instance->file_key);
+        furi_string_set_str(candidate, instance->file_key);
         snprintf(subbrute_payload_byte, 4, "%02X ", (uint8_t)step);
-        string_replace_at(candidate, instance->load_index * 3, 3, subbrute_payload_byte);
+        furi_string_replace_at(candidate, instance->load_index * 3, 3, subbrute_payload_byte);
         //snprintf(step_payload, sizeof(step_payload), "%02X", (uint8_t)instance->file_key[step]);
     } else {
         //snprintf(step_payload, sizeof(step_payload), "%16X", step);
         //snprintf(step_payload, sizeof(step_payload), "%016llX", step);
-        string_t buffer;
-        string_init(buffer);
-        string_init_printf(buffer, "%16X", step);
+        FuriString* buffer = furi_string_alloc();
+        furi_string_printf(buffer, "%16llX", step);
         int j = 0;
-        string_set_str(candidate, "                       ");
+        furi_string_set_str(candidate, "                       ");
         for(uint8_t i = 0; i < 16; i++) {
-            if(string_get_char(buffer, i) != ' ') {
-                string_set_char(candidate, i + j, string_get_char(buffer, i));
+            if(furi_string_get_char(buffer, i) != ' ') {
+                furi_string_set_char(candidate, i + j, furi_string_get_char(buffer, i));
             } else {
-                string_set_char(candidate, i + j, '0');
+                furi_string_set_char(candidate, i + j, '0');
             }
             if(i % 2 != 0) {
                 j++;
             }
         }
-        string_clear(buffer);
+        furi_string_free(buffer);
     }
 
 #ifdef FURI_DEBUG
-    FURI_LOG_D(TAG, "candidate: %s, step: %d", string_get_cstr(candidate), step);
+    FURI_LOG_D(TAG, "candidate: %s, step: %lld", furi_string_get_cstr(candidate), step);
 #endif
 
     Stream* stream = flipper_format_get_raw_stream(flipper_format);
@@ -397,7 +395,7 @@ bool subbrute_device_create_packet_parsed(
                 stream,
                 subbrute_key_small_with_tail,
                 instance->protocol_info->bits,
-                string_get_cstr(candidate),
+                furi_string_get_cstr(candidate),
                 instance->protocol_info->te,
                 instance->protocol_info->repeat);
         } else {
@@ -414,7 +412,7 @@ bool subbrute_device_create_packet_parsed(
                 stream,
                 subbrute_key_file_key_with_tail,
                 instance->file_template,
-                string_get_cstr(candidate),
+                furi_string_get_cstr(candidate),
                 instance->protocol_info->te,
                 instance->protocol_info->repeat);
         } else {
@@ -430,7 +428,7 @@ bool subbrute_device_create_packet_parsed(
     //FURI_LOG_D(TAG, "payload: %s", instance->payload);
 #endif
 
-    string_clear(candidate);
+    furi_string_free(candidate);
 
     return true;
 }
@@ -477,15 +475,15 @@ SubBruteFileResult subbrute_device_attack_set(SubBruteDevice* instance, SubBrute
 
     // Calc max value
     if(instance->attack == SubBruteAttackLoadFile) {
-        instance->max_value = 0xFF;
+        instance->max_value = 0x3F;
     } else {
-        string_t max_value_s;
-        string_init(max_value_s);
+        FuriString* max_value_s;
+        max_value_s = furi_string_alloc();
         for(uint8_t i = 0; i < instance->protocol_info->bits; i++) {
-            string_cat_printf(max_value_s, "1");
+            furi_string_cat_printf(max_value_s, "1");
         }
-        instance->max_value = (uint64_t)strtol(string_get_cstr(max_value_s), NULL, 2);
-        string_clear(max_value_s);
+        instance->max_value = (uint64_t)strtol(furi_string_get_cstr(max_value_s), NULL, 2);
+        furi_string_free(max_value_s);
     }
 
     // Now we are ready to set file template for using in the future with snprintf
@@ -514,18 +512,18 @@ SubBruteFileResult subbrute_device_attack_set(SubBruteDevice* instance, SubBrute
     return SubBruteFileResultOk;
 }
 
-uint8_t subbrute_device_load_from_file(SubBruteDevice* instance, string_t file_path) {
+uint8_t subbrute_device_load_from_file(SubBruteDevice* instance, FuriString* file_path) {
     furi_assert(instance);
 #ifdef FURI_DEBUG
-    FURI_LOG_D(TAG, "subbrute_device_load_from_file: %s", string_get_cstr(file_path));
+    FURI_LOG_D(TAG, "subbrute_device_load_from_file: %s", furi_string_get_cstr(file_path));
 #endif
     SubBruteFileResult result = SubBruteFileResultUnknown;
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
     FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
 
-    string_t temp_str;
-    string_init(temp_str);
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
     uint32_t temp_data32;
 
     instance->receiver = subghz_receiver_alloc_init(instance->environment);
@@ -533,8 +531,8 @@ uint8_t subbrute_device_load_from_file(SubBruteDevice* instance, string_t file_p
     furi_hal_subghz_reset();
 
     do {
-        if(!flipper_format_file_open_existing(fff_data_file, string_get_cstr(file_path))) {
-            FURI_LOG_E(TAG, "Error open file %s", string_get_cstr(file_path));
+        if(!flipper_format_file_open_existing(fff_data_file, furi_string_get_cstr(file_path))) {
+            FURI_LOG_E(TAG, "Error open file %s", furi_string_get_cstr(file_path));
             result = SubBruteFileResultErrorOpenFile;
             break;
         }
@@ -618,7 +616,10 @@ uint8_t subbrute_device_load_from_file(SubBruteDevice* instance, string_t file_p
             break;
         } else {
             snprintf(
-                instance->file_key, sizeof(instance->file_key), "%s", string_get_cstr(temp_str));
+                instance->file_key,
+                sizeof(instance->file_key),
+                "%s",
+                furi_string_get_cstr(temp_str));
 #ifdef FURI_DEBUG
             FURI_LOG_D(TAG, "Key: %s", instance->file_key);
 #endif
@@ -636,7 +637,7 @@ uint8_t subbrute_device_load_from_file(SubBruteDevice* instance, string_t file_p
         // Repeat
         if(flipper_format_read_uint32(fff_data_file, "Repeat", &temp_data32, 1)) {
 #ifdef FURI_DEBUG
-            FURI_LOG_D(TAG, "Repeat: %d", temp_data32);
+            FURI_LOG_D(TAG, "Repeat: %ld", temp_data32);
 #endif
             instance->protocol_info->repeat = (uint8_t)temp_data32;
         } else {
@@ -649,7 +650,7 @@ uint8_t subbrute_device_load_from_file(SubBruteDevice* instance, string_t file_p
         result = SubBruteFileResultOk;
     } while(0);
 
-    string_clear(temp_str);
+    furi_string_free(temp_str);
     flipper_format_file_close(fff_data_file);
     flipper_format_free(fff_data_file);
     furi_record_close(RECORD_STORAGE);

applications/plugins/subbrute/subbrute_device.h

@@ -6,7 +6,56 @@
 #include <lib/subghz/receiver.h>
 #include <lib/subghz/environment.h>
 
-struct SubBruteDevice {
+#define SUBBRUTE_TEXT_STORE_SIZE 256
+
+#define SUBBRUTE_MAX_LEN_NAME 64
+#define SUBBRUTE_PATH EXT_PATH("subghz")
+#define SUBBRUTE_FILE_EXT ".sub"
+
+#define SUBBRUTE_PAYLOAD_SIZE 16
+
+typedef enum {
+    SubBruteAttackCAME12bit303,
+    SubBruteAttackCAME12bit307,
+    SubBruteAttackCAME12bit433,
+    SubBruteAttackCAME12bit868,
+    SubBruteAttackNICE12bit433,
+    SubBruteAttackNICE12bit868,
+    SubBruteAttackChamberlain9bit300,
+    SubBruteAttackChamberlain9bit315,
+    SubBruteAttackChamberlain9bit390,
+    SubBruteAttackLinear10bit300,
+    SubBruteAttackLinear10bit310,
+    SubBruteAttackLoadFile,
+    SubBruteAttackTotalCount,
+} SubBruteAttacks;
+
+typedef enum {
+    SubBruteFileResultUnknown,
+    SubBruteFileResultOk,
+    SubBruteFileResultErrorOpenFile,
+    SubBruteFileResultMissingOrIncorrectHeader,
+    SubBruteFileResultFrequencyNotAllowed,
+    SubBruteFileResultMissingOrIncorrectFrequency,
+    SubBruteFileResultPresetInvalid,
+    SubBruteFileResultMissingProtocol,
+    SubBruteFileResultProtocolNotSupported,
+    SubBruteFileResultDynamicProtocolNotValid,
+    SubBruteFileResultProtocolNotFound,
+    SubBruteFileResultMissingOrIncorrectBit,
+    SubBruteFileResultMissingOrIncorrectKey,
+    SubBruteFileResultMissingOrIncorrectTe,
+    SubBruteFileResultBigBitSize,
+} SubBruteFileResult;
+
+typedef enum {
+    SubBruteDeviceStateIDLE,
+    SubBruteDeviceStateReady,
+    SubBruteDeviceStateTx,
+    SubBruteDeviceStateFinished,
+} SubBruteDeviceState;
+
+typedef struct {
     SubBruteDeviceState state;
     SubBruteProtocol* protocol_info;
     volatile bool worker_running;

applications/plugins/subbrute/subbrute_i.h

@@ -6,7 +6,6 @@
 
 #include <notification/notification.h>
 #include <notification/notification_messages.h>
-#include <m-string.h>
 
 #include <gui/gui.h>
 #include <gui/view_dispatcher.h>

applications/plugins/subbrute/views/subbrute_attack_view.c

@@ -249,7 +249,11 @@ void subbrute_attack_view_init_values(
     bool is_attacking) {
 #ifdef FURI_DEBUG
     FURI_LOG_D(
-        TAG, "init, index: %d, max_value: %d, current_step: %d", index, max_value, current_step);
+        TAG,
+        "init, index: %d, max_value: %lld, current_step: %lld",
+        index,
+        max_value,
+        current_step);
 #endif
     with_view_model(
         instance->view, (SubBruteAttackViewModel * model) {

applications/plugins/subbrute/views/subbrute_main_view.c

@@ -34,7 +34,7 @@ void subbrute_main_view_set_callback(
     instance->context = context;
 }
 
-void center_displayed_key(string_t result, const char* key_cstr, uint8_t index) {
+FuriString* center_displayed_key(const char* key_cstr, uint8_t index) {
     uint8_t str_index = (index * 3);
 
     char display_menu[] = {
@@ -76,7 +76,7 @@ void center_displayed_key(string_t result, const char* key_cstr, uint8_t index)
             display_menu[15] = ' ';
         }
     }
-    string_init_set_str(result, display_menu);
+    return furi_string_alloc_set(display_menu);
 }
 
 void subbrute_main_view_draw(Canvas* canvas, SubBruteMainViewModel* model) {
@@ -97,19 +97,19 @@ void subbrute_main_view_draw(Canvas* canvas, SubBruteMainViewModel* model) {
         snprintf(msg_index, sizeof(msg_index), "Field index : %d", m->index);
         canvas_draw_str_aligned(canvas, 64, 26, AlignCenter, AlignTop, msg_index);
 
-        string_t menu_items;
-        string_init(menu_items);
+        FuriString* menu_items;
 
-        center_displayed_key(menu_items, m->key_field, m->index);
+        menu_items = center_displayed_key(m->key_field, m->index);
         canvas_set_font(canvas, FontSecondary);
         canvas_draw_str_aligned(
-            canvas, 64, 40, AlignCenter, AlignTop, string_get_cstr(menu_items));
+            canvas, 64, 40, AlignCenter, AlignTop, furi_string_get_cstr(menu_items));
 
         elements_button_center(canvas, "Select");
         elements_button_left(canvas, "<");
         elements_button_right(canvas, ">");
 
-        string_reset(menu_items);
+        furi_string_reset(menu_items);
+        furi_string_free(menu_items);
     } else {
         // Menu
         canvas_set_color(canvas, ColorBlack);

applications/plugins/tetris_game/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="tetris_game",
+    appid="Tetris",
     name="Tetris",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="tetris_game_app",

applications/plugins/tictactoe_game/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="tictactoe_game",
+    appid="TicTacToe",
     name="Tic Tac Toe",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="tictactoe_game_app",

applications/plugins/wav_player/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="wav_player",
+    appid="WAV_Player",
     name="WAV Player",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="wav_player_app",

applications/plugins/wav_player/wav_player.c

@@ -19,9 +19,9 @@
 static bool open_wav_stream(Stream* stream) {
     DialogsApp* dialogs = furi_record_open("dialogs");
     bool result = false;
-    string_t path;
-    string_init(path);
-    string_set_str(path, WAVPLAYER_FOLDER);
+    FuriString* path;
+    path = furi_string_alloc();
+    furi_string_set(path, WAVPLAYER_FOLDER);
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(&browser_options, ".wav", &I_music_10px);
@@ -31,13 +31,13 @@ static bool open_wav_stream(Stream* stream) {
 
     furi_record_close("dialogs");
     if(ret) {
-        if(!file_stream_open(stream, string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
-            FURI_LOG_E(TAG, "Cannot open file \"%s\"", string_get_cstr(path));
+        if(!file_stream_open(stream, furi_string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
+            FURI_LOG_E(TAG, "Cannot open file \"%s\"", furi_string_get_cstr(path));
         } else {
             result = true;
         }
     }
-    string_clear(path);
+    furi_string_free(path);
     return result;
 }
 

applications/plugins/wifi_marauder_companion/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="wifi_marauder",
+    appid="ESP32_WiFi_Marauder",
     name="[ESP32] WiFi Marauder",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="wifi_marauder_app",

applications/plugins/wifi_marauder_companion/scenes/wifi_marauder_scene_console_output.c

@@ -7,13 +7,13 @@ void wifi_marauder_console_output_handle_rx_data_cb(uint8_t* buf, size_t len, vo
     // If text box store gets too big, then truncate it
     app->text_box_store_strlen += len;
     if(app->text_box_store_strlen >= WIFI_MARAUDER_TEXT_BOX_STORE_SIZE - 1) {
-        string_right(app->text_box_store, app->text_box_store_strlen / 2);
-        app->text_box_store_strlen = string_size(app->text_box_store) + len;
+        furi_string_right(app->text_box_store, app->text_box_store_strlen / 2);
+        app->text_box_store_strlen = furi_string_size(app->text_box_store) + len;
     }
 
     // Null-terminate buf and append to text box store
     buf[len] = '\0';
-    string_cat_printf(app->text_box_store, "%s", buf);
+    furi_string_cat_printf(app->text_box_store, "%s", buf);
 
     view_dispatcher_send_custom_event(app->view_dispatcher, WifiMarauderEventRefreshConsoleOutput);
 }
@@ -30,24 +30,24 @@ void wifi_marauder_scene_console_output_on_enter(void* context) {
         text_box_set_focus(text_box, TextBoxFocusEnd);
     }
     if(app->is_command) {
-        string_reset(app->text_box_store);
+        furi_string_reset(app->text_box_store);
         app->text_box_store_strlen = 0;
         if(0 == strncmp("help", app->selected_tx_string, strlen("help"))) {
             const char* help_msg =
                 "For app support/feedback,\nreach out to me:\n@cococode#6011 (discord)\n0xchocolate (github)\n";
-            string_cat_str(app->text_box_store, help_msg);
+            furi_string_cat_str(app->text_box_store, help_msg);
             app->text_box_store_strlen += strlen(help_msg);
         }
 
         if(app->show_stopscan_tip) {
             const char* help_msg = "Press BACK to send stopscan\n";
-            string_cat_str(app->text_box_store, help_msg);
+            furi_string_cat_str(app->text_box_store, help_msg);
             app->text_box_store_strlen += strlen(help_msg);
         }
     }
 
     // Set starting text - for "View Log", this will just be what was already in the text box store
-    text_box_set_text(app->text_box, string_get_cstr(app->text_box_store));
+    text_box_set_text(app->text_box, furi_string_get_cstr(app->text_box_store));
 
     scene_manager_set_scene_state(app->scene_manager, WifiMarauderSceneConsoleOutput, 0);
     view_dispatcher_switch_to_view(app->view_dispatcher, WifiMarauderAppViewConsoleOutput);
@@ -70,7 +70,7 @@ bool wifi_marauder_scene_console_output_on_event(void* context, SceneManagerEven
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        text_box_set_text(app->text_box, string_get_cstr(app->text_box_store));
+        text_box_set_text(app->text_box, furi_string_get_cstr(app->text_box_store));
         consumed = true;
     } else if(event.type == SceneManagerEventTypeTick) {
         consumed = true;

applications/plugins/wifi_marauder_companion/wifi_marauder_app.c

@@ -53,8 +53,8 @@ WifiMarauderApp* wifi_marauder_app_alloc() {
     app->text_box = text_box_alloc();
     view_dispatcher_add_view(
         app->view_dispatcher, WifiMarauderAppViewConsoleOutput, text_box_get_view(app->text_box));
-    string_init(app->text_box_store);
-    string_reserve(app->text_box_store, WIFI_MARAUDER_TEXT_BOX_STORE_SIZE);
+    app->text_box_store = furi_string_alloc();
+    furi_string_reserve(app->text_box_store, WIFI_MARAUDER_TEXT_BOX_STORE_SIZE);
 
     app->text_input = text_input_alloc();
     view_dispatcher_add_view(
@@ -73,7 +73,7 @@ void wifi_marauder_app_free(WifiMarauderApp* app) {
     view_dispatcher_remove_view(app->view_dispatcher, WifiMarauderAppViewConsoleOutput);
     view_dispatcher_remove_view(app->view_dispatcher, WifiMarauderAppViewTextInput);
     text_box_free(app->text_box);
-    string_clear(app->text_box_store);
+    furi_string_free(app->text_box_store);
     text_input_free(app->text_input);
 
     // View dispatcher

applications/plugins/wifi_marauder_companion/wifi_marauder_app_i.h

@@ -23,7 +23,7 @@ struct WifiMarauderApp {
     SceneManager* scene_manager;
 
     char text_input_store[WIFI_MARAUDER_TEXT_INPUT_STORE_SIZE + 1];
-    string_t text_box_store;
+    FuriString* text_box_store;
     size_t text_box_store_strlen;
     TextBox* text_box;
     TextInput* text_input;

applications/plugins/wifi_marauder_companion/wifi_marauder_uart.c

@@ -1,15 +1,13 @@
 #include "wifi_marauder_app_i.h"
 #include "wifi_marauder_uart.h"
 
-#include <stream_buffer.h>
-
 #define UART_CH (FuriHalUartIdUSART1)
 #define BAUDRATE (115200)
 
 struct WifiMarauderUart {
     WifiMarauderApp* app;
     FuriThread* rx_thread;
-    StreamBufferHandle_t rx_stream;
+    FuriStreamBuffer* rx_stream;
     uint8_t rx_buf[RX_BUF_SIZE + 1];
     void (*handle_rx_data_cb)(uint8_t* buf, size_t len, void* context);
 };
@@ -30,19 +28,17 @@ void wifi_marauder_uart_set_handle_rx_data_cb(
 
 void wifi_marauder_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
     WifiMarauderUart* uart = (WifiMarauderUart*)context;
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 
     if(ev == UartIrqEventRXNE) {
-        xStreamBufferSendFromISR(uart->rx_stream, &data, 1, &xHigherPriorityTaskWoken);
+        furi_stream_buffer_send(uart->rx_stream, &data, 1, 0);
         furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtRxDone);
-        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
     }
 }
 
 static int32_t uart_worker(void* context) {
     WifiMarauderUart* uart = (void*)context;
 
-    uart->rx_stream = xStreamBufferCreate(RX_BUF_SIZE, 1);
+    uart->rx_stream = furi_stream_buffer_alloc(RX_BUF_SIZE, 1);
 
     while(1) {
         uint32_t events =
@@ -50,14 +46,14 @@ static int32_t uart_worker(void* context) {
         furi_check((events & FuriFlagError) == 0);
         if(events & WorkerEvtStop) break;
         if(events & WorkerEvtRxDone) {
-            size_t len = xStreamBufferReceive(uart->rx_stream, uart->rx_buf, RX_BUF_SIZE, 0);
+            size_t len = furi_stream_buffer_receive(uart->rx_stream, uart->rx_buf, RX_BUF_SIZE, 0);
             if(len > 0) {
                 if(uart->handle_rx_data_cb) uart->handle_rx_data_cb(uart->rx_buf, len, uart->app);
             }
         }
     }
 
-    vStreamBufferDelete(uart->rx_stream);
+    furi_stream_buffer_free(uart->rx_stream);
 
     return 0;
 }

applications/plugins/wifi_scanner/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="wifi_scanner",
+    appid="WiFi_Scanner",
     name="[WiFi] Scanner",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="wifi_scanner_app",

applications/plugins/wifi_scanner/wifi_scanner.c

@@ -6,12 +6,11 @@
 #include <gui/canvas_i.h>
 #include <gui/gui.h>
 #include <input/input.h>
-#include <m-string.h>
 #include <math.h>
 #include <notification/notification.h>
 #include <notification/notification_messages.h>
 #include <stdlib.h>
-#include <stream_buffer.h>
+
 #include <u8g2.h>
 
 #include "FlipperZeroWiFiModuleDefines.h"
@@ -59,10 +58,10 @@ typedef struct SPluginEvent {
 } SPluginEvent;
 
 typedef struct EAccessPointDesc {
-    string_t m_accessPointName;
+    FuriString* m_accessPointName;
     int16_t m_rssi;
-    string_t m_secType;
-    string_t m_bssid;
+    FuriString* m_secType;
+    FuriString* m_bssid;
     unsigned short m_channel;
     bool m_isHidden;
 } EAccessPointDesc;
@@ -87,7 +86,7 @@ typedef struct SWiFiScannerApp {
     Gui* m_gui;
     FuriThread* m_worker_thread;
     NotificationApp* m_notification;
-    StreamBufferHandle_t m_rx_stream;
+    FuriStreamBuffer* m_rx_stream;
 
     bool m_wifiModuleInitialized;
     bool m_wifiModuleAttached;
@@ -111,13 +110,13 @@ static void wifi_scanner_app_init(SWiFiScannerApp* const app) {
     app->m_totalAccessPoints = 0;
     app->m_currentIndexAccessPoint = 0;
 
-    string_init(app->m_currentAccesspointDescription.m_accessPointName);
-    string_set_str(app->m_currentAccesspointDescription.m_accessPointName, "N/A\n");
+    app->m_currentAccesspointDescription.m_accessPointName = furi_string_alloc();
+    furi_string_set(app->m_currentAccesspointDescription.m_accessPointName, "N/A\n");
     app->m_currentAccesspointDescription.m_channel = 0;
-    string_init(app->m_currentAccesspointDescription.m_bssid);
-    string_set_str(app->m_currentAccesspointDescription.m_bssid, "N/A\n");
-    string_init(app->m_currentAccesspointDescription.m_secType);
-    string_set_str(app->m_currentAccesspointDescription.m_secType, "N/A\n");
+    app->m_currentAccesspointDescription.m_bssid = furi_string_alloc();
+    furi_string_set(app->m_currentAccesspointDescription.m_bssid, "N/A\n");
+    app->m_currentAccesspointDescription.m_secType = furi_string_alloc();
+    furi_string_set(app->m_currentAccesspointDescription.m_secType, "N/A\n");
     app->m_currentAccesspointDescription.m_rssi = 0;
     app->m_currentAccesspointDescription.m_isHidden = false;
 
@@ -238,7 +237,7 @@ static void wifi_module_render_callback(Canvas* const canvas, void* ctx) {
                 offsetY,
                 app->m_currentAccesspointDescription.m_isHidden ?
                     "(Hidden SSID)" :
-                    string_get_cstr(app->m_currentAccesspointDescription.m_accessPointName));
+                    furi_string_get_cstr(app->m_currentAccesspointDescription.m_accessPointName));
 
             offsetY += fontHeight;
 
@@ -246,7 +245,7 @@ static void wifi_module_render_callback(Canvas* const canvas, void* ctx) {
                 canvas,
                 offsetX,
                 offsetY,
-                string_get_cstr(app->m_currentAccesspointDescription.m_bssid));
+                furi_string_get_cstr(app->m_currentAccesspointDescription.m_bssid));
 
             canvas_set_font(canvas, FontSecondary);
             //u8g2_SetFont(&canvas->fb, u8g2_font_tinytim_tf);
@@ -271,7 +270,7 @@ static void wifi_module_render_callback(Canvas* const canvas, void* ctx) {
                 string,
                 sizeof(string),
                 "ENCR: %s",
-                string_get_cstr(app->m_currentAccesspointDescription.m_secType));
+                furi_string_get_cstr(app->m_currentAccesspointDescription.m_secType));
             canvas_draw_str(canvas, offsetX, offsetY, string);
 
             offsetY += fontHeight;
@@ -346,7 +345,7 @@ static void wifi_module_render_callback(Canvas* const canvas, void* ctx) {
                 canvas,
                 offsetX,
                 offsetY,
-                string_get_cstr(app->m_currentAccesspointDescription.m_accessPointName));
+                furi_string_get_cstr(app->m_currentAccesspointDescription.m_accessPointName));
 
             offsetY += fontHeight + 2;
 
@@ -354,7 +353,7 @@ static void wifi_module_render_callback(Canvas* const canvas, void* ctx) {
                 canvas,
                 offsetX,
                 offsetY,
-                string_get_cstr(app->m_currentAccesspointDescription.m_bssid));
+                furi_string_get_cstr(app->m_currentAccesspointDescription.m_bssid));
 
             DrawSignalStrengthBar(
                 canvas, app->m_currentAccesspointDescription.m_rssi, 5, 5, 12, 25);
@@ -446,7 +445,6 @@ static void wifi_module_input_callback(InputEvent* input_event, FuriMessageQueue
 
 static void uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
     furi_assert(context);
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 
     SWiFiScannerApp* app = context;
 
@@ -454,9 +452,8 @@ static void uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
 
     if(ev == UartIrqEventRXNE) {
         WIFI_APP_LOG_I("ev == UartIrqEventRXNE");
-        xStreamBufferSendFromISR(app->m_rx_stream, &data, 1, &xHigherPriorityTaskWoken);
+        furi_stream_buffer_send(app->m_rx_stream, &data, 1, 0);
         furi_thread_flags_set(furi_thread_get_id(app->m_worker_thread), WorkerEventRx);
-        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
     }
 }
 
@@ -468,7 +465,7 @@ static int32_t uart_worker(void* context) {
         return 1;
     }
 
-    StreamBufferHandle_t rx_stream = app->m_rx_stream;
+    FuriStreamBuffer* rx_stream = app->m_rx_stream;
 
     release_mutex((ValueMutex*)context, app);
 
@@ -480,54 +477,55 @@ static int32_t uart_worker(void* context) {
         if(events & WorkerEventStop) break;
         if(events & WorkerEventRx) {
             size_t length = 0;
-            string_t receivedString;
-            string_init(receivedString);
+            FuriString* receivedString;
+            receivedString = furi_string_alloc();
             do {
                 uint8_t data[64];
-                length = xStreamBufferReceive(rx_stream, data, 64, 25);
+                length = furi_stream_buffer_receive(rx_stream, data, 64, 25);
                 if(length > 0) {
                     WIFI_APP_LOG_I("Received Data - length: %i", length);
 
                     for(uint16_t i = 0; i < length; i++) {
-                        string_push_back(receivedString, data[i]);
+                        furi_string_push_back(receivedString, data[i]);
                     }
 
                     //notification_message(app->notification, &sequence_set_only_red_255);
                 }
             } while(length > 0);
-            if(string_size(receivedString) > 0) {
-                string_t chunk;
-                string_init(chunk);
+            if(furi_string_size(receivedString) > 0) {
+                FuriString* chunk;
+                chunk = furi_string_alloc();
                 size_t begin = 0;
                 size_t end = 0;
-                size_t stringSize = string_size(receivedString);
+                size_t stringSize = furi_string_size(receivedString);
 
-                WIFI_APP_LOG_I("Received string: %s", string_get_cstr(receivedString));
+                WIFI_APP_LOG_I("Received string: %s", furi_string_get_cstr(receivedString));
 
-                string_t chunksArray[EChunkArrayData_ENUM_MAX];
+                FuriString* chunksArray[EChunkArrayData_ENUM_MAX];
                 for(uint8_t i = 0; i < EChunkArrayData_ENUM_MAX; ++i) {
-                    string_init(chunksArray[i]);
+                    chunksArray[i] = furi_string_alloc();
                 }
 
                 uint8_t index = 0;
                 do {
-                    end = string_search_char(receivedString, '+', begin);
+                    end = furi_string_search_char(receivedString, '+', begin);
 
-                    if(end == STRING_FAILURE) {
+                    if(end == FURI_STRING_FAILURE) {
                         end = stringSize;
                     }
 
                     WIFI_APP_LOG_I("size: %i, begin: %i, end: %i", stringSize, begin, end);
 
-                    string_set_strn(chunk, &string_get_cstr(receivedString)[begin], end - begin);
+                    furi_string_set_strn(
+                        chunk, &furi_string_get_cstr(receivedString)[begin], end - begin);
 
-                    WIFI_APP_LOG_I("String chunk: %s", string_get_cstr(chunk));
+                    WIFI_APP_LOG_I("String chunk: %s", furi_string_get_cstr(chunk));
 
-                    string_set(chunksArray[index++], chunk);
+                    furi_string_set(chunksArray[index++], chunk);
 
                     begin = end + 1;
                 } while(end < stringSize);
-                string_clear(chunk);
+                furi_string_free(chunk);
 
                 app = acquire_mutex((ValueMutex*)context, 25);
                 if(app == NULL) {
@@ -535,7 +533,7 @@ static int32_t uart_worker(void* context) {
                 }
 
                 if(!app->m_wifiModuleInitialized) {
-                    if(string_cmp_str(
+                    if(furi_string_cmp_str(
                            chunksArray[EChunkArrayData_Context], MODULE_CONTEXT_INITIALIZATION) ==
                        0) {
                         app->m_wifiModuleInitialized = true;
@@ -543,46 +541,46 @@ static int32_t uart_worker(void* context) {
                     }
 
                 } else {
-                    if(string_cmp_str(
+                    if(furi_string_cmp_str(
                            chunksArray[EChunkArrayData_Context], MODULE_CONTEXT_MONITOR) == 0) {
                         app->m_context = MonitorMode;
                     } else if(
-                        string_cmp_str(
+                        furi_string_cmp_str(
                             chunksArray[EChunkArrayData_Context], MODULE_CONTEXT_SCAN) == 0) {
                         app->m_context = ScanMode;
                     } else if(
-                        string_cmp_str(
+                        furi_string_cmp_str(
                             chunksArray[EChunkArrayData_Context], MODULE_CONTEXT_SCAN_ANIMATION) ==
                         0) {
                         app->m_context = ScanAnimation;
                     } else if(
-                        string_cmp_str(
+                        furi_string_cmp_str(
                             chunksArray[EChunkArrayData_Context],
                             MODULE_CONTEXT_MONITOR_ANIMATION) == 0) {
                         app->m_context = MonitorAnimation;
                     }
 
                     if(app->m_context == MonitorMode || app->m_context == ScanMode) {
-                        string_set(
+                        furi_string_set(
                             app->m_currentAccesspointDescription.m_accessPointName,
                             chunksArray[EChunkArrayData_SSID]);
-                        string_set(
+                        furi_string_set(
                             app->m_currentAccesspointDescription.m_secType,
                             chunksArray[EChunkArrayData_EncryptionType]);
                         app->m_currentAccesspointDescription.m_rssi =
-                            atoi(string_get_cstr(chunksArray[EChunkArrayData_RSSI]));
-                        string_set(
+                            atoi(furi_string_get_cstr(chunksArray[EChunkArrayData_RSSI]));
+                        furi_string_set(
                             app->m_currentAccesspointDescription.m_bssid,
                             chunksArray[EChunkArrayData_BSSID]);
                         app->m_currentAccesspointDescription.m_channel =
-                            atoi(string_get_cstr(chunksArray[EChunkArrayData_Channel]));
+                            atoi(furi_string_get_cstr(chunksArray[EChunkArrayData_Channel]));
                         app->m_currentAccesspointDescription.m_isHidden =
-                            atoi(string_get_cstr(chunksArray[EChunkArrayData_IsHidden]));
+                            atoi(furi_string_get_cstr(chunksArray[EChunkArrayData_IsHidden]));
 
-                        app->m_currentIndexAccessPoint =
-                            atoi(string_get_cstr(chunksArray[EChunkArrayData_CurrentAPIndex]));
+                        app->m_currentIndexAccessPoint = atoi(
+                            furi_string_get_cstr(chunksArray[EChunkArrayData_CurrentAPIndex]));
                         app->m_totalAccessPoints =
-                            atoi(string_get_cstr(chunksArray[EChunkArrayData_TotalAps]));
+                            atoi(furi_string_get_cstr(chunksArray[EChunkArrayData_TotalAps]));
                     }
                 }
 
@@ -590,10 +588,10 @@ static int32_t uart_worker(void* context) {
 
                 // Clear string array
                 for(index = 0; index < EChunkArrayData_ENUM_MAX; ++index) {
-                    string_clear(chunksArray[index]);
+                    furi_string_free(chunksArray[index]);
                 }
             }
-            string_clear(receivedString);
+            furi_string_free(receivedString);
         }
     }
 
@@ -676,7 +674,7 @@ int32_t wifi_scanner_app(void* p) {
 
     WIFI_APP_LOG_I("Mutex created");
 
-    app->m_rx_stream = xStreamBufferCreate(1 * 1024, 1);
+    app->m_rx_stream = furi_stream_buffer_alloc(1 * 1024, 1);
 
     app->m_notification = furi_record_open("notification");
 
@@ -839,7 +837,7 @@ int32_t wifi_scanner_app(void* p) {
 
     furi_message_queue_free(event_queue);
 
-    vStreamBufferDelete(app->m_rx_stream);
+    furi_stream_buffer_free(app->m_rx_stream);
 
     delete_mutex(&app_data_mutex);
 

applications/plugins/zombiez/application.fam

@@ -1,5 +1,5 @@
 App(
-    appid="game_zombiez",
+    appid="Zombiez",
     name="Zombiez",
     apptype=FlipperAppType.EXTERNAL,
     entry_point="zombiez_game_app",