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

[FL-2815, FL-2821] Dummy mode (#1739)

Browse Source 
* Dummy mode implementation
* dumb -> dummy
* F7: Add new api_symbols: game icon
* Starting snake game from dummy mode

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
This commit is contained in:
Nikolay Minaylov
2022-09-19 16:03:42 +03:00
committed by GitHub
parent 3d3c422751
commit d80329b323
21 changed files with 216 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
applications/services/desktop/views/desktop_events.h
View File

@@ -7,9 +7,11 @@ typedef enum {
DesktopMainEventOpenFavoriteSecondary,
DesktopMainEventOpenMenu,
DesktopMainEventOpenDebug,
DesktopMainEventOpenPassport, /**< Broken, don't use it */
DesktopMainEventOpenPassport,
DesktopMainEventOpenPowerOff,
DesktopMainEventOpenGameMenu,
DesktopLockedEventUnlocked,
DesktopLockedEventUpdate,
DesktopLockedEventShowPinInput,
@@ -28,7 +30,8 @@ typedef enum {
DesktopLockMenuEventLock,
DesktopLockMenuEventPinLock,
DesktopLockMenuEventExit,
DesktopLockMenuEventDummyModeOn,
DesktopLockMenuEventDummyModeOff,
DesktopAnimationEventCheckAnimation,
DesktopAnimationEventNewIdleAnimation,

128
applications/services/desktop/views/desktop_view_lock_menu.c
View File

@@ -4,7 +4,13 @@
#include "../desktop_i.h"
#include "desktop_view_lock_menu.h"
#define LOCK_MENU_ITEMS_NB 3
typedef enum {
DesktopLockMenuIndexLock,
DesktopLockMenuIndexPinLock,
DesktopLockMenuIndexDummy,
DesktopLockMenuIndexTotalCount
} DesktopLockMenuIndex;
void desktop_lock_menu_set_callback(
DesktopLockMenuView* lock_menu,
@@ -16,16 +22,24 @@ void desktop_lock_menu_set_callback(
lock_menu->context = context;
}
void desktop_lock_menu_pin_set(DesktopLockMenuView* lock_menu, bool pin_is_set) {
void desktop_lock_menu_set_pin_state(DesktopLockMenuView* lock_menu, bool pin_is_set) {
with_view_model(
lock_menu->view, (DesktopLockMenuViewModel * model) {
model->pin_set = pin_is_set;
model->pin_is_set = pin_is_set;
return true;
});
}
void desktop_lock_menu_set_dummy_mode_state(DesktopLockMenuView* lock_menu, bool dummy_mode) {
with_view_model(
lock_menu->view, (DesktopLockMenuViewModel * model) {
model->dummy_mode = dummy_mode;
return true;
});
}
void desktop_lock_menu_set_idx(DesktopLockMenuView* lock_menu, uint8_t idx) {
furi_assert(idx < LOCK_MENU_ITEMS_NB);
furi_assert(idx < DesktopLockMenuIndexTotalCount);
with_view_model(
lock_menu->view, (DesktopLockMenuViewModel * model) {
model->idx = idx;
@@ -33,43 +47,34 @@ void desktop_lock_menu_set_idx(DesktopLockMenuView* lock_menu, uint8_t idx) {
});
}
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"};
void desktop_lock_menu_draw_callback(Canvas* canvas, void* model) {
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];
for(uint8_t i = 0; i < DesktopLockMenuIndexTotalCount; ++i) {
const char* str = NULL;
if(i == 1 && !m->pin_set) str = "Set PIN";
if(m->hint_timeout && m->idx == 2 && m->idx == i) str = "Not Implemented";
if(i == DesktopLockMenuIndexLock) {
str = "Lock";
} else if(i == DesktopLockMenuIndexPinLock) {
if(m->pin_is_set) {
str = "Lock with PIN";
} else {
str = "Set PIN";
}
} else if(i == DesktopLockMenuIndexDummy) {
if(m->dummy_mode) {
str = "Brainiac Mode";
} else {
str = "Dummy Mode";
}
}
if(str != NULL)
if(str)
canvas_draw_str_aligned(
canvas, 64, 9 + (i * 17) + STATUS_BAR_Y_SHIFT, AlignCenter, AlignCenter, str);
@@ -82,33 +87,58 @@ View* desktop_lock_menu_get_view(DesktopLockMenuView* lock_menu) {
return lock_menu->view;
}
bool desktop_lock_menu_input(InputEvent* event, void* context) {
bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
furi_assert(event);
furi_assert(context);
DesktopLockMenuView* lock_menu = context;
uint8_t idx;
uint8_t idx = 0;
bool consumed = false;
bool dummy_mode = false;
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);
bool ret = false;
if((event->type == InputTypeShort) || (event->type == InputTypeRepeat)) {
if(event->key == InputKeyUp) {
if(model->idx == 0) {
model->idx = DesktopLockMenuIndexTotalCount - 1;
} else {
model->idx = CLAMP(model->idx - 1, DesktopLockMenuIndexTotalCount - 1, 0);
}
ret = true;
consumed = true;
} else if(event->key == InputKeyDown) {
if(model->idx == DesktopLockMenuIndexTotalCount - 1) {
model->idx = 0;
} else {
model->idx = CLAMP(model->idx + 1, DesktopLockMenuIndexTotalCount - 1, 0);
}
ret = true;
consumed = true;
}
}
idx = model->idx;
return true;
dummy_mode = model->dummy_mode;
return ret;
});
if(event->key == InputKeyBack) {
lock_menu->callback(DesktopLockMenuEventExit, lock_menu->context);
} else if(event->key == InputKeyOk) {
lock_menu_callback(lock_menu, idx);
if(event->key == InputKeyOk) {
if((idx == DesktopLockMenuIndexLock) && (event->type == InputTypeShort)) {
lock_menu->callback(DesktopLockMenuEventLock, lock_menu->context);
} else if((idx == DesktopLockMenuIndexPinLock) && (event->type == InputTypeShort)) {
lock_menu->callback(DesktopLockMenuEventPinLock, lock_menu->context);
} else if(idx == DesktopLockMenuIndexDummy) {
if((dummy_mode == false) && (event->type == InputTypeShort)) {
lock_menu->callback(DesktopLockMenuEventDummyModeOn, lock_menu->context);
} else if((dummy_mode == true) && (event->type == InputTypeShort)) {
lock_menu->callback(DesktopLockMenuEventDummyModeOff, lock_menu->context);
}
}
consumed = true;
}
return true;
return consumed;
}
DesktopLockMenuView* desktop_lock_menu_alloc() {
@@ -116,8 +146,8 @@ DesktopLockMenuView* desktop_lock_menu_alloc() {
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);
view_set_draw_callback(lock_menu->view, (ViewDrawCallback)desktop_lock_menu_draw_callback);
view_set_input_callback(lock_menu->view, desktop_lock_menu_input_callback);
return lock_menu;
}

7
applications/services/desktop/views/desktop_view_lock_menu.h
View File

@@ -17,8 +17,8 @@ struct DesktopLockMenuView {
typedef struct {
uint8_t idx;
uint8_t hint_timeout;
bool pin_set;
bool pin_is_set;
bool dummy_mode;
} DesktopLockMenuViewModel;
void desktop_lock_menu_set_callback(
@@ -27,7 +27,8 @@ void desktop_lock_menu_set_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_pin_state(DesktopLockMenuView* lock_menu, bool pin_is_set);
void desktop_lock_menu_set_dummy_mode_state(DesktopLockMenuView* lock_menu, bool dummy_mode);
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);

56
applications/services/desktop/views/desktop_view_main.c
View File

@@ -14,6 +14,7 @@ struct DesktopMainView {
DesktopMainViewCallback callback;
void* context;
TimerHandle_t poweroff_timer;
bool dummy_mode;
};
#define DESKTOP_MAIN_VIEW_POWEROFF_TIMEOUT 5000
@@ -38,29 +39,48 @@ View* desktop_main_get_view(DesktopMainView* main_view) {
return main_view->view;
}
bool desktop_main_input(InputEvent* event, void* context) {
void desktop_main_set_dummy_mode_state(DesktopMainView* main_view, bool dummy_mode) {
furi_assert(main_view);
main_view->dummy_mode = dummy_mode;
}
bool desktop_main_input_callback(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);
if(main_view->dummy_mode == false) {
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);
}
// Right key is handled by animation manager
} 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);
}
}
} 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);
} else {
if(event->type == InputTypeShort) {
if(event->key == InputKeyOk) {
main_view->callback(DesktopMainEventOpenGameMenu, main_view->context);
} else if(event->key == InputKeyUp) {
main_view->callback(DesktopMainEventOpenLockMenu, main_view->context);
} else if(event->key == InputKeyDown) {
main_view->callback(DesktopMainEventOpenPassport, main_view->context);
} else if(event->key == InputKeyLeft) {
main_view->callback(DesktopMainEventOpenPassport, main_view->context);
}
// Right key is handled by animation manager
}
}
@@ -84,7 +104,7 @@ DesktopMainView* desktop_main_alloc() {
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);
view_set_input_callback(main_view->view, desktop_main_input_callback);
main_view->poweroff_timer = xTimerCreate(
NULL,

1
applications/services/desktop/views/desktop_view_main.h
View File

@@ -13,5 +13,6 @@ void desktop_main_set_callback(
void* context);
View* desktop_main_get_view(DesktopMainView* main_view);
void desktop_main_set_dummy_mode_state(DesktopMainView* main_view, bool dummy_mode);
DesktopMainView* desktop_main_alloc();
void desktop_main_free(DesktopMainView* main_view);