Merge branch 'ofw_dev' into nfcrefactoring

applications/main/nfc/scenes/nfc_scene_config.h

@@ -1,73 +1,57 @@
 ADD_SCENE(nfc, start, Start)
-ADD_SCENE(nfc, read, Read)
+ADD_SCENE(nfc, file_select, FileSelect)
 ADD_SCENE(nfc, saved_menu, SavedMenu)
-ADD_SCENE(nfc, extra_actions, ExtraActions)
-ADD_SCENE(nfc, set_type, SetType)
-ADD_SCENE(nfc, set_type_mf_uid, SetTypeMfUid)
-ADD_SCENE(nfc, set_sak, SetSak)
-ADD_SCENE(nfc, set_atqa, SetAtqa)
-ADD_SCENE(nfc, set_uid, SetUid)
-ADD_SCENE(nfc, generate_info, GenerateInfo)
-ADD_SCENE(nfc, read_card_success, ReadCardSuccess)
 ADD_SCENE(nfc, save_name, SaveName)
 ADD_SCENE(nfc, save_success, SaveSuccess)
-ADD_SCENE(nfc, file_select, FileSelect)
-ADD_SCENE(nfc, emulate_uid, EmulateUid)
-ADD_SCENE(nfc, nfca_read_success, NfcaReadSuccess)
-ADD_SCENE(nfc, nfca_menu, NfcaMenu)
-ADD_SCENE(nfc, nfcv_menu, NfcVMenu)
-ADD_SCENE(nfc, nfcv_unlock_menu, NfcVUnlockMenu)
-ADD_SCENE(nfc, nfcv_key_input, NfcVKeyInput)
-ADD_SCENE(nfc, nfcv_unlock, NfcVUnlock)
-ADD_SCENE(nfc, nfcv_emulate, NfcVEmulate)
-ADD_SCENE(nfc, nfcv_sniff, NfcVSniff)
-ADD_SCENE(nfc, nfcv_read_success, NfcVReadSuccess)
-ADD_SCENE(nfc, mf_ultralight_read_success, MfUltralightReadSuccess)
-ADD_SCENE(nfc, mf_ultralight_data, MfUltralightData)
-ADD_SCENE(nfc, mf_ultralight_menu, MfUltralightMenu)
-ADD_SCENE(nfc, mf_ultralight_emulate, MfUltralightEmulate)
-ADD_SCENE(nfc, mf_ultralight_read_auth, MfUltralightReadAuth)
-ADD_SCENE(nfc, mf_ultralight_read_auth_result, MfUltralightReadAuthResult)
-ADD_SCENE(nfc, mf_ultralight_key_input, MfUltralightKeyInput)
-ADD_SCENE(nfc, mf_ultralight_unlock_auto, MfUltralightUnlockAuto)
-ADD_SCENE(nfc, mf_ultralight_unlock_menu, MfUltralightUnlockMenu)
-ADD_SCENE(nfc, mf_ultralight_unlock_warn, MfUltralightUnlockWarn)
-ADD_SCENE(nfc, mf_desfire_read_success, MfDesfireReadSuccess)
-ADD_SCENE(nfc, mf_desfire_menu, MfDesfireMenu)
-ADD_SCENE(nfc, mf_desfire_data, MfDesfireData)
-ADD_SCENE(nfc, mf_desfire_app, MfDesfireApp)
-ADD_SCENE(nfc, mf_classic_read_success, MfClassicReadSuccess)
-ADD_SCENE(nfc, mf_classic_data, MfClassicData)
-ADD_SCENE(nfc, mf_classic_menu, MfClassicMenu)
-ADD_SCENE(nfc, mf_classic_emulate, MfClassicEmulate)
-ADD_SCENE(nfc, mf_classic_keys, MfClassicKeys)
-ADD_SCENE(nfc, mf_classic_keys_add, MfClassicKeysAdd)
-ADD_SCENE(nfc, mf_classic_keys_list, MfClassicKeysList)
-ADD_SCENE(nfc, mf_classic_keys_delete, MfClassicKeysDelete)
-ADD_SCENE(nfc, mf_classic_keys_warn_duplicate, MfClassicKeysWarnDuplicate)
-ADD_SCENE(nfc, mf_classic_dict_attack, MfClassicDictAttack)
-ADD_SCENE(nfc, mf_classic_write, MfClassicWrite)
-ADD_SCENE(nfc, mf_classic_write_success, MfClassicWriteSuccess)
-ADD_SCENE(nfc, mf_classic_write_fail, MfClassicWriteFail)
-ADD_SCENE(nfc, mf_classic_update, MfClassicUpdate)
-ADD_SCENE(nfc, mf_classic_update_success, MfClassicUpdateSuccess)
-ADD_SCENE(nfc, mf_classic_wrong_card, MfClassicWrongCard)
-ADD_SCENE(nfc, emv_read_success, EmvReadSuccess)
-ADD_SCENE(nfc, emv_menu, EmvMenu)
-ADD_SCENE(nfc, emulate_apdu_sequence, EmulateApduSequence)
-ADD_SCENE(nfc, device_info, DeviceInfo)
 ADD_SCENE(nfc, delete, Delete)
 ADD_SCENE(nfc, delete_success, DeleteSuccess)
 ADD_SCENE(nfc, restore_original_confirm, RestoreOriginalConfirm)
 ADD_SCENE(nfc, restore_original, RestoreOriginal)
+
+ADD_SCENE(nfc, detect, Detect)
+ADD_SCENE(nfc, read, Read)
+ADD_SCENE(nfc, info, Info)
+ADD_SCENE(nfc, more_info, MoreInfo)
+ADD_SCENE(nfc, supported_card, SupportedCard)
+ADD_SCENE(nfc, select_protocol, SelectProtocol)
+ADD_SCENE(nfc, extra_actions, ExtraActions)
+ADD_SCENE(nfc, read_success, ReadSuccess)
+ADD_SCENE(nfc, read_menu, ReadMenu)
+ADD_SCENE(nfc, emulate, Emulate)
+ADD_SCENE(nfc, rpc, Rpc)
 ADD_SCENE(nfc, debug, Debug)
 ADD_SCENE(nfc, field, Field)
-ADD_SCENE(nfc, dict_not_found, DictNotFound)
-ADD_SCENE(nfc, rpc, Rpc)
-ADD_SCENE(nfc, exit_confirm, ExitConfirm)
 ADD_SCENE(nfc, retry_confirm, RetryConfirm)
-ADD_SCENE(nfc, detect_reader, DetectReader)
-ADD_SCENE(nfc, mfkey_nonces_info, MfkeyNoncesInfo)
-ADD_SCENE(nfc, mfkey_complete, MfkeyComplete)
-ADD_SCENE(nfc, nfc_data_info, NfcDataInfo)
-ADD_SCENE(nfc, read_card_type, ReadCardType)
+ADD_SCENE(nfc, exit_confirm, ExitConfirm)
+
+ADD_SCENE(nfc, mf_ultralight_unlock_menu, MfUltralightUnlockMenu)
+ADD_SCENE(nfc, mf_ultralight_unlock_warn, MfUltralightUnlockWarn)
+ADD_SCENE(nfc, mf_ultralight_key_input, MfUltralightKeyInput)
+ADD_SCENE(nfc, mf_ultralight_capture_pass, MfUltralightCapturePass)
+
+ADD_SCENE(nfc, mf_desfire_more_info, MfDesfireMoreInfo)
+ADD_SCENE(nfc, mf_desfire_app, MfDesfireApp)
+
+ADD_SCENE(nfc, mf_classic_dict_attack, MfClassicDictAttack)
+ADD_SCENE(nfc, mf_classic_detect_reader, MfClassicDetectReader)
+ADD_SCENE(nfc, mf_classic_mfkey_nonces_info, MfClassicMfkeyNoncesInfo)
+ADD_SCENE(nfc, mf_classic_mfkey_complete, MfClassicMfkeyComplete)
+ADD_SCENE(nfc, mf_classic_update_initial, MfClassicUpdateInitial)
+ADD_SCENE(nfc, mf_classic_update_initial_success, MfClassicUpdateInitialSuccess)
+ADD_SCENE(nfc, mf_classic_write_initial, MfClassicWriteInitial)
+ADD_SCENE(nfc, mf_classic_write_initial_success, MfClassicWriteInitialSuccess)
+ADD_SCENE(nfc, mf_classic_write_initial_fail, MfClassicWriteInitialFail)
+ADD_SCENE(nfc, mf_classic_wrong_card, MfClassicWrongCard)
+
+ADD_SCENE(nfc, mf_classic_keys, MfClassicKeys)
+ADD_SCENE(nfc, mf_classic_keys_list, MfClassicKeysList)
+ADD_SCENE(nfc, mf_classic_keys_delete, MfClassicKeysDelete)
+ADD_SCENE(nfc, mf_classic_keys_add, MfClassicKeysAdd)
+ADD_SCENE(nfc, mf_classic_keys_warn_duplicate, MfClassicKeysWarnDuplicate)
+
+ADD_SCENE(nfc, set_type, SetType)
+ADD_SCENE(nfc, set_sak, SetSak)
+ADD_SCENE(nfc, set_atqa, SetAtqa)
+ADD_SCENE(nfc, set_uid, SetUid)
+
+ADD_SCENE(nfc, generate_info, GenerateInfo)

applications/main/nfc/scenes/nfc_scene_debug.c

@@ -1,4 +1,4 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 enum SubmenuDebugIndex {
     SubmenuDebugIndexField,
@@ -6,29 +6,26 @@ enum SubmenuDebugIndex {
 };
 
 void nfc_scene_debug_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
 }
 
 void nfc_scene_debug_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     Submenu* submenu = nfc->submenu;
 
     submenu_add_item(
         submenu, "Field", SubmenuDebugIndexField, nfc_scene_debug_submenu_callback, nfc);
-    submenu_add_item(
-        submenu, "Apdu", SubmenuDebugIndexApdu, nfc_scene_debug_submenu_callback, nfc);
 
     submenu_set_selected_item(
         submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneDebug));
 
-    nfc_device_clear(nfc->dev);
     view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
 }
 
 bool nfc_scene_debug_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
@@ -37,18 +34,13 @@ bool nfc_scene_debug_on_event(void* context, SceneManagerEvent event) {
                 nfc->scene_manager, NfcSceneDebug, SubmenuDebugIndexField);
             scene_manager_next_scene(nfc->scene_manager, NfcSceneField);
             consumed = true;
-        } else if(event.event == SubmenuDebugIndexApdu) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneDebug, SubmenuDebugIndexApdu);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateApduSequence);
-            consumed = true;
         }
     }
     return consumed;
 }
 
 void nfc_scene_debug_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     submenu_reset(nfc->submenu);
 }

applications/main/nfc/scenes/nfc_scene_delete.c

@@ -1,21 +1,20 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_delete_widget_callback(GuiButtonType result, InputType type, void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     if(type == InputTypeShort) {
         view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
     }
 }
 
 void nfc_scene_delete_on_enter(void* context) {
-    Nfc* nfc = context;
-    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
+    NfcApp* nfc = context;
 
     // Setup Custom Widget view
     FuriString* temp_str;
     temp_str = furi_string_alloc();
 
-    furi_string_printf(temp_str, "\e#Delete %s?\e#", nfc->dev->dev_name);
+    furi_string_printf(temp_str, "\e#Delete %s?\e#", furi_string_get_cstr(nfc->file_name));
     widget_add_text_box_element(
         nfc->widget, 0, 0, 128, 23, AlignCenter, AlignCenter, furi_string_get_cstr(temp_str), false);
     widget_add_button_element(
@@ -23,47 +22,33 @@ void nfc_scene_delete_on_enter(void* context) {
     widget_add_button_element(
         nfc->widget, GuiButtonTypeRight, "Delete", nfc_scene_delete_widget_callback, nfc);
 
+    size_t uid_len;
+    const uint8_t* uid = nfc_device_get_uid(nfc->nfc_device, &uid_len);
+
     furi_string_set(temp_str, "UID:");
-    for(size_t i = 0; i < nfc_data->uid_len; i++) {
-        furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
+    for(size_t i = 0; i < uid_len; i++) {
+        furi_string_cat_printf(temp_str, " %02X", uid[i]);
     }
     widget_add_string_element(
         nfc->widget, 64, 24, AlignCenter, AlignTop, FontSecondary, furi_string_get_cstr(temp_str));
 
-    NfcProtocol protocol = nfc->dev->dev_data.protocol;
-    const char* nfc_type = "NFC-A";
-
-    if(protocol == NfcDeviceProtocolEMV) {
-        furi_string_set(temp_str, "EMV bank card");
-    } else if(protocol == NfcDeviceProtocolMifareUl) {
-        furi_string_set(temp_str, nfc_mf_ul_type(nfc->dev->dev_data.mf_ul_data.type, true));
-    } else if(protocol == NfcDeviceProtocolMifareClassic) {
-        furi_string_set(temp_str, nfc_mf_classic_type(nfc->dev->dev_data.mf_classic_data.type));
-    } else if(protocol == NfcDeviceProtocolMifareDesfire) {
-        furi_string_set(temp_str, "MIFARE DESFire");
-    } else if(protocol == NfcDeviceProtocolNfcV) {
-        furi_string_set(temp_str, "ISO15693 tag");
-        nfc_type = "NFC-V";
-    } else {
-        furi_string_set(temp_str, "Unknown ISO tag");
-    }
+    furi_string_set_str(temp_str, nfc_device_get_name(nfc->nfc_device, NfcDeviceNameTypeFull));
     widget_add_string_element(
         nfc->widget, 64, 34, AlignCenter, AlignTop, FontSecondary, furi_string_get_cstr(temp_str));
-    widget_add_string_element(nfc->widget, 64, 44, AlignCenter, AlignTop, FontSecondary, nfc_type);
     furi_string_free(temp_str);
 
     view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
 }
 
 bool nfc_scene_delete_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == GuiButtonTypeLeft) {
             consumed = scene_manager_previous_scene(nfc->scene_manager);
         } else if(event.event == GuiButtonTypeRight) {
-            if(nfc_device_delete(nfc->dev, true)) {
+            if(nfc_delete(nfc)) {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneDeleteSuccess);
             } else {
                 scene_manager_search_and_switch_to_previous_scene(
@@ -76,7 +61,7 @@ bool nfc_scene_delete_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_delete_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     widget_reset(nfc->widget);
 }

applications/main/nfc/scenes/nfc_scene_delete_success.c

@@ -1,12 +1,12 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_delete_success_popup_callback(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
 }
 
 void nfc_scene_delete_success_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Setup view
     Popup* popup = nfc->popup;
@@ -20,7 +20,7 @@ void nfc_scene_delete_success_on_enter(void* context) {
 }
 
 bool nfc_scene_delete_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
@@ -38,7 +38,7 @@ bool nfc_scene_delete_success_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_delete_success_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Clear view
     popup_reset(nfc->popup);

applications/main/nfc/scenes/nfc_scene_detect.c

@@ -0,0 +1,59 @@
+#include "../nfc_app_i.h"
+#include <dolphin/dolphin.h>
+
+void nfc_scene_detect_scan_callback(NfcScannerEvent event, void* context) {
+    furi_assert(context);
+
+    NfcApp* instance = context;
+
+    if(event.type == NfcScannerEventTypeDetected) {
+        nfc_app_set_detected_protocols(instance, event.data.protocols, event.data.protocol_num);
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventWorkerExit);
+    }
+}
+
+void nfc_scene_detect_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    // Setup view
+    popup_reset(instance->popup);
+    popup_set_text(
+        instance->popup, "Apply card to\nFlipper's back", 97, 24, AlignCenter, AlignTop);
+    popup_set_icon(instance->popup, 0, 8, &I_NFC_manual_60x50);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+
+    nfc_app_reset_detected_protocols(instance);
+
+    instance->scanner = nfc_scanner_alloc(instance->nfc);
+    nfc_scanner_start(instance->scanner, nfc_scene_detect_scan_callback, instance);
+
+    nfc_blink_detect_start(instance);
+}
+
+bool nfc_scene_detect_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventWorkerExit) {
+            if(instance->protocols_detected_num > 1) {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneSelectProtocol);
+            } else {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneRead);
+            }
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_detect_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    nfc_scanner_stop(instance->scanner);
+    nfc_scanner_free(instance->scanner);
+    popup_reset(instance->popup);
+
+    nfc_blink_stop(instance);
+}

applications/main/nfc/scenes/nfc_scene_detect_reader.c

@@ -1,103 +0,0 @@
-#include "../nfc_i.h"
-
-#define NFC_SCENE_DETECT_READER_PAIR_NONCES_MAX (10U)
-
-static const NotificationSequence sequence_detect_reader = {
-    &message_green_255,
-    &message_blue_255,
-    &message_do_not_reset,
-    NULL,
-};
-
-bool nfc_detect_reader_worker_callback(NfcWorkerEvent event, void* context) {
-    UNUSED(event);
-    furi_assert(context);
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
-    return true;
-}
-
-void nfc_scene_detect_reader_callback(void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-void nfc_scene_detect_reader_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    detect_reader_set_callback(nfc->detect_reader, nfc_scene_detect_reader_callback, nfc);
-    detect_reader_set_nonces_max(nfc->detect_reader, NFC_SCENE_DETECT_READER_PAIR_NONCES_MAX);
-    NfcDeviceData* dev_data = &nfc->dev->dev_data;
-    if(dev_data->nfc_data.uid_len) {
-        detect_reader_set_uid(
-            nfc->detect_reader, dev_data->nfc_data.uid, dev_data->nfc_data.uid_len);
-    }
-
-    // Store number of collected nonces in scene state
-    scene_manager_set_scene_state(nfc->scene_manager, NfcSceneDetectReader, 0);
-    notification_message(nfc->notifications, &sequence_detect_reader);
-
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateAnalyzeReader,
-        &nfc->dev->dev_data,
-        nfc_detect_reader_worker_callback,
-        nfc);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDetectReader);
-}
-
-bool nfc_scene_detect_reader_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-    uint32_t nonces_collected =
-        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneDetectReader);
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventViewExit) {
-            nfc_worker_stop(nfc->worker);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfkeyNoncesInfo);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventDetectReaderMfkeyCollected) {
-            nonces_collected += 2;
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneDetectReader, nonces_collected);
-            detect_reader_set_nonces_collected(nfc->detect_reader, nonces_collected);
-            if(nonces_collected >= NFC_SCENE_DETECT_READER_PAIR_NONCES_MAX) {
-                detect_reader_set_state(nfc->detect_reader, DetectReaderStateDone);
-                nfc_blink_stop(nfc);
-                notification_message(nfc->notifications, &sequence_single_vibro);
-                notification_message(nfc->notifications, &sequence_set_green_255);
-                nfc_worker_stop(nfc->worker);
-            }
-            consumed = true;
-        } else if(event.event == NfcWorkerEventDetectReaderDetected) {
-            if(nonces_collected < NFC_SCENE_DETECT_READER_PAIR_NONCES_MAX) {
-                notification_message(nfc->notifications, &sequence_blink_start_cyan);
-                detect_reader_set_state(nfc->detect_reader, DetectReaderStateReaderDetected);
-            }
-        } else if(event.event == NfcWorkerEventDetectReaderLost) {
-            if(nonces_collected < NFC_SCENE_DETECT_READER_PAIR_NONCES_MAX) {
-                nfc_blink_stop(nfc);
-                notification_message(nfc->notifications, &sequence_detect_reader);
-                detect_reader_set_state(nfc->detect_reader, DetectReaderStateReaderLost);
-            }
-        }
-    }
-
-    return consumed;
-}
-
-void nfc_scene_detect_reader_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-
-    // Clear view
-    detect_reader_reset(nfc->detect_reader);
-
-    // Stop notifications
-    nfc_blink_stop(nfc);
-    notification_message(nfc->notifications, &sequence_reset_green);
-}

applications/main/nfc/scenes/nfc_scene_device_info.c

@@ -1,87 +0,0 @@
-#include "../nfc_i.h"
-#include "../helpers/nfc_emv_parser.h"
-
-void nfc_scene_device_info_widget_callback(GuiButtonType result, InputType type, void* context) {
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_device_info_on_enter(void* context) {
-    Nfc* nfc = context;
-    NfcDeviceData* dev_data = &nfc->dev->dev_data;
-
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    if(dev_data->protocol == NfcDeviceProtocolEMV) {
-        EmvData* emv_data = &dev_data->emv_data;
-        furi_string_printf(temp_str, "\e#%s\n", emv_data->name);
-        for(uint8_t i = 0; i < emv_data->number_len; i += 2) {
-            furi_string_cat_printf(
-                temp_str, "%02X%02X ", emv_data->number[i], emv_data->number[i + 1]);
-        }
-        furi_string_trim(temp_str);
-
-        // Add expiration date
-        if(emv_data->exp_mon) {
-            furi_string_cat_printf(
-                temp_str, "\nExp: %02X/%02X", emv_data->exp_mon, emv_data->exp_year);
-        }
-        // Parse currency code
-        if((emv_data->currency_code)) {
-            FuriString* currency_name;
-            currency_name = furi_string_alloc();
-            if(nfc_emv_parser_get_currency_name(
-                   nfc->dev->storage, emv_data->currency_code, currency_name)) {
-                furi_string_cat_printf(
-                    temp_str, "\nCur: %s  ", furi_string_get_cstr(currency_name));
-            }
-            furi_string_free(currency_name);
-        }
-        // Parse country code
-        if((emv_data->country_code)) {
-            FuriString* country_name;
-            country_name = furi_string_alloc();
-            if(nfc_emv_parser_get_country_name(
-                   nfc->dev->storage, emv_data->country_code, country_name)) {
-                furi_string_cat_printf(temp_str, "Reg: %s", furi_string_get_cstr(country_name));
-            }
-            furi_string_free(country_name);
-        }
-    } else if(
-        dev_data->protocol == NfcDeviceProtocolMifareClassic ||
-        dev_data->protocol == NfcDeviceProtocolMifareDesfire ||
-        dev_data->protocol == NfcDeviceProtocolMifareUl) {
-        furi_string_set(temp_str, nfc->dev->dev_data.parsed_data);
-    }
-
-    widget_add_text_scroll_element(nfc->widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
-    furi_string_free(temp_str);
-
-    widget_add_button_element(
-        nfc->widget, GuiButtonTypeRight, "More", nfc_scene_device_info_widget_callback, nfc);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_device_info_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeRight) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
-            consumed = true;
-        }
-    }
-    return consumed;
-}
-
-void nfc_scene_device_info_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear views
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_dict_not_found.c

@@ -1,52 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_dict_not_found_popup_callback(void* context) {
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-void nfc_scene_dict_not_found_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup view
-    Popup* popup = nfc->popup;
-    popup_set_text(
-        popup,
-        "Function requires\nan SD card with\nfresh databases.",
-        82,
-        24,
-        AlignCenter,
-        AlignCenter);
-    popup_set_icon(popup, 6, 10, &I_SDQuestion_35x43);
-    popup_set_timeout(popup, 2500);
-    popup_set_context(popup, nfc);
-    popup_set_callback(popup, nfc_scene_dict_not_found_popup_callback);
-    popup_enable_timeout(popup);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-}
-
-bool nfc_scene_dict_not_found_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventViewExit) {
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneMfClassicKeys)) {
-                consumed = scene_manager_search_and_switch_to_previous_scene(
-                    nfc->scene_manager, NfcSceneMfClassicKeys);
-            } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneExtraActions)) {
-                consumed = scene_manager_search_and_switch_to_previous_scene(
-                    nfc->scene_manager, NfcSceneExtraActions);
-            } else {
-                consumed = scene_manager_search_and_switch_to_previous_scene(
-                    nfc->scene_manager, NfcSceneStart);
-            }
-        }
-    }
-    return consumed;
-}
-
-void nfc_scene_dict_not_found_on_exit(void* context) {
-    Nfc* nfc = context;
-    popup_reset(nfc->popup);
-}

applications/main/nfc/scenes/nfc_scene_emulate.c

@@ -0,0 +1,13 @@
+#include "../helpers/protocol_support/nfc_protocol_support.h"
+
+void nfc_scene_emulate_on_enter(void* context) {
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneEmulate, context);
+}
+
+bool nfc_scene_emulate_on_event(void* context, SceneManagerEvent event) {
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneEmulate, context, event);
+}
+
+void nfc_scene_emulate_on_exit(void* context) {
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneEmulate, context);
+}

applications/main/nfc/scenes/nfc_scene_emulate_apdu_sequence.c

@@ -1,34 +0,0 @@
-#include "../nfc_i.h"
-#include <core/common_defines.h>
-
-void nfc_scene_emulate_apdu_sequence_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup view
-    Popup* popup = nfc->popup;
-    popup_set_header(popup, "Run APDU reader", 64, 31, AlignCenter, AlignTop);
-
-    // Setup and start worker
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-    nfc_worker_start(nfc->worker, NfcWorkerStateEmulateApdu, &nfc->dev->dev_data, NULL, nfc);
-
-    nfc_blink_emulate_start(nfc);
-}
-
-bool nfc_scene_emulate_apdu_sequence_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
-    bool consumed = false;
-    return consumed;
-}
-
-void nfc_scene_emulate_apdu_sequence_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-    // Clear view
-    popup_reset(nfc->popup);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_emulate_uid.c

@@ -1,144 +0,0 @@
-#include "../nfc_i.h"
-
-#define NFC_SCENE_EMULATE_UID_LOG_SIZE_MAX (200)
-
-enum {
-    NfcSceneEmulateUidStateWidget,
-    NfcSceneEmulateUidStateTextBox,
-};
-
-bool nfc_emulate_uid_worker_callback(NfcWorkerEvent event, void* context) {
-    UNUSED(event);
-    furi_assert(context);
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventWorkerExit);
-    return true;
-}
-
-void nfc_scene_emulate_uid_widget_callback(GuiButtonType result, InputType type, void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_emulate_uid_textbox_callback(void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-// Add widget with device name or inform that data received
-static void nfc_scene_emulate_uid_widget_config(Nfc* nfc, bool data_received) {
-    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
-    Widget* widget = nfc->widget;
-    widget_reset(widget);
-    FuriString* info_str;
-    info_str = furi_string_alloc();
-
-    widget_add_icon_element(widget, 0, 3, &I_NFC_dolphin_emulation_47x61);
-    widget_add_string_element(widget, 57, 13, AlignLeft, AlignTop, FontPrimary, "Emulating UID");
-    if(strcmp(nfc->dev->dev_name, "") != 0) {
-        furi_string_printf(info_str, "%s", nfc->dev->dev_name);
-    } else {
-        for(uint8_t i = 0; i < data->uid_len; i++) {
-            furi_string_cat_printf(info_str, "%02X ", data->uid[i]);
-        }
-    }
-    furi_string_trim(info_str);
-    widget_add_text_box_element(
-        widget, 57, 28, 67, 25, AlignCenter, AlignTop, furi_string_get_cstr(info_str), true);
-    furi_string_free(info_str);
-    if(data_received) {
-        widget_add_button_element(
-            widget, GuiButtonTypeCenter, "Log", nfc_scene_emulate_uid_widget_callback, nfc);
-    }
-}
-
-void nfc_scene_emulate_uid_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup Widget
-    nfc_scene_emulate_uid_widget_config(nfc, false);
-    // Setup TextBox
-    TextBox* text_box = nfc->text_box;
-    text_box_set_font(text_box, TextBoxFontHex);
-    text_box_set_focus(text_box, TextBoxFocusEnd);
-    furi_string_reset(nfc->text_box_store);
-
-    // Set Widget state and view
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneEmulateUid, NfcSceneEmulateUidStateWidget);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-    // Start worker
-    memset(&nfc->dev->dev_data.reader_data, 0, sizeof(NfcReaderRequestData));
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateUidEmulate,
-        &nfc->dev->dev_data,
-        nfc_emulate_uid_worker_callback,
-        nfc);
-
-    nfc_blink_emulate_start(nfc);
-}
-
-bool nfc_scene_emulate_uid_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    NfcReaderRequestData* reader_data = &nfc->dev->dev_data.reader_data;
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneEmulateUid);
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventWorkerExit) {
-            // Add data button to widget if data is received for the first time
-            if(!furi_string_size(nfc->text_box_store)) {
-                nfc_scene_emulate_uid_widget_config(nfc, true);
-            }
-            // Update TextBox data
-            if(furi_string_size(nfc->text_box_store) < NFC_SCENE_EMULATE_UID_LOG_SIZE_MAX) {
-                furi_string_cat_printf(nfc->text_box_store, "R:");
-                for(uint16_t i = 0; i < reader_data->size; i++) {
-                    furi_string_cat_printf(nfc->text_box_store, " %02X", reader_data->data[i]);
-                }
-                furi_string_push_back(nfc->text_box_store, '\n');
-                text_box_set_text(nfc->text_box, furi_string_get_cstr(nfc->text_box_store));
-            }
-            memset(reader_data, 0, sizeof(NfcReaderRequestData));
-            consumed = true;
-        } else if(event.event == GuiButtonTypeCenter && state == NfcSceneEmulateUidStateWidget) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneEmulateUid, NfcSceneEmulateUidStateTextBox);
-            consumed = true;
-        } else if(event.event == NfcCustomEventViewExit && state == NfcSceneEmulateUidStateTextBox) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneEmulateUid, NfcSceneEmulateUidStateWidget);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        if(state == NfcSceneEmulateUidStateTextBox) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneEmulateUid, NfcSceneEmulateUidStateWidget);
-            consumed = true;
-        }
-    }
-
-    return consumed;
-}
-
-void nfc_scene_emulate_uid_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-
-    // Clear view
-    widget_reset(nfc->widget);
-    text_box_reset(nfc->text_box);
-    furi_string_reset(nfc->text_box_store);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_emv_menu.c

@@ -1,54 +0,0 @@
-#include "../nfc_i.h"
-
-enum SubmenuIndex {
-    SubmenuIndexSave,
-    SubmenuIndexInfo,
-};
-
-void nfc_scene_emv_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_emv_menu_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-
-    submenu_add_item(submenu, "Save", SubmenuIndexSave, nfc_scene_emv_menu_submenu_callback, nfc);
-    submenu_add_item(submenu, "Info", SubmenuIndexInfo, nfc_scene_emv_menu_submenu_callback, nfc);
-    submenu_set_selected_item(
-        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneEmvMenu));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_emv_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SubmenuIndexSave) {
-            nfc->dev->format = NfcDeviceSaveFormatBankCard;
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
-            consumed = true;
-        } else if(event.event == SubmenuIndexInfo) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
-            consumed = true;
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneEmvMenu, event.event);
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed = scene_manager_previous_scene(nfc->scene_manager);
-    }
-
-    return consumed;
-}
-
-void nfc_scene_emv_menu_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_emv_read_success.c

