[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/services/desktop/views/desktop_events.h

@@ -0,0 +1,44 @@
+#pragma once
+
+typedef enum {
+    DesktopMainEventOpenLockMenu,
+    DesktopMainEventOpenArchive,
+    DesktopMainEventOpenFavoritePrimary,
+    DesktopMainEventOpenFavoriteSecondary,
+    DesktopMainEventOpenMenu,
+    DesktopMainEventOpenDebug,
+    DesktopMainEventOpenPassport, /**< Broken, don't use it */
+    DesktopMainEventOpenPowerOff,
+
+    DesktopLockedEventUnlocked,
+    DesktopLockedEventUpdate,
+    DesktopLockedEventShowPinInput,
+
+    DesktopPinInputEventResetWrongPinLabel,
+    DesktopPinInputEventUnlocked,
+    DesktopPinInputEventUnlockFailed,
+    DesktopPinInputEventBack,
+
+    DesktopPinTimeoutExit,
+
+    DesktopDebugEventDeed,
+    DesktopDebugEventWrongDeed,
+    DesktopDebugEventSaveState,
+    DesktopDebugEventExit,
+
+    DesktopLockMenuEventLock,
+    DesktopLockMenuEventPinLock,
+    DesktopLockMenuEventExit,
+
+    DesktopAnimationEventCheckAnimation,
+    DesktopAnimationEventNewIdleAnimation,
+    DesktopAnimationEventInteractAnimation,
+
+    DesktopSlideshowCompleted,
+    DesktopSlideshowPoweroff,
+
+    // Global events
+    DesktopGlobalBeforeAppStarted,
+    DesktopGlobalAfterAppFinished,
+    DesktopGlobalAutoLock,
+} DesktopEvent;

applications/services/desktop/views/desktop_view_debug.c

@@ -0,0 +1,200 @@
+#include <toolbox/version.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include <dolphin/helpers/dolphin_state.h>
+#include <dolphin/dolphin.h>
+
+#include "../desktop_i.h"
+#include "desktop_view_debug.h"
+
+void desktop_debug_set_callback(
+    DesktopDebugView* debug_view,
+    DesktopDebugViewCallback callback,
+    void* context) {
+    furi_assert(debug_view);
+    furi_assert(callback);
+    debug_view->callback = callback;
+    debug_view->context = context;
+}
+
+void desktop_debug_render(Canvas* canvas, void* model) {
+    canvas_clear(canvas);
+    DesktopDebugViewModel* m = model;
+    const Version* ver;
+    char buffer[64];
+
+    static const char* headers[] = {"Device Info:", "Dolphin Info:"};
+
+    canvas_set_color(canvas, ColorBlack);
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str_aligned(
+        canvas, 64, 1 + STATUS_BAR_Y_SHIFT, AlignCenter, AlignTop, headers[m->screen]);
+    canvas_set_font(canvas, FontSecondary);
+
+    if(m->screen != DesktopViewStatsMeta) {
+        // Hardware version
+        const char* my_name = furi_hal_version_get_name_ptr();
+        snprintf(
+            buffer,
+            sizeof(buffer),
+            "%d.F%dB%dC%d %s:%s %s",
+            furi_hal_version_get_hw_version(),
+            furi_hal_version_get_hw_target(),
+            furi_hal_version_get_hw_body(),
+            furi_hal_version_get_hw_connect(),
+            furi_hal_version_get_hw_region_name(),
+            furi_hal_region_get_name(),
+            my_name ? my_name : "Unknown");
+        canvas_draw_str(canvas, 0, 19 + STATUS_BAR_Y_SHIFT, buffer);
+
+        ver = furi_hal_version_get_firmware_version();
+        const BleGlueC2Info* c2_ver = NULL;
+#ifdef SRV_BT
+        c2_ver = ble_glue_get_c2_info();
+#endif
+        if(!ver) {
+            canvas_draw_str(canvas, 0, 30 + STATUS_BAR_Y_SHIFT, "No info");
+            return;
+        }
+
+        snprintf(
+            buffer,
+            sizeof(buffer),
+            "%s [%s]",
+            version_get_version(ver),
+            version_get_builddate(ver));
+        canvas_draw_str(canvas, 0, 30 + STATUS_BAR_Y_SHIFT, buffer);
+
+        snprintf(
+            buffer,
+            sizeof(buffer),
+            "%s%s [%s] %s",
+            version_get_dirty_flag(ver) ? "[!] " : "",
+            version_get_githash(ver),
+            version_get_gitbranchnum(ver),
+            c2_ver ? c2_ver->StackTypeString : "<none>");
+        canvas_draw_str(canvas, 0, 40 + STATUS_BAR_Y_SHIFT, buffer);
+
+        snprintf(
+            buffer, sizeof(buffer), "[%d] %s", version_get_target(ver), version_get_gitbranch(ver));
+        canvas_draw_str(canvas, 0, 50 + STATUS_BAR_Y_SHIFT, buffer);
+
+    } else {
+        Dolphin* dolphin = furi_record_open(RECORD_DOLPHIN);
+        DolphinStats stats = dolphin_stats(dolphin);
+        furi_record_close(RECORD_DOLPHIN);
+
+        uint32_t current_lvl = stats.level;
+        uint32_t remaining = dolphin_state_xp_to_levelup(m->icounter);
+
+        canvas_set_font(canvas, FontSecondary);
+        snprintf(buffer, sizeof(buffer), "Icounter: %ld  Butthurt %ld", m->icounter, m->butthurt);
+        canvas_draw_str(canvas, 5, 19 + STATUS_BAR_Y_SHIFT, buffer);
+
+        snprintf(
+            buffer,
+            sizeof(buffer),
+            "Level: %ld  To level up: %ld",
+            current_lvl,
+            (remaining == (uint32_t)(-1) ? remaining : 0));
+        canvas_draw_str(canvas, 5, 29 + STATUS_BAR_Y_SHIFT, buffer);
+
+        // even if timestamp is uint64_t, it's safe to cast it to uint32_t, because furi_hal_rtc_datetime_to_timestamp only returns uint32_t
+        snprintf(buffer, sizeof(buffer), "%ld", (uint32_t)m->timestamp);
+
+        canvas_draw_str(canvas, 5, 39 + STATUS_BAR_Y_SHIFT, buffer);
+        canvas_draw_str(canvas, 0, 49 + STATUS_BAR_Y_SHIFT, "[< >] icounter value   [ok] save");
+    }
+}
+
+View* desktop_debug_get_view(DesktopDebugView* debug_view) {
+    furi_assert(debug_view);
+    return debug_view->view;
+}
+
+bool desktop_debug_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    DesktopDebugView* debug_view = context;
+
+    if(event->type != InputTypeShort && event->type != InputTypeRepeat) {
+        return false;
+    }
+
+    DesktopViewStatsScreens current = 0;
+    with_view_model(
+        debug_view->view, (DesktopDebugViewModel * model) {
+
+#ifdef SRV_DOLPHIN_STATE_DEBUG
+            if((event->key == InputKeyDown) || (event->key == InputKeyUp)) {
+                model->screen = !model->screen;
+            }
+#endif
+            current = model->screen;
+            return true;
+        });
+
+    size_t count = (event->type == InputTypeRepeat) ? 10 : 1;
+    if(current == DesktopViewStatsMeta) {
+        if(event->key == InputKeyLeft) {
+            while(count-- > 0) {
+                debug_view->callback(DesktopDebugEventWrongDeed, debug_view->context);
+            }
+        } else if(event->key == InputKeyRight) {
+            while(count-- > 0) {
+                debug_view->callback(DesktopDebugEventDeed, debug_view->context);
+            }
+        } else if(event->key == InputKeyOk) {
+            debug_view->callback(DesktopDebugEventSaveState, debug_view->context);
+        } else {
+            return false;
+        }
+    }
+
+    if(event->key == InputKeyBack) {
+        debug_view->callback(DesktopDebugEventExit, debug_view->context);
+    }
+
+    return true;
+}
+
+DesktopDebugView* desktop_debug_alloc() {
+    DesktopDebugView* debug_view = malloc(sizeof(DesktopDebugView));
+    debug_view->view = view_alloc();
+    view_allocate_model(debug_view->view, ViewModelTypeLocking, sizeof(DesktopDebugViewModel));
+    view_set_context(debug_view->view, debug_view);
+    view_set_draw_callback(debug_view->view, (ViewDrawCallback)desktop_debug_render);
+    view_set_input_callback(debug_view->view, desktop_debug_input);
+
+    return debug_view;
+}
+
+void desktop_debug_free(DesktopDebugView* debug_view) {
+    furi_assert(debug_view);
+
+    view_free(debug_view->view);
+    free(debug_view);
+}
+
+void desktop_debug_get_dolphin_data(DesktopDebugView* debug_view) {
+    Dolphin* dolphin = furi_record_open(RECORD_DOLPHIN);
+    DolphinStats stats = dolphin_stats(dolphin);
+    with_view_model(
+        debug_view->view, (DesktopDebugViewModel * model) {
+            model->icounter = stats.icounter;
+            model->butthurt = stats.butthurt;
+            model->timestamp = stats.timestamp;
+            return true;
+        });
+
+    furi_record_close(RECORD_DOLPHIN);
+}
+
+void desktop_debug_reset_screen_idx(DesktopDebugView* debug_view) {
+    with_view_model(
+        debug_view->view, (DesktopDebugViewModel * model) {
+            model->screen = 0;
+            return true;
+        });
+}

