[FL-2263] Flasher service & RAM exec (#1006)

* WIP on stripping fw
* Compact FW build - use RAM_EXEC=1 COMPACT=1 DEBUG=0
* Fixed uninitialized storage struct; small fixes to compact fw
* Flasher srv w/mocked flash ops
* Fixed typos & accomodated FFF changes
* Alternative fw startup branch
* Working load & jmp to RAM fw
* +manifest processing for stage loader; + crc verification for stage payload
* Fixed questionable code & potential leaks
* Lowered screen update rate; added radio stack update stubs; working dfu write
* Console EP with manifest & stage validation
* Added microtar lib; minor ui fixes for updater
* Removed microtar
* Removed mtar #2
* Added a better version of microtar
* TAR archive api; LFS backup & restore core
* Recursive backup/restore
* LFS worker thread
* Added system apps to loader - not visible in UI; full update process with restarts
* Typo fix
* Dropped BL & f6; tooling for updater WIP
* Minor py fixes
* Minor fixes to make it build after merge
* Ported flash workaround from BL + fixed visuals
* Minor cleanup
* Chmod + loader app search fix
* Python linter fix
* Removed usb stuff & float read support for staged loader == -10% of binary size
* Added backup/restore & update pb requests
* Added stub impl to RPC for backup/restore/update commands
* Reworked TAR to use borrowed Storage api; slightly reduced build size by removing `static string`; hidden update-related RPC behind defines
* Moved backup&restore to storage
* Fixed new message types
* Backup/restore/update RPC impl
* Moved furi_hal_crc to LL; minor fixes
* CRC HAL rework to LL
* Purging STM HAL
* Brought back minimal DFU boot mode (no gui); additional crc state checks
* Added splash screen, BROKEN usb function
* Clock init rework WIP
* Stripped graphics from DFU mode
* Temp fix for unused static fun
* WIP update picker - broken!
* Fixed UI
* Bumping version
* Fixed RTC setup
* Backup to update folder instead of ext root
* Removed unused scenes & more usb remnants from staged loader
* CI updates
* Fixed update bundle name
* Temporary restored USB handler
* Attempt to prevent .text corruption
* Comments on how I spent this Saturday
* Added update file icon
* Documentation updates
* Moved common code to lib folder
* Storage: more unit tests
* Storage: blocking dir open, differentiate file and dir when freed.
* Major refactoring; added input processing to updater to allow retrying on failures (not very useful prob). Added API for extraction of thread return value
* Removed re-init check for manifest
* Changed low-level path manipulation to toolbox/path.h; makefile cleanup; tiny fix in lint.py
* Increased update worker stack size
* Text fixes in backup CLI
* Displaying number of update stages to run; removed timeout in handling errors
* Bumping version
* Added thread cleanup for spawner thread
* Updated build targets to exclude firmware bundle from 'ALL'
* Fixed makefile for update_package; skipping VCP init for update mode (ugly)
* Switched github build from ALL to update_package
* Added +x for dist_update.sh
* Cli: add total heap size to "free" command
* Moved (RAM) suffix to build version instead of git commit no.
* DFU comment
* Some fixes suggested by clang-tidy
* Fixed recursive PREFIX macro
* Makefile: gather all new rules in updater namespace. FuriHal: rename bootloader to boot, isr safe delays
* Github: correct build target name in firmware build
* FuriHal: move target switch to boot
* Makefile: fix firmware flash
* Furi, FuriHal: move kernel start to furi, early init
* Drop bootloader related stuff
* Drop cube. Drop bootloader linker script.
* Renamed update_hl, moved constants to #defines
* Moved update-related boot mode to separate bitfield
* Reworked updater cli to single entry point; fixed crash on tar cleanup
* Added Python replacement for dist shell scripts
* Linter fixes for dist.py +x
* Fixes for environment suffix
* Dropped bash scripts
* Added dirty build flag to version structure & interfaces
* Version string escapes
* Fixed flag logic in dist.py; added support for App instances being imported and not terminating the whole program
* Fixed fw address in ReadMe.md
* Rpc: fix crash on double screen start
* Return back original boot behavior and fix jump to system bootloader
* Cleanup code, add error sequence for RTC
* Update firmware readme
* FuriHal: drop boot, restructure RTC registers usage and add header register check
* Furi goes first
* Toolchain: add ccache support
* Renamed update bundle dir

Co-authored-by: DrZlo13 <who.just.the.doctor@gmail.com>
Co-authored-by: あく <alleteam@gmail.com>

applications/updater/cli/updater_cli.c

@@ -0,0 +1,134 @@
+
+#include <furi.h>
+#include <furi_hal.h>
+#include <m-string.h>
+#include <cli/cli.h>
+#include <storage/storage.h>
+#include <loader/loader.h>
+#include <toolbox/path.h>
+#include <toolbox/tar/tar_archive.h>
+#include <toolbox/args.h>
+#include <update_util/update_manifest.h>
+#include <update_util/lfs_backup.h>
+#include <update_util/update_operation.h>
+
+typedef void (*cmd_handler)(string_t args);
+typedef struct {
+    const char* command;
+    const cmd_handler handler;
+} CliSubcommand;
+
+static void updater_cli_install(string_t manifest_path) {
+    printf("Verifying update package at '%s'\r\n", string_get_cstr(manifest_path));
+
+    UpdatePrepareResult result = update_operation_prepare(string_get_cstr(manifest_path));
+    if(result != UpdatePrepareResultOK) {
+        printf(
+            "Error: %s. Stopping update.\r\n",
+            update_operation_describe_preparation_result(result));
+        return;
+    }
+    printf("OK.\r\nRestarting to apply update. BRB\r\n");
+    osDelay(100);
+    furi_hal_power_reset();
+}
+
+static void updater_cli_backup(string_t args) {
+    printf("Backup /int to '%s'\r\n", string_get_cstr(args));
+    Storage* storage = furi_record_open("storage");
+    bool success = lfs_backup_create(storage, string_get_cstr(args));
+    furi_record_close("storage");
+    printf("Result: %s\r\n", success ? "OK" : "FAIL");
+}
+
+static void updater_cli_restore(string_t args) {
+    printf("Restore /int from '%s'\r\n", string_get_cstr(args));
+    Storage* storage = furi_record_open("storage");
+    bool success = lfs_backup_unpack(storage, string_get_cstr(args));
+    furi_record_close("storage");
+    printf("Result: %s\r\n", success ? "OK" : "FAIL");
+}
+
+static void updater_cli_help(string_t args) {
+    UNUSED(args);
+    printf("Commands:\r\n"
+           "\tinstall /ext/update/PACKAGE/update.fuf - verify & apply update package\r\n"
+           "\tbackup /ext/path/to/backup.tar - create internal storage backup\r\n"
+           "\trestore /ext/path/to/backup.tar - restore internal storage backup\r\n");
+}
+
+static const CliSubcommand update_cli_subcommands[] = {
+    {.command = "install", .handler = updater_cli_install},
+    {.command = "backup", .handler = updater_cli_backup},
+    {.command = "restore", .handler = updater_cli_restore},
+    {.command = "help", .handler = updater_cli_help},
+};
+
+static void updater_cli_ep(Cli* cli, string_t args, void* context) {
+    string_t subcommand;
+    string_init(subcommand);
+    if(!args_read_string_and_trim(args, subcommand) || string_empty_p(args)) {
+        updater_cli_help(args);
+        string_clear(subcommand);
+        return;
+    }
+    for(size_t idx = 0; idx < COUNT_OF(update_cli_subcommands); ++idx) {
+        const CliSubcommand* subcmd_def = &update_cli_subcommands[idx];
+        if(string_cmp_str(subcommand, subcmd_def->command) == 0) {
+            string_clear(subcommand);
+            subcmd_def->handler(args);
+            return;
+        }
+    }
+    string_clear(subcommand);
+    updater_cli_help(args);
+}
+
+static int32_t updater_spawner_thread_worker(void* arg) {
+    Loader* loader = furi_record_open("loader");
+    loader_start(loader, "UpdaterApp", NULL);
+    furi_record_close("loader");
+    return 0;
+}
+
+static void updater_spawner_thread_cleanup(FuriThreadState state, void* context) {
+    FuriThread* thread = context;
+    if(state == FuriThreadStateStopped) {
+        furi_thread_free(thread);
+    }
+}
+
+static void updater_start_app() {
+    FuriHalRtcBootMode mode = furi_hal_rtc_get_boot_mode();
+    if((mode != FuriHalRtcBootModePreUpdate) && (mode != FuriHalRtcBootModePostUpdate)) {
+        return;
+    }
+
+    /* We need to spawn a separate thread, because these callbacks are executed 
+     * inside loader process, at startup. 
+     * So, accessing its record would cause a deadlock 
+     */
+    FuriThread* thread = furi_thread_alloc();
+
+    furi_thread_set_name(thread, "UpdateAppSpawner");
+    furi_thread_set_stack_size(thread, 768);
+    furi_thread_set_callback(thread, updater_spawner_thread_worker);
+    furi_thread_set_state_callback(thread, updater_spawner_thread_cleanup);
+    furi_thread_set_state_context(thread, thread);
+    furi_thread_start(thread);
+}
+
+void updater_on_system_start() {
+#ifdef SRV_CLI
+    Cli* cli = (Cli*)furi_record_open("cli");
+    cli_add_command(cli, "update", CliCommandFlagDefault, updater_cli_ep, NULL);
+    furi_record_close("cli");
+#else
+    UNUSED(updater_cli_ep);
+#endif
+#ifndef FURI_RAM_EXEC
+    updater_start_app();
+#else
+    UNUSED(updater_start_app);
+#endif
+}

applications/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/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/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/updater/scenes/updater_scene_error.c

@@ -0,0 +1,65 @@
+#include "updater/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/updater/scenes/updater_scene_loadcfg.c

@@ -0,0 +1,105 @@
+#include "updater/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_string_multiline_element(
+            updater->widget,
+            64,
+            32,
+            AlignCenter,
+            AlignCenter,
+            FontSecondary,
+            string_get_cstr(pending_upd->manifest->version));
+
+        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/updater/scenes/updater_scene_main.c

