Merge branch 'Eng1n33r:dev' into 420

CHANGELOG.md

@@ -1,13 +1,12 @@
 ### New changes
-* Plugins: RFID Fuzzer - fix crashes, fix bugs, improve gui, add more examples, add new protocols - PAC/Stanley, H10301 (@xMasterX)
-* PR: SubGHz: Fix Detect RAW crashes, fix critical RPC issues, improve startup speed for favourites (by @derskythe & @xMasterX | PR #80)
-* PR: RFID Fuzzer - ability to change bits (up/down) in Load file menu (by @mvanzanten | PR #83)
-* PR: SubGHz - turn display on when signal received (by @TQMatvey | PR #82)
-* Infrared: Update assets (by @Amec0e)
-* OFW: Thread: Clear TLS after thread stop
-* OFW: Fix memory leak in lfRFID write
-* OFW PR: CLI: log command argument (OFW PR 1817 by DrZlo13)
-* OFW PR: FFF trailing space fix (OFW PR 1811 by gsurkov)
+* SubGHz: Now Hopping can't be used at same time with detect RAW feature, fixes issue with freeze 
+* SubGHz: Frequency Analyzer -> turn display on on all feedback modes
+* PR: RFID Fuzzer - Allow the RFID protocol menu to wrap (by @colingrady | PR #84)
+* PR: RFID Fuzzer - Improve UI for added on-the-fly feature (by @mvanzanten | PR #85)
+* OFW PR: NFC update detect reader (OFW PR 1820 by gornekich)
+* OFW PR: Remove bank card uid emulation & fix emv info (OFW PR 1823 by gornekich)
+* OFW PR: Don't turn off the backlight on MFC dict attack (OFW PR 1826 by Astrrra)
+* OFW PR: Infrared error message (OFW PR 1827 by gsurkov)
 
 #### [🎲 Download extra apps pack](https://download-directory.github.io/?url=https://github.com/UberGuidoZ/Flipper/tree/main/Applications/Unleashed)
 

applications/main/infrared/scenes/infrared_scene_learn_enter_name.c

@@ -50,8 +50,10 @@ bool infrared_scene_learn_enter_name_on_event(void* context, SceneManagerEvent e
             if(success) {
                 scene_manager_next_scene(scene_manager, InfraredSceneLearnDone);
             } else {
-                scene_manager_search_and_switch_to_previous_scene(
-                    scene_manager, InfraredSceneRemoteList);
+                dialog_message_show_storage_error(infrared->dialogs, "Failed to save file");
+                const uint32_t possible_scenes[] = {InfraredSceneRemoteList, InfraredSceneStart};
+                scene_manager_search_and_switch_to_previous_scene_one_of(
+                    scene_manager, possible_scenes, COUNT_OF(possible_scenes));
             }
             consumed = true;
         }

applications/main/nfc/nfc.c

@@ -277,6 +277,8 @@ int32_t nfc_app(void* p) {
                     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 == NfcDeviceSaveFormatBankCard) {
+                    scene_manager_next_scene(nfc->scene_manager, NfcSceneDeviceInfo);
                 } else {
                     scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
                 }

applications/main/nfc/scenes/nfc_scene_detect_reader.c

@@ -1,6 +1,15 @@
 #include "../nfc_i.h"
 #include <dolphin/dolphin.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);
@@ -20,21 +29,26 @@ void nfc_scene_detect_reader_on_enter(void* context) {
     DOLPHIN_DEED(DolphinDeedNfcEmulate);
 
     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);
+
+    // 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);
-
-    nfc_blink_read_start(nfc);
 }
 
 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) {
@@ -42,8 +56,29 @@ bool nfc_scene_detect_reader_on_event(void* context, SceneManagerEvent event) {
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfkeyNoncesInfo);
             consumed = true;
         } else if(event.event == NfcWorkerEventDetectReaderMfkeyCollected) {
-            detect_reader_inc_nonce_cnt(nfc->detect_reader);
+            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);
+            }
         }
     }
 
