Merge pull request #41 from acegoal07/dev

Dev

README.md

@@ -3,14 +3,16 @@ The idea behind this app is to allow for you to test multiple copies of NFC's at
 ## How it works:
 When starting the app you are greeted by a select file option where you choose the playlist you wanna run.
 
-All the playlists should be placed in ext/apps_data/nfc_playlist and an example of how the data in the file should look can be found below.
+All the playlists should be placed in ext/apps_data/nfc_playlist but can be placed in other file locations and an example of how the data in the file should look can be found below along with a example file in the repository.
 ```txt
 /ext/nfc/link.nfc
 /ext/nfc/link2.nfc
 ```
 An example file can be found in the repository
-## How to build
-This app was design, built and tested using the <a href="https://github.com/Next-Flip/Momentum-Firmware">Momentum</a> so keep that in mind when building the FAP for yourself
+## Feedback:
+Any feedback is welcome and would be very much appreciated as this is my first C project
+- <a href="https://github.com/acegoal07/FlipperZero_NFC_Playlist/issues/new?assignees=acegoal07&labels=enhancement&projects=&template=feature_request.md&title=%5BFEATURE%7D">Feature request</a>
+- <a href="https://github.com/acegoal07/FlipperZero_NFC_Playlist/issues/new?assignees=acegoal07&labels=bug&projects=&template=bug_report.md&title=%5BBUG%5D">Bug report</a>
 ## Supported Firmwares
 As i know these firmwares are supported and working if you know any more please let me know
 - <a href="https://github.com/Next-Flip/Momentum-Firmware">Momentum</a>
@@ -31,6 +33,4 @@ As i know these firmwares are supported and working if you know any more please
 - View playlist content (Allows you to view the contents of the playlist)
 ## Feature ideas:
 - A function to allow you to add multiple nfc items to a playlist at once
-- A view playlist function which only shows the name of the playlist items excluding the file path
-
-Any feedback is welcome and would be very much appreciated
+- A view playlist function which only shows the name of the playlist items excluding the file path

application.fam