@@ -0,0 +1,106 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <applications.h>
+#include <storage/storage.h>
+
+#include "updater/updater_i.h"
+#include "updater/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;
+    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_restart_to_postupdate() {
+    furi_hal_rtc_set_boot_mode(FuriHalRtcBootModePostUpdate);
+    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_restart_to_postupdate();
+            }
+        } else {
+            updater->idle_ticks = 0;
+        }
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case UpdaterCustomEventStartUpdate:
+            if(!update_task_is_running(updater->update_task) &&
+               update_task_init(updater->update_task)) {
+                update_task_start(updater->update_task);
+            }
+            consumed = true;
+            break;
+
+        case UpdaterCustomEventRetryUpdate:
+            if(!update_task_is_running(updater->update_task) &&
+               (update_task_get_state(updater->update_task)->stage != UpdateTaskStageComplete))
+                update_task_start(updater->update_task);
+            consumed = true;
+            break;
+
+        case UpdaterCustomEventCancelUpdate:
+            if(!update_task_is_running(updater->update_task)) {
+                updater_scene_restart_to_postupdate();
+            }
+            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;
+
+    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);
+}

applications/updater/updater.c

@@ -0,0 +1,132 @@
+#include "scenes/updater_scene.h"
+#include "updater_i.h"
+
+#include <storage/storage.h>
+#include <gui/view_dispatcher.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include <portmacro.h>
+#include <stdint.h>
+
+static bool updater_custom_event_callback(void* context, uint32_t event) {
+    furi_assert(context);
+    Updater* updater = (Updater*)context;
+    return scene_manager_handle_custom_event(updater->scene_manager, event);
+}
+
+static void updater_tick_event_callback(void* context) {
+    furi_assert(context);
+    Updater* app = context;
+    scene_manager_handle_tick_event(app->scene_manager);
+}
+
+static bool updater_back_event_callback(void* context) {
+    furi_assert(context);
+    Updater* updater = (Updater*)context;
+    return scene_manager_handle_back_event(updater->scene_manager);
+}
+
+static void status_update_cb(
+    const char* message,
+    const uint8_t progress,
+    const uint8_t idx_stage,
+    const uint8_t total_stages,
+    bool failed,
+    void* context) {
+    UpdaterMainView* main_view = context;
+    updater_main_model_set_state(main_view, message, progress, idx_stage, total_stages, failed);
+}
+
+Updater* updater_alloc(const char* arg) {
+    Updater* updater = malloc(sizeof(Updater));
+    if(arg) {
+        string_init_set_str(updater->startup_arg, arg);
+        string_replace_str(updater->startup_arg, "/any/", "/ext/");
+    } else {
+        string_init(updater->startup_arg);
+    }
+
+    updater->storage = furi_record_open("storage");
+
+    updater->gui = furi_record_open("gui");
+    updater->view_dispatcher = view_dispatcher_alloc();
+    updater->scene_manager = scene_manager_alloc(&updater_scene_handlers, updater);
+
+    view_dispatcher_enable_queue(updater->view_dispatcher);
+
+    view_dispatcher_set_event_callback_context(updater->view_dispatcher, updater);
+    view_dispatcher_set_custom_event_callback(
+        updater->view_dispatcher, updater_custom_event_callback);
+    view_dispatcher_set_navigation_event_callback(
+        updater->view_dispatcher, updater_back_event_callback);
+    view_dispatcher_set_tick_event_callback(
+        updater->view_dispatcher, updater_tick_event_callback, UPDATER_APP_TICK);
+
+    view_dispatcher_attach_to_gui(
+        updater->view_dispatcher,
+        updater->gui,
+        arg ? ViewDispatcherTypeFullscreen : ViewDispatcherTypeWindow);
+
+    updater->main_view = updater_main_alloc();
+    view_dispatcher_add_view(
+        updater->view_dispatcher, UpdaterViewMain, updater_main_get_view(updater->main_view));
+
+#ifndef FURI_RAM_EXEC
+    updater->widget = widget_alloc();
+    view_dispatcher_add_view(
+        updater->view_dispatcher, UpdaterViewWidget, widget_get_view(updater->widget));
+#endif
+
+#ifdef FURI_RAM_EXEC
+    if(true) {
+#else
+    if(!arg) {
+#endif
+        updater->update_task = update_task_alloc();
+        update_task_set_progress_cb(updater->update_task, status_update_cb, updater->main_view);
+
+        scene_manager_next_scene(updater->scene_manager, UpdaterSceneMain);
+    } else {
+#ifndef FURI_RAM_EXEC
+        scene_manager_next_scene(updater->scene_manager, UpdaterSceneLoadCfg);
+#endif
+    }
+
+    return updater;
+}
+
+void updater_free(Updater* updater) {
+    furi_assert(updater);
+
+    string_clear(updater->startup_arg);
+    if(updater->update_task) {
+        update_task_set_progress_cb(updater->update_task, NULL, NULL);
+        update_task_free(updater->update_task);
+    }
+
+    view_dispatcher_remove_view(updater->view_dispatcher, UpdaterViewMain);
+    updater_main_free(updater->main_view);
+
+#ifndef FURI_RAM_EXEC
+    view_dispatcher_remove_view(updater->view_dispatcher, UpdaterViewWidget);
+    widget_free(updater->widget);
+#endif
+
+    view_dispatcher_free(updater->view_dispatcher);
+    scene_manager_free(updater->scene_manager);
+
+    furi_record_close("gui");
+    furi_record_close("storage");
+
+    free(updater);
+}
+
+int32_t updater_srv(void* p) {
+    const char* cfgpath = p;
+
+    Updater* updater = updater_alloc(cfgpath);
+    view_dispatcher_run(updater->view_dispatcher);
+    updater_free(updater);
+
+    return 0;
+}

applications/updater/updater_i.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "views/updater_main.h"
+#include "util/update_task.h"
+
+#include <furi.h>
+#include <gui/gui.h>
+#include <gui/view_stack.h>
+#include <gui/view_dispatcher.h>
+#include <gui/modules/popup.h>
+#include <gui/scene_manager.h>
+#include <gui/modules/widget.h>
+#include <storage/storage.h>
+#include <update_util/update_operation.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define UPDATER_APP_TICK 500
+
+typedef enum {
+    UpdaterViewMain,
+    UpdaterViewWidget,
+} UpdaterViewEnum;
+
+typedef enum {
+    UpdaterCustomEventUnknown,
+    UpdaterCustomEventStartUpdate,
+    UpdaterCustomEventRetryUpdate,
+    UpdaterCustomEventCancelUpdate,
+    UpdaterCustomEventSdUnmounted,
+} UpdaterCustomEvent;
+
+typedef struct UpdaterManifestProcessingState {
+    UpdateManifest* manifest;
+    string_t message;
+    bool ready_to_be_applied;
+} UpdaterManifestProcessingState;
+
+typedef struct {
+    // GUI
+    Gui* gui;
+    SceneManager* scene_manager;
+    ViewDispatcher* view_dispatcher;
+    Storage* storage;
+
+    UpdaterMainView* main_view;
+
+    UpdaterManifestProcessingState* pending_update;
+    UpdatePrepareResult preparation_result;
+
+    UpdateTask* update_task;
+    Widget* widget;
+    string_t startup_arg;
+    int32_t idle_ticks;
+} Updater;
+
+Updater* updater_alloc(const char* arg);
+
+void updater_free(Updater* updater);
+
+#ifdef __cplusplus
+}
+#endif

