update nfc playlist

README.md

@@ -1,6 +1,5 @@
 # FlipperZero_NFC_Playlist:
 The idea behind this app is to allow for you to test multiple copies of NFC's at once as a bulk test
-
 ## How it works:
 When starting the app you are greeted by a select file option where you choose the playlist you wanna run.
 
@@ -10,16 +9,30 @@ All the playlists should be placed in ext/apps_data/nfc_playlist and an example
 /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/Flipper-XFW/Xtreme-Firmware">Xtreme firmware</a> so keep that in mind when building the FAP for yourself
-
+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
+## 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/Flipper-XFW/Xtreme-Firmware">Xtreme</a>
+- <a href="https://github.com/Next-Flip/Momentum-Firmware">Momentum</a>
+- <a href="https://github.com/RogueMaster/flipperzero-firmware-wPlugins">RogueMaster</a>
 ## Settings:
 - Emulate time (How long the NFC card will be emulated for)
 - Delay time (How long the gap between the cards will be)
 - LED indicator (Whether or not the LED's will be on)
+- Skip errors (Makes it so you can make the emulation screen hide errors and skip delays between errors and emulation)
 - Reset settings (Puts all the settings back to the defaults)
-
 ## Playlist editor:
+- Create PLaylist (Creates a new playlist with the given name)
 - Delete playlist (Deletes the selected playlist)
-- Rename playlist (Renames the selected playlist the new name provided)
+- Rename playlist (Renames the selected playlist to the new name provided)
+- Add NFC Item (Adds the selected nfc item to the currently selected playlist)
+- Remove NFC Item (Opens a menu allowing you to select a line to remove from the playlist)
+- View playlist content (Allows you to view the contents of the playlist)
+## Development plans/ideas:
+Things i would like to add:
+- Ability to remove cards from the playlist
+
+These features are not guaranteed to be added but are being looked at as features to add
+
+Any feedback is welcome and would be very much appreciated

application.fam

@@ -8,15 +8,12 @@ App(
     fap_category="NFC",
     fap_author="@acegoal07",
     fap_weburl="https://github.com/acegoal07/FlipperZero_NFC_Playlist/tree/main",
-    fap_version="1.4",
-    fap_icon="icon.png",
+    fap_version="2.1",
     fap_icon_assets="assets",
+    fap_icon="icon.png",
     fap_private_libs=[
         Lib(
             name="worker",
         ),
-        Lib(
-            name="led",
-        ),
     ],
 )

lib/led/nfc_playlist_led.c

@@ -1,42 +0,0 @@
-#include "nfc_playlist_led.h"
-
-NotificationMessage blink_message_normal = {
-   .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
-};
-
-NotificationMessage blink_message_error = {
-   .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
-};
-
-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);
-      }
-   }
-}
-
-void stop_blink(NfcPlaylist* nfc_playlist) {
-   if (nfc_playlist->settings.emulate_led_indicator) {
-      notification_message_block(nfc_playlist->notification, &sequence_blink_stop);
-   }
-}

lib/led/nfc_playlist_led.h

@@ -1,11 +0,0 @@
-#pragma once
-#include <../../nfc_playlist.h>
-#include <notification/notification_messages.h>
-
-typedef enum NfcPlaylistLedState {
-   NfcPlaylistLedState_Normal,
-   NfcPlaylistLedState_Error
-} NfcPlaylistLedState;
-
-void start_blink(NfcPlaylist* nfc_playlist, int state);
-void stop_blink(NfcPlaylist* nfc_playlist);

lib/worker/nfc_playlist_worker.c

@@ -2,23 +2,18 @@
 
 NfcPlaylistWorker* nfc_playlist_worker_alloc() {
    NfcPlaylistWorker* nfc_playlist_worker = malloc(sizeof(NfcPlaylistWorker));
-
    nfc_playlist_worker->thread = furi_thread_alloc_ex("NfcPlaylistWorker", 8192, nfc_playlist_worker_task, nfc_playlist_worker);
    nfc_playlist_worker->state = NfcPlaylistWorkerState_Stopped;
-
    nfc_playlist_worker->nfc = nfc_alloc();
    nfc_playlist_worker->nfc_device = nfc_device_alloc();
-
    return nfc_playlist_worker;
 }
 
 void nfc_playlist_worker_free(NfcPlaylistWorker* nfc_playlist_worker) {
    furi_assert(nfc_playlist_worker);
    furi_thread_free(nfc_playlist_worker->thread);
-
    nfc_free(nfc_playlist_worker->nfc);
    nfc_device_free(nfc_playlist_worker->nfc_device);
-
    free(nfc_playlist_worker);
 }
 
@@ -62,22 +57,17 @@ int32_t nfc_playlist_worker_task(void* context) {
 }
 
 bool nfc_playlist_worker_is_emulating(NfcPlaylistWorker* nfc_playlist_worker) {
-   if (nfc_playlist_worker->state == NfcPlaylistWorkerState_Emulating) {
-      return true;
-   }
-   return false;
+   furi_assert(nfc_playlist_worker);
+   return nfc_playlist_worker->state == NfcPlaylistWorkerState_Emulating;
 }
 
 void nfc_playlist_worker_set_nfc_data(NfcPlaylistWorker* nfc_playlist_worker, char* file_path) {
-   nfc_device_clear(nfc_playlist_worker->nfc_device);
+   furi_assert(nfc_playlist_worker);
    nfc_device_load(nfc_playlist_worker->nfc_device, file_path);
    nfc_playlist_worker->nfc_protocol = nfc_device_get_protocol(nfc_playlist_worker->nfc_device);
 }
 
 void nfc_playlist_worker_clear_nfc_data(NfcPlaylistWorker* nfc_playlist_worker) {
+   furi_assert(nfc_playlist_worker);
    nfc_device_clear(nfc_playlist_worker->nfc_device);
-}
-
-NfcDeviceData* nfc_playlist_worker_get_nfc_data(NfcPlaylistWorker* nfc_playlist_worker) {
-   return nfc_playlist_worker->nfc_data;
 }

lib/worker/nfc_playlist_worker.h

@@ -16,7 +16,6 @@ typedef struct NfcPlaylistWorker {
    NfcListener* nfc_listener;
    NfcDevice* nfc_device;
    NfcProtocol nfc_protocol;
-   NfcDeviceData* nfc_data;
    Nfc* nfc;
 } NfcPlaylistWorker;
 
@@ -29,5 +28,4 @@ int32_t nfc_playlist_worker_task(void* context);
 
 bool nfc_playlist_worker_is_emulating(NfcPlaylistWorker* nfc_playlist_worker);
 void nfc_playlist_worker_set_nfc_data(NfcPlaylistWorker* nfc_playlist_worker, char* file_path);
-void nfc_playlist_worker_clear_nfc_data(NfcPlaylistWorker* nfc_playlist_worker);
-NfcDeviceData* nfc_playlist_worker_get_nfc_data(NfcPlaylistWorker* nfc_playlist_worker);
+void nfc_playlist_worker_clear_nfc_data(NfcPlaylistWorker* nfc_playlist_worker);