applications/services/desktop/views/desktop_view_debug.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <stdint.h>
+#include <gui/view.h>
+#include "desktop_events.h"
+
+typedef struct DesktopDebugView DesktopDebugView;
+
+typedef void (*DesktopDebugViewCallback)(DesktopEvent event, void* context);
+
+// Debug info
+typedef enum {
+    DesktopViewStatsFw,
+    DesktopViewStatsMeta,
+    DesktopViewStatsTotalCount,
+} DesktopViewStatsScreens;
+
+struct DesktopDebugView {
+    View* view;
+    DesktopDebugViewCallback callback;
+    void* context;
+};
+
+typedef struct {
+    uint32_t icounter;
+    uint32_t butthurt;
+    uint64_t timestamp;
+    DesktopViewStatsScreens screen;
+} DesktopDebugViewModel;
+
+void desktop_debug_set_callback(
+    DesktopDebugView* debug_view,
+    DesktopDebugViewCallback callback,
+    void* context);
+
+View* desktop_debug_get_view(DesktopDebugView* debug_view);
+
+DesktopDebugView* desktop_debug_alloc();
+void desktop_debug_free(DesktopDebugView* debug_view);
+
+void desktop_debug_get_dolphin_data(DesktopDebugView* debug_view);
+void desktop_debug_reset_screen_idx(DesktopDebugView* debug_view);

applications/services/desktop/views/desktop_view_lock_menu.c

@@ -0,0 +1,130 @@
+#include <furi.h>
+#include <gui/elements.h>
+
+#include "../desktop_i.h"
+#include "desktop_view_lock_menu.h"
+
+#define LOCK_MENU_ITEMS_NB 3
+
+void desktop_lock_menu_set_callback(
+    DesktopLockMenuView* lock_menu,
+    DesktopLockMenuViewCallback callback,
+    void* context) {
+    furi_assert(lock_menu);
+    furi_assert(callback);
+    lock_menu->callback = callback;
+    lock_menu->context = context;
+}
+
+void desktop_lock_menu_pin_set(DesktopLockMenuView* lock_menu, bool pin_is_set) {
+    with_view_model(
+        lock_menu->view, (DesktopLockMenuViewModel * model) {
+            model->pin_set = pin_is_set;
+            return true;
+        });
+}
+
+void desktop_lock_menu_set_idx(DesktopLockMenuView* lock_menu, uint8_t idx) {
+    furi_assert(idx < LOCK_MENU_ITEMS_NB);
+    with_view_model(
+        lock_menu->view, (DesktopLockMenuViewModel * model) {
+            model->idx = idx;
+            return true;
+        });
+}
+
+static void lock_menu_callback(void* context, uint8_t index) {
+    furi_assert(context);
+    DesktopLockMenuView* lock_menu = context;
+    switch(index) {
+    case 0: // lock
+        lock_menu->callback(DesktopLockMenuEventLock, lock_menu->context);
+        break;
+    case 1: // lock
+        lock_menu->callback(DesktopLockMenuEventPinLock, lock_menu->context);
+        break;
+    default: // wip message
+        with_view_model(
+            lock_menu->view, (DesktopLockMenuViewModel * model) {
+                model->hint_timeout = HINT_TIMEOUT;
+                return true;
+            });
+        break;
+    }
+}
+
+void desktop_lock_menu_render(Canvas* canvas, void* model) {
+    const char* Lockmenu_Items[LOCK_MENU_ITEMS_NB] = {"Lock", "Lock with PIN", "DUMB mode"};
+
+    DesktopLockMenuViewModel* m = model;
+    canvas_clear(canvas);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_draw_icon(canvas, -57, 0 + STATUS_BAR_Y_SHIFT, &I_DoorLeft_70x55);
+    canvas_draw_icon(canvas, 116, 0 + STATUS_BAR_Y_SHIFT, &I_DoorRight_70x55);
+    canvas_set_font(canvas, FontSecondary);
+
+    for(uint8_t i = 0; i < LOCK_MENU_ITEMS_NB; ++i) {
+        const char* str = Lockmenu_Items[i];
+
+        if(i == 1 && !m->pin_set) str = "Set PIN";
+        if(m->hint_timeout && m->idx == 2 && m->idx == i) str = "Not Implemented";
+
+        if(str != NULL)
+            canvas_draw_str_aligned(
+                canvas, 64, 9 + (i * 17) + STATUS_BAR_Y_SHIFT, AlignCenter, AlignCenter, str);
+
+        if(m->idx == i) elements_frame(canvas, 15, 1 + (i * 17) + STATUS_BAR_Y_SHIFT, 98, 15);
+    }
+}
+
+View* desktop_lock_menu_get_view(DesktopLockMenuView* lock_menu) {
+    furi_assert(lock_menu);
+    return lock_menu->view;
+}
+
+bool desktop_lock_menu_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    DesktopLockMenuView* lock_menu = context;
+    uint8_t idx;
+
+    if(event->type != InputTypeShort) return false;
+    with_view_model(
+        lock_menu->view, (DesktopLockMenuViewModel * model) {
+            model->hint_timeout = 0; // clear hint timeout
+            if(event->key == InputKeyUp) {
+                model->idx = CLAMP(model->idx - 1, LOCK_MENU_ITEMS_NB - 1, 0);
+            } else if(event->key == InputKeyDown) {
+                model->idx = CLAMP(model->idx + 1, LOCK_MENU_ITEMS_NB - 1, 0);
+            }
+            idx = model->idx;
+            return true;
+        });
+
+    if(event->key == InputKeyBack) {
+        lock_menu->callback(DesktopLockMenuEventExit, lock_menu->context);
+    } else if(event->key == InputKeyOk) {
+        lock_menu_callback(lock_menu, idx);
+    }
+
+    return true;
+}
+
+DesktopLockMenuView* desktop_lock_menu_alloc() {
+    DesktopLockMenuView* lock_menu = malloc(sizeof(DesktopLockMenuView));
+    lock_menu->view = view_alloc();
+    view_allocate_model(lock_menu->view, ViewModelTypeLocking, sizeof(DesktopLockMenuViewModel));
+    view_set_context(lock_menu->view, lock_menu);
+    view_set_draw_callback(lock_menu->view, (ViewDrawCallback)desktop_lock_menu_render);
+    view_set_input_callback(lock_menu->view, desktop_lock_menu_input);
+
+    return lock_menu;
+}
+
+void desktop_lock_menu_free(DesktopLockMenuView* lock_menu_view) {
+    furi_assert(lock_menu_view);
+
+    view_free(lock_menu_view->view);
+    free(lock_menu_view);
+}

