Format

nfc_playlist/nfc_playlist.c

@@ -1,150 +1,165 @@
 #include "nfc_playlist.h"
 
 static bool nfc_playlist_custom_callback(void* context, uint32_t custom_event) {
-   furi_assert(context);
-   NfcPlaylist* nfc_playlist = context;
-   return scene_manager_handle_custom_event(nfc_playlist->scene_manager, custom_event);
+    furi_assert(context);
+    NfcPlaylist* nfc_playlist = context;
+    return scene_manager_handle_custom_event(nfc_playlist->scene_manager, custom_event);
 }
 
 static bool nfc_playlist_back_event_callback(void* context) {
-   furi_assert(context);
-   NfcPlaylist* nfc_playlist = context;
-   return scene_manager_handle_back_event(nfc_playlist->scene_manager);
+    furi_assert(context);
+    NfcPlaylist* nfc_playlist = context;
+    return scene_manager_handle_back_event(nfc_playlist->scene_manager);
 }
 
 static NfcPlaylist* nfc_playlist_alloc() {
-   NfcPlaylist* nfc_playlist = malloc(sizeof(NfcPlaylist));
-   furi_assert(nfc_playlist);
-   nfc_playlist->scene_manager = scene_manager_alloc(&nfc_playlist_scene_handlers, nfc_playlist);
-   nfc_playlist->view_dispatcher = view_dispatcher_alloc();
-   view_dispatcher_enable_queue(nfc_playlist->view_dispatcher);
-   nfc_playlist->variable_item_list = variable_item_list_alloc();
-   nfc_playlist->submenu = submenu_alloc();
-   nfc_playlist->widget= widget_alloc();
-
-   nfc_playlist->settings.file_path = furi_string_alloc();
-   nfc_playlist->file_browser_output = furi_string_alloc();
-   nfc_playlist->settings.playlist_selected = false;
-   nfc_playlist->settings.emulate_timeout = default_emulate_timeout;
-   nfc_playlist->settings.emulate_delay = default_emulate_delay;
-   nfc_playlist->settings.emulate_led_indicator = default_emulate_led_indicator;
-   nfc_playlist->settings.skip_error = default_skip_error;
-
-   nfc_playlist->notification = furi_record_open(RECORD_NOTIFICATION);
-   nfc_playlist->file_browser = file_browser_alloc(nfc_playlist->file_browser_output);
-
-   nfc_playlist->text_input = text_input_alloc();
-   nfc_playlist->popup = popup_alloc();
-
-   view_dispatcher_set_event_callback_context(nfc_playlist->view_dispatcher, nfc_playlist);
-   view_dispatcher_set_custom_event_callback(nfc_playlist->view_dispatcher, nfc_playlist_custom_callback);
-   view_dispatcher_set_navigation_event_callback(nfc_playlist->view_dispatcher, nfc_playlist_back_event_callback);
-
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Submenu, submenu_get_view(nfc_playlist->submenu));
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Popup, popup_get_view(nfc_playlist->popup));
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Widget, widget_get_view(nfc_playlist->widget));
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList, variable_item_list_get_view(nfc_playlist->variable_item_list));
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileBrowser, file_browser_get_view(nfc_playlist->file_browser));
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput, text_input_get_view(nfc_playlist->text_input));
-
-   Storage* storage = furi_record_open(RECORD_STORAGE);
-   if (!storage_common_exists(storage, PLAYLIST_DIR)) {
-      storage_common_mkdir(storage, PLAYLIST_DIR);
-   }
-   furi_record_close(RECORD_STORAGE);
-
-   return nfc_playlist;
+    NfcPlaylist* nfc_playlist = malloc(sizeof(NfcPlaylist));
+    furi_assert(nfc_playlist);
+    nfc_playlist->scene_manager = scene_manager_alloc(&nfc_playlist_scene_handlers, nfc_playlist);
+    nfc_playlist->view_dispatcher = view_dispatcher_alloc();
+    view_dispatcher_enable_queue(nfc_playlist->view_dispatcher);
+    nfc_playlist->variable_item_list = variable_item_list_alloc();
+    nfc_playlist->submenu = submenu_alloc();
+    nfc_playlist->widget = widget_alloc();
+
+    nfc_playlist->settings.file_path = furi_string_alloc();
+    nfc_playlist->file_browser_output = furi_string_alloc();
+    nfc_playlist->settings.playlist_selected = false;
+    nfc_playlist->settings.emulate_timeout = default_emulate_timeout;
+    nfc_playlist->settings.emulate_delay = default_emulate_delay;
+    nfc_playlist->settings.emulate_led_indicator = default_emulate_led_indicator;
+    nfc_playlist->settings.skip_error = default_skip_error;
+
+    nfc_playlist->notification = furi_record_open(RECORD_NOTIFICATION);
+    nfc_playlist->file_browser = file_browser_alloc(nfc_playlist->file_browser_output);
+
+    nfc_playlist->text_input = text_input_alloc();
+    nfc_playlist->popup = popup_alloc();
+
+    view_dispatcher_set_event_callback_context(nfc_playlist->view_dispatcher, nfc_playlist);
+    view_dispatcher_set_custom_event_callback(
+        nfc_playlist->view_dispatcher, nfc_playlist_custom_callback);
+    view_dispatcher_set_navigation_event_callback(
+        nfc_playlist->view_dispatcher, nfc_playlist_back_event_callback);
+
+    view_dispatcher_add_view(
+        nfc_playlist->view_dispatcher,
+        NfcPlaylistView_Submenu,
+        submenu_get_view(nfc_playlist->submenu));
+    view_dispatcher_add_view(
+        nfc_playlist->view_dispatcher, NfcPlaylistView_Popup, popup_get_view(nfc_playlist->popup));
+    view_dispatcher_add_view(
+        nfc_playlist->view_dispatcher,
+        NfcPlaylistView_Widget,
+        widget_get_view(nfc_playlist->widget));
+    view_dispatcher_add_view(
+        nfc_playlist->view_dispatcher,
+        NfcPlaylistView_VariableItemList,
+        variable_item_list_get_view(nfc_playlist->variable_item_list));
+    view_dispatcher_add_view(
+        nfc_playlist->view_dispatcher,
+        NfcPlaylistView_FileBrowser,
+        file_browser_get_view(nfc_playlist->file_browser));
+    view_dispatcher_add_view(
+        nfc_playlist->view_dispatcher,
+        NfcPlaylistView_TextInput,
+        text_input_get_view(nfc_playlist->text_input));
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    if(!storage_common_exists(storage, PLAYLIST_DIR)) {
+        storage_common_mkdir(storage, PLAYLIST_DIR);
+    }
+    furi_record_close(RECORD_STORAGE);
+
+    return nfc_playlist;
 }
 
 static void nfc_playlist_free(NfcPlaylist* nfc_playlist) {
-   furi_assert(nfc_playlist);
-
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Submenu);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Popup);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Widget);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileBrowser);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
-
-   scene_manager_free(nfc_playlist->scene_manager);
-   view_dispatcher_free(nfc_playlist->view_dispatcher);
-   variable_item_list_free(nfc_playlist->variable_item_list);
-   submenu_free(nfc_playlist->submenu);
-   widget_free(nfc_playlist->widget);
-
-   furi_record_close(RECORD_NOTIFICATION);
-   file_browser_free(nfc_playlist->file_browser);
-   text_input_free(nfc_playlist->text_input);
-   popup_free(nfc_playlist->popup);
-
-   furi_string_free(nfc_playlist->settings.file_path);
-   furi_string_free(nfc_playlist->file_browser_output);
-   free(nfc_playlist);
+    furi_assert(nfc_playlist);
+
+    view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Submenu);
+    view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Popup);
+    view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Widget);
+    view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList);
+    view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileBrowser);
+    view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
+
+    scene_manager_free(nfc_playlist->scene_manager);
+    view_dispatcher_free(nfc_playlist->view_dispatcher);
+    variable_item_list_free(nfc_playlist->variable_item_list);
+    submenu_free(nfc_playlist->submenu);
+    widget_free(nfc_playlist->widget);
+
+    furi_record_close(RECORD_NOTIFICATION);
+    file_browser_free(nfc_playlist->file_browser);
+    text_input_free(nfc_playlist->text_input);
+    popup_free(nfc_playlist->popup);
+
+    furi_string_free(nfc_playlist->settings.file_path);
+    furi_string_free(nfc_playlist->file_browser_output);
+    free(nfc_playlist);
 }
 
 void nfc_playlist_set_log_level() {
 #ifdef FURI_DEBUG
-   furi_log_set_level(FuriLogLevelTrace);
+    furi_log_set_level(FuriLogLevelTrace);
 #else
-   furi_log_set_level(FuriLogLevelInfo);
+    furi_log_set_level(FuriLogLevelInfo);
 #endif
 }
 
 int32_t nfc_playlist_main(void* p) {
-   UNUSED(p);
+    UNUSED(p);
 
-   NfcPlaylist* nfc_playlist = nfc_playlist_alloc();
+    NfcPlaylist* nfc_playlist = nfc_playlist_alloc();
 
-   nfc_playlist_set_log_level();
+    nfc_playlist_set_log_level();
 
-   Gui* gui = furi_record_open(RECORD_GUI);
-   view_dispatcher_attach_to_gui(nfc_playlist->view_dispatcher, gui, ViewDispatcherTypeFullscreen);
-   scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
-   view_dispatcher_run(nfc_playlist->view_dispatcher);
+    Gui* gui = furi_record_open(RECORD_GUI);
+    view_dispatcher_attach_to_gui(
+        nfc_playlist->view_dispatcher, gui, ViewDispatcherTypeFullscreen);
+    scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+    view_dispatcher_run(nfc_playlist->view_dispatcher);
 
-   furi_record_close(RECORD_GUI);
-   nfc_playlist_free(nfc_playlist);
+    furi_record_close(RECORD_GUI);
+    nfc_playlist_free(nfc_playlist);
 
-   return 0;
+    return 0;
 }
 
 NotificationMessage blink_message_normal = {
-   .type = NotificationMessageTypeLedBlinkStart,
-   .data.led_blink.color = LightBlue | LightGreen,
-   .data.led_blink.on_time = 10,
-   .data.led_blink.period = 100
-};
+    .type = NotificationMessageTypeLedBlinkStart,
+    .data.led_blink.color = LightBlue | LightGreen,
+    .data.led_blink.on_time = 10,
+    .data.led_blink.period = 100};
 const NotificationSequence blink_sequence_normal = {
-   &blink_message_normal,
-   &message_do_not_reset,
-   NULL
-};
+    &blink_message_normal,
+    &message_do_not_reset,
+    NULL};
 
 NotificationMessage blink_message_error = {
-   .type = NotificationMessageTypeLedBlinkStart,
-   .data.led_blink.color = LightRed,
-   .data.led_blink.on_time = 10,
-   .data.led_blink.period = 100
-};
+    .type = NotificationMessageTypeLedBlinkStart,
+    .data.led_blink.color = LightRed,
+    .data.led_blink.on_time = 10,
+    .data.led_blink.period = 100};
 
 const NotificationSequence blink_sequence_error = {
-   &blink_message_error,
-   &message_do_not_reset,
-   NULL
-};
+    &blink_message_error,
+    &message_do_not_reset,
+    NULL};
 
 void start_blink(NfcPlaylist* nfc_playlist, int state) {
-   if (nfc_playlist->settings.emulate_led_indicator) {
-      if (state == NfcPlaylistLedState_Normal) {
-         notification_message_block(nfc_playlist->notification, &blink_sequence_normal);
-      } else if (state == NfcPlaylistLedState_Error) {
-         notification_message_block(nfc_playlist->notification, &blink_sequence_error);
-      }
-   }
+    if(nfc_playlist->settings.emulate_led_indicator) {
+        if(state == NfcPlaylistLedState_Normal) {
+            notification_message_block(nfc_playlist->notification, &blink_sequence_normal);
+        } else if(state == NfcPlaylistLedState_Error) {
+            notification_message_block(nfc_playlist->notification, &blink_sequence_error);
+        }
+    }
 }
 
 void stop_blink(NfcPlaylist* nfc_playlist) {
-   if (nfc_playlist->settings.emulate_led_indicator) {
-      notification_message_block(nfc_playlist->notification, &sequence_blink_stop);
-   }
+    if(nfc_playlist->settings.emulate_led_indicator) {
+        notification_message_block(nfc_playlist->notification, &sequence_blink_stop);
+    }
 }