@@ -1,113 +0,0 @@
-#include "../nfc_i.h"
-#include "../helpers/nfc_emv_parser.h"
-
-void nfc_scene_emv_read_success_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_emv_read_success_on_enter(void* context) {
-    Nfc* nfc = context;
-    EmvData* emv_data = &nfc->dev->dev_data.emv_data;
-
-    // Setup Custom Widget view
-    widget_add_button_element(
-        nfc->widget, GuiButtonTypeLeft, "Retry", nfc_scene_emv_read_success_widget_callback, nfc);
-    widget_add_button_element(
-        nfc->widget, GuiButtonTypeRight, "More", nfc_scene_emv_read_success_widget_callback, nfc);
-
-    FuriString* temp_str;
-    if(emv_data->name[0] != '\0') {
-        temp_str = furi_string_alloc_printf("\e#%s\n", emv_data->name);
-    } else {
-        temp_str = furi_string_alloc_printf("\e#Unknown Bank Card\n");
-    }
-    if(emv_data->number_len) {
-        for(uint8_t i = 0; i < emv_data->number_len; i += 2) {
-            furi_string_cat_printf(
-                temp_str, "%02X%02X ", emv_data->number[i], emv_data->number[i + 1]);
-        }
-        furi_string_trim(temp_str);
-    } else if(emv_data->aid_len) {
-        furi_string_cat_printf(temp_str, "Can't parse data from app\n");
-        // Parse AID name
-        FuriString* aid_name;
-        aid_name = furi_string_alloc();
-        if(nfc_emv_parser_get_aid_name(
-               nfc->dev->storage, emv_data->aid, emv_data->aid_len, aid_name)) {
-            furi_string_cat_printf(temp_str, "AID: %s", furi_string_get_cstr(aid_name));
-        } else {
-            furi_string_cat_printf(temp_str, "AID: ");
-            for(uint8_t i = 0; i < emv_data->aid_len; i++) {
-                furi_string_cat_printf(temp_str, "%02X", emv_data->aid[i]);
-            }
-        }
-        furi_string_free(aid_name);
-    }
-
-    // Add expiration date
-    if(emv_data->exp_mon) {
-        furi_string_cat_printf(
-            temp_str, "\nExp: %02X/%02X", emv_data->exp_mon, emv_data->exp_year);
-    }
-    // Parse currency code
-    if((emv_data->currency_code)) {
-        FuriString* currency_name;
-        currency_name = furi_string_alloc();
-        if(nfc_emv_parser_get_currency_name(
-               nfc->dev->storage, emv_data->currency_code, currency_name)) {
-            furi_string_cat_printf(temp_str, "\nCur: %s  ", furi_string_get_cstr(currency_name));
-        }
-        furi_string_free(currency_name);
-    }
-    // Parse country code
-    if((emv_data->country_code)) {
-        FuriString* country_name;
-        country_name = furi_string_alloc();
-        if(nfc_emv_parser_get_country_name(
-               nfc->dev->storage, emv_data->country_code, country_name)) {
-            furi_string_cat_printf(temp_str, "Reg: %s", furi_string_get_cstr(country_name));
-        }
-        furi_string_free(country_name);
-    }
-
-    notification_message_block(nfc->notifications, &sequence_set_green_255);
-
-    widget_add_text_scroll_element(nfc->widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
-    furi_string_free(temp_str);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_emv_read_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
-            consumed = true;
-        } else if(event.event == GuiButtonTypeRight) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmvMenu);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
-        consumed = true;
-    }
-    return consumed;
-}
-
-void nfc_scene_emv_read_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    notification_message_block(nfc->notifications, &sequence_reset_green);
-
-    // Clear view
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_exit_confirm.c

@@ -1,13 +1,13 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_exit_confirm_dialog_callback(DialogExResult result, void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
 }
 
 void nfc_scene_exit_confirm_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     DialogEx* dialog_ex = nfc->dialog_ex;
 
     dialog_ex_set_left_button_text(dialog_ex, "Exit");
@@ -22,16 +22,16 @@ void nfc_scene_exit_confirm_on_enter(void* context) {
 }
 
 bool nfc_scene_exit_confirm_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == DialogExResultRight) {
             consumed = scene_manager_previous_scene(nfc->scene_manager);
         } else if(event.event == DialogExResultLeft) {
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneReadCardType)) {
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSelectProtocol)) {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
-                    nfc->scene_manager, NfcSceneReadCardType);
+                    nfc->scene_manager, NfcSceneSelectProtocol);
             } else {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneStart);
@@ -45,7 +45,7 @@ bool nfc_scene_exit_confirm_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_exit_confirm_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Clean view
     dialog_ex_reset(nfc->dialog_ex);

applications/main/nfc/scenes/nfc_scene_extra_actions.c

@@ -1,92 +1,72 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 enum SubmenuIndex {
     SubmenuIndexReadCardType,
     SubmenuIndexMfClassicKeys,
     SubmenuIndexMfUltralightUnlock,
-    SubmenuIndexNfcVUnlock,
-    SubmenuIndexNfcVSniff,
 };
 
 void nfc_scene_extra_actions_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+    view_dispatcher_send_custom_event(instance->view_dispatcher, index);
 }
 
 void nfc_scene_extra_actions_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
+    NfcApp* instance = context;
+    Submenu* submenu = instance->submenu;
 
     submenu_add_item(
         submenu,
         "Read Specific Card Type",
         SubmenuIndexReadCardType,
         nfc_scene_extra_actions_submenu_callback,
-        nfc);
+        instance);
     submenu_add_item(
         submenu,
         "Mifare Classic Keys",
         SubmenuIndexMfClassicKeys,
         nfc_scene_extra_actions_submenu_callback,
-        nfc);
+        instance);
     submenu_add_item(
         submenu,
         "Unlock NTAG/Ultralight",
         SubmenuIndexMfUltralightUnlock,
         nfc_scene_extra_actions_submenu_callback,
-        nfc);
-    submenu_add_item(
-        submenu,
-        "Unlock SLIX-L",
-        SubmenuIndexNfcVUnlock,
-        nfc_scene_extra_actions_submenu_callback,
-        nfc);
-    submenu_add_item(
-        submenu,
-        "Listen NfcV Reader",
-        SubmenuIndexNfcVSniff,
-        nfc_scene_extra_actions_submenu_callback,
-        nfc);
+        instance);
     submenu_set_selected_item(
-        submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneExtraActions));
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+        submenu, scene_manager_get_scene_state(instance->scene_manager, NfcSceneExtraActions));
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewMenu);
 }
 
 bool nfc_scene_extra_actions_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexMfClassicKeys) {
-            if(mf_classic_dict_check_presence(MfClassicDictTypeSystem)) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeys);
+            if(nfc_dict_check_presence(NFC_APP_MF_CLASSIC_DICT_USER_PATH)) {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicKeys);
             } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
+                scene_manager_previous_scene(instance->scene_manager);
             }
             consumed = true;
         } else if(event.event == SubmenuIndexMfUltralightUnlock) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
+            mf_ultralight_auth_reset(instance->mf_ul_auth);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightUnlockMenu);
             consumed = true;
         } else if(event.event == SubmenuIndexReadCardType) {
-            scene_manager_set_scene_state(nfc->scene_manager, NfcSceneReadCardType, 0);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneReadCardType);
-            consumed = true;
-        } else if(event.event == SubmenuIndexNfcVUnlock) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVUnlockMenu);
-            consumed = true;
-        } else if(event.event == SubmenuIndexNfcVSniff) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVSniff);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneSelectProtocol);
             consumed = true;
         }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneExtraActions, event.event);
+        scene_manager_set_scene_state(instance->scene_manager, NfcSceneExtraActions, event.event);
     }
 
     return consumed;
 }
 
 void nfc_scene_extra_actions_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    submenu_reset(nfc->submenu);
+    submenu_reset(instance->submenu);
 }

applications/main/nfc/scenes/nfc_scene_field.c

@@ -1,10 +1,10 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_field_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    furi_hal_nfc_field_on();
+    NfcApp* nfc = context;
 
+    furi_hal_nfc_low_power_mode_stop();
+    furi_hal_nfc_poller_field_on();
     Popup* popup = nfc->popup;
     popup_set_header(
         popup,
@@ -25,9 +25,9 @@ bool nfc_scene_field_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_field_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
-    furi_hal_nfc_field_off();
+    furi_hal_nfc_low_power_mode_start();
     notification_internal_message(nfc->notifications, &sequence_reset_blue);
     popup_reset(nfc->popup);
 }

applications/main/nfc/scenes/nfc_scene_file_select.c

@@ -1,28 +1,20 @@
-#include "../nfc_i.h"
-#include "nfc/nfc_device.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_file_select_on_enter(void* context) {
-    Nfc* nfc = context;
-    nfc_device_data_clear(&nfc->dev->dev_data);
+    NfcApp* instance = context;
 
-    // Process file_select return
-    nfc_device_set_loading_callback(nfc->dev, nfc_show_loading_popup, nfc);
-    if(!furi_string_size(nfc->dev->load_path)) {
-        furi_string_set_str(nfc->dev->load_path, NFC_APP_FOLDER);
-    }
-    if(nfc_file_select(nfc->dev)) {
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneSavedMenu, 0);
-        scene_manager_next_scene(nfc->scene_manager, NfcSceneSavedMenu);
+    if(nfc_load_from_file_select(instance)) {
+        scene_manager_next_scene(instance->scene_manager, NfcSceneSavedMenu);
     } else {
-        scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, NfcSceneStart);
+        scene_manager_previous_scene(instance->scene_manager);
     }
-    nfc_device_set_loading_callback(nfc->dev, NULL, nfc);
 }
 
 bool nfc_scene_file_select_on_event(void* context, SceneManagerEvent event) {
     UNUSED(context);
     UNUSED(event);
-    return false;
+    bool consumed = false;
+    return consumed;
 }
 
 void nfc_scene_file_select_on_exit(void* context) {

applications/main/nfc/scenes/nfc_scene_generate_info.c

@@ -1,50 +1,55 @@
-#include "../nfc_i.h"
-#include "lib/nfc/helpers/nfc_generators.h"
+#include "../nfc_app_i.h"
 
-void nfc_scene_generate_info_dialog_callback(DialogExResult result, void* context) {
-    Nfc* nfc = context;
+void nfc_scene_generate_info_widget_callback(GuiButtonType result, InputType type, void* context) {
+    NfcApp* instance = context;
 
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+    if(type == InputTypeShort) {
+        if(result == GuiButtonTypeRight) {
+            view_dispatcher_send_custom_event(instance->view_dispatcher, result);
+        }
+    }
 }
 
 void nfc_scene_generate_info_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
+
+    NfcProtocol protocol = nfc_device_get_protocol(instance->nfc_device);
+    furi_assert((protocol == NfcProtocolMfUltralight) || (protocol == NfcProtocolMfClassic));
+
+    const Iso14443_3aData* iso14443_3a_data =
+        nfc_device_get_data(instance->nfc_device, NfcProtocolIso14443_3a);
 
     // Setup dialog view
-    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
-    DialogEx* dialog_ex = nfc->dialog_ex;
-    dialog_ex_set_right_button_text(dialog_ex, "More");
+    Widget* widget = instance->widget;
+    widget_add_button_element(
+        widget, GuiButtonTypeRight, "More", nfc_scene_generate_info_widget_callback, instance);
 
     // Create info text
-    FuriString* info_str = furi_string_alloc_printf(
-        "%s\n%s\nUID:", nfc->generator->name, nfc_get_dev_type(data->type));
+    NfcDataGeneratorType type =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneGenerateInfo);
+    const char* name = nfc_data_generator_get_name(type);
+    widget_add_string_element(widget, 0, 0, AlignLeft, AlignTop, FontPrimary, name);
+    widget_add_string_element(widget, 0, 13, AlignLeft, AlignTop, FontSecondary, "NFC-A");
 
+    FuriString* temp_str = furi_string_alloc_printf("UID:");
     // Append UID
-    for(int i = 0; i < data->uid_len; ++i) {
-        furi_string_cat_printf(info_str, " %02X", data->uid[i]);
+    for(int i = 0; i < iso14443_3a_data->uid_len; i++) {
+        furi_string_cat_printf(temp_str, " %02X", iso14443_3a_data->uid[i]);
     }
-    nfc_text_store_set(nfc, furi_string_get_cstr(info_str));
-    furi_string_free(info_str);
+    widget_add_string_element(
+        widget, 0, 25, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(temp_str));
+    furi_string_free(temp_str);
 
-    dialog_ex_set_text(dialog_ex, nfc->text_store, 0, 0, AlignLeft, AlignTop);
-    dialog_ex_set_context(dialog_ex, nfc);
-    dialog_ex_set_result_callback(dialog_ex, nfc_scene_generate_info_dialog_callback);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDialogEx);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
 }
 
 bool nfc_scene_generate_info_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == DialogExResultRight) {
-            // Switch either to NfcSceneMfClassicMenu or NfcSceneMfUltralightMenu
-            if(nfc->dev->dev_data.protocol == NfcDeviceProtocolMifareClassic) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicMenu);
-            } else if(nfc->dev->dev_data.protocol == NfcDeviceProtocolMifareUl) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightMenu);
-            }
+        if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneReadMenu);
             consumed = true;
         }
     }
@@ -53,8 +58,8 @@ bool nfc_scene_generate_info_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_generate_info_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
     // Clean views
-    dialog_ex_reset(nfc->dialog_ex);
+    widget_reset(instance->widget);
 }

applications/main/nfc/scenes/nfc_scene_info.c

@@ -0,0 +1,13 @@
+#include "../helpers/protocol_support/nfc_protocol_support.h"
+
+void nfc_scene_info_on_enter(void* context) {
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneInfo, context);
+}
+
+bool nfc_scene_info_on_event(void* context, SceneManagerEvent event) {
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneInfo, context, event);
+}
+
+void nfc_scene_info_on_exit(void* context) {
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneInfo, context);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_data.c

@@ -1,106 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_mf_classic_data_on_enter(void* context) {
-    Nfc* nfc = context;
-    MfClassicType type = nfc->dev->dev_data.mf_classic_data.type;
-    MfClassicData* data = &nfc->dev->dev_data.mf_classic_data;
-    TextBox* text_box = nfc->text_box;
-
-    text_box_set_font(text_box, TextBoxFontHex);
-
-    int card_blocks = 0;
-    if(type == MfClassicType1k) {
-        card_blocks = MF_CLASSIC_1K_TOTAL_SECTORS_NUM * 4;
-    } else if(type == MfClassicType4k) {
-        // 16 sectors of 4 blocks each plus 8 sectors of 16 blocks each
-        card_blocks = MF_CLASSIC_1K_TOTAL_SECTORS_NUM * 4 + 8 * 16;
-    } else if(type == MfClassicTypeMini) {
-        card_blocks = MF_MINI_TOTAL_SECTORS_NUM * 4;
-    }
-
-    int bytes_written = 0;
-    for(int block_num = 0; block_num < card_blocks; block_num++) {
-        bool is_sec_trailer = mf_classic_is_sector_trailer(block_num);
-        if(is_sec_trailer) {
-            uint8_t sector_num = mf_classic_get_sector_by_block(block_num);
-            MfClassicSectorTrailer* sec_tr =
-                mf_classic_get_sector_trailer_by_sector(data, sector_num);
-            // Key A
-            for(size_t i = 0; i < sizeof(sec_tr->key_a); i += 2) {
-                if((bytes_written % 8 == 0) && (bytes_written != 0)) {
-                    furi_string_push_back(nfc->text_box_store, '\n');
-                }
-                if(mf_classic_is_key_found(data, sector_num, MfClassicKeyA)) {
-                    furi_string_cat_printf(
-                        nfc->text_box_store, "%02X%02X ", sec_tr->key_a[i], sec_tr->key_a[i + 1]);
-                } else {
-                    furi_string_cat_printf(nfc->text_box_store, "???? ");
-                }
-                bytes_written += 2;
-            }
-            // Access bytes
-            for(size_t i = 0; i < MF_CLASSIC_ACCESS_BYTES_SIZE; i += 2) {
-                if((bytes_written % 8 == 0) && (bytes_written != 0)) {
-                    furi_string_push_back(nfc->text_box_store, '\n');
-                }
-                if(mf_classic_is_block_read(data, block_num)) {
-                    furi_string_cat_printf(
-                        nfc->text_box_store,
-                        "%02X%02X ",
-                        sec_tr->access_bits[i],
-                        sec_tr->access_bits[i + 1]);
-                } else {
-                    furi_string_cat_printf(nfc->text_box_store, "???? ");
-                }
-                bytes_written += 2;
-            }
-            // Key B
-            for(size_t i = 0; i < sizeof(sec_tr->key_b); i += 2) {
-                if((bytes_written % 8 == 0) && (bytes_written != 0)) {
-                    furi_string_push_back(nfc->text_box_store, '\n');
-                }
-                if(mf_classic_is_key_found(data, sector_num, MfClassicKeyB)) {
-                    furi_string_cat_printf(
-                        nfc->text_box_store, "%02X%02X ", sec_tr->key_b[i], sec_tr->key_b[i + 1]);
-                } else {
-                    furi_string_cat_printf(nfc->text_box_store, "???? ");
-                }
-                bytes_written += 2;
-            }
-        } else {
-            // Write data block
-            for(size_t i = 0; i < MF_CLASSIC_BLOCK_SIZE; i += 2) {
-                if((bytes_written % 8 == 0) && (bytes_written != 0)) {
-                    furi_string_push_back(nfc->text_box_store, '\n');
-                }
-                if(mf_classic_is_block_read(data, block_num)) {
-                    furi_string_cat_printf(
-                        nfc->text_box_store,
-                        "%02X%02X ",
-                        data->block[block_num].value[i],
-                        data->block[block_num].value[i + 1]);
-                } else {
-                    furi_string_cat_printf(nfc->text_box_store, "???? ");
-                }
-                bytes_written += 2;
-            }
-        }
-    }
-    text_box_set_text(text_box, furi_string_get_cstr(nfc->text_box_store));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
-}
-
-bool nfc_scene_mf_classic_data_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
-    return false;
-}
-
-void nfc_scene_mf_classic_data_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clean view
-    text_box_reset(nfc->text_box);
-    furi_string_reset(nfc->text_box_store);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_detect_reader.c

@@ -0,0 +1,154 @@
+#include "../nfc_app_i.h"
+
+#include <nfc/protocols/mf_classic/mf_classic_listener.h>
+
+#define NXP_MANUFACTURER_ID (0x04)
+
+#define NFC_SCENE_DETECT_READER_PAIR_NONCES_MAX (10U)
+#define NFC_SCENE_DETECT_READER_WAIT_NONCES_TIMEOUT_MS (1000)
+
+static const NotificationSequence sequence_detect_reader = {
+    &message_green_255,
+    &message_blue_255,
+    &message_do_not_reset,
+    NULL,
+};
+
+void nfc_scene_mf_classic_detect_reader_view_callback(void* context) {
+    NfcApp* instance = context;
+
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventViewExit);
+}
+
+NfcCommand nfc_scene_mf_classic_detect_listener_callback(NfcGenericEvent event, void* context) {
+    furi_assert(context);
+    furi_assert(event.event_data);
+    furi_assert(event.protocol == NfcProtocolMfClassic);
+
+    NfcApp* instance = context;
+    MfClassicListenerEvent* mfc_event = event.event_data;
+
+    if(mfc_event->type == MfClassicListenerEventTypeAuthContextPartCollected) {
+        MfClassicAuthContext* auth_ctx = &mfc_event->data->auth_context;
+        mfkey32_logger_add_nonce(instance->mfkey32_logger, auth_ctx);
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventWorkerUpdate);
+    }
+
+    return NfcCommandContinue;
+}
+
+void nfc_scene_mf_classic_timer_callback(void* context) {
+    NfcApp* instance = context;
+
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventTimerExpired);
+}
+
+void nfc_scene_mf_classic_detect_reader_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    if(nfc_device_get_protocol(instance->nfc_device) == NfcProtocolInvalid) {
+        Iso14443_3aData iso3_data = {
+            .uid_len = 7,
+            .uid = {0},
+            .atqa = {0x44, 0x00},
+            .sak = 0x08,
+        };
+        iso3_data.uid[0] = NXP_MANUFACTURER_ID;
+        furi_hal_random_fill_buf(&iso3_data.uid[1], iso3_data.uid_len - 1);
+        MfClassicData* mfc_data = mf_classic_alloc();
+
+        mfc_data->type = MfClassicType4k;
+        iso14443_3a_copy(mfc_data->iso14443_3a_data, &iso3_data);
+        nfc_device_set_data(instance->nfc_device, NfcProtocolMfClassic, mfc_data);
+
+        mf_classic_free(mfc_data);
+    }
+
+    const Iso14443_3aData* iso3_data =
+        nfc_device_get_data(instance->nfc_device, NfcProtocolIso14443_3a);
+    uint32_t cuid = iso14443_3a_get_cuid(iso3_data);
+
+    instance->mfkey32_logger = mfkey32_logger_alloc(cuid);
+    instance->timer =
+        furi_timer_alloc(nfc_scene_mf_classic_timer_callback, FuriTimerTypeOnce, instance);
+
+    detect_reader_set_nonces_max(instance->detect_reader, NFC_SCENE_DETECT_READER_PAIR_NONCES_MAX);
+    detect_reader_set_callback(
+        instance->detect_reader, nfc_scene_mf_classic_detect_reader_view_callback, instance);
+
+    notification_message(instance->notifications, &sequence_detect_reader);
+
+    instance->listener = nfc_listener_alloc(
+        instance->nfc,
+        NfcProtocolMfClassic,
+        nfc_device_get_data(instance->nfc_device, NfcProtocolMfClassic));
+    nfc_listener_start(
+        instance->listener, nfc_scene_mf_classic_detect_listener_callback, instance);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewDetectReader);
+}
+
+bool nfc_scene_mf_classic_detect_reader_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventWorkerUpdate) {
+            furi_timer_stop(instance->timer);
+            notification_message(instance->notifications, &sequence_blink_start_cyan);
+
+            size_t nonces_pairs = 2 * mfkey32_logger_get_params_num(instance->mfkey32_logger);
+            detect_reader_set_state(instance->detect_reader, DetectReaderStateReaderDetected);
+            detect_reader_set_nonces_collected(instance->detect_reader, nonces_pairs);
+            if(nonces_pairs >= NFC_SCENE_DETECT_READER_PAIR_NONCES_MAX) {
+                if(instance->listener) {
+                    nfc_listener_stop(instance->listener);
+                    nfc_listener_free(instance->listener);
+                    instance->listener = NULL;
+                }
+                detect_reader_set_state(instance->detect_reader, DetectReaderStateDone);
+                nfc_blink_stop(instance);
+                notification_message(instance->notifications, &sequence_single_vibro);
+                notification_message(instance->notifications, &sequence_set_green_255);
+            } else {
+                furi_timer_start(instance->timer, NFC_SCENE_DETECT_READER_WAIT_NONCES_TIMEOUT_MS);
+            }
+            consumed = true;
+        } else if(event.event == NfcCustomEventTimerExpired) {
+            detect_reader_set_state(instance->detect_reader, DetectReaderStateReaderLost);
+            nfc_blink_stop(instance);
+            notification_message(instance->notifications, &sequence_detect_reader);
+        } else if(event.event == NfcCustomEventViewExit) {
+            if(instance->listener) {
+                nfc_listener_stop(instance->listener);
+                nfc_listener_free(instance->listener);
+                instance->listener = NULL;
+            }
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicMfkeyNoncesInfo);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        if(instance->listener) {
+            nfc_listener_stop(instance->listener);
+            nfc_listener_free(instance->listener);
+            instance->listener = NULL;
+        }
+        mfkey32_logger_free(instance->mfkey32_logger);
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_detect_reader_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    // Clear view
+    detect_reader_reset(instance->detect_reader);
+
+    furi_timer_stop(instance->timer);
+    furi_timer_free(instance->timer);
+
+    // Stop notifications
+    nfc_blink_stop(instance);
+    notification_message(instance->notifications, &sequence_reset_green);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_dict_attack.c

@@ -1,186 +1,270 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
+
 #include <dolphin/dolphin.h>
+#include <lib/nfc/protocols/mf_classic/mf_classic_poller.h>
 
 #define TAG "NfcMfClassicDictAttack"
 
 typedef enum {
-    DictAttackStateIdle,
     DictAttackStateUserDictInProgress,
-    DictAttackStateFlipperDictInProgress,
+    DictAttackStateSystemDictInProgress,
 } DictAttackState;
 
-bool nfc_dict_attack_worker_callback(NfcWorkerEvent event, void* context) {
+NfcCommand nfc_dict_attack_worker_callback(NfcGenericEvent event, void* context) {
     furi_assert(context);
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
-    return true;
-}
+    furi_assert(event.event_data);
+    furi_assert(event.instance);
+    furi_assert(event.protocol == NfcProtocolMfClassic);
 
-void nfc_dict_attack_dict_attack_result_callback(void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventDictAttackSkip);
-}
+    NfcCommand command = NfcCommandContinue;
+    MfClassicPollerEvent* mfc_event = event.event_data;
 
-static void nfc_scene_mf_classic_dict_attack_update_view(Nfc* nfc) {
-    MfClassicData* data = &nfc->dev->dev_data.mf_classic_data;
-    uint8_t sectors_read = 0;
-    uint8_t keys_found = 0;
-
-    // Calculate found keys and read sectors
-    mf_classic_get_read_sectors_and_keys(data, &sectors_read, &keys_found);
-    dict_attack_set_keys_found(nfc->dict_attack, keys_found);
-    dict_attack_set_sector_read(nfc->dict_attack, sectors_read);
-}
-
-static void nfc_scene_mf_classic_dict_attack_prepare_view(Nfc* nfc, DictAttackState state) {
-    MfClassicData* data = &nfc->dev->dev_data.mf_classic_data;
-    NfcMfClassicDictAttackData* dict_attack_data = &nfc->dev->dev_data.mf_classic_dict_attack_data;
-    NfcWorkerState worker_state = NfcWorkerStateReady;
-    MfClassicDict* dict = NULL;
-
-    // Identify scene state
-    if(state == DictAttackStateIdle) {
-        if(mf_classic_dict_check_presence(MfClassicDictTypeUser)) {
-            state = DictAttackStateUserDictInProgress;
+    NfcApp* instance = context;
+    if(mfc_event->type == MfClassicPollerEventTypeCardDetected) {
+        instance->nfc_dict_context.is_card_present = true;
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventCardDetected);
+    } else if(mfc_event->type == MfClassicPollerEventTypeCardLost) {
+        instance->nfc_dict_context.is_card_present = false;
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventCardLost);
+    } else if(mfc_event->type == MfClassicPollerEventTypeRequestMode) {
+        const MfClassicData* mfc_data =
+            nfc_device_get_data(instance->nfc_device, NfcProtocolMfClassic);
+        mfc_event->data->poller_mode.mode = MfClassicPollerModeDictAttack;
+        mfc_event->data->poller_mode.data = mfc_data;
+        instance->nfc_dict_context.sectors_total =
+            mf_classic_get_total_sectors_num(mfc_data->type);
+        mf_classic_get_read_sectors_and_keys(
+            mfc_data,
+            &instance->nfc_dict_context.sectors_read,
+            &instance->nfc_dict_context.keys_found);
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+    } else if(mfc_event->type == MfClassicPollerEventTypeRequestKey) {
+        MfClassicKey key = {};
+        if(nfc_dict_get_next_key(instance->nfc_dict_context.dict, key.data, sizeof(MfClassicKey))) {
+            mfc_event->data->key_request_data.key = key;
+            mfc_event->data->key_request_data.key_provided = true;
+            instance->nfc_dict_context.dict_keys_current++;
+            if(instance->nfc_dict_context.dict_keys_current % 10 == 0) {
+                view_dispatcher_send_custom_event(
+                    instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+            }
         } else {
-            state = DictAttackStateFlipperDictInProgress;
+            mfc_event->data->key_request_data.key_provided = false;
         }
-    } else if(state == DictAttackStateUserDictInProgress) {
-        state = DictAttackStateFlipperDictInProgress;
+    } else if(mfc_event->type == MfClassicPollerEventTypeDataUpdate) {
+        MfClassicPollerEventDataUpdate* data_update = &mfc_event->data->data_update;
+        instance->nfc_dict_context.sectors_read = data_update->sectors_read;
+        instance->nfc_dict_context.keys_found = data_update->keys_found;
+        instance->nfc_dict_context.current_sector = data_update->current_sector;
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+    } else if(mfc_event->type == MfClassicPollerEventTypeNextSector) {
+        nfc_dict_rewind(instance->nfc_dict_context.dict);
+        instance->nfc_dict_context.dict_keys_current = 0;
+        instance->nfc_dict_context.current_sector =
+            mfc_event->data->next_sector_data.current_sector;
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+    } else if(mfc_event->type == MfClassicPollerEventTypeFoundKeyA) {
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+    } else if(mfc_event->type == MfClassicPollerEventTypeFoundKeyB) {
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+    } else if(mfc_event->type == MfClassicPollerEventTypeKeyAttackStart) {
+        instance->nfc_dict_context.key_attack_current_sector =
+            mfc_event->data->key_attack_data.current_sector;
+        instance->nfc_dict_context.is_key_attack = true;
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+    } else if(mfc_event->type == MfClassicPollerEventTypeKeyAttackStop) {
+        nfc_dict_rewind(instance->nfc_dict_context.dict);
+        instance->nfc_dict_context.is_key_attack = false;
+        instance->nfc_dict_context.dict_keys_current = 0;
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
+    } else if(mfc_event->type == MfClassicPollerEventTypeSuccess) {
+        const MfClassicData* mfc_data = nfc_poller_get_data(instance->poller);
+        nfc_device_set_data(instance->nfc_device, NfcProtocolMfClassic, mfc_data);
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, NfcCustomEventDictAttackComplete);
+        command = NfcCommandStop;
     }
 
-    // Setup view
+    return command;
+}
+
+void nfc_dict_attack_dict_attack_result_callback(DictAttackEvent event, void* context) {
+    furi_assert(context);
+    NfcApp* instance = context;
+
+    if(event == DictAttackEventSkipPressed) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventDictAttackSkip);
+    }
+}
+
+static void nfc_scene_mf_classic_dict_attack_update_view(NfcApp* instance) {
+    NfcMfClassicDictAttackContext* mfc_dict = &instance->nfc_dict_context;
+
+    if(mfc_dict->is_key_attack) {
+        dict_attack_set_key_attack(instance->dict_attack, mfc_dict->key_attack_current_sector);
+    } else {
+        dict_attack_reset_key_attack(instance->dict_attack);
+        dict_attack_set_sectors_total(instance->dict_attack, mfc_dict->sectors_total);
+        dict_attack_set_sectors_read(instance->dict_attack, mfc_dict->sectors_read);
+        dict_attack_set_keys_found(instance->dict_attack, mfc_dict->keys_found);
+        dict_attack_set_current_dict_key(instance->dict_attack, mfc_dict->dict_keys_current);
+        dict_attack_set_current_sector(instance->dict_attack, mfc_dict->current_sector);
+    }
+}
+
+static void nfc_scene_mf_classic_dict_attack_prepare_view(NfcApp* instance) {
+    uint32_t state =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfClassicDictAttack);
     if(state == DictAttackStateUserDictInProgress) {
-        worker_state = NfcWorkerStateMfClassicDictAttack;
-        dict_attack_set_header(nfc->dict_attack, "MF Classic User Dictionary");
-        dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
+        do {
+            if(!nfc_dict_check_presence(NFC_APP_MF_CLASSIC_DICT_USER_PATH)) {
+                state = DictAttackStateSystemDictInProgress;
+                break;
+            }
 
-        // If failed to load user dictionary - try the system dictionary
-        if(!dict) {
-            FURI_LOG_E(TAG, "User dictionary not found");
-            state = DictAttackStateFlipperDictInProgress;
-        }
+            instance->nfc_dict_context.dict = nfc_dict_alloc(
+                NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+            if(nfc_dict_get_total_keys(instance->nfc_dict_context.dict) == 0) {
+                nfc_dict_free(instance->nfc_dict_context.dict);
+                state = DictAttackStateSystemDictInProgress;
+                break;
+            }
+
+            dict_attack_set_header(instance->dict_attack, "MF Classic User Dictionary");
+        } while(false);
     }
-    if(state == DictAttackStateFlipperDictInProgress) {
-        worker_state = NfcWorkerStateMfClassicDictAttack;
-        dict_attack_set_header(nfc->dict_attack, "MF Classic System Dictionary");
-        dict = mf_classic_dict_alloc(MfClassicDictTypeSystem);
-        if(!dict) {
-            FURI_LOG_E(TAG, "Flipper dictionary not found");
-            // Pass through to let the worker handle the failure
-        }
+    if(state == DictAttackStateSystemDictInProgress) {
+        instance->nfc_dict_context.dict = nfc_dict_alloc(
+            NFC_APP_MF_CLASSIC_DICT_SYSTEM_PATH, NfcDictModeOpenExisting, sizeof(MfClassicKey));
+        dict_attack_set_header(instance->dict_attack, "MF Classic System Dictionary");
     }
-    // Free previous dictionary
-    if(dict_attack_data->dict) {
-        mf_classic_dict_free(dict_attack_data->dict);
-    }
-    dict_attack_data->dict = dict;
-    scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfClassicDictAttack, state);
-    dict_attack_set_callback(nfc->dict_attack, nfc_dict_attack_dict_attack_result_callback, nfc);
-    dict_attack_set_current_sector(nfc->dict_attack, 0);
-    dict_attack_set_card_detected(nfc->dict_attack, data->type);
+
+    instance->nfc_dict_context.dict_keys_total =
+        nfc_dict_get_total_keys(instance->nfc_dict_context.dict);
     dict_attack_set_total_dict_keys(
-        nfc->dict_attack, dict ? mf_classic_dict_get_total_keys(dict) : 0);
-    nfc_scene_mf_classic_dict_attack_update_view(nfc);
-    nfc_worker_start(
-        nfc->worker, worker_state, &nfc->dev->dev_data, nfc_dict_attack_worker_callback, nfc);
+        instance->dict_attack, instance->nfc_dict_context.dict_keys_total);
+    instance->nfc_dict_context.dict_keys_current = 0;
+
+    dict_attack_set_callback(
+        instance->dict_attack, nfc_dict_attack_dict_attack_result_callback, instance);
+    nfc_scene_mf_classic_dict_attack_update_view(instance);
+
+    scene_manager_set_scene_state(instance->scene_manager, NfcSceneMfClassicDictAttack, state);
 }
 
 void nfc_scene_mf_classic_dict_attack_on_enter(void* context) {
-    Nfc* nfc = context;
-    nfc_scene_mf_classic_dict_attack_prepare_view(nfc, DictAttackStateIdle);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewDictAttack);
-    nfc_blink_read_start(nfc);
-    notification_message(nfc->notifications, &sequence_display_backlight_enforce_on);
+    NfcApp* instance = context;
+
+    scene_manager_set_scene_state(
+        instance->scene_manager, NfcSceneMfClassicDictAttack, DictAttackStateUserDictInProgress);
+    nfc_scene_mf_classic_dict_attack_prepare_view(instance);
+    dict_attack_set_card_state(instance->dict_attack, true);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewDictAttack);
+    nfc_blink_read_start(instance);
+    notification_message(instance->notifications, &sequence_display_backlight_enforce_on);
+
+    instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfClassic);
+    nfc_poller_start(instance->poller, nfc_dict_attack_worker_callback, instance);
 }
 
 bool nfc_scene_mf_classic_dict_attack_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    MfClassicData* data = &nfc->dev->dev_data.mf_classic_data;