applications/services/desktop/views/desktop_view_lock_menu.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <gui/view.h>
+#include "desktop_events.h"
+
+#define HINT_TIMEOUT 2
+
+typedef struct DesktopLockMenuView DesktopLockMenuView;
+
+typedef void (*DesktopLockMenuViewCallback)(DesktopEvent event, void* context);
+
+struct DesktopLockMenuView {
+    View* view;
+    DesktopLockMenuViewCallback callback;
+    void* context;
+};
+
+typedef struct {
+    uint8_t idx;
+    uint8_t hint_timeout;
+    bool pin_set;
+} DesktopLockMenuViewModel;
+
+void desktop_lock_menu_set_callback(
+    DesktopLockMenuView* lock_menu,
+    DesktopLockMenuViewCallback callback,
+    void* context);
+
+View* desktop_lock_menu_get_view(DesktopLockMenuView* lock_menu);
+void desktop_lock_menu_pin_set(DesktopLockMenuView* lock_menu, bool pin_is_set);
+void desktop_lock_menu_set_idx(DesktopLockMenuView* lock_menu, uint8_t idx);
+DesktopLockMenuView* desktop_lock_menu_alloc();
+void desktop_lock_menu_free(DesktopLockMenuView* lock_menu);

applications/services/desktop/views/desktop_view_locked.c