nfc_playlist.c

@@ -1,120 +1,165 @@
 #include "nfc_playlist.h"
-#include "nfc_playlist_i.h"
-
-static void (*const nfc_playlist_scene_on_enter_handlers[])(void*) = {
-   nfc_playlist_main_menu_scene_on_enter,
-   nfc_playlist_settings_scene_on_enter,
-   nfc_playlist_emulation_scene_on_enter,
-   nfc_playlist_file_select_scene_on_enter,
-   nfc_playlist_file_edit_scene_on_enter,
-   nfc_playlist_text_input_scene_on_enter
-};
-
-static bool (*const nfc_playlist_scene_on_event_handlers[])(void*, SceneManagerEvent) = {
-   nfc_playlist_main_menu_scene_on_event,
-   nfc_playlist_settings_scene_on_event,
-   nfc_playlist_emulation_scene_on_event,
-   nfc_playlist_file_select_scene_on_event,
-   nfc_playlist_file_edit_scene_on_event,
-   nfc_playlist_text_input_scene_on_event
-};
-
-static void (*const nfc_playlist_scene_on_exit_handlers[])(void*) = {
-   nfc_playlist_main_menu_scene_on_exit,
-   nfc_playlist_settings_scene_on_exit,
-   nfc_playlist_emulation_scene_on_exit,
-   nfc_playlist_file_select_scene_on_exit,
-   nfc_playlist_file_edit_scene_on_exit,
-   nfc_playlist_text_input_scene_on_exit
-};
-
-static const SceneManagerHandlers nfc_playlist_scene_manager_handlers = {
-   .on_enter_handlers = nfc_playlist_scene_on_enter_handlers,
-   .on_event_handlers = nfc_playlist_scene_on_event_handlers,
-   .on_exit_handlers = nfc_playlist_scene_on_exit_handlers,
-   .scene_num = NfcPlaylistScene_count
-};
 
 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_manager_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->settings.base_file_path = furi_string_alloc_set_str("/ext/apps_data/nfc_playlist/");
-   nfc_playlist->settings.file_path = nfc_playlist->settings.base_file_path;
-   nfc_playlist->settings.file_selected = false;
-   nfc_playlist->settings.file_selected_check = 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->notification = furi_record_open(RECORD_NOTIFICATION);
-   nfc_playlist->file_browser = file_browser_alloc(nfc_playlist->settings.file_path);
-   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_Menu, submenu_get_view(nfc_playlist->submenu));
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Settings, variable_item_list_get_view(nfc_playlist->variable_item_list));
-   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_FileSelect, file_browser_get_view(nfc_playlist->file_browser));
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileEdit, submenu_get_view(nfc_playlist->submenu));
-   view_dispatcher_add_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput, text_input_get_view(nfc_playlist->text_input));
-   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.playlist_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);
-   scene_manager_free(nfc_playlist->scene_manager);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Menu);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Settings);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Popup);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileSelect);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileEdit);
-   view_dispatcher_remove_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
-   view_dispatcher_free(nfc_playlist->view_dispatcher);
-   variable_item_list_free(nfc_playlist->variable_item_list);
-   submenu_free(nfc_playlist->submenu);
-   file_browser_free(nfc_playlist->file_browser);
-   text_input_free(nfc_playlist->text_input);
-   popup_free(nfc_playlist->popup);
-   furi_record_close(RECORD_NOTIFICATION);
-   furi_string_free(nfc_playlist->settings.base_file_path);
-   furi_string_free(nfc_playlist->settings.file_path);
-   free(nfc_playlist->playlist_name);
-   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.playlist_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);
+#else
+    furi_log_set_level(FuriLogLevelInfo);
+#endif
 }
 
 int32_t nfc_playlist_main(void* p) {
-   UNUSED(p);
+    UNUSED(p);
+
+    NfcPlaylist* nfc_playlist = nfc_playlist_alloc();
+
+    nfc_playlist_set_log_level();
 
-   NfcPlaylist* nfc_playlist = nfc_playlist_alloc();
+    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;
+}
+
+NotificationMessage blink_message_normal = {
+    .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};
+
+NotificationMessage blink_message_error = {
+    .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};
+
+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);
+        }
+    }
+}
 
-   return 0;
+void stop_blink(NfcPlaylist* nfc_playlist) {
+    if(nfc_playlist->settings.emulate_led_indicator) {
+        notification_message_block(nfc_playlist->notification, &sequence_blink_stop);
+    }
 }

nfc_playlist.h

@@ -1,7 +1,11 @@
 #pragma once
 #include <furi.h>
 #include <furi_hal.h>
+
 #include <string.h>
+
+#include "nfc_playlist_icons.h"
+
 #include <gui/gui.h>
 #include <gui/view_dispatcher.h>
 #include <gui/scene_manager.h>
@@ -10,55 +14,71 @@
 #include <gui/modules/submenu.h>
 #include <gui/modules/file_browser.h>
 #include <gui/modules/text_input.h>
+#include <gui/modules/widget.h>
+#include <gui/modules/widget_elements/widget_element.h>
+
 #include <notification/notification_messages.h>