+    NfcApp* instance = context;
     bool consumed = false;
 
     uint32_t state =
-        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicDictAttack);
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfClassicDictAttack);
     if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcWorkerEventSuccess) {
+        if(event.event == NfcCustomEventDictAttackComplete) {
             if(state == DictAttackStateUserDictInProgress) {
-                nfc_worker_stop(nfc->worker);
-                nfc_scene_mf_classic_dict_attack_prepare_view(nfc, state);
+                nfc_poller_stop(instance->poller);
+                nfc_poller_free(instance->poller);
+                nfc_dict_free(instance->nfc_dict_context.dict);
+                scene_manager_set_scene_state(
+                    instance->scene_manager,
+                    NfcSceneMfClassicDictAttack,
+                    DictAttackStateSystemDictInProgress);
+                nfc_scene_mf_classic_dict_attack_prepare_view(instance);
+                instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfClassic);
+                nfc_poller_start(instance->poller, nfc_dict_attack_worker_callback, instance);
                 consumed = true;
             } else {
-                notification_message(nfc->notifications, &sequence_success);
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicReadSuccess);
+                notification_message(instance->notifications, &sequence_success);
+                scene_manager_next_scene(instance->scene_manager, NfcSceneReadSuccess);
                 dolphin_deed(DolphinDeedNfcReadSuccess);
                 consumed = true;
             }
-        } else if(event.event == NfcWorkerEventAborted) {
-            if(state == DictAttackStateUserDictInProgress &&
-               dict_attack_get_card_state(nfc->dict_attack)) {
-                nfc_scene_mf_classic_dict_attack_prepare_view(nfc, state);
-                consumed = true;
-            } else {
-                notification_message(nfc->notifications, &sequence_success);
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicReadSuccess);
-                // Counting failed attempts too
-                dolphin_deed(DolphinDeedNfcReadSuccess);
-                consumed = true;
-            }
-        } else if(event.event == NfcWorkerEventCardDetected) {
-            dict_attack_set_card_detected(nfc->dict_attack, data->type);
+        } else if(event.event == NfcCustomEventCardDetected) {
+            dict_attack_set_card_state(instance->dict_attack, true);
             consumed = true;
-        } else if(event.event == NfcWorkerEventNoCardDetected) {
-            dict_attack_set_card_removed(nfc->dict_attack);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventFoundKeyA) {
-            dict_attack_inc_keys_found(nfc->dict_attack);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventFoundKeyB) {
-            dict_attack_inc_keys_found(nfc->dict_attack);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventNewSector) {
-            nfc_scene_mf_classic_dict_attack_update_view(nfc);
-            dict_attack_inc_current_sector(nfc->dict_attack);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventNewDictKeyBatch) {
-            nfc_scene_mf_classic_dict_attack_update_view(nfc);
-            dict_attack_inc_current_dict_key(nfc->dict_attack, NFC_DICT_KEY_BATCH_SIZE);
+        } else if(event.event == NfcCustomEventCardLost) {
+            dict_attack_set_card_state(instance->dict_attack, false);
             consumed = true;
+        } else if(event.event == NfcCustomEventDictAttackDataUpdate) {
+            nfc_scene_mf_classic_dict_attack_update_view(instance);
         } else if(event.event == NfcCustomEventDictAttackSkip) {
+            const MfClassicData* mfc_data = nfc_poller_get_data(instance->poller);
+            nfc_device_set_data(instance->nfc_device, NfcProtocolMfClassic, mfc_data);
             if(state == DictAttackStateUserDictInProgress) {
-                nfc_worker_stop(nfc->worker);
+                if(instance->nfc_dict_context.is_card_present) {
+                    nfc_poller_stop(instance->poller);
+                    nfc_poller_free(instance->poller);
+                    nfc_dict_free(instance->nfc_dict_context.dict);
+                    scene_manager_set_scene_state(
+                        instance->scene_manager,
+                        NfcSceneMfClassicDictAttack,
+                        DictAttackStateSystemDictInProgress);
+                    nfc_scene_mf_classic_dict_attack_prepare_view(instance);
+                    instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfClassic);
+                    nfc_poller_start(instance->poller, nfc_dict_attack_worker_callback, instance);
+                } else {
+                    notification_message(instance->notifications, &sequence_success);
+                    scene_manager_next_scene(instance->scene_manager, NfcSceneReadSuccess);
+                    dolphin_deed(DolphinDeedNfcReadSuccess);
+                }
                 consumed = true;
-            } else if(state == DictAttackStateFlipperDictInProgress) {
-                nfc_worker_stop(nfc->worker);
+            } else if(state == DictAttackStateSystemDictInProgress) {
+                notification_message(instance->notifications, &sequence_success);
+                scene_manager_next_scene(instance->scene_manager, NfcSceneReadSuccess);
+                dolphin_deed(DolphinDeedNfcReadSuccess);
                 consumed = true;
             }
-        } else if(event.event == NfcWorkerEventKeyAttackStart) {
-            dict_attack_set_key_attack(
-                nfc->dict_attack,
-                true,
-                nfc->dev->dev_data.mf_classic_dict_attack_data.current_sector);
-        } else if(event.event == NfcWorkerEventKeyAttackStop) {
-            dict_attack_set_key_attack(nfc->dict_attack, false, 0);
-        } else if(event.event == NfcWorkerEventKeyAttackNextSector) {
-            dict_attack_inc_key_attack_current_sector(nfc->dict_attack);
         }
     } else if(event.type == SceneManagerEventTypeBack) {
-        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
+        scene_manager_next_scene(instance->scene_manager, NfcSceneExitConfirm);
         consumed = true;
     }
     return consumed;
 }
 
 void nfc_scene_mf_classic_dict_attack_on_exit(void* context) {
-    Nfc* nfc = context;
-    NfcMfClassicDictAttackData* dict_attack_data = &nfc->dev->dev_data.mf_classic_dict_attack_data;
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-    if(dict_attack_data->dict) {
-        mf_classic_dict_free(dict_attack_data->dict);
-        dict_attack_data->dict = NULL;
-    }
-    dict_attack_reset(nfc->dict_attack);
-    nfc_blink_stop(nfc);
-    notification_message(nfc->notifications, &sequence_display_backlight_enforce_auto);
+    NfcApp* instance = context;
+
+    nfc_poller_stop(instance->poller);
+    nfc_poller_free(instance->poller);
+
+    dict_attack_reset(instance->dict_attack);
+    scene_manager_set_scene_state(
+        instance->scene_manager, NfcSceneMfClassicDictAttack, DictAttackStateUserDictInProgress);
+
+    nfc_dict_free(instance->nfc_dict_context.dict);
+
+    instance->nfc_dict_context.current_sector = 0;
+    instance->nfc_dict_context.sectors_total = 0;
+    instance->nfc_dict_context.sectors_read = 0;
+    instance->nfc_dict_context.keys_found = 0;
+    instance->nfc_dict_context.dict_keys_total = 0;
+    instance->nfc_dict_context.dict_keys_current = 0;
+    instance->nfc_dict_context.is_key_attack = false;
+    instance->nfc_dict_context.key_attack_current_sector = 0;
+    instance->nfc_dict_context.is_card_present = false;
+
+    nfc_blink_stop(instance);
+    notification_message(instance->notifications, &sequence_display_backlight_enforce_auto);
 }

applications/main/nfc/scenes/nfc_scene_mf_classic_emulate.c

@@ -1,69 +0,0 @@
-#include "../nfc_i.h"
-
-#define NFC_MF_CLASSIC_DATA_NOT_CHANGED (0UL)
-#define NFC_MF_CLASSIC_DATA_CHANGED (1UL)
-
-bool nfc_mf_classic_emulate_worker_callback(NfcWorkerEvent event, void* context) {
-    UNUSED(event);
-    Nfc* nfc = context;
-
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneMfClassicEmulate, NFC_MF_CLASSIC_DATA_CHANGED);
-    return true;
-}
-
-void nfc_scene_mf_classic_emulate_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup view
-    Popup* popup = nfc->popup;
-    popup_set_header(popup, "Emulating", 67, 13, AlignLeft, AlignTop);
-    if(strcmp(nfc->dev->dev_name, "") != 0) {
-        nfc_text_store_set(nfc, "%s", nfc->dev->dev_name);
-    } else {
-        nfc_text_store_set(nfc, "MIFARE\nClassic");
-    }
-    popup_set_icon(popup, 0, 3, &I_NFC_dolphin_emulation_47x61);
-    popup_set_text(popup, nfc->text_store, 90, 28, AlignCenter, AlignTop);
-
-    // Setup and start worker
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateMfClassicEmulate,
-        &nfc->dev->dev_data,
-        nfc_mf_classic_emulate_worker_callback,
-        nfc);
-    nfc_blink_emulate_start(nfc);
-}
-
-bool nfc_scene_mf_classic_emulate_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeBack) {
-        // Stop worker
-        nfc_worker_stop(nfc->worker);
-        // Check if data changed and save in shadow file
-        if(scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicEmulate) ==
-           NFC_MF_CLASSIC_DATA_CHANGED) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfClassicEmulate, NFC_MF_CLASSIC_DATA_NOT_CHANGED);
-            // Save shadow file
-            if(furi_string_size(nfc->dev->load_path)) {
-                nfc_device_save_shadow(nfc->dev, furi_string_get_cstr(nfc->dev->load_path));
-            }
-        }
-        consumed = false;
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_classic_emulate_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    popup_reset(nfc->popup);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_keys.c

@@ -1,62 +1,86 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
+
+#define NFC_SCENE_MF_CLASSIC_KEYS_MAX (100)
 
 void nfc_scene_mf_classic_keys_widget_callback(GuiButtonType result, InputType type, void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
     }
 }
 
 void nfc_scene_mf_classic_keys_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
     // Load flipper dict keys total
     uint32_t flipper_dict_keys_total = 0;
-    MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeSystem);
+    NfcDict* dict = nfc_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_SYSTEM_PATH, NfcDictModeOpenExisting, sizeof(MfClassicKey));
     if(dict) {
-        flipper_dict_keys_total = mf_classic_dict_get_total_keys(dict);
-        mf_classic_dict_free(dict);
-    }
-    // Load user dict keys total
-    uint32_t user_dict_keys_total = 0;
-    dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
-    if(dict) {
-        user_dict_keys_total = mf_classic_dict_get_total_keys(dict);
-        mf_classic_dict_free(dict);
+        flipper_dict_keys_total = nfc_dict_get_total_keys(dict);
+        nfc_dict_free(dict);
     }
 
+    // Load user dict keys total
+    uint32_t user_dict_keys_total = 0;
+    dict = nfc_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+    if(dict) {
+        user_dict_keys_total = nfc_dict_get_total_keys(dict);
+        nfc_dict_free(dict);
+    }
+
+    FuriString* temp_str = furi_string_alloc();
     widget_add_string_element(
-        nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "MIFARE Classic Keys");
-    char temp_str[32];
-    snprintf(temp_str, sizeof(temp_str), "System dict: %lu", flipper_dict_keys_total);
-    widget_add_string_element(nfc->widget, 0, 20, AlignLeft, AlignTop, FontSecondary, temp_str);
-    snprintf(temp_str, sizeof(temp_str), "User dict: %lu", user_dict_keys_total);
-    widget_add_string_element(nfc->widget, 0, 32, AlignLeft, AlignTop, FontSecondary, temp_str);
+        instance->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "MIFARE Classic Keys");
+    furi_string_printf(temp_str, "System dict: %lu", flipper_dict_keys_total);
+    widget_add_string_element(
+        instance->widget,
+        0,
+        20,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        furi_string_get_cstr(temp_str));
+    furi_string_printf(temp_str, "User dict: %lu", user_dict_keys_total);
+    widget_add_string_element(
+        instance->widget,
+        0,
+        32,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        furi_string_get_cstr(temp_str));
+    widget_add_icon_element(instance->widget, 87, 13, &I_Keychain_39x36);
     widget_add_button_element(
-        nfc->widget, GuiButtonTypeCenter, "Add", nfc_scene_mf_classic_keys_widget_callback, nfc);
-    widget_add_icon_element(nfc->widget, 87, 13, &I_Keychain_39x36);
+        instance->widget,
+        GuiButtonTypeCenter,
+        "Add",
+        nfc_scene_mf_classic_keys_widget_callback,
+        instance);
     if(user_dict_keys_total > 0) {
         widget_add_button_element(
-            nfc->widget,
+            instance->widget,
             GuiButtonTypeRight,
             "List",
             nfc_scene_mf_classic_keys_widget_callback,
-            nfc);
+            instance);
     }
+    furi_string_free(temp_str);
 
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
 }
 
 bool nfc_scene_mf_classic_keys_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == GuiButtonTypeCenter) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeysAdd);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicKeysAdd);
             consumed = true;
         } else if(event.event == GuiButtonTypeRight) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeysList);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicKeysList);
             consumed = true;
         }
     }
@@ -65,7 +89,7 @@ bool nfc_scene_mf_classic_keys_on_event(void* context, SceneManagerEvent event)
 }
 
 void nfc_scene_mf_classic_keys_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    widget_reset(nfc->widget);
+    widget_reset(instance->widget);
 }

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_add.c

@@ -1,60 +1,62 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
+#include "../nfc_app_i.h"
 
 void nfc_scene_mf_classic_keys_add_byte_input_callback(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventByteInputDone);
 }
 
 void nfc_scene_mf_classic_keys_add_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
     // Setup view
-    ByteInput* byte_input = nfc->byte_input;
+    ByteInput* byte_input = instance->byte_input;
     byte_input_set_header_text(byte_input, "Enter the key in hex");
     byte_input_set_result_callback(
         byte_input,
         nfc_scene_mf_classic_keys_add_byte_input_callback,
         NULL,
-        nfc,
-        nfc->byte_input_store,
-        6);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+        instance,
+        instance->byte_input_store,
+        sizeof(MfClassicKey));
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewByteInput);
 }
 
 bool nfc_scene_mf_classic_keys_add_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventByteInputDone) {
             // Add key to dict
-            MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
-            if(dict) {
-                if(mf_classic_dict_is_key_present(dict, nfc->byte_input_store)) {
-                    scene_manager_next_scene(
-                        nfc->scene_manager, NfcSceneMfClassicKeysWarnDuplicate);
-                } else if(mf_classic_dict_add_key(dict, nfc->byte_input_store)) {
-                    scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
-                    dolphin_deed(DolphinDeedNfcMfcAdd);
-                } else {
-                    scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
-                }
+            NfcDict* dict = nfc_dict_alloc(
+                NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+            furi_assert(dict);
+
+            MfClassicKey key = {};
+            memcpy(key.data, instance->byte_input_store, sizeof(MfClassicKey));
+            if(nfc_dict_is_key_present(dict, key.data, sizeof(MfClassicKey))) {
+                scene_manager_next_scene(
+                    instance->scene_manager, NfcSceneMfClassicKeysWarnDuplicate);
+            } else if(nfc_dict_add_key(dict, key.data, sizeof(MfClassicKey))) {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneSaveSuccess);
+                dolphin_deed(DolphinDeedNfcMfcAdd);
             } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
+                scene_manager_previous_scene(instance->scene_manager);
             }
-            mf_classic_dict_free(dict);
+
+            nfc_dict_free(dict);
             consumed = true;
         }
     }
+
     return consumed;
 }
 
 void nfc_scene_mf_classic_keys_add_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
     // Clear view
-    byte_input_set_result_callback(nfc->byte_input, NULL, NULL, NULL, NULL, 0);
-    byte_input_set_header_text(nfc->byte_input, "");
+    byte_input_set_result_callback(instance->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(instance->byte_input, "");
 }

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_delete.c

@@ -1,42 +1,40 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_mf_classic_keys_delete_widget_callback(
     GuiButtonType result,
     InputType type,
     void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
     }
 }
 
 void nfc_scene_mf_classic_keys_delete_on_enter(void* context) {
-    Nfc* nfc = context;
-    MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
+    NfcApp* instance = context;
+
     uint32_t key_index =
-        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicKeysDelete);
-    // Setup Custom Widget view
-    FuriString* key_str;
-    key_str = furi_string_alloc();
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfClassicKeysDelete);
+    FuriString* key_str = furi_string_alloc();
 
     widget_add_string_element(
-        nfc->widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Delete this key?");
+        instance->widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Delete this key?");
     widget_add_button_element(
-        nfc->widget,
+        instance->widget,
         GuiButtonTypeLeft,
         "Cancel",
         nfc_scene_mf_classic_keys_delete_widget_callback,
-        nfc);
+        instance);
     widget_add_button_element(
-        nfc->widget,
+        instance->widget,
         GuiButtonTypeRight,
         "Delete",
         nfc_scene_mf_classic_keys_delete_widget_callback,
-        nfc);
+        instance);
 
-    mf_classic_dict_get_key_at_index_str(dict, key_str, key_index);
+    mf_user_dict_get_key_str(instance->mf_user_dict, key_index, key_str);
     widget_add_string_element(
-        nfc->widget,
+        instance->widget,
         64,
         32,
         AlignCenter,
@@ -45,39 +43,35 @@ void nfc_scene_mf_classic_keys_delete_on_enter(void* context) {
         furi_string_get_cstr(key_str));
 
     furi_string_free(key_str);
-    mf_classic_dict_free(dict);
 
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
 }
 
 bool nfc_scene_mf_classic_keys_delete_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
-    uint32_t key_index =
-        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicKeysDelete);
 
     if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            consumed = scene_manager_search_and_switch_to_previous_scene(
-                nfc->scene_manager, NfcSceneMfClassicKeys);
-        } else if(event.event == GuiButtonTypeRight) {
-            MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
-            if(mf_classic_dict_delete_index(dict, key_index)) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneDeleteSuccess);
+        if(event.event == GuiButtonTypeRight) {
+            uint32_t key_index = scene_manager_get_scene_state(
+                instance->scene_manager, NfcSceneMfClassicKeysDelete);
+            if(mf_user_dict_delete_key(instance->mf_user_dict, key_index)) {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneDeleteSuccess);
             } else {
-                scene_manager_search_and_switch_to_previous_scene(
-                    nfc->scene_manager, NfcSceneMfClassicKeys);
+                scene_manager_previous_scene(instance->scene_manager);
             }
-            mf_classic_dict_free(dict);
-            consumed = true;
+        } else if(event.event == GuiButtonTypeLeft) {
+            scene_manager_previous_scene(instance->scene_manager);
         }
+        consumed = true;
     }
 
     return consumed;
 }
 
 void nfc_scene_mf_classic_keys_delete_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    widget_reset(nfc->widget);
+    mf_user_dict_free(instance->mf_user_dict);
+    widget_reset(instance->widget);
 }

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_list.c

@@ -1,100 +1,51 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 #define NFC_SCENE_MF_CLASSIC_KEYS_LIST_MAX (100)
 
 void nfc_scene_mf_classic_keys_list_submenu_callback(void* context, uint32_t index) {
-    furi_assert(context);
+    NfcApp* instance = context;
 
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_mf_classic_keys_list_popup_callback(void* context) {
-    furi_assert(context);
-
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-void nfc_scene_mf_classic_keys_list_prepare(Nfc* nfc, MfClassicDict* dict) {
-    Submenu* submenu = nfc->submenu;
-    uint32_t index = 0;
-    FuriString* temp_key;
-    temp_key = furi_string_alloc();
-
-    submenu_set_header(submenu, "Select key to delete:");
-    while(mf_classic_dict_get_next_key_str(dict, temp_key)) {
-        char* current_key = (char*)malloc(sizeof(char) * 13);
-        strncpy(current_key, furi_string_get_cstr(temp_key), 12);
-        MfClassicUserKeys_push_back(nfc->mfc_key_strs, current_key);
-        FURI_LOG_D("ListKeys", "Key %lu: %s", index, current_key);
-        submenu_add_item(
-            submenu, current_key, index++, nfc_scene_mf_classic_keys_list_submenu_callback, nfc);
-    }
-    furi_string_free(temp_key);
+    view_dispatcher_send_custom_event(instance->view_dispatcher, index);
 }
 
 void nfc_scene_mf_classic_keys_list_on_enter(void* context) {
-    Nfc* nfc = context;
-    MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
-    MfClassicUserKeys_init(nfc->mfc_key_strs);
-    if(dict) {
-        uint32_t total_user_keys = mf_classic_dict_get_total_keys(dict);
-        if(total_user_keys < NFC_SCENE_MF_CLASSIC_KEYS_LIST_MAX) {
-            nfc_scene_mf_classic_keys_list_prepare(nfc, dict);
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-        } else {
-            popup_set_header(nfc->popup, "Too many keys!", 64, 0, AlignCenter, AlignTop);
-            popup_set_text(
-                nfc->popup,
-                "Edit user dictionary\nwith file browser",
-                64,
-                12,
-                AlignCenter,
-                AlignTop);
-            popup_set_callback(nfc->popup, nfc_scene_mf_classic_keys_list_popup_callback);
-            popup_set_context(nfc->popup, nfc);
-            popup_set_timeout(nfc->popup, 3000);
-            popup_enable_timeout(nfc->popup);
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-        }
-        mf_classic_dict_free(dict);
-    } else {
-        popup_set_header(
-            nfc->popup, "Failed to load dictionary", 64, 32, AlignCenter, AlignCenter);
-        popup_set_callback(nfc->popup, nfc_scene_mf_classic_keys_list_popup_callback);
-        popup_set_context(nfc->popup, nfc);
-        popup_set_timeout(nfc->popup, 3000);
-        popup_enable_timeout(nfc->popup);
-        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+    NfcApp* instance = context;
+
+    instance->mf_user_dict = mf_user_dict_alloc(NFC_SCENE_MF_CLASSIC_KEYS_LIST_MAX);
+
+    submenu_set_header(instance->submenu, "Select key to delete:");
+    FuriString* temp_str = furi_string_alloc();
+    for(size_t i = 0; i < mf_user_dict_get_keys_cnt(instance->mf_user_dict); i++) {
+        mf_user_dict_get_key_str(instance->mf_user_dict, i, temp_str);
+        submenu_add_item(
+            instance->submenu,
+            furi_string_get_cstr(temp_str),
+            i,
+            nfc_scene_mf_classic_keys_list_submenu_callback,
+            instance);
     }
+    furi_string_free(temp_str);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewMenu);
 }
 
 bool nfc_scene_mf_classic_keys_list_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
+
     bool consumed = false;
     if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventViewExit) {
-            consumed = scene_manager_previous_scene(nfc->scene_manager);
-        } else {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfClassicKeysDelete, event.event);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeysDelete);
-            consumed = true;
-        }
+        scene_manager_set_scene_state(
+            instance->scene_manager, NfcSceneMfClassicKeysDelete, event.event);
+        scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicKeysDelete);
+    } else if(event.type == SceneManagerEventTypeBack) {
+        mf_user_dict_free(instance->mf_user_dict);
     }
+
     return consumed;
 }
 
 void nfc_scene_mf_classic_keys_list_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    MfClassicUserKeys_it_t it;
-    for(MfClassicUserKeys_it(it, nfc->mfc_key_strs); !MfClassicUserKeys_end_p(it);
-        MfClassicUserKeys_next(it)) {
-        free(*MfClassicUserKeys_ref(it));
-    }
-    MfClassicUserKeys_clear(nfc->mfc_key_strs);
-    submenu_reset(nfc->submenu);
-    popup_reset(nfc->popup);
+    submenu_reset(instance->submenu);
 }

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_warn_duplicate.c

@@ -1,15 +1,16 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_mf_classic_keys_warn_duplicate_popup_callback(void* context) {
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
+    NfcApp* instance = context;
+
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventViewExit);
 }
 
 void nfc_scene_mf_classic_keys_warn_duplicate_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
     // Setup view
-    Popup* popup = nfc->popup;
+    Popup* popup = instance->popup;
     popup_set_icon(popup, 72, 16, &I_DolphinCommon_56x48);
     popup_set_header(popup, "Key already exists!", 64, 3, AlignCenter, AlignTop);
     popup_set_text(
@@ -20,28 +21,29 @@ void nfc_scene_mf_classic_keys_warn_duplicate_on_enter(void* context) {
         24,
         AlignLeft,
         AlignTop);
-    popup_set_timeout(popup, 5000);
-    popup_set_context(popup, nfc);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, instance);
     popup_set_callback(popup, nfc_scene_mf_classic_keys_warn_duplicate_popup_callback);
     popup_enable_timeout(popup);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
 }
 
 bool nfc_scene_mf_classic_keys_warn_duplicate_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventViewExit) {
             consumed = scene_manager_search_and_switch_to_previous_scene(
-                nfc->scene_manager, NfcSceneMfClassicKeysAdd);
+                instance->scene_manager, NfcSceneMfClassicKeysAdd);
         }
     }
+
     return consumed;
 }
 
 void nfc_scene_mf_classic_keys_warn_duplicate_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    popup_reset(nfc->popup);
+    popup_reset(instance->popup);
 }

applications/main/nfc/scenes/nfc_scene_mf_classic_menu.c

@@ -1,82 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum SubmenuIndex {
-    SubmenuIndexSave,
-    SubmenuIndexEmulate,
-    SubmenuIndexDetectReader,
-    SubmenuIndexInfo,
-};
-
-void nfc_scene_mf_classic_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_mf_classic_menu_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-
-    submenu_add_item(
-        submenu, "Save", SubmenuIndexSave, nfc_scene_mf_classic_menu_submenu_callback, nfc);
-    submenu_add_item(
-        submenu, "Emulate", SubmenuIndexEmulate, nfc_scene_mf_classic_menu_submenu_callback, nfc);
-    if(!mf_classic_is_card_read(&nfc->dev->dev_data.mf_classic_data)) {
-        submenu_add_item(
-            submenu,
-            "Detect Reader",
-            SubmenuIndexDetectReader,
-            nfc_scene_mf_classic_menu_submenu_callback,
-            nfc);
-    }
-    submenu_add_item(
-        submenu, "Info", SubmenuIndexInfo, nfc_scene_mf_classic_menu_submenu_callback, nfc);
-
-    submenu_set_selected_item(
-        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicMenu));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_mf_classic_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfClassicMenu, event.event);
-        if(event.event == SubmenuIndexSave) {
-            nfc->dev->format = NfcDeviceSaveFormatMifareClassic;
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
-            consumed = true;
-        } else if(event.event == SubmenuIndexEmulate) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicEmulate);
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
-                dolphin_deed(DolphinDeedNfcAddEmulate);
-            } else {
-                dolphin_deed(DolphinDeedNfcEmulate);
-            }
-            consumed = true;
-        } else if(event.event == SubmenuIndexDetectReader) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneDetectReader);
-            dolphin_deed(DolphinDeedNfcDetectReader);
-            consumed = true;
-        } else if(event.event == SubmenuIndexInfo) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed = scene_manager_previous_scene(nfc->scene_manager);
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mf_classic_menu_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_mfkey_complete.c