@@ -0,0 +1,245 @@
+#include <projdefs.h>
+#include <stdint.h>
+#include <furi.h>
+#include <gui/elements.h>
+#include <gui/icon.h>
+#include <gui/view.h>
+#include <portmacro.h>
+
+#include <desktop/desktop_settings.h>
+#include "../desktop_i.h"
+#include "desktop_view_locked.h"
+
+#define DOOR_MOVING_INTERVAL_MS (1000 / 16)
+#define LOCKED_HINT_TIMEOUT_MS (1000)
+#define UNLOCKED_HINT_TIMEOUT_MS (2000)
+
+#define DOOR_OFFSET_START -55
+#define DOOR_OFFSET_END 0
+
+#define DOOR_L_FINAL_POS 0
+#define DOOR_R_FINAL_POS 60
+
+#define UNLOCK_CNT 3
+#define UNLOCK_RST_TIMEOUT 600
+
+struct DesktopViewLocked {
+    View* view;
+    DesktopViewLockedCallback callback;
+    void* context;
+
+    TimerHandle_t timer;
+    uint8_t lock_count;
+    uint32_t lock_lastpress;
+};
+
+typedef enum {
+    DesktopViewLockedStateUnlocked,
+    DesktopViewLockedStateLocked,
+    DesktopViewLockedStateDoorsClosing,
+    DesktopViewLockedStateLockedHintShown,
+    DesktopViewLockedStateUnlockedHintShown
+} DesktopViewLockedState;
+
+typedef struct {
+    bool pin_locked;
+    int8_t door_offset;
+    DesktopViewLockedState view_state;
+} DesktopViewLockedModel;
+
+void desktop_view_locked_set_callback(
+    DesktopViewLocked* locked_view,
+    DesktopViewLockedCallback callback,
+    void* context) {
+    furi_assert(locked_view);
+    furi_assert(callback);
+    locked_view->callback = callback;
+    locked_view->context = context;
+}
+
+static void locked_view_timer_callback(TimerHandle_t timer) {
+    DesktopViewLocked* locked_view = pvTimerGetTimerID(timer);
+    locked_view->callback(DesktopLockedEventUpdate, locked_view->context);
+}
+
+static void desktop_view_locked_doors_draw(Canvas* canvas, DesktopViewLockedModel* model) {
+    int8_t offset = model->door_offset;
+    uint8_t door_left_x = DOOR_L_FINAL_POS + offset;
+    uint8_t door_right_x = DOOR_R_FINAL_POS - offset;
+    uint8_t height = icon_get_height(&I_DoorLeft_70x55);
+    canvas_draw_icon(canvas, door_left_x, canvas_height(canvas) - height, &I_DoorLeft_70x55);
+    canvas_draw_icon(canvas, door_right_x, canvas_height(canvas) - height, &I_DoorRight_70x55);
+}
+
+static bool desktop_view_locked_doors_move(DesktopViewLockedModel* model) {
+    bool stop = false;
+    if(model->door_offset < DOOR_OFFSET_END) {
+        model->door_offset = CLAMP(model->door_offset + 5, DOOR_OFFSET_END, DOOR_OFFSET_START);
+        stop = true;
+    }
+
+    return stop;
+}
+
+static void desktop_view_locked_update_hint_icon_timeout(DesktopViewLocked* locked_view) {
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    const bool change_state = (model->view_state == DesktopViewLockedStateLocked) &&
+                              !model->pin_locked;
+    if(change_state) {
+        model->view_state = DesktopViewLockedStateLockedHintShown;
+    }
+    view_commit_model(locked_view->view, change_state);
+    xTimerChangePeriod(locked_view->timer, pdMS_TO_TICKS(LOCKED_HINT_TIMEOUT_MS), portMAX_DELAY);
+}
+
+void desktop_view_locked_update(DesktopViewLocked* locked_view) {
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    DesktopViewLockedState view_state = model->view_state;
+
+    if(view_state == DesktopViewLockedStateDoorsClosing &&
+       !desktop_view_locked_doors_move(model)) {
+        model->view_state = DesktopViewLockedStateLocked;
+    } else if(view_state == DesktopViewLockedStateLockedHintShown) {
+        model->view_state = DesktopViewLockedStateLocked;
+    } else if(view_state == DesktopViewLockedStateUnlockedHintShown) {
+        model->view_state = DesktopViewLockedStateUnlocked;
+    }
+
+    view_commit_model(locked_view->view, true);
+
+    if(view_state != DesktopViewLockedStateDoorsClosing) {
+        xTimerStop(locked_view->timer, portMAX_DELAY);
+    }
+}
+
+static void desktop_view_locked_draw(Canvas* canvas, void* model) {
+    DesktopViewLockedModel* m = model;
+    DesktopViewLockedState view_state = m->view_state;
+    canvas_set_color(canvas, ColorBlack);
+
+    if(view_state == DesktopViewLockedStateDoorsClosing) {
+        desktop_view_locked_doors_draw(canvas, m);
+        canvas_set_font(canvas, FontPrimary);
+        elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Locked");
+    } else if(view_state == DesktopViewLockedStateLockedHintShown) {
+        canvas_set_font(canvas, FontSecondary);
+        elements_bold_rounded_frame(canvas, 14, 2 + STATUS_BAR_Y_SHIFT, 99, 48);
+        elements_multiline_text(canvas, 65, 20 + STATUS_BAR_Y_SHIFT, "To unlock\npress:");
+        canvas_draw_icon(canvas, 65, 36 + STATUS_BAR_Y_SHIFT, &I_Pin_back_arrow_10x8);
+        canvas_draw_icon(canvas, 80, 36 + STATUS_BAR_Y_SHIFT, &I_Pin_back_arrow_10x8);
+        canvas_draw_icon(canvas, 95, 36 + STATUS_BAR_Y_SHIFT, &I_Pin_back_arrow_10x8);
+        canvas_draw_icon(canvas, 16, 7 + STATUS_BAR_Y_SHIFT, &I_WarningDolphin_45x42);
+        canvas_draw_dot(canvas, 17, 61);
+    } else if(view_state == DesktopViewLockedStateUnlockedHintShown) {
+        canvas_set_font(canvas, FontPrimary);
+        elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Unlocked");
+    }
+}
+
+View* desktop_view_locked_get_view(DesktopViewLocked* locked_view) {
+    furi_assert(locked_view);
+    return locked_view->view;
+}
+
+static bool desktop_view_locked_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    bool is_changed = false;
+    const uint32_t press_time = xTaskGetTickCount();
+    DesktopViewLocked* locked_view = context;
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    if(model->view_state == DesktopViewLockedStateUnlockedHintShown &&
+       event->type == InputTypePress) {
+        model->view_state = DesktopViewLockedStateUnlocked;
+        is_changed = true;
+    }
+    const DesktopViewLockedState view_state = model->view_state;
+    const bool pin_locked = model->pin_locked;
+    view_commit_model(locked_view->view, is_changed);
+
+    if(view_state == DesktopViewLockedStateUnlocked) {
+        return view_state != DesktopViewLockedStateUnlocked;
+    } else if(view_state == DesktopViewLockedStateLocked && pin_locked) {
+        locked_view->callback(DesktopLockedEventShowPinInput, locked_view->context);
+    } else if(
+        view_state == DesktopViewLockedStateLocked ||
+        view_state == DesktopViewLockedStateLockedHintShown) {
+        if(press_time - locked_view->lock_lastpress > UNLOCK_RST_TIMEOUT) {
+            locked_view->lock_lastpress = press_time;
+            locked_view->lock_count = 0;
+        }
+
+        desktop_view_locked_update_hint_icon_timeout(locked_view);
+
+        if(event->key == InputKeyBack) {
+            if(event->type == InputTypeShort) {
+                locked_view->lock_lastpress = press_time;
+                locked_view->lock_count++;
+                if(locked_view->lock_count == UNLOCK_CNT) {
+                    locked_view->callback(DesktopLockedEventUnlocked, locked_view->context);
+                }
+            }
+        } else {
+            locked_view->lock_count = 0;
+        }
+
+        locked_view->lock_lastpress = press_time;
+    }
+
+    return true;
+}
+
+DesktopViewLocked* desktop_view_locked_alloc() {
+    DesktopViewLocked* locked_view = malloc(sizeof(DesktopViewLocked));
+    locked_view->view = view_alloc();
+    locked_view->timer =
+        xTimerCreate(NULL, 1000 / 16, pdTRUE, locked_view, locked_view_timer_callback);
+
+    view_allocate_model(locked_view->view, ViewModelTypeLocking, sizeof(DesktopViewLockedModel));
+    view_set_context(locked_view->view, locked_view);
+    view_set_draw_callback(locked_view->view, desktop_view_locked_draw);
+    view_set_input_callback(locked_view->view, desktop_view_locked_input);
+
+    return locked_view;
+}
+
+void desktop_view_locked_free(DesktopViewLocked* locked_view) {
+    furi_assert(locked_view);
+    furi_timer_free(locked_view->timer);
+    view_free(locked_view->view);
+    free(locked_view);
+}
+
+void desktop_view_locked_close_doors(DesktopViewLocked* locked_view) {
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    furi_assert(model->view_state == DesktopViewLockedStateLocked);
+    model->view_state = DesktopViewLockedStateDoorsClosing;
+    model->door_offset = DOOR_OFFSET_START;
+    view_commit_model(locked_view->view, true);
+    xTimerChangePeriod(locked_view->timer, pdMS_TO_TICKS(DOOR_MOVING_INTERVAL_MS), portMAX_DELAY);
+}
+
+void desktop_view_locked_lock(DesktopViewLocked* locked_view, bool pin_locked) {
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    furi_assert(model->view_state == DesktopViewLockedStateUnlocked);
+    model->view_state = DesktopViewLockedStateLocked;
+    model->pin_locked = pin_locked;
+    view_commit_model(locked_view->view, true);
+}
+
+void desktop_view_locked_unlock(DesktopViewLocked* locked_view) {
+    locked_view->lock_count = 0;
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    model->view_state = DesktopViewLockedStateUnlockedHintShown;
+    model->pin_locked = false;
+    view_commit_model(locked_view->view, true);
+    xTimerChangePeriod(locked_view->timer, pdMS_TO_TICKS(UNLOCKED_HINT_TIMEOUT_MS), portMAX_DELAY);
+}
+
+bool desktop_view_locked_is_locked_hint_visible(DesktopViewLocked* locked_view) {
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    const DesktopViewLockedState view_state = model->view_state;
+    view_commit_model(locked_view->view, false);
+    return view_state == DesktopViewLockedStateLockedHintShown;
+}

applications/services/desktop/views/desktop_view_locked.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <desktop/desktop_settings.h>
+#include "../views/desktop_events.h"
+#include <gui/view.h>
+
+typedef struct DesktopViewLocked DesktopViewLocked;
+
+typedef void (*DesktopViewLockedCallback)(DesktopEvent event, void* context);
+
+void desktop_view_locked_set_callback(
+    DesktopViewLocked* locked_view,
+    DesktopViewLockedCallback callback,
+    void* context);
+void desktop_view_locked_update(DesktopViewLocked* locked_view);
+View* desktop_view_locked_get_view(DesktopViewLocked* locked_view);
+DesktopViewLocked* desktop_view_locked_alloc();
+void desktop_view_locked_free(DesktopViewLocked* locked_view);
+void desktop_view_locked_lock(DesktopViewLocked* locked_view, bool pin_locked);
+void desktop_view_locked_unlock(DesktopViewLocked* locked_view);
+void desktop_view_locked_close_doors(DesktopViewLocked* locked_view);
+bool desktop_view_locked_is_locked_hint_visible(DesktopViewLocked* locked_view);

applications/services/desktop/views/desktop_view_main.c

