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

[FL-1090] Dolphin scenes (#402)

Browse Source 
* dolphin scene draft wip
* gui/elements multiline framed text added
* zoom poc
* item callbacks
* engine tweaks
* move scenes out of services
* improve dolphin gfx selection
* glitch hints
* dialogue typewriter effect
* app loading from scenes app, small action changes, passport app(WIP)
* removed passport from main dolphin app, added statusbar
* small elements position fixes
* fix thread alloc, dolphin and dolphin_scene free functions, other minor issues
* sleep emote improvements
* Dolpin: fix memory leaks, variable namings and etc

Co-authored-by: gornekich <44112859+gornekich@users.noreply.github.com>
Co-authored-by: DrZlo13 <who.just.the.doctor@gmail.com>
Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
its your bedtime
2021-04-13 21:06:25 +03:00
committed by GitHub
parent eae9cb3514
commit d1f523687e
70 changed files with 1093 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
applications/dolphin/dolphin.c
View File

@@ -1,5 +1,19 @@
#include "dolphin_i.h"
#include <stdlib.h>
#include "applications.h"
static void
dolphin_switch_to_interactive_scene(Dolphin* dolphin, const FlipperApplication* flipper_app) {
furi_assert(dolphin);
furi_assert(flipper_app);
furi_assert(flipper_app->app);
furi_assert(flipper_app->name);
furi_thread_set_name(dolphin->scene_thread, flipper_app->name);
furi_thread_set_stack_size(dolphin->scene_thread, flipper_app->stack_size);
furi_thread_set_callback(dolphin->scene_thread, flipper_app->app);
furi_thread_start(dolphin->scene_thread);
}
// temporary main screen animation managment
void dolphin_scene_handler_set_scene(Dolphin* dolphin, IconName icon) {
@@ -66,11 +80,10 @@ bool dolphin_view_idle_main_input(InputEvent* event, void* context) {
} else if(event->key == InputKeyLeft) {
view_dispatcher_switch_to_view(dolphin->idle_view_dispatcher, DolphinViewIdleUp);
} else if(event->key == InputKeyRight) {
view_dispatcher_switch_to_view(dolphin->idle_view_dispatcher, DolphinViewIdleMeta);
dolphin_switch_to_interactive_scene(dolphin, &FLIPPER_SCENES);
} else if(event->key == InputKeyDown) {
view_dispatcher_switch_to_view(dolphin->idle_view_dispatcher, DolphinViewIdleDown);
}
if(event->key == InputKeyBack) {
view_dispatcher_switch_to_view(dolphin->idle_view_dispatcher, DolphinViewIdleMain);
}
@@ -121,19 +134,6 @@ static void lock_menu_callback(void* context, uint8_t index) {
view_dispatcher_switch_to_view(dolphin->idle_view_dispatcher, DolphinViewIdleMain);
view_port_enabled_set(dolphin->lock_viewport, true);
break;
default:
break;
}
}
static void meta_menu_callback(void* context, uint8_t index) {
Dolphin* dolphin = context;
switch(index) {
case 0:
view_port_enabled_set(dolphin->passport, true);
break;
default:
break;
}
@@ -145,59 +145,6 @@ static void lock_icon_callback(Canvas* canvas, void* context) {
canvas_draw_icon(canvas, 0, 0, dolphin->lock_icon);
}
static void draw_passport_callback(Canvas* canvas, void* context) {
furi_assert(context);
Dolphin* dolphin = context;
char level[20];
uint32_t current_level = dolphin_state_get_level(dolphin->state);
uint32_t prev_cap = dolphin_state_xp_to_levelup(dolphin->state, current_level - 1, false);
uint32_t exp = (dolphin_state_xp_to_levelup(dolphin->state, current_level, true) * 63) /
(dolphin_state_xp_to_levelup(dolphin->state, current_level, false) - prev_cap);
canvas_clear(canvas);
// multipass
canvas_draw_icon_name(canvas, 0, 0, I_PassportLeft_6x47);
canvas_draw_icon_name(canvas, 0, 47, I_PassportBottom_128x17);
canvas_draw_line(canvas, 6, 0, 125, 0);
canvas_draw_line(canvas, 127, 2, 127, 47);
canvas_draw_dot(canvas, 126, 1);
//portrait frame
canvas_draw_line(canvas, 9, 6, 9, 53);
canvas_draw_line(canvas, 10, 5, 52, 5);
canvas_draw_line(canvas, 55, 8, 55, 53);
canvas_draw_line(canvas, 10, 54, 54, 54);
canvas_draw_line(canvas, 53, 5, 55, 7);
// portrait
canvas_draw_icon_name(canvas, 14, 11, I_DolphinOkay_41x43);
canvas_draw_line(canvas, 59, 18, 124, 18);
canvas_draw_line(canvas, 59, 31, 124, 31);
canvas_draw_line(canvas, 59, 44, 124, 44);
canvas_draw_str(canvas, 59, 15, api_hal_version_get_name_ptr());
canvas_draw_str(canvas, 59, 28, "Mood: OK");
snprintf(level, 20, "Level: %ld", current_level);
canvas_draw_str(canvas, 59, 41, level);
canvas_set_color(canvas, ColorWhite);
canvas_draw_box(canvas, 123 - exp, 48, exp + 1, 6);
canvas_set_color(canvas, ColorBlack);
canvas_draw_line(canvas, 123 - exp, 48, 123 - exp, 54);
}
static void passport_input_callback(InputEvent* event, void* context) {
Dolphin* dolphin = context;
if(event->type == InputTypeShort) {
if(event->key == InputKeyBack) {
view_port_enabled_set(dolphin->passport, false);
}
}
}
bool dolphin_view_lockmenu_input(InputEvent* event, void* context) {
furi_assert(event);
furi_assert(context);
@@ -244,51 +191,6 @@ bool dolphin_view_lockmenu_input(InputEvent* event, void* context) {
return true;
}
bool dolphin_view_idle_meta_input(InputEvent* event, void* context) {
furi_assert(event);
furi_assert(context);
Dolphin* dolphin = context;
if(event->type != InputTypeShort) return false;
if(event->key == InputKeyLeft) {
with_view_model(
dolphin->idle_view_meta, (DolphinViewMenuModel * model) {
if(model->idx <= 0)
model->idx = 0;
else
--model->idx;
return true;
});
} else if(event->key == InputKeyRight) {
with_view_model(
dolphin->idle_view_meta, (DolphinViewMenuModel * model) {
if(model->idx >= 2)
model->idx = 2;
else
++model->idx;
return true;
});
} else if(event->key == InputKeyOk) {
with_view_model(
dolphin->idle_view_meta, (DolphinViewMenuModel * model) {
meta_menu_callback(context, model->idx);
return true;
});
} else if(event->key == InputKeyBack) {
with_view_model(
dolphin->idle_view_meta, (DolphinViewMenuModel * model) {
model->idx = 0;
return true;
});
view_dispatcher_switch_to_view(dolphin->idle_view_dispatcher, DolphinViewIdleMain);
if(random() % 100 > 50)
dolphin_scene_handler_set_scene(dolphin, idle_scenes[random() % sizeof(idle_scenes)]);
}
return true;
}
Dolphin* dolphin_alloc() {
Dolphin* dolphin = furi_alloc(sizeof(Dolphin));
// Message queue
@@ -298,8 +200,15 @@ Dolphin* dolphin_alloc() {
dolphin->state = dolphin_state_alloc();
// Menu
dolphin->menu_vm = furi_record_open("menu");
// Scene thread
dolphin->scene_thread = furi_thread_alloc();
// GUI
dolphin->gui = furi_record_open("gui");
// Dispatcher
dolphin->idle_view_dispatcher = view_dispatcher_alloc();
// First start View
dolphin->idle_view_first_start = view_alloc();
view_allocate_model(
@@ -309,6 +218,7 @@ Dolphin* dolphin_alloc() {
view_set_input_callback(dolphin->idle_view_first_start, dolphin_view_first_start_input);
view_dispatcher_add_view(
dolphin->idle_view_dispatcher, DolphinViewFirstStart, dolphin->idle_view_first_start);
// Main Idle View
dolphin->idle_view_main = view_alloc();
view_set_context(dolphin->idle_view_main, dolphin);
@@ -319,6 +229,7 @@ Dolphin* dolphin_alloc() {
view_set_input_callback(dolphin->idle_view_main, dolphin_view_idle_main_input);
view_dispatcher_add_view(
dolphin->idle_view_dispatcher, DolphinViewIdleMain, dolphin->idle_view_main);
// Stats Idle View
dolphin->idle_view_up = view_alloc();
view_set_context(dolphin->idle_view_up, dolphin);
@@ -330,6 +241,7 @@ Dolphin* dolphin_alloc() {
view_set_previous_callback(dolphin->idle_view_up, dolphin_view_idle_back);
view_dispatcher_add_view(
dolphin->idle_view_dispatcher, DolphinViewIdleUp, dolphin->idle_view_up);
// Lock Menu View
dolphin->view_lockmenu = view_alloc();
view_set_context(dolphin->view_lockmenu, dolphin);
@@ -340,22 +252,14 @@ Dolphin* dolphin_alloc() {
view_set_previous_callback(dolphin->view_lockmenu, dolphin_view_idle_back);
view_dispatcher_add_view(
dolphin->idle_view_dispatcher, DolphinViewLockMenu, dolphin->view_lockmenu);
// Meta View
dolphin->idle_view_meta = view_alloc();
view_set_context(dolphin->idle_view_meta, dolphin);
view_allocate_model(
dolphin->idle_view_meta, ViewModelTypeLockFree, sizeof(DolphinViewMenuModel));
view_set_draw_callback(dolphin->idle_view_meta, dolphin_view_idle_meta_draw);
view_set_input_callback(dolphin->idle_view_meta, dolphin_view_idle_meta_input);
view_set_previous_callback(dolphin->idle_view_meta, dolphin_view_idle_back);
view_dispatcher_add_view(
dolphin->idle_view_dispatcher, DolphinViewIdleMeta, dolphin->idle_view_meta);
// Down Idle View
dolphin->idle_view_down = view_alloc();
view_set_draw_callback(dolphin->idle_view_down, dolphin_view_idle_down_draw);
view_set_previous_callback(dolphin->idle_view_down, dolphin_view_idle_back);
view_dispatcher_add_view(
dolphin->idle_view_dispatcher, DolphinViewIdleDown, dolphin->idle_view_down);
// HW Mismatch
dolphin->view_hw_mismatch = view_alloc();
view_set_draw_callback(dolphin->view_hw_mismatch, dolphin_view_hw_mismatch_draw);
@@ -370,18 +274,40 @@ Dolphin* dolphin_alloc() {
view_port_draw_callback_set(dolphin->lock_viewport, lock_icon_callback, dolphin);
view_port_enabled_set(dolphin->lock_viewport, false);
// Passport
dolphin->passport = view_port_alloc();
view_port_draw_callback_set(dolphin->passport, draw_passport_callback, dolphin);
view_port_input_callback_set(dolphin->passport, passport_input_callback, dolphin);
view_port_enabled_set(dolphin->passport, false);
// Main screen animation
dolphin_scene_handler_set_scene(dolphin, idle_scenes[random() % sizeof(idle_scenes)]);
view_dispatcher_attach_to_gui(
dolphin->idle_view_dispatcher, dolphin->gui, ViewDispatcherTypeWindow);
gui_add_view_port(dolphin->gui, dolphin->lock_viewport, GuiLayerStatusBarLeft);
return dolphin;
}
void dolphin_free(Dolphin* dolphin) {
furi_assert(dolphin);
gui_remove_view_port(dolphin->gui, dolphin->lock_viewport);
view_port_free(dolphin->lock_viewport);
icon_free(dolphin->lock_icon);
view_dispatcher_free(dolphin->idle_view_dispatcher);
furi_record_close("gui");
dolphin->gui = NULL;
furi_thread_free(dolphin->scene_thread);
furi_record_close("menu");
dolphin->menu_vm = NULL;
dolphin_state_free(dolphin->state);
osMessageQueueDelete(dolphin->event_queue);
free(dolphin);
}
void dolphin_save(Dolphin* dolphin) {
furi_assert(dolphin);
DolphinEvent event;
@@ -400,13 +326,6 @@ void dolphin_deed(Dolphin* dolphin, DolphinDeed deed) {
int32_t dolphin_task() {
Dolphin* dolphin = dolphin_alloc();
Gui* gui = furi_record_open("gui");
view_dispatcher_attach_to_gui(dolphin->idle_view_dispatcher, gui, ViewDispatcherTypeWindow);
gui_add_view_port(gui, dolphin->lock_viewport, GuiLayerStatusBarLeft);
gui_add_view_port(gui, dolphin->passport, GuiLayerFullscreen);
if(dolphin_state_load(dolphin->state)) {
view_dispatcher_switch_to_view(dolphin->idle_view_dispatcher, DolphinViewIdleMain);
} else {
@@ -439,5 +358,6 @@ int32_t dolphin_task() {
dolphin_state_save(dolphin->state);
}
}
dolphin_free(dolphin);
return 0;
}

6
applications/dolphin/dolphin_i.h
View File

@@ -33,7 +33,10 @@ struct Dolphin {
DolphinState* state;
// Menu
ValueMutex* menu_vm;
// Scene
FuriThread* scene_thread;
// GUI
Gui* gui;
ViewDispatcher* idle_view_dispatcher;
View* idle_view_first_start;
View* idle_view_main;
@@ -42,7 +45,6 @@ struct Dolphin {
View* idle_view_meta;
View* view_hw_mismatch;
View* view_lockmenu;
ViewPort* passport;
ViewPort* lock_viewport;
Icon* lock_icon;
@@ -55,6 +57,8 @@ const IconName idle_scenes[] = {A_Wink_128x64, A_WatchingTV_128x64};
Dolphin* dolphin_alloc();
void dolphin_free(Dolphin* dolphin);
/* Save Dolphin state (write to permanent memory)
* Thread safe
*/

2
applications/dolphin/dolphin_state.c
View File

@@ -40,7 +40,7 @@ DolphinState* dolphin_state_alloc() {
return dolphin_state;
}
void dolphin_state_release(DolphinState* dolphin_state) {
void dolphin_state_free(DolphinState* dolphin_state) {
free(dolphin_state);
}

2
applications/dolphin/dolphin_state.h
View File

@@ -8,7 +8,7 @@ typedef struct DolphinState DolphinState;
DolphinState* dolphin_state_alloc();
void dolphin_state_release(DolphinState* dolphin_state);
void dolphin_state_free(DolphinState* dolphin_state);
bool dolphin_state_save(DolphinState* dolphin_state);

26
applications/dolphin/dolphin_views.c
View File

@@ -5,7 +5,6 @@
#include <api-hal.h>
static char* Lockmenu_Items[3] = {"Lock", "Set PIN", "DUMB mode"};
static char* Meta_Items[3] = {"Passport", "Games", "???"};
void dolphin_view_first_start_draw(Canvas* canvas, void* model) {
DolphinViewFirstStartModel* m = model;
@@ -58,7 +57,7 @@ void dolphin_view_first_start_draw(Canvas* canvas, void* model) {
void dolphin_view_idle_main_draw(Canvas* canvas, void* model) {
canvas_clear(canvas);
DolphinViewMainModel* m = model;
if(m->animation) canvas_draw_icon(canvas, 0, 0, m->animation);
if(m->animation) canvas_draw_icon(canvas, 0, -3, m->animation);
}
void dolphin_view_idle_up_draw(Canvas* canvas, void* model) {
@@ -92,29 +91,6 @@ void dolphin_view_lockmenu_draw(Canvas* canvas, void* model) {
}
}
void dolphin_view_idle_meta_draw(Canvas* canvas, void* model) {
DolphinViewMenuModel* m = model;
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontSecondary);
canvas_draw_icon_name(canvas, 20, 23, I_BigProfile_24x24);
canvas_draw_icon_name(canvas, 55, 23, I_BigGames_24x24);
canvas_draw_icon_name(canvas, 90, 23, I_BigBurger_24x24);
canvas_draw_str_aligned(canvas, 66, 12, AlignCenter, AlignCenter, Meta_Items[m->idx]);
canvas_draw_frame(canvas, 17 + (35 * m->idx), 20, 30, 30);
canvas_set_color(canvas, ColorWhite);
canvas_draw_dot(canvas, 17 + (35 * m->idx), 20);
canvas_draw_dot(canvas, 17 + (35 * m->idx), 49);
canvas_draw_dot(canvas, 46 + (35 * m->idx), 20);
canvas_draw_dot(canvas, 46 + (35 * m->idx), 49);
canvas_set_color(canvas, ColorBlack);
}
void dolphin_view_idle_down_draw(Canvas* canvas, void* model) {
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);

5
applications/dolphin/dolphin_views.h
View File

@@ -8,13 +8,12 @@
// Idle scree
typedef enum {
DolphinViewFirstStart,
DolphinViewIdleMain,
DolphinViewFirstStart,
DolphinViewIdleUp,
DolphinViewIdleDown,
DolphinViewHwMismatch,
DolphinViewLockMenu,
DolphinViewIdleMeta,
} DolphinViewIdle;
typedef struct {
@@ -48,8 +47,6 @@ void dolphin_view_lockmenu_draw(Canvas* canvas, void* model);
void dolphin_view_idle_down_draw(Canvas* canvas, void* model);
void dolphin_view_idle_meta_draw(Canvas* canvas, void* model);
void dolphin_view_hw_mismatch_draw(Canvas* canvas, void* model);
uint32_t dolphin_view_idle_back(void* context);