@@ -0,0 +1,58 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_classic_mfkey_complete_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    NfcApp* instance = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_classic_mfkey_complete_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    widget_add_string_element(
+        instance->widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Complete!");
+    widget_add_string_multiline_element(
+        instance->widget,
+        64,
+        32,
+        AlignCenter,
+        AlignCenter,
+        FontSecondary,
+        "Now use Mfkey32\nto extract keys");
+    widget_add_button_element(
+        instance->widget,
+        GuiButtonTypeCenter,
+        "OK",
+        nfc_scene_mf_classic_mfkey_complete_callback,
+        instance);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_classic_mfkey_complete_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeCenter) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                instance->scene_manager, NfcSceneStart);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        const uint32_t prev_scenes[] = {NfcSceneSavedMenu, NfcSceneStart};
+        consumed = scene_manager_search_and_switch_to_previous_scene_one_of(
+            instance->scene_manager, prev_scenes, COUNT_OF(prev_scenes));
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_mfkey_complete_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    widget_reset(instance->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_mfkey_nonces_info.c

@@ -0,0 +1,72 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_classic_mfkey_nonces_info_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    NfcApp* instance = context;
+
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_classic_mfkey_nonces_info_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    FuriString* temp_str = furi_string_alloc();
+
+    size_t mfkey_params_saved = mfkey32_logger_get_params_num(instance->mfkey32_logger);
+    furi_string_printf(temp_str, "Nonce pairs saved: %zu\n", mfkey_params_saved);
+    widget_add_string_element(
+        instance->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, furi_string_get_cstr(temp_str));
+    widget_add_string_element(
+        instance->widget, 0, 12, AlignLeft, AlignTop, FontSecondary, "Authenticated sectors:");
+
+    mfkey32_logger_get_params_data(instance->mfkey32_logger, temp_str);
+    widget_add_text_scroll_element(
+        instance->widget, 0, 22, 128, 42, furi_string_get_cstr(temp_str));
+    widget_add_button_element(
+        instance->widget,
+        GuiButtonTypeCenter,
+        "OK",
+        nfc_scene_mf_classic_mfkey_nonces_info_callback,
+        instance);
+
+    furi_string_free(temp_str);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_classic_mfkey_nonces_info_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeCenter) {
+            if(mfkey32_logger_save_params(
+                   instance->mfkey32_logger, NFC_APP_MFKEY32_LOGS_FILE_PATH)) {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicMfkeyComplete);
+            } else {
+                scene_manager_search_and_switch_to_previous_scene(
+                    instance->scene_manager, NfcSceneStart);
+            }
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        const uint32_t prev_scenes[] = {NfcSceneSavedMenu, NfcSceneStart};
+        consumed = scene_manager_search_and_switch_to_previous_scene_one_of(
+            instance->scene_manager, prev_scenes, COUNT_OF(prev_scenes));
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_mfkey_nonces_info_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    mfkey32_logger_free(instance->mfkey32_logger);
+
+    // Clear view
+    widget_reset(instance->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_read_success.c

@@ -1,82 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_mf_classic_read_success_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_mf_classic_read_success_on_enter(void* context) {
-    Nfc* nfc = context;
-    NfcDeviceData* dev_data = &nfc->dev->dev_data;
-    MfClassicData* mf_data = &dev_data->mf_classic_data;
-
-    // Setup view
-    Widget* widget = nfc->widget;
-    widget_add_button_element(
-        widget, GuiButtonTypeLeft, "Retry", nfc_scene_mf_classic_read_success_widget_callback, nfc);
-    widget_add_button_element(
-        widget, GuiButtonTypeRight, "More", nfc_scene_mf_classic_read_success_widget_callback, nfc);
-
-    FuriString* temp_str = NULL;
-    if(furi_string_size(nfc->dev->dev_data.parsed_data)) {
-        temp_str = furi_string_alloc_set(nfc->dev->dev_data.parsed_data);
-    } else {
-        temp_str = furi_string_alloc_printf("\e#%s\n", nfc_mf_classic_type(mf_data->type));
-        furi_string_cat_printf(temp_str, "UID:");
-        for(size_t i = 0; i < dev_data->nfc_data.uid_len; i++) {
-            furi_string_cat_printf(temp_str, " %02X", dev_data->nfc_data.uid[i]);
-        }
-        uint8_t sectors_total = mf_classic_get_total_sectors_num(mf_data->type);
-        uint8_t keys_total = sectors_total * 2;
-        uint8_t keys_found = 0;
-        uint8_t sectors_read = 0;
-        mf_classic_get_read_sectors_and_keys(mf_data, &sectors_read, &keys_found);
-        furi_string_cat_printf(temp_str, "\nKeys Found: %d/%d", keys_found, keys_total);
-        furi_string_cat_printf(temp_str, "\nSectors Read: %d/%d", sectors_read, sectors_total);
-    }
-
-    widget_add_text_scroll_element(widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
-    furi_string_free(temp_str);
-
-    notification_message_block(nfc->notifications, &sequence_set_green_255);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_mf_classic_read_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
-            consumed = true;
-        } else if(event.event == GuiButtonTypeRight) {
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicMenu);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
-        consumed = true;
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mf_classic_read_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    notification_message_block(nfc->notifications, &sequence_reset_green);
-
-    // Clear view
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_update.c

@@ -1,98 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum {
-    NfcSceneMfClassicUpdateStateCardSearch,
-    NfcSceneMfClassicUpdateStateCardFound,
-};
-
-bool nfc_mf_classic_update_worker_callback(NfcWorkerEvent event, void* context) {
-    furi_assert(context);
-
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
-
-    return true;
-}
-
-static void nfc_scene_mf_classic_update_setup_view(Nfc* nfc) {
-    Popup* popup = nfc->popup;
-    popup_reset(popup);
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicUpdate);
-
-    if(state == NfcSceneMfClassicUpdateStateCardSearch) {
-        popup_set_text(
-            nfc->popup, "Apply the initial\ncard only", 128, 32, AlignRight, AlignCenter);
-        popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual_60x50);
-    } else {
-        popup_set_header(popup, "Updating\nDon't move...", 52, 32, AlignLeft, AlignCenter);
-        popup_set_icon(popup, 12, 23, &A_Loading_24);
-    }
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-}
-
-void nfc_scene_mf_classic_update_on_enter(void* context) {
-    Nfc* nfc = context;
-    dolphin_deed(DolphinDeedNfcEmulate);
-
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneMfClassicUpdate, NfcSceneMfClassicUpdateStateCardSearch);
-    nfc_scene_mf_classic_update_setup_view(nfc);
-
-    // Setup and start worker
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateMfClassicUpdate,
-        &nfc->dev->dev_data,
-        nfc_mf_classic_update_worker_callback,
-        nfc);
-    nfc_blink_emulate_start(nfc);
-}
-
-bool nfc_scene_mf_classic_update_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcWorkerEventSuccess) {
-            nfc_worker_stop(nfc->worker);
-            if(nfc_device_save_shadow(nfc->dev, furi_string_get_cstr(nfc->dev->load_path))) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicUpdateSuccess);
-            } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicWrongCard);
-            }
-            consumed = true;
-        } else if(event.event == NfcWorkerEventWrongCard) {
-            nfc_worker_stop(nfc->worker);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicWrongCard);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventCardDetected) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager,
-                NfcSceneMfClassicUpdate,
-                NfcSceneMfClassicUpdateStateCardFound);
-            nfc_scene_mf_classic_update_setup_view(nfc);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventNoCardDetected) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager,
-                NfcSceneMfClassicUpdate,
-                NfcSceneMfClassicUpdateStateCardSearch);
-            nfc_scene_mf_classic_update_setup_view(nfc);
-            consumed = true;
-        }
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_classic_update_on_exit(void* context) {
-    Nfc* nfc = context;
-    nfc_worker_stop(nfc->worker);
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneMfClassicUpdate, NfcSceneMfClassicUpdateStateCardSearch);
-    // Clear view
-    popup_reset(nfc->popup);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_update_initial.c

@@ -0,0 +1,144 @@
+#include "../nfc_app_i.h"
+
+#include <nfc/protocols/mf_classic/mf_classic_poller.h>
+
+enum {
+    NfcSceneMfClassicUpdateInitialStateCardSearch,
+    NfcSceneMfClassicUpdateInitialStateCardFound,
+};
+
+NfcCommand nfc_mf_classic_update_initial_worker_callback(NfcGenericEvent event, void* context) {
+    furi_assert(context);
+    furi_assert(event.event_data);
+    furi_assert(event.protocol == NfcProtocolMfClassic);
+
+    NfcCommand command = NfcCommandContinue;
+    const MfClassicPollerEvent* mfc_event = event.event_data;
+    NfcApp* instance = context;
+
+    if(mfc_event->type == MfClassicPollerEventTypeCardDetected) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventCardDetected);
+    } else if(mfc_event->type == MfClassicPollerEventTypeCardLost) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventCardLost);
+    } else if(mfc_event->type == MfClassicPollerEventTypeRequestMode) {
+        const MfClassicData* updated_data = nfc_poller_get_data(instance->poller);
+        const MfClassicData* old_data =
+            nfc_device_get_data(instance->nfc_device, NfcProtocolMfClassic);
+        if(iso14443_3a_is_equal(updated_data->iso14443_3a_data, old_data->iso14443_3a_data)) {
+            mfc_event->data->poller_mode.mode = MfClassicPollerModeRead;
+        } else {
+            view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventWrongCard);
+            command = NfcCommandStop;
+        }
+    } else if(mfc_event->type == MfClassicPollerEventTypeRequestReadSector) {
+        uint8_t sector_num = 0;
+        MfClassicKey key = {};
+        MfClassicKeyType key_type = MfClassicKeyTypeA;
+        if(mf_classic_key_cahce_get_next_key(
+               instance->mfc_key_cache, &sector_num, &key, &key_type)) {
+            mfc_event->data->read_sector_request_data.sector_num = sector_num;
+            mfc_event->data->read_sector_request_data.key = key;
+            mfc_event->data->read_sector_request_data.key_type = key_type;
+            mfc_event->data->read_sector_request_data.key_provided = true;
+        } else {
+            mfc_event->data->read_sector_request_data.key_provided = false;
+        }
+    } else if(mfc_event->type == MfClassicPollerEventTypeSuccess) {
+        const MfClassicData* updated_data = nfc_poller_get_data(instance->poller);
+        nfc_device_set_data(instance->nfc_device, NfcProtocolMfClassic, updated_data);
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventWorkerExit);
+        command = NfcCommandStop;
+    }
+
+    return command;
+}
+
+static void nfc_scene_mf_classic_update_initial_setup_view(NfcApp* instance) {
+    Popup* popup = instance->popup;
+    popup_reset(popup);
+    uint32_t state =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfClassicUpdateInitial);
+
+    if(state == NfcSceneMfClassicUpdateInitialStateCardSearch) {
+        popup_set_text(
+            instance->popup, "Apply the initial\ncard only", 128, 32, AlignRight, AlignCenter);
+        popup_set_icon(instance->popup, 0, 8, &I_NFC_manual_60x50);
+    } else {
+        popup_set_header(popup, "Updating\nDon't move...", 52, 32, AlignLeft, AlignCenter);
+        popup_set_icon(popup, 12, 23, &A_Loading_24);
+    }
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+}
+
+void nfc_scene_mf_classic_update_initial_on_enter(void* context) {
+    NfcApp* instance = context;
+    dolphin_deed(DolphinDeedNfcEmulate);
+
+    const MfClassicData* mfc_data =
+        nfc_device_get_data(instance->nfc_device, NfcProtocolMfClassic);
+    mf_classic_key_cache_load_from_data(instance->mfc_key_cache, mfc_data);
+
+    scene_manager_set_scene_state(
+        instance->scene_manager,
+        NfcSceneMfClassicUpdateInitial,
+        NfcSceneMfClassicUpdateInitialStateCardSearch);
+    nfc_scene_mf_classic_update_initial_setup_view(instance);
+
+    // Setup and start worker
+    instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfClassic);
+    nfc_poller_start(instance->poller, nfc_mf_classic_update_initial_worker_callback, instance);
+    nfc_blink_emulate_start(instance);
+}
+
+bool nfc_scene_mf_classic_update_initial_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventCardDetected) {
+            scene_manager_set_scene_state(
+                instance->scene_manager,
+                NfcSceneMfClassicUpdateInitial,
+                NfcSceneMfClassicUpdateInitialStateCardFound);
+            nfc_scene_mf_classic_update_initial_setup_view(instance);
+            consumed = true;
+        } else if(event.event == NfcCustomEventCardLost) {
+            scene_manager_set_scene_state(
+                instance->scene_manager,
+                NfcSceneMfClassicUpdateInitial,
+                NfcSceneMfClassicUpdateInitialStateCardSearch);
+            nfc_scene_mf_classic_update_initial_setup_view(instance);
+            consumed = true;
+        } else if(event.event == NfcCustomEventWrongCard) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicWrongCard);
+            consumed = true;
+        } else if(event.event == NfcCustomEventWorkerExit) {
+            if(nfc_save_shadow_file(instance)) {
+                scene_manager_next_scene(
+                    instance->scene_manager, NfcSceneMfClassicUpdateInitialSuccess);
+            } else {
+                scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicWrongCard);
+                consumed = true;
+            }
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_update_initial_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    nfc_poller_stop(instance->poller);
+    nfc_poller_free(instance->poller);
+
+    scene_manager_set_scene_state(
+        instance->scene_manager,
+        NfcSceneMfClassicUpdateInitial,
+        NfcSceneMfClassicUpdateInitialStateCardSearch);
+    // Clear view
+    popup_reset(instance->popup);
+
+    nfc_blink_stop(instance);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_update_initial_success.c

@@ -0,0 +1,43 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_classic_update_initial_success_popup_callback(void* context) {
+    NfcApp* instance = context;
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_mf_classic_update_initial_success_on_enter(void* context) {
+    NfcApp* instance = context;
+    dolphin_deed(DolphinDeedNfcSave);
+
+    notification_message(instance->notifications, &sequence_success);
+
+    Popup* popup = instance->popup;
+    popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
+    popup_set_header(popup, "Updated!", 11, 20, AlignLeft, AlignBottom);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, instance);
+    popup_set_callback(popup, nfc_scene_mf_classic_update_initial_success_popup_callback);
+    popup_enable_timeout(popup);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_mf_classic_update_initial_success_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                instance->scene_manager, NfcSceneSavedMenu);
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_classic_update_initial_success_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    // Clear view
+    popup_reset(instance->popup);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_update_success.c

@@ -1,44 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-void nfc_scene_mf_classic_update_success_popup_callback(void* context) {
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-void nfc_scene_mf_classic_update_success_on_enter(void* context) {
-    Nfc* nfc = context;
-    dolphin_deed(DolphinDeedNfcSave);
-
-    notification_message(nfc->notifications, &sequence_success);
-
-    Popup* popup = nfc->popup;
-    popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
-    popup_set_header(popup, "Updated!", 11, 20, AlignLeft, AlignBottom);
-    popup_set_timeout(popup, 1500);
-    popup_set_context(popup, nfc);
-    popup_set_callback(popup, nfc_scene_mf_classic_update_success_popup_callback);
-    popup_enable_timeout(popup);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-}
-
-bool nfc_scene_mf_classic_update_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventViewExit) {
-            consumed = scene_manager_search_and_switch_to_previous_scene(
-                nfc->scene_manager, NfcSceneFileSelect);
-        }
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_classic_update_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    popup_reset(nfc->popup);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_write.c

@@ -1,92 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum {
-    NfcSceneMfClassicWriteStateCardSearch,
-    NfcSceneMfClassicWriteStateCardFound,
-};
-
-bool nfc_mf_classic_write_worker_callback(NfcWorkerEvent event, void* context) {
-    furi_assert(context);
-
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
-
-    return true;
-}
-
-static void nfc_scene_mf_classic_write_setup_view(Nfc* nfc) {
-    Popup* popup = nfc->popup;
-    popup_reset(popup);
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfClassicWrite);
-
-    if(state == NfcSceneMfClassicWriteStateCardSearch) {
-        popup_set_text(
-            nfc->popup, "Apply the initial\ncard only", 128, 32, AlignRight, AlignCenter);
-        popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual_60x50);
-    } else {
-        popup_set_header(popup, "Writing\nDon't move...", 52, 32, AlignLeft, AlignCenter);
-        popup_set_icon(popup, 12, 23, &A_Loading_24);
-    }
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-}
-
-void nfc_scene_mf_classic_write_on_enter(void* context) {
-    Nfc* nfc = context;
-    dolphin_deed(DolphinDeedNfcEmulate);
-
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneMfClassicWrite, NfcSceneMfClassicWriteStateCardSearch);
-    nfc_scene_mf_classic_write_setup_view(nfc);
-
-    // Setup and start worker
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateMfClassicWrite,
-        &nfc->dev->dev_data,
-        nfc_mf_classic_write_worker_callback,
-        nfc);
-    nfc_blink_emulate_start(nfc);
-}
-
-bool nfc_scene_mf_classic_write_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcWorkerEventSuccess) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicWriteSuccess);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventFail) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicWriteFail);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventWrongCard) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicWrongCard);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventCardDetected) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfClassicWrite, NfcSceneMfClassicWriteStateCardFound);
-            nfc_scene_mf_classic_write_setup_view(nfc);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventNoCardDetected) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfClassicWrite, NfcSceneMfClassicWriteStateCardSearch);
-            nfc_scene_mf_classic_write_setup_view(nfc);
-            consumed = true;
-        }
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_classic_write_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    nfc_worker_stop(nfc->worker);
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneMfClassicWrite, NfcSceneMfClassicWriteStateCardSearch);
-    // Clear view
-    popup_reset(nfc->popup);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_write_fail.c

@@ -1,58 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_mf_classic_write_fail_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_mf_classic_write_fail_on_enter(void* context) {
-    Nfc* nfc = context;
-    Widget* widget = nfc->widget;
-
-    notification_message(nfc->notifications, &sequence_error);
-
-    widget_add_icon_element(widget, 72, 17, &I_DolphinCommon_56x48);
-    widget_add_string_element(
-        widget, 7, 4, AlignLeft, AlignTop, FontPrimary, "Writing gone wrong!");
-    widget_add_string_multiline_element(
-        widget,
-        7,
-        17,
-        AlignLeft,
-        AlignTop,
-        FontSecondary,
-        "Not all sectors\nwere written\ncorrectly.");
-
-    widget_add_button_element(
-        widget, GuiButtonTypeLeft, "Finish", nfc_scene_mf_classic_write_fail_widget_callback, nfc);
-
-    // Setup and start worker
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_mf_classic_write_fail_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            consumed = scene_manager_search_and_switch_to_previous_scene(
-                nfc->scene_manager, NfcSceneFileSelect);
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed = scene_manager_search_and_switch_to_previous_scene(
-            nfc->scene_manager, NfcSceneSavedMenu);
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_classic_write_fail_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_write_initial.c

@@ -0,0 +1,146 @@
+#include "../nfc_app_i.h"
+
+#include <nfc/protocols/mf_classic/mf_classic_poller.h>
+
+enum {
+    NfcSceneMfClassicWriteInitialStateCardSearch,
+    NfcSceneMfClassicWriteInitialStateCardFound,
+};
+
+NfcCommand
+    nfc_scene_mf_classic_write_initial_worker_callback(NfcGenericEvent event, void* context) {
+    furi_assert(context);
+    furi_assert(event.event_data);
+    furi_assert(event.protocol == NfcProtocolMfClassic);
+
+    NfcCommand command = NfcCommandContinue;
+    NfcApp* instance = context;
+    MfClassicPollerEvent* mfc_event = event.event_data;
+    const MfClassicData* write_data =
+        nfc_device_get_data(instance->nfc_device, NfcProtocolMfClassic);
+
+    if(mfc_event->type == MfClassicPollerEventTypeCardDetected) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventCardDetected);
+    } else if(mfc_event->type == MfClassicPollerEventTypeCardLost) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventCardLost);
+    } else if(mfc_event->type == MfClassicPollerEventTypeRequestMode) {
+        const MfClassicData* tag_data = nfc_poller_get_data(instance->poller);
+        if(iso14443_3a_is_equal(tag_data->iso14443_3a_data, write_data->iso14443_3a_data)) {
+            mfc_event->data->poller_mode.mode = MfClassicPollerModeWrite;
+        } else {
+            view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventWrongCard);
+            command = NfcCommandStop;
+        }
+    } else if(mfc_event->type == MfClassicPollerEventTypeRequestSectorTrailer) {
+        uint8_t sector = mfc_event->data->sec_tr_data.sector_num;
+        uint8_t sec_tr = mf_classic_get_sector_trailer_num_by_sector(sector);
+        if(mf_classic_is_block_read(write_data, sec_tr)) {
+            mfc_event->data->sec_tr_data.sector_trailer = write_data->block[sec_tr];
+            mfc_event->data->sec_tr_data.sector_trailer_provided = true;
+        } else {
+            mfc_event->data->sec_tr_data.sector_trailer_provided = false;
+        }
+    } else if(mfc_event->type == MfClassicPollerEventTypeRequestWriteBlock) {
+        uint8_t block_num = mfc_event->data->write_block_data.block_num;
+        if(mf_classic_is_block_read(write_data, block_num)) {
+            mfc_event->data->write_block_data.write_block = write_data->block[block_num];
+            mfc_event->data->write_block_data.write_block_provided = true;
+        } else {
+            mfc_event->data->write_block_data.write_block_provided = false;
+        }
+    } else if(mfc_event->type == MfClassicPollerEventTypeSuccess) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventPollerSuccess);
+        command = NfcCommandStop;
+    } else if(mfc_event->type == MfClassicPollerEventTypeFail) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventPollerFailure);
+        command = NfcCommandStop;
+    }
+    return command;
+}
+
+static void nfc_scene_mf_classic_write_initial_setup_view(NfcApp* instance) {
+    Popup* popup = instance->popup;
+    popup_reset(popup);
+    uint32_t state =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneMfClassicWriteInitial);
+
+    if(state == NfcSceneMfClassicWriteInitialStateCardSearch) {
+        popup_set_text(
+            instance->popup, "Apply the initial\ncard only", 128, 32, AlignRight, AlignCenter);
+        popup_set_icon(instance->popup, 0, 8, &I_NFC_manual_60x50);
+    } else {
+        popup_set_header(popup, "Writing\nDon't move...", 52, 32, AlignLeft, AlignCenter);
+        popup_set_icon(popup, 12, 23, &A_Loading_24);
+    }
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+}
+
+void nfc_scene_mf_classic_write_initial_on_enter(void* context) {
+    NfcApp* instance = context;
+    dolphin_deed(DolphinDeedNfcEmulate);
+
+    scene_manager_set_scene_state(
+        instance->scene_manager,
+        NfcSceneMfClassicWriteInitial,
+        NfcSceneMfClassicWriteInitialStateCardSearch);
+    nfc_scene_mf_classic_write_initial_setup_view(instance);
+
+    // Setup and start worker
+    instance->poller = nfc_poller_alloc(instance->nfc, NfcProtocolMfClassic);
+    nfc_poller_start(
+        instance->poller, nfc_scene_mf_classic_write_initial_worker_callback, instance);
+
+    nfc_blink_emulate_start(instance);
+}
+
+bool nfc_scene_mf_classic_write_initial_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventCardDetected) {
+            scene_manager_set_scene_state(
+                instance->scene_manager,
+                NfcSceneMfClassicWriteInitial,
+                NfcSceneMfClassicWriteInitialStateCardFound);
+            nfc_scene_mf_classic_write_initial_setup_view(instance);
+            consumed = true;
+        } else if(event.event == NfcCustomEventCardLost) {
+            scene_manager_set_scene_state(
+                instance->scene_manager,
+                NfcSceneMfClassicWriteInitial,
+                NfcSceneMfClassicWriteInitialStateCardSearch);
+            nfc_scene_mf_classic_write_initial_setup_view(instance);
+            consumed = true;
+        } else if(event.event == NfcCustomEventWrongCard) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicWrongCard);
+            consumed = true;
+        } else if(event.event == NfcCustomEventPollerSuccess) {
+            scene_manager_next_scene(
+                instance->scene_manager, NfcSceneMfClassicWriteInitialSuccess);
+            consumed = true;
+        } else if(event.event == NfcCustomEventPollerFailure) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfClassicWriteInitialFail);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_classic_write_initial_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    nfc_poller_stop(instance->poller);
+    nfc_poller_free(instance->poller);
+
+    scene_manager_set_scene_state(
+        instance->scene_manager,
+        NfcSceneMfClassicWriteInitial,
+        NfcSceneMfClassicWriteInitialStateCardSearch);
+    // Clear view
+    popup_reset(instance->popup);
+
+    nfc_blink_stop(instance);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_write_initial_fail.c

@@ -0,0 +1,62 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_classic_write_initial_fail_widget_callback(
+    GuiButtonType result,
+    InputType type,
+    void* context) {
+    NfcApp* instance = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
+    }
+}
+
+void nfc_scene_mf_classic_write_initial_fail_on_enter(void* context) {
+    NfcApp* instance = context;
+    Widget* widget = instance->widget;
+
+    notification_message(instance->notifications, &sequence_error);
+
+    widget_add_icon_element(widget, 72, 17, &I_DolphinCommon_56x48);
+    widget_add_string_element(
+        widget, 7, 4, AlignLeft, AlignTop, FontPrimary, "Writing gone wrong!");
+    widget_add_string_multiline_element(
+        widget,
+        7,
+        17,
+        AlignLeft,
+        AlignTop,
+        FontSecondary,
+        "Not all sectors\nwere written\ncorrectly.");
+
+    widget_add_button_element(
+        widget,
+        GuiButtonTypeLeft,
+        "Finish",
+        nfc_scene_mf_classic_write_initial_fail_widget_callback,
+        instance);
+
+    // Setup and start worker
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+}
+
+bool nfc_scene_mf_classic_write_initial_fail_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeLeft) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                instance->scene_manager, NfcSceneSavedMenu);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_search_and_switch_to_previous_scene(
+            instance->scene_manager, NfcSceneSavedMenu);
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_classic_write_initial_fail_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    widget_reset(instance->widget);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_write_initial_success.c

@@ -0,0 +1,43 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_mf_classic_write_initial_success_popup_callback(void* context) {
+    NfcApp* instance = context;
+    view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventViewExit);
+}
+
+void nfc_scene_mf_classic_write_initial_success_on_enter(void* context) {
+    NfcApp* instance = context;
+    dolphin_deed(DolphinDeedNfcSave);
+
+    notification_message(instance->notifications, &sequence_success);
+
+    Popup* popup = instance->popup;
+    popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
+    popup_set_header(popup, "Successfully\nwritten", 13, 22, AlignLeft, AlignBottom);
+    popup_set_timeout(popup, 1500);
+    popup_set_context(popup, instance);
+    popup_set_callback(popup, nfc_scene_mf_classic_write_initial_success_popup_callback);
+    popup_enable_timeout(popup);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+}
+
+bool nfc_scene_mf_classic_write_initial_success_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == NfcCustomEventViewExit) {
+            consumed = scene_manager_search_and_switch_to_previous_scene(
+                instance->scene_manager, NfcSceneSavedMenu);
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_classic_write_initial_success_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    // Clear view
+    popup_reset(instance->popup);
+}

applications/main/nfc/scenes/nfc_scene_mf_classic_write_success.c

@@ -1,44 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-void nfc_scene_mf_classic_write_success_popup_callback(void* context) {
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-void nfc_scene_mf_classic_write_success_on_enter(void* context) {
-    Nfc* nfc = context;
-    dolphin_deed(DolphinDeedNfcSave);
-
-    notification_message(nfc->notifications, &sequence_success);
-
-    Popup* popup = nfc->popup;
-    popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
-    popup_set_header(popup, "Successfully\nwritten", 13, 22, AlignLeft, AlignBottom);
-    popup_set_timeout(popup, 1500);
-    popup_set_context(popup, nfc);
-    popup_set_callback(popup, nfc_scene_mf_classic_write_success_popup_callback);
-    popup_enable_timeout(popup);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-}
-
-bool nfc_scene_mf_classic_write_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventViewExit) {
-            consumed = scene_manager_search_and_switch_to_previous_scene(
-                nfc->scene_manager, NfcSceneFileSelect);
-        }
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_classic_write_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    popup_reset(nfc->popup);
-}

applications/main/nfc/scenes/nfc_scene_mf_classic_wrong_card.c

@@ -1,20 +1,20 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_mf_classic_wrong_card_widget_callback(
     GuiButtonType result,
     InputType type,
     void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
+        view_dispatcher_send_custom_event(instance->view_dispatcher, result);
     }
 }
 
 void nfc_scene_mf_classic_wrong_card_on_enter(void* context) {
-    Nfc* nfc = context;
-    Widget* widget = nfc->widget;
+    NfcApp* instance = context;
+    Widget* widget = instance->widget;
 
-    notification_message(nfc->notifications, &sequence_error);
+    notification_message(instance->notifications, &sequence_error);
 
     widget_add_icon_element(widget, 73, 17, &I_DolphinCommon_56x48);
     widget_add_string_element(
@@ -28,26 +28,30 @@ void nfc_scene_mf_classic_wrong_card_on_enter(void* context) {
         FontSecondary,
         "Data management\nis only possible\nwith initial card");
     widget_add_button_element(
-        widget, GuiButtonTypeLeft, "Retry", nfc_scene_mf_classic_wrong_card_widget_callback, nfc);
+        widget,
+        GuiButtonTypeLeft,
+        "Retry",
+        nfc_scene_mf_classic_wrong_card_widget_callback,
+        instance);
 
     // Setup and start worker
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
 }
 
 bool nfc_scene_mf_classic_wrong_card_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == GuiButtonTypeLeft) {
-            consumed = scene_manager_previous_scene(nfc->scene_manager);
+            consumed = scene_manager_previous_scene(instance->scene_manager);
         }
     }
     return consumed;
 }
 
 void nfc_scene_mf_classic_wrong_card_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    widget_reset(nfc->widget);
+    widget_reset(instance->widget);
 }

applications/main/nfc/scenes/nfc_scene_mf_desfire_app.c

@@ -1,103 +1,93 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
-#define TAG "NfcSceneMfDesfireApp"
+#include "../helpers/protocol_support/mf_desfire/mf_desfire_render.h"
 
 enum SubmenuIndex {
     SubmenuIndexAppInfo,
     SubmenuIndexDynamic, // dynamic indexes start here
 };
 
-void nfc_scene_mf_desfire_popup_callback(void* context) {
-    furi_assert(context);
-
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-MifareDesfireApplication* nfc_scene_mf_desfire_app_get_app(Nfc* nfc) {
-    uint32_t app_idx = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp) >>
-                       1;
-    MifareDesfireApplication* app = nfc->dev->dev_data.mf_df_data.app_head;
-    for(uint32_t i = 0; i < app_idx && app; i++) {
-        app = app->next;
-    }
-    return app;
-}
-
-void nfc_scene_mf_desfire_app_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
+static void nfc_scene_mf_desfire_app_submenu_callback(void* context, uint32_t index) {
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
 }
 
 void nfc_scene_mf_desfire_app_on_enter(void* context) {
-    Nfc* nfc = context;
-    MifareDesfireApplication* app = nfc_scene_mf_desfire_app_get_app(nfc);
-    if(!app) {
-        popup_set_icon(nfc->popup, 5, 5, &I_WarningDolphin_45x42);
-        popup_set_header(nfc->popup, "Empty card!", 55, 12, AlignLeft, AlignBottom);
-        popup_set_callback(nfc->popup, nfc_scene_mf_desfire_popup_callback);
-        popup_set_context(nfc->popup, nfc);
-        popup_set_timeout(nfc->popup, 3000);
-        popup_enable_timeout(nfc->popup);
-        popup_set_text(nfc->popup, "No application\nfound.", 55, 15, AlignLeft, AlignTop);
-        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-    } else {
-        text_box_set_font(nfc->text_box, TextBoxFontHex);
+    NfcApp* nfc = context;
+
+    text_box_set_font(nfc->text_box, TextBoxFontHex);
+    submenu_add_item(
+        nfc->submenu,
+        "App info",
+        SubmenuIndexAppInfo,
+        nfc_scene_mf_desfire_app_submenu_callback,
+        nfc);
+
+    const uint32_t app_idx =
+        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp) >> 1;
+
+    const MfDesfireData* data = nfc_device_get_data(nfc->nfc_device, NfcProtocolMfDesfire);
+    const MfDesfireApplication* app = simple_array_cget(data->applications, app_idx);
+
+    FuriString* label = furi_string_alloc();
+
+    for(uint32_t i = 0; i < simple_array_get_count(app->file_ids); ++i) {
+        const MfDesfireFileId file_id =
+            *(const MfDesfireFileId*)simple_array_cget(app->file_ids, i);
+        furi_string_printf(label, "File %d", file_id);
         submenu_add_item(
             nfc->submenu,
-            "App info",
-            SubmenuIndexAppInfo,
+            furi_string_get_cstr(label),
+            i + SubmenuIndexDynamic,
             nfc_scene_mf_desfire_app_submenu_callback,
             nfc);
-
-        FuriString* label = furi_string_alloc();
-        int idx = SubmenuIndexDynamic;
-        for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
-            furi_string_printf(label, "File %d", file->id);
-            submenu_add_item(
-                nfc->submenu,
-                furi_string_get_cstr(label),
-                idx++,
-                nfc_scene_mf_desfire_app_submenu_callback,
-                nfc);
-        }
-        furi_string_free(label);
-
-        view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
     }
+
+    furi_string_free(label);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
 }
 
 bool nfc_scene_mf_desfire_app_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp);