@@ -0,0 +1,104 @@
+#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 <dolphin/dolphin.h>
+
+#include "../desktop_i.h"
+#include "desktop_view_main.h"
+
+struct DesktopMainView {
+    View* view;
+    DesktopMainViewCallback callback;
+    void* context;
+    TimerHandle_t poweroff_timer;
+};
+
+#define DESKTOP_MAIN_VIEW_POWEROFF_TIMEOUT 5000
+
+static void desktop_main_poweroff_timer_callback(TimerHandle_t timer) {
+    DesktopMainView* main_view = pvTimerGetTimerID(timer);
+    main_view->callback(DesktopMainEventOpenPowerOff, main_view->context);
+}
+
+void desktop_main_set_callback(
+    DesktopMainView* main_view,
+    DesktopMainViewCallback callback,
+    void* context) {
+    furi_assert(main_view);
+    furi_assert(callback);
+    main_view->callback = callback;
+    main_view->context = context;
+}
+
+View* desktop_main_get_view(DesktopMainView* main_view) {
+    furi_assert(main_view);
+    return main_view->view;
+}
+
+bool desktop_main_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    DesktopMainView* main_view = context;
+
+    if(event->type == InputTypeShort) {
+        if(event->key == InputKeyOk) {
+            main_view->callback(DesktopMainEventOpenMenu, main_view->context);
+        } else if(event->key == InputKeyUp) {
+            main_view->callback(DesktopMainEventOpenLockMenu, main_view->context);
+        } else if(event->key == InputKeyDown) {
+            main_view->callback(DesktopMainEventOpenArchive, main_view->context);
+        } else if(event->key == InputKeyLeft) {
+            main_view->callback(DesktopMainEventOpenFavoritePrimary, main_view->context);
+        } else if(event->key == InputKeyRight) {
+            main_view->callback(DesktopMainEventOpenPassport, main_view->context);
+        }
+    } else if(event->type == InputTypeLong) {
+        if(event->key == InputKeyDown) {
+            main_view->callback(DesktopMainEventOpenDebug, main_view->context);
+        } else if(event->key == InputKeyLeft) {
+            main_view->callback(DesktopMainEventOpenFavoriteSecondary, main_view->context);
+        }
+    }
+
+    if(event->key == InputKeyBack) {
+        if(event->type == InputTypePress) {
+            xTimerChangePeriod(
+                main_view->poweroff_timer,
+                pdMS_TO_TICKS(DESKTOP_MAIN_VIEW_POWEROFF_TIMEOUT),
+                portMAX_DELAY);
+        } else if(event->type == InputTypeRelease) {
+            xTimerStop(main_view->poweroff_timer, portMAX_DELAY);
+        }
+    }
+
+    return true;
+}
+
+DesktopMainView* desktop_main_alloc() {
+    DesktopMainView* main_view = malloc(sizeof(DesktopMainView));
+
+    main_view->view = view_alloc();
+    view_allocate_model(main_view->view, ViewModelTypeLockFree, 1);
+    view_set_context(main_view->view, main_view);
+    view_set_input_callback(main_view->view, desktop_main_input);
+
+    main_view->poweroff_timer = xTimerCreate(
+        NULL,
+        pdMS_TO_TICKS(DESKTOP_MAIN_VIEW_POWEROFF_TIMEOUT),
+        pdFALSE,
+        main_view,
+        desktop_main_poweroff_timer_callback);
+
+    return main_view;
+}
+
+void desktop_main_free(DesktopMainView* main_view) {
+    furi_assert(main_view);
+    view_free(main_view->view);
+    furi_timer_free(main_view->poweroff_timer);
+    free(main_view);
+}

applications/services/desktop/views/desktop_view_main.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <gui/view.h>
+#include "desktop_events.h"
+
+typedef struct DesktopMainView DesktopMainView;
+
+typedef void (*DesktopMainViewCallback)(DesktopEvent event, void* context);
+
+void desktop_main_set_callback(
+    DesktopMainView* main_view,
+    DesktopMainViewCallback callback,
+    void* context);
+
+View* desktop_main_get_view(DesktopMainView* main_view);
+DesktopMainView* desktop_main_alloc();
+void desktop_main_free(DesktopMainView* main_view);

applications/services/desktop/views/desktop_view_pin_input.c

