[FL-3618] Infrared remote button index support (#3180)

* Do not load all signals at once (Draft)
* Minor cleanup
* Refactor remote renaming
* Improve function signatures
* Rename infrared_remote functions
* Optimise signal loading
* Implement adding signals to remote
* Add read_name() method
* Deprecate a function
* Partially implement deleting signals (draft)
* Use m-array instead of m-list for signal name directory
* Use plain C strings instead of furi_string
* Implement deleting signals
* Implement deleting signals via generalised callback
* Implement renaming signals
* Rename some types
* Some more renaming
* Remove unused type
* Implement inserting signals (internal use)
* Improve InfraredMoveView
* Send an event to move a signal
* Remove unused type
* Implement moving signals
* Implement creating new remotes with one signal
* Un-deprecate and rename a function
* Add InfraredRemote API docs
* Add InfraredSignal API docs
* Better error messages
* Show progress pop-up when moving buttons in a remote
* Copy labels to the InfraredMoveView to avoid pointer invalidation
* Improve file selection scene
* Show progress pop-up when renaming buttons in a remote
* Refactor a scene
* Show progress when deleting a button from remote
* Use a random name for temp files
* Add docs to infrared_brute_force.h
* Rename Infrared type to InfraredApp
* Add docs to infrared_app_i.h
* Deliver event data via a callback
* Bundle event data together with event type
* Change DataExchange behaviour
* Adapt RPC debug app to new API
* Remove rogue output
* Add Doxygen comments to rpc_app.h
* Simplify rpc_app.c code
* Remove superflous parameter
* Do not allocate protobuf messages on the stack
* Fix GetError response
* Support for button indices
* Comment out shallow submodules
* Fix F18 api
* Fix logical error and add more debug output
* fbt: testing unshallow for protobuf
* github: lint&checks: unshallow prior to checks
* Fix a TODO
* github: do not unshallow the unshallowed
* fbt: assets: only attempt to unshallow if cannot describe
* Do not use the name when loading a signal by index (duh)
* Simplify loading infrared signals by name
* Sync with protobuf release
* Infrared: use compact furi_crash macros

Co-authored-by: hedger <hedger@nanode.su>
Co-authored-by: hedger <hedger@users.noreply.github.com>
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

applications/main/ibutton/ibutton.c

@@ -39,21 +39,23 @@ static void ibutton_make_app_folder(iButton* ibutton) {
     furi_record_close(RECORD_STORAGE);
 }
 
-static void ibutton_rpc_command_callback(RpcAppSystemEvent event, void* context) {
+static void ibutton_rpc_command_callback(const RpcAppSystemEvent* event, void* context) {
     furi_assert(context);
     iButton* ibutton = context;
 
-    if(event == RpcAppEventSessionClose) {
+    if(event->type == RpcAppEventTypeSessionClose) {
         view_dispatcher_send_custom_event(
             ibutton->view_dispatcher, iButtonCustomEventRpcSessionClose);
         rpc_system_app_set_callback(ibutton->rpc, NULL, NULL);
         ibutton->rpc = NULL;
-    } else if(event == RpcAppEventAppExit) {
+    } else if(event->type == RpcAppEventTypeAppExit) {
         view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventRpcExit);
-    } else if(event == RpcAppEventLoadFile) {
-        view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventRpcLoad);
+    } else if(event->type == RpcAppEventTypeLoadFile) {
+        furi_assert(event->data.type == RpcAppSystemEventDataTypeString);
+        furi_string_set(ibutton->file_path, event->data.string);
+        view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventRpcLoadFile);
     } else {
-        rpc_system_app_confirm(ibutton->rpc, event, false);
+        rpc_system_app_confirm(ibutton->rpc, false);
     }
 }
 

applications/main/ibutton/ibutton_custom_event.h

@@ -15,7 +15,7 @@ typedef enum {
     iButtonCustomEventWorkerWriteNoDetect,
     iButtonCustomEventWorkerWriteCannotWrite,
 
-    iButtonCustomEventRpcLoad,
+    iButtonCustomEventRpcLoadFile,
     iButtonCustomEventRpcExit,
     iButtonCustomEventRpcSessionClose,
 } iButtonCustomEvent;