+
+    const uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp);
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventViewExit) {
             consumed = scene_manager_previous_scene(nfc->scene_manager);
         } else {
-            MifareDesfireApplication* app = nfc_scene_mf_desfire_app_get_app(nfc);
+            const MfDesfireData* data = nfc_device_get_data(nfc->nfc_device, NfcProtocolMfDesfire);
+
+            const uint32_t app_index =
+                scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp) >> 1;
+            const MfDesfireApplication* app = simple_array_cget(data->applications, app_index);
+
             TextBox* text_box = nfc->text_box;
             furi_string_reset(nfc->text_box_store);
             if(event.event == SubmenuIndexAppInfo) {
-                mf_df_cat_application_info(app, nfc->text_box_store);
+                const MfDesfireApplicationId* app_id =
+                    simple_array_cget(data->application_ids, app_index);
+                nfc_render_mf_desfire_application_id(app_id, nfc->text_box_store);
+                nfc_render_mf_desfire_application(app, nfc->text_box_store);
             } else {
-                uint16_t index = event.event - SubmenuIndexDynamic;
-                MifareDesfireFile* file = app->file_head;
-                for(int i = 0; file && i < index; i++) {
-                    file = file->next;
-                }
-                if(!file) {
-                    return false;
-                }
-                mf_df_cat_file(file, nfc->text_box_store);
+                const uint32_t file_index = event.event - SubmenuIndexDynamic;
+                const MfDesfireFileId* file_id = simple_array_cget(app->file_ids, file_index);
+                const MfDesfireFileSettings* file_settings =
+                    simple_array_cget(app->file_settings, file_index);
+                const MfDesfireFileData* file_data = simple_array_cget(app->file_data, file_index);
+                nfc_render_mf_desfire_file_id(file_id, nfc->text_box_store);
+                nfc_render_mf_desfire_file_settings_data(
+                    file_settings, file_data, nfc->text_box_store);
             }
             text_box_set_text(text_box, furi_string_get_cstr(nfc->text_box_store));
             scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp, state | 1);
             view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
             consumed = true;
         }
+
     } else if(event.type == SceneManagerEventTypeBack) {
         if(state & 1) {
             view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
@@ -110,10 +100,9 @@ bool nfc_scene_mf_desfire_app_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_mf_desfire_app_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Clear views
-    popup_reset(nfc->popup);
     text_box_reset(nfc->text_box);
     furi_string_reset(nfc->text_box_store);
     submenu_reset(nfc->submenu);

applications/main/nfc/scenes/nfc_scene_mf_desfire_data.c

@@ -1,104 +0,0 @@
-#include "../nfc_i.h"
-
-#define TAG "NfcSceneMfDesfireData"
-
-enum {
-    MifareDesfireDataStateMenu,
-    MifareDesfireDataStateItem, // MUST be last, states >= this correspond with submenu index
-};
-
-enum SubmenuIndex {
-    SubmenuIndexCardInfo,
-    SubmenuIndexDynamic, // dynamic indexes start here
-};
-
-void nfc_scene_mf_desfire_data_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = (Nfc*)context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_mf_desfire_data_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireData);
-    MifareDesfireData* data = &nfc->dev->dev_data.mf_df_data;
-
-    text_box_set_font(nfc->text_box, TextBoxFontHex);
-
-    submenu_add_item(
-        submenu,
-        "Card info",
-        SubmenuIndexCardInfo,
-        nfc_scene_mf_desfire_data_submenu_callback,
-        nfc);
-
-    FuriString* label = furi_string_alloc();
-    int idx = SubmenuIndexDynamic;
-    for(MifareDesfireApplication* app = data->app_head; app; app = app->next) {
-        furi_string_printf(label, "App %02x%02x%02x", app->id[0], app->id[1], app->id[2]);
-        submenu_add_item(
-            submenu,
-            furi_string_get_cstr(label),
-            idx++,
-            nfc_scene_mf_desfire_data_submenu_callback,
-            nfc);
-    }
-    furi_string_free(label);
-
-    if(state >= MifareDesfireDataStateItem) {
-        submenu_set_selected_item(
-            nfc->submenu, state - MifareDesfireDataStateItem + SubmenuIndexDynamic);
-        scene_manager_set_scene_state(
-            nfc->scene_manager, NfcSceneMfDesfireData, MifareDesfireDataStateMenu);
-    }
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_mf_desfire_data_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireData);
-    MifareDesfireData* data = &nfc->dev->dev_data.mf_df_data;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        TextBox* text_box = nfc->text_box;
-        furi_string_reset(nfc->text_box_store);
-        if(event.event == SubmenuIndexCardInfo) {
-            mf_df_cat_card_info(data, nfc->text_box_store);
-            text_box_set_text(text_box, furi_string_get_cstr(nfc->text_box_store));
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
-            scene_manager_set_scene_state(
-                nfc->scene_manager,
-                NfcSceneMfDesfireData,
-                MifareDesfireDataStateItem + SubmenuIndexCardInfo);
-            consumed = true;
-        } else {
-            uint16_t index = event.event - SubmenuIndexDynamic;
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfDesfireData, MifareDesfireDataStateItem + index);
-            scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp, index << 1);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireApp);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        if(state >= MifareDesfireDataStateItem) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfDesfireData, MifareDesfireDataStateMenu);
-            consumed = true;
-        }
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mf_desfire_data_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear views
-    text_box_reset(nfc->text_box);
-    furi_string_reset(nfc->text_box_store);
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_mf_desfire_menu.c

@@ -1,72 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum SubmenuIndex {
-    SubmenuIndexSave,
-    SubmenuIndexEmulateUid,
-    SubmenuIndexInfo,
-};
-
-void nfc_scene_mf_desfire_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_mf_desfire_menu_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-
-    submenu_add_item(
-        submenu, "Save", SubmenuIndexSave, nfc_scene_mf_desfire_menu_submenu_callback, nfc);
-    submenu_add_item(
-        submenu,
-        "Emulate UID",
-        SubmenuIndexEmulateUid,
-        nfc_scene_mf_desfire_menu_submenu_callback,
-        nfc);
-    submenu_add_item(
-        submenu, "Info", SubmenuIndexInfo, nfc_scene_mf_desfire_menu_submenu_callback, nfc);
-
-    submenu_set_selected_item(
-        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireMenu));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_mf_desfire_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SubmenuIndexSave) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfDesfireMenu, SubmenuIndexSave);
-            nfc->dev->format = NfcDeviceSaveFormatMifareDesfire;
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
-            consumed = true;
-        } else if(event.event == SubmenuIndexEmulateUid) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
-                dolphin_deed(DolphinDeedNfcAddEmulate);
-            } else {
-                dolphin_deed(DolphinDeedNfcEmulate);
-            }
-            consumed = true;
-        } else if(event.event == SubmenuIndexInfo) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
-            consumed = true;
-        }
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mf_desfire_menu_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_mf_desfire_more_info.c

@@ -0,0 +1,112 @@
+#include "../nfc_app_i.h"
+
+#include "../helpers/protocol_support/nfc_protocol_support_gui_common.h"
+#include "../helpers/protocol_support/mf_desfire/mf_desfire_render.h"
+
+enum {
+    MifareDesfireMoreInfoStateMenu,
+    MifareDesfireMoreInfoStateItem, // MUST be last, states >= this correspond with submenu index
+};
+
+enum SubmenuIndex {
+    SubmenuIndexCardInfo,
+    SubmenuIndexDynamic, // dynamic indices start here
+};
+
+void nfc_scene_mf_desfire_more_info_on_enter(void* context) {
+    NfcApp* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    const uint32_t state =
+        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireMoreInfo);
+    const MfDesfireData* data = nfc_device_get_data(nfc->nfc_device, NfcProtocolMfDesfire);
+
+    text_box_set_font(nfc->text_box, TextBoxFontHex);
+
+    submenu_add_item(
+        submenu,
+        "Card info",
+        SubmenuIndexCardInfo,
+        nfc_protocol_support_common_submenu_callback,
+        nfc);
+
+    FuriString* label = furi_string_alloc();
+
+    for(uint32_t i = 0; i < simple_array_get_count(data->application_ids); ++i) {
+        const MfDesfireApplicationId* app_id = simple_array_cget(data->application_ids, i);
+        furi_string_printf(
+            label, "App %02x%02x%02x", app_id->data[0], app_id->data[1], app_id->data[2]);
+        submenu_add_item(
+            submenu,
+            furi_string_get_cstr(label),
+            i + SubmenuIndexDynamic,
+            nfc_protocol_support_common_submenu_callback,
+            nfc);
+    }
+
+    furi_string_free(label);
+
+    if(state >= MifareDesfireMoreInfoStateItem) {
+        submenu_set_selected_item(
+            nfc->submenu, state - MifareDesfireMoreInfoStateItem + SubmenuIndexDynamic);
+        scene_manager_set_scene_state(
+            nfc->scene_manager, NfcSceneMfDesfireMoreInfo, MifareDesfireMoreInfoStateMenu);
+    }
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_mf_desfire_more_info_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* nfc = context;
+    bool consumed = false;
+
+    const uint32_t state =
+        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfDesfireMoreInfo);
+    const MfDesfireData* data = nfc_device_get_data(nfc->nfc_device, NfcProtocolMfDesfire);
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        TextBox* text_box = nfc->text_box;
+        furi_string_reset(nfc->text_box_store);
+
+        if(event.event == SubmenuIndexCardInfo) {
+            nfc_render_mf_desfire_data(data, nfc->text_box_store);
+            text_box_set_text(text_box, furi_string_get_cstr(nfc->text_box_store));
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
+            scene_manager_set_scene_state(
+                nfc->scene_manager,
+                NfcSceneMfDesfireMoreInfo,
+                MifareDesfireMoreInfoStateItem + SubmenuIndexCardInfo);
+            consumed = true;
+        } else {
+            const uint32_t index = event.event - SubmenuIndexDynamic;
+            scene_manager_set_scene_state(
+                nfc->scene_manager,
+                NfcSceneMfDesfireMoreInfo,
+                MifareDesfireMoreInfoStateItem + index);
+            scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfDesfireApp, index << 1);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireApp);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        if(state >= MifareDesfireMoreInfoStateItem) {
+            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+            scene_manager_set_scene_state(
+                nfc->scene_manager, NfcSceneMfDesfireMoreInfo, MifareDesfireMoreInfoStateMenu);
+        } else {
+            // Return directly to the Info scene
+            scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, NfcSceneInfo);
+        }
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void nfc_scene_mf_desfire_more_info_on_exit(void* context) {
+    NfcApp* nfc = context;
+
+    // Clear views
+    text_box_reset(nfc->text_box);
+    furi_string_reset(nfc->text_box_store);
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_mf_desfire_read_success.c

@@ -1,101 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-void nfc_scene_mf_desfire_read_success_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    Nfc* nfc = context;
-
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_mf_desfire_read_success_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
-    MifareDesfireData* data = &nfc->dev->dev_data.mf_df_data;
-    Widget* widget = nfc->widget;
-
-    // Prepare string for data display
-    FuriString* temp_str = NULL;
-    if(furi_string_size(nfc->dev->dev_data.parsed_data)) {
-        temp_str = furi_string_alloc_set(nfc->dev->dev_data.parsed_data);
-    } else {
-        temp_str = furi_string_alloc_printf("\e#MIFARE DESFire\n");
-        furi_string_cat_printf(temp_str, "UID:");
-        for(size_t i = 0; i < nfc_data->uid_len; i++) {
-            furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
-        }
-
-        uint32_t bytes_total = 1UL << (data->version.sw_storage >> 1);
-        uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
-        furi_string_cat_printf(temp_str, "\n%lu", bytes_total);
-        if(data->version.sw_storage & 1) {
-            furi_string_push_back(temp_str, '+');
-        }
-        furi_string_cat_printf(temp_str, " bytes, %lu bytes free\n", bytes_free);
-
-        uint16_t n_apps = 0;
-        uint16_t n_files = 0;
-        for(MifareDesfireApplication* app = data->app_head; app; app = app->next) {
-            n_apps++;
-            for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
-                n_files++;
-            }
-        }
-        furi_string_cat_printf(temp_str, "%d Application", n_apps);
-        if(n_apps != 1) {
-            furi_string_push_back(temp_str, 's');
-        }
-        furi_string_cat_printf(temp_str, ", %d file", n_files);
-        if(n_files != 1) {
-            furi_string_push_back(temp_str, 's');
-        }
-    }
-
-    notification_message_block(nfc->notifications, &sequence_set_green_255);
-
-    // Add text scroll element
-    widget_add_text_scroll_element(widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
-    furi_string_free(temp_str);
-
-    // Add button elements
-    widget_add_button_element(
-        widget, GuiButtonTypeLeft, "Retry", nfc_scene_mf_desfire_read_success_widget_callback, nfc);
-    widget_add_button_element(
-        widget, GuiButtonTypeRight, "More", nfc_scene_mf_desfire_read_success_widget_callback, nfc);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_mf_desfire_read_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
-            consumed = true;
-        } else if(event.event == GuiButtonTypeRight) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireMenu);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
-        consumed = true;
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mf_desfire_read_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    notification_message_block(nfc->notifications, &sequence_reset_green);
-
-    // Clean dialog
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_capture_pass.c

@@ -0,0 +1,67 @@
+#include "../nfc_app_i.h"
+
+NfcCommand
+    nfc_scene_mf_ultralight_capture_pass_worker_callback(NfcGenericEvent event, void* context) {
+    NfcApp* instance = context;
+    MfUltralightListenerEvent* mfu_event = event.event_data;
+    MfUltralightAuth* mauth = instance->mf_ul_auth;
+
+    if(mfu_event->type == MfUltralightListenerEventTypeAuth) {
+        mauth->password = mfu_event->data->password;
+        view_dispatcher_send_custom_event(
+            instance->view_dispatcher, MfUltralightListenerEventTypeAuth);
+    }
+
+    return NfcCommandContinue;
+}
+
+void nfc_scene_mf_ultralight_capture_pass_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    // Setup view
+    widget_add_string_multiline_element(
+        instance->widget,
+        54,
+        30,
+        AlignLeft,
+        AlignCenter,
+        FontPrimary,
+        "Touch the\nreader to get\npassword...");
+    widget_add_icon_element(instance->widget, 0, 15, &I_Modern_reader_18x34);
+    widget_add_icon_element(instance->widget, 20, 12, &I_Move_flipper_26x39);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+
+    // Start worker
+    const MfUltralightData* data =
+        nfc_device_get_data(instance->nfc_device, NfcProtocolMfUltralight);
+    instance->listener = nfc_listener_alloc(instance->nfc, NfcProtocolMfUltralight, data);
+    nfc_listener_start(
+        instance->listener, nfc_scene_mf_ultralight_capture_pass_worker_callback, instance);
+
+    nfc_blink_read_start(instance);
+}
+
+bool nfc_scene_mf_ultralight_capture_pass_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == MfUltralightListenerEventTypeAuth) {
+            notification_message(instance->notifications, &sequence_success);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightUnlockWarn);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_mf_ultralight_capture_pass_on_exit(void* context) {
+    NfcApp* instance = context;
+
+    // Clear view
+    nfc_listener_stop(instance->listener);
+    nfc_listener_free(instance->listener);
+    widget_reset(instance->widget);
+
+    nfc_blink_stop(instance);
+}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_data.c

@@ -1,32 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_mf_ultralight_data_on_enter(void* context) {
-    Nfc* nfc = context;
-    MfUltralightData* data = &nfc->dev->dev_data.mf_ul_data;
-    TextBox* text_box = nfc->text_box;
-
-    text_box_set_font(text_box, TextBoxFontHex);
-    for(uint16_t i = 0; i < data->data_size; i += 2) {
-        if(!(i % 8) && i) {
-            furi_string_push_back(nfc->text_box_store, '\n');
-        }
-        furi_string_cat_printf(nfc->text_box_store, "%02X%02X ", data->data[i], data->data[i + 1]);
-    }
-    text_box_set_text(text_box, furi_string_get_cstr(nfc->text_box_store));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
-}
-
-bool nfc_scene_mf_ultralight_data_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
-    return false;
-}
-
-void nfc_scene_mf_ultralight_data_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clean view
-    text_box_reset(nfc->text_box);
-    furi_string_reset(nfc->text_box_store);
-}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_emulate.c

@@ -1,74 +0,0 @@
-#include "../nfc_i.h"
-
-#define NFC_MF_UL_DATA_NOT_CHANGED (0UL)
-#define NFC_MF_UL_DATA_CHANGED (1UL)
-
-bool nfc_mf_ultralight_emulate_worker_callback(NfcWorkerEvent event, void* context) {
-    UNUSED(event);
-    Nfc* nfc = context;
-
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneMfUltralightEmulate, NFC_MF_UL_DATA_CHANGED);
-    return true;
-}
-
-void nfc_scene_mf_ultralight_emulate_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup view
-    MfUltralightType type = nfc->dev->dev_data.mf_ul_data.type;
-    bool is_ultralight = (type == MfUltralightTypeUL11) || (type == MfUltralightTypeUL21) ||
-                         (type == MfUltralightTypeUnknown);
-    Popup* popup = nfc->popup;
-    popup_set_header(popup, "Emulating", 67, 13, AlignLeft, AlignTop);
-    if(strcmp(nfc->dev->dev_name, "") != 0) {
-        nfc_text_store_set(nfc, "%s", nfc->dev->dev_name);
-    } else if(is_ultralight) {
-        nfc_text_store_set(nfc, "MIFARE\nUltralight");
-    } else {
-        nfc_text_store_set(nfc, "MIFARE\nNTAG");
-    }
-    popup_set_icon(popup, 0, 3, &I_NFC_dolphin_emulation_47x61);
-    popup_set_text(popup, nfc->text_store, 90, 28, AlignCenter, AlignTop);
-
-    // Setup and start worker
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateMfUltralightEmulate,
-        &nfc->dev->dev_data,
-        nfc_mf_ultralight_emulate_worker_callback,
-        nfc);
-    nfc_blink_emulate_start(nfc);
-}
-
-bool nfc_scene_mf_ultralight_emulate_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeBack) {
-        // Stop worker
-        nfc_worker_stop(nfc->worker);
-        // Check if data changed and save in shadow file
-        if(scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate) ==
-           NFC_MF_UL_DATA_CHANGED) {
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneMfUltralightEmulate, NFC_MF_UL_DATA_NOT_CHANGED);
-            // Save shadow file
-            if(furi_string_size(nfc->dev->load_path)) {
-                nfc_device_save_shadow(nfc->dev, furi_string_get_cstr(nfc->dev->load_path));
-            }
-        }
-        consumed = false;
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_ultralight_emulate_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    popup_reset(nfc->popup);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_key_input.c

@@ -1,13 +1,13 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_mf_ultralight_key_input_byte_input_callback(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
 }
 
 void nfc_scene_mf_ultralight_key_input_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Setup view
     ByteInput* byte_input = nfc->byte_input;
@@ -17,13 +17,13 @@ void nfc_scene_mf_ultralight_key_input_on_enter(void* context) {
         nfc_scene_mf_ultralight_key_input_byte_input_callback,
         NULL,
         nfc,
-        nfc->byte_input_store,
+        nfc->mf_ul_auth->password.data,
         4);
     view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
 }
 
 bool nfc_scene_mf_ultralight_key_input_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
@@ -36,7 +36,7 @@ bool nfc_scene_mf_ultralight_key_input_on_event(void* context, SceneManagerEvent
 }
 
 void nfc_scene_mf_ultralight_key_input_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Clear view
     byte_input_set_result_callback(nfc->byte_input, NULL, NULL, NULL, NULL, 0);

applications/main/nfc/scenes/nfc_scene_mf_ultralight_menu.c

@@ -1,89 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum SubmenuIndex {
-    SubmenuIndexUnlock,
-    SubmenuIndexSave,
-    SubmenuIndexEmulate,
-    SubmenuIndexInfo,
-};
-
-void nfc_scene_mf_ultralight_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_mf_ultralight_menu_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-    MfUltralightData* data = &nfc->dev->dev_data.mf_ul_data;
-
-    if(!mf_ul_is_full_capture(data) && data->type != MfUltralightTypeULC) {
-        submenu_add_item(
-            submenu,
-            "Unlock",
-            SubmenuIndexUnlock,
-            nfc_scene_mf_ultralight_menu_submenu_callback,
-            nfc);
-    }
-    submenu_add_item(
-        submenu, "Save", SubmenuIndexSave, nfc_scene_mf_ultralight_menu_submenu_callback, nfc);
-    if(mf_ul_emulation_supported(data)) {
-        submenu_add_item(
-            submenu,
-            "Emulate",
-            SubmenuIndexEmulate,
-            nfc_scene_mf_ultralight_menu_submenu_callback,
-            nfc);
-    }
-    submenu_add_item(
-        submenu, "Info", SubmenuIndexInfo, nfc_scene_mf_ultralight_menu_submenu_callback, nfc);
-
-    submenu_set_selected_item(
-        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightMenu));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_mf_ultralight_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SubmenuIndexSave) {
-            nfc->dev->format = NfcDeviceSaveFormatMifareUl;
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
-            consumed = true;
-        } else if(event.event == SubmenuIndexEmulate) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightEmulate);
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
-                dolphin_deed(DolphinDeedNfcAddEmulate);
-            } else {
-                dolphin_deed(DolphinDeedNfcEmulate);
-            }
-            consumed = true;
-        } else if(event.event == SubmenuIndexUnlock) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
-            consumed = true;
-        } else if(event.event == SubmenuIndexInfo) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
-            consumed = true;
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfUltralightMenu, event.event);
-
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed = scene_manager_previous_scene(nfc->scene_manager);
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mf_ultralight_menu_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_read_auth.c

@@ -1,116 +0,0 @@
-#include "../nfc_i.h"
-
-typedef enum {
-    NfcSceneMfUlReadStateIdle,
-    NfcSceneMfUlReadStateDetecting,
-    NfcSceneMfUlReadStateReading,
-    NfcSceneMfUlReadStateNotSupportedCard,
-} NfcSceneMfUlReadState;
-
-bool nfc_scene_mf_ultralight_read_auth_worker_callback(NfcWorkerEvent event, void* context) {
-    Nfc* nfc = context;
-
-    if(event == NfcWorkerEventMfUltralightPassKey) {
-        memcpy(nfc->dev->dev_data.mf_ul_data.auth_key, nfc->byte_input_store, 4);
-    } else {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
-    }
-    return true;
-}
-
-void nfc_scene_mf_ultralight_read_auth_set_state(Nfc* nfc, NfcSceneMfUlReadState state) {
-    uint32_t curr_state =
-        scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightReadAuth);
-    if(curr_state != state) {
-        if(state == NfcSceneMfUlReadStateDetecting) {
-            popup_reset(nfc->popup);
-            popup_set_text(nfc->popup, "Apply the\ntarget card", 97, 24, AlignCenter, AlignTop);
-            popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual_60x50);
-            nfc_blink_read_start(nfc);
-        } else if(state == NfcSceneMfUlReadStateReading) {
-            popup_reset(nfc->popup);
-            popup_set_header(
-                nfc->popup, "Reading card\nDon't move...", 85, 24, AlignCenter, AlignTop);
-            popup_set_icon(nfc->popup, 12, 23, &A_Loading_24);
-            nfc_blink_detect_start(nfc);
-        } else if(state == NfcSceneMfUlReadStateNotSupportedCard) {
-            popup_reset(nfc->popup);
-            popup_set_header(nfc->popup, "Wrong type of card!", 64, 3, AlignCenter, AlignTop);
-            popup_set_text(
-                nfc->popup,
-                "Only MIFARE\nUltralight & NTAG\nare supported",
-                4,
-                22,
-                AlignLeft,
-                AlignTop);
-            popup_set_icon(nfc->popup, 73, 20, &I_DolphinCommon_56x48);
-            nfc_blink_stop(nfc);
-            notification_message(nfc->notifications, &sequence_error);
-            notification_message(nfc->notifications, &sequence_set_red_255);
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfUltralightReadAuth, state);
-    }
-}
-
-void nfc_scene_mf_ultralight_read_auth_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    nfc_device_clear(nfc->dev);
-    // Setup view
-    nfc_scene_mf_ultralight_read_auth_set_state(nfc, NfcSceneMfUlReadStateDetecting);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-    // Start worker
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateReadMfUltralightReadAuth,
-        &nfc->dev->dev_data,
-        nfc_scene_mf_ultralight_read_auth_worker_callback,
-        nfc);
-}
-
-bool nfc_scene_mf_ultralight_read_auth_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if((event.event == NfcWorkerEventSuccess) || (event.event == NfcWorkerEventFail)) {
-            notification_message(nfc->notifications, &sequence_success);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightReadAuthResult);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventCardDetected) {
-            nfc_scene_mf_ultralight_read_auth_set_state(nfc, NfcSceneMfUlReadStateReading);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventNoCardDetected) {
-            nfc_scene_mf_ultralight_read_auth_set_state(nfc, NfcSceneMfUlReadStateDetecting);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventWrongCardDetected) {
-            nfc_scene_mf_ultralight_read_auth_set_state(
-                nfc, NfcSceneMfUlReadStateNotSupportedCard);
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        MfUltralightData* mf_ul_data = &nfc->dev->dev_data.mf_ul_data;
-        NfcScene next_scene;
-        if(mf_ul_data->auth_method == MfUltralightAuthMethodManual) {
-            next_scene = NfcSceneMfUltralightKeyInput;
-        } else if(mf_ul_data->auth_method == MfUltralightAuthMethodAuto) {
-            next_scene = NfcSceneMfUltralightUnlockAuto;
-        } else {
-            next_scene = NfcSceneMfUltralightUnlockMenu;
-        }
-        consumed =
-            scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, next_scene);
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_ultralight_read_auth_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-    // Clear view
-    popup_reset(nfc->popup);
-    nfc_blink_stop(nfc);
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneMfUltralightReadAuth, NfcSceneMfUlReadStateIdle);
-}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_read_auth_result.c

@@ -1,116 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_mf_ultralight_read_auth_result_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    Nfc* nfc = context;
-
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_mf_ultralight_read_auth_result_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup dialog view
-    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
-    MfUltralightData* mf_ul_data = &nfc->dev->dev_data.mf_ul_data;
-    MfUltralightConfigPages* config_pages = mf_ultralight_get_config_pages(mf_ul_data);
-    Widget* widget = nfc->widget;
-    const char* title;
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    if((mf_ul_data->data_read == mf_ul_data->data_size) && (mf_ul_data->data_read > 0)) {
-        if(mf_ul_data->auth_success) {
-            title = "All pages are unlocked!";
-        } else {
-            title = "All unlocked but failed auth!";
-        }
-    } else {
-        title = "Not all pages unlocked!";
-    }
-    widget_add_string_element(widget, 64, 0, AlignCenter, AlignTop, FontPrimary, title);
-    furi_string_set(temp_str, "UID:");
-    for(size_t i = 0; i < nfc_data->uid_len; i++) {
-        furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
-    }
-    widget_add_string_element(
-        widget, 0, 17, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(temp_str));
-    if(mf_ul_data->auth_success) {
-        furi_string_printf(
-            temp_str,
-            "Password: %02X %02X %02X %02X",
-            config_pages->auth_data.pwd.raw[0],
-            config_pages->auth_data.pwd.raw[1],
-            config_pages->auth_data.pwd.raw[2],
-            config_pages->auth_data.pwd.raw[3]);
-        widget_add_string_element(
-            widget, 0, 28, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(temp_str));
-        furi_string_printf(
-            temp_str,
-            "PACK: %02X %02X",
-            config_pages->auth_data.pack.raw[0],
-            config_pages->auth_data.pack.raw[1]);
-        widget_add_string_element(
-            widget, 0, 39, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(temp_str));
-    }
-    furi_string_printf(
-        temp_str, "Pages Read: %d/%d", mf_ul_data->data_read / 4, mf_ul_data->data_size / 4);
-    widget_add_string_element(
-        widget, 0, 50, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(temp_str));
-    widget_add_button_element(
-        widget,
-        GuiButtonTypeRight,
-        "Save",
-        nfc_scene_mf_ultralight_read_auth_result_widget_callback,
-        nfc);
-
-    furi_string_free(temp_str);
-    notification_message(nfc->notifications, &sequence_set_green_255);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_mf_ultralight_read_auth_result_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeRight) {
-            nfc->dev->format = NfcDeviceSaveFormatMifareUl;
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        MfUltralightData* mf_ul_data = &nfc->dev->dev_data.mf_ul_data;
-        if(mf_ul_data->auth_method == MfUltralightAuthMethodManual ||
-           mf_ul_data->auth_method == MfUltralightAuthMethodAuto) {
-            consumed = scene_manager_previous_scene(nfc->scene_manager);
-        } else {
-            NfcScene next_scene;
-            if((mf_ul_data->data_read == mf_ul_data->data_size) && (mf_ul_data->data_read > 0)) {
-                next_scene = NfcSceneMfUltralightMenu;
-            } else {
-                next_scene = NfcSceneMfUltralightUnlockMenu;
-            }
-
-            consumed =
-                scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, next_scene);
-        }
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mf_ultralight_read_auth_result_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clean views
-    widget_reset(nfc->widget);
-
-    notification_message_block(nfc->notifications, &sequence_reset_green);
-}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_read_success.c

@@ -1,84 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_mf_ultralight_read_success_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    Nfc* nfc = context;
-
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_mf_ultralight_read_success_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup widget view
-    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
-    MfUltralightData* mf_ul_data = &nfc->dev->dev_data.mf_ul_data;
-    Widget* widget = nfc->widget;
-    widget_add_button_element(
-        widget,
-        GuiButtonTypeLeft,
-        "Retry",
-        nfc_scene_mf_ultralight_read_success_widget_callback,
-        nfc);
-    widget_add_button_element(
-        widget,
-        GuiButtonTypeRight,
-        "More",
-        nfc_scene_mf_ultralight_read_success_widget_callback,
-        nfc);
-
-    FuriString* temp_str = NULL;
-    if(furi_string_size(nfc->dev->dev_data.parsed_data)) {
-        temp_str = furi_string_alloc_set(nfc->dev->dev_data.parsed_data);
-    } else {
-        temp_str = furi_string_alloc_printf("\e#%s\n", nfc_mf_ul_type(mf_ul_data->type, true));
-        furi_string_cat_printf(temp_str, "UID:");
-        for(size_t i = 0; i < data->uid_len; i++) {
-            furi_string_cat_printf(temp_str, " %02X", data->uid[i]);
-        }
-        furi_string_cat_printf(
-            temp_str, "\nPages Read: %d/%d", mf_ul_data->data_read / 4, mf_ul_data->data_size / 4);
-        if(mf_ul_data->data_read != mf_ul_data->data_size) {
-            furi_string_cat_printf(temp_str, "\nPassword-protected pages!");
-        }
-    }
-    widget_add_text_scroll_element(widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
-    furi_string_free(temp_str);
-
-    notification_message_block(nfc->notifications, &sequence_set_green_255);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_mf_ultralight_read_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
-            consumed = true;
-        } else if(event.event == GuiButtonTypeRight) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightMenu);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
-        consumed = true;
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mf_ultralight_read_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    notification_message_block(nfc->notifications, &sequence_reset_green);
-
-    // Clean view
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_unlock_auto.c

@@ -1,64 +0,0 @@
-#include "../nfc_i.h"
-
-bool nfc_scene_mf_ultralight_unlock_auto_worker_callback(NfcWorkerEvent event, void* context) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
-    return true;
-}
-
-void nfc_scene_mf_ultralight_unlock_auto_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup view
-    widget_add_string_multiline_element(
-        nfc->widget,
-        54,
-        30,
-        AlignLeft,
-        AlignCenter,
-        FontPrimary,
-        "Touch the\nreader to get\npassword...");
-    widget_add_icon_element(nfc->widget, 0, 15, &I_Modern_reader_18x34);
-    widget_add_icon_element(nfc->widget, 20, 12, &I_Move_flipper_26x39);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-
-    // Start worker
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateMfUltralightEmulate,
-        &nfc->dev->dev_data,
-        nfc_scene_mf_ultralight_unlock_auto_worker_callback,
-        nfc);
-
-    nfc_blink_read_start(nfc);
-}
-
-bool nfc_scene_mf_ultralight_unlock_auto_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if((event.event == NfcWorkerEventMfUltralightPwdAuth)) {
-            MfUltralightAuth* auth = &nfc->dev->dev_data.mf_ul_auth;
-            memcpy(nfc->byte_input_store, auth->pwd.raw, sizeof(auth->pwd.raw));
-            nfc->dev->dev_data.mf_ul_data.auth_method = MfUltralightAuthMethodAuto;
-            nfc_worker_stop(nfc->worker);
-            notification_message(nfc->notifications, &sequence_success);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockWarn);
-            consumed = true;
-        }
-    }
-    return consumed;
-}
-
-void nfc_scene_mf_ultralight_unlock_auto_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-    // Clear view
-    widget_reset(nfc->widget);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_mf_ultralight_unlock_menu.c