@@ -0,0 +1,340 @@
+#include <gui/canvas.h>
+#include <furi.h>
+#include <gui/view.h>
+#include <gui/elements.h>
+#include <stdint.h>
+#include <portmacro.h>
+
+#include "desktop_view_pin_input.h"
+#include <desktop/desktop_settings.h>
+
+#define NO_ACTIVITY_TIMEOUT 15000
+
+#define PIN_CELL_WIDTH 13
+#define DEFAULT_PIN_X 64
+#define DEFAULT_PIN_Y 32
+
+struct DesktopViewPinInput {
+    View* view;
+    DesktopViewPinInputCallback back_callback;
+    DesktopViewPinInputCallback timeout_callback;
+    DesktopViewPinInputDoneCallback done_callback;
+    void* context;
+    TimerHandle_t timer;
+};
+
+typedef struct {
+    PinCode pin;
+    bool pin_hidden;
+    bool locked_input;
+    uint8_t pin_x;
+    uint8_t pin_y;
+    const char* primary_str;
+    uint8_t primary_str_x;
+    uint8_t primary_str_y;
+    const char* secondary_str;
+    uint8_t secondary_str_x;
+    uint8_t secondary_str_y;
+    const char* button_label;
+} DesktopViewPinInputModel;
+
+static bool desktop_view_pin_input_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    DesktopViewPinInput* pin_input = context;
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+
+    bool call_back_callback = false;
+    bool call_done_callback = false;
+    PinCode pin_code = {0};
+
+    if(event->type == InputTypeShort) {
+        switch(event->key) {
+        case InputKeyRight:
+        case InputKeyLeft:
+        case InputKeyDown:
+        case InputKeyUp:
+            if(!model->locked_input) {
+                if(model->pin.length < MAX_PIN_SIZE) {
+                    model->pin.data[model->pin.length++] = event->key;
+                }
+            }
+            break;
+        case InputKeyOk:
+            if(model->pin.length >= MIN_PIN_SIZE) {
+                call_done_callback = true;
+                pin_code = model->pin;
+            }
+            break;
+        case InputKeyBack:
+            if(!model->locked_input) {
+                if(model->pin.length > 0) {
+                    model->pin.length = 0;
+                } else {
+                    call_back_callback = true;
+                }
+            }
+            break;
+        default:
+            furi_assert(0);
+            break;
+        }
+    }
+    view_commit_model(pin_input->view, true);
+
+    if(call_done_callback && pin_input->done_callback) {
+        pin_input->done_callback(&pin_code, pin_input->context);
+    } else if(call_back_callback && pin_input->back_callback) {
+        pin_input->back_callback(pin_input->context);
+    }
+
+    xTimerStart(pin_input->timer, 0);
+
+    return true;
+}
+
+static void desktop_view_pin_input_draw_cells(Canvas* canvas, DesktopViewPinInputModel* model) {
+    furi_assert(canvas);
+    furi_assert(model);
+
+    uint8_t draw_pin_size = MAX(4, model->pin.length + 1);
+    if(model->locked_input || (model->pin.length == MAX_PIN_SIZE)) {
+        draw_pin_size = model->pin.length;
+    }
+
+    uint8_t x = model->pin_x - (draw_pin_size * (PIN_CELL_WIDTH - 1)) / 2;
+    uint8_t y = model->pin_y - (PIN_CELL_WIDTH / 2);
+
+    for(int i = 0; i < draw_pin_size; ++i) {
+        canvas_draw_frame(canvas, x, y, PIN_CELL_WIDTH, PIN_CELL_WIDTH);
+        if(i < model->pin.length) {
+            if(model->pin_hidden) {
+                canvas_draw_icon(canvas, x + 3, y + 3, &I_Pin_star_7x7);
+            } else {
+                switch(model->pin.data[i]) {
+                case InputKeyDown:
+                    canvas_draw_icon(canvas, x + 3, y + 2, &I_Pin_arrow_down_7x9);
+                    break;
+                case InputKeyUp:
+                    canvas_draw_icon(canvas, x + 3, y + 2, &I_Pin_arrow_up7x9);
+                    break;
+                case InputKeyLeft:
+                    canvas_draw_icon(canvas, x + 2, y + 3, &I_Pin_arrow_left_9x7);
+                    break;
+                case InputKeyRight:
+                    canvas_draw_icon(canvas, x + 2, y + 3, &I_Pin_arrow_right_9x7);
+                    break;
+                default:
+                    furi_assert(0);
+                    break;
+                }
+            }
+        } else if(i == model->pin.length) {
+            canvas_draw_icon(canvas, x + 4, y + PIN_CELL_WIDTH + 1, &I_Pin_pointer_5x3);
+        }
+        x += PIN_CELL_WIDTH - 1;
+    }
+}
+
+static void desktop_view_pin_input_draw(Canvas* canvas, void* context) {
+    furi_assert(canvas);
+    furi_assert(context);
+
+    canvas_set_font(canvas, FontSecondary);
+    DesktopViewPinInputModel* model = context;
+    desktop_view_pin_input_draw_cells(canvas, model);
+
+    if((model->pin.length > 0) && !model->locked_input) {
+        canvas_draw_icon(canvas, 4, 53, &I_Pin_back_full_40x8);
+    }
+
+    if(model->button_label && ((model->pin.length >= MIN_PIN_SIZE) || model->locked_input)) {
+        elements_button_center(canvas, model->button_label);
+    }
+
+    if(model->primary_str) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str(canvas, model->primary_str_x, model->primary_str_y, model->primary_str);
+        canvas_set_font(canvas, FontSecondary);
+    }
+
+    if(model->secondary_str) {
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str(
+            canvas, model->secondary_str_x, model->secondary_str_y, model->secondary_str);
+    }
+}
+
+void desktop_view_pin_input_timer_callback(TimerHandle_t timer) {
+    DesktopViewPinInput* pin_input = pvTimerGetTimerID(timer);
+
+    if(pin_input->timeout_callback) {
+        pin_input->timeout_callback(pin_input->context);
+    }
+}
+
+static void desktop_view_pin_input_enter(void* context) {
+    DesktopViewPinInput* pin_input = context;
+    xTimerStart(pin_input->timer, portMAX_DELAY);
+}
+
+static void desktop_view_pin_input_exit(void* context) {
+    DesktopViewPinInput* pin_input = context;
+    xTimerStop(pin_input->timer, portMAX_DELAY);
+}
+
+DesktopViewPinInput* desktop_view_pin_input_alloc(void) {
+    DesktopViewPinInput* pin_input = malloc(sizeof(DesktopViewPinInput));
+    pin_input->view = view_alloc();
+    view_allocate_model(pin_input->view, ViewModelTypeLocking, sizeof(DesktopViewPinInputModel));
+    view_set_context(pin_input->view, pin_input);
+    view_set_draw_callback(pin_input->view, desktop_view_pin_input_draw);
+    view_set_input_callback(pin_input->view, desktop_view_pin_input_input);
+    pin_input->timer = xTimerCreate(
+        NULL,
+        pdMS_TO_TICKS(NO_ACTIVITY_TIMEOUT),
+        pdFALSE,
+        pin_input,
+        desktop_view_pin_input_timer_callback);
+    view_set_enter_callback(pin_input->view, desktop_view_pin_input_enter);
+    view_set_exit_callback(pin_input->view, desktop_view_pin_input_exit);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin_x = DEFAULT_PIN_X;
+    model->pin_y = DEFAULT_PIN_Y;
+    model->pin.length = 0;
+    view_commit_model(pin_input->view, false);
+
+    return pin_input;
+}
+
+void desktop_view_pin_input_free(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+
+    xTimerStop(pin_input->timer, portMAX_DELAY);
+    while(xTimerIsTimerActive(pin_input->timer)) {
+        furi_delay_tick(1);
+    }
+    xTimerDelete(pin_input->timer, portMAX_DELAY);
+
+    view_free(pin_input->view);
+    free(pin_input);
+}
+
+void desktop_view_pin_input_lock_input(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->locked_input = true;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_unlock_input(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->locked_input = false;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_pin(DesktopViewPinInput* pin_input, const PinCode* pin) {
+    furi_assert(pin_input);
+    furi_assert(pin);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin = *pin;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_reset_pin(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin.length = 0;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_hide_pin(DesktopViewPinInput* pin_input, bool pin_hidden) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin_hidden = pin_hidden;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_label_button(DesktopViewPinInput* pin_input, const char* label) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->button_label = label;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_label_primary(
+    DesktopViewPinInput* pin_input,
+    uint8_t x,
+    uint8_t y,
+    const char* label) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->primary_str = label;
+    model->primary_str_x = x;
+    model->primary_str_y = y;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_label_secondary(
+    DesktopViewPinInput* pin_input,
+    uint8_t x,
+    uint8_t y,
+    const char* label) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->secondary_str = label;
+    model->secondary_str_x = x;
+    model->secondary_str_y = y;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_pin_position(DesktopViewPinInput* pin_input, uint8_t x, uint8_t y) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin_x = x;
+    model->pin_y = y;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_context(DesktopViewPinInput* pin_input, void* context) {
+    furi_assert(pin_input);
+    pin_input->context = context;
+}
+
+void desktop_view_pin_input_set_timeout_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputCallback callback) {
+    furi_assert(pin_input);
+    pin_input->timeout_callback = callback;
+}
+
+void desktop_view_pin_input_set_back_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputCallback callback) {
+    furi_assert(pin_input);
+    pin_input->back_callback = callback;
+}
+
+void desktop_view_pin_input_set_done_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputDoneCallback callback) {
+    furi_assert(pin_input);
+    pin_input->done_callback = callback;
+}
+
+View* desktop_view_pin_input_get_view(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+    return pin_input->view;
+}

applications/services/desktop/views/desktop_view_pin_input.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <gui/view.h>
+#include <desktop/desktop_settings.h>
+
+typedef void (*DesktopViewPinInputCallback)(void*);
+typedef void (*DesktopViewPinInputDoneCallback)(const PinCode* pin_code, void*);
+typedef struct DesktopViewPinInput DesktopViewPinInput;
+
+DesktopViewPinInput* desktop_view_pin_input_alloc(void);
+void desktop_view_pin_input_free(DesktopViewPinInput*);
+
+void desktop_view_pin_input_set_pin(DesktopViewPinInput* pin_input, const PinCode* pin);
+void desktop_view_pin_input_reset_pin(DesktopViewPinInput* pin_input);
+void desktop_view_pin_input_hide_pin(DesktopViewPinInput* pin_input, bool pin_hidden);
+void desktop_view_pin_input_set_label_button(DesktopViewPinInput* pin_input, const char* label);
+void desktop_view_pin_input_set_label_primary(
+    DesktopViewPinInput* pin_input,
+    uint8_t x,
+    uint8_t y,
+    const char* label);
+void desktop_view_pin_input_set_label_secondary(
+    DesktopViewPinInput* pin_input,
+    uint8_t x,
+    uint8_t y,
+    const char* label);
+void desktop_view_pin_input_set_pin_position(DesktopViewPinInput* pin_input, uint8_t x, uint8_t y);
+View* desktop_view_pin_input_get_view(DesktopViewPinInput*);
+void desktop_view_pin_input_set_done_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputDoneCallback callback);
+void desktop_view_pin_input_set_back_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputCallback callback);
+void desktop_view_pin_input_set_timeout_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputCallback callback);
+void desktop_view_pin_input_set_context(DesktopViewPinInput* pin_input, void* context);
+void desktop_view_pin_input_lock_input(DesktopViewPinInput* pin_input);
+void desktop_view_pin_input_unlock_input(DesktopViewPinInput* pin_input);