-#include <nfc_playlist_worker.h>
+
+#include <storage/storage.h>
+
+#include <toolbox/stream/stream.h>
+#include <toolbox/stream/file_stream.h>
+
+#include "lib/worker/nfc_playlist_worker.h"
+
+#include "scenes/nfc_playlist_scene.h"
 
 typedef enum {
-    NfcPlaylistView_Menu,
-    NfcPlaylistView_Settings,
+    NfcPlaylistView_Submenu,
     NfcPlaylistView_Popup,
-    NfcPlaylistView_FileSelect,
-    NfcPlaylistView_FileEdit,
+    NfcPlaylistView_Widget,
+    NfcPlaylistView_VariableItemList,
+    NfcPlaylistView_FileBrowser,
     NfcPlaylistView_TextInput
-} NfcPlayScenesView;
-
-typedef enum {
-    NfcPlaylistScene_MainMenu,
-    NfcPlaylistScene_Settings,
-    NfcPlaylistScene_EmulatingPopup,
-    NfcPlaylistScene_FileSelect,
-    NfcPlaylistScene_FileEdit,
-    NfcPlaylistScene_TextInput,
-    NfcPlaylistScene_count
-} NfcPlaylistScene;
+} NfcPlaylistViews;
 
 typedef struct {
-    FuriString* base_file_path;
-    FuriString* file_path;
-    bool file_selected;
-    bool file_selected_check;
+    FuriString* playlist_path;
+    uint8_t playlist_length;
+    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;
-    Submenu* submenu;
-    Popup* popup;
+    char* text_input_output;
     NotificationApp* notification;
     FuriThread* thread;
+    FuriString* temp_furi_string;
     NfcPlaylistWorker* nfc_playlist_worker;
     NfcPlaylistSettings settings;
-    char* playlist_name;
 } NfcPlaylist;
 
 static const int options_emulate_timeout[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 static const int default_emulate_timeout = 4;
 static const int options_emulate_delay[] = {0, 1, 2, 3, 4, 5, 6};
 static const int default_emulate_delay = 0;
-static const bool default_emulate_led_indicator = true;
+static const bool default_emulate_led_indicator = true;
+static const bool default_skip_error = false;
+
+#define PLAYLIST_LOCATION "/ext/apps_data/nfc_playlist/"
+#define PLAYLIST_DIR "/ext/apps_data/nfc_playlist"
+
+typedef enum NfcPlaylistLedState {
+    NfcPlaylistLedState_Normal,
+    NfcPlaylistLedState_Error
+} NfcPlaylistLedState;
+
+void start_blink(NfcPlaylist* nfc_playlist, int state);
+void stop_blink(NfcPlaylist* nfc_playlist);

nfc_playlist_i.h

@@ -1,8 +0,0 @@
-#pragma once
-#include "scences/main_menu.h"
-#include "scences/settings.h"
-#include "scences/emulation.h"
-#include "scences/file_select.h"
-#include "scences/file_edit.h"
-#include "scences/text_input.h"
-#include <nfc_playlist_icons.h>

scences/emulation.c

@@ -1,156 +0,0 @@
-#include "nfc_playlist.h"
-#include "scences/emulation.h"
-
-NfcPlaylistEmulationState EmulationState = NfcPlaylistEmulationState_Stopped;
-
-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);
-}
-
-bool nfc_playlist_emulation_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(context);
-   if (event.event == 0 && EmulationState == NfcPlaylistEmulationState_Emulating) {
-      EmulationState = NfcPlaylistEmulationState_Canceled;
-      return true;
-   }
-   return false;
-}
-
-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);
-}
-
-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();
-}
-
-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;
-}
-
-void nfc_playlist_emulation_start(NfcPlaylist* nfc_playlist) {
-   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);
-}
-
-int32_t nfc_playlist_emulation_task(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-
-   Storage* storage = furi_record_open(RECORD_STORAGE);
-   Stream* stream = file_stream_alloc(storage);
-   FuriString* line = furi_string_alloc();
-
-   popup_reset(nfc_playlist->popup);
-   popup_set_context(nfc_playlist->popup, nfc_playlist);
-   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) && nfc_playlist->settings.file_selected_check) {
-      EmulationState = NfcPlaylistEmulationState_Emulating;
-      int file_position = 0;
-      while(stream_read_line(stream, line) && EmulationState == NfcPlaylistEmulationState_Emulating) {
-
-         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) {
-            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);
-            do {
-               char display_text[10];
-               snprintf(display_text, 10, "%ds", (time_counter_delay_ms/1000));
-               popup_set_text(nfc_playlist->popup, display_text, 64, 50, AlignCenter, AlignTop);
-               furi_delay_ms(50);
-               time_counter_delay_ms -= 50;
-            } while(time_counter_delay_ms > 0 && EmulationState == NfcPlaylistEmulationState_Emulating);
-         } else if (nfc_playlist->settings.emulate_delay > 0) {
-            file_position++;
-         }
-
-         if (EmulationState != NfcPlaylistEmulationState_Emulating) {break;}
-
-         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 (storage_file_exists(storage, file_path) == false) {
-            int popup_header_text_size = strlen(file_name) + 18;
-            char popup_header_text[popup_header_text_size];
-            snprintf(popup_header_text, popup_header_text_size, "%s\n%s", "ERROR not found:", file_name);
-            popup_set_header(nfc_playlist->popup, popup_header_text, 64, 10, AlignCenter, AlignTop);
-            start_blink(nfc_playlist, NfcPlaylistLedState_Error);
-            do {
-               char popup_text[10];
-               snprintf(popup_text, 10, "%ds", (time_counter_ms/1000));
-               popup_set_text(nfc_playlist->popup, popup_text, 64, 50, AlignCenter, AlignTop);
-               furi_delay_ms(50);
-               time_counter_ms -= 50;
-            } while(time_counter_ms > 0 && EmulationState == NfcPlaylistEmulationState_Emulating);
-         } else if (strcasestr(file_ext, "nfc") == NULL) {
-            int popup_header_text_size = strlen(file_name) + 21;
-            char popup_header_text[popup_header_text_size];
-            snprintf(popup_header_text, popup_header_text_size, "%s\n%s", "ERROR invalid file:", file_name);
-            popup_set_header(nfc_playlist->popup, popup_header_text, 64, 10, AlignCenter, AlignTop);
-            start_blink(nfc_playlist, NfcPlaylistLedState_Error);
-            do {
-               char popup_text[10];
-               snprintf(popup_text, 10, "%ds", (time_counter_ms/1000));
-               popup_set_text(nfc_playlist->popup, popup_text, 64, 50, AlignCenter, AlignTop);
-               furi_delay_ms(50);
-               time_counter_ms -= 50;
-            } while(time_counter_ms > 0 && EmulationState == NfcPlaylistEmulationState_Emulating);
-         } else {
-            int popup_header_text_size = strlen(file_name) + 12;
-            char popup_header_text[popup_header_text_size];
-            snprintf(popup_header_text, popup_header_text_size, "%s\n%s", "Emulating:", file_name);
-            popup_set_header(nfc_playlist->popup, popup_header_text, 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);
-            do {
-               char popup_text[10];
-               snprintf(popup_text, 10, "%ds", (time_counter_ms/1000));
-               popup_set_text(nfc_playlist->popup, popup_text, 64, 50, AlignCenter, AlignTop);
-               furi_delay_ms(50);
-               time_counter_ms -= 50;
-            } while(nfc_playlist_worker_is_emulating(nfc_playlist->nfc_playlist_worker) && time_counter_ms > 0 && EmulationState == NfcPlaylistEmulationState_Emulating);
-            nfc_playlist_worker_stop(nfc_playlist->nfc_playlist_worker);
-            nfc_playlist_worker_clear_nfc_data(nfc_playlist->nfc_playlist_worker);
-         }
-         free(file_path);
-      }
-      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;
-   } 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);
-   }
-
-   furi_string_free(line);
-   file_stream_close(stream);
-   furi_record_close(RECORD_STORAGE);
-   stream_free(stream);
-
-   return 0;
-}

scences/emulation.h