nfc_playlist/nfc_playlist.h

@@ -29,39 +29,39 @@
 #include "scenes/nfc_playlist_scene.h"
 
 typedef enum {
-   NfcPlaylistView_Submenu,
-   NfcPlaylistView_Popup,
-   NfcPlaylistView_Widget,
-   NfcPlaylistView_VariableItemList,
-   NfcPlaylistView_FileBrowser,
-   NfcPlaylistView_TextInput
+    NfcPlaylistView_Submenu,
+    NfcPlaylistView_Popup,
+    NfcPlaylistView_Widget,
+    NfcPlaylistView_VariableItemList,
+    NfcPlaylistView_FileBrowser,
+    NfcPlaylistView_TextInput
 } NfcPlaylistViews;
 
 typedef struct {
-   FuriString* file_path;
-   bool playlist_selected;
-   uint8_t emulate_timeout;
-   uint8_t emulate_delay;
-   bool emulate_led_indicator;
-   bool skip_error;
+    FuriString* file_path;
+    bool playlist_selected;
+    uint8_t emulate_timeout;
+    uint8_t emulate_delay;
+    bool emulate_led_indicator;
+    bool skip_error;
 } NfcPlaylistSettings;
 
 typedef struct {
-   SceneManager* scene_manager;
-   ViewDispatcher* view_dispatcher;
-   Submenu* submenu;
-   Popup* popup;
-   Widget* widget;
-   VariableItemList* variable_item_list;
-   FileBrowser* file_browser;
-   FuriString* file_browser_output;
-   TextInput* text_input;
-   char* text_input_output;
-   NotificationApp* notification;
-   FuriThread* thread;
-   FuriString* temp_furi_string;
-   NfcPlaylistWorker* nfc_playlist_worker;
-   NfcPlaylistSettings settings;
+    SceneManager* scene_manager;
+    ViewDispatcher* view_dispatcher;
+    Submenu* submenu;
+    Popup* popup;
+    Widget* widget;
+    VariableItemList* variable_item_list;
+    FileBrowser* file_browser;
+    FuriString* file_browser_output;
+    TextInput* text_input;
+    char* text_input_output;
+    NotificationApp* notification;
+    FuriThread* thread;
+    FuriString* temp_furi_string;
+    NfcPlaylistWorker* nfc_playlist_worker;
+    NfcPlaylistSettings settings;
 } NfcPlaylist;
 
 static const int options_emulate_timeout[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
@@ -76,8 +76,8 @@ static const bool default_skip_error = false;
 #define PLAYLIST_VIEW_MAX_SIZE 1000
 
 typedef enum NfcPlaylistLedState {
-   NfcPlaylistLedState_Normal,
-   NfcPlaylistLedState_Error
+    NfcPlaylistLedState_Normal,
+    NfcPlaylistLedState_Error
 } NfcPlaylistLedState;
 
 void start_blink(NfcPlaylist* nfc_playlist, int state);

nfc_playlist/scenes/nfc_playlist_scene.c

@@ -23,8 +23,8 @@ void (*const nfc_playlist_on_exit_handlers[])(void* context) = {
 
 // Initialize scene handlers configuration structure
 const SceneManagerHandlers nfc_playlist_scene_handlers = {
-   .on_enter_handlers = nfc_playlist_on_enter_handlers,
-   .on_event_handlers = nfc_playlist_on_event_handlers,
-   .on_exit_handlers = nfc_playlist_on_exit_handlers,
-   .scene_num = NfcPlaylistScene_Count,
+    .on_enter_handlers = nfc_playlist_on_enter_handlers,
+    .on_event_handlers = nfc_playlist_on_event_handlers,
+    .on_exit_handlers = nfc_playlist_on_exit_handlers,
+    .scene_num = NfcPlaylistScene_Count,
 };

nfc_playlist/scenes/nfc_playlist_scene.h

@@ -6,7 +6,7 @@
 #define ADD_SCENE(prefix, name, id) NfcPlaylistScene_##id,
 typedef enum {
 #include "nfc_playlist_scene_config.h"
-   NfcPlaylistScene_Count
+    NfcPlaylistScene_Count
 } NfcPlaylistScene;
 #undef ADD_SCENE
 
@@ -19,7 +19,7 @@ extern const SceneManagerHandlers nfc_playlist_scene_handlers;
 
 // Generate scene on_event handlers declaration
 #define ADD_SCENE(prefix, name, id) \
-   bool prefix##_##name##_scene_on_event(void* context, SceneManagerEvent event);
+    bool prefix##_##name##_scene_on_event(void* context, SceneManagerEvent event);
 #include "nfc_playlist_scene_config.h"
 #undef ADD_SCENE
 

nfc_playlist/scenes/nfc_playlist_scene_confirm_delete.c

@@ -1,35 +1,57 @@
 #include "../nfc_playlist.h"
 
 void nfc_playlist_confirm_delete_menu_callback(GuiButtonType result, InputType type, void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   if(type == InputTypeShort) {
-      view_dispatcher_send_custom_event(nfc_playlist->view_dispatcher, result);
-   }
+    NfcPlaylist* nfc_playlist = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(nfc_playlist->view_dispatcher, result);
+    }
 }
 
 void nfc_playlist_confirm_delete_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
+    NfcPlaylist* nfc_playlist = context;
 
-   FuriString* temp_str = furi_string_alloc();
-   char* file_path = (char*)furi_string_get_cstr(nfc_playlist->settings.file_path);
-   furi_string_printf(temp_str, "\e#Delete %s?\e#", strchr(file_path, '/') != NULL ? &strrchr(file_path, '/')[1] : file_path);
-   furi_string_replace(temp_str, ".txt", "");
+    FuriString* temp_str = furi_string_alloc();
+    char* file_path = (char*)furi_string_get_cstr(nfc_playlist->settings.file_path);
+    furi_string_printf(
+        temp_str,
+        "\e#Delete %s?\e#",
+        strchr(file_path, '/') != NULL ? &strrchr(file_path, '/')[1] : file_path);
+    furi_string_replace(temp_str, ".txt", "");
 
-   widget_add_text_box_element(nfc_playlist->widget, 0, 0, 128, 23, AlignCenter, AlignCenter, furi_string_get_cstr(temp_str), false);
-   widget_add_button_element(nfc_playlist->widget, GuiButtonTypeLeft, "Cancel", nfc_playlist_confirm_delete_menu_callback, nfc_playlist);
-   widget_add_button_element(nfc_playlist->widget, GuiButtonTypeRight, "Delete", nfc_playlist_confirm_delete_menu_callback, nfc_playlist);
+    widget_add_text_box_element(
+        nfc_playlist->widget,
+        0,
+        0,
+        128,
+        23,
+        AlignCenter,
+        AlignCenter,
+        furi_string_get_cstr(temp_str),
+        false);
+    widget_add_button_element(
+        nfc_playlist->widget,
+        GuiButtonTypeLeft,
+        "Cancel",
+        nfc_playlist_confirm_delete_menu_callback,
+        nfc_playlist);
+    widget_add_button_element(
+        nfc_playlist->widget,
+        GuiButtonTypeRight,
+        "Delete",
+        nfc_playlist_confirm_delete_menu_callback,
+        nfc_playlist);
 
-   furi_string_free(temp_str);
+    furi_string_free(temp_str);
 
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Widget);
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Widget);
 }
 
 bool nfc_playlist_confirm_delete_scene_on_event(void* context, SceneManagerEvent event) {
-   NfcPlaylist* nfc_playlist = context;
-   bool consumed = false;
-   if(event.type == SceneManagerEventTypeCustom) {
-      switch(event.event) {
-         case GuiButtonTypeRight:
+    NfcPlaylist* nfc_playlist = context;
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case GuiButtonTypeRight:
             Storage* storage = furi_record_open(RECORD_STORAGE);
             storage_simply_remove(storage, furi_string_get_cstr(nfc_playlist->settings.file_path));
             nfc_playlist->settings.playlist_selected = false;
@@ -37,15 +59,15 @@ bool nfc_playlist_confirm_delete_scene_on_event(void* context, SceneManagerEvent
             furi_record_close(RECORD_STORAGE);
             consumed = true;
             break;
-         default:
+        default:
             break;
-      }
-      scene_manager_previous_scene(nfc_playlist->scene_manager);
-   }
-   return consumed;
+        }
+        scene_manager_previous_scene(nfc_playlist->scene_manager);
+    }
+    return consumed;
 }
 
 void nfc_playlist_confirm_delete_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   widget_reset(nfc_playlist->widget);
+    NfcPlaylist* nfc_playlist = context;
+    widget_reset(nfc_playlist->widget);
 }