applications/services/desktop/views/desktop_view_pin_setup_done.c

@@ -0,0 +1,80 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/elements.h>
+#include <gui/canvas.h>
+#include <toolbox/version.h>
+#include <assets_icons.h>
+#include <dolphin/helpers/dolphin_state.h>
+#include <dolphin/dolphin.h>
+
+#include "../desktop_i.h"
+#include "desktop_view_pin_setup_done.h"
+
+struct DesktopViewPinSetupDone {
+    View* view;
+    DesktopViewPinSetupDoneDoneCallback callback;
+    void* context;
+};
+
+static void desktop_view_pin_done_draw(Canvas* canvas, void* model) {
+    furi_assert(canvas);
+    furi_assert(model);
+
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text_aligned(
+        canvas, 64, 0, AlignCenter, AlignTop, "Prepare to use\narrows as\nPIN symbols");
+
+    canvas_set_font(canvas, FontSecondary);
+    elements_multiline_text(canvas, 58, 24, "Prepare to use\narrows as\nPIN symbols");
+
+    canvas_draw_icon(canvas, 16, 18, &I_Pin_attention_dpad_29x29);
+    elements_button_right(canvas, "Next");
+}
+
+static bool desktop_view_pin_done_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    DesktopViewPinSetupDone* instance = context;
+    bool consumed = false;
+
+    if((event->key == InputKeyRight) && (event->type == InputTypeShort)) {
+        instance->callback(instance->context);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void desktop_view_pin_done_set_callback(
+    DesktopViewPinSetupDone* instance,
+    DesktopViewPinSetupDoneDoneCallback callback,
+    void* context) {
+    furi_assert(instance);
+    furi_assert(callback);
+    instance->callback = callback;
+    instance->context = context;
+}
+
+DesktopViewPinSetupDone* desktop_view_pin_done_alloc() {
+    DesktopViewPinSetupDone* view = malloc(sizeof(DesktopViewPinSetupDone));
+    view->view = view_alloc();
+    view_allocate_model(view->view, ViewModelTypeLockFree, 1);
+    view_set_context(view->view, view);
+    view_set_draw_callback(view->view, desktop_view_pin_done_draw);
+    view_set_input_callback(view->view, desktop_view_pin_done_input);
+
+    return view;
+}
+
+void desktop_view_pin_done_free(DesktopViewPinSetupDone* instance) {
+    furi_assert(instance);
+
+    view_free(instance->view);
+    free(instance);
+}
+
+View* desktop_view_pin_done_get_view(DesktopViewPinSetupDone* instance) {
+    furi_assert(instance);
+    return instance->view;
+}

applications/services/desktop/views/desktop_view_pin_setup_done.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct DesktopViewPinSetupDone DesktopViewPinSetupDone;
+
+typedef void (*DesktopViewPinSetupDoneDoneCallback)(void*);
+
+void desktop_view_pin_done_set_callback(
+    DesktopViewPinSetupDone* instance,
+    DesktopViewPinSetupDoneDoneCallback callback,
+    void* context);
+DesktopViewPinSetupDone* desktop_view_pin_done_alloc();
+void desktop_view_pin_done_free(DesktopViewPinSetupDone* instance);
+View* desktop_view_pin_done_get_view(DesktopViewPinSetupDone* instance);

applications/services/desktop/views/desktop_view_pin_timeout.c

@@ -0,0 +1,111 @@
+
+#include <furi.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <FreeRTOS.h>
+#include <portmacro.h>
+#include <projdefs.h>
+#include <input/input.h>
+#include <gui/canvas.h>
+#include <gui/view.h>
+
+#include "desktop_view_pin_timeout.h"
+
+struct DesktopViewPinTimeout {
+    View* view;
+    TimerHandle_t timer;
+    DesktopViewPinTimeoutDoneCallback callback;
+    void* context;
+};
+
+typedef struct {
+    uint32_t time_left;
+} DesktopViewPinTimeoutModel;
+
+void desktop_view_pin_timeout_set_callback(
+    DesktopViewPinTimeout* instance,
+    DesktopViewPinTimeoutDoneCallback callback,
+    void* context) {
+    furi_assert(instance);
+
+    instance->callback = callback;
+    instance->context = context;
+}
+
+static void desktop_view_pin_timeout_timer_callback(TimerHandle_t timer) {
+    DesktopViewPinTimeout* instance = pvTimerGetTimerID(timer);
+    bool stop = false;
+
+    DesktopViewPinTimeoutModel* model = view_get_model(instance->view);
+    if(model->time_left > 0) {
+        --model->time_left;
+    } else {
+        stop = true;
+    }
+    view_commit_model(instance->view, true);
+
+    if(stop) {
+        xTimerStop(instance->timer, portMAX_DELAY);
+        instance->callback(instance->context);
+    }
+}
+
+static bool desktop_view_pin_timeout_input(InputEvent* event, void* context) {
+    UNUSED(event);
+    UNUSED(context);
+    return true;
+}
+
+static void desktop_view_pin_timeout_draw(Canvas* canvas, void* _model) {
+    furi_assert(canvas);
+    furi_assert(_model);
+
+    DesktopViewPinTimeoutModel* model = _model;
+
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str(canvas, 36, 31, "Wrong PIN!");
+
+    canvas_set_font(canvas, FontSecondary);
+    char str[30] = {0};
+    snprintf(str, sizeof(str), "Timeout: %lds", model->time_left);
+    canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignCenter, str);
+}
+
+void desktop_view_pin_timeout_free(DesktopViewPinTimeout* instance) {
+    view_free(instance->view);
+    xTimerDelete(instance->timer, portMAX_DELAY);
+
+    free(instance);
+}
+
+DesktopViewPinTimeout* desktop_view_pin_timeout_alloc(void) {
+    DesktopViewPinTimeout* instance = malloc(sizeof(DesktopViewPinTimeout));
+    instance->timer = xTimerCreate(
+        NULL, pdMS_TO_TICKS(1000), pdTRUE, instance, desktop_view_pin_timeout_timer_callback);
+
+    instance->view = view_alloc();
+    view_allocate_model(instance->view, ViewModelTypeLockFree, sizeof(DesktopViewPinTimeoutModel));
+
+    view_set_context(instance->view, instance);
+    view_set_draw_callback(instance->view, desktop_view_pin_timeout_draw);
+    view_set_input_callback(instance->view, desktop_view_pin_timeout_input);
+
+    return instance;
+}
+
+void desktop_view_pin_timeout_start(DesktopViewPinTimeout* instance, uint32_t time_left) {
+    furi_assert(instance);
+
+    DesktopViewPinTimeoutModel* model = view_get_model(instance->view);
+    // no race - always called when timer is stopped
+    model->time_left = time_left;
+    view_commit_model(instance->view, true);
+
+    xTimerStart(instance->timer, portMAX_DELAY);
+}
+
+View* desktop_view_pin_timeout_get_view(DesktopViewPinTimeout* instance) {
+    furi_assert(instance);
+
+    return instance->view;
+}