@@ -1,27 +0,0 @@
-#pragma once
-#include <furi.h>
-#include <storage/storage.h>
-#include <toolbox/stream/stream.h>
-#include <toolbox/stream/file_stream.h>
-#include <lib/worker/nfc_playlist_worker.h>
-#include <lib/led/nfc_playlist_led.h>
-#include <gui/gui.h>
-#include <gui/view_dispatcher.h>
-#include <gui/scene_manager.h>
-#include <gui/modules/popup.h>
-
-void nfc_playlist_emulation_scene_on_enter(void* context);
-bool nfc_playlist_emulation_scene_on_event(void* context, SceneManagerEvent event);
-void nfc_playlist_emulation_scene_on_exit(void* context);
-
-void nfc_playlist_emulation_setup(void* context);
-void nfc_playlist_emulation_free(NfcPlaylist* nfc_playlist);
-void nfc_playlist_emulation_start(NfcPlaylist* nfc_playlist);
-void nfc_playlist_emulation_stop(NfcPlaylist* nfc_playlist);
-int32_t nfc_playlist_emulation_task(void* context);
-
-typedef enum NfcPlaylistEmulationState {
-   NfcPlaylistEmulationState_Emulating,
-   NfcPlaylistEmulationState_Stopped,
-   NfcPlaylistEmulationState_Canceled
-} NfcPlaylistEmulationState;

scences/file_edit.c

@@ -1,70 +0,0 @@
-#include "nfc_playlist.h"
-#include "scences/file_edit.h"
-
-typedef enum {
-   NfcPlaylistMenuSelection_DeletePlaylist,
-   NfcPlaylistMenuSelection_RenamePlaylist,
-   NfcPlaylistMenuSelection_EditList
-} NfcPlaylistMenuSelection;
-
-void nfc_playlist_file_edit_menu_callback(void* context, uint32_t index) {
-   NfcPlaylist* nfc_playlist = context;
-   Storage* storage = furi_record_open(RECORD_STORAGE);
-   switch(index) {
-      case NfcPlaylistMenuSelection_DeletePlaylist: {
-         storage_simply_remove(storage, furi_string_get_cstr(nfc_playlist->settings.file_path));
-         nfc_playlist->settings.file_selected = false;
-         nfc_playlist->settings.file_selected_check = false;
-         nfc_playlist->settings.file_path = nfc_playlist->settings.base_file_path;
-         scene_manager_previous_scene(nfc_playlist->scene_manager);
-         break;
-      }
-      case NfcPlaylistMenuSelection_RenamePlaylist: {
-         scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_TextInput);
-         break;
-      }
-      case NfcPlaylistMenuSelection_EditList: {
-         break;
-      }
-      default:
-         break;
-   }
-   furi_record_close(RECORD_STORAGE);
-}
-
-void nfc_playlist_file_edit_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-
-   submenu_set_header(nfc_playlist->submenu, "Edit Playlist");
-
-   submenu_add_lockable_item(
-      nfc_playlist->submenu,
-      "Delete Playlist",
-      NfcPlaylistMenuSelection_DeletePlaylist,
-      nfc_playlist_file_edit_menu_callback,
-      nfc_playlist,
-      !nfc_playlist->settings.file_selected_check,
-      "No\nplaylist\nselected");
-
-   submenu_add_lockable_item(
-      nfc_playlist->submenu,
-      "Rename Playlist",
-      NfcPlaylistMenuSelection_RenamePlaylist,
-      nfc_playlist_file_edit_menu_callback,
-      nfc_playlist,
-      !nfc_playlist->settings.file_selected_check,
-      "No\nplaylist\nselected");
-
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileEdit);
-}
-
-bool nfc_playlist_file_edit_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(event);
-   UNUSED(context);
-   return false;
-}
-
-void nfc_playlist_file_edit_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   submenu_reset(nfc_playlist->submenu);
-}

scences/file_edit.h

@@ -1,13 +0,0 @@
-#pragma once
-#include <furi.h>
-#include <gui/gui.h>
-#include <gui/view_dispatcher.h>
-#include <gui/scene_manager.h>
-#include <gui/modules/submenu.h>
-#include <storage/storage.h>
-#include <toolbox/stream/stream.h>
-#include <toolbox/stream/file_stream.h>
-
-void nfc_playlist_file_edit_scene_on_enter(void* context);
-bool nfc_playlist_file_edit_scene_on_event(void* context, SceneManagerEvent event);
-void nfc_playlist_file_edit_scene_on_exit(void* context);

scences/file_select.c

@@ -1,34 +0,0 @@
-#include "nfc_playlist.h"
-#include "scences/file_select.h"
-
-void nfc_playlist_file_select_menu_callback(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   nfc_playlist->settings.file_selected_check = true;
-   scene_manager_previous_scene(nfc_playlist->scene_manager);
-}
-
-void nfc_playlist_file_select_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   file_browser_configure(
-      nfc_playlist->file_browser,
-      ".txt",
-      furi_string_get_cstr(nfc_playlist->settings.base_file_path),
-      true,
-      true,
-      &I_sub1_10px,
-      true);
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_FileSelect);
-   file_browser_set_callback(nfc_playlist->file_browser, nfc_playlist_file_select_menu_callback, nfc_playlist);
-   file_browser_start(nfc_playlist->file_browser, nfc_playlist->settings.base_file_path);
-}
-
-bool nfc_playlist_file_select_scene_on_event(void* context, SceneManagerEvent event) {
-   UNUSED(event);
-   UNUSED(context);
-   return false;
-}
-
-void nfc_playlist_file_select_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   file_browser_stop(nfc_playlist->file_browser);
-}

scences/file_select.h

@@ -1,11 +0,0 @@
-#pragma once
-#include <furi.h>
-#include <gui/gui.h>
-#include <gui/view_dispatcher.h>
-#include <gui/scene_manager.h>
-#include <gui/modules/file_browser.h>
-#include <nfc_playlist_icons.h>
-
-void nfc_playlist_file_select_scene_on_enter(void* context);
-bool nfc_playlist_file_select_scene_on_event(void* context, SceneManagerEvent event);
-void nfc_playlist_file_select_scene_on_exit(void* context);

scences/main_menu.c