nfc_playlist/scenes/nfc_playlist_scene_emulation.c

@@ -1,169 +1,236 @@
 #include "../nfc_playlist.h"
 
 typedef enum NfcPlaylistEmulationState {
-   NfcPlaylistEmulationState_Emulating,
-   NfcPlaylistEmulationState_Stopped,
-   NfcPlaylistEmulationState_Canceled
+    NfcPlaylistEmulationState_Emulating,
+    NfcPlaylistEmulationState_Stopped,
+    NfcPlaylistEmulationState_Canceled
 } NfcPlaylistEmulationState;
 
 NfcPlaylistEmulationState EmulationState = NfcPlaylistEmulationState_Stopped;
 
 int32_t nfc_playlist_emulation_task(void* context) {
-   NfcPlaylist* nfc_playlist = context;
+    NfcPlaylist* nfc_playlist = context;
 
-   Storage* storage = furi_record_open(RECORD_STORAGE);
-   Stream* stream = file_stream_alloc(storage);
-   bool skip_delay = false;
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    Stream* stream = file_stream_alloc(storage);
+    bool skip_delay = false;
 
-   popup_reset(nfc_playlist->popup);
-   popup_set_context(nfc_playlist->popup, nfc_playlist);
+    popup_reset(nfc_playlist->popup);
+    popup_set_context(nfc_playlist->popup, nfc_playlist);
 
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Popup);
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Popup);
 
-   if (file_stream_open(stream, furi_string_get_cstr(nfc_playlist->settings.file_path), FSAM_READ, FSOM_OPEN_EXISTING)) {
-      EmulationState = NfcPlaylistEmulationState_Emulating;
-      int file_position = 0;
+    if(file_stream_open(
+           stream,
+           furi_string_get_cstr(nfc_playlist->settings.file_path),
+           FSAM_READ,
+           FSOM_OPEN_EXISTING)) {
+        EmulationState = NfcPlaylistEmulationState_Emulating;
+        int file_position = 0;
 
-      FuriString* line = furi_string_alloc();
-      FuriString* tmp_header_str = furi_string_alloc();
-      FuriString* tmp_counter_str = furi_string_alloc();
+        FuriString* line = furi_string_alloc();
+        FuriString* tmp_header_str = furi_string_alloc();
+        FuriString* tmp_counter_str = furi_string_alloc();
 
-      while(stream_read_line(stream, line) && EmulationState == NfcPlaylistEmulationState_Emulating) {
+        while(stream_read_line(stream, line) &&
+              EmulationState == NfcPlaylistEmulationState_Emulating) {
+            char* file_path = (char*)furi_string_get_cstr(line);
 
-         char* file_path = (char*)furi_string_get_cstr(line);
-
-         if (strlen(file_path) <= 1) {continue;}
-
-         if (nfc_playlist->settings.emulate_delay > 0 && file_position != 0 && !skip_delay) {
-            popup_set_header(nfc_playlist->popup, "Delaying", 64, 10, AlignCenter, AlignTop);
-            start_blink(nfc_playlist, NfcPlaylistLedState_Error);
-            int time_counter_delay_ms = (options_emulate_delay[nfc_playlist->settings.emulate_delay]*1000);
-            while(time_counter_delay_ms > 0 && EmulationState == NfcPlaylistEmulationState_Emulating) {
-               furi_string_printf(tmp_counter_str,  "%ds", (time_counter_delay_ms/1000));
-               popup_set_text(nfc_playlist->popup, furi_string_get_cstr(tmp_counter_str), 64, 50, AlignCenter, AlignTop);
-               furi_delay_ms(50);
-               time_counter_delay_ms -= 50;
-            };
-         } else if (nfc_playlist->settings.emulate_delay > 0) {
-            skip_delay = false;
-            file_position++;
-         }
-
-         if(EmulationState != NfcPlaylistEmulationState_Emulating) {break;}
+            if(strlen(file_path) <= 1) {
+                continue;
+            }
 
-         char* file_name = strchr(file_path, '/') != NULL ? &strrchr(file_path, '/')[1] : file_path;
-         char const* file_ext = &strrchr(file_path, '.')[1];
-         int time_counter_ms = (options_emulate_timeout[nfc_playlist->settings.emulate_timeout]*1000);
+            if(nfc_playlist->settings.emulate_delay > 0 && file_position != 0 && !skip_delay) {
+                popup_set_header(nfc_playlist->popup, "Delaying", 64, 10, AlignCenter, AlignTop);
+                start_blink(nfc_playlist, NfcPlaylistLedState_Error);
+                int time_counter_delay_ms =
+                    (options_emulate_delay[nfc_playlist->settings.emulate_delay] * 1000);
+                while(time_counter_delay_ms > 0 &&
+                      EmulationState == NfcPlaylistEmulationState_Emulating) {
+                    furi_string_printf(tmp_counter_str, "%ds", (time_counter_delay_ms / 1000));
+                    popup_set_text(
+                        nfc_playlist->popup,
+                        furi_string_get_cstr(tmp_counter_str),
+                        64,
+                        50,
+                        AlignCenter,
+                        AlignTop);
+                    furi_delay_ms(50);
+                    time_counter_delay_ms -= 50;
+                };
+            } else if(nfc_playlist->settings.emulate_delay > 0) {
+                skip_delay = false;
+                file_position++;
+            }
 
-         if(!strcasestr(file_ext, "nfc")) {
-            if(nfc_playlist->settings.skip_error) {
-               skip_delay = true;
-               continue;
+            if(EmulationState != NfcPlaylistEmulationState_Emulating) {
+                break;
             }
-            furi_string_printf(tmp_header_str, "ERROR invalid file:\n%s", file_name);
-            popup_set_header(nfc_playlist->popup, furi_string_get_cstr(tmp_header_str), 64, 10, AlignCenter, AlignTop);
-            start_blink(nfc_playlist, NfcPlaylistLedState_Error);
-            while(time_counter_ms > 0 && EmulationState == NfcPlaylistEmulationState_Emulating) {
-               furi_string_printf(tmp_counter_str, "%ds", (time_counter_ms/1000));
-               popup_set_text(nfc_playlist->popup, furi_string_get_cstr(tmp_counter_str), 64, 50, AlignCenter, AlignTop);
-               furi_delay_ms(50);
-               time_counter_ms -= 50;
-            };
-         } else if(!storage_file_exists(storage, file_path)) {
-            if(nfc_playlist->settings.skip_error) {
-               skip_delay = true;
-               continue;
+
+            char* file_name = strchr(file_path, '/') != NULL ? &strrchr(file_path, '/')[1] :
+                                                               file_path;
+            char const* file_ext = &strrchr(file_path, '.')[1];
+            int time_counter_ms =
+                (options_emulate_timeout[nfc_playlist->settings.emulate_timeout] * 1000);
+
+            if(!strcasestr(file_ext, "nfc")) {
+                if(nfc_playlist->settings.skip_error) {
+                    skip_delay = true;
+                    continue;
+                }
+                furi_string_printf(tmp_header_str, "ERROR invalid file:\n%s", file_name);
+                popup_set_header(
+                    nfc_playlist->popup,
+                    furi_string_get_cstr(tmp_header_str),
+                    64,
+                    10,
+                    AlignCenter,
+                    AlignTop);
+                start_blink(nfc_playlist, NfcPlaylistLedState_Error);
+                while(time_counter_ms > 0 &&
+                      EmulationState == NfcPlaylistEmulationState_Emulating) {
+                    furi_string_printf(tmp_counter_str, "%ds", (time_counter_ms / 1000));
+                    popup_set_text(
+                        nfc_playlist->popup,
+                        furi_string_get_cstr(tmp_counter_str),
+                        64,
+                        50,
+                        AlignCenter,
+                        AlignTop);
+                    furi_delay_ms(50);
+                    time_counter_ms -= 50;
+                };
+            } else if(!storage_file_exists(storage, file_path)) {
+                if(nfc_playlist->settings.skip_error) {
+                    skip_delay = true;
+                    continue;
+                }
+                furi_string_printf(tmp_header_str, "ERROR not found:\n%s", file_name);
+                popup_set_header(
+                    nfc_playlist->popup,
+                    furi_string_get_cstr(tmp_header_str),
+                    64,
+                    10,
+                    AlignCenter,
+                    AlignTop);
+                start_blink(nfc_playlist, NfcPlaylistLedState_Error);
+                while(time_counter_ms > 0 &&
+                      EmulationState == NfcPlaylistEmulationState_Emulating) {
+                    furi_string_printf(tmp_counter_str, "%ds", (time_counter_ms / 1000));
+                    popup_set_text(
+                        nfc_playlist->popup,
+                        furi_string_get_cstr(tmp_counter_str),
+                        64,
+                        50,
+                        AlignCenter,
+                        AlignTop);
+                    furi_delay_ms(50);
+                    time_counter_ms -= 50;
+                };
+            } else {
+                furi_string_printf(tmp_header_str, "Emulating:\n%s", file_name);
+                popup_set_header(
+                    nfc_playlist->popup,
+                    furi_string_get_cstr(tmp_header_str),
+                    64,
+                    10,
+                    AlignCenter,
+                    AlignTop);
+                nfc_playlist_worker_set_nfc_data(nfc_playlist->nfc_playlist_worker, file_path);
+                nfc_playlist_worker_start(nfc_playlist->nfc_playlist_worker);
+                start_blink(nfc_playlist, NfcPlaylistLedState_Normal);
+                while(nfc_playlist_worker_is_emulating(nfc_playlist->nfc_playlist_worker) &&
+                      time_counter_ms > 0 &&
+                      EmulationState == NfcPlaylistEmulationState_Emulating) {
+                    furi_string_printf(tmp_counter_str, "%ds", (time_counter_ms / 1000));
+                    popup_set_text(
+                        nfc_playlist->popup,
+                        furi_string_get_cstr(tmp_counter_str),
+                        64,
+                        50,
+                        AlignCenter,
+                        AlignTop);
+                    furi_delay_ms(50);
+                    time_counter_ms -= 50;
+                };
+                nfc_playlist_worker_stop(nfc_playlist->nfc_playlist_worker);
+                nfc_playlist_worker_clear_nfc_data(nfc_playlist->nfc_playlist_worker);
             }
-            furi_string_printf(tmp_header_str, "ERROR not found:\n%s", file_name);
-            popup_set_header(nfc_playlist->popup, furi_string_get_cstr(tmp_header_str), 64, 10, AlignCenter, AlignTop);
-            start_blink(nfc_playlist, NfcPlaylistLedState_Error);
-            while(time_counter_ms > 0 && EmulationState == NfcPlaylistEmulationState_Emulating) {
-               furi_string_printf(tmp_counter_str, "%ds", (time_counter_ms/1000));
-               popup_set_text(nfc_playlist->popup, furi_string_get_cstr(tmp_counter_str), 64, 50, AlignCenter, AlignTop);
-               furi_delay_ms(50);
-               time_counter_ms -= 50;
-            };
-         } else {
-            furi_string_printf(tmp_header_str, "Emulating:\n%s", file_name);
-            popup_set_header(nfc_playlist->popup, furi_string_get_cstr(tmp_header_str), 64, 10, AlignCenter, AlignTop);
-            nfc_playlist_worker_set_nfc_data(nfc_playlist->nfc_playlist_worker, file_path);
-            nfc_playlist_worker_start(nfc_playlist->nfc_playlist_worker);
-            start_blink(nfc_playlist, NfcPlaylistLedState_Normal);
-            while(nfc_playlist_worker_is_emulating(nfc_playlist->nfc_playlist_worker) && time_counter_ms > 0 && EmulationState == NfcPlaylistEmulationState_Emulating) {
-               furi_string_printf(tmp_counter_str, "%ds", (time_counter_ms/1000));
-               popup_set_text(nfc_playlist->popup, furi_string_get_cstr(tmp_counter_str), 64, 50, AlignCenter, AlignTop);
-               furi_delay_ms(50);
-               time_counter_ms -= 50;
-            };
-            nfc_playlist_worker_stop(nfc_playlist->nfc_playlist_worker);
-            nfc_playlist_worker_clear_nfc_data(nfc_playlist->nfc_playlist_worker);
-         }
-      }
-      popup_reset(nfc_playlist->popup);
-      popup_set_header(nfc_playlist->popup, EmulationState == NfcPlaylistEmulationState_Canceled ? "Emulation stopped" : "Emulation finished", 64, 10, AlignCenter, AlignTop);
-      popup_set_text(nfc_playlist->popup, "Press back", 64, 50, AlignCenter, AlignTop);
-      stop_blink(nfc_playlist);
-
-      EmulationState = NfcPlaylistEmulationState_Stopped;
-      furi_string_free(line);
-      furi_string_free(tmp_header_str);
-      furi_string_free(tmp_counter_str);
-   } else {
-      popup_set_header(nfc_playlist->popup, "Failed to open playlist", 64, 10, AlignCenter, AlignTop);
-      popup_set_text(nfc_playlist->popup, "Press back", 64, 50, AlignCenter, AlignTop);
-   }
-
-   file_stream_close(stream);
-   furi_record_close(RECORD_STORAGE);
-   stream_free(stream);
-
-   return 0;
+        }
+        popup_reset(nfc_playlist->popup);
+        popup_set_header(
+            nfc_playlist->popup,
+            EmulationState == NfcPlaylistEmulationState_Canceled ? "Emulation stopped" :
+                                                                   "Emulation finished",
+            64,
+            10,
+            AlignCenter,
+            AlignTop);
+        popup_set_text(nfc_playlist->popup, "Press back", 64, 50, AlignCenter, AlignTop);
+        stop_blink(nfc_playlist);
+
+        EmulationState = NfcPlaylistEmulationState_Stopped;
+        furi_string_free(line);
+        furi_string_free(tmp_header_str);
+        furi_string_free(tmp_counter_str);
+    } else {
+        popup_set_header(
+            nfc_playlist->popup, "Failed to open playlist", 64, 10, AlignCenter, AlignTop);
+        popup_set_text(nfc_playlist->popup, "Press back", 64, 50, AlignCenter, AlignTop);
+    }
+
+    file_stream_close(stream);
+    furi_record_close(RECORD_STORAGE);
+    stream_free(stream);
+
+    return 0;
 }
 
 void nfc_playlist_emulation_setup(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   nfc_playlist->thread = furi_thread_alloc_ex("NfcPlaylistEmulationWorker", 8192, nfc_playlist_emulation_task, nfc_playlist);
-   nfc_playlist->nfc_playlist_worker = nfc_playlist_worker_alloc();
+    NfcPlaylist* nfc_playlist = context;
+    nfc_playlist->thread = furi_thread_alloc_ex(
+        "NfcPlaylistEmulationWorker", 8192, nfc_playlist_emulation_task, nfc_playlist);
+    nfc_playlist->nfc_playlist_worker = nfc_playlist_worker_alloc();
 }
 
 void nfc_playlist_emulation_free(NfcPlaylist* nfc_playlist) {
-   furi_assert(nfc_playlist);
-   furi_thread_free(nfc_playlist->thread);
-   nfc_playlist_worker_free(nfc_playlist->nfc_playlist_worker);
-   nfc_playlist->thread = NULL;
-   nfc_playlist->nfc_playlist_worker = NULL;
+    furi_assert(nfc_playlist);
+    furi_thread_free(nfc_playlist->thread);
+    nfc_playlist_worker_free(nfc_playlist->nfc_playlist_worker);
+    nfc_playlist->thread = NULL;
+    nfc_playlist->nfc_playlist_worker = NULL;
 }
 
 void nfc_playlist_emulation_start(NfcPlaylist* nfc_playlist) {
-   furi_assert(nfc_playlist);
-   furi_thread_start(nfc_playlist->thread);
+    furi_assert(nfc_playlist);
+    furi_thread_start(nfc_playlist->thread);
 }
 
 void nfc_playlist_emulation_stop(NfcPlaylist* nfc_playlist) {
-   furi_assert(nfc_playlist);
-   furi_thread_join(nfc_playlist->thread);
+    furi_assert(nfc_playlist);
+    furi_thread_join(nfc_playlist->thread);
 }
 
 void nfc_playlist_emulation_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   nfc_playlist_emulation_setup(nfc_playlist);
-   nfc_playlist_emulation_start(nfc_playlist);
+    NfcPlaylist* nfc_playlist = context;
+    nfc_playlist_emulation_setup(nfc_playlist);
+    nfc_playlist_emulation_start(nfc_playlist);
 }
 
 bool nfc_playlist_emulation_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(context);
