name refractoring changes

scenes/uhf_scene_card_menu.c

@@ -5,13 +5,13 @@ enum SubmenuIndex {
     SubmenuIndexChangeKey,
 };
 
-void uhf_scene_card_menu_submenu_callback(void* context, uint32_t index) {
-    UHFApp* uhf_app = context;
+void uhf_scene_card_menu_submenu_callback(void* ctx, uint32_t index) {
+    UHFApp* uhf_app = ctx;
     view_dispatcher_send_custom_event(uhf_app->view_dispatcher, index);
 }
 
-void uhf_scene_card_menu_on_enter(void* context) {
-    UHFApp* uhf_app = context;
+void uhf_scene_card_menu_on_enter(void* ctx) {
+    UHFApp* uhf_app = ctx;
 
     Submenu* submenu = uhf_app->submenu;
 
@@ -30,12 +30,11 @@ void uhf_scene_card_menu_on_enter(void* context) {
     view_dispatcher_switch_to_view(uhf_app->view_dispatcher, UHFViewMenu);
 }
 
-bool uhf_scene_card_menu_on_event(void* context, SceneManagerEvent event) {
-    UHFApp* uhf_app = context;
+bool uhf_scene_card_menu_on_event(void* ctx, SceneManagerEvent event) {
+    UHFApp* uhf_app = ctx;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        FURI_LOG_E("LOG", "%lu", event.event);
         if(event.event == SubmenuIndexSave) {
             scene_manager_set_scene_state(
                 uhf_app->scene_manager, UHFSceneCardMenu, SubmenuIndexSave);
@@ -56,8 +55,8 @@ bool uhf_scene_card_menu_on_event(void* context, SceneManagerEvent event) {
     return consumed;
 }
 
-void uhf_scene_card_menu_on_exit(void* context) {
-    UHFApp* uhf_app = context;
+void uhf_scene_card_menu_on_exit(void* ctx) {
+    UHFApp* uhf_app = ctx;
 
     submenu_reset(uhf_app->submenu);
 }

scenes/uhf_scene_read_tag.c

@@ -12,7 +12,6 @@ void uhf_read_tag_worker_callback(UHFWorkerEvent event, void* ctx) {
 }
 
 void uhf_scene_read_tag_on_enter(void* ctx) {
-    // FURI_LOG_E("33", "uhf_scene_read_tag_on_enter was called!");
     UHFApp* uhf_app = ctx;
     dolphin_deed(DolphinDeedNfcRead);
 
@@ -34,7 +33,6 @@ bool uhf_scene_read_tag_on_event(void* ctx, SceneManagerEvent event) {
     UHFApp* uhf_app = ctx;
     bool consumed = false;
     if(event.event == UHFCustomEventWorkerExit) {
-        FURI_LOG_E("uhf_scene_read_tag_on_event", "event was registered");
         scene_manager_next_scene(uhf_app->scene_manager, UHFSceneReadTagSuccess);
         consumed = true;
     }

scenes/uhf_scene_read_tag_success.c

@@ -17,7 +17,7 @@ void uhf_scene_read_card_success_widget_callback(GuiButtonType result, InputType
 void uhf_scene_read_tag_success_on_enter(void* ctx) {
     UHFApp* uhf_app = ctx;
 
-    const uint8_t* read_data = uhf_app->worker->data->data->data;
+    const uint8_t* read_data = uhf_app->worker->response_data->head->data;
 
     widget_add_string_element(
         uhf_app->widget, 32, 5, AlignLeft, AlignCenter, FontPrimary, "Read Success");
@@ -77,7 +77,6 @@ bool uhf_scene_read_tag_success_on_event(void* ctx, SceneManagerEvent event) {
     UHFApp* uhf_app = ctx;
     bool consumed = false;
     if(event.event == SceneManagerEventTypeBack) {
-        // FURI_LOG_E("36", "Back button was pressed");
         uhf_app->worker->state = UHFWorkerStateStop;
     }
     if(event.type == SceneManagerEventTypeCustom) {

scenes/uhf_scene_save_name.c

@@ -45,7 +45,7 @@ void uhf_scene_save_name_on_enter(void* context) {
 
 bool uhf_scene_save_name_on_event(void* context, SceneManagerEvent event) {
     UHFApp* uhf_app = context;
-    UHFResponseData* uhf_data_save = uhf_app->worker->data;
+    UHFResponseData* uhf_data_save = uhf_app->worker->response_data;
     bool consumed = false;
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == UHFCustomEventTextInputDone) {

scenes/uhf_scene_start.c

@@ -27,7 +27,6 @@ bool uhf_scene_start_on_event(void* ctx, SceneManagerEvent event) {
     UHFApp* uhf_app = ctx;
     bool consumed = false;
     if(event.type == SceneManagerEventTypeCustom) {
-        // FURI_LOG_E("scene_start_on_event", "%lu", event.event);
         if(event.event == SubmenuIndexRead) {
             scene_manager_set_scene_state(uhf_app->scene_manager, UHFSceneStart, SubmenuIndexRead);
             scene_manager_next_scene(uhf_app->scene_manager, UHFSceneReadTag);

scenes/uhf_scene_verify.c

@@ -52,10 +52,10 @@ bool uhf_scene_verify_on_event(void* ctx, SceneManagerEvent event) {
             if(verify_success) {
                 widget_reset(uhf_app->widget);
                 furi_string_reset(temp_str);
-                UHFResponseData* response_data = uhf_app->worker->data;
-                UHFData* hardware_version = uhf_response_data_get_uhf_data(response_data, 0);
-                UHFData* software_version = uhf_response_data_get_uhf_data(response_data, 1);
-                UHFData* manufacturer = uhf_response_data_get_uhf_data(response_data, 2);
+                UHFResponseData* uhf_response_data = uhf_app->worker->response_data;
+                UHFData* hardware_version = uhf_response_data_get_uhf_data(uhf_response_data, 0);
+                UHFData* software_version = uhf_response_data_get_uhf_data(uhf_response_data, 1);
+                UHFData* manufacturer = uhf_response_data_get_uhf_data(uhf_response_data, 2);
                 uint offset = 6;
                 widget_add_string_element(
                     uhf_app->widget, 64, 5, AlignCenter, AlignCenter, FontPrimary, "Module Info");

uhf_app.c

@@ -52,7 +52,7 @@ bool uhf_save_read_data(UHFResponseData* uhf_response_data, Storage* storage, co
     if(!flipper_format_write_header_cstr(file, uhf_file_header, uhf_file_version)) return false;
     // write epc bank
     if(!flipper_format_write_hex(
-           file, "EPC", uhf_response_data->data->data, uhf_response_data->data->length))
+           file, "EPC", uhf_response_data->head->data, uhf_response_data->head->length))
         return false;
     furi_string_free(temp_str);
     flipper_format_free(file);

uhf_app_i.h

@@ -26,9 +26,6 @@
 #include "uhf_worker.h"
 #include <uhf_rfid_icons.h>
 
-#define UHF_FILE_HEADER            \
-    "Filetype: Flipper uhf data\n" \
-    "Version: 1"
 #define UHF_TEXT_STORE_SIZE 128
 #define UHF_APPS_DATA_FOLDER EXT_PATH("apps_data")
 #define UHF_APPS_STORAGE_FOLDER \

uhf_data.c

@@ -35,35 +35,36 @@ void uhf_data_reset(UHFData* uhf_data) {
 }
 
 void uhf_data_free(UHFData* uhf_data) {
-    if(uhf_data != NULL) {
-        while(uhf_data != NULL) {
-            UHFData* next = uhf_data->next;
-            free(uhf_data);
-            uhf_data = next;
-        }
+    if(uhf_data == NULL) return;
+    while(uhf_data != NULL) {
+        UHFData* next = uhf_data->next;
+        free(uhf_data);
+        uhf_data = next;
     }
 }
 
 UHFResponseData* uhf_response_data_alloc() {
     UHFResponseData* uhf_response_data = (UHFResponseData*)malloc(sizeof(UHFResponseData));
-    uhf_response_data->data = uhf_data_alloc();
+    uhf_response_data->head = uhf_data_alloc();
+    uhf_response_data->tail = uhf_response_data->head;
     uhf_response_data->size = 1;
     return uhf_response_data;
 }
 
 UHFData* uhf_response_data_add_new_uhf_data(UHFResponseData* uhf_response_data) {
-    UHFData* next = uhf_response_data->data;
-    while(next->next != NULL) {
-        next = next->next;
+    UHFData* temp = uhf_response_data->head;
+    while(temp->next != NULL) {
+        temp = temp->next;
     }
-    next->next = uhf_data_alloc();
+    temp->next = uhf_data_alloc();
     uhf_response_data->size++;
-    return next->next;
+    uhf_response_data->tail = temp->next;
+    return temp->next;
 }
 
 UHFData* uhf_response_data_get_uhf_data(UHFResponseData* uhf_response_data, uint index) {
     if(uhf_response_data == NULL || uhf_response_data->size <= index) return NULL;
-    UHFData* uhf_data = uhf_response_data->data;
+    UHFData* uhf_data = uhf_response_data->head;
     if(index == 0) return uhf_data;
     while(uhf_data != NULL && index >= 1) {
         uhf_data = uhf_data->next;
@@ -72,7 +73,16 @@ UHFData* uhf_response_data_get_uhf_data(UHFResponseData* uhf_response_data, uint
     return uhf_data;
 }
 
+void uhf_response_data_reset(UHFResponseData* uhf_response_data) {
+    uhf_data_reset(uhf_response_data->head);
+    if(uhf_response_data->size == 1) {
+        return;
+    }
+    uhf_data_free(uhf_response_data->head->next);
+    uhf_response_data->size = 1;
+}
+
 void uhf_response_data_free(UHFResponseData* uhf_response_data) {
-    uhf_data_free(uhf_response_data->data);
+    uhf_data_free(uhf_response_data->head);
     free(uhf_response_data);
 }

uhf_data.h

@@ -14,7 +14,8 @@ typedef struct UHFData {
 } UHFData;
 
 typedef struct UHFResponseData {
-    UHFData* data;
+    UHFData* head;
+    UHFData* tail;
     size_t size;
 
 } UHFResponseData;
@@ -27,4 +28,5 @@ void uhf_data_free(UHFData* uhf_data);
 UHFResponseData* uhf_response_data_alloc();
 UHFData* uhf_response_data_add_new_uhf_data(UHFResponseData* uhf_response_data);
 UHFData* uhf_response_data_get_uhf_data(UHFResponseData* uhf_response_data, uint index);
+void uhf_response_data_reset(UHFResponseData* uhf_response_data);
 void uhf_response_data_free(UHFResponseData* uhf_response_data);

uhf_worker.c

@@ -11,11 +11,13 @@ void module_rx_callback(UartIrqEvent event, uint8_t data, void* ctx) {
 
 // yrm100 module commands
 UHFWorkerEvent verify_module_connected(UHFWorker* uhf_worker) {
-    UHFResponseData* uhf_response_data = uhf_worker->data;
-    UHFData* hardware_version = uhf_response_data->data;
-    uhf_data_reset(hardware_version);
+    UHFResponseData* uhf_response_data = uhf_worker->response_data;
+    uhf_response_data_reset(uhf_response_data);
+    FURI_LOG_E("log", "freeing done");
+    UHFData* hardware_version = uhf_response_data->head;
     UHFData* software_version = uhf_response_data_add_new_uhf_data(uhf_response_data);
     UHFData* manufacturer = uhf_response_data_add_new_uhf_data(uhf_response_data);
+    FURI_LOG_E("log", "alloc done");
     furi_hal_uart_set_br(FuriHalUartIdUSART1, DEFAULT_BAUD_RATE);
     // read hardware version
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, module_rx_callback, hardware_version);
@@ -29,16 +31,16 @@ UHFWorkerEvent verify_module_connected(UHFWorker* uhf_worker) {
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, module_rx_callback, manufacturer);
     furi_hal_uart_tx(FuriHalUartIdUSART1, CMD_MANUFACTURERS.cmd, CMD_MANUFACTURERS.length);
     furi_delay_ms(150);
-
-    if(!hardware_version->end) { //|| !software_version->end || !manufacturer->end) {
+    FURI_LOG_E("log", "done sending tx");
+    if(!hardware_version->end || !software_version->end || !manufacturer->end) {
         return UHFWorkerEventFail;
     }
     return UHFWorkerEventSuccess;
 }
 
 UHFWorkerEvent read_single_card(UHFWorker* uhf_worker) {
-    UHFResponseData* uhf_response_data = uhf_worker->data;
-    UHFData* uhf_data = uhf_response_data->data;
+    UHFResponseData* uhf_response_data = uhf_worker->response_data;
+    UHFData* uhf_data = uhf_response_data->head;
     furi_hal_uart_set_br(FuriHalUartIdUSART1, DEFAULT_BAUD_RATE);
     furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, module_rx_callback, uhf_data);
     uhf_data_reset(uhf_data);
@@ -76,7 +78,7 @@ int32_t uhf_worker_task(void* ctx) {
 UHFWorker* uhf_worker_alloc() {
     UHFWorker* uhf_worker = (UHFWorker*)malloc(sizeof(UHFWorker));
     uhf_worker->thread = furi_thread_alloc_ex("UHFWorker", 8 * 1024, uhf_worker_task, uhf_worker);
-    uhf_worker->data = uhf_response_data_alloc();
+    uhf_worker->response_data = uhf_response_data_alloc();
     uhf_worker->callback = NULL;
     uhf_worker->ctx = NULL;
     return uhf_worker;
@@ -110,6 +112,6 @@ void uhf_worker_stop(UHFWorker* uhf_worker) {
 void uhf_worker_free(UHFWorker* uhf_worker) {
     furi_assert(uhf_worker);
     furi_thread_free(uhf_worker->thread);
-    uhf_response_data_free(uhf_worker->data);
+    uhf_response_data_free(uhf_worker->response_data);
     free(uhf_worker);
 }

uhf_worker.h

@@ -30,7 +30,7 @@ typedef void (*UHFWorkerCallback)(UHFWorkerEvent event, void* ctx);
 
 typedef struct UHFWorker {
     FuriThread* thread;
-    UHFResponseData* data;
+    UHFResponseData* response_data;
     UHFWorkerCallback callback;
     UHFWorkerState state;
     void* ctx;