@@ -1,111 +0,0 @@
-#include "nfc_playlist.h"
-#include "scences/main_menu.h"
-
-typedef enum {
-   NfcPlaylistEvent_ShowEmulatingPopup,
-   NfcPlaylistEvent_ShowFileSelect,
-   NfcPlaylistEvent_ShowFileEdit,
-   NfcPlaylistEvent_ShowSettings
-} NfcPlaylistMainMenuEvent;
-
-typedef enum {
-   NfcPlaylistMenuSelection_Start,
-   NfcPlaylistMenuSelection_FileSelect,
-   NfcPlaylistMenuSelection_FileEdit,
-   NfcPlaylistMenuSelection_Settings
-} NfcPlaylistMenuSelection;
-
-void nfc_playlist_main_menu_menu_callback(void* context, uint32_t index) {
-   NfcPlaylist* nfc_playlist = context;
-   switch(index) {
-      case NfcPlaylistMenuSelection_Start:
-         scene_manager_handle_custom_event(nfc_playlist->scene_manager, NfcPlaylistEvent_ShowEmulatingPopup);
-         break;
-      case NfcPlaylistMenuSelection_FileSelect:
-         scene_manager_handle_custom_event(nfc_playlist->scene_manager, NfcPlaylistEvent_ShowFileSelect);
-         break;
-      case NfcPlaylistMenuSelection_FileEdit:
-         scene_manager_handle_custom_event(nfc_playlist->scene_manager, NfcPlaylistEvent_ShowFileEdit);
-         break;
-      case NfcPlaylistMenuSelection_Settings:
-         scene_manager_handle_custom_event(nfc_playlist->scene_manager, NfcPlaylistEvent_ShowSettings);
-         break;
-      default:
-         break;
-   }
-}
-
-void nfc_playlist_main_menu_scene_on_enter(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   if (!nfc_playlist->settings.file_selected) {
-      nfc_playlist->settings.file_selected = true;
-      scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_FileSelect);
-      return;
-   }
-
-   submenu_set_header(nfc_playlist->submenu, "NFC Playlist");
-
-   submenu_add_lockable_item(
-      nfc_playlist->submenu,
-      "Start",
-      NfcPlaylistMenuSelection_Start,
-      nfc_playlist_main_menu_menu_callback,
-      nfc_playlist,
-      !nfc_playlist->settings.file_selected_check,
-      "No\nplaylist\nselected");
-
-   submenu_add_item(
-      nfc_playlist->submenu,
-      "Select playlist",
-      NfcPlaylistMenuSelection_FileSelect,
-      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);
-   view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Menu);
-}
-
-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_ShowEmulatingPopup:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_EmulatingPopup);
-            consumed = true;
-            break;
-         case NfcPlaylistEvent_ShowFileSelect:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_FileSelect);
-            consumed = true;
-            break;
-         case NfcPlaylistEvent_ShowFileEdit:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_FileEdit);
-            consumed = true;
-            break;
-         case NfcPlaylistEvent_ShowSettings:
-            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Settings);
-            consumed = true;
-            break;
-         default:
-            break;
-      }
-   }
-   return consumed;
-}
-
-void nfc_playlist_main_menu_scene_on_exit(void* context) {
-   NfcPlaylist* nfc_playlist = context;
-   submenu_reset(nfc_playlist->submenu);
-}

scences/main_menu.h

@@ -1,10 +0,0 @@
-#pragma once
-#include <furi.h>
-#include <gui/gui.h>
-#include <gui/view_dispatcher.h>
-#include <gui/scene_manager.h>
-#include <gui/modules/submenu.h>
-
-void nfc_playlist_main_menu_scene_on_enter(void* context);
-bool nfc_playlist_main_menu_scene_on_event(void* context, SceneManagerEvent event);
-void nfc_playlist_main_menu_scene_on_exit(void* context);

scences/settings.c

@@ -1,153 +0,0 @@
-#include "nfc_playlist.h"
-#include "scences/settings.h"
-
-typedef enum {
-    NfcPlaylistSettings_Timeout,
-    NfcPlaylistSettings_Delay,
-    NfcPlaylistSettings_LedIndicator,
-    NfcPlaylistSettings_Reset
-} NfcPlaylistMenuSelection;
-
-void nfc_playlist_settings_menu_callback(void* context, uint32_t index) {
-    NfcPlaylist* nfc_playlist = context;
-    if(index == NfcPlaylistSettings_Reset) {
-        nfc_playlist->settings.emulate_timeout = default_emulate_timeout;
-        VariableItem* emulation_timeout_settings =
-            variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistSettings_Timeout);
-        variable_item_set_current_value_index(
-            emulation_timeout_settings, nfc_playlist->settings.emulate_timeout);
-        char emulation_timeout_settings_text[3];
-        snprintf(
-            emulation_timeout_settings_text,
-            3,
-            "%ds",
-            options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
-        variable_item_set_current_value_text(
-            emulation_timeout_settings, (char*)emulation_timeout_settings_text);
-
-        nfc_playlist->settings.emulate_delay = default_emulate_delay;
-        VariableItem* emulation_delay_settings =
-            variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistSettings_Delay);
-        variable_item_set_current_value_index(
-            emulation_delay_settings, nfc_playlist->settings.emulate_delay);
-        char emulation_delay_settings_text[3];
-        snprintf(
-            emulation_delay_settings_text,
-            3,
-            "%ds",
-            options_emulate_delay[nfc_playlist->settings.emulate_delay]);
-        variable_item_set_current_value_text(
-            emulation_delay_settings, (char*)emulation_delay_settings_text);
-
-        nfc_playlist->settings.emulate_led_indicator = default_emulate_led_indicator;
-        VariableItem* emulation_led_indicator_settings = variable_item_list_get(
-            nfc_playlist->variable_item_list, NfcPlaylistSettings_LedIndicator);
-        variable_item_set_current_value_index(
-            emulation_led_indicator_settings, nfc_playlist->settings.emulate_led_indicator);
-        variable_item_set_current_value_text(
-            emulation_led_indicator_settings,
-            nfc_playlist->settings.emulate_led_indicator ? "ON" : "OFF");
-    }
-}
-
-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);
-
-    switch(current_option) {
-    case NfcPlaylistSettings_Timeout: {
-        nfc_playlist->settings.emulate_timeout = option_value_index;
-        char emulate_timeout_text[3];
-        snprintf(emulate_timeout_text, 3, "%ds", options_emulate_timeout[option_value_index]);
-        variable_item_set_current_value_text(item, (char*)emulate_timeout_text);
-        break;
-    }
-    case NfcPlaylistSettings_Delay: {
-        nfc_playlist->settings.emulate_delay = option_value_index;
-        char emulate_delay_text[3];
-        snprintf(emulate_delay_text, 3, "%ds", options_emulate_delay[option_value_index]);
-        variable_item_set_current_value_text(item, (char*)emulate_delay_text);
-        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;
-    default:
-        break;
-    }
-}
-
-void nfc_playlist_settings_scene_on_enter(void* context) {
-    NfcPlaylist* nfc_playlist = context;
-
-    //variable_item_list_set_header(nfc_playlist->variable_item_list, "Settings");
-
-    VariableItem* emulation_timeout_settings = 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_settings, nfc_playlist->settings.emulate_timeout);
-    char emulation_timeout_settings_text[3];
-    snprintf(
-        emulation_timeout_settings_text,
-        3,
-        "%ds",
-        options_emulate_timeout[nfc_playlist->settings.emulate_timeout]);
-    variable_item_set_current_value_text(
-        emulation_timeout_settings, (char*)emulation_timeout_settings_text);
-
-    VariableItem* emulation_delay_settings = 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_settings, nfc_playlist->settings.emulate_delay);
-    char emulation_delay_settings_text[3];
-    snprintf(
-        emulation_delay_settings_text,
-        3,
-        "%ds",
-        options_emulate_delay[nfc_playlist->settings.emulate_delay]);
-    variable_item_set_current_value_text(
-        emulation_delay_settings, (char*)emulation_delay_settings_text);
-
-    VariableItem* emulation_led_indicator_settings = 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_settings, nfc_playlist->settings.emulate_led_indicator);
-    variable_item_set_current_value_text(
-        emulation_led_indicator_settings,
-        nfc_playlist->settings.emulate_led_indicator ? "ON" : "OFF");
-
-    variable_item_list_add(nfc_playlist->variable_item_list, "Reset settings", 0, NULL, NULL);
-
-    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_Settings);
-}
-
-bool nfc_playlist_settings_scene_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
-    return false;
-}
-
-void nfc_playlist_settings_scene_on_exit(void* context) {
-    NfcPlaylist* nfc_playlist = context;
-    variable_item_list_reset(nfc_playlist->variable_item_list);
-}