applications/updater/util/update_task.c

@@ -0,0 +1,226 @@
+#include "update_task.h"
+#include "update_task_i.h"
+
+#include <furi.h>
+#include <furi_hal.h>
+#include <storage/storage.h>
+#include <toolbox/path.h>
+#include <update_util/dfu_file.h>
+#include <update_util/lfs_backup.h>
+#include <update_util/update_operation.h>
+
+static const char* update_task_stage_descr[] = {
+    [UpdateTaskStageProgress] = "...",
+    [UpdateTaskStageReadManifest] = "Loading update manifest",
+    [UpdateTaskStageValidateDFUImage] = "Checking DFU file",
+    [UpdateTaskStageFlashWrite] = "Writing flash",
+    [UpdateTaskStageFlashValidate] = "Validating",
+    [UpdateTaskStageRadioWrite] = "Writing radio stack",
+    [UpdateTaskStageRadioCommit] = "Applying radio stack",
+    [UpdateTaskStageLfsBackup] = "Backing up LFS",
+    [UpdateTaskStageLfsRestore] = "Restoring LFS",
+    [UpdateTaskStageComplete] = "Complete",
+    [UpdateTaskStageError] = "Error",
+};
+
+static void update_task_set_status(UpdateTask* update_task, const char* status) {
+    if(!status) {
+        if(update_task->state.stage >= COUNT_OF(update_task_stage_descr)) {
+            status = "...";
+        } else {
+            status = update_task_stage_descr[update_task->state.stage];
+        }
+    }
+    string_set_str(update_task->state.status, status);
+}
+
+void update_task_set_progress(UpdateTask* update_task, UpdateTaskStage stage, uint8_t progress) {
+    if(stage != UpdateTaskStageProgress) {
+        update_task->state.stage = stage;
+        update_task->state.current_stage_idx++;
+        update_task_set_status(update_task, NULL);
+    }
+
+    if(progress > 100) {
+        progress = 100;
+    }
+
+    update_task->state.progress = progress;
+    if(update_task->status_change_cb) {
+        (update_task->status_change_cb)(
+            string_get_cstr(update_task->state.status),
+            progress,
+            update_task->state.current_stage_idx,
+            update_task->state.total_stages,
+            update_task->state.stage == UpdateTaskStageError,
+            update_task->status_change_cb_state);
+    }
+}
+
+static void update_task_close_file(UpdateTask* update_task) {
+    furi_assert(update_task);
+    if(!storage_file_is_open(update_task->file)) {
+        return;
+    }
+
+    storage_file_close(update_task->file);
+}
+
+static bool update_task_check_file_exists(UpdateTask* update_task, string_t filename) {
+    furi_assert(update_task);
+    string_t tmp_path;
+    string_init_set(tmp_path, update_task->update_path);
+    path_append(tmp_path, string_get_cstr(filename));
+    bool exists =
+        (storage_common_stat(update_task->storage, string_get_cstr(tmp_path), NULL) == FSE_OK);
+    string_clear(tmp_path);
+    return exists;
+}
+
+bool update_task_open_file(UpdateTask* update_task, string_t filename) {
+    furi_assert(update_task);
+    update_task_close_file(update_task);
+
+    string_t tmp_path;
+    string_init_set(tmp_path, update_task->update_path);
+    path_append(tmp_path, string_get_cstr(filename));
+    bool open_success = storage_file_open(
+        update_task->file, string_get_cstr(tmp_path), FSAM_READ, FSOM_OPEN_EXISTING);
+    string_clear(tmp_path);
+    return open_success;
+}
+
+static void update_task_worker_thread_cb(FuriThreadState state, void* context) {
+    UpdateTask* update_task = context;
+
+    if(state != FuriThreadStateStopped) {
+        return;
+    }
+
+    int32_t op_result = furi_thread_get_return_code(update_task->thread);
+    if(op_result == UPDATE_TASK_NOERR) {
+        osDelay(UPDATE_DELAY_OPERATION_OK);
+        furi_hal_power_reset();
+    }
+}
+
+UpdateTask* update_task_alloc() {
+    UpdateTask* update_task = malloc(sizeof(UpdateTask));
+
+    update_task->state.stage = UpdateTaskStageProgress;
+    update_task->state.progress = 0;
+    string_init(update_task->state.status);
+
+    update_task->manifest = update_manifest_alloc();
+    update_task->storage = furi_record_open("storage");
+    update_task->file = storage_file_alloc(update_task->storage);
+    update_task->status_change_cb = NULL;
+
+    FuriThread* thread = update_task->thread = furi_thread_alloc();
+
+    furi_thread_set_name(thread, "UpdateWorker");
+    furi_thread_set_stack_size(thread, 5120);
+    furi_thread_set_context(thread, 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);
+#else
+    UNUSED(update_task_worker_flash_writer);
+    furi_thread_set_callback(thread, update_task_worker_backup_restore);
+#endif
+
+    return update_task;
+}
+
+void update_task_free(UpdateTask* update_task) {
+    furi_assert(update_task);
+
+    furi_thread_join(update_task->thread);
+
+    furi_thread_free(update_task->thread);
+    update_task_close_file(update_task);
+    storage_file_free(update_task->file);
+    update_manifest_free(update_task->manifest);
+
+    furi_record_close("storage");
+    string_clear(update_task->update_path);
+
+    free(update_task);
+}
+
+bool update_task_init(UpdateTask* update_task) {
+    furi_assert(update_task);
+    string_init(update_task->update_path);
+    return true;
+}
+
+bool update_task_parse_manifest(UpdateTask* update_task) {
+    furi_assert(update_task);
+    update_task_set_progress(update_task, UpdateTaskStageReadManifest, 0);
+    bool result = false;
+    string_t manifest_path;
+    string_init(manifest_path);
+
+    do {
+        update_task_set_progress(update_task, UpdateTaskStageProgress, 10);
+        if(!update_operation_get_current_package_path(
+               update_task->storage, update_task->update_path)) {
+            break;
+        }
+
+        path_concat(
+            string_get_cstr(update_task->update_path),
+            UPDATE_MANIFEST_DEFAULT_NAME,
+            manifest_path);
+        update_task_set_progress(update_task, UpdateTaskStageProgress, 30);
+        if(!update_manifest_init(update_task->manifest, string_get_cstr(manifest_path))) {
+            break;
+        }
+
+        update_task_set_progress(update_task, UpdateTaskStageProgress, 50);
+        if(!string_empty_p(update_task->manifest->firmware_dfu_image) &&
+           !update_task_check_file_exists(update_task, update_task->manifest->firmware_dfu_image)) {
+            break;
+        }
+
+        update_task_set_progress(update_task, UpdateTaskStageProgress, 70);
+        if(!string_empty_p(update_task->manifest->radio_image) &&
+           !update_task_check_file_exists(update_task, update_task->manifest->radio_image)) {
+            break;
+        }
+
+        update_task_set_progress(update_task, UpdateTaskStageProgress, 100);
+        result = true;
+    } while(false);
+
+    string_clear(manifest_path);
+    return result;
+}
+
+void update_task_set_progress_cb(UpdateTask* update_task, updateProgressCb cb, void* state) {
+    update_task->status_change_cb = cb;
+    update_task->status_change_cb_state = state;
+}
+
+bool update_task_start(UpdateTask* update_task) {
+    furi_assert(update_task);
+    return furi_thread_start(update_task->thread);
+}
+
+bool update_task_is_running(UpdateTask* update_task) {
+    furi_assert(update_task);
+    return furi_thread_get_state(update_task->thread) == FuriThreadStateRunning;
+}
+
+UpdateTaskState const* update_task_get_state(UpdateTask* update_task) {
+    furi_assert(update_task);
+    return &update_task->state;
+}
+
+UpdateManifest const* update_task_get_manifest(UpdateTask* update_task) {
+    furi_assert(update_task);
+    return update_task->manifest;
+}

