Merge remote-tracking branch 'noproto/nestednonces' into dev

applications/examples/example_number_input/ReadMe.md

@@ -1,7 +1,13 @@
-# Number Input
+# Number Input {#example_number_input}
 
-Simple keyboard that limits user inputs to a full number (integer). Useful to enforce correct entries without the need of intense validations after a user input. 
+Simple keyboard that limits user inputs to a full number (integer). Useful to enforce correct entries without the need for intense validations after a user input. 
 
-Definition of min/max values is required. Numbers are of type int32_t. If negative numbers are allowed withing min - max, an additional button is displayed to switch the sign between + and -. 
+## Source code
 
-It is also possible to define a header text, shown in this example app with the 3 different input options. 
+Source code for this example can be found [here](https://github.com/flipperdevices/flipperzero-firmware/tree/dev/applications/examples/example_number_input).
+
+## General principle
+
+Definition of min/max values is required. Numbers are of type int32_t. If negative numbers are allowed within min - max, an additional button is displayed to switch the sign between + and -. 
+
+It is also possible to define a header text, as shown in this example app with the 3 different input options. 

applications/main/nfc/scenes/nfc_scene_mf_classic_dict_attack.c

@@ -158,6 +158,9 @@ static void nfc_scene_mf_classic_dict_attack_prepare_view(NfcApp* instance) {
                 furi_string_get_cstr(cuid_dict_path),
                 KeysDictModeOpenExisting,
                 sizeof(MfClassicKey));
+
+            furi_string_free(cuid_dict_path);
+
             if(keys_dict_get_total_keys(instance->nfc_dict_context.dict) == 0) {
                 keys_dict_free(instance->nfc_dict_context.dict);
                 state = DictAttackStateUserDictInProgress;

applications/services/loader/loader.c

@@ -309,12 +309,14 @@ static void loader_applications_closed_callback(void* context) {
     furi_message_queue_put(loader->queue, &message, FuriWaitForever);
 }
 
-static void loader_thread_state_callback(FuriThreadState thread_state, void* context) {
+static void
+    loader_thread_state_callback(FuriThread* thread, FuriThreadState thread_state, void* context) {
+    UNUSED(thread);
     furi_assert(context);
 
-    Loader* loader = context;
-
     if(thread_state == FuriThreadStateStopped) {
+        Loader* loader = context;
+
         LoaderMessage message;
         message.type = LoaderMessageTypeAppClosed;
         furi_message_queue_put(loader->queue, &message, FuriWaitForever);

applications/services/region/region.c

@@ -104,19 +104,12 @@ static int32_t region_load_file(void* context) {
     return 0;
 }
 
-static void region_loader_pending_callback(void* context, uint32_t arg) {
-    UNUSED(arg);
-
-    FuriThread* loader = context;
-    furi_thread_join(loader);
-    furi_thread_free(loader);
-}
-
-static void region_loader_state_callback(FuriThreadState state, void* context) {
+static void
+    region_loader_release_callback(FuriThread* thread, FuriThreadState state, void* context) {
     UNUSED(context);
 
     if(state == FuriThreadStateStopped) {
-        furi_timer_pending_callback(region_loader_pending_callback, furi_thread_get_current(), 0);
+        furi_thread_free(thread);
     }
 }
 
@@ -126,7 +119,7 @@ static void region_storage_callback(const void* message, void* context) {
 
     if(event->type == StorageEventTypeCardMount) {
         FuriThread* loader = furi_thread_alloc_ex(NULL, 2048, region_load_file, NULL);
-        furi_thread_set_state_callback(loader, region_loader_state_callback);
+        furi_thread_set_state_callback(loader, region_loader_release_callback);
         furi_thread_start(loader);
     }
 }

applications/services/rpc/rpc.c

@@ -67,7 +67,7 @@ static RpcSystemCallbacks rpc_systems[] = {
 struct RpcSession {
     Rpc* rpc;
 
-    FuriThread* thread;
+    FuriThreadId thread_id;
 
     RpcHandlerDict_t handlers;
     FuriStreamBuffer* stream;
@@ -172,7 +172,7 @@ size_t rpc_session_feed(
 
     size_t bytes_sent = furi_stream_buffer_send(session->stream, encoded_bytes, size, timeout);
 
-    furi_thread_flags_set(furi_thread_get_id(session->thread), RpcEvtNewData);
+    furi_thread_flags_set(session->thread_id, RpcEvtNewData);
 
     return bytes_sent;
 }
@@ -220,7 +220,7 @@ bool rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_t count) {
                     break;
                 } else {
                     /* Save disconnect flag and continue reading buffer */
-                    furi_thread_flags_set(furi_thread_get_id(session->thread), RpcEvtDisconnect);
+                    furi_thread_flags_set(session->thread_id, RpcEvtDisconnect);
                 }
             } else if(flags & RpcEvtNewData) {
                 // Just wake thread up
@@ -347,35 +347,32 @@ static int32_t rpc_session_worker(void* context) {
     return 0;
 }
 
-static void rpc_session_thread_pending_callback(void* context, uint32_t arg) {
-    UNUSED(arg);
-    RpcSession* session = (RpcSession*)context;
-
-    for(size_t i = 0; i < COUNT_OF(rpc_systems); ++i) {
-        if(rpc_systems[i].free) {
-            (rpc_systems[i].free)(session->system_contexts[i]);
-        }
-    }
-    free(session->system_contexts);
-    free(session->decoded_message);
-    RpcHandlerDict_clear(session->handlers);
-    furi_stream_buffer_free(session->stream);
-
-    furi_mutex_acquire(session->callbacks_mutex, FuriWaitForever);
-    if(session->terminated_callback) {
-        session->terminated_callback(session->context);
-    }
-    furi_mutex_release(session->callbacks_mutex);
-
-    furi_mutex_free(session->callbacks_mutex);
-    furi_thread_join(session->thread);
-    furi_thread_free(session->thread);
-    free(session);
-}
-
-static void rpc_session_thread_state_callback(FuriThreadState thread_state, void* context) {
+static void rpc_session_thread_release_callback(
+    FuriThread* thread,
+    FuriThreadState thread_state,
+    void* context) {
     if(thread_state == FuriThreadStateStopped) {
-        furi_timer_pending_callback(rpc_session_thread_pending_callback, context, 0);
+        RpcSession* session = (RpcSession*)context;
+
+        for(size_t i = 0; i < COUNT_OF(rpc_systems); ++i) {
+            if(rpc_systems[i].free) {
+                (rpc_systems[i].free)(session->system_contexts[i]);
+            }
+        }
+        free(session->system_contexts);
+        free(session->decoded_message);
+        RpcHandlerDict_clear(session->handlers);
+        furi_stream_buffer_free(session->stream);
+
+        furi_mutex_acquire(session->callbacks_mutex, FuriWaitForever);
+        if(session->terminated_callback) {
+            session->terminated_callback(session->context);
+        }
+        furi_mutex_release(session->callbacks_mutex);
+
+        furi_mutex_free(session->callbacks_mutex);
+        furi_thread_free(thread);
+        free(session);
     }
 }
 
@@ -407,12 +404,14 @@ RpcSession* rpc_session_open(Rpc* rpc, RpcOwner owner) {
     };
     rpc_add_handler(session, PB_Main_stop_session_tag, &rpc_handler);
 
-    session->thread = furi_thread_alloc_ex("RpcSessionWorker", 3072, rpc_session_worker, session);
+    FuriThread* thread =
+        furi_thread_alloc_ex("RpcSessionWorker", 3072, rpc_session_worker, session);
+    session->thread_id = furi_thread_get_id(thread);
 
-    furi_thread_set_state_context(session->thread, session);
-    furi_thread_set_state_callback(session->thread, rpc_session_thread_state_callback);
+    furi_thread_set_state_context(thread, session);
+    furi_thread_set_state_callback(thread, rpc_session_thread_release_callback);
 
-    furi_thread_start(session->thread);
+    furi_thread_start(thread);
 
     return session;
 }
@@ -424,7 +423,7 @@ void rpc_session_close(RpcSession* session) {
     rpc_session_set_send_bytes_callback(session, NULL);
     rpc_session_set_close_callback(session, NULL);
     rpc_session_set_buffer_is_empty_callback(session, NULL);
-    furi_thread_flags_set(furi_thread_get_id(session->thread), RpcEvtDisconnect);
+    furi_thread_flags_set(session->thread_id, RpcEvtDisconnect);
 }
 
 void rpc_on_system_start(void* p) {

applications/system/updater/util/update_task.c

@@ -395,14 +395,15 @@ bool update_task_open_file(UpdateTask* update_task, FuriString* filename) {
     return open_success;
 }
 
-static void update_task_worker_thread_cb(FuriThreadState state, void* context) {
-    UpdateTask* update_task = context;
+static void
+    update_task_worker_thread_cb(FuriThread* thread, FuriThreadState state, void* context) {
+    UNUSED(context);
 
     if(state != FuriThreadStateStopped) {
         return;
     }
 
-    if(furi_thread_get_return_code(update_task->thread) == UPDATE_TASK_NOERR) {
+    if(furi_thread_get_return_code(thread) == UPDATE_TASK_NOERR) {
         furi_delay_ms(UPDATE_DELAY_OPERATION_OK);
         furi_hal_power_reset();
     }
@@ -427,7 +428,6 @@ UpdateTask* update_task_alloc(void) {
         furi_thread_alloc_ex("UpdateWorker", 5120, NULL, update_task);
 
     furi_thread_set_state_callback(thread, update_task_worker_thread_cb);
-    furi_thread_set_state_context(thread, update_task);
 #ifdef FURI_RAM_EXEC
     UNUSED(update_task_worker_backup_restore);
     furi_thread_set_callback(thread, update_task_worker_flash_writer);