Merge branch 'reborned/nfc_ui_refactor' of git@github.com:RebornedBrain/flipperzero-firmware.git

applications/main/nfc/helpers/mf_user_dict.c

@@ -1,6 +1,6 @@
 #include "mf_user_dict.h"
 
-#include <nfc/helpers/nfc_dict.h>
+#include <toolbox/keys_dict.h>
 #include <nfc/protocols/mf_classic/mf_classic.h>
 #include <furi/furi.h>
 
@@ -15,22 +15,22 @@ struct MfUserDict {
 MfUserDict* mf_user_dict_alloc(size_t max_keys_to_load) {
     MfUserDict* instance = malloc(sizeof(MfUserDict));
 
-    NfcDict* dict = nfc_dict_alloc(
-        NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+    KeysDict* dict = keys_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_USER_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
     furi_assert(dict);
 
-    size_t dict_keys_num = nfc_dict_get_total_keys(dict);
+    size_t dict_keys_num = keys_dict_get_total_keys(dict);
     instance->keys_num = MIN(max_keys_to_load, dict_keys_num);
 
     if(instance->keys_num > 0) {
         instance->keys_arr = malloc(instance->keys_num * sizeof(MfClassicKey));
         for(size_t i = 0; i < instance->keys_num; i++) {
             bool key_loaded =
-                nfc_dict_get_next_key(dict, instance->keys_arr[i].data, sizeof(MfClassicKey));
+                keys_dict_get_next_key(dict, instance->keys_arr[i].data, sizeof(MfClassicKey));
             furi_assert(key_loaded);
         }
     }
-    nfc_dict_free(dict);
+    keys_dict_free(dict);
 
     return instance;
 }
@@ -67,13 +67,13 @@ bool mf_user_dict_delete_key(MfUserDict* instance, uint32_t index) {
     furi_assert(index < instance->keys_num);
     furi_assert(instance->keys_arr);
 
-    NfcDict* dict = nfc_dict_alloc(
-        NFC_APP_MF_CLASSIC_DICT_USER_PATH, NfcDictModeOpenAlways, sizeof(MfClassicKey));
+    KeysDict* dict = keys_dict_alloc(
+        NFC_APP_MF_CLASSIC_DICT_USER_PATH, KeysDictModeOpenAlways, sizeof(MfClassicKey));
     furi_assert(dict);
 
     bool key_delete_success =
-        nfc_dict_delete_key(dict, instance->keys_arr[index].data, sizeof(MfClassicKey));
-    nfc_dict_free(dict);
+        keys_dict_delete_key(dict, instance->keys_arr[index].data, sizeof(MfClassicKey));
+    keys_dict_free(dict);
 
     if(key_delete_success) {
         instance->keys_num--;

applications/main/nfc/helpers/nfc_supported_cards.c

@@ -1,4 +1,5 @@
 #include "nfc_supported_cards.h"
+
 #include "../plugins/supported_cards/nfc_supported_card_plugin.h"
 
 #include <flipper_application/flipper_application.h>
@@ -7,22 +8,72 @@
 
 #include <furi.h>
 #include <path.h>
+#include <m-array.h>
 
 #define TAG "NfcSupportedCards"
 
 #define NFC_SUPPORTED_CARDS_PLUGINS_PATH APP_DATA_PATH("plugins")
 #define NFC_SUPPORTED_CARDS_PLUGIN_SUFFIX "_parser.fal"
 
+typedef enum {
+    NfcSupportedCardsPluginFeatureHasVerify = (1U << 0),
+    NfcSupportedCardsPluginFeatureHasRead = (1U << 1),
+    NfcSupportedCardsPluginFeatureHasParse = (1U << 2),
+} NfcSupportedCardsPluginFeature;
+
+typedef struct {
+    FuriString* path;
+    NfcProtocol protocol;
+    NfcSupportedCardsPluginFeature feature;
+} NfcSupportedCardsPluginCache;
+
+ARRAY_DEF(NfcSupportedCardsPluginCache, NfcSupportedCardsPluginCache, M_POD_OPLIST);
+
+typedef enum {
+    NfcSupportedCardsLoadStateIdle,
+    NfcSupportedCardsLoadStateInProgress,
+    NfcSupportedCardsLoadStateSuccess,
+    NfcSupportedCardsLoadStateFail,
+} NfcSupportedCardsLoadState;
+
 typedef struct {
     Storage* storage;
     File* directory;
     FuriString* file_path;
     char file_name[256];
     FlipperApplication* app;
-} NfcSupportedCards;
+} NfcSupportedCardsLoadContext;
 
-static NfcSupportedCards* nfc_supported_cards_alloc() {
+struct NfcSupportedCards {
+    NfcSupportedCardsPluginCache_t plugins_cache_arr;
+    NfcSupportedCardsLoadState load_state;
+    NfcSupportedCardsLoadContext* load_context;
+};
+
+NfcSupportedCards* nfc_supported_cards_alloc() {
     NfcSupportedCards* instance = malloc(sizeof(NfcSupportedCards));
+    NfcSupportedCardsPluginCache_init(instance->plugins_cache_arr);
+
+    return instance;
+}
+
+void nfc_supported_cards_free(NfcSupportedCards* instance) {
+    furi_assert(instance);
+
+    NfcSupportedCardsPluginCache_it_t iter;
+    for(NfcSupportedCardsPluginCache_it(iter, instance->plugins_cache_arr);
+        !NfcSupportedCardsPluginCache_end_p(iter);
+        NfcSupportedCardsPluginCache_next(iter)) {
+        NfcSupportedCardsPluginCache* plugin_cache = NfcSupportedCardsPluginCache_ref(iter);
+        furi_string_free(plugin_cache->path);
+    }
+
+    NfcSupportedCardsPluginCache_clear(instance->plugins_cache_arr);
+    free(instance);
+}
+
+static NfcSupportedCardsLoadContext* nfc_supported_cards_load_context_alloc() {
+    NfcSupportedCardsLoadContext* instance = malloc(sizeof(NfcSupportedCardsLoadContext));
 
     instance->storage = furi_record_open(RECORD_STORAGE);
     instance->directory = storage_file_alloc(instance->storage);
@@ -35,7 +86,7 @@ static NfcSupportedCards* nfc_supported_cards_alloc() {
     return instance;
 }
 
-static void nfc_supported_cards_free(NfcSupportedCards* instance) {
+static void nfc_supported_cards_load_context_free(NfcSupportedCardsLoadContext* instance) {
     if(instance->app) {
         flipper_application_free(instance->app);
     }
@@ -50,7 +101,36 @@ static void nfc_supported_cards_free(NfcSupportedCards* instance) {
 }
 
 static const NfcSupportedCardsPlugin*
-    nfc_supported_cards_get_next_plugin(NfcSupportedCards* instance) {
+    nfc_supported_cards_get_plugin(NfcSupportedCardsLoadContext* instance, FuriString* path) {
+    furi_assert(instance);
+    furi_assert(path);
+
+    const NfcSupportedCardsPlugin* plugin = NULL;
+    do {
+        if(instance->app) flipper_application_free(instance->app);
+        instance->app = flipper_application_alloc(instance->storage, firmware_api_interface);
+        if(flipper_application_preload(instance->app, furi_string_get_cstr(path)) !=
+           FlipperApplicationPreloadStatusSuccess)
+            break;
+        if(!flipper_application_is_plugin(instance->app)) break;
+        if(flipper_application_map_to_memory(instance->app) != FlipperApplicationLoadStatusSuccess)
+            break;
+        const FlipperAppPluginDescriptor* descriptor =
+            flipper_application_plugin_get_descriptor(instance->app);
+
+        if(descriptor == NULL) break;
+
+        if(strcmp(descriptor->appid, NFC_SUPPORTED_CARD_PLUGIN_APP_ID) != 0) break;
+        if(descriptor->ep_api_version != NFC_SUPPORTED_CARD_PLUGIN_API_VERSION) break;
+
+        plugin = descriptor->entry_point;
+    } while(false);
+
+    return plugin;
+}
+
+static const NfcSupportedCardsPlugin*
+    nfc_supported_cards_get_next_plugin(NfcSupportedCardsLoadContext* instance) {
     const NfcSupportedCardsPlugin* plugin = NULL;
 
     do {
@@ -65,83 +145,137 @@ static const NfcSupportedCardsPlugin*
 
         path_concat(NFC_SUPPORTED_CARDS_PLUGINS_PATH, instance->file_name, instance->file_path);
 
-        if(instance->app) flipper_application_free(instance->app);
-        instance->app = flipper_application_alloc(instance->storage, firmware_api_interface);
-
-        if(flipper_application_preload(instance->app, furi_string_get_cstr(instance->file_path)) !=
-           FlipperApplicationPreloadStatusSuccess)
-            continue;
-        if(!flipper_application_is_plugin(instance->app)) continue;
-
-        if(flipper_application_map_to_memory(instance->app) != FlipperApplicationLoadStatusSuccess)
-            continue;
-
-        const FlipperAppPluginDescriptor* descriptor =
-            flipper_application_plugin_get_descriptor(instance->app);
-
-        if(descriptor == NULL) continue;
-
-        if(strcmp(descriptor->appid, NFC_SUPPORTED_CARD_PLUGIN_APP_ID) != 0) continue;
-        if(descriptor->ep_api_version != NFC_SUPPORTED_CARD_PLUGIN_API_VERSION) continue;
-
-        plugin = descriptor->entry_point;
+        plugin = nfc_supported_cards_get_plugin(instance, instance->file_path);
     } while(plugin == NULL); //-V654
 
     return plugin;
 }
 
-bool nfc_supported_cards_read(NfcDevice* device, Nfc* nfc) {
+void nfc_supported_cards_load_cache(NfcSupportedCards* instance) {
+    furi_assert(instance);
+
+    do {
+        if((instance->load_state == NfcSupportedCardsLoadStateSuccess) ||
+           (instance->load_state == NfcSupportedCardsLoadStateFail))
+            break;
+
+        instance->load_context = nfc_supported_cards_load_context_alloc();
+
+        while(true) {
+            const NfcSupportedCardsPlugin* plugin =
+                nfc_supported_cards_get_next_plugin(instance->load_context);
+            if(plugin == NULL) break; //-V547
+
+            NfcSupportedCardsPluginCache plugin_cache = {}; //-V779
+            plugin_cache.path = furi_string_alloc_set(instance->load_context->file_path);
+            plugin_cache.protocol = plugin->protocol;
+            if(plugin->verify) {
+                plugin_cache.feature |= NfcSupportedCardsPluginFeatureHasVerify;
+            }
+            if(plugin->read) {
+                plugin_cache.feature |= NfcSupportedCardsPluginFeatureHasRead;
+            }
+            if(plugin->parse) {
+                plugin_cache.feature |= NfcSupportedCardsPluginFeatureHasParse;
+            }
+            NfcSupportedCardsPluginCache_push_back(instance->plugins_cache_arr, plugin_cache);
+        }
+
+        nfc_supported_cards_load_context_free(instance->load_context);
+
+        size_t plugins_loaded = NfcSupportedCardsPluginCache_size(instance->plugins_cache_arr);
+        if(plugins_loaded == 0) {
+            FURI_LOG_D(TAG, "Plugins not found");
+            instance->load_state = NfcSupportedCardsLoadStateFail;
+        } else {
+            FURI_LOG_D(TAG, "Loaded %zu plugins", plugins_loaded);
+            instance->load_state = NfcSupportedCardsLoadStateSuccess;
+        }
+
+    } while(false);
+}
+
+bool nfc_supported_cards_read(NfcSupportedCards* instance, NfcDevice* device, Nfc* nfc) {
+    furi_assert(instance);
     furi_assert(device);
     furi_assert(nfc);
 
     bool card_read = false;
-
-    NfcSupportedCards* supported_cards = nfc_supported_cards_alloc();
+    NfcProtocol protocol = nfc_device_get_protocol(device);
 
     do {
-        const NfcSupportedCardsPlugin* plugin =
-            nfc_supported_cards_get_next_plugin(supported_cards);
-        if(plugin == NULL) break; //-V547
+        if(instance->load_state != NfcSupportedCardsLoadStateSuccess) break;
 
-        const NfcProtocol protocol = nfc_device_get_protocol(device); //-V779
-        if(plugin->protocol != protocol) continue;
+        instance->load_context = nfc_supported_cards_load_context_alloc();
 
-        if(plugin->verify) {
-            if(!plugin->verify(nfc)) continue;
+        NfcSupportedCardsPluginCache_it_t iter;
+        for(NfcSupportedCardsPluginCache_it(iter, instance->plugins_cache_arr);
+            !NfcSupportedCardsPluginCache_end_p(iter);
+            NfcSupportedCardsPluginCache_next(iter)) {
+            NfcSupportedCardsPluginCache* plugin_cache = NfcSupportedCardsPluginCache_ref(iter);
+            if(plugin_cache->protocol != protocol) continue;
+            if((plugin_cache->feature & NfcSupportedCardsPluginFeatureHasRead) == 0) continue;
+
+            const NfcSupportedCardsPlugin* plugin =
+                nfc_supported_cards_get_plugin(instance->load_context, plugin_cache->path);
+            if(plugin == NULL) continue;
+
+            if(plugin->verify) {
+                if(!plugin->verify(nfc)) continue;
+            }
+
+            if(plugin->read) {
+                if(plugin->read(nfc, device)) {
+                    card_read = true;
+                    break;
+                }
+            }
         }
 
-        if(plugin->read) {
-            card_read = plugin->read(nfc, device);
-        }
+        nfc_supported_cards_load_context_free(instance->load_context);
+    } while(false);
 
-    } while(!card_read);
-
-    nfc_supported_cards_free(supported_cards);
     return card_read;
 }
 
-bool nfc_supported_cards_parse(const NfcDevice* device, FuriString* parsed_data) {
+bool nfc_supported_cards_parse(
+    NfcSupportedCards* instance,
+    NfcDevice* device,
+    FuriString* parsed_data) {
+    furi_assert(instance);
     furi_assert(device);
     furi_assert(parsed_data);
 
-    bool parsed = false;
-
-    NfcSupportedCards* supported_cards = nfc_supported_cards_alloc();
+    bool card_parsed = false;
+    NfcProtocol protocol = nfc_device_get_protocol(device);
 
     do {
-        const NfcSupportedCardsPlugin* plugin =
-            nfc_supported_cards_get_next_plugin(supported_cards);
-        if(plugin == NULL) break; //-V547
+        if(instance->load_state != NfcSupportedCardsLoadStateSuccess) break;
 
-        const NfcProtocol protocol = nfc_device_get_protocol(device); //-V779
-        if(plugin->protocol != protocol) continue;
+        instance->load_context = nfc_supported_cards_load_context_alloc();
 
-        if(plugin->parse) {
-            parsed = plugin->parse(device, parsed_data);
+        NfcSupportedCardsPluginCache_it_t iter;
+        for(NfcSupportedCardsPluginCache_it(iter, instance->plugins_cache_arr);
+            !NfcSupportedCardsPluginCache_end_p(iter);
+            NfcSupportedCardsPluginCache_next(iter)) {
+            NfcSupportedCardsPluginCache* plugin_cache = NfcSupportedCardsPluginCache_ref(iter);
+            if(plugin_cache->protocol != protocol) continue;
+            if((plugin_cache->feature & NfcSupportedCardsPluginFeatureHasParse) == 0) continue;
+
+            const NfcSupportedCardsPlugin* plugin =
+                nfc_supported_cards_get_plugin(instance->load_context, plugin_cache->path);
+            if(plugin == NULL) continue;
+
+            if(plugin->parse) {
+                if(plugin->parse(device, parsed_data)) {
+                    card_parsed = true;
+                    break;
+                }
+            }
         }
 
-    } while(!parsed);
+        nfc_supported_cards_load_context_free(instance->load_context);
+    } while(false);
 
-    nfc_supported_cards_free(supported_cards);
-    return parsed;
+    return card_parsed;
 }

applications/main/nfc/helpers/nfc_supported_cards.h

@@ -15,6 +15,34 @@
 extern "C" {
 #endif
 
+/**
+ * @brief NfcSupportedCards opaque type definition.
+ */
+typedef struct NfcSupportedCards NfcSupportedCards;
+
+/**
+ * @brief Allocate NfcSupportedCards instance.
+ *
+ * @return pointer to allocated NfcSupportedCards instance.
+ */
+NfcSupportedCards* nfc_supported_cards_alloc();
+
+/**
+ * @brief Delete an NfcSupportedCards instance
+ * 
+ * @param[in] instance pointer to instance to be deleted.
+ */
+void nfc_supported_cards_free(NfcSupportedCards* instance);
+
+/**
+ * @brief Load plugins information to cache.
+ *
+ * @note This function must be called before calling read and parse fanctions.
+ *
+ * @param[in, out] instance pointer to NfcSupportedCards instance.
+ */
+void nfc_supported_cards_load_cache(NfcSupportedCards* instance);
+
 /**
  * @brief Read the card using a custom procedure.
  *
@@ -22,13 +50,14 @@ extern "C" {
  * try to execute the custom read procedure specified in each. Upon first success,
  * no further attempts will be made and the function will return.
  *
+ * @param[in, out] instance pointer to NfcSupportedCards instance.
  * @param[in,out] device pointer to a device instance to hold the read data.
  * @param[in,out] nfc pointer to an Nfc instance.
  * @returns true if the card was successfully read, false otherwise.
  *
  * @see NfcSupportedCardPluginRead for detailed description.
  */
-bool nfc_supported_cards_read(NfcDevice* device, Nfc* nfc);
+bool nfc_supported_cards_read(NfcSupportedCards* instance, NfcDevice* device, Nfc* nfc);
 
 /**
  * @brief Parse raw data into human-readable representation.
@@ -37,13 +66,17 @@ bool nfc_supported_cards_read(NfcDevice* device, Nfc* nfc);
  * try to parse the data according to each implementation. Upon first success,
  * no further attempts will be made and the function will return.
  *
+ * @param[in, out] instance pointer to NfcSupportedCards instance.
  * @param[in] device pointer to a device instance holding the data is to be parsed.
  * @param[out] parsed_data pointer to the string to contain the formatted result.
  * @returns true if the card was successfully parsed, false otherwise.
  *
  * @see NfcSupportedCardPluginParse for detailed description.
  */
-bool nfc_supported_cards_parse(const NfcDevice* device, FuriString* parsed_data);
+bool nfc_supported_cards_parse(
+    NfcSupportedCards* instance,
+    NfcDevice* device,
+    FuriString* parsed_data);
 
 #ifdef __cplusplus
 }

applications/main/nfc/helpers/protocol_support/mf_ultralight/mf_ultralight.c

@@ -12,6 +12,7 @@ enum {
     SubmenuIndexUnlock = SubmenuIndexCommonMax,
     SubmenuIndexUnlockByReader,
     SubmenuIndexUnlockByPassword,
+    SubmenuIndexWrite,
 };
 
 static void nfc_scene_info_on_enter_mf_ultralight(NfcApp* instance) {
@@ -148,6 +149,15 @@ static void nfc_scene_read_and_saved_menu_on_enter_mf_ultralight(NfcApp* instanc
             SubmenuIndexUnlock,
             nfc_protocol_support_common_submenu_callback,
             instance);
+    } else if(
+        data->type == MfUltralightTypeNTAG213 || data->type == MfUltralightTypeNTAG215 ||
+        data->type == MfUltralightTypeNTAG216) {
+        submenu_add_item(
+            submenu,
+            "Write",
+            SubmenuIndexWrite,
+            nfc_protocol_support_common_submenu_callback,
+            instance);
     }
 }
 
@@ -188,6 +198,9 @@ static bool
     if(event == SubmenuIndexUnlock) {
         scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightUnlockMenu);
         return true;
+    } else if(event == SubmenuIndexWrite) {
+        scene_manager_next_scene(instance->scene_manager, NfcSceneMfUltralightWrite);
+        return true;
     }
     return false;
 }

applications/main/nfc/helpers/protocol_support/nfc_protocol_support.c

@@ -8,7 +8,6 @@
 #include "nfc_protocol_support.h"
 
 #include "nfc/nfc_app_i.h"
-#include "nfc/helpers/nfc_supported_cards.h"
 
 #include "nfc_protocol_support_defs.h"
 #include "nfc_protocol_support_gui_common.h"
@@ -157,6 +156,9 @@ static void nfc_protocol_support_scene_read_on_enter(NfcApp* instance) {
         instance->protocols_detected[instance->protocols_detected_selected_idx];
     instance->poller = nfc_poller_alloc(instance->nfc, protocol);
 
+    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewPopup);
+    nfc_supported_cards_load_cache(instance->nfc_supported_cards);
+
     // Start poller with the appropriate callback
     nfc_protocol_support[protocol]->scene_read.on_enter(instance);
 
@@ -177,7 +179,8 @@ static bool nfc_protocol_support_scene_read_on_event(NfcApp* instance, SceneMana
         } else if(event.event == NfcCustomEventPollerIncomplete) {
             nfc_poller_stop(instance->poller);
             nfc_poller_free(instance->poller);
-            bool card_read = nfc_supported_cards_read(instance->nfc_device, instance->nfc);
+            bool card_read = nfc_supported_cards_read(
+                instance->nfc_supported_cards, instance->nfc_device, instance->nfc);
             if(card_read) {
                 notification_message(instance->notifications, &sequence_success);
                 scene_manager_next_scene(instance->scene_manager, NfcSceneReadSuccess);
@@ -306,7 +309,7 @@ static void nfc_protocol_support_scene_read_success_on_enter(NfcApp* instance) {
     Widget* widget = instance->widget;
 
     FuriString* temp_str = furi_string_alloc();
-    if(nfc_supported_cards_parse(instance->nfc_device, temp_str)) {
+    if(nfc_supported_cards_parse(instance->nfc_supported_cards, instance->nfc_device, temp_str)) {
         widget_add_text_scroll_element(
             instance->widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
     } else {

applications/main/nfc/helpers/protocol_support/st25tb/st25tb.c

@@ -29,7 +29,9 @@ static NfcCommand nfc_scene_read_poller_callback_st25tb(NfcGenericEvent event, v
     NfcApp* instance = context;
     const St25tbPollerEvent* st25tb_event = event.event_data;
 
-    if(st25tb_event->type == St25tbPollerEventTypeReady) {
+    if(st25tb_event->type == St25tbPollerEventTypeRequestMode) {
+        st25tb_event->data->mode_request.mode = St25tbPollerModeRead;
+    } else if(st25tb_event->type == St25tbPollerEventTypeSuccess) {
         nfc_device_set_data(
             instance->nfc_device, NfcProtocolSt25tb, nfc_poller_get_data(instance->poller));
         view_dispatcher_send_custom_event(instance->view_dispatcher, NfcCustomEventPollerSuccess);