scences/settings.h

@@ -1,10 +0,0 @@
-#pragma once
-#include <furi.h>
-#include <gui/gui.h>
-#include <gui/view_dispatcher.h>
-#include <gui/scene_manager.h>
-#include <gui/modules/variable_item_list.h>
-
-void nfc_playlist_settings_scene_on_enter(void* context);
-bool nfc_playlist_settings_scene_on_event(void* context, SceneManagerEvent event);
-void nfc_playlist_settings_scene_on_exit(void* context);

scences/text_input.c

@@ -1,67 +0,0 @@
-#include "nfc_playlist.h"
-#include "scences/text_input.h"
-
-void nfc_playlist_text_input_menu_callback(void* context) {
-    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;
-
-    int file_path_size = (strlen(old_file_path) - strlen(old_file_name) + 1);
-
-    char* file_path = (char*)malloc(file_path_size);
-    snprintf(file_path, file_path_size, "%s", old_file_path);
-
-    int new_file_path_size =
-        (strlen(nfc_playlist->playlist_name) + strlen(".txt") + file_path_size + 1);
-
-    char* new_file_name = (char*)malloc(new_file_path_size);
-    snprintf(
-        new_file_name,
-        new_file_path_size,
-        "%s%s%s",
-        file_path,
-        nfc_playlist->playlist_name,
-        ".txt");
-
-    if(!storage_file_exists(storage, new_file_name)) {
-        storage_common_rename(
-            storage, furi_string_get_cstr(nfc_playlist->settings.file_path), new_file_name);
-        nfc_playlist->settings.file_path = furi_string_alloc_set_str(new_file_name);
-    }
-
-    free(new_file_name);
-    free(file_path);
-    free(nfc_playlist->playlist_name);
-    furi_record_close(RECORD_STORAGE);
-
-    scene_manager_previous_scene(nfc_playlist->scene_manager);
-}
-
-void nfc_playlist_text_input_scene_on_enter(void* context) {
-    NfcPlaylist* nfc_playlist = context;
-    nfc_playlist->playlist_name = (char*)malloc(50);
-    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_text_input_menu_callback,
-        nfc_playlist,
-        nfc_playlist->playlist_name,
-        50,
-        true);
-    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
-}
-
-bool nfc_playlist_text_input_scene_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
-    return false;
-}
-
-void nfc_playlist_text_input_scene_on_exit(void* context) {
-    NfcPlaylist* nfc_playlist = context;
-    text_input_reset(nfc_playlist->text_input);
-}

scences/text_input.h

@@ -1,13 +0,0 @@
-#pragma once
-#include <furi.h>
-#include <string.h>
-#include <gui/gui.h>
-#include <gui/view_dispatcher.h>
-#include <gui/scene_manager.h>
-#include <gui/modules/file_browser.h>
-#include <gui/modules/text_input.h>
-#include <storage/storage.h>
-
-void nfc_playlist_text_input_scene_on_enter(void* context);
-bool nfc_playlist_text_input_scene_on_event(void* context, SceneManagerEvent event);
-void nfc_playlist_text_input_scene_on_exit(void* context);

scenes/nfc_playlist_scene.c

@@ -0,0 +1,30 @@
+#include "nfc_playlist_scene.h"
+
+// Generate scene on_enter handlers definition
+#define ADD_SCENE(prefix, name, id) prefix##_##name##_scene_on_enter,
+void (*const nfc_playlist_on_enter_handlers[])(void*) = {
+#include "nfc_playlist_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_##name##_scene_on_event,
+bool (*const nfc_playlist_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "nfc_playlist_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_##name##_scene_on_exit,
+void (*const nfc_playlist_on_exit_handlers[])(void* context) = {
+#include "nfc_playlist_scene_config.h"
+};
+#undef ADD_SCENE
+
+// 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,
+};

scenes/nfc_playlist_scene.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) NfcPlaylistScene_##id,
+typedef enum {
+#include "nfc_playlist_scene_config.h"
+    NfcPlaylistScene_Count
+} NfcPlaylistScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers nfc_playlist_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_##name##_scene_on_enter(void*);
+#include "nfc_playlist_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_event handlers declaration
+#define ADD_SCENE(prefix, name, id) \
+    bool prefix##_##name##_scene_on_event(void* context, SceneManagerEvent event);
+#include "nfc_playlist_scene_config.h"
+#undef ADD_SCENE
+
+// 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

scenes/nfc_playlist_scene_config.h

@@ -0,0 +1,11 @@
+ADD_SCENE(nfc_playlist, confirm_delete, ConfirmDelete)
+ADD_SCENE(nfc_playlist, emulation, Emulation)
+ADD_SCENE(nfc_playlist, playlist_edit, PlaylistEdit)
+ADD_SCENE(nfc_playlist, playlist_rename, PlaylistRename)
+ADD_SCENE(nfc_playlist, main_menu, MainMenu)
+ADD_SCENE(nfc_playlist, name_new_playlist, NameNewPlaylist)
+ADD_SCENE(nfc_playlist, nfc_select, NfcSelect)
+ADD_SCENE(nfc_playlist, nfc_remove, NfcRemove)
+ADD_SCENE(nfc_playlist, playlist_select, PlaylistSelect)
+ADD_SCENE(nfc_playlist, settings, Settings)
+ADD_SCENE(nfc_playlist, view_playlist_content, ViewPlaylistContent)

scenes/nfc_playlist_scene_confirm_delete.c

@@ -0,0 +1,76 @@
+#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);
+    }
+}
+
+void nfc_playlist_confirm_delete_scene_on_enter(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+
+    FuriString* temp_str = furi_string_alloc();
+    char* file_path = (char*)furi_string_get_cstr(nfc_playlist->settings.playlist_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);
+
+    furi_string_free(temp_str);
+
+    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:
+            Storage* storage = furi_record_open(RECORD_STORAGE);
+            storage_simply_remove(
+                storage, furi_string_get_cstr(nfc_playlist->settings.playlist_path));
+            nfc_playlist->settings.playlist_selected = false;
+            furi_string_reset(nfc_playlist->settings.playlist_path);
+            furi_record_close(RECORD_STORAGE);
+            consumed = true;
+            scene_manager_search_and_switch_to_previous_scene(
+                nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+            break;
+        default:
+            scene_manager_previous_scene(nfc_playlist->scene_manager);
+            break;
+        }
+    }
+    return consumed;
+}
+
+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