applications/main/ibutton/scenes/ibutton_scene_rpc.c

@@ -23,28 +23,23 @@ bool ibutton_scene_rpc_on_event(void* context, SceneManagerEvent event) {
     if(event.type == SceneManagerEventTypeCustom) {
         consumed = true;
 
-        if(event.event == iButtonCustomEventRpcLoad) {
+        if(event.event == iButtonCustomEventRpcLoadFile) {
             bool result = false;
-            const char* file_path = rpc_system_app_get_data(ibutton->rpc);
 
-            if(file_path && (furi_string_empty(ibutton->file_path))) {
-                furi_string_set(ibutton->file_path, file_path);
+            if(ibutton_load_key(ibutton)) {
+                popup_set_text(popup, ibutton->key_name, 82, 32, AlignCenter, AlignTop);
+                view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewPopup);
 
-                if(ibutton_load_key(ibutton)) {
-                    popup_set_text(popup, ibutton->key_name, 82, 32, AlignCenter, AlignTop);
-                    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewPopup);
+                ibutton_notification_message(ibutton, iButtonNotificationMessageEmulateStart);
+                ibutton_worker_emulate_start(ibutton->worker, ibutton->key);
 
-                    ibutton_notification_message(ibutton, iButtonNotificationMessageEmulateStart);
-                    ibutton_worker_emulate_start(ibutton->worker, ibutton->key);
-
-                    result = true;
-                }
+                result = true;
             }
 
-            rpc_system_app_confirm(ibutton->rpc, RpcAppEventLoadFile, result);
+            rpc_system_app_confirm(ibutton->rpc, result);
 
         } else if(event.event == iButtonCustomEventRpcExit) {
-            rpc_system_app_confirm(ibutton->rpc, RpcAppEventAppExit, true);
+            rpc_system_app_confirm(ibutton->rpc, true);
             scene_manager_stop(ibutton->scene_manager);
             view_dispatcher_stop(ibutton->view_dispatcher);
 

applications/main/infrared/infrared_app.c

@@ -44,30 +44,42 @@ static void infrared_tick_event_callback(void* context) {
     scene_manager_handle_tick_event(infrared->scene_manager);
 }
 
-static void infrared_rpc_command_callback(RpcAppSystemEvent event, void* context) {
+static void infrared_rpc_command_callback(const RpcAppSystemEvent* event, void* context) {
     furi_assert(context);
     InfraredApp* infrared = context;
     furi_assert(infrared->rpc_ctx);
 
-    if(event == RpcAppEventSessionClose) {
+    if(event->type == RpcAppEventTypeSessionClose) {
         view_dispatcher_send_custom_event(
             infrared->view_dispatcher, InfraredCustomEventTypeRpcSessionClose);
         rpc_system_app_set_callback(infrared->rpc_ctx, NULL, NULL);
         infrared->rpc_ctx = NULL;
-    } else if(event == RpcAppEventAppExit) {
+    } else if(event->type == RpcAppEventTypeAppExit) {
         view_dispatcher_send_custom_event(
             infrared->view_dispatcher, InfraredCustomEventTypeRpcExit);
-    } else if(event == RpcAppEventLoadFile) {
+    } else if(event->type == RpcAppEventTypeLoadFile) {
+        furi_assert(event->data.type == RpcAppSystemEventDataTypeString);
+        furi_string_set(infrared->file_path, event->data.string);
         view_dispatcher_send_custom_event(
-            infrared->view_dispatcher, InfraredCustomEventTypeRpcLoad);
-    } else if(event == RpcAppEventButtonPress) {
-        view_dispatcher_send_custom_event(
-            infrared->view_dispatcher, InfraredCustomEventTypeRpcButtonPress);
-    } else if(event == RpcAppEventButtonRelease) {
+            infrared->view_dispatcher, InfraredCustomEventTypeRpcLoadFile);
+    } else if(event->type == RpcAppEventTypeButtonPress) {
+        furi_assert(
+            event->data.type == RpcAppSystemEventDataTypeString ||
+            event->data.type == RpcAppSystemEventDataTypeInt32);
+        if(event->data.type == RpcAppSystemEventDataTypeString) {
+            furi_string_set(infrared->button_name, event->data.string);
+            view_dispatcher_send_custom_event(
+                infrared->view_dispatcher, InfraredCustomEventTypeRpcButtonPressName);
+        } else {
+            infrared->app_state.current_button_index = event->data.i32;
+            view_dispatcher_send_custom_event(
+                infrared->view_dispatcher, InfraredCustomEventTypeRpcButtonPressIndex);
+        }
+    } else if(event->type == RpcAppEventTypeButtonRelease) {
         view_dispatcher_send_custom_event(
             infrared->view_dispatcher, InfraredCustomEventTypeRpcButtonRelease);
     } else {
-        rpc_system_app_confirm(infrared->rpc_ctx, event, false);
+        rpc_system_app_confirm(infrared->rpc_ctx, false);
     }
 }
 
@@ -117,6 +129,7 @@ static InfraredApp* infrared_alloc() {
     InfraredApp* infrared = malloc(sizeof(InfraredApp));
 
     infrared->file_path = furi_string_alloc();
+    infrared->button_name = furi_string_alloc();
 
     InfraredAppState* app_state = &infrared->app_state;
     app_state->is_learning_new_remote = false;
@@ -247,6 +260,7 @@ static void infrared_free(InfraredApp* infrared) {
     infrared->gui = NULL;
 
     furi_string_free(infrared->file_path);
+    furi_string_free(infrared->button_name);
 
     free(infrared);
 }

applications/main/infrared/infrared_app_i.h

@@ -121,6 +121,7 @@ struct InfraredApp {
     InfraredProgressView* progress; /**< Custom view for showing brute force progress. */
 
     FuriString* file_path; /**< Full path to the currently loaded file. */
+    FuriString* button_name; /** Name of the button requested in RPC mode. */
     /** Arbitrary text storage for various inputs. */
     char text_store[INFRARED_TEXT_STORE_NUM][INFRARED_TEXT_STORE_SIZE + 1];
     InfraredAppState app_state; /**< Application state. */

applications/main/infrared/infrared_brute_force.c

@@ -128,7 +128,7 @@ void infrared_brute_force_stop(InfraredBruteForce* brute_force) {
 
 bool infrared_brute_force_send_next(InfraredBruteForce* brute_force) {
     furi_assert(brute_force->is_started);
-    const bool success = infrared_signal_search_and_read(
+    const bool success = infrared_signal_search_by_name_and_read(
         brute_force->current_signal,
         brute_force->ff,
         furi_string_get_cstr(brute_force->current_record_name));

applications/main/infrared/infrared_custom_event.h

@@ -15,9 +15,10 @@ enum InfraredCustomEventType {
     InfraredCustomEventTypeButtonSelected,
     InfraredCustomEventTypeBackPressed,
 
-    InfraredCustomEventTypeRpcLoad,
+    InfraredCustomEventTypeRpcLoadFile,
     InfraredCustomEventTypeRpcExit,
-    InfraredCustomEventTypeRpcButtonPress,
+    InfraredCustomEventTypeRpcButtonPressName,
+    InfraredCustomEventTypeRpcButtonPressIndex,
     InfraredCustomEventTypeRpcButtonRelease,
     InfraredCustomEventTypeRpcSessionClose,
 };

applications/main/infrared/infrared_remote.c

@@ -95,10 +95,9 @@ bool infrared_remote_load_signal(
         const char* path = furi_string_get_cstr(remote->path);
         if(!flipper_format_buffered_file_open_existing(ff, path)) break;
 
-        const char* name = infrared_remote_get_signal_name(remote, index);
-
-        if(!infrared_signal_search_and_read(signal, ff, name)) {
-            FURI_LOG_E(TAG, "Failed to load signal '%s' from file '%s'", name, path);
+        if(!infrared_signal_search_by_index_and_read(signal, ff, index)) {
+            const char* signal_name = infrared_remote_get_signal_name(remote, index);
+            FURI_LOG_E(TAG, "Failed to load signal '%s' from file '%s'", signal_name, path);
             break;
         }
 

applications/main/infrared/infrared_signal.c

@@ -266,19 +266,37 @@ bool infrared_signal_read_name(FlipperFormat* ff, FuriString* name) {
     return flipper_format_read_string(ff, INFRARED_SIGNAL_NAME_KEY, name);
 }
 
-bool infrared_signal_search_and_read(InfraredSignal* signal, FlipperFormat* ff, const char* name) {
+bool infrared_signal_search_by_name_and_read(
+    InfraredSignal* signal,
+    FlipperFormat* ff,
+    const char* name) {
     bool success = false;
     FuriString* tmp = furi_string_alloc();
 
-    do {
-        bool is_name_found = false;
-        while(!is_name_found && infrared_signal_read_name(ff, tmp)) { //-V560
-            is_name_found = furi_string_equal(tmp, name);
+    while(infrared_signal_read_name(ff, tmp)) {
+        if(furi_string_equal(tmp, name)) {
+            success = infrared_signal_read_body(signal, ff);
+            break;
         }
-        if(!is_name_found) break; //-V547
-        if(!infrared_signal_read_body(signal, ff)) break; //-V779
-        success = true;
-    } while(false);
+    }
+
+    furi_string_free(tmp);
+    return success;
+}
+
+bool infrared_signal_search_by_index_and_read(
+    InfraredSignal* signal,
+    FlipperFormat* ff,
+    size_t index) {
+    bool success = false;
+    FuriString* tmp = furi_string_alloc();
+
+    for(uint32_t i = 0; infrared_signal_read_name(ff, tmp); ++i) {
+        if(i == index) {
+            success = infrared_signal_read_body(signal, ff);
+            break;
+        }
+    }
 
     furi_string_free(tmp);
     return success;

applications/main/infrared/infrared_signal.h

@@ -162,7 +162,26 @@ bool infrared_signal_read_name(FlipperFormat* ff, FuriString* name);
  * @param[in] name pointer to a zero-terminated string containing the requested signal name.
  * @returns true if a signal was found and successfully read, false otherwise (e.g. the signal was not found).
  */
-bool infrared_signal_search_and_read(InfraredSignal* signal, FlipperFormat* ff, const char* name);
+bool infrared_signal_search_by_name_and_read(
+    InfraredSignal* signal,
+    FlipperFormat* ff,
+    const char* name);
+
+/**
+ * @brief Read a signal with a particular index from a FlipperFormat file into an InfraredSignal instance.
+ *
+ * This function will look for a signal with the given index and if found, attempt to read it.
+ * Same considerations apply as to infrared_signal_read().
+ *
+ * @param[in,out] signal pointer to the instance to be read into.
+ * @param[in,out] ff pointer to the FlipperFormat file instance to read from.
+ * @param[in] index the requested signal index.
+ * @returns true if a signal was found and successfully read, false otherwise (e.g. the signal was not found).
+ */
+bool infrared_signal_search_by_index_and_read(
+    InfraredSignal* signal,
+    FlipperFormat* ff,
+    size_t index);
 
 /**
  * @brief Save a signal contained in an InfraredSignal instance to a FlipperFormat file.

applications/main/infrared/scenes/infrared_scene_remote.c

@@ -1,7 +1,7 @@
 #include "../infrared_app_i.h"
 
 typedef enum {
-    ButtonIndexPlus = -2,
+    ButtonIndexLearn = -2,
     ButtonIndexEdit = -1,
     ButtonIndexNA = 0,
 } ButtonIndex;
@@ -44,7 +44,7 @@ void infrared_scene_remote_on_enter(void* context) {
     button_menu_add_item(
         button_menu,
         "+",
-        ButtonIndexPlus,
+        ButtonIndexLearn,
         infrared_scene_remote_button_menu_callback,
         ButtonMenuItemTypeControl,
         context);
@@ -95,7 +95,7 @@ bool infrared_scene_remote_on_event(void* context, SceneManagerEvent event) {
             if(is_transmitter_idle) {
                 scene_manager_set_scene_state(
                     scene_manager, InfraredSceneRemote, (unsigned)button_index);
-                if(button_index == ButtonIndexPlus) {
+                if(button_index == ButtonIndexLearn) {
                     infrared->app_state.is_learning_new_remote = false;
                     scene_manager_next_scene(scene_manager, InfraredSceneLearn);
                     consumed = true;

applications/main/infrared/scenes/infrared_scene_rpc.c

@@ -1,6 +1,8 @@
 #include "../infrared_app_i.h"
 #include <gui/canvas.h>
 
+#define TAG "InfraredApp"
+
 typedef enum {
     InfraredRpcStateIdle,
     InfraredRpcStateLoaded,
@@ -38,11 +40,9 @@ bool infrared_scene_rpc_on_event(void* context, SceneManagerEvent event) {
             view_dispatcher_stop(infrared->view_dispatcher);
         } else if(event.event == InfraredCustomEventTypePopupClosed) {
             view_dispatcher_stop(infrared->view_dispatcher);
-        } else if(event.event == InfraredCustomEventTypeRpcLoad) {
+        } else if(event.event == InfraredCustomEventTypeRpcLoadFile) {
             bool result = false;
-            const char* arg = rpc_system_app_get_data(infrared->rpc_ctx);
-            if(arg && (state == InfraredRpcStateIdle)) {
-                furi_string_set(infrared->file_path, arg);
+            if(state == InfraredRpcStateIdle) {
                 result = infrared_remote_load(
                     infrared->remote, furi_string_get_cstr(infrared->file_path));
                 if(result) {
@@ -56,20 +56,35 @@ bool infrared_scene_rpc_on_event(void* context, SceneManagerEvent event) {
             popup_set_text(
                 infrared->popup, infrared->text_store[0], 89, 44, AlignCenter, AlignTop);
 
-            rpc_system_app_confirm(infrared->rpc_ctx, RpcAppEventLoadFile, result);
-        } else if(event.event == InfraredCustomEventTypeRpcButtonPress) {
+            rpc_system_app_confirm(infrared->rpc_ctx, result);
+        } else if(
+            event.event == InfraredCustomEventTypeRpcButtonPressName ||
+            event.event == InfraredCustomEventTypeRpcButtonPressIndex) {
             bool result = false;
-            const char* arg = rpc_system_app_get_data(infrared->rpc_ctx);
-            if(arg && (state == InfraredRpcStateLoaded)) {
-                size_t button_index = 0;
-                if(infrared_remote_get_signal_index(infrared->remote, arg, &button_index)) {
-                    infrared_tx_start_button_index(infrared, button_index);
-                    result = true;
+            if(state == InfraredRpcStateLoaded) {
+                if(event.event == InfraredCustomEventTypeRpcButtonPressName) {
+                    const char* button_name = furi_string_get_cstr(infrared->button_name);
+                    size_t index;
+                    const bool index_found =
+                        infrared_remote_get_signal_index(infrared->remote, button_name, &index);
+                    infrared->app_state.current_button_index =
+                        index_found ? (signed)index : InfraredButtonIndexNone;
+                    FURI_LOG_D(TAG, "Sending signal with name \"%s\"", button_name);
+                } else {
+                    FURI_LOG_D(
+                        TAG,
+                        "Sending signal with index \"%ld\"",
+                        infrared->app_state.current_button_index);
+                }
+                if(infrared->app_state.current_button_index != InfraredButtonIndexNone) {
+                    infrared_tx_start_button_index(
+                        infrared, infrared->app_state.current_button_index);
                     scene_manager_set_scene_state(
                         infrared->scene_manager, InfraredSceneRpc, InfraredRpcStateSending);
+                    result = true;
                 }
             }
-            rpc_system_app_confirm(infrared->rpc_ctx, RpcAppEventButtonRelease, result);
+            rpc_system_app_confirm(infrared->rpc_ctx, result);
         } else if(event.event == InfraredCustomEventTypeRpcButtonRelease) {
             bool result = false;
             if(state == InfraredRpcStateSending) {
@@ -78,11 +93,11 @@ bool infrared_scene_rpc_on_event(void* context, SceneManagerEvent event) {
                 scene_manager_set_scene_state(
                     infrared->scene_manager, InfraredSceneRpc, InfraredRpcStateLoaded);
             }
-            rpc_system_app_confirm(infrared->rpc_ctx, RpcAppEventButtonRelease, result);
+            rpc_system_app_confirm(infrared->rpc_ctx, result);
         } else if(event.event == InfraredCustomEventTypeRpcExit) {
             scene_manager_stop(infrared->scene_manager);
             view_dispatcher_stop(infrared->view_dispatcher);
-            rpc_system_app_confirm(infrared->rpc_ctx, RpcAppEventAppExit, true);
+            rpc_system_app_confirm(infrared->rpc_ctx, true);
         } else if(event.event == InfraredCustomEventTypeRpcSessionClose) {
             scene_manager_stop(infrared->scene_manager);
             view_dispatcher_stop(infrared->view_dispatcher);

applications/main/lfrfid/lfrfid.c

@@ -13,21 +13,23 @@ static bool lfrfid_debug_back_event_callback(void* context) {
     return scene_manager_handle_back_event(app->scene_manager);
 }
 
-static void rpc_command_callback(RpcAppSystemEvent rpc_event, void* context) {
+static void rpc_command_callback(const RpcAppSystemEvent* event, void* context) {
     furi_assert(context);
     LfRfid* app = (LfRfid*)context;
 
-    if(rpc_event == RpcAppEventSessionClose) {
+    if(event->type == RpcAppEventTypeSessionClose) {
         view_dispatcher_send_custom_event(app->view_dispatcher, LfRfidEventRpcSessionClose);
         // Detach RPC
         rpc_system_app_set_callback(app->rpc_ctx, NULL, NULL);
         app->rpc_ctx = NULL;
-    } else if(rpc_event == RpcAppEventAppExit) {
+    } else if(event->type == RpcAppEventTypeAppExit) {
         view_dispatcher_send_custom_event(app->view_dispatcher, LfRfidEventExit);
-    } else if(rpc_event == RpcAppEventLoadFile) {
+    } else if(event->type == RpcAppEventTypeLoadFile) {
+        furi_assert(event->data.type == RpcAppSystemEventDataTypeString);
+        furi_string_set(app->file_path, event->data.string);
         view_dispatcher_send_custom_event(app->view_dispatcher, LfRfidEventRpcLoadFile);
     } else {
-        rpc_system_app_confirm(app->rpc_ctx, rpc_event, false);
+        rpc_system_app_confirm(app->rpc_ctx, false);
     }
 }
 

applications/main/lfrfid/scenes/lfrfid_scene_rpc.c

@@ -24,17 +24,15 @@ bool lfrfid_scene_rpc_on_event(void* context, SceneManagerEvent event) {
     if(event.type == SceneManagerEventTypeCustom) {
         consumed = true;
         if(event.event == LfRfidEventExit) {
-            rpc_system_app_confirm(app->rpc_ctx, RpcAppEventAppExit, true);
+            rpc_system_app_confirm(app->rpc_ctx, true);
             scene_manager_stop(app->scene_manager);
             view_dispatcher_stop(app->view_dispatcher);
         } else if(event.event == LfRfidEventRpcSessionClose) {
             scene_manager_stop(app->scene_manager);
             view_dispatcher_stop(app->view_dispatcher);
         } else if(event.event == LfRfidEventRpcLoadFile) {
-            const char* arg = rpc_system_app_get_data(app->rpc_ctx);
             bool result = false;
-            if(arg && (app->rpc_state == LfRfidRpcStateIdle)) {
-                furi_string_set(app->file_path, arg);
+            if(app->rpc_state == LfRfidRpcStateIdle) {
                 if(lfrfid_load_key_data(app, app->file_path, false)) {
                     lfrfid_worker_start_thread(app->lfworker);
                     lfrfid_worker_emulate_start(app->lfworker, (LFRFIDProtocol)app->protocol_id);
@@ -48,7 +46,7 @@ bool lfrfid_scene_rpc_on_event(void* context, SceneManagerEvent event) {
                     result = true;
                 }
             }
-            rpc_system_app_confirm(app->rpc_ctx, RpcAppEventLoadFile, result);
+            rpc_system_app_confirm(app->rpc_ctx, result);
         }
     }
     return consumed;

applications/main/nfc/helpers/nfc_custom_event.h

@@ -21,7 +21,7 @@ typedef enum {
     NfcCustomEventTextInputDone,
     NfcCustomEventDictAttackDone,
 
-    NfcCustomEventRpcLoad,
+    NfcCustomEventRpcLoadFile,
     NfcCustomEventRpcExit,
     NfcCustomEventRpcSessionClose,
 

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

@@ -694,15 +694,17 @@ static bool nfc_protocol_support_scene_rpc_on_event(NfcApp* instance, SceneManag
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == NfcCustomEventRpcLoad && instance->rpc_state == NfcRpcStateIdle) {
-            furi_string_set(instance->file_path, rpc_system_app_get_data(instance->rpc_ctx));
-            const bool load_success = nfc_load_file(instance, instance->file_path, false);
-            if(load_success) {
-                nfc_protocol_support_scene_rpc_setup_ui_and_emulate(instance);
+        if(event.event == NfcCustomEventRpcLoadFile) {
+            bool success = false;
+            if(instance->rpc_state == NfcRpcStateIdle) {
+                if(nfc_load_file(instance, instance->file_path, false)) {
+                    nfc_protocol_support_scene_rpc_setup_ui_and_emulate(instance);
+                    success = true;
+                }
             }
-            rpc_system_app_confirm(instance->rpc_ctx, RpcAppEventLoadFile, load_success);
+            rpc_system_app_confirm(instance->rpc_ctx, success);
         } else if(event.event == NfcCustomEventRpcExit) {
-            rpc_system_app_confirm(instance->rpc_ctx, RpcAppEventAppExit, true);
+            rpc_system_app_confirm(instance->rpc_ctx, true);
             scene_manager_stop(instance->scene_manager);
             view_dispatcher_stop(instance->view_dispatcher);
         } else if(event.event == NfcCustomEventRpcSessionClose) {

applications/main/nfc/nfc_app.c

@@ -14,22 +14,24 @@ bool nfc_back_event_callback(void* context) {
     return scene_manager_handle_back_event(nfc->scene_manager);
 }
 
-static void nfc_app_rpc_command_callback(RpcAppSystemEvent rpc_event, void* context) {
+static void nfc_app_rpc_command_callback(const RpcAppSystemEvent* event, void* context) {
     furi_assert(context);
     NfcApp* nfc = (NfcApp*)context;
 
     furi_assert(nfc->rpc_ctx);
 
-    if(rpc_event == RpcAppEventSessionClose) {
+    if(event->type == RpcAppEventTypeSessionClose) {
         view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventRpcSessionClose);
         rpc_system_app_set_callback(nfc->rpc_ctx, NULL, NULL);
         nfc->rpc_ctx = NULL;
-    } else if(rpc_event == RpcAppEventAppExit) {
+    } else if(event->type == RpcAppEventTypeAppExit) {
         view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventRpcExit);
-    } else if(rpc_event == RpcAppEventLoadFile) {
-        view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventRpcLoad);
+    } else if(event->type == RpcAppEventTypeLoadFile) {
+        furi_assert(event->data.type == RpcAppSystemEventDataTypeString);
+        furi_string_set(nfc->file_path, event->data.string);
+        view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventRpcLoadFile);
     } else {
-        rpc_system_app_confirm(nfc->rpc_ctx, rpc_event, false);
+        rpc_system_app_confirm(nfc->rpc_ctx, false);
     }
 }
 

applications/main/subghz/scenes/subghz_scene_rpc.c

@@ -33,13 +33,13 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
         if(event.event == SubGhzCustomEventSceneExit) {
             scene_manager_stop(subghz->scene_manager);
             view_dispatcher_stop(subghz->view_dispatcher);
-            rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventAppExit, true);
+            rpc_system_app_confirm(subghz->rpc_ctx, true);
         } else if(event.event == SubGhzCustomEventSceneRpcSessionClose) {
             scene_manager_stop(subghz->scene_manager);
             view_dispatcher_stop(subghz->view_dispatcher);
         } else if(event.event == SubGhzCustomEventSceneRpcButtonPress) {
             bool result = false;
-            if((state == SubGhzRpcStateLoaded)) {
+            if(state == SubGhzRpcStateLoaded) {
                 switch(
                     subghz_txrx_tx_start(subghz->txrx, subghz_txrx_get_fff_data(subghz->txrx))) {
                 case SubGhzTxRxStartTxStateErrorOnlyRx:
@@ -61,7 +61,7 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
                     break;
                 }
             }
-            rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventButtonPress, result);
+            rpc_system_app_confirm(subghz->rpc_ctx, result);
         } else if(event.event == SubGhzCustomEventSceneRpcButtonRelease) {
             bool result = false;
             if(state == SubGhzRpcStateTx) {
@@ -70,15 +70,13 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
                 result = true;
             }
             state = SubGhzRpcStateIdle;
-            rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventButtonRelease, result);
+            rpc_system_app_confirm(subghz->rpc_ctx, result);
         } else if(event.event == SubGhzCustomEventSceneRpcLoad) {
             bool result = false;
-            const char* arg = rpc_system_app_get_data(subghz->rpc_ctx);
-            if(arg && (state == SubGhzRpcStateIdle)) {
-                if(subghz_key_load(subghz, arg, false)) {
+            if(state == SubGhzRpcStateIdle) {
+                if(subghz_key_load(subghz, furi_string_get_cstr(subghz->file_path), false)) {
                     scene_manager_set_scene_state(
                         subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateLoaded);
-                    furi_string_set(subghz->file_path, arg);
                     result = true;
                     FuriString* file_name;
                     file_name = furi_string_alloc();
@@ -97,7 +95,7 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
                     rpc_system_app_set_error_text(subghz->rpc_ctx, "Cannot parse file");
                 }
             }
-            rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventLoadFile, result);
+            rpc_system_app_confirm(subghz->rpc_ctx, result);
         }
     }
     return consumed;

applications/main/subghz/subghz.c

@@ -20,29 +20,31 @@ void subghz_tick_event_callback(void* context) {
     scene_manager_handle_tick_event(subghz->scene_manager);
 }
 
-static void subghz_rpc_command_callback(RpcAppSystemEvent event, void* context) {
+static void subghz_rpc_command_callback(const RpcAppSystemEvent* event, void* context) {
     furi_assert(context);
     SubGhz* subghz = context;
 
     furi_assert(subghz->rpc_ctx);
 
-    if(event == RpcAppEventSessionClose) {
+    if(event->type == RpcAppEventTypeSessionClose) {
         view_dispatcher_send_custom_event(
             subghz->view_dispatcher, SubGhzCustomEventSceneRpcSessionClose);
         rpc_system_app_set_callback(subghz->rpc_ctx, NULL, NULL);
         subghz->rpc_ctx = NULL;
-    } else if(event == RpcAppEventAppExit) {
+    } else if(event->type == RpcAppEventTypeAppExit) {
         view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneExit);
-    } else if(event == RpcAppEventLoadFile) {
+    } else if(event->type == RpcAppEventTypeLoadFile) {
+        furi_assert(event->data.type == RpcAppSystemEventDataTypeString);
+        furi_string_set(subghz->file_path, event->data.string);
         view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneRpcLoad);
-    } else if(event == RpcAppEventButtonPress) {
+    } else if(event->type == RpcAppEventTypeButtonPress) {
         view_dispatcher_send_custom_event(
             subghz->view_dispatcher, SubGhzCustomEventSceneRpcButtonPress);
-    } else if(event == RpcAppEventButtonRelease) {
+    } else if(event->type == RpcAppEventTypeButtonRelease) {
         view_dispatcher_send_custom_event(
             subghz->view_dispatcher, SubGhzCustomEventSceneRpcButtonRelease);
     } else {
-        rpc_system_app_confirm(subghz->rpc_ctx, event, false);
+        rpc_system_app_confirm(subghz->rpc_ctx, false);
     }
 }