[FL-2627] Flipper applications: SDK, build and debug system (#1387)

* Added support for running applications from SD card (FAPs - Flipper Application Packages)
* Added plugin_dist target for fbt to build FAPs
* All apps of type FlipperAppType.EXTERNAL and FlipperAppType.PLUGIN are built as FAPs by default
* Updated VSCode configuration for new fbt features - re-deploy stock configuration to use them
* Added debugging support for FAPs with fbt debug & VSCode
* Added public firmware API with automated versioning

Co-authored-by: hedger <hedger@users.noreply.github.com>
Co-authored-by: SG <who.just.the.doctor@gmail.com>
Co-authored-by: あく <alleteam@gmail.com>

applications/system/updater/scenes/updater_scene.c

@@ -0,0 +1,30 @@
+#include "updater_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const updater_on_enter_handlers[])(void*) = {
+#include "updater_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 updater_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "updater_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 updater_on_exit_handlers[])(void* context) = {
+#include "updater_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers updater_scene_handlers = {
+    .on_enter_handlers = updater_on_enter_handlers,
+    .on_event_handlers = updater_on_event_handlers,
+    .on_exit_handlers = updater_on_exit_handlers,
+    .scene_num = UpdaterSceneNum,
+};

applications/system/updater/scenes/updater_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) UpdaterScene##id,
+typedef enum {
+#include "updater_scene_config.h"
+    UpdaterSceneNum,
+} UpdaterScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers updater_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "updater_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 "updater_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 "updater_scene_config.h"
+#undef ADD_SCENE

applications/system/updater/scenes/updater_scene_config.h

@@ -0,0 +1,5 @@
+ADD_SCENE(updater, main, Main)
+#ifndef FURI_RAM_EXEC
+ADD_SCENE(updater, loadcfg, LoadCfg)
+ADD_SCENE(updater, error, Error)
+#endif

applications/system/updater/scenes/updater_scene_error.c

@@ -0,0 +1,65 @@
+#include "../updater_i.h"
+#include "updater_scene.h"
+#include <update_util/update_operation.h>
+
+void updater_scene_error_callback(GuiButtonType result, InputType type, void* context) {
+    furi_assert(context);
+    Updater* updater = context;
+    if(type != InputTypeShort) {
+        return;
+    }
+
+    if(result == GuiButtonTypeLeft) {
+        view_dispatcher_send_custom_event(
+            updater->view_dispatcher, UpdaterCustomEventCancelUpdate);
+    }
+}
+
+void updater_scene_error_on_enter(void* context) {
+    Updater* updater = (Updater*)context;
+
+    widget_add_button_element(
+        updater->widget, GuiButtonTypeLeft, "Exit", updater_scene_error_callback, updater);
+
+    widget_add_string_multiline_element(
+        updater->widget, 64, 13, AlignCenter, AlignCenter, FontPrimary, "Error");
+
+    widget_add_string_multiline_element(
+        updater->widget,
+        64,
+        33,
+        AlignCenter,
+        AlignCenter,
+        FontPrimary,
+        update_operation_describe_preparation_result(updater->preparation_result));
+
+    view_dispatcher_switch_to_view(updater->view_dispatcher, UpdaterViewWidget);
+}
+
+bool updater_scene_error_on_event(void* context, SceneManagerEvent event) {
+    Updater* updater = (Updater*)context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeBack) {
+        view_dispatcher_stop(updater->view_dispatcher);
+        consumed = true;
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case UpdaterCustomEventCancelUpdate:
+            view_dispatcher_stop(updater->view_dispatcher);
+            consumed = true;
+            break;
+        default:
+            break;
+        }
+    }
+
+    return consumed;
+}
+
+void updater_scene_error_on_exit(void* context) {
+    Updater* updater = (Updater*)context;
+
+    widget_reset(updater->widget);
+    free(updater->pending_update);
+}

applications/system/updater/scenes/updater_scene_loadcfg.c