-   bool consumed = false;
-   if(event.event == 0 && EmulationState == NfcPlaylistEmulationState_Emulating) {
-      EmulationState = NfcPlaylistEmulationState_Canceled;
-      consumed = true;
-   }
-   return consumed;
+    UNUSED(context);
+    bool consumed = false;
+    if(event.event == 0 && EmulationState == NfcPlaylistEmulationState_Emulating) {
+        EmulationState = NfcPlaylistEmulationState_Canceled;
+        consumed = true;
+    }
+    return consumed;
 }
 
 void nfc_playlist_emulation_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   EmulationState = NfcPlaylistEmulationState_Stopped;
-   nfc_playlist_emulation_stop(nfc_playlist);
-   nfc_playlist_emulation_free(nfc_playlist);
-   popup_reset(nfc_playlist->popup);
+    NfcPlaylist* nfc_playlist = context;
+    EmulationState = NfcPlaylistEmulationState_Stopped;
+    nfc_playlist_emulation_stop(nfc_playlist);
+    nfc_playlist_emulation_free(nfc_playlist);
+    popup_reset(nfc_playlist->popup);
 }

nfc_playlist/scenes/nfc_playlist_scene_file_edit.c

@@ -1,102 +1,103 @@
 #include "../nfc_playlist.h"
 
 typedef enum {
-   NfcPlaylistMenuSelection_CreatePlaylist,
-   NfcPlaylistMenuSelection_DeletePlaylist,
-   NfcPlaylistMenuSelection_RenamePlaylist,
-   NfcPlaylistMenuSelection_ViewPlaylistContent,
-   NfcPlaylistMenuSelection_AddNfcItem
+    NfcPlaylistMenuSelection_CreatePlaylist,
+    NfcPlaylistMenuSelection_DeletePlaylist,
+    NfcPlaylistMenuSelection_RenamePlaylist,
+    NfcPlaylistMenuSelection_ViewPlaylistContent,
+    NfcPlaylistMenuSelection_AddNfcItem
 } NfcPlaylistFileEditMenuSelection;
 
 void nfc_playlist_file_edit_menu_callback(void* context, uint32_t index) {
-   NfcPlaylist* nfc_playlist = context;
-   scene_manager_handle_custom_event(nfc_playlist->scene_manager, index);
+    NfcPlaylist* nfc_playlist = context;
+    scene_manager_handle_custom_event(nfc_playlist->scene_manager, index);
 }
 
 void nfc_playlist_file_edit_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
+    NfcPlaylist* nfc_playlist = context;
 
-   submenu_set_header(nfc_playlist->submenu, "Edit Playlist");
+    submenu_set_header(nfc_playlist->submenu, "Edit Playlist");
 
-   submenu_add_item(
-      nfc_playlist->submenu,
-      "Create Playlist",
-      NfcPlaylistMenuSelection_CreatePlaylist,
-      nfc_playlist_file_edit_menu_callback,
-      nfc_playlist);
+    submenu_add_item(
+        nfc_playlist->submenu,
+        "Create Playlist",
+        NfcPlaylistMenuSelection_CreatePlaylist,
+        nfc_playlist_file_edit_menu_callback,
+        nfc_playlist);
 
-   submenu_add_lockable_item(
-      nfc_playlist->submenu,
-      "Delete Playlist",
-      NfcPlaylistMenuSelection_DeletePlaylist,
-      nfc_playlist_file_edit_menu_callback,
-      nfc_playlist,
-      furi_string_empty(nfc_playlist->settings.file_path),
-      "No\nplaylist\nselected");
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "Delete Playlist",
+        NfcPlaylistMenuSelection_DeletePlaylist,
+        nfc_playlist_file_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.file_path),
+        "No\nplaylist\nselected");
 
-   submenu_add_lockable_item(
-      nfc_playlist->submenu,
-      "Rename Playlist",
-      NfcPlaylistMenuSelection_RenamePlaylist,
-      nfc_playlist_file_edit_menu_callback,
-      nfc_playlist,
-      furi_string_empty(nfc_playlist->settings.file_path),
-      "No\nplaylist\nselected");
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "Rename Playlist",
+        NfcPlaylistMenuSelection_RenamePlaylist,
+        nfc_playlist_file_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.file_path),
+        "No\nplaylist\nselected");
 