@@ -1,29 +1,29 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 enum SubmenuIndex {
-    SubmenuIndexMfUlUnlockMenuAuto,
+    SubmenuIndexMfUlUnlockMenuReader,
     SubmenuIndexMfUlUnlockMenuAmeebo,
     SubmenuIndexMfUlUnlockMenuXiaomi,
     SubmenuIndexMfUlUnlockMenuManual,
 };
 
 void nfc_scene_mf_ultralight_unlock_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
 }
 
 void nfc_scene_mf_ultralight_unlock_menu_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     Submenu* submenu = nfc->submenu;
 
     uint32_t state =
         scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
-    if(nfc->dev->dev_data.protocol == NfcDeviceProtocolMifareUl) {
+    if(nfc_device_get_protocol(nfc->nfc_device) == NfcProtocolMfUltralight) {
         submenu_add_item(
             submenu,
             "Unlock With Reader",
-            SubmenuIndexMfUlUnlockMenuAuto,
+            SubmenuIndexMfUlUnlockMenuReader,
             nfc_scene_mf_ultralight_unlock_menu_submenu_callback,
             nfc);
     }
@@ -50,24 +50,25 @@ void nfc_scene_mf_ultralight_unlock_menu_on_enter(void* context) {
 }
 
 bool nfc_scene_mf_ultralight_unlock_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexMfUlUnlockMenuManual) {
-            nfc->dev->dev_data.mf_ul_data.auth_method = MfUltralightAuthMethodManual;
+            nfc->mf_ul_auth->type = MfUltralightAuthTypeManual;
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightKeyInput);
             consumed = true;
         } else if(event.event == SubmenuIndexMfUlUnlockMenuAmeebo) {
-            nfc->dev->dev_data.mf_ul_data.auth_method = MfUltralightAuthMethodAmeebo;
+            nfc->mf_ul_auth->type = MfUltralightAuthTypeAmiibo;
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockWarn);
             consumed = true;
         } else if(event.event == SubmenuIndexMfUlUnlockMenuXiaomi) {
-            nfc->dev->dev_data.mf_ul_data.auth_method = MfUltralightAuthMethodXiaomi;
+            nfc->mf_ul_auth->type = MfUltralightAuthTypeXiaomi;
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockWarn);
             consumed = true;
-        } else if(event.event == SubmenuIndexMfUlUnlockMenuAuto) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockAuto);
+        } else if(event.event == SubmenuIndexMfUlUnlockMenuReader) {
+            nfc->mf_ul_auth->type = MfUltralightAuthTypeReader;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightCapturePass);
             consumed = true;
         }
         scene_manager_set_scene_state(
@@ -77,7 +78,7 @@ bool nfc_scene_mf_ultralight_unlock_menu_on_event(void* context, SceneManagerEve
 }
 
 void nfc_scene_mf_ultralight_unlock_menu_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     submenu_reset(nfc->submenu);
 }

applications/main/nfc/scenes/nfc_scene_mf_ultralight_unlock_warn.c

@@ -1,45 +1,41 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 #include <dolphin/dolphin.h>
 
 void nfc_scene_mf_ultralight_unlock_warn_dialog_callback(DialogExResult result, void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
 }
 
 void nfc_scene_mf_ultralight_unlock_warn_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     DialogEx* dialog_ex = nfc->dialog_ex;
-    MfUltralightAuthMethod auth_method = nfc->dev->dev_data.mf_ul_data.auth_method;
 
     dialog_ex_set_context(dialog_ex, nfc);
     dialog_ex_set_result_callback(dialog_ex, nfc_scene_mf_ultralight_unlock_warn_dialog_callback);
 
-    if(auth_method == MfUltralightAuthMethodManual || auth_method == MfUltralightAuthMethodAuto) {
+    MfUltralightAuthType type = nfc->mf_ul_auth->type;
+    if((type == MfUltralightAuthTypeReader) || (type == MfUltralightAuthTypeManual)) {
         // Build dialog text
-        MfUltralightAuth* auth = &nfc->dev->dev_data.mf_ul_auth;
         FuriString* password_str =
             furi_string_alloc_set_str("Try to unlock the card with\npassword: ");
-        for(size_t i = 0; i < sizeof(auth->pwd.raw); ++i) {
-            furi_string_cat_printf(password_str, "%02X ", nfc->byte_input_store[i]);
+        for(size_t i = 0; i < sizeof(nfc->mf_ul_auth->password.data); i++) {
+            furi_string_cat_printf(password_str, "%02X ", nfc->mf_ul_auth->password.data[i]);
         }
         furi_string_cat_str(password_str, "?\nCaution, a wrong password\ncan block the card!");
         nfc_text_store_set(nfc, furi_string_get_cstr(password_str));
         furi_string_free(password_str);
 
-        dialog_ex_set_header(
-            dialog_ex,
-            auth_method == MfUltralightAuthMethodAuto ? "Password captured!" : "Risky function!",
-            64,
-            0,
-            AlignCenter,
-            AlignTop);
+        const char* message = (type == MfUltralightAuthTypeReader) ? "Password captured!" :
+                                                                     "Risky function!";
+        dialog_ex_set_header(dialog_ex, message, 64, 0, AlignCenter, AlignTop);
         dialog_ex_set_text(dialog_ex, nfc->text_store, 64, 12, AlignCenter, AlignTop);
         dialog_ex_set_left_button_text(dialog_ex, "Cancel");
         dialog_ex_set_right_button_text(dialog_ex, "Continue");
 
-        if(auth_method == MfUltralightAuthMethodAuto)
+        if(type == MfUltralightAuthTypeReader) {
             notification_message(nfc->notifications, &sequence_set_green_255);
+        }
     } else {
         dialog_ex_set_header(dialog_ex, "Risky function!", 64, 4, AlignCenter, AlignTop);
         dialog_ex_set_text(
@@ -52,19 +48,20 @@ void nfc_scene_mf_ultralight_unlock_warn_on_enter(void* context) {
 }
 
 bool nfc_scene_mf_ultralight_unlock_warn_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     bool consumed = false;
 
-    MfUltralightAuthMethod auth_method = nfc->dev->dev_data.mf_ul_data.auth_method;
-    if(auth_method == MfUltralightAuthMethodManual || auth_method == MfUltralightAuthMethodAuto) {
+    nfc->protocols_detected[0] = nfc_device_get_protocol(nfc->nfc_device);
+    MfUltralightAuthType type = nfc->mf_ul_auth->type;
+    if((type == MfUltralightAuthTypeReader) || (type == MfUltralightAuthTypeManual)) {
         if(event.type == SceneManagerEventTypeCustom) {
             if(event.event == DialogExResultRight) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightReadAuth);
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
                 dolphin_deed(DolphinDeedNfcRead);
                 consumed = true;
             } else if(event.event == DialogExResultLeft) {
-                if(auth_method == MfUltralightAuthMethodAuto) {
+                if(type == MfUltralightAuthTypeReader) {
                     consumed = scene_manager_search_and_switch_to_previous_scene(
                         nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
                 } else {
@@ -78,7 +75,9 @@ bool nfc_scene_mf_ultralight_unlock_warn_on_event(void* context, SceneManagerEve
     } else {
         if(event.type == SceneManagerEventTypeCustom) {
             if(event.event == DialogExResultCenter) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightReadAuth);
+                const NfcProtocol mfu_protocol[] = {NfcProtocolMfUltralight};
+                nfc_app_set_detected_protocols(nfc, mfu_protocol, COUNT_OF(mfu_protocol));
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
                 dolphin_deed(DolphinDeedNfcRead);
                 consumed = true;
             }
@@ -89,7 +88,7 @@ bool nfc_scene_mf_ultralight_unlock_warn_on_event(void* context, SceneManagerEve
 }
 
 void nfc_scene_mf_ultralight_unlock_warn_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     dialog_ex_reset(nfc->dialog_ex);
     nfc_text_store_clear(nfc);

applications/main/nfc/scenes/nfc_scene_mfkey_complete.c

@@ -1,49 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_mfkey_complete_callback(GuiButtonType result, InputType type, void* context) {
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_mfkey_complete_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    widget_add_string_element(nfc->widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Complete!");
-    widget_add_string_multiline_element(
-        nfc->widget,
-        64,
-        32,
-        AlignCenter,
-        AlignCenter,
-        FontSecondary,
-        "Now use Mfkey32\nto extract keys");
-    widget_add_button_element(
-        nfc->widget, GuiButtonTypeCenter, "OK", nfc_scene_mfkey_complete_callback, nfc);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_mfkey_complete_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeCenter) {
-            consumed = scene_manager_search_and_switch_to_previous_scene(
-                nfc->scene_manager, NfcSceneStart);
-        }
-    } else if(event.event == SceneManagerEventTypeBack) {
-        consumed =
-            scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, NfcSceneStart);
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mfkey_complete_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_mfkey_nonces_info.c

@@ -1,55 +0,0 @@
-#include "../nfc_i.h"
-#include <lib/nfc/helpers/mfkey32.h>
-
-void nfc_scene_mfkey_nonces_info_callback(GuiButtonType result, InputType type, void* context) {
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_mfkey_nonces_info_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    uint16_t nonces_saved = mfkey32_get_auth_sectors(temp_str);
-    widget_add_text_scroll_element(nfc->widget, 0, 22, 128, 42, furi_string_get_cstr(temp_str));
-    furi_string_printf(temp_str, "Nonce pairs saved: %d", nonces_saved);
-    widget_add_string_element(
-        nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, furi_string_get_cstr(temp_str));
-    widget_add_string_element(
-        nfc->widget, 0, 12, AlignLeft, AlignTop, FontSecondary, "Authenticated sectors:");
-
-    widget_add_button_element(
-        nfc->widget, GuiButtonTypeCenter, "OK", nfc_scene_mfkey_nonces_info_callback, nfc);
-
-    furi_string_free(temp_str);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_mfkey_nonces_info_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeCenter) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfkeyComplete);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed =
-            scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, NfcSceneStart);
-    }
-
-    return consumed;
-}
-
-void nfc_scene_mfkey_nonces_info_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_more_info.c

@@ -0,0 +1,13 @@
+#include "../helpers/protocol_support/nfc_protocol_support.h"
+
+void nfc_scene_more_info_on_enter(void* context) {
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneMoreInfo, context);
+}
+
+bool nfc_scene_more_info_on_event(void* context, SceneManagerEvent event) {
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneMoreInfo, context, event);
+}
+
+void nfc_scene_more_info_on_exit(void* context) {
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneMoreInfo, context);
+}

applications/main/nfc/scenes/nfc_scene_nfc_data_info.c

@@ -1,309 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_nfc_data_info_widget_callback(GuiButtonType result, InputType type, void* context) {
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_slix_build_string(
-    FuriString* temp_str,
-    NfcVData* nfcv_data,
-    SlixTypeFeatures features,
-    const char* type) {
-    furi_string_cat_printf(temp_str, "Type: %s\n", type);
-    furi_string_cat_printf(temp_str, "Keys:\n");
-    if(features & SlixFeatureRead) {
-        furi_string_cat_printf(
-            temp_str,
-            " Read     %08llX%s\n",
-            nfc_util_bytes2num(nfcv_data->sub_data.slix.key_read, 4),
-            (nfcv_data->sub_data.slix.flags & NfcVSlixDataFlagsHasKeyRead) ? "" : " (unset)");
-    }
-    if(features & SlixFeatureWrite) {
-        furi_string_cat_printf(
-            temp_str,
-            " Write    %08llX%s\n",
-            nfc_util_bytes2num(nfcv_data->sub_data.slix.key_write, 4),
-            (nfcv_data->sub_data.slix.flags & NfcVSlixDataFlagsHasKeyWrite) ? "" : " (unset)");
-    }
-    if(features & SlixFeaturePrivacy) {
-        furi_string_cat_printf(
-            temp_str,
-            " Privacy  %08llX%s\n",
-            nfc_util_bytes2num(nfcv_data->sub_data.slix.key_privacy, 4),
-            (nfcv_data->sub_data.slix.flags & NfcVSlixDataFlagsHasKeyPrivacy) ? "" : " (unset)");
-        furi_string_cat_printf(
-            temp_str,
-            " Privacy mode %s\n",
-            (nfcv_data->sub_data.slix.flags & NfcVSlixDataFlagsPrivacy) ? "ENABLED" : "DISABLED");
-    }
-    if(features & SlixFeatureDestroy) {
-        furi_string_cat_printf(
-            temp_str,
-            " Destroy  %08llX%s\n",
-            nfc_util_bytes2num(nfcv_data->sub_data.slix.key_destroy, 4),
-            (nfcv_data->sub_data.slix.flags & NfcVSlixDataFlagsHasKeyDestroy) ? "" : " (unset)");
-    }
-    if(features & SlixFeatureEas) {
-        furi_string_cat_printf(
-            temp_str,
-            " EAS      %08llX%s\n",
-            nfc_util_bytes2num(nfcv_data->sub_data.slix.key_eas, 4),
-            (nfcv_data->sub_data.slix.flags & NfcVSlixDataFlagsHasKeyEas) ? "" : " (unset)");
-    }
-    if(features & SlixFeatureSignature) {
-        furi_string_cat_printf(
-            temp_str,
-            "Signature %08llX...\n",
-            nfc_util_bytes2num(nfcv_data->sub_data.slix.signature, 4));
-    }
-    furi_string_cat_printf(
-        temp_str,
-        "DSFID: %02X %s\n",
-        nfcv_data->dsfid,
-        (nfcv_data->security_status[0] & NfcVLockBitDsfid) ? "(locked)" : "");
-    furi_string_cat_printf(
-        temp_str,
-        "AFI: %02X %s\n",
-        nfcv_data->afi,
-        (nfcv_data->security_status[0] & NfcVLockBitAfi) ? "(locked)" : "");
-    furi_string_cat_printf(
-        temp_str,
-        "EAS: %s\n",
-        (nfcv_data->security_status[0] & NfcVLockBitEas) ? "locked" : "not locked");
-
-    if(features & SlixFeatureProtection) {
-        furi_string_cat_printf(
-            temp_str,
-            "PPL: %s\n",
-            (nfcv_data->security_status[0] & NfcVLockBitPpl) ? "locked" : "not locked");
-        furi_string_cat_printf(temp_str, "Prot.ptr %02X\n", nfcv_data->sub_data.slix.pp_pointer);
-        furi_string_cat_printf(temp_str, "Prot.con %02X\n", nfcv_data->sub_data.slix.pp_condition);
-    }
-}
-
-void nfc_scene_nfc_data_info_on_enter(void* context) {
-    Nfc* nfc = context;
-    Widget* widget = nfc->widget;
-    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
-    NfcDeviceData* dev_data = &nfc->dev->dev_data;
-    NfcProtocol protocol = dev_data->protocol;
-    uint8_t text_scroll_height = 0;
-    if((protocol == NfcDeviceProtocolMifareDesfire) || (protocol == NfcDeviceProtocolMifareUl) ||
-       (protocol == NfcDeviceProtocolMifareClassic)) {
-        widget_add_button_element(
-            widget, GuiButtonTypeRight, "More", nfc_scene_nfc_data_info_widget_callback, nfc);
-        text_scroll_height = 52;
-    } else {
-        text_scroll_height = 64;
-    }
-
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-    // Set name if present
-    if(nfc->dev->dev_name[0] != '\0') {
-        furi_string_printf(temp_str, "\ec%s\n", nfc->dev->dev_name);
-    }
-
-    // Set tag type
-    if(protocol == NfcDeviceProtocolEMV) {
-        furi_string_cat_printf(temp_str, "\e#EMV Bank Card\n");
-    } else if(protocol == NfcDeviceProtocolMifareUl) {
-        furi_string_cat_printf(
-            temp_str, "\e#%s\n", nfc_mf_ul_type(dev_data->mf_ul_data.type, true));
-    } else if(protocol == NfcDeviceProtocolMifareClassic) {
-        furi_string_cat_printf(
-            temp_str, "\e#%s\n", nfc_mf_classic_type(dev_data->mf_classic_data.type));
-    } else if(protocol == NfcDeviceProtocolMifareDesfire) {
-        furi_string_cat_printf(temp_str, "\e#MIFARE DESFire\n");
-    } else if(protocol == NfcDeviceProtocolNfcV) {
-        switch(dev_data->nfcv_data.sub_type) {
-        case NfcVTypePlain:
-            furi_string_cat_printf(temp_str, "\e#ISO15693\n");
-            break;
-        case NfcVTypeSlix:
-            furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX\n");
-            break;
-        case NfcVTypeSlixS:
-            furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX-S\n");
-            break;
-        case NfcVTypeSlixL:
-            furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX-L\n");
-            break;
-        case NfcVTypeSlix2:
-            furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX2\n");
-            break;
-        default:
-            furi_string_cat_printf(temp_str, "\e#ISO15693 (unknown)\n");
-            break;
-        }
-    } else {
-        furi_string_cat_printf(temp_str, "\e#Unknown ISO tag\n");
-    }
-
-    // Set tag iso data
-    if(protocol == NfcDeviceProtocolNfcV) {
-        NfcVData* nfcv_data = &nfc->dev->dev_data.nfcv_data;
-
-        furi_string_cat_printf(temp_str, "UID:\n");
-        for(size_t i = 0; i < nfc_data->uid_len; i++) {
-            furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
-        }
-        furi_string_cat_printf(temp_str, "\n");
-
-        furi_string_cat_printf(temp_str, "IC Ref: %d\n", nfcv_data->ic_ref);
-        furi_string_cat_printf(temp_str, "Blocks: %d\n", nfcv_data->block_num);
-        furi_string_cat_printf(temp_str, "Blocksize: %d\n", nfcv_data->block_size);
-
-        switch(dev_data->nfcv_data.sub_type) {
-        case NfcVTypePlain:
-            furi_string_cat_printf(temp_str, "Type: Plain\n");
-            break;
-        case NfcVTypeSlix:
-            nfc_scene_slix_build_string(temp_str, nfcv_data, SlixFeatureSlix, "SLIX");
-            break;
-        case NfcVTypeSlixS:
-            nfc_scene_slix_build_string(temp_str, nfcv_data, SlixFeatureSlixS, "SLIX-S");
-            break;
-        case NfcVTypeSlixL:
-            nfc_scene_slix_build_string(temp_str, nfcv_data, SlixFeatureSlixL, "SLIX-L");
-            break;
-        case NfcVTypeSlix2:
-            nfc_scene_slix_build_string(temp_str, nfcv_data, SlixFeatureSlix2, "SLIX2");
-            break;
-        default:
-            furi_string_cat_printf(temp_str, "\e#ISO15693 (unknown)\n");
-            break;
-        }
-
-        furi_string_cat_printf(
-            temp_str, "Data (%d byte)\n", nfcv_data->block_num * nfcv_data->block_size);
-
-        int maxBlocks = nfcv_data->block_num;
-        if(maxBlocks > 32) {
-            maxBlocks = 32;
-            furi_string_cat_printf(temp_str, "(truncated to %d blocks)\n", maxBlocks);
-        }
-
-        for(int block = 0; block < maxBlocks; block++) {
-            const char* status = (nfcv_data->security_status[block] & 0x01) ? "(lck)" : "";
-            for(int pos = 0; pos < nfcv_data->block_size; pos++) {
-                furi_string_cat_printf(
-                    temp_str, " %02X", nfcv_data->data[block * nfcv_data->block_size + pos]);
-            }
-            furi_string_cat_printf(temp_str, " %s\n", status);
-        }
-
-    } else {
-        char iso_type = FURI_BIT(nfc_data->sak, 5) ? '4' : '3';
-        furi_string_cat_printf(temp_str, "ISO 14443-%c (NFC-A)\n", iso_type);
-        furi_string_cat_printf(temp_str, "UID:");
-        for(size_t i = 0; i < nfc_data->uid_len; i++) {
-            furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
-        }
-        furi_string_cat_printf(
-            temp_str, "\nATQA: %02X %02X ", nfc_data->atqa[1], nfc_data->atqa[0]);
-        furi_string_cat_printf(temp_str, " SAK: %02X", nfc_data->sak);
-    }
-
-    // Set application specific data
-    if(protocol == NfcDeviceProtocolMifareDesfire) {
-        MifareDesfireData* data = &dev_data->mf_df_data;
-        uint32_t bytes_total = 1UL << (data->version.sw_storage >> 1);
-        uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
-        furi_string_cat_printf(temp_str, "\n%lu", bytes_total);
-        if(data->version.sw_storage & 1) {
-            furi_string_push_back(temp_str, '+');
-        }
-        furi_string_cat_printf(temp_str, " bytes, %lu bytes free\n", bytes_free);
-
-        uint16_t n_apps = 0;
-        uint16_t n_files = 0;
-        for(MifareDesfireApplication* app = data->app_head; app; app = app->next) {
-            n_apps++;
-            for(MifareDesfireFile* file = app->file_head; file; file = file->next) {
-                n_files++;
-            }
-        }
-        furi_string_cat_printf(temp_str, "%d Application", n_apps);
-        if(n_apps != 1) {
-            furi_string_push_back(temp_str, 's');
-        }
-        furi_string_cat_printf(temp_str, ", %d file", n_files);
-        if(n_files != 1) {
-            furi_string_push_back(temp_str, 's');
-        }
-    } else if(protocol == NfcDeviceProtocolMifareUl) {
-        MfUltralightData* data = &dev_data->mf_ul_data;
-        furi_string_cat_printf(
-            temp_str, "\nPages Read %d/%d", data->data_read / 4, data->data_size / 4);
-        if(data->data_size > data->data_read) {
-            furi_string_cat_printf(temp_str, "\nPassword-protected");
-        } else if(data->auth_success) {
-            MfUltralightConfigPages* config_pages = mf_ultralight_get_config_pages(data);
-            if(config_pages) {
-                furi_string_cat_printf(
-                    temp_str,
-                    "\nPassword: %02X %02X %02X %02X",
-                    config_pages->auth_data.pwd.raw[0],
-                    config_pages->auth_data.pwd.raw[1],
-                    config_pages->auth_data.pwd.raw[2],
-                    config_pages->auth_data.pwd.raw[3]);
-                furi_string_cat_printf(
-                    temp_str,
-                    "\nPACK: %02X %02X",
-                    config_pages->auth_data.pack.raw[0],
-                    config_pages->auth_data.pack.raw[1]);
-            }
-        }
-    } else if(protocol == NfcDeviceProtocolMifareClassic) {
-        MfClassicData* data = &dev_data->mf_classic_data;
-        uint8_t sectors_total = mf_classic_get_total_sectors_num(data->type);
-        uint8_t keys_total = sectors_total * 2;
-        uint8_t keys_found = 0;
-        uint8_t sectors_read = 0;
-        mf_classic_get_read_sectors_and_keys(data, &sectors_read, &keys_found);
-        furi_string_cat_printf(temp_str, "\nKeys Found %d/%d", keys_found, keys_total);
-        furi_string_cat_printf(temp_str, "\nSectors Read %d/%d", sectors_read, sectors_total);
-    }
-
-    // Add text scroll widget
-    widget_add_text_scroll_element(
-        widget, 0, 0, 128, text_scroll_height, furi_string_get_cstr(temp_str));
-    furi_string_free(temp_str);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_nfc_data_info_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    NfcProtocol protocol = nfc->dev->dev_data.protocol;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeRight) {
-            if(protocol == NfcDeviceProtocolMifareDesfire) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireData);
-                consumed = true;
-            } else if(protocol == NfcDeviceProtocolMifareUl) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightData);
-                consumed = true;
-            } else if(protocol == NfcDeviceProtocolMifareClassic) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicData);
-            } else if(protocol == NfcDeviceProtocolNfcV) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVMenu);
-                consumed = true;
-            }
-        }
-    }
-
-    return consumed;
-}
-
-void nfc_scene_nfc_data_info_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_nfca_menu.c

@@ -1,68 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum SubmenuIndex {
-    SubmenuIndexSaveUid,
-    SubmenuIndexEmulateUid,
-    SubmenuIndexInfo,
-};
-
-void nfc_scene_nfca_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_nfca_menu_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-
-    submenu_add_item(
-        submenu, "Save UID", SubmenuIndexSaveUid, nfc_scene_nfca_menu_submenu_callback, nfc);
-    submenu_add_item(
-        submenu, "Emulate UID", SubmenuIndexEmulateUid, nfc_scene_nfca_menu_submenu_callback, nfc);
-    submenu_add_item(submenu, "Info", SubmenuIndexInfo, nfc_scene_nfca_menu_submenu_callback, nfc);
-
-    submenu_set_selected_item(
-        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcaMenu));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_nfca_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SubmenuIndexSaveUid) {
-            nfc->dev->format = NfcDeviceSaveFormatUid;
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
-            consumed = true;
-        } else if(event.event == SubmenuIndexEmulateUid) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
-                dolphin_deed(DolphinDeedNfcAddEmulate);
-            } else {
-                dolphin_deed(DolphinDeedNfcEmulate);
-            }
-            consumed = true;
-        } else if(event.event == SubmenuIndexInfo) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
-            consumed = true;
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcaMenu, event.event);
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed = scene_manager_previous_scene(nfc->scene_manager);
-    }
-
-    return consumed;
-}
-
-void nfc_scene_nfca_menu_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_nfca_read_success.c

@@ -1,73 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_nfca_read_success_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_nfca_read_success_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup view
-    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
-    Widget* widget = nfc->widget;
-
-    FuriString* temp_str;
-    temp_str = furi_string_alloc_set("\e#Unknown ISO tag\n");
-
-    notification_message_block(nfc->notifications, &sequence_set_green_255);
-
-    char iso_type = FURI_BIT(data->sak, 5) ? '4' : '3';
-    furi_string_cat_printf(temp_str, "ISO 14443-%c (NFC-A)\n", iso_type);
-    furi_string_cat_printf(temp_str, "UID:");
-    for(size_t i = 0; i < data->uid_len; i++) {
-        furi_string_cat_printf(temp_str, " %02X", data->uid[i]);
-    }
-    furi_string_cat_printf(temp_str, "\nATQA: %02X %02X ", data->atqa[1], data->atqa[0]);
-    furi_string_cat_printf(temp_str, " SAK: %02X", data->sak);
-
-    widget_add_text_scroll_element(widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
-    furi_string_free(temp_str);
-
-    widget_add_button_element(
-        widget, GuiButtonTypeLeft, "Retry", nfc_scene_nfca_read_success_widget_callback, nfc);
-    widget_add_button_element(
-        widget, GuiButtonTypeRight, "More", nfc_scene_nfca_read_success_widget_callback, nfc);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_nfca_read_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
-            consumed = true;
-        } else if(event.event == GuiButtonTypeRight) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcaMenu);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
-        consumed = true;
-    }
-    return consumed;
-}
-
-void nfc_scene_nfca_read_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    notification_message_block(nfc->notifications, &sequence_reset_green);
-
-    // Clear view
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_nfcv_emulate.c

@@ -1,169 +0,0 @@
-#include "../nfc_i.h"
-
-#define NFC_SCENE_EMULATE_NFCV_LOG_SIZE_MAX (200)
-
-enum {
-    NfcSceneNfcVEmulateStateWidget,
-    NfcSceneNfcVEmulateStateTextBox,
-};
-
-bool nfc_scene_nfcv_emulate_worker_callback(NfcWorkerEvent event, void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-
-    switch(event) {
-    case NfcWorkerEventNfcVCommandExecuted:
-        if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-            view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventUpdateLog);
-        }
-        break;
-    case NfcWorkerEventNfcVContentChanged:
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventSaveShadow);
-        break;
-    default:
-        break;
-    }
-    return true;
-}
-
-void nfc_scene_nfcv_emulate_widget_callback(GuiButtonType result, InputType type, void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_nfcv_emulate_textbox_callback(void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-static void nfc_scene_nfcv_emulate_widget_config(Nfc* nfc, bool data_received) {
-    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
-    Widget* widget = nfc->widget;
-    widget_reset(widget);
-    FuriString* info_str;
-    info_str = furi_string_alloc();
-
-    widget_add_icon_element(widget, 0, 3, &I_NFC_dolphin_emulation_47x61);
-    widget_add_string_multiline_element(
-        widget, 87, 13, AlignCenter, AlignTop, FontPrimary, "Emulating\nNFC V");
-    if(strcmp(nfc->dev->dev_name, "") != 0) {
-        furi_string_printf(info_str, "%s", nfc->dev->dev_name);
-    } else {
-        for(uint8_t i = 0; i < data->uid_len; i++) {
-            furi_string_cat_printf(info_str, "%02X ", data->uid[i]);
-        }
-    }
-    furi_string_trim(info_str);
-    widget_add_text_box_element(
-        widget, 52, 40, 70, 21, AlignCenter, AlignTop, furi_string_get_cstr(info_str), true);
-    furi_string_free(info_str);
-    if(data_received) {
-        if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-            widget_add_button_element(
-                widget, GuiButtonTypeCenter, "Log", nfc_scene_nfcv_emulate_widget_callback, nfc);
-        }
-    }
-}
-
-void nfc_scene_nfcv_emulate_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup Widget
-    nfc_scene_nfcv_emulate_widget_config(nfc, false);
-    // Setup TextBox
-    TextBox* text_box = nfc->text_box;
-    text_box_set_font(text_box, TextBoxFontHex);
-    text_box_set_focus(text_box, TextBoxFocusEnd);
-    text_box_set_text(text_box, "");
-    furi_string_reset(nfc->text_box_store);
-
-    // Set Widget state and view
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneNfcVEmulate, NfcSceneNfcVEmulateStateWidget);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-    // Start worker
-    memset(&nfc->dev->dev_data.reader_data, 0, sizeof(NfcReaderRequestData));
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateNfcVEmulate,
-        &nfc->dev->dev_data,
-        nfc_scene_nfcv_emulate_worker_callback,
-        nfc);
-
-    nfc_blink_emulate_start(nfc);
-}
-
-bool nfc_scene_nfcv_emulate_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    NfcVData* nfcv_data = &nfc->dev->dev_data.nfcv_data;
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVEmulate);
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventUpdateLog) {
-            // Add data button to widget if data is received for the first time
-            if(strlen(nfcv_data->last_command) > 0) {
-                if(!furi_string_size(nfc->text_box_store)) {
-                    nfc_scene_nfcv_emulate_widget_config(nfc, true);
-                }
-                /* use the last n bytes from the log so there's enough space for the new log entry */
-                size_t maxSize =
-                    NFC_SCENE_EMULATE_NFCV_LOG_SIZE_MAX - (strlen(nfcv_data->last_command) + 1);
-                if(furi_string_size(nfc->text_box_store) >= maxSize) {
-                    furi_string_right(nfc->text_box_store, (strlen(nfcv_data->last_command) + 1));
-                }
-                furi_string_cat_printf(nfc->text_box_store, "%s", nfcv_data->last_command);
-                furi_string_push_back(nfc->text_box_store, '\n');
-                text_box_set_text(nfc->text_box, furi_string_get_cstr(nfc->text_box_store));
-
-                /* clear previously logged command */
-                strcpy(nfcv_data->last_command, "");
-            }
-            consumed = true;
-        } else if(event.event == NfcCustomEventSaveShadow) {
-            if(furi_string_size(nfc->dev->load_path)) {
-                nfc_device_save_shadow(nfc->dev, furi_string_get_cstr(nfc->dev->load_path));
-            }
-            consumed = true;
-        } else if(event.event == GuiButtonTypeCenter && state == NfcSceneNfcVEmulateStateWidget) {
-            if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-                view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
-                scene_manager_set_scene_state(
-                    nfc->scene_manager, NfcSceneNfcVEmulate, NfcSceneNfcVEmulateStateTextBox);
-            }
-            consumed = true;
-        } else if(event.event == NfcCustomEventViewExit && state == NfcSceneNfcVEmulateStateTextBox) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneNfcVEmulate, NfcSceneNfcVEmulateStateWidget);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        if(state == NfcSceneNfcVEmulateStateTextBox) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneNfcVEmulate, NfcSceneNfcVEmulateStateWidget);
-            consumed = true;
-        }
-    }
-
-    return consumed;
-}
-
-void nfc_scene_nfcv_emulate_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-
-    // Clear view
-    widget_reset(nfc->widget);
-    text_box_reset(nfc->text_box);
-    furi_string_reset(nfc->text_box_store);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_nfcv_key_input.c

