[FL-2957] Unified Info API, App Error, Data Xchange (#1998)

* Update protobuf definitions
* Add Property subsystem entry point function
* Key-based system info and power info function stubs
* Remove unneeded functions
* Working power info
* Working system info
* Replace #defines with string literals
* Remove unneeded field
* Simplify system info formatting
* Refactor output callback handling
* Handle the last info element correctly
* Optimise power info, rename methods
* Add comments
* Add power debug
* Remove unneeded definitions
* Rename some files and functions
* Update protobuf definitions
* Implement App GetError and DataExchange APIs
* Send GetErrorReply with correct command_id
* Add RPC debug app stub
* Add more scenes
* Add warning, increase stack size
* Add receive data exchange scene
* Improve data exchange
* Add notifications
* Update application requirements
* Bump format version for property-based infos
* Correctly reset error text
* RCP: sync protobuf repo to latest release tag

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene.c

@@ -0,0 +1,30 @@
+#include "rpc_debug_app_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const rpc_debug_app_on_enter_handlers[])(void*) = {
+#include "rpc_debug_app_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
+bool (*const rpc_debug_app_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "rpc_debug_app_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
+void (*const rpc_debug_app_on_exit_handlers[])(void* context) = {
+#include "rpc_debug_app_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers rpc_debug_app_scene_handlers = {
+    .on_enter_handlers = rpc_debug_app_on_enter_handlers,
+    .on_event_handlers = rpc_debug_app_on_event_handlers,
+    .on_exit_handlers = rpc_debug_app_on_exit_handlers,
+    .scene_num = RpcDebugAppSceneNum,
+};

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) RpcDebugAppScene##id,
+typedef enum {
+#include "rpc_debug_app_scene_config.h"
+    RpcDebugAppSceneNum,
+} RpcDebugAppScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers rpc_debug_app_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "rpc_debug_app_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_event handlers declaration
+#define ADD_SCENE(prefix, name, id) \
+    bool prefix##_scene_##name##_on_event(void* context, SceneManagerEvent event);
+#include "rpc_debug_app_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* context);
+#include "rpc_debug_app_scene_config.h"
+#undef ADD_SCENE

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_config.h

@@ -0,0 +1,8 @@
+ADD_SCENE(rpc_debug_app, start, Start)
+ADD_SCENE(rpc_debug_app, start_dummy, StartDummy)
+ADD_SCENE(rpc_debug_app, test_app_error, TestAppError)
+ADD_SCENE(rpc_debug_app, test_data_exchange, TestDataExchange)
+ADD_SCENE(rpc_debug_app, input_error_code, InputErrorCode)
+ADD_SCENE(rpc_debug_app, input_error_text, InputErrorText)
+ADD_SCENE(rpc_debug_app, input_data_exchange, InputDataExchange)
+ADD_SCENE(rpc_debug_app, receive_data_exchange, ReceiveDataExchange)

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_input_data_exchange.c

@@ -0,0 +1,40 @@
+#include "../rpc_debug_app.h"
+
+static void rpc_debug_app_scene_input_data_exchange_result_callback(void* context) {
+    RpcDebugApp* app = context;
+    view_dispatcher_send_custom_event(
+        app->view_dispatcher, RpcDebugAppCustomEventInputDataExchange);
+}
+
+void rpc_debug_app_scene_input_data_exchange_on_enter(void* context) {
+    RpcDebugApp* app = context;
+    byte_input_set_header_text(app->byte_input, "Enter data to exchange");
+    byte_input_set_result_callback(
+        app->byte_input,
+        rpc_debug_app_scene_input_data_exchange_result_callback,
+        NULL,
+        app,
+        app->data_store,
+        DATA_STORE_SIZE);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RpcDebugAppViewByteInput);
+}
+
+bool rpc_debug_app_scene_input_data_exchange_on_event(void* context, SceneManagerEvent event) {
+    RpcDebugApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == RpcDebugAppCustomEventInputDataExchange) {
+            rpc_system_app_exchange_data(app->rpc, app->data_store, DATA_STORE_SIZE);
+            scene_manager_previous_scene(app->scene_manager);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void rpc_debug_app_scene_input_data_exchange_on_exit(void* context) {
+    RpcDebugApp* app = context;
+    UNUSED(app);
+}

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_input_error_code.c

@@ -0,0 +1,60 @@
+#include "../rpc_debug_app.h"
+
+static bool rpc_debug_app_scene_input_error_code_validator_callback(
+    const char* text,
+    FuriString* error,
+    void* context) {
+    UNUSED(context);
+
+    for(; *text; ++text) {
+        const char c = *text;
+        if(c < '0' || c > '9') {
+            furi_string_printf(error, "%s", "Please enter\na number!");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static void rpc_debug_app_scene_input_error_code_result_callback(void* context) {
+    RpcDebugApp* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, RpcDebugAppCustomEventInputErrorCode);
+}
+
+void rpc_debug_app_scene_input_error_code_on_enter(void* context) {
+    RpcDebugApp* app = context;
+    strncpy(app->text_store, "666", TEXT_STORE_SIZE);
+    text_input_set_header_text(app->text_input, "Enter error code");
+    text_input_set_validator(
+        app->text_input, rpc_debug_app_scene_input_error_code_validator_callback, NULL);
+    text_input_set_result_callback(
+        app->text_input,
+        rpc_debug_app_scene_input_error_code_result_callback,
+        app,
+        app->text_store,
+        TEXT_STORE_SIZE,
+        true);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RpcDebugAppViewTextInput);
+}
+
+bool rpc_debug_app_scene_input_error_code_on_event(void* context, SceneManagerEvent event) {
+    RpcDebugApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == RpcDebugAppCustomEventInputErrorCode) {
+            rpc_system_app_set_error_code(app->rpc, (uint32_t)atol(app->text_store));
+            scene_manager_previous_scene(app->scene_manager);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void rpc_debug_app_scene_input_error_code_on_exit(void* context) {
+    RpcDebugApp* app = context;
+    text_input_reset(app->text_input);
+    text_input_set_validator(app->text_input, NULL, NULL);
+}

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_input_error_text.c

@@ -0,0 +1,40 @@
+#include "../rpc_debug_app.h"
+
+static void rpc_debug_app_scene_input_error_text_result_callback(void* context) {
+    RpcDebugApp* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, RpcDebugAppCustomEventInputErrorText);
+}
+
+void rpc_debug_app_scene_input_error_text_on_enter(void* context) {
+    RpcDebugApp* app = context;
+    strncpy(app->text_store, "I'm a scary error message!", TEXT_STORE_SIZE);
+    text_input_set_header_text(app->text_input, "Enter error text");
+    text_input_set_result_callback(
+        app->text_input,
+        rpc_debug_app_scene_input_error_text_result_callback,
+        app,
+        app->text_store,
+        TEXT_STORE_SIZE,
+        true);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RpcDebugAppViewTextInput);
+}
+
+bool rpc_debug_app_scene_input_error_text_on_event(void* context, SceneManagerEvent event) {
+    RpcDebugApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == RpcDebugAppCustomEventInputErrorText) {
+            rpc_system_app_set_error_text(app->rpc, app->text_store);
+            scene_manager_previous_scene(app->scene_manager);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void rpc_debug_app_scene_input_error_text_on_exit(void* context) {
+    RpcDebugApp* app = context;
+    text_input_reset(app->text_input);
+}

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_receive_data_exchange.c

@@ -0,0 +1,70 @@
+#include "../rpc_debug_app.h"
+
+static void rpc_debug_app_scene_start_format_hex(
+    const uint8_t* data,
+    size_t data_size,
+    char* buf,
+    size_t buf_size) {
+    furi_assert(data);
+    furi_assert(buf);
+
+    const size_t byte_width = 3;
+    const size_t line_width = 7;
+
+    data_size = MIN(data_size, buf_size / (byte_width + 1));
+
+    for(size_t i = 0; i < data_size; ++i) {
+        char* p = buf + (i * byte_width);
+        char sep = !((i + 1) % line_width) ? '\n' : ' ';
+        snprintf(p, byte_width + 1, "%02X%c", data[i], sep);
+    }
+
+    buf[buf_size - 1] = '\0';
+}
+
+static void rpc_debug_app_scene_receive_data_exchange_callback(
+    const uint8_t* data,
+    size_t data_size,
+    void* context) {
+    RpcDebugApp* app = context;
+    if(data) {
+        rpc_debug_app_scene_start_format_hex(data, data_size, app->text_store, TEXT_STORE_SIZE);
+    } else {
+        strncpy(app->text_store, "<Data empty>", TEXT_STORE_SIZE);
+    }
+    view_dispatcher_send_custom_event(app->view_dispatcher, RpcDebugAppCustomEventRpcDataExchange);
+}
+
+void rpc_debug_app_scene_receive_data_exchange_on_enter(void* context) {
+    RpcDebugApp* app = context;
+    strncpy(app->text_store, "Received data will appear here...", TEXT_STORE_SIZE);
+
+    text_box_set_text(app->text_box, app->text_store);
+    text_box_set_font(app->text_box, TextBoxFontHex);
+
+    rpc_system_app_set_data_exchange_callback(
+        app->rpc, rpc_debug_app_scene_receive_data_exchange_callback, app);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RpcDebugAppViewTextBox);
+}
+
+bool rpc_debug_app_scene_receive_data_exchange_on_event(void* context, SceneManagerEvent event) {
+    RpcDebugApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == RpcDebugAppCustomEventRpcDataExchange) {
+            notification_message(app->notifications, &sequence_blink_cyan_100);
+            notification_message(app->notifications, &sequence_display_backlight_on);
+            text_box_set_text(app->text_box, app->text_store);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void rpc_debug_app_scene_receive_data_exchange_on_exit(void* context) {
+    RpcDebugApp* app = context;
+    text_box_reset(app->text_box);
+    rpc_system_app_set_data_exchange_callback(app->rpc, NULL, NULL);
+}

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_start.c

@@ -0,0 +1,57 @@
+#include "../rpc_debug_app.h"
+
+enum SubmenuIndex {
+    SubmenuIndexTestAppError,
+    SubmenuIndexTestDataExchange,
+};
+
+static void rpc_debug_app_scene_start_submenu_callback(void* context, uint32_t index) {
+    RpcDebugApp* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, index);
+}
+
+void rpc_debug_app_scene_start_on_enter(void* context) {
+    RpcDebugApp* app = context;
+    Submenu* submenu = app->submenu;
+
+    submenu_add_item(
+        submenu,
+        "Test App Error",
+        SubmenuIndexTestAppError,
+        rpc_debug_app_scene_start_submenu_callback,
+        app);
+    submenu_add_item(
+        submenu,
+        "Test Data Exchange",
+        SubmenuIndexTestDataExchange,
+        rpc_debug_app_scene_start_submenu_callback,
+        app);
+
+    submenu_set_selected_item(submenu, SubmenuIndexTestAppError);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RpcDebugAppViewSubmenu);
+}
+
+bool rpc_debug_app_scene_start_on_event(void* context, SceneManagerEvent event) {
+    RpcDebugApp* app = context;
+    SceneManager* scene_manager = app->scene_manager;
+
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        const uint32_t submenu_index = event.event;
+        if(submenu_index == SubmenuIndexTestAppError) {
+            scene_manager_next_scene(scene_manager, RpcDebugAppSceneTestAppError);
+            consumed = true;
+        } else if(submenu_index == SubmenuIndexTestDataExchange) {
+            scene_manager_next_scene(scene_manager, RpcDebugAppSceneTestDataExchange);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void rpc_debug_app_scene_start_on_exit(void* context) {
+    RpcDebugApp* app = context;
+    submenu_reset(app->submenu);
+}

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_start_dummy.c

@@ -0,0 +1,30 @@
+#include "../rpc_debug_app.h"
+
+void rpc_debug_app_scene_start_dummy_on_enter(void* context) {
+    RpcDebugApp* app = context;
+    widget_add_text_box_element(
+        app->widget,
+        0,
+        0,
+        128,
+        64,
+        AlignCenter,
+        AlignCenter,
+        "This application\nis meant to be run\nin \e#RPC\e# mode.",
+        false);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RpcDebugAppViewWidget);
+}
+
+bool rpc_debug_app_scene_start_dummy_on_event(void* context, SceneManagerEvent event) {
+    RpcDebugApp* app = context;
+    UNUSED(app);
+    UNUSED(event);
+
+    bool consumed = false;
+    return consumed;
+}
+
+void rpc_debug_app_scene_start_dummy_on_exit(void* context) {
+    RpcDebugApp* app = context;
+    widget_reset(app->widget);
+}

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_test_app_error.c

@@ -0,0 +1,57 @@
+#include "../rpc_debug_app.h"
+
+typedef enum {
+    SubmenuIndexSetErrorCode,
+    SubmenuIndexSetErrorText,
+} SubmenuIndex;
+
+static void rpc_debug_app_scene_test_app_error_submenu_callback(void* context, uint32_t index) {
+    RpcDebugApp* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, index);
+}
+
+void rpc_debug_app_scene_test_app_error_on_enter(void* context) {
+    RpcDebugApp* app = context;
+    Submenu* submenu = app->submenu;
+
+    submenu_add_item(
+        submenu,
+        "Set Error Code",
+        SubmenuIndexSetErrorCode,
+        rpc_debug_app_scene_test_app_error_submenu_callback,
+        app);
+    submenu_add_item(
+        submenu,
+        "Set Error Text",
+        SubmenuIndexSetErrorText,
+        rpc_debug_app_scene_test_app_error_submenu_callback,
+        app);
+
+    submenu_set_selected_item(submenu, SubmenuIndexSetErrorCode);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RpcDebugAppViewSubmenu);
+}
+
+bool rpc_debug_app_scene_test_app_error_on_event(void* context, SceneManagerEvent event) {
+    RpcDebugApp* app = context;
+    SceneManager* scene_manager = app->scene_manager;
+
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        const uint32_t submenu_index = event.event;
+        if(submenu_index == SubmenuIndexSetErrorCode) {
+            scene_manager_next_scene(scene_manager, RpcDebugAppSceneInputErrorCode);
+            consumed = true;
+        } else if(submenu_index == SubmenuIndexSetErrorText) {
+            scene_manager_next_scene(scene_manager, RpcDebugAppSceneInputErrorText);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void rpc_debug_app_scene_test_app_error_on_exit(void* context) {
+    RpcDebugApp* app = context;
+    submenu_reset(app->submenu);
+}

applications/debug/rpc_debug_app/scenes/rpc_debug_app_scene_test_data_exchange.c

@@ -0,0 +1,58 @@
+#include "../rpc_debug_app.h"
+
+typedef enum {
+    SubmenuIndexSendData,
+    SubmenuIndexReceiveData,
+} SubmenuIndex;
+
+static void
+    rpc_debug_app_scene_test_data_exchange_submenu_callback(void* context, uint32_t index) {
+    RpcDebugApp* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, index);
+}
+
+void rpc_debug_app_scene_test_data_exchange_on_enter(void* context) {
+    RpcDebugApp* app = context;
+    Submenu* submenu = app->submenu;
+
+    submenu_add_item(
+        submenu,
+        "Send Data",
+        SubmenuIndexSendData,
+        rpc_debug_app_scene_test_data_exchange_submenu_callback,
+        app);
+    submenu_add_item(
+        submenu,
+        "Receive Data",
+        SubmenuIndexReceiveData,
+        rpc_debug_app_scene_test_data_exchange_submenu_callback,
+        app);
+
+    submenu_set_selected_item(submenu, SubmenuIndexSendData);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RpcDebugAppViewSubmenu);
+}
+
+bool rpc_debug_app_scene_test_data_exchange_on_event(void* context, SceneManagerEvent event) {
+    RpcDebugApp* app = context;
+    SceneManager* scene_manager = app->scene_manager;
+
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        const uint32_t submenu_index = event.event;
+        if(submenu_index == SubmenuIndexSendData) {
+            scene_manager_next_scene(scene_manager, RpcDebugAppSceneInputDataExchange);
+            consumed = true;
+        } else if(submenu_index == SubmenuIndexReceiveData) {
+            scene_manager_next_scene(scene_manager, RpcDebugAppSceneReceiveDataExchange);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+void rpc_debug_app_scene_test_data_exchange_on_exit(void* context) {
+    RpcDebugApp* app = context;
+    submenu_reset(app->submenu);
+}