@@ -0,0 +1,236 @@
+#include "../nfc_playlist.h"
+
+typedef enum NfcPlaylistEmulationState {
+    NfcPlaylistEmulationState_Emulating,
+    NfcPlaylistEmulationState_Stopped,
+    NfcPlaylistEmulationState_Canceled
+} NfcPlaylistEmulationState;
+
+NfcPlaylistEmulationState EmulationState = NfcPlaylistEmulationState_Stopped;
+
+int32_t nfc_playlist_emulation_task(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+
+    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);
+
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Popup);
+
+    if(file_stream_open(
+           stream,
+           furi_string_get_cstr(nfc_playlist->settings.playlist_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();
+
+        while(stream_read_line(stream, line) &&
+              EmulationState == NfcPlaylistEmulationState_Emulating) {
+            char* file_path = (char*)furi_string_get_cstr(line);
+
+            if(strspn(file_path, " \t\n\r") == strlen(file_path)) {
+                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;
+            }
+
+            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);
+            }
+        }
+        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();
+}
+
+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;
+}
+
+void nfc_playlist_emulation_start(NfcPlaylist* nfc_playlist) {
+    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);
+}
+
+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);
+}
+
+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;
+}
+
+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);
+}

scenes/nfc_playlist_scene_main_menu.c

@@ -0,0 +1,99 @@
+#include "../nfc_playlist.h"
+
+typedef enum {
+    NfcPlaylistEvent_ShowEmulation,
+    NfcPlaylistEvent_ShowPlaylistSelect,
+    NfcPlaylistEvent_ShowFileEdit,
+    NfcPlaylistEvent_ShowSettings
+} NfcPlaylistMainMenuEvent;
+
+typedef enum {
+    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);
+}
+
+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;
+    }
+
+    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.playlist_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,
+        "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);
+
+    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:
+            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Emulation);
+            consumed = true;
+            break;
+        case NfcPlaylistEvent_ShowPlaylistSelect:
+            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistSelect);
+            consumed = true;
+            break;
+        case NfcPlaylistEvent_ShowFileEdit:
+            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistEdit);
+            consumed = true;
+            break;
+        case NfcPlaylistEvent_ShowSettings:
+            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_Settings);
+            consumed = true;
+            break;
+        default:
+            break;
+        }
+    }
+    return consumed;
+}
+
+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

@@ -0,0 +1,51 @@
+#include "../nfc_playlist.h"
+
+void nfc_playlist_name_new_playlist_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.playlist_path, file_name);
+    }
+
+    nfc_playlist->settings.playlist_length = 0;
+
+    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_playlist_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_playlist_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_playlist_scene_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}
+
+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_remove.c

@@ -0,0 +1,139 @@
+#include "../nfc_playlist.h"
+
+typedef enum {
+    NfcPlaylistSettings_LineSelector,
+    NfcPlaylistSettings_RemoveLine
+} NfcPlaylistSettingsMenuSelection;
+
+uint8_t selected_line;
+
+void nfc_playlist_nfc_remove_menu_callback(void* context, uint32_t index) {
+    NfcPlaylist* nfc_playlist = context;
+    scene_manager_handle_custom_event(nfc_playlist->scene_manager, 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 option_value_index = variable_item_get_current_value_index(item);
+    FuriString* tmp_str = furi_string_alloc();
+    switch(current_option) {
+    case NfcPlaylistSettings_LineSelector:
+        selected_line = option_value_index + 1;
+        furi_string_printf(tmp_str, "%d", selected_line);
+        variable_item_set_current_value_text(item, furi_string_get_cstr(tmp_str));
+        break;
+    default:
+        break;
+    }
+    furi_string_free(tmp_str);
+}
+
+void nfc_playlist_nfc_remove_scene_on_enter(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+    FuriString* tmp_str = furi_string_alloc();
+
+    selected_line = nfc_playlist->settings.playlist_length;
+
+    //variable_item_list_set_header(nfc_playlist->variable_item_list, "Settings");
+
+    VariableItem* Line_selector = variable_item_list_add(
+        nfc_playlist->variable_item_list,
+        "Select Line",
+        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);
+    furi_string_printf(tmp_str, "%d", selected_line);
+    variable_item_set_current_value_text(Line_selector, furi_string_get_cstr(tmp_str));
+    variable_item_set_locked(
+        Line_selector,
+        nfc_playlist->settings.playlist_length == 0 ? true : false,
+        "Playlist\nis empty");
+
+    variable_item_list_add(nfc_playlist->variable_item_list, "Remove Line", 0, NULL, NULL);
+    variable_item_set_locked(
+        variable_item_list_get(nfc_playlist->variable_item_list, NfcPlaylistSettings_RemoveLine),
+        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);
+    furi_string_free(tmp_str);
+
+    view_dispatcher_switch_to_view(
+        nfc_playlist->view_dispatcher, NfcPlaylistView_VariableItemList);
+}
+
+bool nfc_playlist_nfc_remove_scene_on_event(void* context, SceneManagerEvent event) {
+    NfcPlaylist* nfc_playlist = context;
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case NfcPlaylistSettings_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_replace_all(line, "\n", "");
+                        if(furi_string_empty(tmp_str)) {
+                            furi_string_cat_printf(tmp_str, "%s", furi_string_get_cstr(line));
+                        } else {
+                            furi_string_cat_printf(tmp_str, "\n%s", furi_string_get_cstr(line));
+                        }
+                    }
+                }
+
+                stream_clean(stream);
+                furi_string_free(line);
+                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 {
+                FuriString* tmp_str = furi_string_alloc();
+
+                VariableItem* Line_selector = variable_item_list_get(
+                    nfc_playlist->variable_item_list, NfcPlaylistSettings_LineSelector);
+                variable_item_set_values_count(
+                    Line_selector, nfc_playlist->settings.playlist_length);
+                variable_item_set_current_value_index(Line_selector, selected_line - 1);
+                furi_string_printf(tmp_str, "%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;
+}
+
+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_nfc_select.c

@@ -0,0 +1,65 @@
+#include "../nfc_playlist.h"
+
+void nfc_playlist_nfc_select_menu_callback(void* context) {
+    NfcPlaylist* nfc_playlist = 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)) {
+        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));
+        }
+
+        if(!furi_string_empty(tmp_str)) {
+            furi_string_cat_printf(
+                tmp_str, "\n%s", furi_string_get_cstr(nfc_playlist->file_browser_output));
+        } else {
+            furi_string_printf(
+                tmp_str, "%s", furi_string_get_cstr(nfc_playlist->file_browser_output));
+        }
+
+        stream_clean(stream);
+        furi_string_free(line);
+        stream_write_string(stream, tmp_str);
+        file_stream_close(stream);
+        furi_string_free(tmp_str);
+        nfc_playlist->settings.playlist_length++;
+    }
+
+    stream_free(stream);
+    furi_record_close(RECORD_STORAGE);
+    furi_string_reset(nfc_playlist->file_browser_output);
+
+    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);
+
+    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;
+}
+
+void nfc_playlist_nfc_select_scene_on_exit(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+    file_browser_stop(nfc_playlist->file_browser);
+}

scenes/nfc_playlist_scene_playlist_edit.c

