liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FL-2183] [FL-2209] Dolphin Deeds, Level up, assets generation, refactoring (#965)

Browse Source 
* Desktop: cleanup headers
* Get loader pubsub via record
* [FL-2183] Dolphin refactoring 2022.01
* Restruct animations assets structure
* Rename assets
* Cleanup headers
* Update Recording animation
* Add BadBattery animation
* Provide loader's pubsub via record
* Fix load/unload animations
* Scripts: add flipper format support, initial dolphin packager rework. Assets: internal and external dolphin.
* Sync internal meta.txt and manifest.txt
* Reorder, rename dolphin assets
* Split essential generated assets
* Add ReadMe for dolphin assets
* Separate essential blocking animations
* Scripts: full dolphin validation before packaging
* Assets, Scripts: dolphin external resources packer
* Github: update codeowners
* Scripts: proper slots handling in dolphin animation meta
* Scripts: correct frames enumeration and fix compiled assets.
* [FL-2209] Add Dolphin Deeds points and many more
* Remove excess frame_rate
* Change dolphin assets directory
* Scripts: add internal resource support to dolphin compiler
* Scripts: add internal assets generation, renaming
* Scripts: correct assert, renaming
* Code cleanup, documentation, fixes
* Update Levelup animations
* Rename essential -> blocking
* Fix Unlocked hint
* Scripts: rewrite Templite compiller, replace regexps with token parser, split block types into code and variable blocks. Update dolphin templates.
* Documentation: add key combos description and use information
* Scripts: cleanup templit, more debug info and add dev comment

Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
Albert Kharisov
2022-01-29 13:20:41 +04:00
committed by GitHub
parent 53e7415d12
commit 84410c83b5
366 changed files with 3646 additions and 1566 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
applications/desktop/views/desktop_debug.c
View File

@@ -1,7 +1,9 @@
#include <toolbox/version.h>
#include <furi.h>
#include <furi_hal.h>
#include "../desktop_i.h"
#include "desktop_debug.h"
#include "dolphin/helpers/dolphin_state.h"
#include "dolphin/dolphin.h"

7
applications/desktop/views/desktop_debug.h
View File

@@ -1,12 +1,7 @@
#pragma once
#include <gui/gui_i.h>
#include <stdint.h>
#include <gui/view.h>
#include <gui/canvas.h>
#include <gui/elements.h>
#include <furi.h>
#include <storage/storage.h>
#include <time.h>
#include "desktop_events.h"
typedef struct DesktopDebugView DesktopDebugView;

3
applications/desktop/views/desktop_events.h
View File

@@ -6,6 +6,7 @@ typedef enum {
DesktopMainEventOpenFavorite,
DesktopMainEventOpenMenu,
DesktopMainEventOpenDebug,
DesktopMainEventUpdate,
DesktopMainEventUnlocked,
DesktopMainEventRightShort,
DesktopMainEventCheckAnimation,
@@ -14,8 +15,6 @@ typedef enum {
DesktopMainEventBeforeAppStarted,
DesktopMainEventAfterAppFinished,
DesktopLockedEventUnlock,
DesktopLockedEventUpdate,
DesktopLockedEventInputReset,
DesktopLockedEventCheckAnimation,
DesktopLockedEventMax,
DesktopDebugEventDeed,

2
applications/desktop/views/desktop_first_start.c
View File

@@ -1,4 +1,6 @@
#include <furi.h>
#include <furi_hal.h>
#include <gui/elements.h>
#include "../desktop_i.h"
#include "desktop_first_start.h"

5
applications/desktop/views/desktop_first_start.h
View File

@@ -1,10 +1,7 @@
#pragma once
#include <gui/gui_i.h>
#include <gui/view.h>
#include <gui/canvas.h>
#include <gui/elements.h>
#include <furi.h>
#include "desktop_events.h"
typedef struct DesktopFirstStartView DesktopFirstStartView;

2
applications/desktop/views/desktop_lock_menu.c
View File

@@ -1,4 +1,6 @@
#include <furi.h>
#include <gui/elements.h>
#include "../desktop_i.h"
#include "desktop_lock_menu.h"

4
applications/desktop/views/desktop_lock_menu.h
View File

@@ -1,10 +1,6 @@
#pragma once
#include <gui/gui_i.h>
#include <gui/view.h>
#include <gui/canvas.h>
#include <gui/elements.h>
#include <furi.h>
#include "desktop_events.h"
#define HINT_TIMEOUT 2

286
applications/desktop/views/desktop_locked.c
View File

@@ -1,6 +1,42 @@
#include "desktop/desktop_settings/desktop_settings.h"
#include "furi/check.h"
#include "gui/view.h"
#include "portmacro.h"
#include <furi.h>
#include <gui/gui_i.h>
#include <gui/elements.h>
#include "../desktop_i.h"
#include "desktop_locked.h"
#include <stdint.h>
#define DOOR_MOVING_INTERVAL_MS (1000 / 16)
#define UNLOCKED_HINT_TIMEOUT_MS (2000)
struct DesktopLockedView {
View* view;
DesktopLockedViewCallback callback;
void* context;
TimerHandle_t timer;
uint8_t lock_count;
uint32_t lock_lastpress;
PinCode pincode;
PinCode pincode_input;
};
typedef struct {
uint32_t hint_icon_expire_at;
bool unlocked_hint;
bool locked;
bool pin_locked;
int8_t door_left_x;
int8_t door_right_x;
bool animation_seq_end;
} DesktopLockedViewModel;
static void desktop_locked_unlock(DesktopLockedView* locked_view);
void desktop_locked_set_callback(
DesktopLockedView* locked_view,
@@ -12,98 +48,69 @@ void desktop_locked_set_callback(
locked_view->context = context;
}
void locked_view_timer_callback(void* context) {
DesktopLockedView* locked_view = context;
locked_view->callback(DesktopLockedEventUpdate, locked_view->context);
void locked_view_timer_callback(TimerHandle_t timer) {
DesktopLockedView* locked_view = pvTimerGetTimerID(timer);
locked_view->callback(DesktopMainEventUpdate, locked_view->context);
}
void desktop_locked_update_hint_timeout(DesktopLockedView* locked_view) {
with_view_model(
locked_view->view, (DesktopLockedViewModel * model) {
model->hint_expire_at = osKernelGetTickCount() + osKernelGetTickFreq();
return true;
});
static void desktop_locked_update_hint_icon_timeout(DesktopLockedView* locked_view) {
DesktopLockedViewModel* model = view_get_model(locked_view->view);
model->hint_icon_expire_at = osKernelGetTickCount() + osKernelGetTickFreq();
view_commit_model(locked_view->view, true);
}
void desktop_locked_reset_door_pos(DesktopLockedView* locked_view) {
with_view_model(
locked_view->view, (DesktopLockedViewModel * model) {
model->animation_seq_end = false;
model->door_left_x = DOOR_L_POS;
model->door_right_x = DOOR_R_POS;
return true;
});
static void desktop_locked_reset_door_pos(DesktopLockedView* locked_view) {
DesktopLockedViewModel* model = view_get_model(locked_view->view);
model->animation_seq_end = false;
model->door_left_x = DOOR_L_POS;
model->door_right_x = DOOR_R_POS;
view_commit_model(locked_view->view, true);
}
void desktop_locked_manage_redraw(DesktopLockedView* locked_view) {
bool animation_seq_end;
void desktop_locked_update(DesktopLockedView* locked_view) {
bool stop_timer = false;
with_view_model(
locked_view->view, (DesktopLockedViewModel * model) {
model->animation_seq_end = !model->door_left_x;
animation_seq_end = model->animation_seq_end;
DesktopLockedViewModel* model = view_get_model(locked_view->view);
if(model->locked) {
if(model->door_left_x != DOOR_L_POS_MAX) {
model->door_left_x = CLAMP(model->door_left_x + 5, DOOR_L_POS_MAX, DOOR_L_POS);
model->door_right_x = CLAMP(model->door_right_x - 5, DOOR_R_POS, DOOR_R_POS_MIN);
} else {
model->animation_seq_end = true;
}
stop_timer = model->animation_seq_end;
} else {
model->unlocked_hint = false;
stop_timer = true;
}
view_commit_model(locked_view->view, true);
if(!model->animation_seq_end) {
model->door_left_x = CLAMP(model->door_left_x + 5, DOOR_L_POS_MAX, DOOR_L_POS);
model->door_right_x = CLAMP(model->door_right_x - 5, DOOR_R_POS, DOOR_R_POS_MIN);
} else {
model->hint_expire_at = !model->hint_expire_at;
}
return true;
});
if(animation_seq_end) {
osTimerStop(locked_view->timer);
if(stop_timer) {
xTimerStop(locked_view->timer, portMAX_DELAY);
}
}
void desktop_locked_reset_counter(DesktopLockedView* locked_view) {
locked_view->lock_count = 0;
locked_view->lock_lastpress = 0;
with_view_model(
locked_view->view, (DesktopLockedViewModel * model) {
model->hint_expire_at = 0;
return true;
});
}
void desktop_locked_with_pin(DesktopLockedView* locked_view, bool locked) {
with_view_model(
locked_view->view, (DesktopLockedViewModel * model) {
model->pin_lock = locked;
return true;
});
}
void desktop_locked_render(Canvas* canvas, void* model) {
void desktop_locked_draw(Canvas* canvas, void* model) {
DesktopLockedViewModel* m = model;
uint32_t now = osKernelGetTickCount();
canvas_set_color(canvas, ColorBlack);
if(!m->animation_seq_end) {
canvas_draw_icon(canvas, m->door_left_x, 0 + STATUS_BAR_Y_SHIFT, &I_DoorLeft_70x55);
canvas_draw_icon(canvas, m->door_right_x, 0 + STATUS_BAR_Y_SHIFT, &I_DoorRight_70x55);
}
if(m->animation && m->animation_seq_end) {
if(m->status_bar_background_black) {
canvas_draw_box(canvas, 0, 0, GUI_STATUS_BAR_WIDTH, GUI_STATUS_BAR_HEIGHT);
}
canvas_draw_icon_animation(canvas, 0, 0 + STATUS_BAR_Y_SHIFT, m->animation);
}
if(now < m->hint_expire_at) {
if(m->locked) {
if(!m->animation_seq_end) {
canvas_draw_icon(canvas, m->door_left_x, 0 + STATUS_BAR_Y_SHIFT, &I_DoorLeft_70x55);
canvas_draw_icon(canvas, m->door_right_x, 0 + STATUS_BAR_Y_SHIFT, &I_DoorRight_70x55);
canvas_set_font(canvas, FontPrimary);
elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Locked");
} else if(!m->pin_lock) {
} else if((now < m->hint_icon_expire_at) && !m->pin_locked) {
canvas_set_font(canvas, FontSecondary);
canvas_draw_icon(canvas, 13, 2 + STATUS_BAR_Y_SHIFT, &I_LockPopup_100x49);
elements_multiline_text(canvas, 65, 20 + STATUS_BAR_Y_SHIFT, "To unlock\npress:");
}
} else {
if(m->unlocked_hint) {
canvas_set_font(canvas, FontPrimary);
elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Unlocked");
}
}
}
@@ -116,85 +123,72 @@ bool desktop_locked_input(InputEvent* event, void* context) {
furi_assert(event);
furi_assert(context);
DesktopLockedView* locked_view = context;
uint32_t press_time = 0;
bool locked = false;
bool locked_with_pin = false;
uint32_t press_time = xTaskGetTickCount();
with_view_model(
locked_view->view, (DesktopLockedViewModel * model) {
locked_with_pin = model->pin_lock;
return false;
});
if(event->type == InputTypeShort) {
if(locked_with_pin) {
press_time = osKernelGetTickCount();
if(press_time - locked_view->lock_lastpress > UNLOCK_RST_TIMEOUT * 3) {
locked_view->lock_lastpress = press_time;
locked_view->callback(DesktopLockedEventInputReset, locked_view->context);
}
locked_view->callback(event->key, locked_view->context);
} else {
desktop_locked_update_hint_timeout(locked_view);
if(event->key == InputKeyBack) {
press_time = osKernelGetTickCount();
// check if pressed sequentially
if(press_time - locked_view->lock_lastpress < UNLOCK_RST_TIMEOUT) {
locked_view->lock_lastpress = press_time;
locked_view->lock_count++;
}
if(locked_view->lock_count == UNLOCK_CNT) {
locked_view->lock_count = 0;
locked_view->callback(DesktopLockedEventUnlock, locked_view->context);
}
}
{
DesktopLockedViewModel* model = view_get_model(locked_view->view);
bool changed = false;
locked = model->locked;
locked_with_pin = model->pin_locked;
if(!locked && model->unlocked_hint && event->type == InputTypePress) {
model->unlocked_hint = false;
changed = true;
}
view_commit_model(locked_view->view, changed);
}
if(press_time - locked_view->lock_lastpress > UNLOCK_RST_TIMEOUT) {
if(!locked || (event->type != InputTypeShort)) {
return locked;
}
if(press_time - locked_view->lock_lastpress > UNLOCK_RST_TIMEOUT) {
locked_view->lock_lastpress = press_time;
locked_view->lock_count = 0;
locked_view->pincode_input.length = 0;
}
if(locked_with_pin) {
locked_view->pincode_input.length = code_input_push(
locked_view->pincode_input.data, locked_view->pincode_input.length, event->key);
bool match = code_input_compare(
locked_view->pincode_input.data,
locked_view->pincode_input.length,
locked_view->pincode.data,
locked_view->pincode.length);
if(match) {
desktop_locked_unlock(locked_view);
}
} else {
if(event->key == InputKeyBack) {
locked_view->lock_lastpress = press_time;
locked_view->lock_count++;
if(locked_view->lock_count == UNLOCK_CNT) {
desktop_locked_unlock(locked_view);
}
} else {
desktop_locked_update_hint_icon_timeout(locked_view);
locked_view->lock_count = 0;
}
}
// All events consumed
return true;
}
void desktop_locked_enter(void* context) {
DesktopLockedView* locked_view = context;
locked_view->lock_lastpress = press_time;
with_view_model(
locked_view->view, (DesktopLockedViewModel * model) {
if(model->animation) icon_animation_start(model->animation);
return false;
});
}
void desktop_locked_exit(void* context) {
DesktopLockedView* locked_view = context;
with_view_model(
locked_view->view, (DesktopLockedViewModel * model) {
if(model->animation) icon_animation_stop(model->animation);
return false;
});
return locked;
}
DesktopLockedView* desktop_locked_alloc() {
DesktopLockedView* locked_view = furi_alloc(sizeof(DesktopLockedView));
locked_view->view = view_alloc();
locked_view->timer =
osTimerNew(locked_view_timer_callback, osTimerPeriodic, locked_view, NULL);
xTimerCreate("Locked view", 1000 / 16, pdTRUE, locked_view, locked_view_timer_callback);
view_allocate_model(locked_view->view, ViewModelTypeLocking, sizeof(DesktopLockedViewModel));
view_set_context(locked_view->view, locked_view);
view_set_draw_callback(locked_view->view, (ViewDrawCallback)desktop_locked_render);
view_set_draw_callback(locked_view->view, (ViewDrawCallback)desktop_locked_draw);
view_set_input_callback(locked_view->view, desktop_locked_input);
view_set_enter_callback(locked_view->view, desktop_locked_enter);
view_set_exit_callback(locked_view->view, desktop_locked_exit);
return locked_view;
}
@@ -205,3 +199,37 @@ void desktop_locked_free(DesktopLockedView* locked_view) {
view_free(locked_view->view);
free(locked_view);
}
void desktop_locked_lock(DesktopLockedView* locked_view) {
locked_view->pincode.length = 0;
DesktopLockedViewModel* model = view_get_model(locked_view->view);
model->locked = true;
model->pin_locked = false;
view_commit_model(locked_view->view, true);
desktop_locked_reset_door_pos(locked_view);
xTimerChangePeriod(locked_view->timer, DOOR_MOVING_INTERVAL_MS, portMAX_DELAY);
}
void desktop_locked_lock_pincode(DesktopLockedView* locked_view, PinCode pincode) {
locked_view->pincode = pincode;
locked_view->pincode_input.length = 0;
DesktopLockedViewModel* model = view_get_model(locked_view->view);
model->locked = true;
model->pin_locked = true;
view_commit_model(locked_view->view, true);
desktop_locked_reset_door_pos(locked_view);
xTimerChangePeriod(locked_view->timer, DOOR_MOVING_INTERVAL_MS, portMAX_DELAY);
}
static void desktop_locked_unlock(DesktopLockedView* locked_view) {
furi_assert(locked_view);
locked_view->lock_count = 0;
DesktopLockedViewModel* model = view_get_model(locked_view->view);
model->locked = false;
model->pin_locked = false;
model->unlocked_hint = true;
view_commit_model(locked_view->view, true);
locked_view->callback(DesktopMainEventUnlocked, locked_view->context);
xTimerChangePeriod(locked_view->timer, UNLOCKED_HINT_TIMEOUT_MS, portMAX_DELAY);
}

39
applications/desktop/views/desktop_locked.h
View File

@@ -1,14 +1,11 @@
#pragma once
#include <gui/gui_i.h>
#include <desktop/desktop_settings/desktop_settings.h>
#include <gui/view.h>
#include <gui/canvas.h>
#include <gui/elements.h>
#include <furi.h>
#include "desktop_events.h"
#define UNLOCK_RST_TIMEOUT 300
#define UNLOCK_CNT 2 // 3 actually
#define UNLOCK_CNT 3
#define DOOR_L_POS -57
#define DOOR_L_POS_MAX 0
@@ -24,40 +21,16 @@ typedef struct DesktopLockedView DesktopLockedView;
typedef void (*DesktopLockedViewCallback)(DesktopEvent event, void* context);
struct DesktopLockedView {
View* view;
DesktopLockedViewCallback callback;
void* context;
osTimerId_t timer;
uint8_t lock_count;
uint32_t lock_lastpress;
};
typedef struct {
IconAnimation* animation;
uint32_t hint_expire_at;
bool status_bar_background_black;
uint8_t scene_num;
int8_t door_left_x;
int8_t door_right_x;
bool animation_seq_end;
bool pin_lock;
} DesktopLockedViewModel;
void desktop_locked_set_callback(
DesktopLockedView* locked_view,
DesktopLockedViewCallback callback,
void* context);
void desktop_locked_update_hint_timeout(DesktopLockedView* locked_view);
void desktop_locked_reset_counter(DesktopLockedView* locked_view);
void desktop_locked_reset_door_pos(DesktopLockedView* locked_view);
void desktop_locked_manage_redraw(DesktopLockedView* locked_view);
void desktop_locked_update(DesktopLockedView* locked_view);
View* desktop_locked_get_view(DesktopLockedView* locked_view);
DesktopLockedView* desktop_locked_alloc();
void desktop_locked_free(DesktopLockedView* locked_view);
void desktop_locked_with_pin(DesktopLockedView* lock_menu, bool locked);
void desktop_locked_lock_pincode(DesktopLockedView* locked_view, PinCode pincode);
void desktop_locked_lock(DesktopLockedView* locked_view);

107
applications/desktop/views/desktop_main.c
View File

@@ -1,13 +1,19 @@
#include "dolphin/dolphin.h"
#include "furi/record.h"
#include "gui/canvas.h"
#include "gui/view.h"
#include "gui/view_composed.h"
#include "input/input.h"
#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_main.h"
//#include "../animations/views/bubble_animation_view.h"
struct DesktopMainView {
View* view;
DesktopMainViewCallback callback;
void* context;
};
void desktop_main_set_callback(
DesktopMainView* main_view,
@@ -19,59 +25,6 @@ void desktop_main_set_callback(
main_view->context = context;
}
void desktop_main_reset_hint(DesktopMainView* main_view) {
with_view_model(
main_view->view, (DesktopMainViewModel * model) {
model->hint_expire_at = 0;
return true;
});
}
void desktop_main_switch_dolphin_animation(
DesktopMainView* main_view,
const Icon* icon,
bool status_bar_background_black) {
with_view_model(
main_view->view, (DesktopMainViewModel * model) {
if(model->animation) icon_animation_free(model->animation);
model->animation = icon_animation_alloc(icon);
view_tie_icon_animation(main_view->view, model->animation);
icon_animation_start(model->animation);
model->icon = NULL;
model->status_bar_background_black = status_bar_background_black;
return true;
});
}
void desktop_main_switch_dolphin_icon(DesktopMainView* main_view, const Icon* icon) {
with_view_model(
main_view->view, (DesktopMainViewModel * model) {
if(model->animation) icon_animation_free(model->animation);
model->animation = NULL;
model->icon = icon;
return true;
});
}
void desktop_main_render(Canvas* canvas, void* model) {
DesktopMainViewModel* m = model;
uint32_t now = osKernelGetTickCount();
if(m->status_bar_background_black) {
canvas_draw_box(canvas, 0, 0, GUI_STATUS_BAR_WIDTH, GUI_STATUS_BAR_HEIGHT);
}
if(m->icon) {
canvas_draw_icon(canvas, 0, 0 + STATUS_BAR_Y_SHIFT, m->icon);
} else if(m->animation) {
canvas_draw_icon_animation(canvas, 0, 0 + STATUS_BAR_Y_SHIFT, m->animation);
}
if(now < m->hint_expire_at) {
canvas_set_font(canvas, FontPrimary);
elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Unlocked");
}
}
View* desktop_main_get_view(DesktopMainView* main_view) {
furi_assert(main_view);
return main_view->view;
@@ -100,40 +53,16 @@ bool desktop_main_input(InputEvent* event, void* context) {
consumed = true;
}
desktop_main_reset_hint(main_view);
return consumed;
}
void desktop_main_enter(void* context) {
DesktopMainView* main_view = context;
with_view_model(
main_view->view, (DesktopMainViewModel * model) {
if(model->animation) icon_animation_start(model->animation);
return false;
});
}
void desktop_main_exit(void* context) {
DesktopMainView* main_view = context;
with_view_model(
main_view->view, (DesktopMainViewModel * model) {
if(model->animation) icon_animation_stop(model->animation);
return false;
});
}
DesktopMainView* desktop_main_alloc() {
DesktopMainView* main_view = furi_alloc(sizeof(DesktopMainView));
main_view->view = view_alloc();
view_allocate_model(main_view->view, ViewModelTypeLocking, sizeof(DesktopMainViewModel));
view_allocate_model(main_view->view, ViewModelTypeLockFree, 1);
view_set_context(main_view->view, main_view);
view_set_draw_callback(main_view->view, (ViewDrawCallback)desktop_main_render);
view_set_input_callback(main_view->view, desktop_main_input);
view_set_enter_callback(main_view->view, desktop_main_enter);
view_set_exit_callback(main_view->view, desktop_main_exit);
return main_view;
}
@@ -143,11 +72,3 @@ void desktop_main_free(DesktopMainView* main_view) {
view_free(main_view->view);
free(main_view);
}
void desktop_main_unlocked(DesktopMainView* main_view) {
with_view_model(
main_view->view, (DesktopMainViewModel * model) {
model->hint_expire_at = osKernelGetTickCount() + osKernelGetTickFreq();
return true;
});
}

26
applications/desktop/views/desktop_main.h
View File

@@ -1,31 +1,12 @@
#pragma once
#include "gui/view_composed.h"
#include <gui/gui_i.h>
#include <gui/view.h>
#include <gui/canvas.h>
#include <gui/elements.h>
#include <furi.h>
#include "desktop_events.h"
typedef struct DesktopMainView DesktopMainView;
typedef void (*DesktopMainViewCallback)(DesktopEvent event, void* context);
struct DesktopMainView {
View* view;
DesktopMainViewCallback callback;
void* context;
};
typedef struct {
IconAnimation* animation;
const Icon* icon;
uint8_t scene_num;
bool status_bar_background_black;
uint32_t hint_expire_at;
} DesktopMainViewModel;
void desktop_main_set_callback(
DesktopMainView* main_view,
DesktopMainViewCallback callback,
@@ -34,10 +15,3 @@ void desktop_main_set_callback(
View* desktop_main_get_view(DesktopMainView* main_view);
DesktopMainView* desktop_main_alloc();
void desktop_main_free(DesktopMainView* main_view);
void desktop_main_switch_dolphin_animation(
DesktopMainView* main_view,
const Icon* icon,
bool status_bar_background_black);
void desktop_main_unlocked(DesktopMainView* main_view);
void desktop_main_reset_hint(DesktopMainView* main_view);
void desktop_main_switch_dolphin_icon(DesktopMainView* main_view, const Icon* icon);