V1.0 push

Author: acegoal07

README.md

@@ -1 +1,3 @@
-# FlipperZero_NFC_Comparator
+# FlipperZero_NFC_Comparator
+
+This is a simple tool to compare a stored NFC card against a physical card using a Flipper Zero device as of the moment it just checks the UID and protocol but i would like to add support for checking more variables to confirm how similar the NFC cards are.

application.fam

@@ -5,9 +5,9 @@ App(
     entry_point="nfc_comparator_main",
     stack_size=4 * 1024,
     fap_category="NFC",
-    fap_version="0.1",
+    fap_version="1.0",
     fap_icon="assets/Comparator_10px.png",
-    fap_description="A app to check if a physical NFC card is the same as a saved one",
+    fap_description="A tool to check if a physical NFC card is the same as a saved one",
     fap_author="acegoal07",
     fap_weburl="https://github.com/acegoal07/FlipperZero_NFC_Comparator",
     fap_icon_assets="assets",

lib/reader_worker/nfc_comparator_reader_worker.c

@@ -11,21 +11,22 @@ NfcComparatorReaderWorker* nfc_comparator_reader_worker_alloc() {
       4096,
       nfc_comparator_reader_worker_task,
       nfc_comparator_reader_worker);
+   nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Stopped;
    return nfc_comparator_reader_worker;
 }
 
 void nfc_comparator_reader_worker_free(void* context) {
    NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
    furi_assert(nfc_comparator_reader_worker);
    nfc_free(nfc_comparator_reader_worker->nfc);
-   nfc_device_free(nfc_comparator_reader_worker->loaded_nfc_card);
    nfc_scanner_free(nfc_comparator_reader_worker->nfc_scanner);
    furi_thread_free(nfc_comparator_reader_worker->thread);
    free(nfc_comparator_reader_worker);
 }
 
 void nfc_comparator_reader_worker_scanner_callback(NfcScannerEvent event, void* context) {
    NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
+   furi_assert(nfc_comparator_reader_worker);
    switch(event.type) {
    case NfcScannerEventTypeDetected:
       nfc_comparator_reader_worker->protocol = event.data.protocols;
@@ -38,6 +39,7 @@ void nfc_comparator_reader_worker_scanner_callback(NfcScannerEvent event, void*
 
 NfcCommand nfc_comparator_reader_worker_poller_callback(NfcGenericEvent event, void* context) {
    NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
+   furi_assert(nfc_comparator_reader_worker);
    UNUSED(event);
    NfcCommand command = NfcCommandStop;
    nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Comparing;
@@ -70,78 +72,90 @@ int32_t nfc_comparator_reader_worker_task(void* context) {
    while(nfc_comparator_reader_worker->state == NfcComparatorReaderWorkerState_Polling) {
       furi_delay_ms(100);
    }
+
    nfc_poller_stop(nfc_poller);
 
-   NfcDeviceData* nfc_device_data = (NfcDeviceData*)nfc_poller_get_data(nfc_poller);
    NfcDevice* data = nfc_device_alloc();
-   nfc_device_set_data(data, nfc_comparator_reader_worker->protocol[0], nfc_device_data);
-
-   if(nfc_device_get_protocol_name(nfc_device_get_protocol(data)) ==
-      nfc_device_get_protocol_name(
-         nfc_device_get_protocol(nfc_comparator_reader_worker->loaded_nfc_card))) {
-      nfc_comparator_reader_worker->compare_checks->protocol = true;
-   } else {
-      nfc_comparator_reader_worker->compare_checks->protocol = false;
-   }
+   nfc_device_set_data(
+      data,
+      nfc_comparator_reader_worker->protocol[0],
+      (NfcDeviceData*)nfc_poller_get_data(nfc_poller));
+
+   nfc_comparator_reader_worker->compare_checks.protocol =
+      nfc_device_get_protocol_name(nfc_device_get_protocol(data)) ==
+            nfc_device_get_protocol_name(
+               nfc_device_get_protocol(nfc_comparator_reader_worker->loaded_nfc_card)) ?
+         true :
+         false;
 
    nfc_poller_free(nfc_poller);
 
    size_t poller_uid_len = 0;
-   const uint8_t* uid = nfc_device_get_uid(data, &poller_uid_len);
+   const uint8_t* poller_uid = nfc_device_get_uid(data, &poller_uid_len);
    FuriString* poller_uid_str = furi_string_alloc();
    for(size_t i = 0; i < poller_uid_len; i++) {
-      char uid_str[3];
-      snprintf(uid_str, sizeof(uid_str), "%02X", uid[i]);
-      furi_string_cat(poller_uid_str, uid_str);
+      furi_string_utf8_push(poller_uid_str, poller_uid[i]);
    }
 
+   nfc_device_free(data);
+
    size_t loaded_uid_len = 0;
    const uint8_t* loaded_uid =
       nfc_device_get_uid(nfc_comparator_reader_worker->loaded_nfc_card, &loaded_uid_len);
    FuriString* loaded_uid_str = furi_string_alloc();
    for(size_t i = 0; i < loaded_uid_len; i++) {
-      char uid_str[3];
-      snprintf(uid_str, sizeof(uid_str), "%02X", loaded_uid[i]);
-      furi_string_cat(loaded_uid_str, uid_str);
+      furi_string_utf8_push(loaded_uid_str, loaded_uid[i]);
    }
 
-   if(furi_string_cmpi(poller_uid_str, loaded_uid_str) == 0) {
-      nfc_comparator_reader_worker->compare_checks->uid = true;
-   } else {
-      nfc_comparator_reader_worker->compare_checks->uid = false;
-   }
+   nfc_comparator_reader_worker->compare_checks.uid =
+      furi_string_cmpi(loaded_uid_str, poller_uid_str) == 0 ? true : false;
 
    furi_string_free(poller_uid_str);
    furi_string_free(loaded_uid_str);
 
+   nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Stopped;
+
    return 0;
 }
 
 void nfc_comparator_reader_worker_set_compare_nfc_device(void* context, NfcDevice* nfc_device) {
    NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
+   furi_assert(nfc_comparator_reader_worker);
    nfc_comparator_reader_worker->loaded_nfc_card = nfc_device;
 }
 
-bool nfc_comparator_reader_worker_is_done(void* context) {
+bool nfc_comparator_reader_worker_is_running(void* context) {
    NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
-   return nfc_comparator_reader_worker->state == NfcComparatorReaderWorkerState_Stopped;
+   return nfc_comparator_reader_worker->state != NfcComparatorReaderWorkerState_Stopped;
 }
 
-NfcComparatorReaderWorkerCompareChecks*
-   nfc_comparator_reader_worker_get_compare_checks(void* context) {
+NfcComparatorReaderWorkerState nfc_comparator_reader_worker_get_state(void* context) {
    NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
-   return nfc_comparator_reader_worker->compare_checks;
+   furi_assert(nfc_comparator_reader_worker);
+   return nfc_comparator_reader_worker->state;
+}
+
+void nfc_comparator_reader_worker_stop(void* context) {
+   NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
+   furi_assert(nfc_comparator_reader_worker);
+   if(nfc_comparator_reader_worker->state != NfcComparatorReaderWorkerState_Stopped) {
+      nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Stopped;
+   }
+   furi_thread_join(nfc_comparator_reader_worker->thread);
 }
 
 void nfc_comparator_reader_worker_start(void* context) {
    NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
    furi_assert(nfc_comparator_reader_worker);
-   furi_thread_start(nfc_comparator_reader_worker->thread);
+   if(nfc_comparator_reader_worker->state == NfcComparatorReaderWorkerState_Stopped) {
+      nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Scanning;
+      furi_thread_start(nfc_comparator_reader_worker->thread);
+   }
 }
 
-void nfc_comparator_reader_worker_stop(void* context) {
+NfcComparatorReaderWorkerCompareChecks
+   nfc_comparator_reader_worker_get_compare_checks(void* context) {
    NfcComparatorReaderWorker* nfc_comparator_reader_worker = context;
    furi_assert(nfc_comparator_reader_worker);
-   nfc_comparator_reader_worker->state = NfcComparatorReaderWorkerState_Stopped;
-   furi_thread_join(nfc_comparator_reader_worker->thread);
+   return nfc_comparator_reader_worker->compare_checks;
 }

lib/reader_worker/nfc_comparator_reader_worker.h

@@ -18,7 +18,6 @@ typedef struct {
    bool protocol;
 } NfcComparatorReaderWorkerCompareChecks;
 
-
 typedef struct {
    Nfc* nfc;
    FuriThread* thread;
@@ -27,18 +26,20 @@ typedef struct {
    NfcDevice* loaded_nfc_card;
    NfcPoller* nfc_poller;
    NfcScanner* nfc_scanner;
-   NfcComparatorReaderWorkerCompareChecks* compare_checks;
+   NfcComparatorReaderWorkerCompareChecks compare_checks;
 } NfcComparatorReaderWorker;
 
 NfcComparatorReaderWorker* nfc_comparator_reader_worker_alloc();
 void nfc_comparator_reader_worker_free(void* context);
-void nfc_comparator_reader_worker_start(void* context);
-void nfc_comparator_reader_worker_stop(void* context);
 
 void nfc_comparator_reader_worker_scanner_callback(NfcScannerEvent event, void* context);
 NfcCommand nfc_comparator_reader_worker_poller_callback(NfcGenericEvent event, void* context);
 int32_t nfc_comparator_reader_worker_task(void* context);
 void nfc_comparator_reader_worker_set_compare_nfc_device(void* context, NfcDevice* nfc_device);
 
-bool nfc_comparator_reader_worker_is_done(void* context);
-NfcComparatorReaderWorkerCompareChecks* nfc_comparator_reader_worker_get_compare_checks(void* context);
+bool nfc_comparator_reader_worker_is_running(void* context);
+NfcComparatorReaderWorkerState nfc_comparator_reader_worker_get_state(void* context);
+void nfc_comparator_reader_worker_stop(void* context);
+void nfc_comparator_reader_worker_start(void* context);
+NfcComparatorReaderWorkerCompareChecks
+   nfc_comparator_reader_worker_get_compare_checks(void* context);

nfc_comparator.c

@@ -61,7 +61,9 @@ static void nfc_comparator_free(NfcComparator* nfc_comparator) {
    submenu_free(nfc_comparator->submenu);
    file_browser_free(nfc_comparator->file_browser);
    furi_string_free(nfc_comparator->file_browser_output);
-   nfc_device_free(nfc_comparator->loaded_nfc_card);
+   if(nfc_comparator->loaded_nfc_card) {
+      nfc_device_free(nfc_comparator->loaded_nfc_card);
+   }
    popup_free(nfc_comparator->popup);
 
    free(nfc_comparator);

nfc_comparator.h

@@ -41,7 +41,6 @@ typedef struct {
    FuriString* file_browser_output;
    Popup* popup;
    NfcDevice* loaded_nfc_card;
-   NfcComparatorReaderWorkerCompareChecks* compare_results;
 } NfcComparator;
 
 #define NFC_ITEM_LOCATION "/ext/nfc/"

scenes/nfc_comparator_scene_comparator.c

@@ -0,0 +1,69 @@
+
+#include "../nfc_comparator.h"
+
+void nfc_comparator_comparator_menu_callback(void* context, uint32_t index) {
+   NfcComparator* nfc_comparator = context;
+   scene_manager_handle_custom_event(nfc_comparator->scene_manager, index);
+}
+
+void nfc_comparator_comparator_scene_on_enter(void* context) {
+   NfcComparator* nfc_comparator = context;
+   furi_assert(nfc_comparator);
+
+   popup_set_context(nfc_comparator->popup, nfc_comparator);
+   view_dispatcher_switch_to_view(nfc_comparator->view_dispatcher, NfcComparatorView_Popup);
+
+   NfcComparatorReaderWorker* worker = nfc_comparator_reader_worker_alloc();
+   nfc_comparator_reader_worker_set_compare_nfc_device(worker, nfc_comparator->loaded_nfc_card);
+   nfc_comparator_reader_worker_start(worker);
+
+   while(nfc_comparator_reader_worker_is_running(worker)) {
+      switch(nfc_comparator_reader_worker_get_state(worker)) {
+      case NfcComparatorReaderWorkerState_Scanning:
+         popup_set_header(nfc_comparator->popup, "Scanning....", 64, 5, AlignCenter, AlignTop);
+         break;
+      case NfcComparatorReaderWorkerState_Polling:
+         popup_set_header(nfc_comparator->popup, "Polling....", 64, 5, AlignCenter, AlignTop);
+         break;
+      case NfcComparatorReaderWorkerState_Comparing:
+         popup_set_header(nfc_comparator->popup, "Comparing....", 64, 5, AlignCenter, AlignTop);
+         break;
+      default:
+         break;
+      }
+      furi_delay_ms(100);
+   }
+   nfc_comparator_reader_worker_stop(worker);
+
+   popup_set_header(nfc_comparator->popup, "Compare Results", 64, 5, AlignCenter, AlignTop);
+
+   NfcComparatorReaderWorkerCompareChecks checks =
+      nfc_comparator_reader_worker_get_compare_checks(worker);
+   nfc_comparator_reader_worker_free(worker);
+
+   FuriString* comparator = furi_string_alloc();
+   furi_string_printf(
+      comparator,
+      "UID: %s\nProtocol: %s",
+      checks.uid ? "Match" : "Mismatch",
+      checks.protocol ? "Match" : "Mismatch");
+
+   char result_buffer[158];
+   strncpy(result_buffer, furi_string_get_cstr(comparator), sizeof(result_buffer) - 1);
+
+   furi_string_free(comparator);
+
+   popup_set_text(nfc_comparator->popup, result_buffer, 64, 30, AlignCenter, AlignCenter);
+}
+
+bool nfc_comparator_comparator_scene_on_event(void* context, SceneManagerEvent event) {
+   UNUSED(context);
+   UNUSED(event);
+   bool consumed = false;
+   return consumed;
+}
+
+void nfc_comparator_comparator_scene_on_exit(void* context) {
+   NfcComparator* nfc_comparator = context;
+   popup_reset(nfc_comparator->popup);
+}

scenes/nfc_comparator_scene_config.h

@@ -1,3 +1,3 @@
 ADD_SCENE(nfc_comparator, main_menu, MainMenu)
 ADD_SCENE(nfc_comparator, select_nfc_card, SelectNfcCard)
-ADD_SCENE(nfc_comparator, results, Results)
+ADD_SCENE(nfc_comparator, comparator, Comparator)

scenes/nfc_comparator_scene_main_menu.c

@@ -2,7 +2,7 @@
 #include "../nfc_comparator.h"
 
 typedef enum {
-   NfcComparatorMainMenu_Start,
+   NfcComparatorMainMenu_StartComparator,
    NfcComparatorMainMenu_SelectNfcCard
 } NfcComparatorMainMenuMenuSelection;
 
@@ -20,8 +20,8 @@ void nfc_comparator_main_menu_scene_on_enter(void* context) {
 
    submenu_add_lockable_item(
       nfc_comparator->submenu,
-      "Start",
-      NfcComparatorMainMenu_Start,
+      "Start Comparator",
+      NfcComparatorMainMenu_StartComparator,
       nfc_comparator_main_menu_menu_callback,
       nfc_comparator,
       !nfc_comparator->loaded_nfc_card,
@@ -34,6 +34,8 @@ void nfc_comparator_main_menu_scene_on_enter(void* context) {
       nfc_comparator_main_menu_menu_callback,
       nfc_comparator);
 
+   submenu_add_item(nfc_comparator->submenu, "By acegoal07", 0, NULL, NULL);
+
    view_dispatcher_switch_to_view(nfc_comparator->view_dispatcher, NfcComparatorView_Submenu);
 }
 
@@ -42,21 +44,10 @@ bool nfc_comparator_main_menu_scene_on_event(void* context, SceneManagerEvent ev
    bool consumed = false;
    if(event.type == SceneManagerEventTypeCustom) {
       switch(event.event) {
-      case NfcComparatorMainMenu_Start: {
-         NfcComparatorReaderWorker* worker = nfc_comparator_reader_worker_alloc();
-         nfc_comparator_reader_worker_set_compare_nfc_device(
-            worker, nfc_comparator->loaded_nfc_card);
-         nfc_comparator_reader_worker_start(worker);
-         while(!nfc_comparator_reader_worker_is_done(worker)) {
-            furi_delay_ms(100);
-         }
-         nfc_comparator_reader_worker_stop(worker);
-         nfc_comparator->compare_results = nfc_comparator_reader_worker_get_compare_checks(worker);
-         nfc_comparator_reader_worker_free(worker);
-         scene_manager_next_scene(nfc_comparator->scene_manager, NfcComparatorScene_Results);
+      case NfcComparatorMainMenu_StartComparator:
+         scene_manager_next_scene(nfc_comparator->scene_manager, NfcComparatorScene_Comparator);
          consumed = true;
          break;
-      }
       case NfcComparatorMainMenu_SelectNfcCard:
          scene_manager_next_scene(nfc_comparator->scene_manager, NfcComparatorScene_SelectNfcCard);
          consumed = true;