applications/services/desktop/views/desktop_view_pin_timeout.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <stdint.h>
+#include <gui/view.h>
+
+typedef void (*DesktopViewPinTimeoutDoneCallback)(void*);
+typedef struct DesktopViewPinTimeout DesktopViewPinTimeout;
+
+void desktop_view_pin_timeout_set_callback(
+    DesktopViewPinTimeout* instance,
+    DesktopViewPinTimeoutDoneCallback callback,
+    void* context);
+DesktopViewPinTimeout* desktop_view_pin_timeout_alloc(void);
+void desktop_view_pin_timeout_free(DesktopViewPinTimeout*);
+void desktop_view_pin_timeout_start(DesktopViewPinTimeout* instance, uint32_t time_left);
+View* desktop_view_pin_timeout_get_view(DesktopViewPinTimeout* instance);

applications/services/desktop/views/desktop_view_slideshow.c

@@ -0,0 +1,141 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/elements.h>
+
+#include "desktop_view_slideshow.h"
+#include "../desktop_i.h"
+#include "../helpers/slideshow.h"
+#include "../helpers/slideshow_filename.h"
+
+#define DESKTOP_SLIDESHOW_POWEROFF_SHORT 5000
+#define DESKTOP_SLIDESHOW_POWEROFF_LONG (60 * 60 * 1000)
+
+struct DesktopSlideshowView {
+    View* view;
+    DesktopSlideshowViewCallback callback;
+    void* context;
+    FuriTimer* timer;
+};
+
+typedef struct {
+    uint8_t page;
+    Slideshow* slideshow;
+} DesktopSlideshowViewModel;
+
+static void desktop_view_slideshow_draw(Canvas* canvas, void* model) {
+    DesktopSlideshowViewModel* m = model;
+
+    canvas_clear(canvas);
+    if(slideshow_is_loaded(m->slideshow)) {
+        slideshow_draw(m->slideshow, canvas, 0, 0);
+    }
+}
+
+static bool desktop_view_slideshow_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    DesktopSlideshowView* instance = context;
+
+    DesktopSlideshowViewModel* model = view_get_model(instance->view);
+    bool update_view = false;
+    if(event->type == InputTypeShort) {
+        bool end_slideshow = false;
+        switch(event->key) {
+        case InputKeyLeft:
+            slideshow_goback(model->slideshow);
+            break;
+        case InputKeyRight:
+        case InputKeyOk:
+            end_slideshow = !slideshow_advance(model->slideshow);
+            break;
+        case InputKeyBack:
+            end_slideshow = true;
+        default:
+            break;
+        }
+        if(end_slideshow) {
+            instance->callback(DesktopSlideshowCompleted, instance->context);
+        }
+        update_view = true;
+    } else if(event->key == InputKeyOk) {
+        if(event->type == InputTypePress) {
+            furi_timer_start(instance->timer, DESKTOP_SLIDESHOW_POWEROFF_SHORT);
+        } else if(event->type == InputTypeRelease) {
+            furi_timer_stop(instance->timer);
+            if(!slideshow_is_one_page(model->slideshow)) {
+                furi_timer_start(instance->timer, DESKTOP_SLIDESHOW_POWEROFF_LONG);
+            }
+        }
+    }
+    view_commit_model(instance->view, update_view);
+
+    return true;
+}
+
+static void desktop_first_start_timer_callback(void* context) {
+    DesktopSlideshowView* instance = context;
+    instance->callback(DesktopSlideshowPoweroff, instance->context);
+}
+
+static void desktop_view_slideshow_enter(void* context) {
+    DesktopSlideshowView* instance = context;
+
+    furi_assert(instance->timer == NULL);
+    instance->timer =
+        furi_timer_alloc(desktop_first_start_timer_callback, FuriTimerTypeOnce, instance);
+
+    DesktopSlideshowViewModel* model = view_get_model(instance->view);
+    model->slideshow = slideshow_alloc();
+    if(!slideshow_load(model->slideshow, SLIDESHOW_FS_PATH)) {
+        instance->callback(DesktopSlideshowCompleted, instance->context);
+    } else if(!slideshow_is_one_page(model->slideshow)) {
+        furi_timer_start(instance->timer, DESKTOP_SLIDESHOW_POWEROFF_LONG);
+    }
+    view_commit_model(instance->view, false);
+}
+
+static void desktop_view_slideshow_exit(void* context) {
+    DesktopSlideshowView* instance = context;
+
+    furi_timer_stop(instance->timer);
+    furi_timer_free(instance->timer);
+    instance->timer = NULL;
+
+    DesktopSlideshowViewModel* model = view_get_model(instance->view);
+    slideshow_free(model->slideshow);
+    view_commit_model(instance->view, false);
+}
+
+DesktopSlideshowView* desktop_view_slideshow_alloc() {
+    DesktopSlideshowView* instance = malloc(sizeof(DesktopSlideshowView));
+    instance->view = view_alloc();
+    view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(DesktopSlideshowViewModel));
+    view_set_context(instance->view, instance);
+    view_set_draw_callback(instance->view, (ViewDrawCallback)desktop_view_slideshow_draw);
+    view_set_input_callback(instance->view, desktop_view_slideshow_input);
+    view_set_enter_callback(instance->view, desktop_view_slideshow_enter);
+    view_set_exit_callback(instance->view, desktop_view_slideshow_exit);
+
+    return instance;
+}
+
+void desktop_view_slideshow_free(DesktopSlideshowView* instance) {
+    furi_assert(instance);
+
+    view_free(instance->view);
+    free(instance);
+}
+
+View* desktop_view_slideshow_get_view(DesktopSlideshowView* instance) {
+    furi_assert(instance);
+    return instance->view;
+}
+
+void desktop_view_slideshow_set_callback(
+    DesktopSlideshowView* instance,
+    DesktopSlideshowViewCallback callback,
+    void* context) {
+    furi_assert(instance);
+    furi_assert(callback);
+    instance->callback = callback;
+    instance->context = context;
+}

applications/services/desktop/views/desktop_view_slideshow.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <gui/view.h>
+
+#include "desktop_events.h"
+#include "../helpers/slideshow_filename.h"
+
+#define SLIDESHOW_FS_PATH INT_PATH(SLIDESHOW_FILE_NAME)
+
+typedef struct DesktopSlideshowView DesktopSlideshowView;
+
+typedef void (*DesktopSlideshowViewCallback)(DesktopEvent event, void* context);
+
+DesktopSlideshowView* desktop_view_slideshow_alloc();
+
+void desktop_view_slideshow_free(DesktopSlideshowView* main_view);
+
+View* desktop_view_slideshow_get_view(DesktopSlideshowView* main_view);
+
+void desktop_view_slideshow_set_callback(
+    DesktopSlideshowView* main_view,
+    DesktopSlideshowViewCallback callback,
+    void* context);