@@ -59,5 +94,7 @@ void nfc_scene_detect_reader_on_exit(void* context) {
     // 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_mf_classic_dict_attack.c

@@ -91,6 +91,7 @@ void nfc_scene_mf_classic_dict_attack_on_enter(void* 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);
 }
 
 bool nfc_scene_mf_classic_dict_attack_on_event(void* context, SceneManagerEvent event) {
@@ -167,4 +168,5 @@ void nfc_scene_mf_classic_dict_attack_on_exit(void* context) {
     }
     dict_attack_reset(nfc->dict_attack);
     nfc_blink_stop(nfc);
+    notification_message(nfc->notifications, &sequence_display_backlight_enforce_auto);
 }

applications/main/nfc/scenes/nfc_scene_mfkey_nonces_info.c

@@ -16,14 +16,14 @@ void nfc_scene_mfkey_nonces_info_on_enter(void* context) {
 
     uint16_t nonces_saved = mfkey32_get_auth_sectors(temp_str);
     widget_add_text_scroll_element(nfc->widget, 0, 22, 128, 42, string_get_cstr(temp_str));
-    string_printf(temp_str, "Nonces saved %d", nonces_saved);
+    string_printf(temp_str, "Nonce pairs saved %d", nonces_saved);
     widget_add_string_element(
         nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, string_get_cstr(temp_str));
     widget_add_string_element(
         nfc->widget, 0, 12, AlignLeft, AlignTop, FontSecondary, "Authenticated sectors:");
 
     widget_add_button_element(
-        nfc->widget, GuiButtonTypeRight, "Next", nfc_scene_mfkey_nonces_info_callback, nfc);
+        nfc->widget, GuiButtonTypeCenter, "OK", nfc_scene_mfkey_nonces_info_callback, nfc);
 
     string_clear(temp_str);
 
@@ -35,7 +35,7 @@ bool nfc_scene_mfkey_nonces_info_on_event(void* context, SceneManagerEvent event
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == GuiButtonTypeRight) {
+        if(event.event == GuiButtonTypeCenter) {
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfkeyComplete);
             consumed = true;
         }

applications/main/nfc/scenes/nfc_scene_saved_menu.c