applications/updater/util/update_task.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <update_util/update_manifest.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <m-string.h>
+
+#define UPDATE_DELAY_OPERATION_OK 600
+#define UPDATE_DELAY_OPERATION_ERROR INT_MAX
+
+typedef enum {
+    UpdateTaskStageProgress,
+    UpdateTaskStageReadManifest,
+    UpdateTaskStageValidateDFUImage,
+    UpdateTaskStageFlashWrite,
+    UpdateTaskStageFlashValidate,
+    UpdateTaskStageRadioWrite,
+    UpdateTaskStageRadioCommit,
+    UpdateTaskStageLfsBackup,
+    UpdateTaskStageLfsRestore,
+    UpdateTaskStageComplete,
+    UpdateTaskStageError,
+} UpdateTaskStage;
+
+typedef struct {
+    UpdateTaskStage stage;
+    uint8_t progress;
+    uint8_t current_stage_idx;
+    uint8_t total_stages;
+    string_t status;
+} UpdateTaskState;
+
+typedef struct UpdateTask UpdateTask;
+
+typedef void (*updateProgressCb)(
+    const char* status,
+    const uint8_t stage_pct,
+    const uint8_t idx_stage,
+    const uint8_t total_stages,
+    bool failed,
+    void* state);
+
+UpdateTask* update_task_alloc();
+
+void update_task_free(UpdateTask* update_task);
+
+bool update_task_init(UpdateTask* update_task);
+
+void update_task_set_progress_cb(UpdateTask* update_task, updateProgressCb cb, void* state);
+
+bool update_task_start(UpdateTask* update_task);
+
+bool update_task_is_running(UpdateTask* update_task);
+
+UpdateTaskState const* update_task_get_state(UpdateTask* update_task);
+
+UpdateManifest const* update_task_get_manifest(UpdateTask* update_task);
+
+#ifdef __cplusplus
+}
+#endif