@@ -1,48 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-void nfc_scene_nfcv_key_input_byte_input_callback(void* context) {
-    Nfc* nfc = context;
-    NfcVSlixData* data = &nfc->dev->dev_data.nfcv_data.sub_data.slix;
-
-    memcpy(data->key_privacy, nfc->byte_input_store, 4);
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
-}
-
-void nfc_scene_nfcv_key_input_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup view
-    ByteInput* byte_input = nfc->byte_input;
-    byte_input_set_header_text(byte_input, "Enter The Password In Hex");
-    byte_input_set_result_callback(
-        byte_input,
-        nfc_scene_nfcv_key_input_byte_input_callback,
-        NULL,
-        nfc,
-        nfc->byte_input_store,
-        4);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
-}
-
-bool nfc_scene_nfcv_key_input_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventByteInputDone) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVUnlock);
-            dolphin_deed(DolphinDeedNfcRead);
-            consumed = true;
-        }
-    }
-    return consumed;
-}
-
-void nfc_scene_nfcv_key_input_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    byte_input_set_result_callback(nfc->byte_input, NULL, NULL, NULL, NULL, 0);
-    byte_input_set_header_text(nfc->byte_input, "");
-}

applications/main/nfc/scenes/nfc_scene_nfcv_menu.c

@@ -1,68 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum SubmenuIndex {
-    SubmenuIndexSave,
-    SubmenuIndexEmulate,
-    SubmenuIndexInfo,
-};
-
-void nfc_scene_nfcv_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_nfcv_menu_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-
-    submenu_add_item(
-        submenu, "Emulate", SubmenuIndexEmulate, nfc_scene_nfcv_menu_submenu_callback, nfc);
-    submenu_add_item(submenu, "Save", SubmenuIndexSave, nfc_scene_nfcv_menu_submenu_callback, nfc);
-    submenu_add_item(submenu, "Info", SubmenuIndexInfo, nfc_scene_nfcv_menu_submenu_callback, nfc);
-
-    submenu_set_selected_item(
-        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVMenu));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_nfcv_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SubmenuIndexSave) {
-            nfc->dev->format = NfcDeviceSaveFormatNfcV;
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
-            consumed = true;
-        } else if(event.event == SubmenuIndexEmulate) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVEmulate);
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
-                dolphin_deed(DolphinDeedNfcAddEmulate);
-            } else {
-                dolphin_deed(DolphinDeedNfcEmulate);
-            }
-            consumed = true;
-        } else if(event.event == SubmenuIndexInfo) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
-            consumed = true;
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVMenu, event.event);
-
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed = scene_manager_previous_scene(nfc->scene_manager);
-    }
-
-    return consumed;
-}
-
-void nfc_scene_nfcv_menu_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_nfcv_read_success.c

@@ -1,92 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_nfcv_read_success_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_nfcv_read_success_on_enter(void* context) {
-    Nfc* nfc = context;
-    NfcDeviceData* dev_data = &nfc->dev->dev_data;
-    FuriHalNfcDevData* nfc_data = &nfc->dev->dev_data.nfc_data;
-    // Setup view
-    Widget* widget = nfc->widget;
-    widget_add_button_element(
-        widget, GuiButtonTypeLeft, "Retry", nfc_scene_nfcv_read_success_widget_callback, nfc);
-    widget_add_button_element(
-        widget, GuiButtonTypeRight, "More", nfc_scene_nfcv_read_success_widget_callback, nfc);
-
-    FuriString* temp_str = furi_string_alloc();
-
-    switch(dev_data->nfcv_data.sub_type) {
-    case NfcVTypePlain:
-        furi_string_cat_printf(temp_str, "\e#ISO15693\n");
-        break;
-    case NfcVTypeSlix:
-        furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX\n");
-        break;
-    case NfcVTypeSlixS:
-        furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX-S\n");
-        break;
-    case NfcVTypeSlixL:
-        furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX-L\n");
-        break;
-    case NfcVTypeSlix2:
-        furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX2\n");
-        break;
-    default:
-        furi_string_cat_printf(temp_str, "\e#ISO15693 (unknown)\n");
-        break;
-    }
-    furi_string_cat_printf(temp_str, "UID:\n");
-    for(size_t i = 0; i < nfc_data->uid_len; i++) {
-        furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
-    }
-    furi_string_cat_printf(temp_str, "\n");
-    furi_string_cat_printf(temp_str, "(see More->Info for details)\n");
-
-    widget_add_text_scroll_element(widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
-    furi_string_free(temp_str);
-
-    notification_message_block(nfc->notifications, &sequence_set_green_255);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_nfcv_read_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
-            consumed = true;
-        } else if(event.event == GuiButtonTypeRight) {
-            // Clear device name
-            nfc_device_set_name(nfc->dev, "");
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVMenu);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
-        consumed = true;
-    }
-
-    return consumed;
-}
-
-void nfc_scene_nfcv_read_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    notification_message_block(nfc->notifications, &sequence_reset_green);
-
-    // Clear view
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_nfcv_sniff.c

@@ -1,155 +0,0 @@
-#include "../nfc_i.h"
-
-#define NFC_SCENE_EMULATE_NFCV_LOG_SIZE_MAX (800)
-
-enum {
-    NfcSceneNfcVSniffStateWidget,
-    NfcSceneNfcVSniffStateTextBox,
-};
-
-bool nfc_scene_nfcv_sniff_worker_callback(NfcWorkerEvent event, void* context) {
-    UNUSED(event);
-    furi_assert(context);
-    Nfc* nfc = context;
-
-    switch(event) {
-    case NfcWorkerEventNfcVCommandExecuted:
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventUpdateLog);
-        break;
-    case NfcWorkerEventNfcVContentChanged:
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventSaveShadow);
-        break;
-    default:
-        break;
-    }
-    return true;
-}
-
-void nfc_scene_nfcv_sniff_widget_callback(GuiButtonType result, InputType type, void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_nfcv_sniff_textbox_callback(void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-static void nfc_scene_nfcv_sniff_widget_config(Nfc* nfc, bool data_received) {
-    Widget* widget = nfc->widget;
-    widget_reset(widget);
-    FuriString* info_str;
-    info_str = furi_string_alloc();
-
-    widget_add_icon_element(widget, 0, 3, &I_RFIDDolphinSend_97x61);
-    widget_add_string_element(widget, 89, 32, AlignCenter, AlignTop, FontPrimary, "Listen NfcV");
-    furi_string_trim(info_str);
-    widget_add_text_box_element(
-        widget, 56, 43, 70, 21, AlignCenter, AlignTop, furi_string_get_cstr(info_str), true);
-    furi_string_free(info_str);
-    if(data_received) {
-        widget_add_button_element(
-            widget, GuiButtonTypeCenter, "Log", nfc_scene_nfcv_sniff_widget_callback, nfc);
-    }
-}
-
-void nfc_scene_nfcv_sniff_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup Widget
-    nfc_scene_nfcv_sniff_widget_config(nfc, false);
-    // Setup TextBox
-    TextBox* text_box = nfc->text_box;
-    text_box_set_font(text_box, TextBoxFontHex);
-    text_box_set_focus(text_box, TextBoxFocusEnd);
-    text_box_set_text(text_box, "");
-    furi_string_reset(nfc->text_box_store);
-
-    // Set Widget state and view
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneNfcVSniff, NfcSceneNfcVSniffStateWidget);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-    // Start worker
-    memset(&nfc->dev->dev_data.reader_data, 0, sizeof(NfcReaderRequestData));
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateNfcVSniff,
-        &nfc->dev->dev_data,
-        nfc_scene_nfcv_sniff_worker_callback,
-        nfc);
-
-    nfc_blink_emulate_start(nfc);
-}
-
-bool nfc_scene_nfcv_sniff_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    NfcVData* nfcv_data = &nfc->dev->dev_data.nfcv_data;
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVSniff);
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventUpdateLog) {
-            // Add data button to widget if data is received for the first time
-            if(strlen(nfcv_data->last_command) > 0) {
-                if(!furi_string_size(nfc->text_box_store)) {
-                    nfc_scene_nfcv_sniff_widget_config(nfc, true);
-                }
-                /* use the last n bytes from the log so there's enough space for the new log entry */
-                size_t maxSize =
-                    NFC_SCENE_EMULATE_NFCV_LOG_SIZE_MAX - (strlen(nfcv_data->last_command) + 1);
-                if(furi_string_size(nfc->text_box_store) >= maxSize) {
-                    furi_string_right(nfc->text_box_store, (strlen(nfcv_data->last_command) + 1));
-                }
-                furi_string_cat_printf(nfc->text_box_store, "%s", nfcv_data->last_command);
-                furi_string_push_back(nfc->text_box_store, '\n');
-                text_box_set_text(nfc->text_box, furi_string_get_cstr(nfc->text_box_store));
-
-                /* clear previously logged command */
-                strcpy(nfcv_data->last_command, "");
-            }
-            consumed = true;
-        } else if(event.event == NfcCustomEventSaveShadow) {
-            if(furi_string_size(nfc->dev->load_path)) {
-                nfc_device_save_shadow(nfc->dev, furi_string_get_cstr(nfc->dev->load_path));
-            }
-            consumed = true;
-        } else if(event.event == GuiButtonTypeCenter && state == NfcSceneNfcVSniffStateWidget) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneNfcVSniff, NfcSceneNfcVSniffStateTextBox);
-            consumed = true;
-        } else if(event.event == NfcCustomEventViewExit && state == NfcSceneNfcVSniffStateTextBox) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneNfcVSniff, NfcSceneNfcVSniffStateWidget);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        if(state == NfcSceneNfcVSniffStateTextBox) {
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-            scene_manager_set_scene_state(
-                nfc->scene_manager, NfcSceneNfcVSniff, NfcSceneNfcVSniffStateWidget);
-            consumed = true;
-        }
-    }
-
-    return consumed;
-}
-
-void nfc_scene_nfcv_sniff_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-
-    // Clear view
-    widget_reset(nfc->widget);
-    text_box_reset(nfc->text_box);
-    furi_string_reset(nfc->text_box_store);
-
-    nfc_blink_stop(nfc);
-}

applications/main/nfc/scenes/nfc_scene_nfcv_unlock.c

@@ -1,154 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-typedef enum {
-    NfcSceneNfcVUnlockStateIdle,
-    NfcSceneNfcVUnlockStateDetecting,
-    NfcSceneNfcVUnlockStateUnlocked,
-    NfcSceneNfcVUnlockStateAlreadyUnlocked,
-    NfcSceneNfcVUnlockStateNotSupportedCard,
-} NfcSceneNfcVUnlockState;
-
-static bool nfc_scene_nfcv_unlock_worker_callback(NfcWorkerEvent event, void* context) {
-    Nfc* nfc = context;
-    NfcVSlixData* data = &nfc->dev->dev_data.nfcv_data.sub_data.slix;
-
-    if(event == NfcWorkerEventNfcVPassKey) {
-        memcpy(data->key_privacy, nfc->byte_input_store, 4);
-    } else {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
-    }
-    return true;
-}
-
-void nfc_scene_nfcv_unlock_popup_callback(void* context) {
-    Nfc* nfc = context;
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
-}
-
-void nfc_scene_nfcv_unlock_set_state(Nfc* nfc, NfcSceneNfcVUnlockState state) {
-    FuriHalNfcDevData* nfc_data = &(nfc->dev->dev_data.nfc_data);
-    NfcVData* nfcv_data = &(nfc->dev->dev_data.nfcv_data);
-
-    uint32_t curr_state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVUnlock);
-    if(curr_state != state) {
-        Popup* popup = nfc->popup;
-        if(state == NfcSceneNfcVUnlockStateDetecting) {
-            popup_reset(popup);
-            popup_set_text(
-                popup, "Put figurine on\nFlipper's back", 97, 24, AlignCenter, AlignTop);
-            popup_set_icon(popup, 0, 8, &I_NFC_manual_60x50);
-        } else if(state == NfcSceneNfcVUnlockStateUnlocked) {
-            popup_reset(popup);
-
-            if(nfc_worker_get_state(nfc->worker) == NfcWorkerStateNfcVUnlockAndSave) {
-                snprintf(
-                    nfc->dev->dev_name,
-                    sizeof(nfc->dev->dev_name),
-                    "SLIX_%02X%02X%02X%02X%02X%02X%02X%02X",
-                    nfc_data->uid[0],
-                    nfc_data->uid[1],
-                    nfc_data->uid[2],
-                    nfc_data->uid[3],
-                    nfc_data->uid[4],
-                    nfc_data->uid[5],
-                    nfc_data->uid[6],
-                    nfc_data->uid[7]);
-
-                nfc->dev->format = NfcDeviceSaveFormatNfcV;
-
-                if(nfc_save_file(nfc)) {
-                    popup_set_header(popup, "Successfully\nsaved", 94, 3, AlignCenter, AlignTop);
-                } else {
-                    popup_set_header(
-                        popup, "Unlocked but\nsave failed!", 94, 3, AlignCenter, AlignTop);
-                }
-            } else {
-                popup_set_header(popup, "Successfully\nunlocked", 94, 3, AlignCenter, AlignTop);
-            }
-
-            notification_message(nfc->notifications, &sequence_single_vibro);
-            //notification_message(nfc->notifications, &sequence_success);
-
-            popup_set_icon(popup, 0, 6, &I_RFIDDolphinSuccess_108x57);
-            popup_set_context(popup, nfc);
-            popup_set_callback(popup, nfc_scene_nfcv_unlock_popup_callback);
-            popup_set_timeout(popup, 1500);
-
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-            dolphin_deed(DolphinDeedNfcReadSuccess);
-
-        } else if(state == NfcSceneNfcVUnlockStateAlreadyUnlocked) {
-            popup_reset(popup);
-
-            popup_set_header(popup, "Already\nUnlocked!", 94, 3, AlignCenter, AlignTop);
-            popup_set_icon(popup, 0, 6, &I_RFIDDolphinSuccess_108x57);
-            popup_set_context(popup, nfc);
-            popup_set_callback(popup, nfc_scene_nfcv_unlock_popup_callback);
-            popup_set_timeout(popup, 1500);
-
-            view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-        } else if(state == NfcSceneNfcVUnlockStateNotSupportedCard) {
-            popup_reset(popup);
-            popup_set_header(popup, "Wrong Type Of Card!", 64, 3, AlignCenter, AlignTop);
-            popup_set_text(popup, nfcv_data->error, 4, 22, AlignLeft, AlignTop);
-            popup_set_icon(popup, 73, 20, &I_DolphinCommon_56x48);
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVUnlock, state);
-    }
-}
-
-void nfc_scene_nfcv_unlock_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    nfc_device_clear(nfc->dev);
-    // Setup view
-    nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateDetecting);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-
-    // Start worker
-    nfc_worker_start(
-        nfc->worker,
-        NfcWorkerStateNfcVUnlockAndSave,
-        &nfc->dev->dev_data,
-        nfc_scene_nfcv_unlock_worker_callback,
-        nfc);
-
-    nfc_blink_read_start(nfc);
-}
-
-bool nfc_scene_nfcv_unlock_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcWorkerEventCardDetected) {
-            nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateUnlocked);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventAborted) {
-            nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateAlreadyUnlocked);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventNoCardDetected) {
-            nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateDetecting);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventWrongCardDetected) {
-            nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateNotSupportedCard);
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed = scene_manager_search_and_switch_to_previous_scene(
-            nfc->scene_manager, NfcSceneNfcVUnlockMenu);
-    }
-    return consumed;
-}
-
-void nfc_scene_nfcv_unlock_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-    // Clear view
-    popup_reset(nfc->popup);
-    nfc_blink_stop(nfc);
-    scene_manager_set_scene_state(
-        nfc->scene_manager, NfcSceneNfcVUnlock, NfcSceneNfcVUnlockStateIdle);
-}

applications/main/nfc/scenes/nfc_scene_nfcv_unlock_menu.c

@@ -1,60 +0,0 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum SubmenuIndex {
-    SubmenuIndexNfcVUnlockMenuManual,
-    SubmenuIndexNfcVUnlockMenuTonieBox,
-};
-
-void nfc_scene_nfcv_unlock_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_nfcv_unlock_menu_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVUnlockMenu);
-    submenu_add_item(
-        submenu,
-        "Enter PWD Manually",
-        SubmenuIndexNfcVUnlockMenuManual,
-        nfc_scene_nfcv_unlock_menu_submenu_callback,
-        nfc);
-    submenu_add_item(
-        submenu,
-        "Auth As TonieBox",
-        SubmenuIndexNfcVUnlockMenuTonieBox,
-        nfc_scene_nfcv_unlock_menu_submenu_callback,
-        nfc);
-    submenu_set_selected_item(submenu, state);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_nfcv_unlock_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SubmenuIndexNfcVUnlockMenuManual) {
-            nfc->dev->dev_data.nfcv_data.auth_method = NfcVAuthMethodManual;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVKeyInput);
-            consumed = true;
-        } else if(event.event == SubmenuIndexNfcVUnlockMenuTonieBox) {
-            nfc->dev->dev_data.nfcv_data.auth_method = NfcVAuthMethodTonieBox;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVUnlock);
-            dolphin_deed(DolphinDeedNfcRead);
-            consumed = true;
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVUnlockMenu, event.event);
-    }
-    return consumed;
-}
-
-void nfc_scene_nfcv_unlock_menu_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_read.c

@@ -1,128 +1,13 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-typedef enum {
-    NfcSceneReadStateIdle,
-    NfcSceneReadStateDetecting,
-    NfcSceneReadStateReading,
-} NfcSceneReadState;
-
-bool nfc_scene_read_worker_callback(NfcWorkerEvent event, void* context) {
-    Nfc* nfc = context;
-    bool consumed = false;
-    if(event == NfcWorkerEventReadMfClassicLoadKeyCache) {
-        consumed = nfc_device_load_key_cache(nfc->dev);
-    } else {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
-        consumed = true;
-    }
-    return consumed;
-}
-
-void nfc_scene_read_set_state(Nfc* nfc, NfcSceneReadState state) {
-    uint32_t curr_state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneRead);
-    if(curr_state != state) {
-        if(state == NfcSceneReadStateDetecting) {
-            popup_reset(nfc->popup);
-            popup_set_text(
-                nfc->popup, "Apply card to\nFlipper's back", 97, 24, AlignCenter, AlignTop);
-            popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual_60x50);
-        } else if(state == NfcSceneReadStateReading) {
-            popup_reset(nfc->popup);
-            popup_set_header(
-                nfc->popup, "Reading card\nDon't move...", 85, 24, AlignCenter, AlignTop);
-            popup_set_icon(nfc->popup, 12, 23, &A_Loading_24);
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneRead, state);
-    }
-}
+#include "../helpers/protocol_support/nfc_protocol_support.h"
 
 void nfc_scene_read_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    nfc_device_clear(nfc->dev);
-    // Setup view
-    nfc_scene_read_set_state(nfc, NfcSceneReadStateDetecting);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-    // Start worker
-    nfc_worker_start(
-        nfc->worker, NfcWorkerStateRead, &nfc->dev->dev_data, nfc_scene_read_worker_callback, nfc);
-
-    nfc_blink_read_start(nfc);
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneRead, context);
 }
 
 bool nfc_scene_read_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if((event.event == NfcWorkerEventReadUidNfcB) ||
-           (event.event == NfcWorkerEventReadUidNfcF) ||
-           (event.event == NfcWorkerEventReadUidNfcV)) {
-            notification_message(nfc->notifications, &sequence_success);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneReadCardSuccess);
-            dolphin_deed(DolphinDeedNfcReadSuccess);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventReadUidNfcA) {
-            notification_message(nfc->notifications, &sequence_success);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcaReadSuccess);
-            dolphin_deed(DolphinDeedNfcReadSuccess);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventReadNfcV) {
-            notification_message(nfc->notifications, &sequence_success);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVReadSuccess);
-            dolphin_deed(DolphinDeedNfcReadSuccess);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventReadMfUltralight) {
-            notification_message(nfc->notifications, &sequence_success);
-            // Set unlock password input to 0xFFFFFFFF only on fresh read
-            memset(nfc->byte_input_store, 0xFF, sizeof(nfc->byte_input_store));
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightReadSuccess);
-            dolphin_deed(DolphinDeedNfcReadSuccess);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventReadMfClassicDone) {
-            notification_message(nfc->notifications, &sequence_success);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicReadSuccess);
-            dolphin_deed(DolphinDeedNfcReadSuccess);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventReadMfDesfire) {
-            notification_message(nfc->notifications, &sequence_success);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfDesfireReadSuccess);
-            dolphin_deed(DolphinDeedNfcReadSuccess);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventReadBankCard) {
-            notification_message(nfc->notifications, &sequence_success);
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneEmvReadSuccess);
-            dolphin_deed(DolphinDeedNfcReadSuccess);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventReadMfClassicDictAttackRequired) {
-            if(mf_classic_dict_check_presence(MfClassicDictTypeSystem)) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicDictAttack);
-            } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
-            }
-            consumed = true;
-        } else if(event.event == NfcWorkerEventCardDetected) {
-            nfc_scene_read_set_state(nfc, NfcSceneReadStateReading);
-            nfc_blink_detect_start(nfc);
-            consumed = true;
-        } else if(event.event == NfcWorkerEventNoCardDetected) {
-            nfc_scene_read_set_state(nfc, NfcSceneReadStateDetecting);
-            nfc_blink_read_start(nfc);
-            consumed = true;
-        }
-    }
-    return consumed;
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneRead, context, event);
 }
 
 void nfc_scene_read_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Stop worker
-    nfc_worker_stop(nfc->worker);
-    // Clear view
-    popup_reset(nfc->popup);
-    scene_manager_set_scene_state(nfc->scene_manager, NfcSceneRead, NfcSceneReadStateIdle);
-
-    nfc_blink_stop(nfc);
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneRead, context);
 }

applications/main/nfc/scenes/nfc_scene_read_card_success.c

@@ -1,61 +0,0 @@
-#include "../nfc_i.h"
-
-void nfc_scene_read_card_success_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    furi_assert(context);
-    Nfc* nfc = context;
-
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
-    }
-}
-
-void nfc_scene_read_card_success_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    // Setup view
-    FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
-    Widget* widget = nfc->widget;
-    furi_string_set(temp_str, nfc_get_dev_type(data->type));
-    widget_add_string_element(
-        widget, 64, 12, AlignCenter, AlignBottom, FontPrimary, furi_string_get_cstr(temp_str));
-    furi_string_set(temp_str, "UID:");
-    for(uint8_t i = 0; i < data->uid_len; i++) {
-        furi_string_cat_printf(temp_str, " %02X", data->uid[i]);
-    }
-    widget_add_string_element(
-        widget, 64, 32, AlignCenter, AlignCenter, FontSecondary, furi_string_get_cstr(temp_str));
-    widget_add_button_element(
-        widget, GuiButtonTypeLeft, "Retry", nfc_scene_read_card_success_widget_callback, nfc);
-
-    furi_string_free(temp_str);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
-}
-
-bool nfc_scene_read_card_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeLeft) {
-            consumed = scene_manager_previous_scene(nfc->scene_manager);
-        }
-    } else if(event.type == SceneManagerEventTypeBack) {
-        consumed =
-            scene_manager_search_and_switch_to_previous_scene(nfc->scene_manager, NfcSceneStart);
-    }
-    return consumed;
-}
-
-void nfc_scene_read_card_success_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    widget_reset(nfc->widget);
-}

applications/main/nfc/scenes/nfc_scene_read_card_type.c

@@ -1,97 +0,0 @@
-#include "../nfc_i.h"
-#include "nfc_worker_i.h"
-
-enum SubmenuIndex {
-    SubmenuIndexReadMifareClassic,
-    SubmenuIndexReadMifareDesfire,
-    SubmenuIndexReadMfUltralight,
-    SubmenuIndexReadEMV,
-    SubmenuIndexReadNFCA,
-};
-
-void nfc_scene_read_card_type_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
-
-void nfc_scene_read_card_type_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-
-    submenu_add_item(
-        submenu,
-        "Read Mifare Classic",
-        SubmenuIndexReadMifareClassic,
-        nfc_scene_read_card_type_submenu_callback,
-        nfc);
-    submenu_add_item(
-        submenu,
-        "Read Mifare DESFire",
-        SubmenuIndexReadMifareDesfire,
-        nfc_scene_read_card_type_submenu_callback,
-        nfc);
-    submenu_add_item(
-        submenu,
-        "Read NTAG/Ultralight",
-        SubmenuIndexReadMfUltralight,
-        nfc_scene_read_card_type_submenu_callback,
-        nfc);
-    submenu_add_item(
-        submenu,
-        "Read EMV card",
-        SubmenuIndexReadEMV,
-        nfc_scene_read_card_type_submenu_callback,
-        nfc);
-    submenu_add_item(
-        submenu,
-        "Read NFC-A data",
-        SubmenuIndexReadNFCA,
-        nfc_scene_read_card_type_submenu_callback,
-        nfc);
-    uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneReadCardType);
-    submenu_set_selected_item(submenu, state);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
-}
-
-bool nfc_scene_read_card_type_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SubmenuIndexReadMifareClassic) {
-            nfc->dev->dev_data.read_mode = NfcReadModeMfClassic;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
-            consumed = true;
-        }
-        if(event.event == SubmenuIndexReadMifareDesfire) {
-            nfc->dev->dev_data.read_mode = NfcReadModeMfDesfire;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
-            consumed = true;
-        }
-        if(event.event == SubmenuIndexReadMfUltralight) {
-            nfc->dev->dev_data.read_mode = NfcReadModeMfUltralight;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
-            consumed = true;
-        }
-        if(event.event == SubmenuIndexReadEMV) {
-            nfc->dev->dev_data.read_mode = NfcReadModeEMV;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
-            consumed = true;
-        }
-        if(event.event == SubmenuIndexReadNFCA) {
-            nfc->dev->dev_data.read_mode = NfcReadModeNFCA;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
-            consumed = true;
-        }
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneReadCardType, event.event);
-    }
-    return consumed;
-}
-
-void nfc_scene_read_card_type_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    submenu_reset(nfc->submenu);
-}

applications/main/nfc/scenes/nfc_scene_read_menu.c

@@ -0,0 +1,13 @@
+#include "../helpers/protocol_support/nfc_protocol_support.h"
+
+void nfc_scene_read_menu_on_enter(void* context) {
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneReadMenu, context);
+}
+
+bool nfc_scene_read_menu_on_event(void* context, SceneManagerEvent event) {
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneReadMenu, context, event);
+}
+
+void nfc_scene_read_menu_on_exit(void* context) {
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneReadMenu, context);
+}

applications/main/nfc/scenes/nfc_scene_read_success.c

@@ -0,0 +1,13 @@
+#include "../helpers/protocol_support/nfc_protocol_support.h"
+
+void nfc_scene_read_success_on_enter(void* context) {
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneReadSuccess, context);
+}
+
+bool nfc_scene_read_success_on_event(void* context, SceneManagerEvent event) {
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneReadSuccess, context, event);
+}
+
+void nfc_scene_read_success_on_exit(void* context) {
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneReadSuccess, context);
+}

applications/main/nfc/scenes/nfc_scene_restore_original.c

@@ -1,12 +1,12 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_restore_original_popup_callback(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
 }
 
 void nfc_scene_restore_original_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Setup view
     Popup* popup = nfc->popup;
@@ -20,17 +20,17 @@ void nfc_scene_restore_original_on_enter(void* context) {
 }
 
 bool nfc_scene_restore_original_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventViewExit) {
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
+            if(nfc_load_file(nfc, nfc->file_path, false)) {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneSavedMenu);
             } else {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
-                    nfc->scene_manager, NfcSceneStart);
+                    nfc->scene_manager, NfcSceneFileSelect);
             }
         }
     }
@@ -38,7 +38,7 @@ bool nfc_scene_restore_original_on_event(void* context, SceneManagerEvent event)
 }
 
 void nfc_scene_restore_original_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Clear view
     popup_reset(nfc->popup);

applications/main/nfc/scenes/nfc_scene_restore_original_confirm.c

@@ -1,13 +1,13 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_restore_original_confirm_dialog_callback(DialogExResult result, void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
 }
 
 void nfc_scene_restore_original_confirm_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     DialogEx* dialog_ex = nfc->dialog_ex;
 
     dialog_ex_set_header(dialog_ex, "Restore Card Data?", 64, 0, AlignCenter, AlignTop);
@@ -23,16 +23,16 @@ void nfc_scene_restore_original_confirm_on_enter(void* context) {
 }
 
 bool nfc_scene_restore_original_confirm_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == DialogExResultRight) {
-            if(!nfc_device_restore(nfc->dev, true)) {
+            if(nfc_delete_shadow_file(nfc)) {
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneRestoreOriginal);
+            } else {
                 scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneStart);
-            } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneRestoreOriginal);
             }
             consumed = true;
         } else if(event.event == DialogExResultLeft) {
@@ -46,7 +46,7 @@ bool nfc_scene_restore_original_confirm_on_event(void* context, SceneManagerEven
 }
 
 void nfc_scene_restore_original_confirm_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Clean view
     dialog_ex_reset(nfc->dialog_ex);

applications/main/nfc/scenes/nfc_scene_retry_confirm.c

@@ -1,13 +1,13 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_retry_confirm_dialog_callback(DialogExResult result, void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
 }
 
 void nfc_scene_retry_confirm_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     DialogEx* dialog_ex = nfc->dialog_ex;
 
     dialog_ex_set_left_button_text(dialog_ex, "Retry");
@@ -22,15 +22,20 @@ void nfc_scene_retry_confirm_on_enter(void* context) {
 }
 
 bool nfc_scene_retry_confirm_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == DialogExResultRight) {
             consumed = scene_manager_previous_scene(nfc->scene_manager);
         } else if(event.event == DialogExResultLeft) {
-            consumed = scene_manager_search_and_switch_to_previous_scene(
-                nfc->scene_manager, NfcSceneRead);
+            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneDetect)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneDetect);
+            } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneRead)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    nfc->scene_manager, NfcSceneRead);
+            }
         }
     } else if(event.type == SceneManagerEventTypeBack) {
         consumed = true;
@@ -40,7 +45,7 @@ bool nfc_scene_retry_confirm_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_retry_confirm_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Clean view
     dialog_ex_reset(nfc->dialog_ex);

applications/main/nfc/scenes/nfc_scene_rpc.c

@@ -1,93 +1,13 @@
-#include "../nfc_i.h"
+#include "../helpers/protocol_support/nfc_protocol_support.h"
 
 void nfc_scene_rpc_on_enter(void* context) {
-    Nfc* nfc = context;
-    Popup* popup = nfc->popup;
-
-    popup_set_header(popup, "NFC", 89, 42, AlignCenter, AlignBottom);
-    popup_set_text(popup, "RPC mode", 89, 44, AlignCenter, AlignTop);
-
-    popup_set_icon(popup, 0, 12, &I_NFC_dolphin_emulation_47x61);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
-
-    notification_message(nfc->notifications, &sequence_display_backlight_on);
-}
-
-static bool nfc_scene_rpc_emulate_callback(NfcWorkerEvent event, void* context) {
-    UNUSED(event);
-    Nfc* nfc = context;
-
-    nfc->rpc_state = NfcRpcStateEmulated;
-    return true;
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneRpc, context);
 }
 
 bool nfc_scene_rpc_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    Popup* popup = nfc->popup;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        consumed = true;