@@ -20,8 +20,7 @@ void nfc_scene_saved_menu_on_enter(void* context) {
     Submenu* submenu = nfc->submenu;
 
     if(nfc->dev->format == NfcDeviceSaveFormatUid ||
-       nfc->dev->format == NfcDeviceSaveFormatMifareDesfire ||
-       nfc->dev->format == NfcDeviceSaveFormatBankCard) {
+       nfc->dev->format == NfcDeviceSaveFormatMifareDesfire) {
         submenu_add_item(
             submenu,
             "Emulate UID",

applications/main/nfc/views/detect_reader.c

@@ -10,29 +10,50 @@ struct DetectReader {
 
 typedef struct {
     uint16_t nonces;
+    uint16_t nonces_max;
+    DetectReaderState state;
 } DetectReaderViewModel;
 
 static void detect_reader_draw_callback(Canvas* canvas, void* model) {
     DetectReaderViewModel* m = model;
     char text[32] = {};
 
-    snprintf(text, sizeof(text), "Tap the reader several times");
-    canvas_draw_str_aligned(canvas, 64, 0, AlignCenter, AlignTop, "Tap the reader several times");
+    // Draw header and icon
+    canvas_draw_icon(canvas, 0, 16, &I_Modern_reader_18x34);
+    if(m->state == DetectReaderStateStart) {
+        snprintf(text, sizeof(text), "Touch the reader");
+        canvas_draw_icon(canvas, 21, 13, &I_Move_flipper_26x39);
+    } else if(m->state == DetectReaderStateReaderDetected) {
+        snprintf(text, sizeof(text), "Move the Flipper away");
+        canvas_draw_icon(canvas, 24, 25, &I_Release_arrow_18x15);
+    } else if(m->state == DetectReaderStateReaderLost) {
+        snprintf(text, sizeof(text), "Touch the reader again");
+        canvas_draw_icon(canvas, 21, 13, &I_Move_flipper_26x39);
+    }
 
-    if(m->nonces == 0) {
+    canvas_draw_str_aligned(canvas, 64, 0, AlignCenter, AlignTop, text);
+
+    // Draw collected nonces
+    if(m->state == DetectReaderStateStart) {
         canvas_set_font(canvas, FontPrimary);
-        canvas_draw_str_aligned(canvas, 52, 22, AlignLeft, AlignTop, "Emulating...");
+        canvas_draw_str_aligned(canvas, 51, 22, AlignLeft, AlignTop, "Emulating...");
         canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(canvas, 52, 35, AlignLeft, AlignTop, "MIFARE Classic");
-        canvas_draw_icon(canvas, 0, 13, &I_Tap_reader_36x38);
+        canvas_draw_str_aligned(canvas, 51, 35, AlignLeft, AlignTop, "MIFARE MFkey32");
     } else {
-        canvas_set_font(canvas, FontPrimary);
-        canvas_draw_str_aligned(canvas, 54, 22, AlignLeft, AlignTop, "Collecting...");
+        if(m->state == DetectReaderStateDone) {
+            canvas_set_font(canvas, FontPrimary);
+            canvas_draw_str_aligned(canvas, 51, 22, AlignLeft, AlignTop, "Completed!");
+        } else {
+            canvas_set_font(canvas, FontPrimary);
+            canvas_draw_str_aligned(canvas, 51, 22, AlignLeft, AlignTop, "Collecting...");
+        }
         canvas_set_font(canvas, FontSecondary);
-        snprintf(text, sizeof(text), "Nonces: %d", m->nonces);
-        canvas_draw_str_aligned(canvas, 54, 35, AlignLeft, AlignTop, text);
-        elements_button_right(canvas, "Next");
-        canvas_draw_icon(canvas, 6, 15, &I_ArrowC_1_36x36);
+        snprintf(text, sizeof(text), "Nonce pairs: %d/%d", m->nonces, m->nonces_max);
+        canvas_draw_str_aligned(canvas, 51, 35, AlignLeft, AlignTop, text);
+    }
+    // Draw button
+    if(m->nonces > 0) {
+        elements_button_center(canvas, "Done");
     }
 }
 
@@ -49,7 +70,7 @@ static bool detect_reader_input_callback(InputEvent* event, void* context) {
         });
 
     if(event->type == InputTypeShort) {
-        if(event->key == InputKeyRight) {
+        if(event->key == InputKeyOk) {
             if(nonces > 0) {
                 detect_reader->callback(detect_reader->context);
                 consumed = true;
@@ -84,6 +105,8 @@ void detect_reader_reset(DetectReader* detect_reader) {
     with_view_model(
         detect_reader->view, (DetectReaderViewModel * model) {
             model->nonces = 0;
+            model->nonces_max = 0;
+            model->state = DetectReaderStateStart;
             return false;
         });
 }
@@ -105,11 +128,31 @@ void detect_reader_set_callback(
     detect_reader->context = context;
 }
 
-void detect_reader_inc_nonce_cnt(DetectReader* detect_reader) {
+void detect_reader_set_nonces_max(DetectReader* detect_reader, uint16_t nonces_max) {
     furi_assert(detect_reader);
+
     with_view_model(
         detect_reader->view, (DetectReaderViewModel * model) {
-            model->nonces++;
+            model->nonces_max = nonces_max;
             return false;
         });
 }
+
+void detect_reader_set_nonces_collected(DetectReader* detect_reader, uint16_t nonces_collected) {
+    furi_assert(detect_reader);
+
+    with_view_model(
+        detect_reader->view, (DetectReaderViewModel * model) {
+            model->nonces = nonces_collected;
+            return false;
+        });
+}
+
+void detect_reader_set_state(DetectReader* detect_reader, DetectReaderState state) {
+    furi_assert(detect_reader);
+    with_view_model(
+        detect_reader->view, (DetectReaderViewModel * model) {
+            model->state = state;
+            return true;
+        });
+}

applications/main/nfc/views/detect_reader.h

@@ -5,6 +5,13 @@
 
 typedef struct DetectReader DetectReader;
 
+typedef enum {
+    DetectReaderStateStart,
+    DetectReaderStateReaderDetected,
+    DetectReaderStateReaderLost,
+    DetectReaderStateDone,
+} DetectReaderState;
+
 typedef void (*DetectReaderDoneCallback)(void* context);
 
 DetectReader* detect_reader_alloc();
@@ -20,4 +27,8 @@ void detect_reader_set_callback(
     DetectReaderDoneCallback callback,
     void* context);
 
-void detect_reader_inc_nonce_cnt(DetectReader* detect_reader);
+void detect_reader_set_nonces_max(DetectReader* detect_reader, uint16_t nonces_max);
+
+void detect_reader_set_nonces_collected(DetectReader* detect_reader, uint16_t nonces_collected);
+
+void detect_reader_set_state(DetectReader* detect_reader, DetectReaderState state);

applications/main/subghz/scenes/subghz_scene_receiver_config.c

@@ -189,55 +189,64 @@ static void subghz_scene_receiver_config_set_detect_raw(VariableItem* item) {
     SubGhz* subghz = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
 
-    variable_item_set_current_value_text(item, detect_raw_text[index]);
+    if(subghz->txrx->hopper_state == 0) {
+        variable_item_set_current_value_text(item, detect_raw_text[index]);
 #ifdef SUBGHZ_SAVE_DETECT_RAW_SETTING
-    subghz->last_settings->detect_raw = index;
+        subghz->last_settings->detect_raw = index;
 
-    subghz_last_settings_set_detect_raw_values(subghz);
+        subghz_last_settings_set_detect_raw_values(subghz);
 #else
-    subghz_receiver_set_filter(subghz->txrx->receiver, detect_raw_value[index]);
+        subghz_receiver_set_filter(subghz->txrx->receiver, detect_raw_value[index]);
 
-    subghz_protocol_decoder_raw_set_auto_mode(
-        subghz_receiver_search_decoder_base_by_name(
-            subghz->txrx->receiver, SUBGHZ_PROTOCOL_RAW_NAME),
-        (index == 1));
+        subghz_protocol_decoder_raw_set_auto_mode(
+            subghz_receiver_search_decoder_base_by_name(
+                subghz->txrx->receiver, SUBGHZ_PROTOCOL_RAW_NAME),
+            (index == 1));
 #endif
+    } else {
+        variable_item_set_current_value_index(item, 0);
+    }
 }
 
 static void subghz_scene_receiver_config_set_hopping_running(VariableItem* item) {
     SubGhz* subghz = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
 
-    variable_item_set_current_value_text(item, hopping_text[index]);
-    if(hopping_value[index] == SubGhzHopperStateOFF) {
-        char text_buf[10] = {0};
-        snprintf(
-            text_buf,
-            sizeof(text_buf),
-            "%lu.%02lu",
-            subghz_setting_get_default_frequency(subghz->setting) / 1000000,
-            (subghz_setting_get_default_frequency(subghz->setting) % 1000000) / 10000);
-        variable_item_set_current_value_text(
-            (VariableItem*)scene_manager_get_scene_state(
-                subghz->scene_manager, SubGhzSceneReceiverConfig),
-            text_buf);
-        subghz->txrx->preset->frequency = subghz_setting_get_default_frequency(subghz->setting);
-        variable_item_set_current_value_index(
-            (VariableItem*)scene_manager_get_scene_state(
-                subghz->scene_manager, SubGhzSceneReceiverConfig),
-            subghz_setting_get_frequency_default_index(subghz->setting));
-    } else {
-        variable_item_set_current_value_text(
-            (VariableItem*)scene_manager_get_scene_state(
-                subghz->scene_manager, SubGhzSceneReceiverConfig),
-            " -----");
-        variable_item_set_current_value_index(
-            (VariableItem*)scene_manager_get_scene_state(
-                subghz->scene_manager, SubGhzSceneReceiverConfig),
-            subghz_setting_get_frequency_default_index(subghz->setting));
-    }
+    if(subghz_receiver_get_filter(subghz->txrx->receiver) == SubGhzProtocolFlag_Decodable) {
+        variable_item_set_current_value_text(item, hopping_text[index]);
+        if(hopping_value[index] == SubGhzHopperStateOFF) {
+            char text_buf[10] = {0};
+            snprintf(
+                text_buf,
+                sizeof(text_buf),
+                "%lu.%02lu",
+                subghz_setting_get_default_frequency(subghz->setting) / 1000000,
+                (subghz_setting_get_default_frequency(subghz->setting) % 1000000) / 10000);
+            variable_item_set_current_value_text(
+                (VariableItem*)scene_manager_get_scene_state(
+                    subghz->scene_manager, SubGhzSceneReceiverConfig),
+                text_buf);
+            subghz->txrx->preset->frequency =
+                subghz_setting_get_default_frequency(subghz->setting);
+            variable_item_set_current_value_index(
+                (VariableItem*)scene_manager_get_scene_state(
+                    subghz->scene_manager, SubGhzSceneReceiverConfig),
+                subghz_setting_get_frequency_default_index(subghz->setting));
+        } else {
+            variable_item_set_current_value_text(
+                (VariableItem*)scene_manager_get_scene_state(
+                    subghz->scene_manager, SubGhzSceneReceiverConfig),
+                " -----");
+            variable_item_set_current_value_index(
+                (VariableItem*)scene_manager_get_scene_state(
+                    subghz->scene_manager, SubGhzSceneReceiverConfig),
+                subghz_setting_get_frequency_default_index(subghz->setting));
+        }
 
-    subghz->txrx->hopper_state = hopping_value[index];
+        subghz->txrx->hopper_state = hopping_value[index];
+    } else {
+        variable_item_set_current_value_index(item, 0);
+    }
 }
 
 static void subghz_scene_receiver_config_var_list_enter_callback(void* context, uint32_t index) {

applications/main/subghz/views/subghz_frequency_analyzer.c

@@ -367,11 +367,13 @@ void subghz_frequency_analyzer_pair_callback(void* context, uint32_t frequency,
             switch(instance->feedback_level) {
             case 1: // 1 - only vibro
                 notification_message(instance->notifications, &sequence_single_vibro);
+                notification_message(instance->notifications, &sequence_display_backlight_on);
                 break;
             case 2: // 2 - vibro and beep
                 notification_message(instance->notifications, &sequence_success);
                 break;
             default: // 0 - no feedback
+                notification_message(instance->notifications, &sequence_display_backlight_on);
                 break;
             }
 

applications/plugins/flipfrid/scene/flipfrid_scene_entrypoint.c

@@ -116,11 +116,15 @@ void flipfrid_scene_entrypoint_on_event(FlipFridEvent event, FlipFridState* cont
             case InputKeyLeft:
                 if(context->menu_proto_index > EM4100) {
                     context->menu_proto_index--;
+                } else if(context->menu_proto_index == EM4100) {
+                    context->menu_proto_index = H10301;
                 }
                 break;
             case InputKeyRight:
                 if(context->menu_proto_index < H10301) {
                     context->menu_proto_index++;
+                } else if(context->menu_proto_index == H10301) {
+                    context->menu_proto_index = EM4100;
                 }
                 break;
             case InputKeyOk:

applications/plugins/flipfrid/scene/flipfrid_scene_select_field.c

@@ -142,16 +142,17 @@ void flipfrid_scene_select_field_on_draw(Canvas* canvas, FlipFridState* context)
     // Frame
     //canvas_draw_frame(canvas, 0, 0, 128, 64);
 
-    // Title
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 64, 10, AlignCenter, AlignTop, "Use < > to select byte.");
+    canvas_set_font(canvas, FontSecondary);
+    canvas_draw_str_aligned(canvas, 12, 5, AlignLeft, AlignTop, "Left and right: select byte");
+    canvas_draw_str_aligned(canvas, 12, 15, AlignLeft, AlignTop, "Up and down: adjust byte");
 
     char msg_index[18];
+    canvas_set_font(canvas, FontPrimary);
     snprintf(msg_index, sizeof(msg_index), "Field index : %d", context->key_index);
-    canvas_draw_str_aligned(canvas, 64, 26, AlignCenter, AlignTop, msg_index);
+    canvas_draw_str_aligned(canvas, 64, 30, AlignCenter, AlignTop, msg_index);
 
     flipfrid_center_displayed_key(context, context->key_index);
     canvas_set_font(canvas, FontSecondary);
     canvas_draw_str_aligned(
-        canvas, 64, 44, AlignCenter, AlignTop, string_get_cstr(context->notification_msg));
+        canvas, 64, 45, AlignCenter, AlignTop, string_get_cstr(context->notification_msg));
 }

firmware/targets/f7/api_symbols.csv

@@ -4190,6 +4190,8 @@ Variable,+,I_MHz_25x11,const Icon,
 Variable,+,I_Medium_chip_22x21,const Icon,
 Variable,+,I_Mode_25x27,const Icon,
 Variable,+,I_Mode_hvr_25x27,const Icon,
+Variable,+,I_Modern_reader_18x34,const Icon,
+Variable,+,I_Move_flipper_26x39,const Icon,
 Variable,+,I_Mute_25x27,const Icon,
 Variable,+,I_Mute_hvr_25x27,const Icon,
 Variable,+,I_NFC_manual_60x50,const Icon,
@@ -4215,6 +4217,7 @@ Variable,+,I_RFIDDolphinReceive_97x61,const Icon,
 Variable,+,I_RFIDDolphinSend_97x61,const Icon,
 Variable,+,I_RFIDDolphinSuccess_108x57,const Icon,
 Variable,+,I_RFIDSmallChip_14x14,const Icon,
+Variable,+,I_Release_arrow_18x15,const Icon,
 Variable,+,I_Restoring_38x32,const Icon,
 Variable,+,I_Right_mouse_icon_9x9,const Icon,
 Variable,+,I_Rotate_25x27,const Icon,

lib/nfc/helpers/mfkey32.c

@@ -94,7 +94,7 @@ static bool mfkey32_write_params(Mfkey32* instance, Mfkey32Params* params) {
     string_t str;
     string_init_printf(
         str,
-        "Sector %d key %c cuid %08x nt0 %08x nr0 %08x ar0 %08x nt1 %08x nr1 %08x ar1 %08x\n",
+        "Sec %d key %c cuid %08x nt0 %08x nr0 %08x ar0 %08x nt1 %08x nr1 %08x ar1 %08x\n",
         params->sector,
         params->key == MfClassicKeyA ? 'A' : 'B',
         params->cuid,

lib/nfc/nfc_worker.c

@@ -661,7 +661,8 @@ static void nfc_worker_reader_analyzer_callback(ReaderAnalyzerEvent event, void*
     furi_assert(context);
     NfcWorker* nfc_worker = context;
 
-    if(event == ReaderAnalyzerEventMfkeyCollected) {
+    if((nfc_worker->state == NfcWorkerStateAnalyzeReader) &&
+       (event == ReaderAnalyzerEventMfkeyCollected)) {
         if(nfc_worker->callback) {
             nfc_worker->callback(NfcWorkerEventDetectReaderMfkeyCollected, nfc_worker->context);
         }
@@ -669,6 +670,8 @@ static void nfc_worker_reader_analyzer_callback(ReaderAnalyzerEvent event, void*
 }
 
 void nfc_worker_analyze_reader(NfcWorker* nfc_worker) {
+    furi_assert(nfc_worker->callback);
+
     FuriHalNfcTxRxContext tx_rx = {};
 
     ReaderAnalyzer* reader_analyzer = nfc_worker->reader_analyzer;
@@ -687,17 +690,32 @@ void nfc_worker_analyze_reader(NfcWorker* nfc_worker) {
     rfal_platform_spi_acquire();
 
     FURI_LOG_D(TAG, "Start reader analyzer");
+
+    uint8_t reader_no_data_received_cnt = 0;
+    bool reader_no_data_notified = true;
+
     while(nfc_worker->state == NfcWorkerStateAnalyzeReader) {
         furi_hal_nfc_stop_cmd();
         furi_delay_ms(5);
         furi_hal_nfc_listen_start(nfc_data);
         if(furi_hal_nfc_listen_rx(&tx_rx, 300)) {
+            if(reader_no_data_notified) {
+                nfc_worker->callback(NfcWorkerEventDetectReaderDetected, nfc_worker->context);
+            }
+            reader_no_data_received_cnt = 0;
+            reader_no_data_notified = false;
             NfcProtocol protocol =
                 reader_analyzer_guess_protocol(reader_analyzer, tx_rx.rx_data, tx_rx.rx_bits / 8);
             if(protocol == NfcDeviceProtocolMifareClassic) {
                 mf_classic_emulator(&emulator, &tx_rx);
             }
         } else {
+            reader_no_data_received_cnt++;
+            if(!reader_no_data_notified && (reader_no_data_received_cnt > 5)) {
+                nfc_worker->callback(NfcWorkerEventDetectReaderLost, nfc_worker->context);
+                reader_no_data_received_cnt = 0;
+                reader_no_data_notified = true;
+            }
             FURI_LOG_D(TAG, "No data from reader");
             continue;
         }

lib/nfc/nfc_worker.h

@@ -60,6 +60,8 @@ typedef enum {
     NfcWorkerEventMfUltralightPwdAuth, // Reader sent auth command
 
     // Detect Reader events
+    NfcWorkerEventDetectReaderDetected,
+    NfcWorkerEventDetectReaderLost,
     NfcWorkerEventDetectReaderMfkeyCollected,
 
 } NfcWorkerEvent;