-   submenu_add_lockable_item(
-      nfc_playlist->submenu,
-      "View Playlist Content",
-      NfcPlaylistMenuSelection_ViewPlaylistContent,
-      nfc_playlist_file_edit_menu_callback,
-      nfc_playlist,
-      furi_string_empty(nfc_playlist->settings.file_path),
-      "No\nplaylist\nselected");
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "View Playlist Content",
+        NfcPlaylistMenuSelection_ViewPlaylistContent,
+        nfc_playlist_file_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.file_path),
+        "No\nplaylist\nselected");
 
-   submenu_add_lockable_item(
-      nfc_playlist->submenu,
-      "Add NFC Item",
-      NfcPlaylistMenuSelection_AddNfcItem,
-      nfc_playlist_file_edit_menu_callback,
-      nfc_playlist,
-      furi_string_empty(nfc_playlist->settings.file_path),
-      "No\nplaylist\nselected");
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "Add NFC Item",
+        NfcPlaylistMenuSelection_AddNfcItem,
+        nfc_playlist_file_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.file_path),
+        "No\nplaylist\nselected");
 
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Submenu);
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Submenu);
 }
 
 bool nfc_playlist_file_edit_scene_on_event(void* context, SceneManagerEvent event) {
-   NfcPlaylist* nfc_playlist = context;
-   bool consumed = false;
-   if(event.type == SceneManagerEventTypeCustom) {
-      switch(event.event) {
-         case NfcPlaylistMenuSelection_CreatePlaylist:
+    NfcPlaylist* nfc_playlist = context;
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case NfcPlaylistMenuSelection_CreatePlaylist:
             scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NameNewFile);
             consumed = true;
             break;
-         case NfcPlaylistMenuSelection_DeletePlaylist:
+        case NfcPlaylistMenuSelection_DeletePlaylist:
             scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_ConfirmDelete);
             consumed = true;
             break;
-         case NfcPlaylistMenuSelection_RenamePlaylist:
+        case NfcPlaylistMenuSelection_RenamePlaylist:
             scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_FileRename);
             consumed = true;
             break;
-         case NfcPlaylistMenuSelection_ViewPlaylistContent:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_ViewPlaylistContent);
+        case NfcPlaylistMenuSelection_ViewPlaylistContent:
+            scene_manager_next_scene(
+                nfc_playlist->scene_manager, NfcPlaylistScene_ViewPlaylistContent);
             consumed = true;
             break;
-         case NfcPlaylistMenuSelection_AddNfcItem:
+        case NfcPlaylistMenuSelection_AddNfcItem:
             scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcSelect);
             consumed = true;
             break;
-         default:
+        default:
             break;
-      }
-   }
-   return consumed;
+        }
+    }
+    return consumed;
 }
 
 void nfc_playlist_file_edit_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   submenu_reset(nfc_playlist->submenu);
+    NfcPlaylist* nfc_playlist = context;
+    submenu_reset(nfc_playlist->submenu);
 }

nfc_playlist/scenes/nfc_playlist_scene_file_rename.c

@@ -1,54 +1,70 @@
 #include "../nfc_playlist.h"
 
 void nfc_playlist_file_rename_menu_callback(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   Storage* storage = furi_record_open(RECORD_STORAGE);
+    NfcPlaylist* nfc_playlist = context;
+    Storage* storage = furi_record_open(RECORD_STORAGE);
 
-   char const* old_file_path = (char*)furi_string_get_cstr(nfc_playlist->settings.file_path);
-   char const* old_file_name = strchr(old_file_path, '/') != NULL ? &strrchr(old_file_path, '/')[1] : old_file_path;
+    char const* old_file_path = (char*)furi_string_get_cstr(nfc_playlist->settings.file_path);
+    char const* old_file_name =
+        strchr(old_file_path, '/') != NULL ? &strrchr(old_file_path, '/')[1] : old_file_path;
 
-   FuriString* tmp_old_file_path = furi_string_alloc_set_str(old_file_path);
-   furi_string_replace(tmp_old_file_path, old_file_name, "");
+    FuriString* tmp_old_file_path = furi_string_alloc_set_str(old_file_path);
+    furi_string_replace(tmp_old_file_path, old_file_name, "");
 
-   FuriString* tmp_new_file_path = furi_string_alloc();
-   furi_string_printf(tmp_new_file_path, "%s%s.txt", furi_string_get_cstr(tmp_old_file_path), nfc_playlist->text_input_output);
+    FuriString* tmp_new_file_path = furi_string_alloc();
+    furi_string_printf(
+        tmp_new_file_path,
+        "%s%s.txt",
+        furi_string_get_cstr(tmp_old_file_path),
+        nfc_playlist->text_input_output);
 
-   if(!storage_file_exists(storage, furi_string_get_cstr(tmp_new_file_path))) {
-      storage_common_rename_safe(storage, furi_string_get_cstr(nfc_playlist->settings.file_path), furi_string_get_cstr(tmp_new_file_path));
-      nfc_playlist->settings.file_path = furi_string_alloc_set_str(furi_string_get_cstr(tmp_new_file_path));
-   }
-   furi_record_close(RECORD_STORAGE);
-   furi_string_free(tmp_new_file_path);
-   furi_string_free(tmp_old_file_path);
+    if(!storage_file_exists(storage, furi_string_get_cstr(tmp_new_file_path))) {
+        storage_common_rename_safe(
+            storage,
+            furi_string_get_cstr(nfc_playlist->settings.file_path),
+            furi_string_get_cstr(tmp_new_file_path));
+        nfc_playlist->settings.file_path =
+            furi_string_alloc_set_str(furi_string_get_cstr(tmp_new_file_path));
+    }
+    furi_record_close(RECORD_STORAGE);
+    furi_string_free(tmp_new_file_path);
+    furi_string_free(tmp_old_file_path);
 
-   scene_manager_previous_scene(nfc_playlist->scene_manager);
+    scene_manager_previous_scene(nfc_playlist->scene_manager);
 }
 
 void nfc_playlist_file_rename_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
+    NfcPlaylist* nfc_playlist = context;
 
-   char const* tmp_file_path = (char*)furi_string_get_cstr(nfc_playlist->settings.file_path);
-   char const* tmp_file_name = strchr(tmp_file_path, '/') != NULL ? &strrchr(tmp_file_path, '/')[1] : tmp_file_path;
+    char const* tmp_file_path = (char*)furi_string_get_cstr(nfc_playlist->settings.file_path);
+    char const* tmp_file_name =
+        strchr(tmp_file_path, '/') != NULL ? &strrchr(tmp_file_path, '/')[1] : tmp_file_path;
 
-   FuriString* tmp_file_name_furi = furi_string_alloc_set_str(tmp_file_name);
-   furi_string_replace(tmp_file_name_furi, ".txt", "");
+    FuriString* tmp_file_name_furi = furi_string_alloc_set_str(tmp_file_name);
+    furi_string_replace(tmp_file_name_furi, ".txt", "");
 
-   nfc_playlist->text_input_output = (char*)furi_string_get_cstr(tmp_file_name_furi);
-   text_input_set_header_text(nfc_playlist->text_input, "Enter new file name");
-   text_input_set_minimum_length(nfc_playlist->text_input, 1);
-   text_input_set_result_callback(nfc_playlist->text_input, nfc_playlist_file_rename_menu_callback, nfc_playlist, nfc_playlist->text_input_output, 50, false);
+    nfc_playlist->text_input_output = (char*)furi_string_get_cstr(tmp_file_name_furi);
+    text_input_set_header_text(nfc_playlist->text_input, "Enter new file name");
+    text_input_set_minimum_length(nfc_playlist->text_input, 1);
+    text_input_set_result_callback(
+        nfc_playlist->text_input,
+        nfc_playlist_file_rename_menu_callback,
+        nfc_playlist,
+        nfc_playlist->text_input_output,
+        50,
+        false);
 
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
 }
 
 bool nfc_playlist_file_rename_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(context);
-   UNUSED(event);
-   return false;
+    UNUSED(context);
+    UNUSED(event);
+    return false;
 }
 
 void nfc_playlist_file_rename_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   text_input_reset(nfc_playlist->text_input);
-   free(nfc_playlist->text_input_output);
+    NfcPlaylist* nfc_playlist = context;
+    text_input_reset(nfc_playlist->text_input);
+    free(nfc_playlist->text_input_output);
 }

nfc_playlist/scenes/nfc_playlist_scene_main_menu.c

@@ -1,99 +1,99 @@
 #include "../nfc_playlist.h"
 
 typedef enum {
-   NfcPlaylistEvent_ShowEmulation,
-   NfcPlaylistEvent_ShowPlaylistSelect,
-   NfcPlaylistEvent_ShowFileEdit,
-   NfcPlaylistEvent_ShowSettings
+    NfcPlaylistEvent_ShowEmulation,
+    NfcPlaylistEvent_ShowPlaylistSelect,
+    NfcPlaylistEvent_ShowFileEdit,
+    NfcPlaylistEvent_ShowSettings
 } NfcPlaylistMainMenuEvent;
 
 typedef enum {
-   NfcPlaylistMenuSelection_Start,
-   NfcPlaylistMenuSelection_PlaylistSelect,
-   NfcPlaylistMenuSelection_FileEdit,
-   NfcPlaylistMenuSelection_Settings
+    NfcPlaylistMenuSelection_Start,
+    NfcPlaylistMenuSelection_PlaylistSelect,
+    NfcPlaylistMenuSelection_FileEdit,
+    NfcPlaylistMenuSelection_Settings
 } NfcPlaylistMainMenuMenuSelection;
 
 void nfc_playlist_main_menu_menu_callback(void* context, uint32_t index) {
-   NfcPlaylist* nfc_playlist = context;
-   scene_manager_handle_custom_event(nfc_playlist->scene_manager, index);
+    NfcPlaylist* nfc_playlist = context;
+    scene_manager_handle_custom_event(nfc_playlist->scene_manager, index);
 }
 
 void nfc_playlist_main_menu_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   if (!nfc_playlist->settings.playlist_selected) {
-      nfc_playlist->settings.playlist_selected = true;
-      scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistSelect);
-      return;
-   }
+    NfcPlaylist* nfc_playlist = context;
+    if(!nfc_playlist->settings.playlist_selected) {
+        nfc_playlist->settings.playlist_selected = true;
+        scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistSelect);
+        return;
+    }
 
-   FuriString* tmp_str = furi_string_alloc();
-   furi_string_printf(tmp_str, "NFC Playlist v%s", FAP_VERSION);
-   submenu_set_header(nfc_playlist->submenu, furi_string_get_cstr(tmp_str));
-   furi_string_free(tmp_str);
+    FuriString* tmp_str = furi_string_alloc();
+    furi_string_printf(tmp_str, "NFC Playlist v%s", FAP_VERSION);
+    submenu_set_header(nfc_playlist->submenu, furi_string_get_cstr(tmp_str));
+    furi_string_free(tmp_str);
 