@@ -0,0 +1,118 @@
+#include "../nfc_playlist.h"
+
+typedef enum {
+    NfcPlaylistMenuSelection_CreatePlaylist,
+    NfcPlaylistMenuSelection_DeletePlaylist,
+    NfcPlaylistMenuSelection_RenamePlaylist,
+    NfcPlaylistMenuSelection_AddNfcItem,
+    NfcPlaylistMenuSelection_RemoveNfcItem,
+    NfcPlaylistMenuSelection_ViewPlaylistContent
+} NfcPlaylistFileEditMenuSelection;
+
+void nfc_playlist_playlist_edit_menu_callback(void* context, uint32_t index) {
+    NfcPlaylist* nfc_playlist = context;
+    scene_manager_handle_custom_event(nfc_playlist->scene_manager, index);
+}
+
+void nfc_playlist_playlist_edit_scene_on_enter(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+
+    submenu_set_header(nfc_playlist->submenu, "Edit Playlist");
+
+    submenu_add_item(
+        nfc_playlist->submenu,
+        "Create Playlist",
+        NfcPlaylistMenuSelection_CreatePlaylist,
+        nfc_playlist_playlist_edit_menu_callback,
+        nfc_playlist);
+
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "Delete Playlist",
+        NfcPlaylistMenuSelection_DeletePlaylist,
+        nfc_playlist_playlist_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.playlist_path),
+        "No\nplaylist\nselected");
+
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "Rename Playlist",
+        NfcPlaylistMenuSelection_RenamePlaylist,
+        nfc_playlist_playlist_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.playlist_path),
+        "No\nplaylist\nselected");
+
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "Add NFC Item",
+        NfcPlaylistMenuSelection_AddNfcItem,
+        nfc_playlist_playlist_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.playlist_path),
+        "No\nplaylist\nselected");
+
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "Remove NFC Item",
+        NfcPlaylistMenuSelection_RemoveNfcItem,
+        nfc_playlist_playlist_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.playlist_path),
+        "No\nplaylist\nselected");
+
+    submenu_add_lockable_item(
+        nfc_playlist->submenu,
+        "View Playlist Content",
+        NfcPlaylistMenuSelection_ViewPlaylistContent,
+        nfc_playlist_playlist_edit_menu_callback,
+        nfc_playlist,
+        furi_string_empty(nfc_playlist->settings.playlist_path),
+        "No\nplaylist\nselected");
+
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_Submenu);
+}
+
+bool nfc_playlist_playlist_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:
+            scene_manager_next_scene(
+                nfc_playlist->scene_manager, NfcPlaylistScene_NameNewPlaylist);
+            consumed = true;
+            break;
+        case NfcPlaylistMenuSelection_DeletePlaylist:
+            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_ConfirmDelete);
+            consumed = true;
+            break;
+        case NfcPlaylistMenuSelection_RenamePlaylist:
+            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_PlaylistRename);
+            consumed = true;
+            break;
+        case NfcPlaylistMenuSelection_AddNfcItem:
+            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcSelect);
+            consumed = true;
+            break;
+        case NfcPlaylistMenuSelection_RemoveNfcItem:
+            scene_manager_next_scene(nfc_playlist->scene_manager, NfcPlaylistScene_NfcRemove);
+            consumed = true;
+            break;
+        case NfcPlaylistMenuSelection_ViewPlaylistContent:
+            scene_manager_next_scene(
+                nfc_playlist->scene_manager, NfcPlaylistScene_ViewPlaylistContent);
+            consumed = true;
+            break;
+        default:
+            break;
+        }
+    }
+    return consumed;
+}
+
+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

@@ -0,0 +1,63 @@
+#include "../nfc_playlist.h"
+
+void nfc_playlist_playlist_rename_menu_callback(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    char const* old_file_path = (char*)furi_string_get_cstr(nfc_playlist->settings.playlist_path);
+    char const* old_file_name =
+        strchr(old_file_path, '/') != NULL ? &strrchr(old_file_path, '/')[1] : old_file_path;
+
+    FuriString* new_file_path = furi_string_alloc_set(nfc_playlist->settings.playlist_path);
+    furi_string_replace(new_file_path, old_file_name, nfc_playlist->text_input_output);
+    furi_string_cat_str(new_file_path, ".txt");
+
+    if(storage_common_rename(storage, old_file_path, furi_string_get_cstr(new_file_path)) == 0) {
+        furi_string_move(nfc_playlist->settings.playlist_path, new_file_path);
+    } else {
+        furi_string_free(new_file_path);
+    }
+
+    furi_record_close(RECORD_STORAGE);
+
+    scene_manager_search_and_switch_to_previous_scene(
+        nfc_playlist->scene_manager, NfcPlaylistScene_MainMenu);
+}
+
+void nfc_playlist_playlist_rename_scene_on_enter(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+
+    char const* tmp_file_path = furi_string_get_cstr(nfc_playlist->settings.playlist_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", "");
+
+    nfc_playlist->text_input_output = strdup(furi_string_get_cstr(tmp_file_name_furi));
+    furi_string_free(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_playlist_rename_menu_callback,
+        nfc_playlist,
+        nfc_playlist->text_input_output,
+        (50 + sizeof(nfc_playlist->text_input_output)),
+        false);
+
+    view_dispatcher_switch_to_view(nfc_playlist->view_dispatcher, NfcPlaylistView_TextInput);
+}
+
+bool nfc_playlist_playlist_rename_scene_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}
+
+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

@@ -0,0 +1,53 @@
+#include "../nfc_playlist.h"
+
+void nfc_playlist_playlist_select_menu_callback(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+    furi_string_swap(nfc_playlist->settings.playlist_path, nfc_playlist->file_browser_output);
+    furi_string_reset(nfc_playlist->file_browser_output);
+
+    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)) {
+        nfc_playlist->settings.playlist_length = 0;
+        FuriString* line = furi_string_alloc();
+        while(stream_read_line(stream, line)) {
+            nfc_playlist->settings.playlist_length++;
+        }
+        furi_string_free(line);
+        file_stream_close(stream);
+    }
+
+    stream_free(stream);
+    furi_record_close(RECORD_STORAGE);
+
+    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);
+
+    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;
+}
+
+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

@@ -0,0 +1,177 @@
+#include "../nfc_playlist.h"
+
+typedef enum {
+    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);
+}
+
+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);
+}
+
+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);
+}
+
+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:
+            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));
+
+            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");
+
+            furi_string_free(tmp_str);
+            consumed = true;
+            break;
+        default:
+            break;
+        }
+    }
+    return consumed;
+}
+
+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

@@ -0,0 +1,58 @@
+#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);
+    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)) {
+        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));
+        }
+
+        stream_clean(stream);
+        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_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);
+    }
+
+    stream_free(stream);
+    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;
+}
+
+void nfc_playlist_view_playlist_content_scene_on_exit(void* context) {
+    NfcPlaylist* nfc_playlist = context;
+    widget_reset(nfc_playlist->widget);
+}