2022-02-10 21:17:41 +03:00
|
|
|
#include "applications.h"
|
[FL-2183] [FL-2209] Dolphin Deeds, Level up, assets generation, refactoring (#965)
* 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>
2022-01-29 12:20:41 +03:00
|
|
|
#include <furi.h>
|
2021-10-13 18:39:37 +03:00
|
|
|
#include "loader/loader.h"
|
2021-07-18 21:09:00 +03:00
|
|
|
#include "loader_i.h"
|
|
|
|
|
2021-11-12 16:04:35 +03:00
|
|
|
#define TAG "LoaderSrv"
|
|
|
|
|
2021-09-28 16:10:13 +03:00
|
|
|
#define LOADER_THREAD_FLAG_SHOW_MENU (1 << 0)
|
|
|
|
#define LOADER_THREAD_FLAG_ALL (LOADER_THREAD_FLAG_SHOW_MENU)
|
|
|
|
|
2021-07-18 21:09:00 +03:00
|
|
|
static Loader* loader_instance = NULL;
|
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
static bool
|
|
|
|
loader_start_application(const FlipperApplication* application, const char* arguments) {
|
|
|
|
loader_instance->application = application;
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
furi_assert(loader_instance->application_arguments == NULL);
|
|
|
|
if(arguments && strlen(arguments) > 0) {
|
|
|
|
loader_instance->application_arguments = strdup(arguments);
|
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
FURI_LOG_I(TAG, "Starting: %s", loader_instance->application->name);
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-11-12 11:46:04 +03:00
|
|
|
FuriHalRtcHeapTrackMode mode = furi_hal_rtc_get_heap_track_mode();
|
|
|
|
if(mode > FuriHalRtcHeapTrackModeNone) {
|
|
|
|
furi_thread_enable_heap_trace(loader_instance->application_thread);
|
|
|
|
} else {
|
|
|
|
furi_thread_disable_heap_trace(loader_instance->application_thread);
|
|
|
|
}
|
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
furi_thread_set_name(loader_instance->application_thread, loader_instance->application->name);
|
|
|
|
furi_thread_set_stack_size(
|
|
|
|
loader_instance->application_thread, loader_instance->application->stack_size);
|
|
|
|
furi_thread_set_context(
|
|
|
|
loader_instance->application_thread, loader_instance->application_arguments);
|
|
|
|
furi_thread_set_callback(
|
|
|
|
loader_instance->application_thread, loader_instance->application->app);
|
|
|
|
|
2022-06-20 17:54:48 +03:00
|
|
|
furi_thread_start(loader_instance->application_thread);
|
2022-02-10 14:20:50 +03:00
|
|
|
|
2022-06-20 17:54:48 +03:00
|
|
|
return true;
|
2022-02-10 14:20:50 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void loader_menu_callback(void* _ctx, uint32_t index) {
|
2022-05-06 16:37:10 +03:00
|
|
|
UNUSED(index);
|
2022-02-10 14:20:50 +03:00
|
|
|
const FlipperApplication* application = _ctx;
|
|
|
|
|
|
|
|
furi_assert(application->app);
|
|
|
|
furi_assert(application->name);
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
if(!loader_lock(loader_instance)) {
|
|
|
|
FURI_LOG_E(TAG, "Loader is locked");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
loader_start_application(application, NULL);
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
2021-09-28 16:10:13 +03:00
|
|
|
static void loader_submenu_callback(void* context, uint32_t index) {
|
2022-05-06 16:37:10 +03:00
|
|
|
UNUSED(index);
|
2021-09-28 16:10:13 +03:00
|
|
|
uint32_t view_id = (uint32_t)context;
|
|
|
|
view_dispatcher_switch_to_view(loader_instance->view_dispatcher, view_id);
|
|
|
|
}
|
|
|
|
|
2021-12-24 21:47:48 +03:00
|
|
|
static void loader_cli_print_usage() {
|
|
|
|
printf("Usage:\r\n");
|
|
|
|
printf("loader <cmd> <args>\r\n");
|
|
|
|
printf("Cmd list:\r\n");
|
|
|
|
printf("\tlist\t - List available applications\r\n");
|
|
|
|
printf("\topen <Application Name:string>\t - Open application by name\r\n");
|
2022-10-07 15:46:58 +03:00
|
|
|
printf("\tinfo\t - Show loader state\r\n");
|
2021-12-24 21:47:48 +03:00
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-04-13 23:50:25 +03:00
|
|
|
static FlipperApplication const* loader_find_application_by_name_in_list(
|
|
|
|
const char* name,
|
|
|
|
const FlipperApplication* list,
|
|
|
|
const uint32_t n_apps) {
|
|
|
|
for(size_t i = 0; i < n_apps; i++) {
|
|
|
|
if(strcmp(name, list[i].name) == 0) {
|
|
|
|
return &list[i];
|
2021-12-24 21:47:48 +03:00
|
|
|
}
|
|
|
|
}
|
2022-04-13 23:50:25 +03:00
|
|
|
return NULL;
|
|
|
|
}
|
2021-12-24 21:47:48 +03:00
|
|
|
|
2022-04-13 23:50:25 +03:00
|
|
|
const FlipperApplication* loader_find_application_by_name(const char* name) {
|
|
|
|
const FlipperApplication* application = NULL;
|
|
|
|
application = loader_find_application_by_name_in_list(name, FLIPPER_APPS, FLIPPER_APPS_COUNT);
|
|
|
|
if(!application) {
|
|
|
|
application =
|
|
|
|
loader_find_application_by_name_in_list(name, FLIPPER_PLUGINS, FLIPPER_PLUGINS_COUNT);
|
2021-12-24 21:47:48 +03:00
|
|
|
}
|
2022-04-13 23:50:25 +03:00
|
|
|
if(!application) {
|
|
|
|
application = loader_find_application_by_name_in_list(
|
|
|
|
name, FLIPPER_SETTINGS_APPS, FLIPPER_SETTINGS_APPS_COUNT);
|
2022-02-10 21:17:41 +03:00
|
|
|
}
|
2022-04-13 23:50:25 +03:00
|
|
|
if(!application) {
|
|
|
|
application = loader_find_application_by_name_in_list(
|
|
|
|
name, FLIPPER_SYSTEM_APPS, FLIPPER_SYSTEM_APPS_COUNT);
|
|
|
|
}
|
2022-04-19 11:43:58 +03:00
|
|
|
if(!application) {
|
2022-04-13 23:50:25 +03:00
|
|
|
application = loader_find_application_by_name_in_list(
|
|
|
|
name, FLIPPER_DEBUG_APPS, FLIPPER_DEBUG_APPS_COUNT);
|
2021-12-24 21:47:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return application;
|
|
|
|
}
|
|
|
|
|
2022-10-07 15:46:58 +03:00
|
|
|
static void loader_cli_open(Cli* cli, FuriString* args, Loader* instance) {
|
2022-05-06 16:37:10 +03:00
|
|
|
UNUSED(cli);
|
2022-04-15 19:31:25 +03:00
|
|
|
if(loader_is_locked(instance)) {
|
2022-10-07 15:46:58 +03:00
|
|
|
if(instance->application) {
|
|
|
|
furi_assert(instance->application->name);
|
|
|
|
printf("Can't start, %s application is running", instance->application->name);
|
|
|
|
} else {
|
|
|
|
printf("Can't start, furi application is running");
|
|
|
|
}
|
2022-04-15 19:31:25 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
FuriString* application_name;
|
|
|
|
application_name = furi_string_alloc();
|
2021-12-24 21:47:48 +03:00
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
do {
|
|
|
|
if(!args_read_probably_quoted_string_and_trim(args, application_name)) {
|
|
|
|
printf("No application provided\r\n");
|
|
|
|
break;
|
|
|
|
}
|
2021-12-24 21:47:48 +03:00
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
const FlipperApplication* application =
|
2022-10-05 18:15:23 +03:00
|
|
|
loader_find_application_by_name(furi_string_get_cstr(application_name));
|
2022-02-10 14:20:50 +03:00
|
|
|
if(!application) {
|
2022-10-05 18:15:23 +03:00
|
|
|
printf("%s doesn't exists\r\n", furi_string_get_cstr(application_name));
|
2022-02-10 14:20:50 +03:00
|
|
|
break;
|
|
|
|
}
|
2021-12-24 21:47:48 +03:00
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
furi_string_trim(args);
|
|
|
|
if(!loader_start_application(application, furi_string_get_cstr(args))) {
|
2022-02-10 14:20:50 +03:00
|
|
|
printf("Can't start, furi application is running");
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
// We must to increment lock counter to keep balance
|
|
|
|
// TODO: rewrite whole thing, it's complex as hell
|
|
|
|
FURI_CRITICAL_ENTER();
|
|
|
|
instance->lock_count++;
|
|
|
|
FURI_CRITICAL_EXIT();
|
|
|
|
}
|
|
|
|
} while(false);
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
furi_string_free(application_name);
|
2021-12-24 21:47:48 +03:00
|
|
|
}
|
|
|
|
|
2022-10-07 15:46:58 +03:00
|
|
|
static void loader_cli_list(Cli* cli, FuriString* args, Loader* instance) {
|
2022-05-06 16:37:10 +03:00
|
|
|
UNUSED(cli);
|
|
|
|
UNUSED(args);
|
|
|
|
UNUSED(instance);
|
2021-12-24 21:47:48 +03:00
|
|
|
printf("Applications:\r\n");
|
|
|
|
for(size_t i = 0; i < FLIPPER_APPS_COUNT; i++) {
|
|
|
|
printf("\t%s\r\n", FLIPPER_APPS[i].name);
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Plugins:\r\n");
|
|
|
|
for(size_t i = 0; i < FLIPPER_PLUGINS_COUNT; i++) {
|
|
|
|
printf("\t%s\r\n", FLIPPER_PLUGINS[i].name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
|
|
|
|
printf("Debug:\r\n");
|
|
|
|
for(size_t i = 0; i < FLIPPER_DEBUG_APPS_COUNT; i++) {
|
|
|
|
printf("\t%s\r\n", FLIPPER_DEBUG_APPS[i].name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-07 15:46:58 +03:00
|
|
|
static void loader_cli_info(Cli* cli, FuriString* args, Loader* instance) {
|
|
|
|
UNUSED(cli);
|
|
|
|
UNUSED(args);
|
|
|
|
if(!loader_is_locked(instance)) {
|
|
|
|
printf("No application is running\r\n");
|
|
|
|
} else {
|
|
|
|
printf("Running application: ");
|
|
|
|
if(instance->application) {
|
|
|
|
furi_assert(instance->application->name);
|
|
|
|
printf("%s\r\n", instance->application->name);
|
|
|
|
} else {
|
|
|
|
printf("unknown\r\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
static void loader_cli(Cli* cli, FuriString* args, void* _ctx) {
|
2021-12-24 21:47:48 +03:00
|
|
|
furi_assert(_ctx);
|
|
|
|
Loader* instance = _ctx;
|
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
FuriString* cmd;
|
|
|
|
cmd = furi_string_alloc();
|
2021-12-24 21:47:48 +03:00
|
|
|
|
|
|
|
do {
|
|
|
|
if(!args_read_string_and_trim(args, cmd)) {
|
|
|
|
loader_cli_print_usage();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
if(furi_string_cmp_str(cmd, "list") == 0) {
|
2021-12-24 21:47:48 +03:00
|
|
|
loader_cli_list(cli, args, instance);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
if(furi_string_cmp_str(cmd, "open") == 0) {
|
2021-12-24 21:47:48 +03:00
|
|
|
loader_cli_open(cli, args, instance);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-10-07 15:46:58 +03:00
|
|
|
if(furi_string_cmp_str(cmd, "info") == 0) {
|
|
|
|
loader_cli_info(cli, args, instance);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2021-12-24 21:47:48 +03:00
|
|
|
loader_cli_print_usage();
|
|
|
|
} while(false);
|
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
furi_string_free(cmd);
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
2021-10-13 18:39:37 +03:00
|
|
|
LoaderStatus loader_start(Loader* instance, const char* name, const char* args) {
|
2022-05-06 16:37:10 +03:00
|
|
|
UNUSED(instance);
|
2021-07-18 21:09:00 +03:00
|
|
|
furi_assert(name);
|
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
const FlipperApplication* application = loader_find_application_by_name(name);
|
2021-09-28 16:10:13 +03:00
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
if(!application) {
|
2021-11-12 16:04:35 +03:00
|
|
|
FURI_LOG_E(TAG, "Can't find application with name %s", name);
|
2021-10-13 18:39:37 +03:00
|
|
|
return LoaderStatusErrorUnknownApp;
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
if(!loader_lock(loader_instance)) {
|
|
|
|
FURI_LOG_E(TAG, "Loader is locked");
|
2021-10-13 18:39:37 +03:00
|
|
|
return LoaderStatusErrorAppStarted;
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
if(!loader_start_application(application, args)) {
|
|
|
|
return LoaderStatusErrorInternal;
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
return LoaderStatusOk;
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
bool loader_lock(Loader* instance) {
|
2022-02-10 14:20:50 +03:00
|
|
|
FURI_CRITICAL_ENTER();
|
|
|
|
bool result = false;
|
|
|
|
if(instance->lock_count == 0) {
|
|
|
|
instance->lock_count++;
|
|
|
|
result = true;
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
2022-02-10 14:20:50 +03:00
|
|
|
FURI_CRITICAL_EXIT();
|
|
|
|
return result;
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void loader_unlock(Loader* instance) {
|
2022-02-10 14:20:50 +03:00
|
|
|
FURI_CRITICAL_ENTER();
|
|
|
|
if(instance->lock_count > 0) instance->lock_count--;
|
|
|
|
FURI_CRITICAL_EXIT();
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
2021-10-13 18:39:37 +03:00
|
|
|
bool loader_is_locked(Loader* instance) {
|
2022-02-10 14:20:50 +03:00
|
|
|
return instance->lock_count > 0;
|
2021-10-13 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2021-07-18 21:09:00 +03:00
|
|
|
static void loader_thread_state_callback(FuriThreadState thread_state, void* context) {
|
|
|
|
furi_assert(context);
|
|
|
|
|
|
|
|
Loader* instance = context;
|
2022-01-03 00:39:56 +03:00
|
|
|
LoaderEvent event;
|
2021-07-18 21:09:00 +03:00
|
|
|
|
|
|
|
if(thread_state == FuriThreadStateRunning) {
|
2022-01-03 00:39:56 +03:00
|
|
|
event.type = LoaderEventTypeApplicationStarted;
|
|
|
|
furi_pubsub_publish(loader_instance->pubsub, &event);
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
|
2022-11-05 18:07:24 +03:00
|
|
|
if(!(loader_instance->application->flags & FlipperApplicationFlagInsomniaSafe)) {
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
furi_hal_power_insomnia_enter();
|
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
} else if(thread_state == FuriThreadStateStopped) {
|
2022-11-09 20:33:09 +03:00
|
|
|
FURI_LOG_I(TAG, "Application stopped. Free heap: %d", memmgr_get_free_heap());
|
2022-02-10 14:20:50 +03:00
|
|
|
|
|
|
|
if(loader_instance->application_arguments) {
|
|
|
|
free(loader_instance->application_arguments);
|
|
|
|
loader_instance->application_arguments = NULL;
|
|
|
|
}
|
|
|
|
|
2022-11-05 18:07:24 +03:00
|
|
|
if(!(loader_instance->application->flags & FlipperApplicationFlagInsomniaSafe)) {
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
furi_hal_power_insomnia_exit();
|
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
loader_unlock(instance);
|
2022-01-11 20:45:49 +03:00
|
|
|
|
2022-01-03 00:39:56 +03:00
|
|
|
event.type = LoaderEventTypeApplicationStopped;
|
|
|
|
furi_pubsub_publish(loader_instance->pubsub, &event);
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-28 16:10:13 +03:00
|
|
|
static uint32_t loader_hide_menu(void* context) {
|
2022-05-06 16:37:10 +03:00
|
|
|
UNUSED(context);
|
2021-09-28 16:10:13 +03:00
|
|
|
return VIEW_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t loader_back_to_primary_menu(void* context) {
|
2021-11-24 17:05:23 +03:00
|
|
|
furi_assert(context);
|
|
|
|
Submenu* submenu = context;
|
|
|
|
submenu_set_selected_item(submenu, 0);
|
2021-09-28 16:10:13 +03:00
|
|
|
return LoaderMenuViewPrimary;
|
|
|
|
}
|
|
|
|
|
2021-07-18 21:09:00 +03:00
|
|
|
static Loader* loader_alloc() {
|
2022-02-18 22:53:46 +03:00
|
|
|
Loader* instance = malloc(sizeof(Loader));
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
instance->application_thread = furi_thread_alloc();
|
2022-11-12 11:46:04 +03:00
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
furi_thread_set_state_context(instance->application_thread, instance);
|
|
|
|
furi_thread_set_state_callback(instance->application_thread, loader_thread_state_callback);
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-01-03 00:39:56 +03:00
|
|
|
instance->pubsub = furi_pubsub_alloc();
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2021-12-24 21:47:48 +03:00
|
|
|
#ifdef SRV_CLI
|
2022-07-26 15:21:51 +03:00
|
|
|
instance->cli = furi_record_open(RECORD_CLI);
|
|
|
|
cli_add_command(
|
|
|
|
instance->cli, RECORD_LOADER, CliCommandFlagParallelSafe, loader_cli, instance);
|
2022-04-13 23:50:25 +03:00
|
|
|
#else
|
|
|
|
UNUSED(loader_cli);
|
2021-12-24 21:47:48 +03:00
|
|
|
#endif
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-06-20 17:54:48 +03:00
|
|
|
instance->loader_thread = furi_thread_get_current_id();
|
2021-09-28 16:10:13 +03:00
|
|
|
|
|
|
|
// Gui
|
2022-07-26 15:21:51 +03:00
|
|
|
instance->gui = furi_record_open(RECORD_GUI);
|
2021-09-28 16:10:13 +03:00
|
|
|
instance->view_dispatcher = view_dispatcher_alloc();
|
|
|
|
view_dispatcher_attach_to_gui(
|
|
|
|
instance->view_dispatcher, instance->gui, ViewDispatcherTypeFullscreen);
|
|
|
|
// Primary menu
|
|
|
|
instance->primary_menu = menu_alloc();
|
|
|
|
view_set_previous_callback(menu_get_view(instance->primary_menu), loader_hide_menu);
|
|
|
|
view_dispatcher_add_view(
|
|
|
|
instance->view_dispatcher, LoaderMenuViewPrimary, menu_get_view(instance->primary_menu));
|
|
|
|
// Plugins menu
|
|
|
|
instance->plugins_menu = submenu_alloc();
|
2021-11-24 17:05:23 +03:00
|
|
|
view_set_context(submenu_get_view(instance->plugins_menu), instance->plugins_menu);
|
2021-09-28 16:10:13 +03:00
|
|
|
view_set_previous_callback(
|
|
|
|
submenu_get_view(instance->plugins_menu), loader_back_to_primary_menu);
|
|
|
|
view_dispatcher_add_view(
|
|
|
|
instance->view_dispatcher,
|
|
|
|
LoaderMenuViewPlugins,
|
|
|
|
submenu_get_view(instance->plugins_menu));
|
|
|
|
// Debug menu
|
|
|
|
instance->debug_menu = submenu_alloc();
|
2021-11-24 17:05:23 +03:00
|
|
|
view_set_context(submenu_get_view(instance->debug_menu), instance->debug_menu);
|
2021-09-28 16:10:13 +03:00
|
|
|
view_set_previous_callback(
|
|
|
|
submenu_get_view(instance->debug_menu), loader_back_to_primary_menu);
|
|
|
|
view_dispatcher_add_view(
|
|
|
|
instance->view_dispatcher, LoaderMenuViewDebug, submenu_get_view(instance->debug_menu));
|
|
|
|
// Settings menu
|
|
|
|
instance->settings_menu = submenu_alloc();
|
2021-11-24 17:05:23 +03:00
|
|
|
view_set_context(submenu_get_view(instance->settings_menu), instance->settings_menu);
|
2021-09-28 16:10:13 +03:00
|
|
|
view_set_previous_callback(
|
|
|
|
submenu_get_view(instance->settings_menu), loader_back_to_primary_menu);
|
|
|
|
view_dispatcher_add_view(
|
|
|
|
instance->view_dispatcher,
|
|
|
|
LoaderMenuViewSettings,
|
|
|
|
submenu_get_view(instance->settings_menu));
|
|
|
|
|
|
|
|
view_dispatcher_enable_queue(instance->view_dispatcher);
|
|
|
|
|
2021-07-18 21:09:00 +03:00
|
|
|
return instance;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void loader_free(Loader* instance) {
|
|
|
|
furi_assert(instance);
|
|
|
|
|
2021-12-24 21:47:48 +03:00
|
|
|
if(instance->cli) {
|
2022-07-26 15:21:51 +03:00
|
|
|
furi_record_close(RECORD_CLI);
|
2021-12-24 21:47:48 +03:00
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-01-03 00:39:56 +03:00
|
|
|
furi_pubsub_free(instance->pubsub);
|
|
|
|
|
2022-02-10 14:20:50 +03:00
|
|
|
furi_thread_free(instance->application_thread);
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2021-09-28 16:10:13 +03:00
|
|
|
menu_free(loader_instance->primary_menu);
|
|
|
|
view_dispatcher_remove_view(loader_instance->view_dispatcher, LoaderMenuViewPrimary);
|
|
|
|
submenu_free(loader_instance->plugins_menu);
|
|
|
|
view_dispatcher_remove_view(loader_instance->view_dispatcher, LoaderMenuViewPlugins);
|
|
|
|
submenu_free(loader_instance->debug_menu);
|
|
|
|
view_dispatcher_remove_view(loader_instance->view_dispatcher, LoaderMenuViewDebug);
|
|
|
|
submenu_free(loader_instance->settings_menu);
|
|
|
|
view_dispatcher_remove_view(loader_instance->view_dispatcher, LoaderMenuViewSettings);
|
|
|
|
view_dispatcher_free(loader_instance->view_dispatcher);
|
|
|
|
|
2022-07-26 15:21:51 +03:00
|
|
|
furi_record_close(RECORD_GUI);
|
2021-09-28 16:10:13 +03:00
|
|
|
|
2021-07-18 21:09:00 +03:00
|
|
|
free(instance);
|
2021-09-28 16:10:13 +03:00
|
|
|
instance = NULL;
|
|
|
|
}
|
|
|
|
|
2021-07-18 21:09:00 +03:00
|
|
|
static void loader_build_menu() {
|
2021-11-12 16:04:35 +03:00
|
|
|
FURI_LOG_I(TAG, "Building main menu");
|
2021-09-28 16:10:13 +03:00
|
|
|
size_t i;
|
|
|
|
for(i = 0; i < FLIPPER_APPS_COUNT; i++) {
|
|
|
|
menu_add_item(
|
|
|
|
loader_instance->primary_menu,
|
|
|
|
FLIPPER_APPS[i].name,
|
2021-12-15 15:23:16 +03:00
|
|
|
FLIPPER_APPS[i].icon,
|
2021-09-28 16:10:13 +03:00
|
|
|
i,
|
|
|
|
loader_menu_callback,
|
|
|
|
(void*)&FLIPPER_APPS[i]);
|
|
|
|
}
|
2021-12-24 21:47:48 +03:00
|
|
|
if(FLIPPER_PLUGINS_COUNT != 0) {
|
|
|
|
menu_add_item(
|
|
|
|
loader_instance->primary_menu,
|
|
|
|
"Plugins",
|
|
|
|
&A_Plugins_14,
|
|
|
|
i++,
|
|
|
|
loader_submenu_callback,
|
|
|
|
(void*)LoaderMenuViewPlugins);
|
|
|
|
}
|
2022-09-14 19:11:38 +03:00
|
|
|
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug) && (FLIPPER_DEBUG_APPS_COUNT > 0)) {
|
2021-12-15 15:23:16 +03:00
|
|
|
menu_add_item(
|
|
|
|
loader_instance->primary_menu,
|
2022-04-11 14:54:38 +03:00
|
|
|
"Debug Tools",
|
2021-12-15 15:23:16 +03:00
|
|
|
&A_Debug_14,
|
|
|
|
i++,
|
|
|
|
loader_submenu_callback,
|
|
|
|
(void*)LoaderMenuViewDebug);
|
|
|
|
}
|
2021-09-28 16:10:13 +03:00
|
|
|
menu_add_item(
|
|
|
|
loader_instance->primary_menu,
|
|
|
|
"Settings",
|
2021-12-15 15:23:16 +03:00
|
|
|
&A_Settings_14,
|
2021-09-28 16:10:13 +03:00
|
|
|
i++,
|
|
|
|
loader_submenu_callback,
|
|
|
|
(void*)LoaderMenuViewSettings);
|
2021-12-15 15:23:16 +03:00
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2021-12-15 15:23:16 +03:00
|
|
|
static void loader_build_submenu() {
|
2021-11-12 16:04:35 +03:00
|
|
|
FURI_LOG_I(TAG, "Building plugins menu");
|
2021-12-15 15:23:16 +03:00
|
|
|
size_t i;
|
2021-09-28 16:10:13 +03:00
|
|
|
for(i = 0; i < FLIPPER_PLUGINS_COUNT; i++) {
|
|
|
|
submenu_add_item(
|
|
|
|
loader_instance->plugins_menu,
|
|
|
|
FLIPPER_PLUGINS[i].name,
|
|
|
|
i,
|
|
|
|
loader_menu_callback,
|
|
|
|
(void*)&FLIPPER_PLUGINS[i]);
|
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2021-11-12 16:04:35 +03:00
|
|
|
FURI_LOG_I(TAG, "Building debug menu");
|
2021-09-28 16:10:13 +03:00
|
|
|
for(i = 0; i < FLIPPER_DEBUG_APPS_COUNT; i++) {
|
|
|
|
submenu_add_item(
|
|
|
|
loader_instance->debug_menu,
|
|
|
|
FLIPPER_DEBUG_APPS[i].name,
|
|
|
|
i,
|
|
|
|
loader_menu_callback,
|
|
|
|
(void*)&FLIPPER_DEBUG_APPS[i]);
|
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2021-11-12 16:04:35 +03:00
|
|
|
FURI_LOG_I(TAG, "Building settings menu");
|
2021-09-28 16:10:13 +03:00
|
|
|
for(i = 0; i < FLIPPER_SETTINGS_APPS_COUNT; i++) {
|
|
|
|
submenu_add_item(
|
|
|
|
loader_instance->settings_menu,
|
|
|
|
FLIPPER_SETTINGS_APPS[i].name,
|
|
|
|
i,
|
|
|
|
loader_menu_callback,
|
|
|
|
(void*)&FLIPPER_SETTINGS_APPS[i]);
|
|
|
|
}
|
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2021-09-28 16:10:13 +03:00
|
|
|
void loader_show_menu() {
|
|
|
|
furi_assert(loader_instance);
|
2022-06-20 17:54:48 +03:00
|
|
|
furi_thread_flags_set(loader_instance->loader_thread, LOADER_THREAD_FLAG_SHOW_MENU);
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
2021-12-15 15:23:16 +03:00
|
|
|
void loader_update_menu() {
|
2022-01-21 20:32:03 +03:00
|
|
|
menu_reset(loader_instance->primary_menu);
|
2021-12-15 15:23:16 +03:00
|
|
|
loader_build_menu();
|
|
|
|
}
|
|
|
|
|
2021-08-07 19:54:42 +03:00
|
|
|
int32_t loader_srv(void* p) {
|
2022-05-06 16:37:10 +03:00
|
|
|
UNUSED(p);
|
2022-04-19 02:09:11 +03:00
|
|
|
FURI_LOG_I(TAG, "Executing system start hooks");
|
|
|
|
for(size_t i = 0; i < FLIPPER_ON_SYSTEM_START_COUNT; i++) {
|
|
|
|
FLIPPER_ON_SYSTEM_START[i]();
|
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-04-19 02:09:11 +03:00
|
|
|
FURI_LOG_I(TAG, "Starting");
|
2021-07-18 21:09:00 +03:00
|
|
|
loader_instance = loader_alloc();
|
|
|
|
|
|
|
|
loader_build_menu();
|
2021-12-15 15:23:16 +03:00
|
|
|
loader_build_submenu();
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2021-11-12 16:04:35 +03:00
|
|
|
FURI_LOG_I(TAG, "Started");
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-07-26 15:21:51 +03:00
|
|
|
furi_record_create(RECORD_LOADER, loader_instance);
|
2021-07-18 21:09:00 +03:00
|
|
|
|
2022-08-13 01:17:11 +03:00
|
|
|
if(FLIPPER_AUTORUN_APP_NAME && strlen(FLIPPER_AUTORUN_APP_NAME)) {
|
|
|
|
loader_start(loader_instance, FLIPPER_AUTORUN_APP_NAME, NULL);
|
|
|
|
}
|
2021-09-28 16:10:13 +03:00
|
|
|
|
2021-07-18 21:09:00 +03:00
|
|
|
while(1) {
|
2022-06-20 17:54:48 +03:00
|
|
|
uint32_t flags =
|
2022-07-20 13:56:33 +03:00
|
|
|
furi_thread_flags_wait(LOADER_THREAD_FLAG_ALL, FuriFlagWaitAny, FuriWaitForever);
|
2021-09-28 16:10:13 +03:00
|
|
|
if(flags & LOADER_THREAD_FLAG_SHOW_MENU) {
|
2021-09-29 07:18:28 +03:00
|
|
|
menu_set_selected_item(loader_instance->primary_menu, 0);
|
2021-09-28 16:10:13 +03:00
|
|
|
view_dispatcher_switch_to_view(
|
|
|
|
loader_instance->view_dispatcher, LoaderMenuViewPrimary);
|
|
|
|
view_dispatcher_run(loader_instance->view_dispatcher);
|
|
|
|
}
|
2021-07-18 21:09:00 +03:00
|
|
|
}
|
|
|
|
|
2022-07-26 15:21:51 +03:00
|
|
|
furi_record_destroy(RECORD_LOADER);
|
2021-07-18 21:09:00 +03:00
|
|
|
loader_free(loader_instance);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2022-01-03 00:39:56 +03:00
|
|
|
|
[FL-2183] [FL-2209] Dolphin Deeds, Level up, assets generation, refactoring (#965)
* 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>
2022-01-29 12:20:41 +03:00
|
|
|
FuriPubSub* loader_get_pubsub(Loader* instance) {
|
|
|
|
return instance->pubsub;
|
2022-04-15 19:31:25 +03:00
|
|
|
}
|