@@ -0,0 +1,107 @@
+#include "../updater_i.h"
+#include "updater_scene.h"
+
+#include <update_util/update_operation.h>
+#include <furi_hal.h>
+
+void updater_scene_loadcfg_apply_callback(GuiButtonType result, InputType type, void* context) {
+    furi_assert(context);
+    Updater* updater = context;
+    if(type != InputTypeShort) {
+        return;
+    }
+
+    if(result == GuiButtonTypeRight) {
+        view_dispatcher_send_custom_event(updater->view_dispatcher, UpdaterCustomEventStartUpdate);
+    } else if(result == GuiButtonTypeLeft) {
+        view_dispatcher_send_custom_event(
+            updater->view_dispatcher, UpdaterCustomEventCancelUpdate);
+    }
+}
+
+void updater_scene_loadcfg_on_enter(void* context) {
+    Updater* updater = (Updater*)context;
+    UpdaterManifestProcessingState* pending_upd = updater->pending_update =
+        malloc(sizeof(UpdaterManifestProcessingState));
+    pending_upd->manifest = update_manifest_alloc();
+
+    if(update_manifest_init(pending_upd->manifest, string_get_cstr(updater->startup_arg))) {
+        widget_add_string_element(
+            updater->widget, 64, 12, AlignCenter, AlignCenter, FontPrimary, "Update");
+
+        widget_add_text_box_element(
+            updater->widget,
+            5,
+            20,
+            118,
+            32,
+            AlignCenter,
+            AlignCenter,
+            string_get_cstr(pending_upd->manifest->version),
+            true);
+
+        widget_add_button_element(
+            updater->widget,
+            GuiButtonTypeRight,
+            "Install",
+            updater_scene_loadcfg_apply_callback,
+            updater);
+    } else {
+        widget_add_string_element(
+            updater->widget, 64, 24, AlignCenter, AlignCenter, FontPrimary, "Invalid manifest");
+    }
+
+    widget_add_button_element(
+        updater->widget,
+        GuiButtonTypeLeft,
+        "Cancel",
+        updater_scene_loadcfg_apply_callback,
+        updater);
+
+    view_dispatcher_switch_to_view(updater->view_dispatcher, UpdaterViewWidget);
+}
+
+bool updater_scene_loadcfg_on_event(void* context, SceneManagerEvent event) {
+    Updater* updater = (Updater*)context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeBack) {
+        view_dispatcher_stop(updater->view_dispatcher);
+        consumed = true;
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case UpdaterCustomEventStartUpdate:
+            updater->preparation_result =
+                update_operation_prepare(string_get_cstr(updater->startup_arg));
+            if(updater->preparation_result == UpdatePrepareResultOK) {
+                furi_hal_power_reset();
+            } else {
+#ifndef FURI_RAM_EXEC
+                scene_manager_next_scene(updater->scene_manager, UpdaterSceneError);
+#endif
+            }
+            consumed = true;
+            break;
+        case UpdaterCustomEventCancelUpdate:
+            view_dispatcher_stop(updater->view_dispatcher);
+            consumed = true;
+            break;
+        default:
+            break;
+        }
+    }
+
+    return consumed;
+}
+
+void updater_scene_loadcfg_on_exit(void* context) {
+    Updater* updater = (Updater*)context;
+
+    if(updater->pending_update) {
+        update_manifest_free(updater->pending_update->manifest);
+        string_clear(updater->pending_update->message);
+    }
+
+    widget_reset(updater->widget);
+    free(updater->pending_update);
+}

applications/system/updater/scenes/updater_scene_main.c

@@ -0,0 +1,101 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <applications.h>
+#include <storage/storage.h>
+
+#include "../updater_i.h"
+#include "../views/updater_main.h"
+#include "updater_scene.h"
+
+static void sd_mount_callback(const void* message, void* context) {
+    Updater* updater = context;
+    const StorageEvent* new_event = message;
+
+    switch(new_event->type) {
+    case StorageEventTypeCardMount:
+        view_dispatcher_send_custom_event(updater->view_dispatcher, UpdaterCustomEventStartUpdate);
+        break;
+    case StorageEventTypeCardUnmount:
+        view_dispatcher_send_custom_event(updater->view_dispatcher, UpdaterCustomEventSdUnmounted);
+        break;
+    default:
+        break;
+    }
+}
+
+void updater_scene_main_on_enter(void* context) {
+    Updater* updater = (Updater*)context;
+    notification_message(updater->notification, &sequence_display_backlight_enforce_on);
+    UpdaterMainView* main_view = updater->main_view;
+
+    FuriPubSubSubscription* sub =
+        furi_pubsub_subscribe(storage_get_pubsub(updater->storage), &sd_mount_callback, updater);
+    updater_main_set_storage_pubsub(main_view, sub);
+
+    /* FIXME: there's a misbehavior in storage subsystem. If we produce heavy load on it before it
+    * fires an SD card event, it'll never do that until the load is lifted. Meanwhile SD card icon
+    * will be missing from UI, however, /ext will be fully operational. So, until it's fixed, this
+    * should remain commented out. */
+    // If (somehow) we started after SD card is mounted, initiate update immediately
+    if(storage_sd_status(updater->storage) == FSE_OK) {
+        view_dispatcher_send_custom_event(updater->view_dispatcher, UpdaterCustomEventStartUpdate);
+    }
+
+    updater_main_set_view_dispatcher(main_view, updater->view_dispatcher);
+    view_dispatcher_switch_to_view(updater->view_dispatcher, UpdaterViewMain);
+}
+
+static void updater_scene_cancel_update() {
+    update_operation_disarm();
+    furi_hal_power_reset();
+}
+
+bool updater_scene_main_on_event(void* context, SceneManagerEvent event) {
+    Updater* updater = (Updater*)context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeTick) {
+        if(!update_task_is_running(updater->update_task)) {
+            if(updater->idle_ticks++ >= (UPDATE_DELAY_OPERATION_ERROR / UPDATER_APP_TICK)) {
+                updater_scene_cancel_update();
+            }
+        } else {
+            updater->idle_ticks = 0;
+        }
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case UpdaterCustomEventStartUpdate:
+        case UpdaterCustomEventRetryUpdate:
+            if(!update_task_is_running(updater->update_task) &&
+               (update_task_get_state(updater->update_task)->stage != UpdateTaskStageCompleted))
+                update_task_start(updater->update_task);
+            consumed = true;
+            break;
+
+        case UpdaterCustomEventCancelUpdate:
+            if(!update_task_is_running(updater->update_task)) {
+                updater_scene_cancel_update();
+            }
+            consumed = true;
+            break;
+
+        case UpdaterCustomEventSdUnmounted:
+            // TODO: error out, stop worker (it's probably dead actually)
+            break;
+        default:
+            break;
+        }
+    }
+
+    return consumed;
+}
+
+void updater_scene_main_on_exit(void* context) {
+    Updater* updater = (Updater*)context;
+
+    notification_message(updater->notification, &sequence_display_backlight_enforce_auto);
+    furi_pubsub_unsubscribe(
+        storage_get_pubsub(updater->storage), updater_main_get_storage_pubsub(updater->main_view));
+
+    scene_manager_set_scene_state(updater->scene_manager, UpdaterSceneMain, 0);
+}