@@ -8,7 +8,7 @@ App(
     fap_category="NFC",
     fap_author="@acegoal07",
     fap_weburl="https://github.com/acegoal07/FlipperZero_NFC_Playlist/tree/main",
-    fap_version="2.5",
+    fap_version="2.6",
     fap_icon_assets="assets",
     fap_icon="assets/Playlist_10px.png",
     fap_private_libs=[

lib/emulation_worker/nfc_playlist_emulation_worker.c

@@ -1,8 +1,13 @@
 #include "nfc_playlist_emulation_worker.h"
 
 NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker_alloc() {
-   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker = malloc(sizeof(NfcPlaylistEmulationWorker));
-   nfc_playlist_emulation_worker->thread = furi_thread_alloc_ex("NfcPlaylistEmulationWorker", 4096, nfc_playlist_emulation_worker_task, nfc_playlist_emulation_worker);
+   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker =
+      malloc(sizeof(NfcPlaylistEmulationWorker));
+   nfc_playlist_emulation_worker->thread = furi_thread_alloc_ex(
+      "NfcPlaylistEmulationWorker",
+      4096,
+      nfc_playlist_emulation_worker_task,
+      nfc_playlist_emulation_worker);
    nfc_playlist_emulation_worker->state = NfcPlaylistEmulationWorkerState_Stopped;
    nfc_playlist_emulation_worker->nfc = nfc_alloc();
    nfc_playlist_emulation_worker->nfc_device = nfc_device_alloc();
@@ -19,13 +24,14 @@ void nfc_playlist_emulation_worker_free(NfcPlaylistEmulationWorker* nfc_playlist
 
 void nfc_playlist_emulation_worker_stop(NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker) {
    furi_assert(nfc_playlist_emulation_worker);
-   if (nfc_playlist_emulation_worker->state != NfcPlaylistEmulationWorkerState_Stopped) {
+   if(nfc_playlist_emulation_worker->state != NfcPlaylistEmulationWorkerState_Stopped) {
       nfc_playlist_emulation_worker->state = NfcPlaylistEmulationWorkerState_Stopped;
       furi_thread_join(nfc_playlist_emulation_worker->thread);
    }
 }
 
-void nfc_playlist_emulation_worker_start(NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker) {
+void nfc_playlist_emulation_worker_start(
+   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker) {
    furi_assert(nfc_playlist_emulation_worker);
    nfc_playlist_emulation_worker->state = NfcPlaylistEmulationWorkerState_Emulating;
    furi_thread_start(nfc_playlist_emulation_worker->thread);
@@ -34,13 +40,13 @@ void nfc_playlist_emulation_worker_start(NfcPlaylistEmulationWorker* nfc_playlis
 int32_t nfc_playlist_emulation_worker_task(void* context) {
    NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker = context;
 
-   if (nfc_playlist_emulation_worker->state == NfcPlaylistEmulationWorkerState_Emulating) {
-
-      nfc_playlist_emulation_worker->nfc_listener =
-         nfc_listener_alloc(nfc_playlist_emulation_worker->nfc,
-            nfc_playlist_emulation_worker->nfc_protocol,
-            nfc_device_get_data(nfc_playlist_emulation_worker->nfc_device, nfc_playlist_emulation_worker->nfc_protocol)
-         );
+   if(nfc_playlist_emulation_worker->state == NfcPlaylistEmulationWorkerState_Emulating) {
+      nfc_playlist_emulation_worker->nfc_listener = nfc_listener_alloc(
+         nfc_playlist_emulation_worker->nfc,
+         nfc_playlist_emulation_worker->nfc_protocol,
+         nfc_device_get_data(
+            nfc_playlist_emulation_worker->nfc_device,
+            nfc_playlist_emulation_worker->nfc_protocol));
       nfc_listener_start(nfc_playlist_emulation_worker->nfc_listener, NULL, NULL);
 
       while(nfc_playlist_emulation_worker->state == NfcPlaylistEmulationWorkerState_Emulating) {
@@ -56,18 +62,23 @@ int32_t nfc_playlist_emulation_worker_task(void* context) {
    return 0;
 }
 
-bool nfc_playlist_emulation_worker_is_emulating(NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker) {
+bool nfc_playlist_emulation_worker_is_emulating(
+   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker) {
    furi_assert(nfc_playlist_emulation_worker);
    return nfc_playlist_emulation_worker->state == NfcPlaylistEmulationWorkerState_Emulating;
 }
 
-void nfc_playlist_emulation_worker_set_nfc_data(NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker, char* file_path) {
+void nfc_playlist_emulation_worker_set_nfc_data(
+   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker,
+   char* file_path) {
    furi_assert(nfc_playlist_emulation_worker);
    nfc_device_load(nfc_playlist_emulation_worker->nfc_device, file_path);
-   nfc_playlist_emulation_worker->nfc_protocol = nfc_device_get_protocol(nfc_playlist_emulation_worker->nfc_device);
+   nfc_playlist_emulation_worker->nfc_protocol =
+      nfc_device_get_protocol(nfc_playlist_emulation_worker->nfc_device);
 }
 
-void nfc_playlist_emulation_worker_clear_nfc_data(NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker) {
+void nfc_playlist_emulation_worker_clear_nfc_data(
+   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker) {
    furi_assert(nfc_playlist_emulation_worker);
    nfc_device_clear(nfc_playlist_emulation_worker->nfc_device);
-}
+}

lib/emulation_worker/nfc_playlist_emulation_worker.h

@@ -26,6 +26,10 @@ void nfc_playlist_emulation_worker_start(NfcPlaylistEmulationWorker* nfc_playlis
 
 int32_t nfc_playlist_emulation_worker_task(void* context);
 
-bool nfc_playlist_emulation_worker_is_emulating(NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker);
-void nfc_playlist_emulation_worker_set_nfc_data(NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker, char* file_path);
-void nfc_playlist_emulation_worker_clear_nfc_data(NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker);
+bool nfc_playlist_emulation_worker_is_emulating(
+   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker);
+void nfc_playlist_emulation_worker_set_nfc_data(
+   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker,
+   char* file_path);
+void nfc_playlist_emulation_worker_clear_nfc_data(
+   NfcPlaylistEmulationWorker* nfc_playlist_emulation_worker);

nfc_playlist.c

@@ -19,7 +19,7 @@ static NfcPlaylist* nfc_playlist_alloc() {
    nfc_playlist->view_dispatcher = view_dispatcher_alloc();
    nfc_playlist->variable_item_list = variable_item_list_alloc();
    nfc_playlist->submenu = submenu_alloc();
-   nfc_playlist->widget= widget_alloc();
+   nfc_playlist->widget = widget_alloc();
 
    nfc_playlist->settings.playlist_path = furi_string_alloc();
    nfc_playlist->file_browser_output = furi_string_alloc();
@@ -35,15 +35,33 @@ static NfcPlaylist* nfc_playlist_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));
+   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);
    storage_simply_mkdir(storage, PLAYLIST_DIR);
@@ -80,11 +98,11 @@ static void nfc_playlist_free(NfcPlaylist* nfc_playlist) {
 }
 
 void nfc_playlist_set_log_level() {
-   #ifdef FURI_DEBUG
-      furi_log_set_level(FuriLogLevelTrace);
-   #else
-      furi_log_set_level(FuriLogLevelInfo);
-   #endif
+#ifdef FURI_DEBUG
+   furi_log_set_level(FuriLogLevelTrace);
+#else
+   furi_log_set_level(FuriLogLevelInfo);
+#endif
 }
 
 int32_t nfc_playlist_main(void* p) {
@@ -109,44 +127,40 @@ NotificationMessage blink_message_normal = {
    .type = NotificationMessageTypeLedBlinkStart,
    .data.led_blink.color = LightBlue | LightGreen,
    .data.led_blink.on_time = 10,
-   .data.led_blink.period = 100
-};
+   .data.led_blink.period = 100};
 const NotificationSequence blink_sequence_normal = {
    &blink_message_normal,
    &message_do_not_reset,
-   NULL
-};
+   NULL};
 
 NotificationMessage blink_message_error = {
    .type = NotificationMessageTypeLedBlinkStart,
    .data.led_blink.color = LightRed,
    .data.led_blink.on_time = 10,
-   .data.led_blink.period = 100
-};
+   .data.led_blink.period = 100};
 
 const NotificationSequence blink_sequence_error = {
    &blink_message_error,
    &message_do_not_reset,
-   NULL
-};
+   NULL};
 
 void start_blink(NfcPlaylist* nfc_playlist, int state) {
-   if (nfc_playlist->settings.emulate_led_indicator) {
-      switch (state) {
-         case NfcPlaylistLedState_Normal:
-            notification_message_block(nfc_playlist->notification, &blink_sequence_normal);
-            break;
-         case NfcPlaylistLedState_Error:
-            notification_message_block(nfc_playlist->notification, &blink_sequence_error);
-            break;
-         default:
-            break;
+   if(nfc_playlist->settings.emulate_led_indicator) {
+      switch(state) {
+      case NfcPlaylistLedState_Normal:
+         notification_message_block(nfc_playlist->notification, &blink_sequence_normal);
+         break;
+      case NfcPlaylistLedState_Error:
+         notification_message_block(nfc_playlist->notification, &blink_sequence_error);
+         break;
+      default:
+         break;
       }
    }
 }
 
 void stop_blink(NfcPlaylist* nfc_playlist) {
-   if (nfc_playlist->settings.emulate_led_indicator) {
+   if(nfc_playlist->settings.emulate_led_indicator) {
       notification_message_block(nfc_playlist->notification, &sequence_blink_stop);
    }
-}
+}

nfc_playlist.h

@@ -29,9 +29,9 @@
 
 #include "scenes/nfc_playlist_scene.h"
 
-#define PLAYLIST_LOCATION "/ext/apps_data/nfc_playlist/"
-#define PLAYLIST_DIR "/ext/apps_data/nfc_playlist"
-#define NFC_ITEM_LOCATION "/ext/nfc/"
+#define PLAYLIST_LOCATION     "/ext/apps_data/nfc_playlist/"
+#define PLAYLIST_DIR          "/ext/apps_data/nfc_playlist"
+#define NFC_ITEM_LOCATION     "/ext/nfc/"
 #define MAX_PLAYLIST_NAME_LEN 50
 
 typedef enum {

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,
+};

scenes/nfc_playlist_scene.h

@@ -26,4 +26,4 @@ extern const SceneManagerHandlers nfc_playlist_scene_handlers;
 // Generate scene on_exit handlers declaration
 #define ADD_SCENE(prefix, name, id) void prefix##_##name##_scene_on_exit(void* context);
 #include "nfc_playlist_scene_config.h"
-#undef ADD_SCENE
+#undef ADD_SCENE

scenes/nfc_playlist_scene_config.h

@@ -1,5 +1,6 @@
 ADD_SCENE(nfc_playlist, confirm_delete, ConfirmDelete)
 ADD_SCENE(nfc_playlist, emulation, Emulation)
+ADD_SCENE(nfc_playlist, error_playlist_already_exists, ErrorPlaylistAlreadyExists)
 ADD_SCENE(nfc_playlist, main_menu, MainMenu)
 ADD_SCENE(nfc_playlist, name_new_playlist, NameNewPlaylist)
 ADD_SCENE(nfc_playlist, nfc_add, NfcAdd)
@@ -9,4 +10,4 @@ ADD_SCENE(nfc_playlist, playlist_edit, PlaylistEdit)
 ADD_SCENE(nfc_playlist, playlist_rename, PlaylistRename)
 ADD_SCENE(nfc_playlist, playlist_select, PlaylistSelect)
 ADD_SCENE(nfc_playlist, settings, Settings)
-ADD_SCENE(nfc_playlist, view_playlist_content, ViewPlaylistContent)
+ADD_SCENE(nfc_playlist, view_playlist_content, ViewPlaylistContent)

scenes/nfc_playlist_scene_confirm_delete.c

@@ -11,13 +11,34 @@ void nfc_playlist_confirm_delete_scene_on_enter(void* context) {
    NfcPlaylist* nfc_playlist = context;
 
    FuriString* file_name = furi_string_alloc();
-   path_extract_filename_no_ext(furi_string_get_cstr(nfc_playlist->settings.playlist_path), file_name);
-   FuriString* temp_str = furi_string_alloc_printf("\e#Delete %s?\e#", furi_string_get_cstr(file_name));
+   path_extract_filename_no_ext(
+      furi_string_get_cstr(nfc_playlist->settings.playlist_path), file_name);
+   FuriString* temp_str =
+      furi_string_alloc_printf("\e#Delete %s?\e#", furi_string_get_cstr(file_name));
    furi_string_free(file_name);
 
-   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);
 
@@ -29,21 +50,23 @@ bool nfc_playlist_confirm_delete_scene_on_event(void* context, SceneManagerEvent
    bool consumed = false;
    if(event.type == SceneManagerEventTypeCustom) {
       switch(event.event) {
-         case GuiButtonTypeRight:
-            Storage* storage = furi_record_open(RECORD_STORAGE);
-            if (storage_simply_remove(storage, furi_string_get_cstr(nfc_playlist->settings.playlist_path))) {
-               furi_string_reset(nfc_playlist->settings.playlist_path);               
-            }
-            furi_record_close(RECORD_STORAGE);
-            scene_manager_search_and_switch_to_previous_scene(nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
-            consumed = true;
-            break;
-         case GuiButtonTypeLeft:
-            scene_manager_previous_scene(nfc_playlist->scene_manager);
-            consumed = true;
-            break;
-         default:
-            break;
+      case GuiButtonTypeRight:
+         Storage* storage = furi_record_open(RECORD_STORAGE);
+         if(storage_simply_remove(
+               storage, furi_string_get_cstr(nfc_playlist->settings.playlist_path))) {
+            furi_string_reset(nfc_playlist->settings.playlist_path);
+         }
+         furi_record_close(RECORD_STORAGE);
+         scene_manager_search_and_switch_to_previous_scene(
+            nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+         consumed = true;
+         break;
+      case GuiButtonTypeLeft:
+         scene_manager_previous_scene(nfc_playlist->scene_manager);
+         consumed = true;
+         break;
+      default:
+         break;
       }
    }
    return consumed;
@@ -52,4 +75,4 @@ bool nfc_playlist_confirm_delete_scene_on_event(void* context, SceneManagerEvent
 void nfc_playlist_confirm_delete_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    widget_reset(nfc_playlist->widget);
-}
+}

scenes/nfc_playlist_scene_emulation.c

@@ -6,7 +6,7 @@ typedef enum NfcPlaylistEmulationState {
    NfcPlaylistEmulationState_Canceled
 } NfcPlaylistEmulationState;
 
-NfcPlaylistEmulationState EmulationState = NfcPlaylistEmulationState_Stopped;
+static NfcPlaylistEmulationState EmulationState = NfcPlaylistEmulationState_Stopped;
 
 int32_t nfc_playlist_emulation_task(void* context) {
    NfcPlaylist* nfc_playlist = context;
@@ -18,8 +18,18 @@ int32_t nfc_playlist_emulation_task(void* context) {
    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Popup);
 
    if(nfc_playlist->settings.playlist_length == 0) {
-      popup_set_header(nfc_playlist->popup, "The playlist you have\nselected is empty", 64, 10, AlignCenter, AlignTop);
-   } else if(file_stream_open(stream, furi_string_get_cstr(nfc_playlist->settings.playlist_path), FSAM_READ, FSOM_OPEN_EXISTING)) {
+      popup_set_header(
+         nfc_playlist->popup,
+         "The playlist you have\nselected is empty",
+         64,
+         10,
+         AlignCenter,
+         AlignTop);
+   } else if(file_stream_open(
+                stream,
+                furi_string_get_cstr(nfc_playlist->settings.playlist_path),
+                FSAM_READ,
+                FSOM_OPEN_EXISTING)) {
       EmulationState = NfcPlaylistEmulationState_Emulating;
 
       FuriString* line = furi_string_alloc();
@@ -32,7 +42,8 @@ int32_t nfc_playlist_emulation_task(void* context) {
       bool delay_active = false;
       bool skip_delay = false;
 
-      while(stream_read_line(stream, line) && EmulationState == NfcPlaylistEmulationState_Emulating) {
+      while(stream_read_line(stream, line) &&
+            EmulationState == NfcPlaylistEmulationState_Emulating) {
          furi_string_trim(line);
 
          if(furi_string_empty(line)) {
@@ -43,10 +54,18 @@ int32_t nfc_playlist_emulation_task(void* context) {
             if(delay_active && !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);
+               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;
                };
@@ -57,24 +76,42 @@ int32_t nfc_playlist_emulation_task(void* context) {
             }
          }
 
-         if(EmulationState != NfcPlaylistEmulationState_Emulating) {break;}
+         if(EmulationState != NfcPlaylistEmulationState_Emulating) {
+            break;
+         }
 
          path_extract_filename(line, tmp_file_name, false);
          path_extract_ext_str(line, tmp_file_ext);
 
-         int time_counter_ms = (options_emulate_timeout[nfc_playlist->settings.emulate_timeout]*1000);
+         int time_counter_ms =
+            (options_emulate_timeout[nfc_playlist->settings.emulate_timeout] * 1000);
 
          if(furi_string_cmpi_str(tmp_file_ext, ".nfc") != 0) {
             if(nfc_playlist->settings.skip_error) {
                skip_delay = true;
                continue;
             }
-            furi_string_printf(tmp_header_str, "ERROR invalid file type:\n%s", furi_string_get_cstr(tmp_file_name));
-            popup_set_header(nfc_playlist->popup, furi_string_get_cstr(tmp_header_str), 64, 10, AlignCenter, AlignTop);
+            furi_string_printf(
+               tmp_header_str,
+               "ERROR invalid file type:\n%s",
+               furi_string_get_cstr(tmp_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_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;
             };
@@ -83,29 +120,59 @@ int32_t nfc_playlist_emulation_task(void* context) {
                skip_delay = true;
                continue;
             }
-            furi_string_printf(tmp_header_str, "ERROR file not found:\n%s", furi_string_get_cstr(tmp_file_name));
-            popup_set_header(nfc_playlist->popup, furi_string_get_cstr(tmp_header_str), 64, 10, AlignCenter, AlignTop);
+            furi_string_printf(
+               tmp_header_str, "ERROR file not found:\n%s", furi_string_get_cstr(tmp_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_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", furi_string_get_cstr(tmp_file_name));
-            popup_set_header(nfc_playlist->popup, furi_string_get_cstr(tmp_header_str), 64, 10, AlignCenter, AlignTop);
-            nfc_playlist_emulation_worker_set_nfc_data(nfc_playlist->nfc_playlist_emulation_worker, (char*)furi_string_get_cstr(line));
+            furi_string_printf(
+               tmp_header_str, "Emulating:\n%s", furi_string_get_cstr(tmp_file_name));
+            popup_set_header(
+               nfc_playlist->popup,
+               furi_string_get_cstr(tmp_header_str),
+               64,
+               10,
+               AlignCenter,
+               AlignTop);
+            nfc_playlist_emulation_worker_set_nfc_data(
+               nfc_playlist->nfc_playlist_emulation_worker, (char*)furi_string_get_cstr(line));
             nfc_playlist_emulation_worker_start(nfc_playlist->nfc_playlist_emulation_worker);
             start_blink(nfc_playlist, NfcPlaylistLedState_Normal);
-            while(nfc_playlist_emulation_worker_is_emulating(nfc_playlist->nfc_playlist_emulation_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);
+            while(nfc_playlist_emulation_worker_is_emulating(
+                     nfc_playlist->nfc_playlist_emulation_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_emulation_worker_stop(nfc_playlist->nfc_playlist_emulation_worker);
-            nfc_playlist_emulation_worker_clear_nfc_data(nfc_playlist->nfc_playlist_emulation_worker);
+            nfc_playlist_emulation_worker_clear_nfc_data(
+               nfc_playlist->nfc_playlist_emulation_worker);
          }
       }
       stop_blink(nfc_playlist);
@@ -118,9 +185,17 @@ int32_t nfc_playlist_emulation_task(void* context) {
       file_stream_close(stream);
 
       popup_reset(nfc_playlist->popup);
-      popup_set_header(nfc_playlist->popup, EmulationState == NfcPlaylistEmulationState_Canceled ? "Emulation stopped" : "Emulation finished", 64, 10, AlignCenter, AlignTop);
+      popup_set_header(
+         nfc_playlist->popup,
+         EmulationState == NfcPlaylistEmulationState_Canceled ? "Emulation stopped" :
+                                                                "Emulation finished",
+         64,
+         10,
+         AlignCenter,
+         AlignTop);
    } else {
-      popup_set_header(nfc_playlist->popup, "Failed to open playlist", 64, 10, AlignCenter, AlignTop);
+      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);
 
@@ -134,7 +209,8 @@ int32_t nfc_playlist_emulation_task(void* context) {
 
 void nfc_playlist_emulation_setup(void* context) {
    NfcPlaylist* nfc_playlist = context;
-   nfc_playlist->thread = furi_thread_alloc_ex("NfcPlaylistEmulationWorker", 4096, nfc_playlist_emulation_task, nfc_playlist);
+   nfc_playlist->thread = furi_thread_alloc_ex(
+      "NfcPlaylistEmulationWorker", 4096, nfc_playlist_emulation_task, nfc_playlist);
    nfc_playlist->nfc_playlist_emulation_worker = nfc_playlist_emulation_worker_alloc();
 }
 
@@ -178,4 +254,4 @@ void nfc_playlist_emulation_scene_on_exit(void* context) {
    nfc_playlist_emulation_stop(nfc_playlist);
    nfc_playlist_emulation_free(nfc_playlist);
    popup_reset(nfc_playlist->popup);
-}
+}

scenes/nfc_playlist_scene_error_playlist_already_exists.c

@@ -0,0 +1,67 @@
+#include "../nfc_playlist.h"
+
+void nfc_playlist_error_playlist_already_exists_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);
+   }
+}
+
+void nfc_playlist_error_playlist_already_exists_scene_on_enter(void* context) {
+   NfcPlaylist* nfc_playlist = context;
+
+   widget_add_text_box_element(
+      nfc_playlist->widget,
+      0,
+      0,
+      128,
+      23,
+      AlignCenter,
+      AlignCenter,
+      "\e#A playlist with that name already exists\e#",
+      false);
+   widget_add_button_element(
+      nfc_playlist->widget,
+      GuiButtonTypeLeft,
+      "Try Again",
+      nfc_playlist_error_playlist_already_exists_menu_callback,
+      nfc_playlist);
+   widget_add_button_element(
+      nfc_playlist->widget,
+      GuiButtonTypeRight,
+      "Main Menu",
+      nfc_playlist_error_playlist_already_exists_menu_callback,
+      nfc_playlist);
+
+   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Widget);
+}
+
+bool nfc_playlist_error_playlist_already_exists_scene_on_event(
+   void* context,
+   SceneManagerEvent event) {
+   NfcPlaylist* nfc_playlist = context;
+   bool consumed = false;
+   if(event.type == SceneManagerEventTypeCustom) {
+      switch(event.event) {
+      case GuiButtonTypeRight:
+         scene_manager_search_and_switch_to_previous_scene(
+            nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+         break;
+      case GuiButtonTypeLeft:
+         scene_manager_previous_scene(nfc_playlist->scene_manager);
+         consumed = true;
+         break;
+      default:
+         break;
+      }
+   }
+   return consumed;
+}
+
+void nfc_playlist_error_playlist_already_exists_scene_on_exit(void* context) {
+   NfcPlaylist* nfc_playlist = context;
+   widget_reset(nfc_playlist->widget);
+}

scenes/nfc_playlist_scene_main_menu.c

@@ -55,26 +55,26 @@ void nfc_playlist_main_menu_scene_on_enter(void* context) {
 bool nfc_playlist_main_menu_scene_on_event(void* context, SceneManagerEvent event) {
    NfcPlaylist* nfc_playlist = context;
    bool consumed = false;
-   if (event.type == SceneManagerEventTypeCustom) {
+   if(event.type == SceneManagerEventTypeCustom) {
       switch(event.event) {
-         case NfcPlaylistMainMenu_Start:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Emulation);
-            consumed = true;
-            break;
-         case NfcPlaylistMainMenu_PlaylistSelect:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistSelect);
-            consumed = true;
-            break;
-         case NfcPlaylistMainMenu_FileEdit:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistEdit);
-            consumed = true;
-            break;
-         case NfcPlaylistMainMenu_Settings:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Settings);
-            consumed = true;
-            break;
-         default:
-            break;
+      case NfcPlaylistMainMenu_Start:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Emulation);
+         consumed = true;
+         break;
+      case NfcPlaylistMainMenu_PlaylistSelect:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistSelect);
+         consumed = true;
+         break;
+      case NfcPlaylistMainMenu_FileEdit:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistEdit);
+         consumed = true;
+         break;
+      case NfcPlaylistMainMenu_Settings:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Settings);
+         consumed = true;
+         break;
+      default:
+         break;
       }
    }
    return consumed;
@@ -83,4 +83,4 @@ bool nfc_playlist_main_menu_scene_on_event(void* context, SceneManagerEvent even
 void nfc_playlist_main_menu_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    submenu_reset(nfc_playlist->submenu);
-}
+}

scenes/nfc_playlist_scene_name_new_playlist.c

@@ -1,20 +1,25 @@
 #include "../nfc_playlist.h"
 
+static bool playlist_exist_already = false;
+
 int32_t nfc_playlist_name_new_playlist_thread_task(void* context) {
    NfcPlaylist* nfc_playlist = context;
 
-   FuriString* file_name = furi_string_alloc_printf("%s%s.txt", PLAYLIST_LOCATION, nfc_playlist->text_input_output);
+   FuriString* file_name =
+      furi_string_alloc_printf("%s%s.txt", PLAYLIST_LOCATION, nfc_playlist->text_input_output);
    char const* file_name_cstr = furi_string_get_cstr(file_name);
 
    Storage* storage = furi_record_open(RECORD_STORAGE);
    File* file = storage_file_alloc(storage);
 
-   if (!storage_file_exists(storage, file_name_cstr)) {
-      if (storage_file_open(file, file_name_cstr, FSAM_READ_WRITE, FSOM_CREATE_NEW)) {
+   if(!storage_file_exists(storage, file_name_cstr)) {
+      if(storage_file_open(file, file_name_cstr, FSAM_READ_WRITE, FSOM_CREATE_NEW)) {
          storage_file_close(file);
          furi_string_swap(nfc_playlist->settings.playlist_path, file_name);
          nfc_playlist->settings.playlist_length = 0;
       }
+   } else {
+      playlist_exist_already = true;
    }
 
    furi_string_free(file_name);
@@ -29,25 +34,42 @@ void nfc_playlist_name_new_playlist_thread_state_callback(FuriThreadState state,
    if(state == FuriThreadStateStopped) {
       furi_thread_yield();
       nfc_playlist->thread = NULL;
-      scene_manager_search_and_switch_to_previous_scene(nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+      if(playlist_exist_already) {
+         scene_manager_next_scene(
+            nfc_playlist->scene_manager, NfcPlaylistScene_ErrorPlaylistAlreadyExists);
+      } else {
+         scene_manager_search_and_switch_to_previous_scene(
+            nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+      }
    }
 }
 
 void nfc_playlist_name_new_playlist_menu_callback(void* context) {
    NfcPlaylist* nfc_playlist = context;
-   nfc_playlist->thread = furi_thread_alloc_ex("NfcPlaylistCreator", 1024, nfc_playlist_name_new_playlist_thread_task, nfc_playlist);
+
+   nfc_playlist->thread = furi_thread_alloc_ex(
+      "NfcPlaylistCreator", 1024, nfc_playlist_name_new_playlist_thread_task, nfc_playlist);
    furi_thread_set_state_context(nfc_playlist->thread, nfc_playlist);
-   furi_thread_set_state_callback(nfc_playlist->thread, nfc_playlist_name_new_playlist_thread_state_callback);
+   furi_thread_set_state_callback(
+      nfc_playlist->thread, nfc_playlist_name_new_playlist_thread_state_callback);
    furi_thread_start(nfc_playlist->thread);
 }
 
 void nfc_playlist_name_new_playlist_scene_on_enter(void* context) {
    NfcPlaylist* nfc_playlist = context;
 
+   playlist_exist_already = false;
+
    nfc_playlist->text_input_output = malloc(MAX_PLAYLIST_NAME_LEN + 1);
    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_playlist_menu_callback, nfc_playlist, nfc_playlist->text_input_output, MAX_PLAYLIST_NAME_LEN, true);
+   text_input_set_result_callback(
+      nfc_playlist->text_input,
+      nfc_playlist_name_new_playlist_menu_callback,
+      nfc_playlist,
+      nfc_playlist->text_input_output,
+      MAX_PLAYLIST_NAME_LEN,
+      true);
 
    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
 }
@@ -62,4 +84,4 @@ void nfc_playlist_name_new_playlist_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    free(nfc_playlist->text_input_output);
    text_input_reset(nfc_playlist->text_input);
-}
+}

scenes/nfc_playlist_scene_nfc_add.c

@@ -6,7 +6,11 @@ void nfc_playlist_nfc_add_menu_callback(void* context) {
    Storage* storage = furi_record_open(RECORD_STORAGE);
    Stream* stream = file_stream_alloc(storage);
 
-   if (file_stream_open(stream, furi_string_get_cstr(nfc_playlist->settings.playlist_path), FSAM_READ_WRITE, FSOM_OPEN_EXISTING)) {
+   if(file_stream_open(
+         stream,
+         furi_string_get_cstr(nfc_playlist->settings.playlist_path),
+         FSAM_READ_WRITE,
+         FSOM_OPEN_EXISTING)) {
       FuriString* line = furi_string_alloc();
       FuriString* tmp_str = furi_string_alloc();
       while(stream_read_line(stream, line)) {
@@ -14,10 +18,11 @@ void nfc_playlist_nfc_add_menu_callback(void* context) {
       }
       furi_string_free(line);
 
-      if (!furi_string_empty(tmp_str)) {
+      if(!furi_string_empty(tmp_str)) {
          furi_string_cat_printf(tmp_str, "\n");
       }
-      furi_string_cat_printf(tmp_str, "%s", furi_string_get_cstr(nfc_playlist->file_browser_output));
+      furi_string_cat_printf(
+         tmp_str, "%s", furi_string_get_cstr(nfc_playlist->file_browser_output));
 
       stream_clean(stream);
       stream_write_string(stream, tmp_str);
@@ -36,14 +41,9 @@ void nfc_playlist_nfc_add_menu_callback(void* context) {
 void nfc_playlist_nfc_add_scene_on_enter(void* context) {
    NfcPlaylist* nfc_playlist = context;
    file_browser_configure(
-      nfc_playlist->file_browser,
-      ".nfc",
-      NFC_ITEM_LOCATION,
-      true,
-      true,
-      &I_Nfc_10px,
-      true);
-   file_browser_set_callback(nfc_playlist->file_browser, nfc_playlist_nfc_add_menu_callback, nfc_playlist);
+      nfc_playlist->file_browser, ".nfc", NFC_ITEM_LOCATION, true, true, &I_Nfc_10px, true);
+   file_browser_set_callback(
+      nfc_playlist->file_browser, nfc_playlist_nfc_add_menu_callback, nfc_playlist);
    FuriString* tmp_str = furi_string_alloc_set_str(NFC_ITEM_LOCATION);
    file_browser_start(nfc_playlist->file_browser, tmp_str);
    furi_string_free(tmp_str);
@@ -60,4 +60,4 @@ bool nfc_playlist_nfc_add_scene_on_event(void* context, SceneManagerEvent event)
 void nfc_playlist_nfc_add_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    file_browser_stop(nfc_playlist->file_browser);
-}
+}

scenes/nfc_playlist_scene_nfc_move_item.c

@@ -17,29 +17,33 @@ void nfc_playlist_nfc_move_item_menu_callback(void* context, uint32_t index) {
 void nfc_playlist_nfc_move_item_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 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);
 
    switch(current_option) {
-      case NfcPlaylistNfcMoveItem_TargetSelector: {
-         selected_target = option_value_index + 1;
-         FuriString* tmp_str = furi_string_alloc_printf("%d", selected_target);
-         variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
-         furi_string_free(tmp_str);
-         break;
-      }
-      case NfcPlaylistNfcMoveItem_DestinationSelector: {
-         selected_destination = option_value_index + 1;
-         FuriString* tmp_str = furi_string_alloc_printf("%d", selected_destination);
-         variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
-         furi_string_free(tmp_str);
-         break;
-      }
-      default:
-         break;
+   case NfcPlaylistNfcMoveItem_TargetSelector: {
+      selected_target = option_value_index + 1;
+      FuriString* tmp_str = furi_string_alloc_printf("%d", selected_target);
+      variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
+      furi_string_free(tmp_str);
+      break;
+   }
+   case NfcPlaylistNfcMoveItem_DestinationSelector: {
+      selected_destination = option_value_index + 1;
+      FuriString* tmp_str = furi_string_alloc_printf("%d", selected_destination);
+      variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
+      furi_string_free(tmp_str);
+      break;
+   }
+   default:
+      break;
    }
 
-   variable_item_set_locked(variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistNfcMoveItem_MoveItem), (selected_target == selected_destination), "Target\nand\nDestination\nare the same");
+   variable_item_set_locked(
+      variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistNfcMoveItem_MoveItem),
+      (selected_target == selected_destination),
+      "Target\nand\nDestination\nare the same");
 }
 
 void nfc_playlist_nfc_move_item_scene_on_enter(void* context) {
@@ -68,10 +72,15 @@ void nfc_playlist_nfc_move_item_scene_on_enter(void* context) {
    variable_item_set_current_value_index(destination_selector, 0);
    variable_item_set_current_value_text(destination_selector, "1");
 
-   VariableItem* move_button = variable_item_list_add(nfc_playlist->variable_item_list, "Move Item", 0, NULL, NULL);
-   variable_item_set_locked(move_button, (selected_target == selected_destination), "Target\nand\nDestination\nare the same");
+   VariableItem* move_button =
+      variable_item_list_add(nfc_playlist->variable_item_list, "Move Item", 0, NULL, NULL);
+   variable_item_set_locked(
+      move_button,
+      (selected_target == selected_destination),
+      "Target\nand\nDestination\nare the same");
 
-   variable_item_list_set_enter_callback(nfc_playlist->variable_item_list, nfc_playlist_nfc_move_item_menu_callback, nfc_playlist);
+   variable_item_list_set_enter_callback(
+      nfc_playlist->variable_item_list, nfc_playlist_nfc_move_item_menu_callback, nfc_playlist);
 
    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList);
 }
@@ -82,68 +91,80 @@ bool nfc_playlist_nfc_move_item_scene_on_event(void* context, SceneManagerEvent
 
    if(event.type == SceneManagerEventTypeCustom) {
       switch(event.event) {
-         case NfcPlaylistNfcMoveItem_MoveItem: {
-            Storage* storage = furi_record_open(RECORD_STORAGE);
-            Stream* stream = file_stream_alloc(storage);
-
-            if(file_stream_open(stream, furi_string_get_cstr(nfc_playlist->settings.playlist_path), FSAM_READ_WRITE, FSOM_OPEN_EXISTING)) {
-               FuriString* tmp_target_str = furi_string_alloc();
-               FuriString* line = furi_string_alloc();
-               uint8_t counter = 0;
-
-               while(stream_read_line(stream, line)) {
-                  counter++;
-                  if(counter == selected_target) {
-                     furi_string_trim(line);
-                     furi_string_cat_printf(tmp_target_str, "%s", furi_string_get_cstr(line));
-                     stream_rewind(stream);
-                     counter = 0;
-                     break;
-                  }
+      case NfcPlaylistNfcMoveItem_MoveItem: {
+         Storage* storage = furi_record_open(RECORD_STORAGE);
+         Stream* stream = file_stream_alloc(storage);
+
+         if(file_stream_open(
+               stream,
+               furi_string_get_cstr(nfc_playlist->settings.playlist_path),
+               FSAM_READ_WRITE,
+               FSOM_OPEN_EXISTING)) {
+            FuriString* tmp_target_str = furi_string_alloc();
+            FuriString* line = furi_string_alloc();
+            uint8_t counter = 0;
+
+            while(stream_read_line(stream, line)) {
+               counter++;
+               if(counter == selected_target) {
+                  furi_string_trim(line);
+                  furi_string_cat_printf(tmp_target_str, "%s", furi_string_get_cstr(line));
+                  stream_rewind(stream);
+                  counter = 0;
+                  break;
                }
+            }
 
-               FuriString* tmp_new_order_str = furi_string_alloc();
+            FuriString* tmp_new_order_str = furi_string_alloc();
 
-               while(stream_read_line(stream, line)) {
-                  counter++;
+            while(stream_read_line(stream, line)) {
+               counter++;
 
-                  if(counter == selected_target) {
-                     continue;
-                  }
+               if(counter == selected_target) {
+                  continue;
+               }
 
-                  if(!furi_string_empty(tmp_new_order_str)) {
-                     furi_string_cat_printf(tmp_new_order_str, "%s", "\n");
-                  }
+               if(!furi_string_empty(tmp_new_order_str)) {
+                  furi_string_cat_printf(tmp_new_order_str, "%s", "\n");
+               }
 
-                  furi_string_trim(line);
+               furi_string_trim(line);
 
-                  if(counter == selected_destination) {
-                     if(counter == 1) {
-                        furi_string_cat_printf(tmp_new_order_str, "%s\n%s", furi_string_get_cstr(tmp_target_str), furi_string_get_cstr(line));
-                     } else {
-                        furi_string_cat_printf(tmp_new_order_str, "%s\n%s", furi_string_get_cstr(line), furi_string_get_cstr(tmp_target_str));
-                     }
-                     furi_string_free(tmp_target_str);
+               if(counter == selected_destination) {
+                  if(counter == 1) {
+                     furi_string_cat_printf(
+                        tmp_new_order_str,
+                        "%s\n%s",
+                        furi_string_get_cstr(tmp_target_str),
+                        furi_string_get_cstr(line));
                   } else {
-                     furi_string_cat_printf(tmp_new_order_str, "%s", furi_string_get_cstr(line));
+                     furi_string_cat_printf(
+                        tmp_new_order_str,
+                        "%s\n%s",
+                        furi_string_get_cstr(line),
+                        furi_string_get_cstr(tmp_target_str));
                   }
+                  furi_string_free(tmp_target_str);
+               } else {
+                  furi_string_cat_printf(tmp_new_order_str, "%s", furi_string_get_cstr(line));
                }
-
-               furi_string_free(line);
-               stream_clean(stream);
-               stream_write_string(stream, tmp_new_order_str);
-               furi_string_free(tmp_new_order_str);
-               file_stream_close(stream);
             }
 
-            stream_free(stream);
-            furi_record_close(RECORD_STORAGE);
-
-            consumed = true;
-            break;
+            furi_string_free(line);
+            stream_clean(stream);
+            stream_write_string(stream, tmp_new_order_str);
+            furi_string_free(tmp_new_order_str);
+            file_stream_close(stream);
          }
-         default:
-            break;
+
+         stream_free(stream);
+         furi_record_close(RECORD_STORAGE);
+
+         consumed = true;
+         break;
+      }
+      default:
+         break;
       }
    }
 
@@ -153,4 +174,4 @@ bool nfc_playlist_nfc_move_item_scene_on_event(void* context, SceneManagerEvent
 void nfc_playlist_nfc_move_item_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    variable_item_list_reset(nfc_playlist->variable_item_list);
-}
+}

scenes/nfc_playlist_scene_nfc_remove.c

@@ -15,19 +15,20 @@ void nfc_playlist_nfc_remove_menu_callback(void* context, uint32_t index) {
 void nfc_playlist_nfc_remove_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 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);
-   
+
    switch(current_option) {
-      case NfcPlaylistNfcRemove_LineSelector: {
-         selected_line = option_value_index + 1;
-         FuriString* tmp_str = furi_string_alloc_printf("%d", selected_line);
-         variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
-         furi_string_free(tmp_str);
-         break;
-      }
-      default:
-         break;
+   case NfcPlaylistNfcRemove_LineSelector: {
+      selected_line = option_value_index + 1;
+      FuriString* tmp_str = furi_string_alloc_printf("%d", selected_line);
+      variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
+      furi_string_free(tmp_str);
+      break;
+   }
+   default:
+      break;
    }
 }
 
@@ -44,18 +45,27 @@ void nfc_playlist_nfc_remove_scene_on_enter(void* context) {
       nfc_playlist->settings.playlist_length,
       nfc_playlist_nfc_remove_options_change_callback,
       nfc_playlist);
-   variable_item_set_current_value_index(line_selector, nfc_playlist->settings.playlist_length - 1);
+   variable_item_set_current_value_index(
+      line_selector, nfc_playlist->settings.playlist_length - 1);
 
    FuriString* tmp_str = furi_string_alloc_printf("%d", selected_line);
    variable_item_set_current_value_text(line_selector, furi_string_get_cstr(tmp_str));
    furi_string_free(tmp_str);
 
-   variable_item_set_locked(line_selector, nfc_playlist->settings.playlist_length == 0 ? true : false, "Playlist\nis empty");
+   variable_item_set_locked(
+      line_selector,
+      nfc_playlist->settings.playlist_length == 0 ? true : false,
+      "Playlist\nis empty");
 
-   VariableItem* remove_button = variable_item_list_add(nfc_playlist->variable_item_list, "Remove Line", 0, NULL, NULL);
-   variable_item_set_locked(remove_button, nfc_playlist->settings.playlist_length == 0 ? true : false, "Playlist\nis empty");
+   VariableItem* remove_button =
+      variable_item_list_add(nfc_playlist->variable_item_list, "Remove Line", 0, NULL, NULL);
+   variable_item_set_locked(
+      remove_button,
+      nfc_playlist->settings.playlist_length == 0 ? true : false,
+      "Playlist\nis empty");
 
-   variable_item_list_set_enter_callback(nfc_playlist->variable_item_list, nfc_playlist_nfc_remove_menu_callback, nfc_playlist);
+   variable_item_list_set_enter_callback(
+      nfc_playlist->variable_item_list, nfc_playlist_nfc_remove_menu_callback, nfc_playlist);
 
    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList);
 }
@@ -63,54 +73,59 @@ void nfc_playlist_nfc_remove_scene_on_enter(void* context) {
 bool nfc_playlist_nfc_remove_scene_on_event(void* context, SceneManagerEvent event) {
    NfcPlaylist* nfc_playlist = context;
    bool consumed = false;
-   if (event.type == SceneManagerEventTypeCustom) {
+   if(event.type == SceneManagerEventTypeCustom) {
       switch(event.event) {
-         case NfcPlaylistNfcRemove_RemoveLine:
-            Storage* storage = furi_record_open(RECORD_STORAGE);
-            Stream* stream = file_stream_alloc(storage);
-
-            if (file_stream_open(stream, furi_string_get_cstr(nfc_playlist->settings.playlist_path), FSAM_READ_WRITE, FSOM_OPEN_EXISTING)) {
-               FuriString* line = furi_string_alloc();
-               FuriString* tmp_str = furi_string_alloc();
-               uint8_t current_line = 0;
-               while(stream_read_line(stream, line)) {
-                  current_line++;
-                  if (current_line != selected_line) {
-                     furi_string_trim(line);
-                     if (!furi_string_empty(tmp_str)) {
-                        furi_string_cat_printf(tmp_str, "\n");
-                     }
-                     furi_string_cat_printf(tmp_str, "%s", furi_string_get_cstr(line));
+      case NfcPlaylistNfcRemove_RemoveLine:
+         Storage* storage = furi_record_open(RECORD_STORAGE);
+         Stream* stream = file_stream_alloc(storage);
+
+         if(file_stream_open(
+               stream,
+               furi_string_get_cstr(nfc_playlist->settings.playlist_path),
+               FSAM_READ_WRITE,
+               FSOM_OPEN_EXISTING)) {
+            FuriString* line = furi_string_alloc();
+            FuriString* tmp_str = furi_string_alloc();
+            uint8_t current_line = 0;
+            while(stream_read_line(stream, line)) {
+               current_line++;
+               if(current_line != selected_line) {
+                  furi_string_trim(line);
+                  if(!furi_string_empty(tmp_str)) {
+                     furi_string_cat_printf(tmp_str, "\n");
                   }
+                  furi_string_cat_printf(tmp_str, "%s", furi_string_get_cstr(line));
                }
-
-               furi_string_free(line);
-               stream_clean(stream);
-               stream_write_string(stream, tmp_str);
-               furi_string_free(tmp_str);
-               file_stream_close(stream);
-               nfc_playlist->settings.playlist_length--;
-               selected_line = nfc_playlist->settings.playlist_length;
-            }
-            stream_free(stream);
-            furi_record_close(RECORD_STORAGE);
-
-            if (selected_line == 0) {
-               scene_manager_previous_scene(nfc_playlist->scene_manager);
-            } else {
-               VariableItem* Line_selector = variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistNfcRemove_LineSelector);
-               variable_item_set_values_count(Line_selector, nfc_playlist->settings.playlist_length);
-               variable_item_set_current_value_index(Line_selector, selected_line - 1);
-
-               FuriString* tmp_str = furi_string_alloc_printf("%d", selected_line);
-               variable_item_set_current_value_text(Line_selector, furi_string_get_cstr(tmp_str));
-               furi_string_free(tmp_str);
             }
 
-            consumed = true;
-            break;
-         default:
-            break;
+            furi_string_free(line);
+            stream_clean(stream);
+            stream_write_string(stream, tmp_str);
+            furi_string_free(tmp_str);
+            file_stream_close(stream);
+            nfc_playlist->settings.playlist_length--;
+            selected_line = nfc_playlist->settings.playlist_length;
+         }
+         stream_free(stream);
+         furi_record_close(RECORD_STORAGE);
+
+         if(selected_line == 0) {
+            scene_manager_previous_scene(nfc_playlist->scene_manager);
+         } else {
+            VariableItem* Line_selector = variable_item_list_get(
+               nfc_playlist->variable_item_list, NfcPlaylistNfcRemove_LineSelector);
+            variable_item_set_values_count(Line_selector, nfc_playlist->settings.playlist_length);
+            variable_item_set_current_value_index(Line_selector, selected_line - 1);
+
+            FuriString* tmp_str = furi_string_alloc_printf("%d", selected_line);
+            variable_item_set_current_value_text(Line_selector, furi_string_get_cstr(tmp_str));
+            furi_string_free(tmp_str);
+         }
+
+         consumed = true;
+         break;
+      default:
+         break;
       }
    }
    return consumed;
@@ -119,4 +134,4 @@ bool nfc_playlist_nfc_remove_scene_on_event(void* context, SceneManagerEvent eve
 void nfc_playlist_nfc_remove_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    variable_item_list_reset(nfc_playlist->variable_item_list);
-}
+}

scenes/nfc_playlist_scene_playlist_edit.c

@@ -91,36 +91,37 @@ bool nfc_playlist_playlist_edit_scene_on_event(void* context, SceneManagerEvent
    bool consumed = false;
    if(event.type == SceneManagerEventTypeCustom) {
       switch(event.event) {
-         case NfcPlaylistPlaylistEdit_CreatePlaylist:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NameNewPlaylist);
-            consumed = true;
-            break;
-         case NfcPlaylistPlaylistEdit_DeletePlaylist:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_ConfirmDelete);
-            consumed = true;
-            break;
-         case NfcPlaylistPlaylistEdit_RenamePlaylist:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistRename);
-            consumed = true;
-            break;
-         case NfcPlaylistPlaylistEdit_AddNfcItem:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcAdd);
-            consumed = true;
-            break;
-         case NfcPlaylistPlaylistEdit_RemoveNfcItem:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcRemove);
-            consumed = true;
-            break;
-         case NfcPlaylistPlaylistEdit_MoveNfcItem:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcMoveItem);
-            consumed = true;
-            break;
-         case NfcPlaylistPlaylistEdit_ViewPlaylistContent:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_ViewPlaylistContent);
-            consumed = true;
-            break;
-         default:
-            break;
+      case NfcPlaylistPlaylistEdit_CreatePlaylist:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NameNewPlaylist);
+         consumed = true;
+         break;
+      case NfcPlaylistPlaylistEdit_DeletePlaylist:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_ConfirmDelete);
+         consumed = true;
+         break;
+      case NfcPlaylistPlaylistEdit_RenamePlaylist:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistRename);
+         consumed = true;
+         break;
+      case NfcPlaylistPlaylistEdit_AddNfcItem:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcAdd);
+         consumed = true;
+         break;
+      case NfcPlaylistPlaylistEdit_RemoveNfcItem:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcRemove);
+         consumed = true;
+         break;
+      case NfcPlaylistPlaylistEdit_MoveNfcItem:
+         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcMoveItem);
+         consumed = true;
+         break;
+      case NfcPlaylistPlaylistEdit_ViewPlaylistContent:
+         scene_manager_next_scene(
+            nfc_playlist->scene_manager, NfcPlaylistScene_ViewPlaylistContent);
+         consumed = true;
+         break;
+      default:
+         break;
       }
    }
    return consumed;
@@ -129,4 +130,4 @@ bool nfc_playlist_playlist_edit_scene_on_event(void* context, SceneManagerEvent
 void nfc_playlist_playlist_edit_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    submenu_reset(nfc_playlist->submenu);
-}
+}

scenes/nfc_playlist_scene_playlist_rename.c

@@ -1,21 +1,31 @@
 #include "../nfc_playlist.h"
 
+static bool playlist_exist_already = false;
+
 int32_t nfc_playlist_playlist_rename_thread_task(void* context) {
    NfcPlaylist* nfc_playlist = context;
 
    FuriString* old_file_path = furi_string_alloc();
    path_extract_dirname(furi_string_get_cstr(nfc_playlist->settings.playlist_path), old_file_path);
    FuriString* new_file_path = furi_string_alloc_set(old_file_path);
-   path_concat(furi_string_get_cstr(old_file_path), nfc_playlist->text_input_output, new_file_path);
+   path_concat(
+      furi_string_get_cstr(old_file_path), nfc_playlist->text_input_output, new_file_path);
    furi_string_free(old_file_path);
    furi_string_cat_str(new_file_path, ".txt");
 
    Storage* storage = furi_record_open(RECORD_STORAGE);
 
-   if (!storage_file_exists(storage, furi_string_get_cstr(new_file_path))) {
-      if (storage_common_rename(storage, furi_string_get_cstr(nfc_playlist->settings.playlist_path), furi_string_get_cstr(new_file_path)) == FSE_OK) {
+   if(!storage_file_exists(storage, furi_string_get_cstr(new_file_path))) {
+      if(storage_common_rename(
+            storage,
+            furi_string_get_cstr(nfc_playlist->settings.playlist_path),
+            furi_string_get_cstr(new_file_path)) == FSE_OK) {
          furi_string_swap(nfc_playlist->settings.playlist_path, new_file_path);
       }
+   } else {
+      if(furi_string_cmp(nfc_playlist->settings.playlist_path, new_file_path) != 0) {
+         playlist_exist_already = true;
+      }
    }
 
    furi_string_free(new_file_path);
@@ -29,23 +39,35 @@ void nfc_playlist_playlist_rename_thread_state_callback(FuriThreadState state, v
    if(state == FuriThreadStateStopped) {
       furi_thread_yield();
       nfc_playlist->thread = NULL;
-      scene_manager_search_and_switch_to_previous_scene(nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+      if(playlist_exist_already) {
+         scene_manager_next_scene(
+            nfc_playlist->scene_manager, NfcPlaylistScene_ErrorPlaylistAlreadyExists);
+      } else {
+         scene_manager_search_and_switch_to_previous_scene(
+            nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+      }
    }
 }
 
 void nfc_playlist_playlist_rename_menu_callback(void* context) {
    NfcPlaylist* nfc_playlist = context;
-   nfc_playlist->thread = furi_thread_alloc_ex("NfcPlaylistRenamer", 1024, nfc_playlist_playlist_rename_thread_task, nfc_playlist);
+
+   nfc_playlist->thread = furi_thread_alloc_ex(
+      "NfcPlaylistRenamer", 1024, nfc_playlist_playlist_rename_thread_task, nfc_playlist);
    furi_thread_set_state_context(nfc_playlist->thread, nfc_playlist);
-   furi_thread_set_state_callback(nfc_playlist->thread, nfc_playlist_playlist_rename_thread_state_callback);
+   furi_thread_set_state_callback(
+      nfc_playlist->thread, nfc_playlist_playlist_rename_thread_state_callback);
    furi_thread_start(nfc_playlist->thread);
 }
 
 void nfc_playlist_playlist_rename_scene_on_enter(void* context) {
    NfcPlaylist* nfc_playlist = context;
 
+   playlist_exist_already = false;
+
    FuriString* tmp_file_name = furi_string_alloc();
-   path_extract_filename_no_ext(furi_string_get_cstr(nfc_playlist->settings.playlist_path), tmp_file_name);
+   path_extract_filename_no_ext(
+      furi_string_get_cstr(nfc_playlist->settings.playlist_path), tmp_file_name);
 
    nfc_playlist->text_input_output = malloc(MAX_PLAYLIST_NAME_LEN + 1);
    strcpy(nfc_playlist->text_input_output, furi_string_get_cstr(tmp_file_name));
@@ -53,7 +75,13 @@ void nfc_playlist_playlist_rename_scene_on_enter(void* context) {
 
    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_playlist_rename_menu_callback, nfc_playlist, nfc_playlist->text_input_output, MAX_PLAYLIST_NAME_LEN, false);
+   text_input_set_result_callback(
+      nfc_playlist->text_input,
+      nfc_playlist_playlist_rename_menu_callback,
+      nfc_playlist,
+      nfc_playlist->text_input_output,
+      MAX_PLAYLIST_NAME_LEN,
+      false);
 
    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
 }
@@ -68,4 +96,4 @@ void nfc_playlist_playlist_rename_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    free(nfc_playlist->text_input_output);
    text_input_reset(nfc_playlist->text_input);
-}
+}

scenes/nfc_playlist_scene_playlist_select.c

@@ -8,7 +8,11 @@ void nfc_playlist_playlist_select_menu_callback(void* context) {
    Storage* storage = furi_record_open(RECORD_STORAGE);
    Stream* stream = file_stream_alloc(storage);
 
-   if (file_stream_open(stream, furi_string_get_cstr(nfc_playlist->settings.playlist_path), FSAM_READ, FSOM_OPEN_EXISTING)) {
+   if(file_stream_open(
+         stream,
+         furi_string_get_cstr(nfc_playlist->settings.playlist_path),
+         FSAM_READ,
+         FSOM_OPEN_EXISTING)) {
       nfc_playlist->settings.playlist_length = 0;
       FuriString* line = furi_string_alloc();
       while(stream_read_line(stream, line)) {
@@ -27,14 +31,9 @@ void nfc_playlist_playlist_select_menu_callback(void* context) {
 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_Playlist_10px,
-      true);
-   file_browser_set_callback(nfc_playlist->file_browser, nfc_playlist_playlist_select_menu_callback, nfc_playlist);
+      nfc_playlist->file_browser, ".txt", PLAYLIST_LOCATION, true, true, &I_Playlist_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);
@@ -51,4 +50,4 @@ bool nfc_playlist_playlist_select_scene_on_event(void* context, SceneManagerEven
 void nfc_playlist_playlist_select_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    file_browser_stop(nfc_playlist->file_browser);
-}
+}

scenes/nfc_playlist_scene_settings.c

@@ -16,34 +16,38 @@ void nfc_playlist_settings_menu_callback(void* context, uint32_t 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 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);
 
    switch(current_option) {
-      case NfcPlaylistSettings_Timeout: {
-         nfc_playlist->settings.emulate_timeout = option_value_index;
-         FuriString* tmp_str = furi_string_alloc_printf("%ds", options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
-         variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
-         furi_string_free(tmp_str);
-         break;         
-      }
-      case NfcPlaylistSettings_Delay: {
-         nfc_playlist->settings.emulate_delay = option_value_index;
-         FuriString* tmp_str = furi_string_alloc_printf("%ds", options_emulate_delay[nfc_playlist->settings.emulate_delay]);
-         variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
-         furi_string_free(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;
+   case NfcPlaylistSettings_Timeout: {
+      nfc_playlist->settings.emulate_timeout = option_value_index;
+      FuriString* tmp_str = furi_string_alloc_printf(
+         "%ds", options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
+      variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
+      furi_string_free(tmp_str);
+      break;
+   }
+   case NfcPlaylistSettings_Delay: {
+      nfc_playlist->settings.emulate_delay = option_value_index;
+      FuriString* tmp_str = furi_string_alloc_printf(
+         "%ds", options_emulate_delay[nfc_playlist->settings.emulate_delay]);
+      variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
+      furi_string_free(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;
    }
 }
 
@@ -56,20 +60,23 @@ void nfc_playlist_settings_scene_on_enter(void* context) {
    VariableItem* emulation_timeout_setting = variable_item_list_add(
       nfc_playlist->variable_item_list,
       "Emulate time",
-      (sizeof(options_emulate_timeout)/sizeof(options_emulate_timeout[0])),
+      (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_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])),
+      (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);
+   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));
 
@@ -81,8 +88,11 @@ void nfc_playlist_settings_scene_on_enter(void* context) {
       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");
+   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,
@@ -90,15 +100,19 @@ void nfc_playlist_settings_scene_on_enter(void* context) {
       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_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);
+   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);
+   variable_item_list_set_enter_callback(
+      nfc_playlist->variable_item_list, nfc_playlist_settings_menu_callback, nfc_playlist);
 
    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList);
 }
@@ -106,39 +120,54 @@ void nfc_playlist_settings_scene_on_enter(void* context) {
 bool nfc_playlist_settings_scene_on_event(void* context, SceneManagerEvent event) {
    NfcPlaylist* nfc_playlist = context;
    bool consumed = false;
-   if (event.type == SceneManagerEventTypeCustom) {
+   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));
-
-            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));
-            
-            furi_string_free(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");
-
-            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");
-
-            consumed = true;
-            break;
-         default:
-            break;
+      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));
+
+         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));
+
+         furi_string_free(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");
+
+         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");
+
+         consumed = true;
+         break;
+      default:
+         break;
       }
    }
    return consumed;
@@ -147,4 +176,4 @@ bool nfc_playlist_settings_scene_on_event(void* context, SceneManagerEvent event
 void nfc_playlist_settings_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    variable_item_list_reset(nfc_playlist->variable_item_list);
-}
+}

scenes/nfc_playlist_scene_view_playlist_content.c

@@ -6,23 +6,48 @@ void nfc_playlist_view_playlist_content_scene_on_enter(void* context) {
    Storage* storage = furi_record_open(RECORD_STORAGE);
    Stream* stream = file_stream_alloc(storage);
 
-   if (file_stream_open(stream, furi_string_get_cstr(nfc_playlist->settings.playlist_path), FSAM_READ, FSOM_OPEN_EXISTING)) {
+   if(nfc_playlist->settings.playlist_length == 0) {
+      widget_add_text_box_element(
+         nfc_playlist->widget,
+         4,
+         4,
+         128,
+         64,
+         AlignCenter,
+         AlignCenter,
+         "\ePlaylist is empty\n\n\n\nPress back\e",
+         false);
+   } else if(file_stream_open(
+                stream,
+                furi_string_get_cstr(nfc_playlist->settings.playlist_path),
+                FSAM_READ,
+                FSOM_OPEN_EXISTING)) {
       FuriString* line = furi_string_alloc();
       FuriString* tmp_str = furi_string_alloc();
 
       while(stream_read_line(stream, line)) {
-         furi_string_cat_printf(tmp_str, "%s", furi_string_get_cstr(line));
+         furi_string_cat(tmp_str, furi_string_get_cstr(line));
       }
 
       furi_string_free(line);
       file_stream_close(stream);
 
-      widget_add_text_scroll_element(nfc_playlist->widget, 4, 4, 124, 60, furi_string_get_cstr(tmp_str));
+      widget_add_text_scroll_element(
+         nfc_playlist->widget, 4, 4, 124, 60, furi_string_get_cstr(tmp_str));
       widget_add_frame_element(nfc_playlist->widget, 0, 0, 128, 64, 0);
 
       furi_string_free(tmp_str);
    } else {
-      widget_add_text_box_element(nfc_playlist->widget, 0, 0, 128, 64, AlignCenter, AlignCenter, "\eFailed to open playlist\n\nPress back\e", false);
+      widget_add_text_box_element(
+         nfc_playlist->widget,
+         0,
+         0,
+         128,
+         64,
+         AlignCenter,
+         AlignCenter,
+         "\eFailed to open playlist\n\n\n\nPress back\e",
+         false);
    }
 
    stream_free(stream);
@@ -40,4 +65,4 @@ bool nfc_playlist_view_playlist_content_scene_on_event(void* context, SceneManag
 void nfc_playlist_view_playlist_content_scene_on_exit(void* context) {
    NfcPlaylist* nfc_playlist = context;
    widget_reset(nfc_playlist->widget);
-}
+}