-   submenu_add_lockable_item(
-      nfc_playlist->submenu,
-      "Start",
-      NfcPlaylistMenuSelection_Start,
-      nfc_playlist_main_menu_menu_callback,
-      nfc_playlist,
-      furi_string_empty(nfc_playlist->settings.file_path),
-      "No\nplaylist\nselected");
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "Start",
+        NfcPlaylistMenuSelection_Start,
+        nfc_playlist_main_menu_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.file_path),
+        "No\nplaylist\nselected");
 
-   submenu_add_item(
-      nfc_playlist->submenu,
-      "Select playlist",
-      NfcPlaylistMenuSelection_PlaylistSelect,
-      nfc_playlist_main_menu_menu_callback,
-      nfc_playlist);
+    submenu_add_item(
+        nfc_playlist->submenu,
+        "Select playlist",
+        NfcPlaylistMenuSelection_PlaylistSelect,
+        nfc_playlist_main_menu_menu_callback,
+        nfc_playlist);
 
-   submenu_add_item(
-      nfc_playlist->submenu,
-      "Edit playlist",
-      NfcPlaylistMenuSelection_FileEdit,
-      nfc_playlist_main_menu_menu_callback,
-      nfc_playlist);
+    submenu_add_item(
+        nfc_playlist->submenu,
+        "Edit playlist",
+        NfcPlaylistMenuSelection_FileEdit,
+        nfc_playlist_main_menu_menu_callback,
+        nfc_playlist);
 
-   submenu_add_item(
-      nfc_playlist->submenu,
-      "Settings",
-      NfcPlaylistMenuSelection_Settings,
-      nfc_playlist_main_menu_menu_callback,
-      nfc_playlist);
+    submenu_add_item(
+        nfc_playlist->submenu,
+        "Settings",
+        NfcPlaylistMenuSelection_Settings,
+        nfc_playlist_main_menu_menu_callback,
+        nfc_playlist);
 
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Submenu);
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Submenu);
 }
 
 bool nfc_playlist_main_menu_scene_on_event(void* context, SceneManagerEvent event) {
-   NfcPlaylist* nfc_playlist = context;
-   bool consumed = false;
-   if (event.type == SceneManagerEventTypeCustom) {
-      switch(event.event) {
-         case NfcPlaylistEvent_ShowEmulation:
+    NfcPlaylist* nfc_playlist = context;
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case NfcPlaylistEvent_ShowEmulation:
             scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Emulation);
             consumed = true;
             break;
-         case NfcPlaylistEvent_ShowPlaylistSelect:
+        case NfcPlaylistEvent_ShowPlaylistSelect:
             scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistSelect);
             consumed = true;
             break;
-         case NfcPlaylistEvent_ShowFileEdit:
+        case NfcPlaylistEvent_ShowFileEdit:
             scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_FileEdit);
             consumed = true;
             break;
-         case NfcPlaylistEvent_ShowSettings:
+        case NfcPlaylistEvent_ShowSettings:
             scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Settings);
             consumed = true;
             break;
-         default:
+        default:
             break;
-      }
-   }
-   return consumed;
+        }
+    }
+    return consumed;
 }
 
 void nfc_playlist_main_menu_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   submenu_reset(nfc_playlist->submenu);
+    NfcPlaylist* nfc_playlist = context;
+    submenu_reset(nfc_playlist->submenu);
 }

nfc_playlist/scenes/nfc_playlist_scene_name_new_file.c

@@ -1,42 +1,49 @@
 #include "../nfc_playlist.h"
 
 void nfc_playlist_name_new_file_menu_callback(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   Storage* storage = furi_record_open(RECORD_STORAGE);
-   FuriString* file_name = furi_string_alloc();
-
-   furi_string_printf(file_name, "/ext/apps_data/nfc_playlist/%s.txt", nfc_playlist->text_input_output);
-
-   File* file = storage_file_alloc(storage);
-   if (storage_file_open(file, furi_string_get_cstr(file_name), FSAM_READ_WRITE, FSOM_CREATE_NEW)) {
-      storage_file_close(file);
-      furi_string_swap(nfc_playlist->settings.file_path, file_name);
-   }
-
-   storage_file_free(file);
-   furi_string_free(file_name);
-   furi_record_close(RECORD_STORAGE);
-   scene_manager_previous_scene(nfc_playlist->scene_manager);
+    NfcPlaylist* nfc_playlist = context;
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    FuriString* file_name = furi_string_alloc();
+
+    furi_string_printf(
+        file_name, "/ext/apps_data/nfc_playlist/%s.txt", nfc_playlist->text_input_output);
+
+    File* file = storage_file_alloc(storage);
+    if(storage_file_open(file, furi_string_get_cstr(file_name), FSAM_READ_WRITE, FSOM_CREATE_NEW)) {
+        storage_file_close(file);
+        furi_string_swap(nfc_playlist->settings.file_path, file_name);
+    }
+
+    storage_file_free(file);
+    furi_string_free(file_name);
+    furi_record_close(RECORD_STORAGE);
+    scene_manager_previous_scene(nfc_playlist->scene_manager);
 }
 
 void nfc_playlist_name_new_file_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   nfc_playlist->text_input_output = (char*)malloc(50);
-   text_input_set_header_text(nfc_playlist->text_input, "Enter file name");
-   text_input_set_minimum_length(nfc_playlist->text_input, 1);
-   text_input_set_result_callback(nfc_playlist->text_input, nfc_playlist_name_new_file_menu_callback, nfc_playlist, nfc_playlist->text_input_output, 50, true);
-
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
+    NfcPlaylist* nfc_playlist = context;
+    nfc_playlist->text_input_output = (char*)malloc(50);
+    text_input_set_header_text(nfc_playlist->text_input, "Enter file name");
+    text_input_set_minimum_length(nfc_playlist->text_input, 1);
+    text_input_set_result_callback(
+        nfc_playlist->text_input,
+        nfc_playlist_name_new_file_menu_callback,
+        nfc_playlist,
+        nfc_playlist->text_input_output,
+        50,
+        true);
+
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
 }
 
 bool nfc_playlist_name_new_file_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(context);
-   UNUSED(event);
-   return false;
+    UNUSED(context);
+    UNUSED(event);
+    return false;
 }
 
 void nfc_playlist_name_new_file_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   text_input_reset(nfc_playlist->text_input);
-   free(nfc_playlist->text_input_output);
+    NfcPlaylist* nfc_playlist = context;
+    text_input_reset(nfc_playlist->text_input);
+    free(nfc_playlist->text_input_output);
 }

nfc_playlist/scenes/nfc_playlist_scene_nfc_select.c

@@ -1,64 +1,68 @@
 #include "../nfc_playlist.h"
 
 void nfc_playlist_nfc_select_menu_callback(void* context) {
-   NfcPlaylist* nfc_playlist = context;
+    NfcPlaylist* nfc_playlist = context;
 
-   Storage* storage = furi_record_open(RECORD_STORAGE);
-   File* file = storage_file_alloc(storage);
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    File* file = storage_file_alloc(storage);
 
-   if (storage_file_open(file, furi_string_get_cstr(nfc_playlist->settings.file_path), FSAM_READ_WRITE, FSOM_OPEN_EXISTING)) {
-      uint8_t buffer[PLAYLIST_VIEW_MAX_SIZE];
-      uint16_t read_count = storage_file_read(file, buffer, PLAYLIST_VIEW_MAX_SIZE);
-      FuriString* playlist_content = furi_string_alloc();
+    if(storage_file_open(
+           file,
+           furi_string_get_cstr(nfc_playlist->settings.file_path),
+           FSAM_READ_WRITE,
+           FSOM_OPEN_EXISTING)) {
+        uint8_t buffer[PLAYLIST_VIEW_MAX_SIZE];
+        uint16_t read_count = storage_file_read(file, buffer, PLAYLIST_VIEW_MAX_SIZE);
+        FuriString* playlist_content = furi_string_alloc();
 
-      for(uint16_t i = 0; i < read_count; i++) {
-         furi_string_push_back(playlist_content, buffer[i]);
-      }
+        for(uint16_t i = 0; i < read_count; i++) {
+            furi_string_push_back(playlist_content, buffer[i]);
+        }
 
-      if (read_count > 0) {
-         furi_string_printf(playlist_content, "\n%s", furi_string_get_cstr(nfc_playlist->file_browser_output));
-      } else {
-         furi_string_printf(playlist_content, "%s", furi_string_get_cstr(nfc_playlist->file_browser_output));
-      }
+        if(read_count > 0) {
+            furi_string_printf(
+                playlist_content, "\n%s", furi_string_get_cstr(nfc_playlist->file_browser_output));
+        } else {
+            furi_string_printf(
+                playlist_content, "%s", furi_string_get_cstr(nfc_playlist->file_browser_output));
+        }
 
-      storage_file_write(file, furi_string_get_cstr(playlist_content), sizeof(char) * furi_string_utf8_length(playlist_content));
+        storage_file_write(
+            file,
+            furi_string_get_cstr(playlist_content),
+            sizeof(char) * furi_string_utf8_length(playlist_content));
 
-      furi_string_free(playlist_content);
-      storage_file_close(file);
-   }
+        furi_string_free(playlist_content);
+        storage_file_close(file);
+    }
 
-   storage_file_free(file);
-   furi_record_close(RECORD_STORAGE);
-   furi_string_reset(nfc_playlist->file_browser_output);
+    storage_file_free(file);
+    furi_record_close(RECORD_STORAGE);
+    furi_string_reset(nfc_playlist->file_browser_output);
 
-   scene_manager_previous_scene(nfc_playlist->scene_manager);
+    scene_manager_previous_scene(nfc_playlist->scene_manager);
 }
 
 void nfc_playlist_nfc_select_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   file_browser_configure(
-      nfc_playlist->file_browser,
-      ".nfc",
-      "/ext/nfc/",
-      true,
-      true,
-      &I_Nfc_10px,
-      true);
-   file_browser_set_callback(nfc_playlist->file_browser, nfc_playlist_nfc_select_menu_callback, nfc_playlist);
-   FuriString* tmp_str = furi_string_alloc_set_str("/ext/nfc/");
-   file_browser_start(nfc_playlist->file_browser, tmp_str);
-   furi_string_free(tmp_str);
+    NfcPlaylist* nfc_playlist = context;
+    file_browser_configure(
+        nfc_playlist->file_browser, ".nfc", "/ext/nfc/", true, true, &I_Nfc_10px, true);
+    file_browser_set_callback(
+        nfc_playlist->file_browser, nfc_playlist_nfc_select_menu_callback, nfc_playlist);
+    FuriString* tmp_str = furi_string_alloc_set_str("/ext/nfc/");
+    file_browser_start(nfc_playlist->file_browser, tmp_str);
+    furi_string_free(tmp_str);
 
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileBrowser);
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileBrowser);
 }
 
 bool nfc_playlist_nfc_select_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(event);