applications/updater/util/update_task_i.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <storage/storage.h>
+
+#define UPDATE_TASK_NOERR 0
+#define UPDATE_TASK_FAILED -1
+
+typedef struct UpdateTask {
+    UpdateTaskState state;
+    string_t update_path;
+    UpdateManifest* manifest;
+    FuriThread* thread;
+    Storage* storage;
+    File* file;
+    updateProgressCb status_change_cb;
+    void* status_change_cb_state;
+} UpdateTask;
+
+void update_task_set_progress(UpdateTask* update_task, UpdateTaskStage stage, uint8_t progress);
+bool update_task_parse_manifest(UpdateTask* update_task);
+bool update_task_open_file(UpdateTask* update_task, string_t filename);
+
+int32_t update_task_worker_flash_writer(void* context);
+int32_t update_task_worker_backup_restore(void* context);

applications/updater/util/update_task_workers.c

@@ -0,0 +1,148 @@
+#include "update_task.h"
+#include "update_task_i.h"
+
+#include <furi.h>
+#include <furi_hal.h>
+#include <storage/storage.h>
+#include <toolbox/path.h>
+#include <update_util/dfu_file.h>
+#include <update_util/lfs_backup.h>
+#include <update_util/update_operation.h>
+
+#define CHECK_RESULT(x) \
+    if(!(x)) {          \
+        break;          \
+    }
+
+#define STM_DFU_VENDOR_ID 0x0483
+#define STM_DFU_PRODUCT_ID 0xDF11
+/* Written into DFU file by build pipeline */
+#define FLIPPER_ZERO_DFU_DEVICE_CODE 0xFFFF
+
+static const DfuValidationParams flipper_dfu_params = {
+    .device = FLIPPER_ZERO_DFU_DEVICE_CODE,
+    .product = STM_DFU_PRODUCT_ID,
+    .vendor = STM_DFU_VENDOR_ID,
+};
+
+static void update_task_dfu_progress(const uint8_t progress, void* context) {
+    UpdateTask* update_task = context;
+    update_task_set_progress(update_task, UpdateTaskStageProgress, progress);
+}
+
+static bool page_task_compare_flash(
+    const uint8_t i_page,
+    const uint8_t* update_block,
+    uint16_t update_block_len) {
+    const size_t page_addr = furi_hal_flash_get_base() + furi_hal_flash_get_page_size() * i_page;
+    return (memcmp(update_block, (void*)page_addr, update_block_len) == 0);
+}
+
+/* Verifies a flash operation address for fitting into writable memory
+ */
+static bool check_address_boundaries(const size_t address) {
+    const size_t min_allowed_address = furi_hal_flash_get_base();
+    const size_t max_allowed_address = (size_t)furi_hal_flash_get_free_end_address();
+    return ((address >= min_allowed_address) && (address < max_allowed_address));
+}
+
+int32_t update_task_worker_flash_writer(void* context) {
+    furi_assert(context);
+    UpdateTask* update_task = context;
+    bool success = false;
+    DfuUpdateTask page_task = {
+        .address_cb = &check_address_boundaries,
+        .progress_cb = &update_task_dfu_progress,
+        .task_cb = &furi_hal_flash_program_page,
+        .context = update_task,
+    };
+
+    update_task->state.current_stage_idx = 0;
+    update_task->state.total_stages = 4;
+
+    do {
+        CHECK_RESULT(update_task_parse_manifest(update_task));
+
+        if(!string_empty_p(update_task->manifest->firmware_dfu_image)) {
+            update_task_set_progress(update_task, UpdateTaskStageValidateDFUImage, 0);
+            CHECK_RESULT(
+                update_task_open_file(update_task, update_task->manifest->firmware_dfu_image));
+            CHECK_RESULT(
+                dfu_file_validate_crc(update_task->file, &update_task_dfu_progress, update_task));
+
+            const uint8_t valid_targets =
+                dfu_file_validate_headers(update_task->file, &flipper_dfu_params);
+            if(valid_targets == 0) {
+                break;
+            }
+
+            update_task_set_progress(update_task, UpdateTaskStageFlashWrite, 0);
+            CHECK_RESULT(dfu_file_process_targets(&page_task, update_task->file, valid_targets));
+
+            page_task.task_cb = &page_task_compare_flash;
+
+            update_task_set_progress(update_task, UpdateTaskStageFlashValidate, 0);
+            CHECK_RESULT(dfu_file_process_targets(&page_task, update_task->file, valid_targets));
+        }
+
+        update_task_set_progress(update_task, UpdateTaskStageComplete, 100);
+
+        furi_hal_rtc_set_boot_mode(FuriHalRtcBootModePostUpdate);
+
+        success = true;
+    } while(false);
+
+    if(!success) {
+        update_task_set_progress(update_task, UpdateTaskStageError, update_task->state.progress);
+    }
+
+    return success ? UPDATE_TASK_NOERR : UPDATE_TASK_FAILED;
+}
+
+int32_t update_task_worker_backup_restore(void* context) {
+    furi_assert(context);
+    UpdateTask* update_task = context;
+    bool success = false;
+
+    FuriHalRtcBootMode boot_mode = furi_hal_rtc_get_boot_mode();
+    if((boot_mode != FuriHalRtcBootModePreUpdate) && (boot_mode != FuriHalRtcBootModePostUpdate)) {
+        // no idea how we got here. Clear to normal boot
+        furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeNormal);
+        return UPDATE_TASK_NOERR;
+    }
+
+    update_task->state.current_stage_idx = 0;
+    update_task->state.total_stages = 1;
+
+    if(!update_operation_get_current_package_path(update_task->storage, update_task->update_path)) {
+        return UPDATE_TASK_FAILED;
+    }
+
+    string_t backup_file_path;
+    string_init(backup_file_path);
+    path_concat(
+        string_get_cstr(update_task->update_path), LFS_BACKUP_DEFAULT_FILENAME, backup_file_path);
+
+    if(boot_mode == FuriHalRtcBootModePreUpdate) {
+        update_task_set_progress(update_task, UpdateTaskStageLfsBackup, 0);
+        furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeNormal); // to avoid bootloops
+        if((success =
+                lfs_backup_create(update_task->storage, string_get_cstr(backup_file_path)))) {
+            furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeUpdate);
+        }
+    } else if(boot_mode == FuriHalRtcBootModePostUpdate) {
+        update_task_set_progress(update_task, UpdateTaskStageLfsRestore, 0);
+        furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeNormal);
+        success = lfs_backup_unpack(update_task->storage, string_get_cstr(backup_file_path));
+    }
+
+    if(success) {
+        update_task_set_progress(update_task, UpdateTaskStageComplete, 100);
+    } else {
+        update_task_set_progress(update_task, UpdateTaskStageError, update_task->state.progress);
+    }
+
+    string_clear(backup_file_path);
+
+    return success ? UPDATE_TASK_NOERR : UPDATE_TASK_FAILED;
+}