-        if(event.event == NfcCustomEventViewExit) {
-            rpc_system_app_confirm(nfc->rpc_ctx, RpcAppEventAppExit, true);
-            scene_manager_stop(nfc->scene_manager);
-            view_dispatcher_stop(nfc->view_dispatcher);
-        } else if(event.event == NfcCustomEventRpcSessionClose) {
-            scene_manager_stop(nfc->scene_manager);
-            view_dispatcher_stop(nfc->view_dispatcher);
-        } else if(event.event == NfcCustomEventRpcLoad) {
-            bool result = false;
-            const char* arg = rpc_system_app_get_data(nfc->rpc_ctx);
-            if((arg) && (nfc->rpc_state == NfcRpcStateIdle)) {
-                if(nfc_device_load(nfc->dev, arg, false)) {
-                    if(nfc->dev->format == NfcDeviceSaveFormatMifareUl) {
-                        nfc_worker_start(
-                            nfc->worker,
-                            NfcWorkerStateMfUltralightEmulate,
-                            &nfc->dev->dev_data,
-                            nfc_scene_rpc_emulate_callback,
-                            nfc);
-                    } else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
-                        nfc_worker_start(
-                            nfc->worker,
-                            NfcWorkerStateMfClassicEmulate,
-                            &nfc->dev->dev_data,
-                            nfc_scene_rpc_emulate_callback,
-                            nfc);
-                    } else if(nfc->dev->format == NfcDeviceSaveFormatNfcV) {
-                        nfc_worker_start(
-                            nfc->worker,
-                            NfcWorkerStateNfcVEmulate,
-                            &nfc->dev->dev_data,
-                            nfc_scene_rpc_emulate_callback,
-                            nfc);
-                    } else {
-                        nfc_worker_start(
-                            nfc->worker, NfcWorkerStateUidEmulate, &nfc->dev->dev_data, NULL, nfc);
-                    }
-                    nfc->rpc_state = NfcRpcStateEmulating;
-                    result = true;
-
-                    nfc_blink_emulate_start(nfc);
-                    nfc_text_store_set(nfc, "emulating\n%s", nfc->dev->dev_name);
-                    popup_set_text(popup, nfc->text_store, 89, 44, AlignCenter, AlignTop);
-                }
-            }
-
-            rpc_system_app_confirm(nfc->rpc_ctx, RpcAppEventLoadFile, result);
-        }
-    }
-    return consumed;
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneRpc, context, event);
 }
 
 void nfc_scene_rpc_on_exit(void* context) {
-    Nfc* nfc = context;
-    Popup* popup = nfc->popup;
-
-    nfc_blink_stop(nfc);
-
-    popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
-    popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
-    popup_set_icon(popup, 0, 0, NULL);
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneRpc, context);
 }

applications/main/nfc/scenes/nfc_scene_save_name.c

@@ -1,94 +1,13 @@
-#include "../nfc_i.h"
-#include <lib/toolbox/name_generator.h>
-#include <gui/modules/validators.h>
-#include <toolbox/path.h>
-#include <dolphin/dolphin.h>
-
-void nfc_scene_save_name_text_input_callback(void* context) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventTextInputDone);
-}
+#include "../helpers/protocol_support/nfc_protocol_support.h"
 
 void nfc_scene_save_name_on_enter(void* context) {
-    Nfc* nfc = context;
-
-    // Setup view
-    TextInput* text_input = nfc->text_input;
-    bool dev_name_empty = false;
-    if(!strcmp(nfc->dev->dev_name, "")) {
-        name_generator_make_auto(nfc->text_store, NFC_DEV_NAME_MAX_LEN, NFC_APP_FILENAME_PREFIX);
-        dev_name_empty = true;
-    } else {
-        nfc_text_store_set(nfc, nfc->dev->dev_name);
-    }
-    text_input_set_header_text(text_input, "Name the card");
-    text_input_set_result_callback(
-        text_input,
-        nfc_scene_save_name_text_input_callback,
-        nfc,
-        nfc->text_store,
-        NFC_DEV_NAME_MAX_LEN,
-        dev_name_empty);
-
-    FuriString* folder_path;
-    folder_path = furi_string_alloc();
-
-    if(furi_string_end_with(nfc->dev->load_path, NFC_APP_FILENAME_EXTENSION)) {
-        path_extract_dirname(furi_string_get_cstr(nfc->dev->load_path), folder_path);
-    } else {
-        furi_string_set(folder_path, NFC_APP_FOLDER);
-    }
-
-    ValidatorIsFile* validator_is_file = validator_is_file_alloc_init(
-        furi_string_get_cstr(folder_path), NFC_APP_FILENAME_EXTENSION, nfc->dev->dev_name);
-    text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextInput);
-
-    furi_string_free(folder_path);
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneSaveName, context);
 }
 
 bool nfc_scene_save_name_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventTextInputDone) {
-            if(strcmp(nfc->dev->dev_name, "") != 0) {
-                nfc_device_delete(nfc->dev, true);
-            }
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetUid) &&
-               (!scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetTypeMfUid))) {
-                nfc->dev->dev_data.nfc_data = nfc->dev_edit_data;
-            }
-            strlcpy(nfc->dev->dev_name, nfc->text_store, strlen(nfc->text_store) + 1);
-            if(nfc_save_file(nfc)) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
-                if(!scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
-                    // Nothing, do not count editing as saving
-                } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
-                    dolphin_deed(DolphinDeedNfcAddSave);
-                } else {
-                    dolphin_deed(DolphinDeedNfcSave);
-                }
-                consumed = true;
-            } else {
-                consumed = scene_manager_search_and_switch_to_previous_scene(
-                    nfc->scene_manager, NfcSceneStart);
-            }
-        }
-    }
-    return consumed;
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneSaveName, context, event);
 }
 
 void nfc_scene_save_name_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    // Clear view
-    void* validator_context = text_input_get_validator_callback_context(nfc->text_input);
-    text_input_set_validator(nfc->text_input, NULL, NULL);
-    validator_is_file_free(validator_context);
-
-    text_input_reset(nfc->text_input);
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneSaveName, context);
 }

applications/main/nfc/scenes/nfc_scene_save_success.c

@@ -1,12 +1,12 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
 void nfc_scene_save_success_popup_callback(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
 }
 
 void nfc_scene_save_success_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Setup view
     Popup* popup = nfc->popup;
@@ -20,7 +20,7 @@ void nfc_scene_save_success_on_enter(void* context) {
 }
 
 bool nfc_scene_save_success_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
@@ -28,9 +28,6 @@ bool nfc_scene_save_success_on_event(void* context, SceneManagerEvent event) {
             if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneMfClassicKeys)) {
                 consumed = scene_manager_search_and_switch_to_previous_scene(
                     nfc->scene_manager, NfcSceneMfClassicKeys);
-            } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
-                consumed = scene_manager_search_and_switch_to_previous_scene(
-                    nfc->scene_manager, NfcSceneSavedMenu);
             } else {
                 consumed = scene_manager_search_and_switch_to_another_scene(
                     nfc->scene_manager, NfcSceneFileSelect);
@@ -41,7 +38,7 @@ bool nfc_scene_save_success_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_save_success_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     // Clear view
     popup_reset(nfc->popup);

applications/main/nfc/scenes/nfc_scene_saved_menu.c

@@ -1,187 +1,13 @@
-#include "../nfc_i.h"
-#include <dolphin/dolphin.h>
-
-enum SubmenuIndex {
-    SubmenuIndexEmulate,
-    SubmenuIndexEditUid,
-    SubmenuIndexDetectReader,
-    SubmenuIndexWrite,
-    SubmenuIndexUpdate,
-    SubmenuIndexRename,
-    SubmenuIndexDelete,
-    SubmenuIndexInfo,
-    SubmenuIndexRestoreOriginal,
-    SubmenuIndexMfUlUnlockByReader,
-    SubmenuIndexMfUlUnlockByPassword,
-};
-
-void nfc_scene_saved_menu_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
-}
+#include "../helpers/protocol_support/nfc_protocol_support.h"
 
 void nfc_scene_saved_menu_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-
-    if(nfc->dev->format == NfcDeviceSaveFormatUid ||
-       nfc->dev->format == NfcDeviceSaveFormatMifareDesfire ||
-       nfc->dev->format == NfcDeviceSaveFormatBankCard) {
-        submenu_add_item(
-            submenu,
-            "Emulate UID",
-            SubmenuIndexEmulate,
-            nfc_scene_saved_menu_submenu_callback,
-            nfc);
-        if(nfc->dev->dev_data.protocol == NfcDeviceProtocolUnknown) {
-            submenu_add_item(
-                submenu,
-                "Edit UID",
-                SubmenuIndexEditUid,
-                nfc_scene_saved_menu_submenu_callback,
-                nfc);
-        }
-    } else if(
-        (nfc->dev->format == NfcDeviceSaveFormatMifareUl &&
-         mf_ul_emulation_supported(&nfc->dev->dev_data.mf_ul_data)) ||
-        nfc->dev->format == NfcDeviceSaveFormatNfcV ||
-        nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
-        submenu_add_item(
-            submenu, "Emulate", SubmenuIndexEmulate, nfc_scene_saved_menu_submenu_callback, nfc);
-    }
-    if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
-        if(!mf_classic_is_card_read(&nfc->dev->dev_data.mf_classic_data)) {
-            submenu_add_item(
-                submenu,
-                "Detect Reader",
-                SubmenuIndexDetectReader,
-                nfc_scene_saved_menu_submenu_callback,
-                nfc);
-        }
-        submenu_add_item(
-            submenu,
-            "Write to Initial Card",
-            SubmenuIndexWrite,
-            nfc_scene_saved_menu_submenu_callback,
-            nfc);
-        submenu_add_item(
-            submenu,
-            "Update from Initial Card",
-            SubmenuIndexUpdate,
-            nfc_scene_saved_menu_submenu_callback,
-            nfc);
-    }
-    submenu_add_item(
-        submenu, "Info", SubmenuIndexInfo, nfc_scene_saved_menu_submenu_callback, nfc);
-    if(nfc->dev->format == NfcDeviceSaveFormatMifareUl &&
-       nfc->dev->dev_data.mf_ul_data.type != MfUltralightTypeULC &&
-       !mf_ul_is_full_capture(&nfc->dev->dev_data.mf_ul_data)) {
-        submenu_add_item(
-            submenu,
-            "Unlock with Reader",
-            SubmenuIndexMfUlUnlockByReader,
-            nfc_scene_saved_menu_submenu_callback,
-            nfc);
-        submenu_add_item(
-            submenu,
-            "Unlock with Password",
-            SubmenuIndexMfUlUnlockByPassword,
-            nfc_scene_saved_menu_submenu_callback,
-            nfc);
-    }
-    if(nfc->dev->shadow_file_exist) {
-        submenu_add_item(
-            submenu,
-            "Restore to original",
-            SubmenuIndexRestoreOriginal,
-            nfc_scene_saved_menu_submenu_callback,
-            nfc);
-    }
-    submenu_add_item(
-        submenu, "Rename", SubmenuIndexRename, nfc_scene_saved_menu_submenu_callback, nfc);
-    submenu_add_item(
-        submenu, "Delete", SubmenuIndexDelete, nfc_scene_saved_menu_submenu_callback, nfc);
-    submenu_set_selected_item(
-        nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneSavedMenu));
-
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+    nfc_protocol_support_on_enter(NfcProtocolSupportSceneSavedMenu, context);
 }
 
 bool nfc_scene_saved_menu_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
-    NfcDeviceData* dev_data = &nfc->dev->dev_data;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        scene_manager_set_scene_state(nfc->scene_manager, NfcSceneSavedMenu, event.event);
-        if(event.event == SubmenuIndexEmulate) {
-            if(nfc->dev->format == NfcDeviceSaveFormatMifareUl) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightEmulate);
-            } else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicEmulate);
-            } else if(nfc->dev->format == NfcDeviceSaveFormatNfcV) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVEmulate);
-            } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
-            }
-            dolphin_deed(DolphinDeedNfcEmulate);
-            consumed = true;
-        } else if(event.event == SubmenuIndexDetectReader) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneDetectReader);
-            dolphin_deed(DolphinDeedNfcDetectReader);
-            consumed = true;
-        } else if(event.event == SubmenuIndexWrite) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicWrite);
-            consumed = true;
-        } else if(event.event == SubmenuIndexUpdate) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicUpdate);
-            consumed = true;
-        } else if(event.event == SubmenuIndexRename) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
-            consumed = true;
-        } else if(event.event == SubmenuIndexEditUid) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetUid);
-            consumed = true;
-        } else if(event.event == SubmenuIndexDelete) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneDelete);
-            consumed = true;
-        } else if(event.event == SubmenuIndexInfo) {
-            bool application_info_present = false;
-            if(dev_data->protocol == NfcDeviceProtocolEMV) {
-                application_info_present = true;
-            } else if(
-                dev_data->protocol == NfcDeviceProtocolMifareClassic ||
-                dev_data->protocol == NfcDeviceProtocolMifareDesfire ||
-                dev_data->protocol == NfcDeviceProtocolMifareUl) {
-                application_info_present = nfc_supported_card_verify_and_parse(dev_data);
-            }
-
-            FURI_LOG_I("nfc", "application_info_present: %d", application_info_present);
-
-            if(application_info_present) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneDeviceInfo);
-            } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
-            }
-            consumed = true;
-        } else if(event.event == SubmenuIndexRestoreOriginal) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRestoreOriginalConfirm);
-            consumed = true;
-        } else if(event.event == SubmenuIndexMfUlUnlockByReader) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockAuto);
-            consumed = true;
-        } else if(event.event == SubmenuIndexMfUlUnlockByPassword) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
-            consumed = true;
-        }
-    }
-
-    return consumed;
+    return nfc_protocol_support_on_event(NfcProtocolSupportSceneSavedMenu, context, event);
 }
 
 void nfc_scene_saved_menu_on_exit(void* context) {
-    Nfc* nfc = context;
-
-    submenu_reset(nfc->submenu);
+    nfc_protocol_support_on_exit(NfcProtocolSupportSceneSavedMenu, context);
 }

applications/main/nfc/scenes/nfc_scene_select_protocol.c

@@ -0,0 +1,67 @@
+#include "../nfc_app_i.h"
+
+void nfc_scene_select_protocol_submenu_callback(void* context, uint32_t index) {
+    NfcApp* instance = context;
+
+    view_dispatcher_send_custom_event(instance->view_dispatcher, index);
+}
+
+void nfc_scene_select_protocol_on_enter(void* context) {
+    NfcApp* instance = context;
+    Submenu* submenu = instance->submenu;
+
+    FuriString* temp_str = furi_string_alloc();
+    const char* prefix;
+    if(scene_manager_has_previous_scene(instance->scene_manager, NfcSceneExtraActions)) {
+        prefix = "Read";
+        instance->protocols_detected_num = NfcProtocolNum;
+        for(uint32_t i = 0; i < NfcProtocolNum; i++) {
+            instance->protocols_detected[i] = i;
+        }
+    } else {
+        prefix = "Read as";
+        submenu_set_header(submenu, "Multi-protocol card");
+        notification_message(instance->notifications, &sequence_single_vibro);
+    }
+
+    for(uint32_t i = 0; i < instance->protocols_detected_num; i++) {
+        furi_string_printf(
+            temp_str,
+            "%s %s",
+            prefix,
+            nfc_device_get_protocol_name(instance->protocols_detected[i]));
+        submenu_add_item(
+            submenu,
+            furi_string_get_cstr(temp_str),
+            i,
+            nfc_scene_select_protocol_submenu_callback,
+            instance);
+    }
+    furi_string_free(temp_str);
+
+    const uint32_t state =
+        scene_manager_get_scene_state(instance->scene_manager, NfcSceneSelectProtocol);
+    submenu_set_selected_item(submenu, state);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_select_protocol_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        instance->protocols_detected_selected_idx = event.event;
+        scene_manager_next_scene(instance->scene_manager, NfcSceneRead);
+        scene_manager_set_scene_state(
+            instance->scene_manager, NfcSceneSelectProtocol, event.event);
+        consumed = true;
+    }
+    return consumed;
+}
+
+void nfc_scene_select_protocol_on_exit(void* context) {
+    NfcApp* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_set_atqa.c

@@ -1,34 +1,39 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
-void nfc_scene_set_atqa_byte_input_callback(void* context) {
-    Nfc* nfc = context;
+#include "../helpers/protocol_support/nfc_protocol_support_gui_common.h"
 
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+static void nfc_scene_set_atqa_byte_input_changed_callback(void* context) {
+    NfcApp* instance = context;
+    iso14443_3a_set_atqa(instance->iso14443_3a_edit_data, instance->byte_input_store);
 }
 
 void nfc_scene_set_atqa_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
+
+    iso14443_3a_get_atqa(instance->iso14443_3a_edit_data, instance->byte_input_store);
 
     // Setup view
-    ByteInput* byte_input = nfc->byte_input;
+    ByteInput* byte_input = instance->byte_input;
     byte_input_set_header_text(byte_input, "Enter ATQA in hex");
     byte_input_set_result_callback(
         byte_input,
-        nfc_scene_set_atqa_byte_input_callback,
-        NULL,
-        nfc,
-        nfc->dev->dev_data.nfc_data.atqa,
+        nfc_protocol_support_common_byte_input_done_callback,
+        nfc_scene_set_atqa_byte_input_changed_callback,
+        instance,
+        instance->byte_input_store,
         2);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewByteInput);
 }
 
 bool nfc_scene_set_atqa_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventByteInputDone) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetUid);
+            nfc_device_set_data(
+                instance->nfc_device, NfcProtocolIso14443_3a, instance->iso14443_3a_edit_data);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneSetUid);
             consumed = true;
         }
     }
@@ -36,9 +41,9 @@ bool nfc_scene_set_atqa_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_set_atqa_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
     // Clear view
-    byte_input_set_result_callback(nfc->byte_input, NULL, NULL, NULL, NULL, 0);
-    byte_input_set_header_text(nfc->byte_input, "");
+    byte_input_set_result_callback(instance->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(instance->byte_input, "");
 }

applications/main/nfc/scenes/nfc_scene_set_sak.c

@@ -1,44 +1,48 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
-void nfc_scene_set_sak_byte_input_callback(void* context) {
-    Nfc* nfc = context;
+#include "../helpers/protocol_support/nfc_protocol_support_gui_common.h"
 
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+static void nfc_scene_set_sak_byte_input_changed_callback(void* context) {
+    NfcApp* instance = context;
+    iso14443_3a_set_sak(instance->iso14443_3a_edit_data, instance->byte_input_store[0]);
 }
 
 void nfc_scene_set_sak_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
+
+    instance->byte_input_store[0] = iso14443_3a_get_sak(instance->iso14443_3a_edit_data);
 
     // Setup view
-    ByteInput* byte_input = nfc->byte_input;
+    ByteInput* byte_input = instance->byte_input;
     byte_input_set_header_text(byte_input, "Enter SAK in hex");
     byte_input_set_result_callback(
         byte_input,
-        nfc_scene_set_sak_byte_input_callback,
-        NULL,
-        nfc,
-        &nfc->dev->dev_data.nfc_data.sak,
+        nfc_protocol_support_common_byte_input_done_callback,
+        nfc_scene_set_sak_byte_input_changed_callback,
+        instance,
+        instance->byte_input_store,
         1);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewByteInput);
 }
 
 bool nfc_scene_set_sak_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventByteInputDone) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetAtqa);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneSetAtqa);
             consumed = true;
         }
     }
+
     return consumed;
 }
 
 void nfc_scene_set_sak_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
     // Clear view
-    byte_input_set_result_callback(nfc->byte_input, NULL, NULL, NULL, NULL, 0);
-    byte_input_set_header_text(nfc->byte_input, "");
+    byte_input_set_result_callback(instance->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(instance->byte_input, "");
 }

applications/main/nfc/scenes/nfc_scene_set_type.c

@@ -1,79 +1,76 @@
-#include "../nfc_i.h"
-#include "lib/nfc/helpers/nfc_generators.h"
+#include "../nfc_app_i.h"
+
+#include "../helpers/protocol_support/nfc_protocol_support_gui_common.h"
 
 enum SubmenuIndex {
-    SubmenuIndexNFCA4,
-    SubmenuIndexNFCA7,
-    SubmenuIndexMFClassicCustomUID,
     SubmenuIndexGeneratorsStart,
+    SubmenuIndexNFCA4 = NfcDataGeneratorTypeNum,
+    SubmenuIndexNFCA7,
 };
 
-void nfc_scene_set_type_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
-
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+static void nfc_scene_set_type_init_edit_data(Iso14443_3aData* data, size_t uid_len) {
+    // Easiest way to create a zero'd buffer of given length
+    uint8_t* uid = malloc(uid_len);
+    iso14443_3a_set_uid(data, uid, uid_len);
+    free(uid);
 }
 
 void nfc_scene_set_type_on_enter(void* context) {
-    Nfc* nfc = context;
-    Submenu* submenu = nfc->submenu;
-    // Clear device name
-    nfc_device_set_name(nfc->dev, "");
-    furi_string_set(nfc->dev->load_path, "");
-    submenu_add_item(
-        submenu, "NFC-A 7-bytes UID", SubmenuIndexNFCA7, nfc_scene_set_type_submenu_callback, nfc);
-    submenu_add_item(
-        submenu, "NFC-A 4-bytes UID", SubmenuIndexNFCA4, nfc_scene_set_type_submenu_callback, nfc);
+    NfcApp* instance = context;
+
+    Submenu* submenu = instance->submenu;
     submenu_add_item(
         submenu,
-        "Mifare Classic Custom UID",
-        SubmenuIndexMFClassicCustomUID,
-        nfc_scene_set_type_submenu_callback,
-        nfc);
+        "NFC-A 7-bytes UID",
+        SubmenuIndexNFCA7,
+        nfc_protocol_support_common_submenu_callback,
+        instance);
+    submenu_add_item(
+        submenu,
+        "NFC-A 4-bytes UID",
+        SubmenuIndexNFCA4,
+        nfc_protocol_support_common_submenu_callback,
+        instance);
 
-    // Generators
-    int i = SubmenuIndexGeneratorsStart;
-    for(const NfcGenerator* const* generator = nfc_generators; *generator != NULL;
-        ++generator, ++i) {
-        submenu_add_item(submenu, (*generator)->name, i, nfc_scene_set_type_submenu_callback, nfc);
+    for(size_t i = 0; i < NfcDataGeneratorTypeNum; i++) {
+        const char* name = nfc_data_generator_get_name(i);
+        submenu_add_item(submenu, name, i, nfc_protocol_support_common_submenu_callback, instance);
     }
 
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewMenu);
 }
 
 bool nfc_scene_set_type_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexNFCA7) {
-            nfc->dev->dev_data.nfc_data.uid_len = 7;
-            nfc->dev->format = NfcDeviceSaveFormatUid;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetSak);
+            nfc_scene_set_type_init_edit_data(instance->iso14443_3a_edit_data, 7);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneSetSak);
             consumed = true;
         } else if(event.event == SubmenuIndexNFCA4) {
-            nfc->dev->dev_data.nfc_data.uid_len = 4;
-            nfc->dev->format = NfcDeviceSaveFormatUid;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetSak);
+            nfc_scene_set_type_init_edit_data(instance->iso14443_3a_edit_data, 4);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneSetSak);
             consumed = true;
         } else if(event.event == SubmenuIndexMFClassicCustomUID) {
             nfc_device_clear(nfc->dev);
             scene_manager_next_scene(nfc->scene_manager, NfcSceneSetTypeMfUid);
             consumed = true;
         } else {
-            nfc_device_clear(nfc->dev);
-            nfc->generator = nfc_generators[event.event - SubmenuIndexGeneratorsStart];
-            nfc->generator->generator_func(&nfc->dev->dev_data);
-
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneGenerateInfo);
+            nfc_data_generator_fill_data(event.event, instance->nfc_device);
+            scene_manager_set_scene_state(
+                instance->scene_manager, NfcSceneGenerateInfo, event.event);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneGenerateInfo);
             consumed = true;
         }
     }
+
     return consumed;
 }
 
 void nfc_scene_set_type_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
-    submenu_reset(nfc->submenu);
+    submenu_reset(instance->submenu);
 }

applications/main/nfc/scenes/nfc_scene_set_uid.c

@@ -1,38 +1,47 @@
-#include "../nfc_i.h"
+#include "../nfc_app_i.h"
 
-void nfc_scene_set_uid_byte_input_callback(void* context) {
-    Nfc* nfc = context;
+#include "../helpers/protocol_support/nfc_protocol_support_gui_common.h"
 
-    view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
+static void nfc_scene_set_uid_byte_input_changed_callback(void* context) {
+    NfcApp* instance = context;
+    // Retrieve previously saved UID length
+    const size_t uid_len = scene_manager_get_scene_state(instance->scene_manager, NfcSceneSetUid);
+    nfc_device_set_uid(instance->nfc_device, instance->byte_input_store, uid_len);
 }
 
 void nfc_scene_set_uid_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
+
+    size_t uid_len;
+    const uint8_t* uid = nfc_device_get_uid(instance->nfc_device, &uid_len);
+
+    memcpy(instance->byte_input_store, uid, uid_len);
+    // Save UID length for use in callback
+    scene_manager_set_scene_state(instance->scene_manager, NfcSceneSetUid, uid_len);
 
     // Setup view
-    ByteInput* byte_input = nfc->byte_input;
+    ByteInput* byte_input = instance->byte_input;
     byte_input_set_header_text(byte_input, "Enter UID in hex");
-    nfc->dev_edit_data = nfc->dev->dev_data.nfc_data;
     byte_input_set_result_callback(
         byte_input,
-        nfc_scene_set_uid_byte_input_callback,
-        NULL,
-        nfc,
-        nfc->dev_edit_data.uid,
-        nfc->dev_edit_data.uid_len);
-    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
+        nfc_protocol_support_common_byte_input_done_callback,
+        nfc_scene_set_uid_byte_input_changed_callback,
+        instance,
+        instance->byte_input_store,
+        uid_len);
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewByteInput);
 }
 
 bool nfc_scene_set_uid_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = (Nfc*)context;
+    NfcApp* instance = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventByteInputDone) {
-            if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
-                nfc->dev->dev_data.nfc_data = nfc->dev_edit_data;
-                if(nfc_save_file(nfc)) {
-                    scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
+            if(scene_manager_has_previous_scene(instance->scene_manager, NfcSceneSavedMenu)) {
+                if(nfc_save(instance)) {
+                    scene_manager_next_scene(instance->scene_manager, NfcSceneSaveSuccess);
                     consumed = true;
                 }
             } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetTypeMfUid)) {
@@ -51,7 +60,7 @@ bool nfc_scene_set_uid_on_event(void* context, SceneManagerEvent event) {
                 consumed = true;
 
             } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
+                scene_manager_next_scene(instance->scene_manager, NfcSceneSaveName);
                 consumed = true;
             }
         }
@@ -61,9 +70,9 @@ bool nfc_scene_set_uid_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_set_uid_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* instance = context;
 
     // Clear view
-    byte_input_set_result_callback(nfc->byte_input, NULL, NULL, NULL, NULL, 0);
-    byte_input_set_header_text(nfc->byte_input, "");
+    byte_input_set_result_callback(instance->byte_input, NULL, NULL, NULL, NULL, 0);
+    byte_input_set_header_text(instance->byte_input, "");
 }

applications/main/nfc/scenes/nfc_scene_start.c

@@ -1,5 +1,4 @@
-#include "../nfc_i.h"
-#include "nfc_worker_i.h"
+#include "../nfc_app_i.h"
 #include <dolphin/dolphin.h>
 
 enum SubmenuIndex {
@@ -12,15 +11,20 @@ enum SubmenuIndex {
 };
 
 void nfc_scene_start_submenu_callback(void* context, uint32_t index) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
 }
 
 void nfc_scene_start_on_enter(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     Submenu* submenu = nfc->submenu;
 
+    // Clear file name and device contents
+    furi_string_reset(nfc->file_name);
+    nfc_device_clear(nfc->nfc_device);
+    iso14443_3a_reset(nfc->iso14443_3a_edit_data);
+
     submenu_add_item(submenu, "Read", SubmenuIndexRead, nfc_scene_start_submenu_callback, nfc);
     submenu_add_item(
         submenu, "Detect Reader", SubmenuIndexDetectReader, nfc_scene_start_submenu_callback, nfc);
@@ -38,32 +42,23 @@ void nfc_scene_start_on_enter(void* context) {
     submenu_set_selected_item(
         submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneStart));
 
-    nfc_device_clear(nfc->dev);
     view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
 }
 
 bool nfc_scene_start_on_event(void* context, SceneManagerEvent event) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexRead) {
             scene_manager_set_scene_state(nfc->scene_manager, NfcSceneStart, SubmenuIndexRead);
-            nfc->dev->dev_data.read_mode = NfcReadModeAuto;
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneDetect);
             dolphin_deed(DolphinDeedNfcRead);
             consumed = true;
         } else if(event.event == SubmenuIndexDetectReader) {
             scene_manager_set_scene_state(
                 nfc->scene_manager, NfcSceneStart, SubmenuIndexDetectReader);
-            bool sd_exist = storage_sd_status(nfc->dev->storage) == FSE_OK;
-            if(sd_exist) {
-                nfc_device_data_clear(&nfc->dev->dev_data);
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneDetectReader);
-                dolphin_deed(DolphinDeedNfcDetectReader);
-            } else {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);
-            }
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicDetectReader);
             consumed = true;
         } else if(event.event == SubmenuIndexSaved) {
             // Save the scene state explicitly in each branch, so that
@@ -92,7 +87,7 @@ bool nfc_scene_start_on_event(void* context, SceneManagerEvent event) {
 }
 
 void nfc_scene_start_on_exit(void* context) {
-    Nfc* nfc = context;
+    NfcApp* nfc = context;
 
     submenu_reset(nfc->submenu);
 }

applications/main/nfc/scenes/nfc_scene_supported_card.c

@@ -0,0 +1,50 @@
+#include "nfc/nfc_app_i.h"
+
+#include "nfc/helpers/nfc_supported_cards.h"
+#include "nfc/helpers/protocol_support/nfc_protocol_support_gui_common.h"
+
+void nfc_scene_supported_card_on_enter(void* context) {
+    NfcApp* instance = context;
+
+    FuriString* temp_str = furi_string_alloc();
+
+    if(nfc_supported_cards_parse(instance->nfc_device, temp_str)) {
+        widget_add_text_scroll_element(
+            instance->widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
+        widget_add_button_element(
+            instance->widget,
+            GuiButtonTypeRight,
+            "More",
+            nfc_protocol_support_common_widget_callback,
+            instance);
+
+        scene_manager_set_scene_state(instance->scene_manager, NfcSceneSupportedCard, true);
+        view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
+
+    } else {
+        scene_manager_set_scene_state(instance->scene_manager, NfcSceneSupportedCard, false);
+        scene_manager_next_scene(instance->scene_manager, NfcSceneInfo);
+    }
+
+    furi_string_free(temp_str);
+}
+
+bool nfc_scene_supported_card_on_event(void* context, SceneManagerEvent event) {
+    NfcApp* instance = context;
+
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(instance->scene_manager, NfcSceneInfo);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void nfc_scene_supported_card_on_exit(void* context) {
+    NfcApp* instance = context;
+    widget_reset(instance->widget);
+}