-   UNUSED(context);
-   return false;
+    UNUSED(event);
+    UNUSED(context);
+    return false;
 }
 
 void nfc_playlist_nfc_select_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   file_browser_stop(nfc_playlist->file_browser);
+    NfcPlaylist* nfc_playlist = context;
+    file_browser_stop(nfc_playlist->file_browser);
 }

nfc_playlist/scenes/nfc_playlist_scene_playlist_select.c

@@ -1,37 +1,32 @@
 #include "../nfc_playlist.h"
 
 void nfc_playlist_playlist_select_menu_callback(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   furi_string_swap(nfc_playlist->settings.file_path, nfc_playlist->file_browser_output);
-   furi_string_reset(nfc_playlist->file_browser_output);
-   scene_manager_previous_scene(nfc_playlist->scene_manager);
+    NfcPlaylist* nfc_playlist = context;
+    furi_string_swap(nfc_playlist->settings.file_path, nfc_playlist->file_browser_output);
+    furi_string_reset(nfc_playlist->file_browser_output);
+    scene_manager_previous_scene(nfc_playlist->scene_manager);
 }
 
 void nfc_playlist_playlist_select_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   file_browser_configure(
-      nfc_playlist->file_browser,
-      ".txt",
-      PLAYLIST_LOCATION,
-      true,
-      true,
-      &I_unknown_10px,
-      true);
-   file_browser_set_callback(nfc_playlist->file_browser, nfc_playlist_playlist_select_menu_callback, nfc_playlist);
-   FuriString* tmp_str = furi_string_alloc_set_str(PLAYLIST_LOCATION);
-   file_browser_start(nfc_playlist->file_browser, tmp_str);
-   furi_string_free(tmp_str);
+    NfcPlaylist* nfc_playlist = context;
+    file_browser_configure(
+        nfc_playlist->file_browser, ".txt", PLAYLIST_LOCATION, true, true, &I_unknown_10px, true);
+    file_browser_set_callback(
+        nfc_playlist->file_browser, nfc_playlist_playlist_select_menu_callback, nfc_playlist);
+    FuriString* tmp_str = furi_string_alloc_set_str(PLAYLIST_LOCATION);
+    file_browser_start(nfc_playlist->file_browser, tmp_str);
+    furi_string_free(tmp_str);
 
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileBrowser);
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileBrowser);
 }
 
 bool nfc_playlist_playlist_select_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(event);
-   UNUSED(context);
-   return false;
+    UNUSED(event);
+    UNUSED(context);
+    return false;
 }
 
 void nfc_playlist_playlist_select_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   file_browser_stop(nfc_playlist->file_browser);
+    NfcPlaylist* nfc_playlist = context;
+    file_browser_stop(nfc_playlist->file_browser);
 }

nfc_playlist/scenes/nfc_playlist_scene_settings.c

@@ -1,145 +1,177 @@
 #include "../nfc_playlist.h"
 
 typedef enum {
-   NfcPlaylistSettings_Timeout,
-   NfcPlaylistSettings_Delay,
-   NfcPlaylistSettings_LedIndicator,
-   NfcPlaylistSettings_SkipError,
-   NfcPlaylistSettings_Reset
+    NfcPlaylistSettings_Timeout,
+    NfcPlaylistSettings_Delay,
+    NfcPlaylistSettings_LedIndicator,
+    NfcPlaylistSettings_SkipError,
+    NfcPlaylistSettings_Reset
 } NfcPlaylistSettingsMenuSelection;
 
 void nfc_playlist_settings_menu_callback(void* context, uint32_t index) {
-   NfcPlaylist* nfc_playlist = context;
-   scene_manager_handle_custom_event(nfc_playlist->scene_manager, index);
+    NfcPlaylist* nfc_playlist = context;
+    scene_manager_handle_custom_event(nfc_playlist->scene_manager, index);
 }
 
 void nfc_playlist_settings_options_change_callback(VariableItem* item) {
-   NfcPlaylist* nfc_playlist = variable_item_get_context(item);
-
-   uint8_t current_option = variable_item_list_get_selected_item_index(nfc_playlist->variable_item_list);
-   uint8_t option_value_index = variable_item_get_current_value_index(item);
-   FuriString* tmp_str = furi_string_alloc();
-   switch(current_option) {
-      case NfcPlaylistSettings_Timeout:
-         nfc_playlist->settings.emulate_timeout = option_value_index;
-         furi_string_printf(tmp_str, "%ds", options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
-         variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
-         break;
-      case NfcPlaylistSettings_Delay:
-         nfc_playlist->settings.emulate_delay = option_value_index;
-         furi_string_printf(tmp_str, "%ds", options_emulate_delay[nfc_playlist->settings.emulate_delay]);
-         variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
-         break;
-      case NfcPlaylistSettings_LedIndicator:
-         nfc_playlist->settings.emulate_led_indicator = option_value_index;
-         variable_item_set_current_value_text(item, nfc_playlist->settings.emulate_led_indicator ? "ON" : "OFF");
-         break;
-      case NfcPlaylistSettings_SkipError:
-         nfc_playlist->settings.skip_error = option_value_index;
-         variable_item_set_current_value_text(item, nfc_playlist->settings.skip_error ? "ON" : "OFF");
-         break;
-      default:
-         break;
-   }
-   furi_string_free(tmp_str);
+    NfcPlaylist* nfc_playlist = variable_item_get_context(item);
+
+    uint8_t current_option =
+        variable_item_list_get_selected_item_index(nfc_playlist->variable_item_list);
+    uint8_t option_value_index = variable_item_get_current_value_index(item);
+    FuriString* tmp_str = furi_string_alloc();
+    switch(current_option) {
+    case NfcPlaylistSettings_Timeout:
+        nfc_playlist->settings.emulate_timeout = option_value_index;
+        furi_string_printf(
+            tmp_str, "%ds", options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
+        variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
+        break;
+    case NfcPlaylistSettings_Delay:
+        nfc_playlist->settings.emulate_delay = option_value_index;
+        furi_string_printf(
+            tmp_str, "%ds", options_emulate_delay[nfc_playlist->settings.emulate_delay]);
+        variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
+        break;
+    case NfcPlaylistSettings_LedIndicator:
+        nfc_playlist->settings.emulate_led_indicator = option_value_index;
+        variable_item_set_current_value_text(
+            item, nfc_playlist->settings.emulate_led_indicator ? "ON" : "OFF");
+        break;
+    case NfcPlaylistSettings_SkipError:
+        nfc_playlist->settings.skip_error = option_value_index;
+        variable_item_set_current_value_text(
+            item, nfc_playlist->settings.skip_error ? "ON" : "OFF");
+        break;
+    default:
+        break;
+    }
+    furi_string_free(tmp_str);
 }
 
 void nfc_playlist_settings_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   FuriString* tmp_str = furi_string_alloc();
-
-   variable_item_list_set_header(nfc_playlist->variable_item_list, "Settings");
-
-   VariableItem* emulation_timeout_setting = variable_item_list_add(
-      nfc_playlist->variable_item_list,
-      "Emulate time",
-      (sizeof(options_emulate_timeout)/sizeof(options_emulate_timeout[0])),
-      nfc_playlist_settings_options_change_callback,
-      nfc_playlist);
-   variable_item_set_current_value_index(emulation_timeout_setting, nfc_playlist->settings.emulate_timeout);
-   furi_string_printf(tmp_str, "%ds", options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
-   variable_item_set_current_value_text(emulation_timeout_setting, furi_string_get_cstr(tmp_str));
-
-   VariableItem* emulation_delay_setting = variable_item_list_add(
-      nfc_playlist->variable_item_list,
-      "Delay time",
-      (sizeof(options_emulate_delay)/sizeof(options_emulate_delay[0])),
-      nfc_playlist_settings_options_change_callback,
-      nfc_playlist);
-   variable_item_set_current_value_index(emulation_delay_setting, nfc_playlist->settings.emulate_delay);
-   furi_string_printf(tmp_str, "%ds", options_emulate_delay[nfc_playlist->settings.emulate_delay]);
-   variable_item_set_current_value_text(emulation_delay_setting, furi_string_get_cstr(tmp_str));
-
-   VariableItem* emulation_led_indicator_setting = variable_item_list_add(
-      nfc_playlist->variable_item_list,
-      "LED Indicator",
-      2,
-      nfc_playlist_settings_options_change_callback,
-      nfc_playlist);
-   variable_item_set_current_value_index(emulation_led_indicator_setting, nfc_playlist->settings.emulate_led_indicator);
-   variable_item_set_current_value_text(emulation_led_indicator_setting, nfc_playlist->settings.emulate_led_indicator ? "ON" : "OFF");
-
-   VariableItem* emulation_skip_error_setting = variable_item_list_add(
-      nfc_playlist->variable_item_list,
-      "Skip Error",
-      2,
-      nfc_playlist_settings_options_change_callback,
-      nfc_playlist);
-   variable_item_set_current_value_index(emulation_skip_error_setting, nfc_playlist->settings.skip_error);
-   variable_item_set_current_value_text(emulation_skip_error_setting, nfc_playlist->settings.skip_error ? "ON" : "OFF");
-
-   variable_item_list_add(nfc_playlist->variable_item_list, "Reset settings", 0, NULL, NULL);
-
-   VariableItem* credits = variable_item_list_add(nfc_playlist->variable_item_list, "acegoal07", 1, NULL, NULL);
-   variable_item_set_current_value_text(credits, "Credits");
-
-   variable_item_list_set_enter_callback(nfc_playlist->variable_item_list, nfc_playlist_settings_menu_callback, nfc_playlist);
-   furi_string_free(tmp_str);
-
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList);
+    NfcPlaylist* nfc_playlist = context;
+    FuriString* tmp_str = furi_string_alloc();
+
+    variable_item_list_set_header(nfc_playlist->variable_item_list, "Settings");
+
+    VariableItem* emulation_timeout_setting = variable_item_list_add(
+        nfc_playlist->variable_item_list,
+        "Emulate time",
+        (sizeof(options_emulate_timeout) / sizeof(options_emulate_timeout[0])),
+        nfc_playlist_settings_options_change_callback,
+        nfc_playlist);
+    variable_item_set_current_value_index(
+        emulation_timeout_setting, nfc_playlist->settings.emulate_timeout);
+    furi_string_printf(
+        tmp_str, "%ds", options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
+    variable_item_set_current_value_text(emulation_timeout_setting, furi_string_get_cstr(tmp_str));
+
+    VariableItem* emulation_delay_setting = variable_item_list_add(
+        nfc_playlist->variable_item_list,
+        "Delay time",
+        (sizeof(options_emulate_delay) / sizeof(options_emulate_delay[0])),
+        nfc_playlist_settings_options_change_callback,
+        nfc_playlist);
+    variable_item_set_current_value_index(
+        emulation_delay_setting, nfc_playlist->settings.emulate_delay);
+    furi_string_printf(
+        tmp_str, "%ds", options_emulate_delay[nfc_playlist->settings.emulate_delay]);
+    variable_item_set_current_value_text(emulation_delay_setting, furi_string_get_cstr(tmp_str));
+
+    VariableItem* emulation_led_indicator_setting = variable_item_list_add(
+        nfc_playlist->variable_item_list,
+        "LED Indicator",
+        2,
+        nfc_playlist_settings_options_change_callback,
+        nfc_playlist);
+    variable_item_set_current_value_index(
+        emulation_led_indicator_setting, nfc_playlist->settings.emulate_led_indicator);
+    variable_item_set_current_value_text(
+        emulation_led_indicator_setting,
+        nfc_playlist->settings.emulate_led_indicator ? "ON" : "OFF");
+
+    VariableItem* emulation_skip_error_setting = variable_item_list_add(
+        nfc_playlist->variable_item_list,
+        "Skip Error",
+        2,
+        nfc_playlist_settings_options_change_callback,
+        nfc_playlist);
+    variable_item_set_current_value_index(
+        emulation_skip_error_setting, nfc_playlist->settings.skip_error);
+    variable_item_set_current_value_text(
+        emulation_skip_error_setting, nfc_playlist->settings.skip_error ? "ON" : "OFF");
+
+    variable_item_list_add(nfc_playlist->variable_item_list, "Reset settings", 0, NULL, NULL);
+
+    VariableItem* credits =
+        variable_item_list_add(nfc_playlist->variable_item_list, "acegoal07", 1, NULL, NULL);
+    variable_item_set_current_value_text(credits, "Credits");
+
+    variable_item_list_set_enter_callback(
+        nfc_playlist->variable_item_list, nfc_playlist_settings_menu_callback, nfc_playlist);
+    furi_string_free(tmp_str);
+
+    view_dispatcher_switch_to_view(
+        nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList);
 }
 
 bool nfc_playlist_settings_scene_on_event(void* context, SceneManagerEvent event) {
-   NfcPlaylist* nfc_playlist = context;
-   bool consumed = false;
-   if (event.type == SceneManagerEventTypeCustom) {
-      switch(event.event) {
-         case NfcPlaylistSettings_Reset:
+    NfcPlaylist* nfc_playlist = context;
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case NfcPlaylistSettings_Reset:
             FuriString* tmp_str = furi_string_alloc();
 
             nfc_playlist->settings.emulate_timeout = default_emulate_timeout;
-            VariableItem* emulation_timeout_setting = variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistSettings_Timeout);
-            variable_item_set_current_value_index(emulation_timeout_setting, nfc_playlist->settings.emulate_timeout);
-            furi_string_printf(tmp_str, "%ds", options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
-            variable_item_set_current_value_text(emulation_timeout_setting, furi_string_get_cstr(tmp_str));
+            VariableItem* emulation_timeout_setting = variable_item_list_get(
+                nfc_playlist->variable_item_list, NfcPlaylistSettings_Timeout);
+            variable_item_set_current_value_index(
+                emulation_timeout_setting, nfc_playlist->settings.emulate_timeout);
+            furi_string_printf(
+                tmp_str, "%ds", options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
+            variable_item_set_current_value_text(
+                emulation_timeout_setting, furi_string_get_cstr(tmp_str));
 
             nfc_playlist->settings.emulate_delay = default_emulate_delay;
-            VariableItem* emulation_delay_setting = variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistSettings_Delay);
-            variable_item_set_current_value_index(emulation_delay_setting, nfc_playlist->settings.emulate_delay);
-            furi_string_printf(tmp_str, "%ds", options_emulate_delay[nfc_playlist->settings.emulate_delay]);
-            variable_item_set_current_value_text(emulation_delay_setting, furi_string_get_cstr(tmp_str));
+            VariableItem* emulation_delay_setting = variable_item_list_get(
+                nfc_playlist->variable_item_list, NfcPlaylistSettings_Delay);
+            variable_item_set_current_value_index(
+                emulation_delay_setting, nfc_playlist->settings.emulate_delay);
+            furi_string_printf(
+                tmp_str, "%ds", options_emulate_delay[nfc_playlist->settings.emulate_delay]);
+            variable_item_set_current_value_text(
+                emulation_delay_setting, furi_string_get_cstr(tmp_str));
 
             nfc_playlist->settings.emulate_led_indicator = default_emulate_led_indicator;
-            VariableItem* emulation_led_indicator_setting = variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistSettings_LedIndicator);
-            variable_item_set_current_value_index(emulation_led_indicator_setting, nfc_playlist->settings.emulate_led_indicator);
-            variable_item_set_current_value_text(emulation_led_indicator_setting, nfc_playlist->settings.emulate_led_indicator ? "ON" : "OFF");
+            VariableItem* emulation_led_indicator_setting = variable_item_list_get(
+                nfc_playlist->variable_item_list, NfcPlaylistSettings_LedIndicator);
+            variable_item_set_current_value_index(
+                emulation_led_indicator_setting, nfc_playlist->settings.emulate_led_indicator);
+            variable_item_set_current_value_text(
+                emulation_led_indicator_setting,
+                nfc_playlist->settings.emulate_led_indicator ? "ON" : "OFF");
 
             nfc_playlist->settings.skip_error = default_skip_error;
-            VariableItem* emulation_skip_error_setting = variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistSettings_SkipError);
-            variable_item_set_current_value_index(emulation_skip_error_setting, nfc_playlist->settings.skip_error);
-            variable_item_set_current_value_text(emulation_skip_error_setting, nfc_playlist->settings.skip_error ? "ON" : "OFF");
+            VariableItem* emulation_skip_error_setting = variable_item_list_get(
+                nfc_playlist->variable_item_list, NfcPlaylistSettings_SkipError);
+            variable_item_set_current_value_index(
+                emulation_skip_error_setting, nfc_playlist->settings.skip_error);
+            variable_item_set_current_value_text(
+                emulation_skip_error_setting, nfc_playlist->settings.skip_error ? "ON" : "OFF");
 
             furi_string_free(tmp_str);
             consumed = true;
             break;
-         default:
+        default:
             break;
-      }
-   }
-   return consumed;
+        }
+    }
+    return consumed;
 }
 
 void nfc_playlist_settings_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   variable_item_list_reset(nfc_playlist->variable_item_list);