applications/updater/views/updater_main.c

@@ -0,0 +1,151 @@
+#include <gui/gui_i.h>
+#include <gui/view.h>
+#include <gui/elements.h>
+#include <gui/canvas.h>
+#include <furi.h>
+#include <input/input.h>
+
+#include "../updater_i.h"
+#include "updater_main.h"
+
+struct UpdaterMainView {
+    View* view;
+    ViewDispatcher* view_dispatcher;
+    FuriPubSubSubscription* subscription;
+    void* context;
+};
+
+static const uint8_t PROGRESS_RENDER_STEP = 3; /* percent, to limit rendering rate */
+
+typedef struct {
+    string_t status;
+    uint8_t progress, rendered_progress;
+    uint8_t idx_stage, total_stages;
+    bool failed;
+} UpdaterProgressModel;
+
+void updater_main_model_set_state(
+    UpdaterMainView* main_view,
+    const char* message,
+    uint8_t progress,
+    uint8_t idx_stage,
+    uint8_t total_stages,
+    bool failed) {
+    with_view_model(
+        main_view->view, (UpdaterProgressModel * model) {
+            model->failed = failed;
+            model->idx_stage = idx_stage;
+            model->total_stages = total_stages;
+            model->progress = progress;
+            if(string_cmp_str(model->status, message)) {
+                string_set(model->status, message);
+                model->rendered_progress = progress;
+                return true;
+            }
+            if((model->rendered_progress > progress) ||
+               ((progress - model->rendered_progress) > PROGRESS_RENDER_STEP)) {
+                model->rendered_progress = progress;
+                return true;
+            }
+            return false;
+        });
+}
+
+View* updater_main_get_view(UpdaterMainView* main_view) {
+    furi_assert(main_view);
+    return main_view->view;
+}
+
+bool updater_main_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    UpdaterMainView* main_view = context;
+    if(!main_view->view_dispatcher) {
+        return true;
+    }
+
+    if(event->type != InputTypeShort) {
+        return true;
+    }
+
+    if(event->key == InputKeyOk) {
+        view_dispatcher_send_custom_event(
+            main_view->view_dispatcher, UpdaterCustomEventRetryUpdate);
+    } else if(event->key == InputKeyBack) {
+        view_dispatcher_send_custom_event(
+            main_view->view_dispatcher, UpdaterCustomEventCancelUpdate);
+    }
+
+    return true;
+}
+
+static void updater_main_draw_callback(Canvas* canvas, void* _model) {
+    UpdaterProgressModel* model = _model;
+
+    canvas_set_font(canvas, FontPrimary);
+
+    uint16_t y_offset = model->failed ? 5 : 13;
+    string_t status_text;
+    if(!model->failed && (model->idx_stage != 0) && (model->idx_stage <= model->total_stages)) {
+        string_init_printf(
+            status_text,
+            "[%d/%d] %s",
+            model->idx_stage,
+            model->total_stages,
+            string_get_cstr(model->status));
+    } else {
+        string_init_set(status_text, model->status);
+    }
+    canvas_draw_str_aligned(
+        canvas, 128 / 2, y_offset, AlignCenter, AlignTop, string_get_cstr(status_text));
+    string_clear(status_text);
+    if(model->failed) {
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str_aligned(
+            canvas, 128 / 2, 20, AlignCenter, AlignTop, "[OK] to retry, [Back] to abort");
+    }
+    elements_progress_bar(canvas, 14, 35, 100, (float)model->progress / 100);
+}
+
+UpdaterMainView* updater_main_alloc() {
+    UpdaterMainView* main_view = malloc(sizeof(UpdaterMainView));
+
+    main_view->view = view_alloc();
+    view_allocate_model(main_view->view, ViewModelTypeLocking, sizeof(UpdaterProgressModel));
+
+    with_view_model(
+        main_view->view, (UpdaterProgressModel * model) {
+            string_init_set(model->status, "Waiting for storage");
+            return true;
+        });
+
+    view_set_context(main_view->view, main_view);
+    view_set_input_callback(main_view->view, updater_main_input);
+    view_set_draw_callback(main_view->view, updater_main_draw_callback);
+
+    return main_view;
+}
+
+void updater_main_free(UpdaterMainView* main_view) {
+    furi_assert(main_view);
+    with_view_model(
+        main_view->view, (UpdaterProgressModel * model) {
+            string_clear(model->status);
+            return false;
+        });
+    view_free(main_view->view);
+    free(main_view);
+}
+
+void updater_main_set_storage_pubsub(UpdaterMainView* main_view, FuriPubSubSubscription* sub) {
+    main_view->subscription = sub;
+}
+
+FuriPubSubSubscription* updater_main_get_storage_pubsub(UpdaterMainView* main_view) {
+    return main_view->subscription;
+}
+
+void updater_main_set_view_dispatcher(UpdaterMainView* main_view, ViewDispatcher* view_dispatcher) {
+    main_view->view_dispatcher = view_dispatcher;
+}

applications/updater/views/updater_main.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct UpdaterMainView UpdaterMainView;
+typedef struct FuriPubSubSubscription FuriPubSubSubscription;
+typedef struct ViewDispatcher ViewDispatcher;
+typedef void (*UpdaterMainInputCallback)(InputType type, void* context);
+
+View* updater_main_get_view(UpdaterMainView* main_view);
+
+UpdaterMainView* updater_main_alloc();
+
+void updater_main_free(UpdaterMainView* main_view);
+
+void updater_main_model_set_state(
+    UpdaterMainView* main_view,
+    const char* message,
+    uint8_t progress,
+    uint8_t idx_stage,
+    uint8_t total_stages,
+    bool failed);
+
+void updater_main_set_storage_pubsub(UpdaterMainView* main_view, FuriPubSubSubscription* sub);
+
+FuriPubSubSubscription* updater_main_get_storage_pubsub(UpdaterMainView* main_view);
+
+void updater_main_set_view_dispatcher(UpdaterMainView* main_view, ViewDispatcher* view_dispatcher);