+    NfcPlaylist* nfc_playlist = context;
+    variable_item_list_reset(nfc_playlist->variable_item_list);
 }

nfc_playlist/scenes/nfc_playlist_scene_view_playlist_content.c

@@ -1,42 +1,56 @@
 #include "../nfc_playlist.h"
 
 void nfc_playlist_view_playlist_content_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-
-   Storage* storage = furi_record_open(RECORD_STORAGE);
-   File* file = storage_file_alloc(storage);
-
-   if (storage_file_open(file, furi_string_get_cstr(nfc_playlist->settings.file_path), FSAM_READ, FSOM_OPEN_EXISTING)) {
-      uint8_t buffer[PLAYLIST_VIEW_MAX_SIZE];
-      uint16_t read_count = storage_file_read(file, buffer, PLAYLIST_VIEW_MAX_SIZE);
-      FuriString* playlist_content = furi_string_alloc();
-
-      for(uint16_t i = 0; i < read_count; i++) {
-         furi_string_push_back(playlist_content, buffer[i]);
-      }
-
-      widget_add_text_scroll_element(nfc_playlist->widget, 4, 4, 124, 60, furi_string_get_cstr(playlist_content));
-      widget_add_frame_element(nfc_playlist->widget, 0, 0, 128, 64, 0);
-
-      furi_string_free(playlist_content);
-      storage_file_close(file);
-   } else {
-      widget_add_text_box_element(nfc_playlist->widget, 0, 0, 128, 64, AlignCenter, AlignCenter, "\eFailed to open playlist\n\nPress back\e", false);
-   }
-
-   storage_file_free(file);
-   furi_record_close(RECORD_STORAGE);
-
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Widget);
+    NfcPlaylist* nfc_playlist = context;
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    File* file = storage_file_alloc(storage);
+
+    if(storage_file_open(
+           file,
+           furi_string_get_cstr(nfc_playlist->settings.file_path),
+           FSAM_READ,
+           FSOM_OPEN_EXISTING)) {
+        uint8_t buffer[PLAYLIST_VIEW_MAX_SIZE];
+        uint16_t read_count = storage_file_read(file, buffer, PLAYLIST_VIEW_MAX_SIZE);
+        FuriString* playlist_content = furi_string_alloc();
+
+        for(uint16_t i = 0; i < read_count; i++) {
+            furi_string_push_back(playlist_content, buffer[i]);
+        }
+
+        widget_add_text_scroll_element(
+            nfc_playlist->widget, 4, 4, 124, 60, furi_string_get_cstr(playlist_content));
+        widget_add_frame_element(nfc_playlist->widget, 0, 0, 128, 64, 0);
+
+        furi_string_free(playlist_content);
+        storage_file_close(file);
+    } else {
+        widget_add_text_box_element(
+            nfc_playlist->widget,
+            0,
+            0,
+            128,
+            64,
+            AlignCenter,
+            AlignCenter,
+            "\eFailed to open playlist\n\nPress back\e",
+            false);
+    }
+
+    storage_file_free(file);
+    furi_record_close(RECORD_STORAGE);
+
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Widget);
 }
 
 bool nfc_playlist_view_playlist_content_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(context);
-   UNUSED(event);
-   return false;
+    UNUSED(context);
+    UNUSED(event);
+    return false;
 }
 
 void nfc_playlist_view_playlist_content_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   widget_reset(nfc_playlist->widget);
+    NfcPlaylist* nfc_playlist = context;
+    widget_reset(nfc_playlist->widget);
 }