Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-04-24 03:29:57 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'ul-dev' into xfw-dev

Browse Source
This commit is contained in:
Willy-JL
2023-05-06 01:43:09 +01:00
parent 49df6a89b5
commit 8fa7d16c5f
46 changed files with 1007 additions and 721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -2,6 +2,7 @@
*.swp
*.swo
*.gdb_history
*.old
# LSP

6
applications/external/hid_app/views/hid_mouse_jiggler.c vendored
View File

@@ -6,8 +6,6 @@
#define TAG "HidMouseJiggler"
#define LENGTH(x) (int)(sizeof(x) / sizeof((x)[0]))
struct HidMouseJiggler {
View* view;
Hid* hid;
@@ -44,7 +42,7 @@ static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
elements_multiline_text(canvas, AlignLeft, 26, "Interval (ms):");
canvas_set_font(canvas, FontSecondary);
if(model->interval_idx != 0) canvas_draw_icon(canvas, 74, 19, &I_ButtonLeft_4x7);
if(model->interval_idx != LENGTH(intervals) - 1)
if(model->interval_idx != (int)COUNT_OF(intervals) - 1)
canvas_draw_icon(canvas, 80, 19, &I_ButtonRight_4x7);
FuriString* interval_str = furi_string_alloc_printf("%d", intervals[model->interval_idx]);
elements_multiline_text(canvas, 91, 26, furi_string_get_cstr(interval_str));
@@ -116,7 +114,7 @@ static bool hid_mouse_jiggler_input_callback(InputEvent* event, void* context) {
consumed = true;
}
if(event->type == InputTypePress && event->key == InputKeyRight && !model->running &&
model->interval_idx < LENGTH(intervals) - 1) {
model->interval_idx < (int)COUNT_OF(intervals) - 1) {
model->interval_idx++;
consumed = true;
}

6
applications/external/pocsag_pager/views/pocsag_pager_receiver.c vendored
View File

@@ -12,7 +12,7 @@
#define MENU_ITEMS 4u
#define UNLOCK_CNT 3
#define SUBGHZ_RAW_TRESHOLD_MIN -90.0f
#define SUBGHZ_RAW_THRESHOLD_MIN -90.0f
typedef struct {
FuriString* item_str;
@@ -69,10 +69,10 @@ void pcsg_receiver_rssi(PCSGReceiver* instance, float rssi) {
instance->view,
PCSGReceiverModel * model,
{
if(rssi < SUBGHZ_RAW_TRESHOLD_MIN) {
if(rssi < SUBGHZ_RAW_THRESHOLD_MIN) {
model->u_rssi = 0;
} else {
model->u_rssi = (uint8_t)(rssi - SUBGHZ_RAW_TRESHOLD_MIN);
model->u_rssi = (uint8_t)(rssi - SUBGHZ_RAW_THRESHOLD_MIN);
}
},
true);

6
applications/external/weather_station/views/weather_station_receiver.c vendored
View File

@@ -12,7 +12,7 @@
#define MENU_ITEMS 4u
#define UNLOCK_CNT 3
#define SUBGHZ_RAW_TRESHOLD_MIN -90.0f
#define SUBGHZ_RAW_THRESHOLD_MIN -90.0f
typedef struct {
FuriString* item_str;
uint8_t type;
@@ -69,10 +69,10 @@ void ws_view_receiver_set_rssi(WSReceiver* instance, float rssi) {
instance->view,
WSReceiverModel * model,
{
if(rssi < SUBGHZ_RAW_TRESHOLD_MIN) {
if(rssi < SUBGHZ_RAW_THRESHOLD_MIN) {
model->u_rssi = 0;
} else {
model->u_rssi = (uint8_t)(rssi - SUBGHZ_RAW_TRESHOLD_MIN);
model->u_rssi = (uint8_t)(rssi - SUBGHZ_RAW_THRESHOLD_MIN);
}
},
true);

28
applications/main/subghz/scenes/subghz_scene_decode_raw.c
View File

@@ -24,14 +24,10 @@
static void subghz_scene_receiver_update_statusbar(void* context) {
SubGhz* subghz = context;
FuriString* history_stat_str;
history_stat_str = furi_string_alloc();
FuriString* history_stat_str = furi_string_alloc();
if(!subghz_history_get_text_space_left(subghz->txrx->history, history_stat_str)) {
FuriString* frequency_str;
FuriString* modulation_str;
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
FuriString* frequency_str = furi_string_alloc();
FuriString* modulation_str = furi_string_alloc();
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
@@ -62,11 +58,9 @@ static void subghz_scene_add_to_history_callback(
void* context) {
furi_assert(context);
SubGhz* subghz = context;
FuriString* item_name;
FuriString* item_time;
FuriString* item_name = furi_string_alloc();
FuriString* item_time = furi_string_alloc();
uint16_t idx = subghz_history_get_item(subghz->txrx->history);
item_name = furi_string_alloc();
item_time = furi_string_alloc();
if(subghz_history_add_to_history(subghz->txrx->history, decoder_base, subghz->txrx->preset)) {
furi_string_reset(item_name);
@@ -90,8 +84,7 @@ static void subghz_scene_add_to_history_callback(
}
bool subghz_scene_decode_raw_start(SubGhz* subghz) {
FuriString* file_name;
file_name = furi_string_alloc();
FuriString* file_name = furi_string_alloc();
bool success = false;
do {
if(!flipper_format_rewind(subghz->txrx->fff_data)) {
@@ -148,8 +141,7 @@ bool subghz_scene_decode_raw_next(SubGhz* subghz) {
}
// Update progress info
FuriString* progress_str;
progress_str = furi_string_alloc();
FuriString* progress_str = furi_string_alloc();
subghz_file_encoder_worker_get_text_progress(
subghz->decode_raw_file_worker_encoder, progress_str);
@@ -164,10 +156,8 @@ bool subghz_scene_decode_raw_next(SubGhz* subghz) {
void subghz_scene_decode_raw_on_enter(void* context) {
SubGhz* subghz = context;
FuriString* item_name;
FuriString* item_time;
item_name = furi_string_alloc();
item_time = furi_string_alloc();
FuriString* item_name = furi_string_alloc();
FuriString* item_time = furi_string_alloc();
subghz_view_receiver_set_lock(subghz->subghz_receiver, subghz->lock);
subghz_view_receiver_set_mode(subghz->subghz_receiver, SubGhzViewReceiverModeFile);

10
applications/main/subghz/scenes/subghz_scene_delete.c
View File

@@ -11,13 +11,9 @@ void subghz_scene_delete_callback(GuiButtonType result, InputType type, void* co
void subghz_scene_delete_on_enter(void* context) {
SubGhz* subghz = context;
FuriString* frequency_str;
FuriString* modulation_str;
FuriString* text;
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
text = furi_string_alloc();
FuriString* frequency_str = furi_string_alloc();
FuriString* modulation_str = furi_string_alloc();
FuriString* text = furi_string_alloc();
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
widget_add_string_element(

7
applications/main/subghz/scenes/subghz_scene_delete_raw.c
View File

@@ -15,11 +15,8 @@ void subghz_scene_delete_raw_callback(GuiButtonType result, InputType type, void
void subghz_scene_delete_raw_on_enter(void* context) {
SubGhz* subghz = context;
FuriString* frequency_str;
FuriString* modulation_str;
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
FuriString* frequency_str = furi_string_alloc();
FuriString* modulation_str = furi_string_alloc();
char delete_str[SUBGHZ_MAX_LEN_NAME + 16];
FuriString* file_name;

16
applications/main/subghz/scenes/subghz_scene_read_raw.c
View File

@@ -12,8 +12,7 @@
bool subghz_scene_read_raw_update_filename(SubGhz* subghz) {
bool ret = false;
//set the path to read the file
FuriString* temp_str;
temp_str = furi_string_alloc();
FuriString* temp_str = furi_string_alloc();
do {
if(!flipper_format_rewind(subghz->txrx->fff_data)) {
FURI_LOG_E(TAG, "Rewind error");
@@ -38,11 +37,8 @@ static void subghz_scene_read_raw_update_statusbar(void* context) {
furi_assert(context);
SubGhz* subghz = context;
FuriString* frequency_str;
FuriString* modulation_str;
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
FuriString* frequency_str = furi_string_alloc();
FuriString* modulation_str = furi_string_alloc();
#ifdef SUBGHZ_EXT_PRESET_NAME
subghz_get_frequency_modulation(subghz, frequency_str, NULL);
@@ -74,8 +70,7 @@ void subghz_scene_read_raw_callback_end_tx(void* context) {
void subghz_scene_read_raw_on_enter(void* context) {
SubGhz* subghz = context;
FuriString* file_name;
file_name = furi_string_alloc();
FuriString* file_name = furi_string_alloc();
switch(subghz->txrx->rx_key_state) {
case SubGhzRxKeyStateBack:
@@ -313,8 +308,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
subghz_protocol_raw_save_to_file_stop(
(SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result);
FuriString* temp_str;
temp_str = furi_string_alloc();
FuriString* temp_str = furi_string_alloc();
furi_string_printf(
temp_str, "%s/%s%s", SUBGHZ_RAW_FOLDER, RAW_FILE_NAME, SUBGHZ_APP_EXTENSION);
subghz_protocol_raw_gen_fff_data(

24
applications/main/subghz/scenes/subghz_scene_receiver.c
View File

@@ -39,14 +39,10 @@ const NotificationSequence subghz_sequence_rx_locked = {
static void subghz_scene_receiver_update_statusbar(void* context) {
SubGhz* subghz = context;
FuriString* history_stat_str;
history_stat_str = furi_string_alloc();
FuriString* history_stat_str = furi_string_alloc();
if(!subghz_history_get_text_space_left(subghz->txrx->history, history_stat_str)) {
FuriString* frequency_str;
FuriString* modulation_str;
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
FuriString* frequency_str = furi_string_alloc();
FuriString* modulation_str = furi_string_alloc();
#ifdef SUBGHZ_EXT_PRESET_NAME
if(subghz_history_get_last_index(subghz->txrx->history) > 0) {
@@ -90,12 +86,12 @@ static void subghz_scene_add_to_history_callback(
SubGhzProtocolDecoderBase* decoder_base,
void* context) {
furi_assert(context);
SubGhz* subghz = context;
FuriString* item_name;
FuriString* item_time;
FuriString* item_name = furi_string_alloc();
FuriString* item_time = furi_string_alloc();
uint16_t idx = subghz_history_get_item(subghz->txrx->history);
item_name = furi_string_alloc();
item_time = furi_string_alloc();
if(subghz_history_add_to_history(subghz->txrx->history, decoder_base, subghz->txrx->preset)) {
furi_string_reset(item_name);
@@ -122,10 +118,8 @@ static void subghz_scene_add_to_history_callback(
void subghz_scene_receiver_on_enter(void* context) {
SubGhz* subghz = context;
FuriString* item_name;
FuriString* item_time;
item_name = furi_string_alloc();
item_time = furi_string_alloc();
FuriString* item_name = furi_string_alloc();
FuriString* item_time = furi_string_alloc();
if(subghz->txrx->rx_key_state == SubGhzRxKeyStateIDLE) {
subghz_preset_init(subghz, "AM650", subghz->last_settings->frequency, NULL, 0);

10
applications/main/subghz/scenes/subghz_scene_receiver_info.c
View File

@@ -49,13 +49,9 @@ static bool subghz_scene_receiver_info_update_parser(void* context) {
void subghz_scene_receiver_info_draw_widget(SubGhz* subghz) {
if(subghz_scene_receiver_info_update_parser(subghz)) {
FuriString* frequency_str;
FuriString* modulation_str;
FuriString* text;
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
text = furi_string_alloc();
FuriString* frequency_str = furi_string_alloc();
FuriString* modulation_str = furi_string_alloc();
FuriString* text = furi_string_alloc();
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
widget_add_string_element(

3
applications/main/subghz/scenes/subghz_scene_rpc.c
View File

@@ -73,8 +73,7 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateLoaded);
furi_string_set(subghz->file_path, arg);
result = true;
FuriString* file_name;
file_name = furi_string_alloc();
FuriString* file_name = furi_string_alloc();
path_extract_filename(subghz->file_path, file_name, true);
snprintf(

8
applications/main/subghz/scenes/subghz_scene_save_name.c
View File

@@ -51,10 +51,8 @@ void subghz_scene_save_name_on_enter(void* context) {
TextInput* text_input = subghz->text_input;
bool dev_name_empty = false;
FuriString* file_name;
FuriString* dir_name;
file_name = furi_string_alloc();
dir_name = furi_string_alloc();
FuriString* file_name = furi_string_alloc();
FuriString* dir_name = furi_string_alloc();
if(!subghz_path_is_file(subghz->file_path)) {
char file_name_buf[SUBGHZ_MAX_LEN_NAME] = {0};
@@ -109,7 +107,7 @@ void subghz_scene_save_name_on_enter(void* context) {
subghz_scene_save_name_text_input_callback,
subghz,
subghz->file_name_tmp,
MAX_TEXT_INPUT_LEN, // buffer size
MAX_TEXT_INPUT_LEN,
dev_name_empty);
ValidatorIsFile* validator_is_file = validator_is_file_alloc_init(

11
applications/main/subghz/scenes/subghz_scene_show_error.c
View File

@@ -50,9 +50,10 @@ void subghz_scene_show_error_on_enter(void* context) {
bool subghz_scene_show_error_on_event(void* context, SceneManagerEvent event) {
SubGhz* subghz = context;
SubGhzCustomEvent scene_state =
scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError);
if(event.type == SceneManagerEventTypeBack) {
if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError) ==
SubGhzCustomEventManagerSet) {
if(scene_state == SubGhzCustomEventManagerSet) {
return false;
} else {
scene_manager_search_and_switch_to_previous_scene(
@@ -61,14 +62,12 @@ bool subghz_scene_show_error_on_event(void* context, SceneManagerEvent event) {
return true;
} else if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubGhzCustomEventSceneShowErrorOk) {
if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError) ==
SubGhzCustomEventManagerSet) {
if(scene_state == SubGhzCustomEventManagerSet) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneStart);
}
return true;
} else if(event.event == SubGhzCustomEventSceneShowErrorBack) {
if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError) ==
SubGhzCustomEventManagerSet) {
if(scene_state == SubGhzCustomEventManagerSet) {
//exit app
if(!scene_manager_previous_scene(subghz->scene_manager)) {
scene_manager_stop(subghz->scene_manager);

13
applications/main/subghz/scenes/subghz_scene_transmitter.c
View File

@@ -17,14 +17,11 @@ bool subghz_scene_transmitter_update_data_show(void* context) {
SubGhz* subghz = context;
bool ret = false;
if(subghz->txrx->decoder_result) {
FuriString* key_str;
FuriString* frequency_str;
FuriString* modulation_str;
FuriString* key_str = furi_string_alloc();
FuriString* frequency_str = furi_string_alloc();
FuriString* modulation_str = furi_string_alloc();
key_str = furi_string_alloc();
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
uint8_t show_button = 0;
bool show_button = false;
if(subghz_protocol_decoder_base_deserialize(
subghz->txrx->decoder_result, subghz->txrx->fff_data) == SubGhzProtocolStatusOk) {
@@ -32,7 +29,7 @@ bool subghz_scene_transmitter_update_data_show(void* context) {
if((subghz->txrx->decoder_result->protocol->flag & SubGhzProtocolFlag_Send) ==
SubGhzProtocolFlag_Send) {
show_button = 1;
show_button = true;
}
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);

36
applications/main/subghz/subghz_cli.c
View File

@@ -215,8 +215,7 @@ static void subghz_cli_command_rx_callback(
SubGhzCliCommandRx* instance = context;
instance->packet_count++;
FuriString* text;
text = furi_string_alloc();
FuriString* text = furi_string_alloc();
subghz_protocol_decoder_base_get_string(decoder_base, text);
subghz_receiver_reset(receiver);
printf("%s", furi_string_get_cstr(text));
@@ -384,14 +383,12 @@ void subghz_cli_command_rx_raw(Cli* cli, FuriString* args, void* context) {
}
void subghz_cli_command_decode_raw(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
FuriString* file_name;
file_name = furi_string_alloc();
FuriString* file_name = furi_string_alloc();
furi_string_set(file_name, ANY_PATH("subghz/test.sub"));
Storage* storage = furi_record_open(RECORD_STORAGE);
FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
FuriString* temp_str;
temp_str = furi_string_alloc();
FuriString* temp_str = furi_string_alloc();
uint32_t temp_data32;
bool check_file = false;
@@ -526,10 +523,8 @@ static void subghz_cli_command_encrypt_keeloq(Cli* cli, FuriString* args) {
UNUSED(cli);
uint8_t iv[16];
FuriString* source;
FuriString* destination;
source = furi_string_alloc();
destination = furi_string_alloc();
FuriString* source = furi_string_alloc();
FuriString* destination = furi_string_alloc();
SubGhzKeystore* keystore = subghz_keystore_alloc();
@@ -569,10 +564,8 @@ static void subghz_cli_command_encrypt_raw(Cli* cli, FuriString* args) {
UNUSED(cli);
uint8_t iv[16];
FuriString* source;
FuriString* destination;
source = furi_string_alloc();
destination = furi_string_alloc();
FuriString* source = furi_string_alloc();
FuriString* destination = furi_string_alloc();
do {
if(!args_read_string_and_trim(args, source)) {
@@ -646,14 +639,10 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args, void* context) {
size_t message_max_len = 64;
uint8_t message[64] = {0};
FuriString* input;
input = furi_string_alloc();
FuriString* name;
name = furi_string_alloc();
FuriString* output;
output = furi_string_alloc();
FuriString* sysmsg;
sysmsg = furi_string_alloc();
FuriString* input = furi_string_alloc();
FuriString* name = furi_string_alloc();
FuriString* output = furi_string_alloc();
FuriString* sysmsg = furi_string_alloc();
bool exit = false;
SubGhzChatEvent chat_event;
@@ -786,8 +775,7 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args, void* context) {
}
static void subghz_cli_command(Cli* cli, FuriString* args, void* context) {
FuriString* cmd;
cmd = furi_string_alloc();
FuriString* cmd = furi_string_alloc();
do {
if(!args_read_string_and_trim(args, cmd)) {

3
applications/main/subghz/subghz_history.c
View File

@@ -197,8 +197,7 @@ bool subghz_history_add_to_history(
instance->code_last_hash_data = subghz_protocol_decoder_base_get_hash_data(decoder_base);
instance->last_update_timestamp = furi_get_tick();
FuriString* text;
text = furi_string_alloc();
FuriString* text = furi_string_alloc();
SubGhzHistoryItem* item = SubGhzHistoryItemArray_push_raw(instance->history->data);
item->preset = malloc(sizeof(SubGhzRadioPreset));
item->type = decoder_base->protocol->type;

22
applications/main/subghz/subghz_i.c
View File

@@ -145,8 +145,7 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
furi_assert(subghz);
bool ret = false;
FuriString* temp_str;
temp_str = furi_string_alloc();
FuriString* temp_str = furi_string_alloc();
uint32_t repeat = 200;
do {
if(!flipper_format_rewind(flipper_format)) {
@@ -254,8 +253,7 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
Stream* fff_data_stream = flipper_format_get_raw_stream(subghz->txrx->fff_data);
SubGhzLoadKeyState load_key_state = SubGhzLoadKeyStateParseErr;
FuriString* temp_str;
temp_str = furi_string_alloc();
FuriString* temp_str = furi_string_alloc();
uint32_t temp_data32;
do {
@@ -393,13 +391,9 @@ bool subghz_get_next_name_file(SubGhz* subghz, uint8_t max_len) {
furi_assert(subghz);
Storage* storage = furi_record_open(RECORD_STORAGE);
FuriString* temp_str;
FuriString* file_name;
FuriString* file_path;
temp_str = furi_string_alloc();
file_name = furi_string_alloc();
file_path = furi_string_alloc();
FuriString* temp_str = furi_string_alloc();
FuriString* file_name = furi_string_alloc();
FuriString* file_path = furi_string_alloc();
bool res = false;
@@ -446,8 +440,7 @@ bool subghz_save_protocol_to_file(
Stream* flipper_format_stream = flipper_format_get_raw_stream(flipper_format);
bool saved = false;
FuriString* file_dir;
file_dir = furi_string_alloc();
FuriString* file_dir = furi_string_alloc();
path_extract_dirname(dev_file_name, file_dir);
do {
@@ -478,8 +471,7 @@ bool subghz_save_protocol_to_file(
bool subghz_load_protocol_from_file(SubGhz* subghz) {
furi_assert(subghz);
FuriString* file_path;
file_path = furi_string_alloc();
FuriString* file_path = furi_string_alloc();
DialogsFileBrowserOptions browser_options;
dialog_file_browser_set_basic_options(&browser_options, SUBGHZ_APP_EXTENSION, &I_sub1_10px);

3
applications/main/subghz/views/receiver.c
View File

@@ -241,8 +241,7 @@ void subghz_view_receiver_draw(Canvas* canvas, SubGhzViewReceiverModel* model) {
}
bool scrollbar = model->history_item > 4;
FuriString* str_buff;
str_buff = furi_string_alloc();
FuriString* str_buff = furi_string_alloc();
SubGhzReceiverMenuItem* item_menu;

4
applications/main/subghz/views/transmitter.c
View File

@@ -21,7 +21,7 @@ void subghz_view_transmitter_add_data_to_show(
const char* key_str,
const char* frequency_str,
const char* preset_str,
uint8_t show_button) {
bool show_button) {
furi_assert(subghz_transmitter);
with_view_model(
subghz_transmitter->view,
@@ -104,7 +104,7 @@ bool subghz_view_transmitter_input(InputEvent* event, void* context) {
furi_string_reset(model->preset_str);
furi_string_reset(model->key_str);
furi_string_reset(model->temp_button_id);
model->show_button = 0;
model->show_button = false;
model->draw_temp_button = false;
},
false);

4
applications/main/subghz/views/transmitter.h
View File

@@ -7,7 +7,7 @@ typedef struct {
FuriString* frequency_str;
FuriString* preset_str;
FuriString* key_str;
uint8_t show_button;
bool show_button;
FuriString* temp_button_id;
bool draw_temp_button;
} SubGhzViewTransmitterModel;
@@ -36,4 +36,4 @@ void subghz_view_transmitter_add_data_to_show(
const char* key_str,
const char* frequency_str,
const char* preset_str,
uint8_t show_button);
bool show_button);

2
applications/services/cli/cli_commands.c
View File

@@ -230,11 +230,9 @@ void cli_command_sysctl_debug(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
if(!furi_string_cmp(args, "0")) {
furi_hal_rtc_reset_flag(FuriHalRtcFlagDebug);
loader_update_menu();
printf("Debug disabled.");
} else if(!furi_string_cmp(args, "1")) {
furi_hal_rtc_set_flag(FuriHalRtcFlagDebug);
loader_update_menu();
printf("Debug enabled.");
} else {
cli_print_usage("sysctl debug", "<1|0>", furi_string_get_cstr(args));

3
applications/services/desktop/scenes/desktop_scene_lock_menu.c
View File

@@ -80,7 +80,8 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
switch(event.event) {
case DesktopLockMenuEventSettings:
desktop_scene_lock_menu_save_settings(desktop);
loader_show_settings();
loader_show_settings(furi_record_open(RECORD_LOADER));
furi_record_close(RECORD_LOADER);
consumed = true;
break;
case DesktopLockMenuEventLock:

8
applications/services/desktop/scenes/desktop_scene_main.c
View File

@@ -90,10 +90,12 @@ bool desktop_scene_main_on_event(void* context, SceneManagerEvent event) {
if(event.type == SceneManagerEventTypeCustom) {
switch(event.event) {
case DesktopMainEventOpenMenu:
loader_show_menu();
case DesktopMainEventOpenMenu: {
Loader* loader = furi_record_open(RECORD_LOADER);
loader_show_menu(loader);
furi_record_close(RECORD_LOADER);
consumed = true;
break;
} break;
case DesktopMainEventOpenLockMenu:
scene_manager_next_scene(desktop->scene_manager, DesktopSceneLockMenu);

9
applications/services/loader/application.fam
View File

@@ -5,6 +5,7 @@ App(
entry_point="loader_srv",
cdefines=["SRV_LOADER"],
requires=["gui"],
provides=["loader_start"],
stack_size=2 * 1024,
order=90,
sdk_headers=[
@@ -12,3 +13,11 @@ App(
"firmware_api/firmware_api.h",
],
)
App(
appid="loader_start",
apptype=FlipperAppType.STARTUP,
entry_point="loader_on_system_start",
requires=["loader"],
order=90,
)

699
applications/services/loader/loader.c
View File

@@ -1,23 +1,125 @@
#include "applications.h"
#include <furi.h>
#include <storage/storage.h>
#include "loader/loader.h"
#include "loader.h"
#include "loader_i.h"
#include "applications/main/fap_loader/fap_loader_app.h"
#include <flipper_application/application_manifest.h>
#include <gui/icon_i.h>
#include <core/dangerous_defines.h>
#include <toolbox/stream/file_stream.h>
#include <xtreme.h>
#include <gui/modules/file_browser.h>
#include "loader_menu.h"
#include <applications.h>
#include <furi_hal.h>
#define TAG "LoaderSrv"
#define TAG "Loader"
#define LOADER_MAGIC_THREAD_VALUE 0xDEADBEEF
// api
#define LOADER_THREAD_FLAG_SHOW_MENU (1 << 0)
#define LOADER_THREAD_FLAG_SHOW_SETTINGS (1 << 1)
#define LOADER_THREAD_FLAG_ALL (LOADER_THREAD_FLAG_SHOW_MENU | LOADER_THREAD_FLAG_SHOW_SETTINGS)
LoaderStatus loader_start(Loader* loader, const char* name, const char* args) {
LoaderMessage message;
LoaderMessageLoaderStatusResult result;
static Loader* loader_instance = NULL;
message.type = LoaderMessageTypeStartByName;
message.start.name = name;
message.start.args = args;
message.api_lock = api_lock_alloc_locked();
message.status_value = &result;
furi_message_queue_put(loader->queue, &message, FuriWaitForever);
api_lock_wait_unlock_and_free(message.api_lock);
return result.value;
}
bool loader_lock(Loader* loader) {
LoaderMessage message;
LoaderMessageBoolResult result;
message.type = LoaderMessageTypeLock;
message.api_lock = api_lock_alloc_locked();
message.bool_value = &result;
furi_message_queue_put(loader->queue, &message, FuriWaitForever);
api_lock_wait_unlock_and_free(message.api_lock);
return result.value;
}
void loader_unlock(Loader* loader) {
LoaderMessage message;
message.type = LoaderMessageTypeUnlock;
furi_message_queue_put(loader->queue, &message, FuriWaitForever);
}
bool loader_is_locked(Loader* loader) {
LoaderMessage message;
LoaderMessageBoolResult result;
message.type = LoaderMessageTypeIsLocked;
message.api_lock = api_lock_alloc_locked();
message.bool_value = &result;
furi_message_queue_put(loader->queue, &message, FuriWaitForever);
api_lock_wait_unlock_and_free(message.api_lock);
return result.value;
}
void loader_show_menu(Loader* loader) {
LoaderMessage message;
message.type = LoaderMessageTypeShowMenu;
furi_message_queue_put(loader->queue, &message, FuriWaitForever);
}
void loader_show_settings(Loader* loader) {
LoaderMessage message;
message.type = LoaderMessageTypeShowSettings;
furi_message_queue_put(loader->queue, &message, FuriWaitForever);
}
FuriPubSub* loader_get_pubsub(Loader* loader) {
furi_assert(loader);
// it's safe to return pubsub without locking
// because it's never freed and loader is never exited
// also the loader instance cannot be obtained until the pubsub is created
return loader->pubsub;
}
// callbacks
static void loader_menu_closed_callback(void* context) {
Loader* loader = context;
LoaderMessage message;
message.type = LoaderMessageTypeMenuClosed;
furi_message_queue_put(loader->queue, &message, FuriWaitForever);
}
static void loader_menu_click_callback(const char* name, bool external, void* context) {
Loader* loader = context;
if(external) {
loader_start(loader, FAP_LOADER_APP_NAME, name);
} else {
loader_start(loader, name, NULL);
}
}
static void loader_thread_state_callback(FuriThreadState thread_state, void* context) {
furi_assert(context);
Loader* loader = context;
LoaderEvent event;
if(thread_state == FuriThreadStateRunning) {
event.type = LoaderEventTypeApplicationStarted;
furi_pubsub_publish(loader->pubsub, &event);
} else if(thread_state == FuriThreadStateStopped) {
LoaderMessage message;
message.type = LoaderMessageTypeAppClosed;
furi_message_queue_put(loader->queue, &message, FuriWaitForever);
event.type = LoaderEventTypeApplicationStopped;
furi_pubsub_publish(loader->pubsub, &event);
}
}
// implementation
static Loader* loader_alloc() {
Loader* loader = malloc(sizeof(Loader));
loader->pubsub = furi_pubsub_alloc();
loader->queue = furi_message_queue_alloc(1, sizeof(LoaderMessage));
loader->loader_menu = NULL;
loader->app.args = NULL;
loader->app.name = NULL;
loader->app.thread = NULL;
loader->app.insomniac = false;
return loader;
}
static FlipperApplication const* loader_find_application_by_name_in_list(
const char* name,
@@ -31,46 +133,7 @@ static FlipperApplication const* loader_find_application_by_name_in_list(
return NULL;
}
static bool
loader_start_application(const FlipperApplication* application, const char* arguments) {
if(application->app == NULL) {
arguments = application->appid;
application = loader_find_application_by_name_in_list(
FAP_LOADER_APP_NAME, FLIPPER_APPS, FLIPPER_APPS_COUNT);
}
loader_instance->application = application;
furi_assert(loader_instance->application_arguments == NULL);
if(arguments && strlen(arguments) > 0) {
loader_instance->application_arguments = strdup(arguments);
FURI_LOG_I(TAG, "Starting: %s, args: %s", loader_instance->application->name, arguments);
} else {
FURI_LOG_I(TAG, "Starting: %s", loader_instance->application->name);
}
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);
}
furi_thread_set_name(loader_instance->application_thread, loader_instance->application->name);
furi_thread_set_appid(
loader_instance->application_thread, loader_instance->application->appid);
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);
furi_thread_start(loader_instance->application_thread);
return true;
}
const FlipperApplication* loader_find_application_by_name(const char* name) {
static 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) {
@@ -85,449 +148,177 @@ const FlipperApplication* loader_find_application_by_name(const char* name) {
return application;
}
static void loader_menu_callback(void* _ctx, uint32_t index) {
UNUSED(index);
const FlipperApplication* application = _ctx;
static void
loader_start_internal_app(Loader* loader, const FlipperApplication* app, const char* args) {
FURI_LOG_I(TAG, "Starting %s", app->name);
furi_assert(application->app);
furi_assert(application->name);
if(!loader_lock(loader_instance)) {
FURI_LOG_E(TAG, "Loader is locked");
return;
if(app->app == NULL) {
args = app->appid;
app = loader_find_application_by_name_in_list(
FAP_LOADER_APP_NAME, FLIPPER_APPS, FLIPPER_APPS_COUNT);
}
loader_start_application(application, NULL);
}
static void loader_external_callback(void* _ctx, uint32_t index) {
UNUSED(index);
const char* path = _ctx;
const FlipperApplication* app = loader_find_application_by_name_in_list(
FAP_LOADER_APP_NAME, FLIPPER_APPS, FLIPPER_APPS_COUNT);
furi_assert(path);
if(!loader_lock(loader_instance)) {
FURI_LOG_E(TAG, "Loader is locked");
return;
// store args
furi_assert(loader->app.args == NULL);
if(args && strlen(args) > 0) {
loader->app.args = strdup(args);
}
loader_start_application(app, path);
}
// store name
furi_assert(loader->app.name == NULL);
loader->app.name = strdup(app->name);
static void loader_submenu_callback(void* context, uint32_t index) {
UNUSED(index);
uint32_t view_id = (uint32_t)context;
view_dispatcher_switch_to_view(loader_instance->view_dispatcher, view_id);
}
// setup app thread
loader->app.thread =
furi_thread_alloc_ex(app->name, app->stack_size, app->app, loader->app.args);
furi_thread_set_appid(loader->app.thread, app->appid);
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");
printf("\tinfo\t - Show loader state\r\n");
}
static void loader_cli_open(Cli* cli, FuriString* args, Loader* instance) {
UNUSED(cli);
if(loader_is_locked(instance)) {
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");
}
return;
}
FuriString* application_name;
application_name = furi_string_alloc();
do {
if(!args_read_probably_quoted_string_and_trim(args, application_name)) {
printf("No application provided\r\n");
break;
}
const FlipperApplication* application =
loader_find_application_by_name(furi_string_get_cstr(application_name));
if(!application) {
printf("%s doesn't exists\r\n", furi_string_get_cstr(application_name));
break;
}
furi_string_trim(args);
if(!loader_start_application(application, furi_string_get_cstr(args))) {
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);
furi_string_free(application_name);
}
static void loader_cli_list(Cli* cli, FuriString* args, Loader* instance) {
UNUSED(cli);
UNUSED(args);
UNUSED(instance);
printf("Applications:\r\n");
for(size_t i = 0; i < FLIPPER_APPS_COUNT; i++) {
printf("\t%s\r\n", FLIPPER_APPS[i].name);
}
}
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");
// setup heap trace
FuriHalRtcHeapTrackMode mode = furi_hal_rtc_get_heap_track_mode();
if(mode > FuriHalRtcHeapTrackModeNone) {
furi_thread_enable_heap_trace(loader->app.thread);
} else {
printf("Running application: ");
if(instance->application) {
furi_assert(instance->application->name);
printf("%s\r\n", instance->application->name);
} else {
printf("unknown\r\n");
}
furi_thread_disable_heap_trace(loader->app.thread);
}
// setup insomnia
if(!(app->flags & FlipperApplicationFlagInsomniaSafe)) {
furi_hal_power_insomnia_enter();
loader->app.insomniac = true;
} else {
loader->app.insomniac = false;
}
// setup app thread callbacks
furi_thread_set_state_context(loader->app.thread, loader);
furi_thread_set_state_callback(loader->app.thread, loader_thread_state_callback);
// start app thread
furi_thread_start(loader->app.thread);
}
// process messages
static void loader_do_menu_show(Loader* loader, bool settings) {
if(!loader->loader_menu) {
loader->loader_menu = loader_menu_alloc();
loader_menu_set_closed_callback(loader->loader_menu, loader_menu_closed_callback, loader);
loader_menu_set_click_callback(loader->loader_menu, loader_menu_click_callback, loader);
loader_menu_start(loader->loader_menu, settings);
}
}
static void loader_cli(Cli* cli, FuriString* args, void* _ctx) {
furi_assert(_ctx);
Loader* instance = _ctx;
FuriString* cmd;
cmd = furi_string_alloc();
do {
if(!args_read_string_and_trim(args, cmd)) {
loader_cli_print_usage();
break;
}
if(furi_string_cmp_str(cmd, "list") == 0) {
loader_cli_list(cli, args, instance);
break;
}
if(furi_string_cmp_str(cmd, "open") == 0) {
loader_cli_open(cli, args, instance);
break;
}
if(furi_string_cmp_str(cmd, "info") == 0) {
loader_cli_info(cli, args, instance);
break;
}
loader_cli_print_usage();
} while(false);
furi_string_free(cmd);
static void loader_do_menu_closed(Loader* loader) {
if(loader->loader_menu) {
loader_menu_stop(loader->loader_menu);
loader_menu_free(loader->loader_menu);
loader->loader_menu = NULL;
}
}
LoaderStatus loader_start(Loader* instance, const char* name, const char* args) {
UNUSED(instance);
furi_assert(name);
static bool loader_do_is_locked(Loader* loader) {
return loader->app.thread != NULL;
}
const FlipperApplication* application = loader_find_application_by_name(name);
if(!application) {
FURI_LOG_E(TAG, "Can't find application with name %s", name);
return LoaderStatusErrorUnknownApp;
}
if(!loader_lock(loader_instance)) {
FURI_LOG_E(TAG, "Loader is locked");
static LoaderStatus loader_do_start_by_name(Loader* loader, const char* name, const char* args) {
if(loader_do_is_locked(loader)) {
return LoaderStatusErrorAppStarted;
}
if(!loader_start_application(application, args)) {
return LoaderStatusErrorInternal;
const FlipperApplication* app = loader_find_application_by_name(name);
if(!app) {
return LoaderStatusErrorUnknownApp;
}
loader_start_internal_app(loader, app, args);
return LoaderStatusOk;
}
bool loader_lock(Loader* instance) {
FURI_CRITICAL_ENTER();
bool result = false;
if(instance->lock_count == 0) {
instance->lock_count++;
result = true;
}
FURI_CRITICAL_EXIT();
return result;
}
void loader_unlock(Loader* instance) {
FURI_CRITICAL_ENTER();
if(instance->lock_count > 0) instance->lock_count--;
FURI_CRITICAL_EXIT();
}
bool loader_is_locked(const Loader* instance) {
return instance->lock_count > 0;
}
static void loader_thread_state_callback(FuriThreadState thread_state, void* context) {
furi_assert(context);
Loader* instance = context;
LoaderEvent event;
if(thread_state == FuriThreadStateRunning) {
event.type = LoaderEventTypeApplicationStarted;
furi_pubsub_publish(loader_instance->pubsub, &event);
if(!(loader_instance->application->flags & FlipperApplicationFlagInsomniaSafe)) {
furi_hal_power_insomnia_enter();
}
} else if(thread_state == FuriThreadStateStopped) {
FURI_LOG_I(TAG, "Application stopped. Free heap: %zu", memmgr_get_free_heap());
if(loader_instance->application_arguments) {
free(loader_instance->application_arguments);
loader_instance->application_arguments = NULL;
}
if(!(loader_instance->application->flags & FlipperApplicationFlagInsomniaSafe)) {
furi_hal_power_insomnia_exit();
}
loader_unlock(instance);
event.type = LoaderEventTypeApplicationStopped;
furi_pubsub_publish(loader_instance->pubsub, &event);
}
}
static uint32_t loader_hide_menu(void* context) {
UNUSED(context);
return VIEW_NONE;
}
static uint32_t loader_back_to_primary_menu(void* context) {
furi_assert(context);
Submenu* submenu = context;
submenu_set_selected_item(submenu, 0);
return LoaderMenuViewPrimary;
}
static Loader* loader_alloc() {
Loader* instance = malloc(sizeof(Loader));
instance->application_thread = furi_thread_alloc();
furi_thread_set_state_context(instance->application_thread, instance);
furi_thread_set_state_callback(instance->application_thread, loader_thread_state_callback);
instance->pubsub = furi_pubsub_alloc();
#ifdef SRV_CLI
instance->cli = furi_record_open(RECORD_CLI);
cli_add_command(
instance->cli, RECORD_LOADER, CliCommandFlagParallelSafe, loader_cli, instance);
#else
UNUSED(loader_cli);
#endif
instance->loader_thread = furi_thread_get_current_id();
// Gui
instance->gui = furi_record_open(RECORD_GUI);
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));
// Settings menu
instance->settings_menu = submenu_alloc();
view_set_context(submenu_get_view(instance->settings_menu), instance->settings_menu);
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);
return instance;
}
static void loader_free(Loader* instance) {
furi_assert(instance);
if(instance->cli) {
furi_record_close(RECORD_CLI);
}
furi_pubsub_free(instance->pubsub);
furi_thread_free(instance->application_thread);
menu_free(loader_instance->primary_menu);
view_dispatcher_remove_view(loader_instance->view_dispatcher, LoaderMenuViewPrimary);
submenu_free(loader_instance->settings_menu);
view_dispatcher_remove_view(loader_instance->view_dispatcher, LoaderMenuViewSettings);
view_dispatcher_free(loader_instance->view_dispatcher);
furi_record_close(RECORD_GUI);
free(instance);
instance = NULL;
}
bool loader_load_fap_meta(Storage* storage, FuriString* path, FuriString* name, const Icon** icon) {
*icon = NULL;
uint8_t* icon_buf = malloc(CUSTOM_ICON_MAX_SIZE);
if(!fap_loader_load_name_and_icon(path, storage, &icon_buf, name)) {
free(icon_buf);
icon_buf = NULL;
static bool loader_do_lock(Loader* loader) {
if(loader->app.thread) {
return false;
}
*icon = malloc(sizeof(Icon));
FURI_CONST_ASSIGN((*icon)->frame_count, 1);
FURI_CONST_ASSIGN((*icon)->frame_rate, 0);
FURI_CONST_ASSIGN((*icon)->width, 10);
FURI_CONST_ASSIGN((*icon)->height, 10);
FURI_CONST_ASSIGN_PTR((*icon)->frames, malloc(sizeof(const uint8_t*)));
FURI_CONST_ASSIGN_PTR((*icon)->frames[0], icon_buf);
loader->app.thread = (FuriThread*)LOADER_MAGIC_THREAD_VALUE;
return true;
}
static void loader_build_menu() {
FURI_LOG_I(TAG, "Building main menu");
size_t i;
for(i = 0; i < FLIPPER_APPS_COUNT; i++) {
menu_add_item(
loader_instance->primary_menu,
FLIPPER_APPS[i].name,
FLIPPER_APPS[i].icon,
i,
loader_menu_callback,
(void*)&FLIPPER_APPS[i]);
static void loader_do_unlock(Loader* loader) {
furi_assert(loader->app.thread == (FuriThread*)LOADER_MAGIC_THREAD_VALUE);
loader->app.thread = NULL;
}
static void loader_do_app_closed(Loader* loader) {
furi_assert(loader->app.thread);
FURI_LOG_I(TAG, "Application stopped. Free heap: %zu", memmgr_get_free_heap());
if(loader->app.args) {
free(loader->app.args);
loader->app.args = NULL;
}
menu_add_item(
loader_instance->primary_menu,
"Settings",
&A_Settings_14,
i++,
loader_submenu_callback,
(void*)LoaderMenuViewSettings);
Storage* storage = furi_record_open(RECORD_STORAGE);
FuriString* path = furi_string_alloc();
FuriString* name = furi_string_alloc();
Stream* stream = file_stream_alloc(storage);
if(file_stream_open(stream, XTREME_APPS_PATH, FSAM_READ, FSOM_OPEN_EXISTING)) {
while(stream_read_line(stream, path)) {
furi_string_replace_all(path, "\r", "");
furi_string_replace_all(path, "\n", "");
const Icon* icon;
if(!loader_load_fap_meta(storage, path, name, &icon)) continue;
menu_add_item(
loader_instance->primary_menu,
strdup(furi_string_get_cstr(name)),
icon,
i++,
loader_external_callback,
(void*)strdup(furi_string_get_cstr(path)));
}
if(loader->app.insomniac) {
furi_hal_power_insomnia_exit();
}
file_stream_close(stream);
stream_free(stream);
furi_string_free(name);
furi_string_free(path);
furi_record_close(RECORD_STORAGE);
free(loader->app.name);
loader->app.name = NULL;
furi_thread_join(loader->app.thread);
furi_thread_free(loader->app.thread);
loader->app.thread = NULL;
}
static void loader_build_submenu() {
FURI_LOG_I(TAG, "Building settings menu");
for(size_t 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]);
}
}
void loader_show_menu() {
furi_assert(loader_instance);
furi_thread_flags_set(loader_instance->loader_thread, LOADER_THREAD_FLAG_SHOW_MENU);
}
void loader_show_settings() {
furi_assert(loader_instance);
furi_thread_flags_set(loader_instance->loader_thread, LOADER_THREAD_FLAG_SHOW_SETTINGS);
}
void loader_update_menu() {
menu_reset(loader_instance->primary_menu);
loader_build_menu();
}
// app
int32_t loader_srv(void* p) {
UNUSED(p);
Loader* loader = loader_alloc();
furi_record_create(RECORD_LOADER, loader);
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]();
}
FURI_LOG_I(TAG, "Starting");
loader_instance = loader_alloc();
loader_build_menu();
loader_build_submenu();
FURI_LOG_I(TAG, "Started");
furi_record_create(RECORD_LOADER, loader_instance);
if(FLIPPER_AUTORUN_APP_NAME && strlen(FLIPPER_AUTORUN_APP_NAME)) {
loader_start(loader_instance, FLIPPER_AUTORUN_APP_NAME, NULL);
loader_do_start_by_name(loader, FLIPPER_AUTORUN_APP_NAME, NULL);
}
while(1) {
uint32_t flags =
furi_thread_flags_wait(LOADER_THREAD_FLAG_ALL, FuriFlagWaitAny, FuriWaitForever);
if(flags & LOADER_THREAD_FLAG_SHOW_MENU) {
menu_set_selected_item(loader_instance->primary_menu, 0);
view_dispatcher_switch_to_view(
loader_instance->view_dispatcher, LoaderMenuViewPrimary);
view_dispatcher_run(loader_instance->view_dispatcher);
} else if(flags & LOADER_THREAD_FLAG_SHOW_SETTINGS) {
submenu_set_selected_item(loader_instance->settings_menu, 0);
view_set_previous_callback(
submenu_get_view(loader_instance->settings_menu), loader_hide_menu);
view_dispatcher_switch_to_view(
loader_instance->view_dispatcher, LoaderMenuViewSettings);
view_dispatcher_run(loader_instance->view_dispatcher);
view_set_previous_callback(
submenu_get_view(loader_instance->settings_menu), loader_back_to_primary_menu);
LoaderMessage message;
while(true) {
if(furi_message_queue_get(loader->queue, &message, FuriWaitForever) == FuriStatusOk) {
switch(message.type) {
case LoaderMessageTypeStartByName:
message.status_value->value =
loader_do_start_by_name(loader, message.start.name, message.start.args);
api_lock_unlock(message.api_lock);
break;
case LoaderMessageTypeShowMenu:
loader_do_menu_show(loader, false);
break;
case LoaderMessageTypeShowSettings:
loader_do_menu_show(loader, true);
break;
case LoaderMessageTypeMenuClosed:
loader_do_menu_closed(loader);
break;
case LoaderMessageTypeIsLocked:
message.bool_value->value = loader_do_is_locked(loader);
api_lock_unlock(message.api_lock);
break;
case LoaderMessageTypeAppClosed:
loader_do_app_closed(loader);
break;
case LoaderMessageTypeLock:
message.bool_value->value = loader_do_lock(loader);
api_lock_unlock(message.api_lock);
break;
case LoaderMessageTypeUnlock:
loader_do_unlock(loader);
}
}
}
furi_record_destroy(RECORD_LOADER);
loader_free(loader_instance);
return 0;
}
FuriPubSub* loader_get_pubsub(Loader* instance) {
return instance->pubsub;
}

13
applications/services/loader/loader.h
View File

@@ -1,7 +1,5 @@
#pragma once
#include <core/pubsub.h>
#include <stdbool.h>
#include <furi.h>
#ifdef __cplusplus
extern "C" {
@@ -45,16 +43,13 @@ bool loader_lock(Loader* instance);
void loader_unlock(Loader* instance);
/** Get loader lock status */
bool loader_is_locked(const Loader* instance);
bool loader_is_locked(Loader* instance);
/** Show primary loader */
void loader_show_menu();
void loader_show_menu(Loader* instance);
/** Show settings menu */
void loader_show_settings();
/** Show primary loader */
void loader_update_menu();
void loader_show_settings(Loader* loader);
/** Show primary loader */
FuriPubSub* loader_get_pubsub(Loader* instance);

117
applications/services/loader/loader_cli.c Normal file
View File

@@ -0,0 +1,117 @@
#include <furi.h>
#include <cli/cli.h>
#include <applications.h>
#include <lib/toolbox/args.h>
#include "loader.h"
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");
printf("\tinfo\t - Show loader state\r\n");
}
static void loader_cli_list() {
printf("Applications:\r\n");
for(size_t i = 0; i < FLIPPER_APPS_COUNT; i++) {
printf("\t%s\r\n", FLIPPER_APPS[i].name);
}
printf("Settings:\r\n");
for(size_t i = 0; i < FLIPPER_SETTINGS_APPS_COUNT; i++) {
printf("\t%s\r\n", FLIPPER_SETTINGS_APPS[i].name);
}
}
static void loader_cli_info(Loader* loader) {
if(!loader_is_locked(loader)) {
printf("No application is running\r\n");
} else {
// TODO: print application name ???
printf("Application is running\r\n");
}
}
static void loader_cli_open(FuriString* args, Loader* loader) {
FuriString* app_name = furi_string_alloc();
do {
if(!args_read_probably_quoted_string_and_trim(args, app_name)) {
printf("No application provided\r\n");
break;
}
furi_string_trim(args);
const char* args_str = furi_string_get_cstr(args);
if(strlen(args_str) == 0) {
args_str = NULL;
}
const char* app_name_str = furi_string_get_cstr(app_name);
LoaderStatus status = loader_start(loader, app_name_str, args_str);
switch(status) {
case LoaderStatusOk:
break;
case LoaderStatusErrorAppStarted:
printf("Can't start, application is running");
break;
case LoaderStatusErrorUnknownApp:
printf("%s doesn't exists\r\n", app_name_str);
break;
case LoaderStatusErrorInternal:
printf("Internal error\r\n");
break;
}
} while(false);
furi_string_free(app_name);
}
static void loader_cli(Cli* cli, FuriString* args, void* context) {
UNUSED(cli);
UNUSED(context);
Loader* loader = furi_record_open(RECORD_LOADER);
FuriString* cmd;
cmd = furi_string_alloc();
do {
if(!args_read_string_and_trim(args, cmd)) {
loader_cli_print_usage();
break;
}
if(furi_string_cmp_str(cmd, "list") == 0) {
loader_cli_list();
break;
}
if(furi_string_cmp_str(cmd, "open") == 0) {
loader_cli_open(args, loader);
break;
}
if(furi_string_cmp_str(cmd, "info") == 0) {
loader_cli_info(loader);
break;
}
loader_cli_print_usage();
} while(false);
furi_string_free(cmd);
furi_record_close(RECORD_LOADER);
}
void loader_on_system_start() {
#ifdef SRV_CLI
Cli* cli = furi_record_open(RECORD_CLI);
cli_add_command(cli, RECORD_LOADER, CliCommandFlagParallelSafe, loader_cli, NULL);
furi_record_close(RECORD_CLI);
#else
UNUSED(loader_cli);
#endif
}

80
applications/services/loader/loader_i.h
View File

@@ -1,39 +1,57 @@
#include "loader.h"
#pragma once
#include <furi.h>
#include <furi_hal.h>
#include <core/pubsub.h>
#include <cli/cli.h>
#include <lib/toolbox/args.h>
#include <toolbox/api_lock.h>
#include "loader.h"
#include "loader_menu.h"
#include <gui/view_dispatcher.h>
#include <gui/modules/menu.h>
#include <gui/modules/submenu.h>
#include <applications.h>
#include <assets_icons.h>
typedef struct {
char* args;
char* name;
FuriThread* thread;
bool insomniac;
} LoaderAppData;
struct Loader {
FuriThreadId loader_thread;
const FlipperApplication* application;
FuriThread* application_thread;
char* application_arguments;
Cli* cli;
Gui* gui;
ViewDispatcher* view_dispatcher;
Menu* primary_menu;
Submenu* settings_menu;
volatile uint8_t lock_count;
FuriPubSub* pubsub;
FuriMessageQueue* queue;
LoaderMenu* loader_menu;
LoaderAppData app;
};
typedef enum {
LoaderMenuViewPrimary,
LoaderMenuViewSettings,
} LoaderMenuView;
LoaderMessageTypeStartByName,
LoaderMessageTypeAppClosed,
LoaderMessageTypeShowMenu,
LoaderMessageTypeMenuClosed,
LoaderMessageTypeLock,
LoaderMessageTypeUnlock,
LoaderMessageTypeIsLocked,
LoaderMessageTypeShowSettings,
} LoaderMessageType;
typedef struct {
const char* name;
const char* args;
} LoaderMessageStartByName;
typedef struct {
LoaderStatus value;
} LoaderMessageLoaderStatusResult;
typedef struct {
bool value;
} LoaderMessageBoolResult;
typedef struct {
FuriApiLock api_lock;
LoaderMessageType type;
union {
LoaderMessageStartByName start;
};
union {
LoaderMessageLoaderStatusResult* status_value;
LoaderMessageBoolResult* bool_value;
};
} LoaderMessage;

256
applications/services/loader/loader_menu.c Normal file
View File

@@ -0,0 +1,256 @@
#include <gui/gui.h>
#include <gui/view_dispatcher.h>
#include <gui/modules/menu.h>
#include <gui/modules/submenu.h>
#include <assets_icons.h>
#include <applications.h>
#include <core/dangerous_defines.h>
#include <gui/modules/file_browser.h>
#include <toolbox/stream/file_stream.h>
#include "applications/main/fap_loader/fap_loader_app.h"
#include <xtreme.h>
#include "loader_menu.h"
#define TAG "LoaderMenu"
struct LoaderMenu {
Gui* gui;
ViewDispatcher* view_dispatcher;
Menu* primary_menu;
Submenu* settings_menu;
bool settings;
void (*closed_callback)(void*);
void* closed_callback_context;
void (*click_callback)(const char*, bool, void*);
void* click_callback_context;
FuriThread* thread;
};
typedef enum {
LoaderMenuViewPrimary,
LoaderMenuViewSettings,
} LoaderMenuView;
static int32_t loader_menu_thread(void* p);
LoaderMenu* loader_menu_alloc() {
LoaderMenu* loader_menu = malloc(sizeof(LoaderMenu));
loader_menu->gui = furi_record_open(RECORD_GUI);
loader_menu->view_dispatcher = view_dispatcher_alloc();
loader_menu->primary_menu = menu_alloc();
loader_menu->settings_menu = submenu_alloc();
loader_menu->thread = NULL;
return loader_menu;
}
void loader_menu_free(LoaderMenu* loader_menu) {
furi_assert(loader_menu);
// check if thread is running
furi_assert(!loader_menu->thread);
submenu_free(loader_menu->settings_menu);
menu_free(loader_menu->primary_menu);
view_dispatcher_free(loader_menu->view_dispatcher);
furi_record_close(RECORD_GUI);
free(loader_menu);
}
void loader_menu_start(LoaderMenu* loader_menu, bool settings) {
furi_assert(loader_menu);
furi_assert(!loader_menu->thread);
loader_menu->settings = settings;
loader_menu->thread = furi_thread_alloc_ex(TAG, 1024, loader_menu_thread, loader_menu);
furi_thread_start(loader_menu->thread);
}
void loader_menu_stop(LoaderMenu* loader_menu) {
furi_assert(loader_menu);
furi_assert(loader_menu->thread);
view_dispatcher_stop(loader_menu->view_dispatcher);
furi_thread_join(loader_menu->thread);
furi_thread_free(loader_menu->thread);
loader_menu->thread = NULL;
}
void loader_menu_set_closed_callback(
LoaderMenu* loader_menu,
void (*callback)(void*),
void* context) {
loader_menu->closed_callback = callback;
loader_menu->closed_callback_context = context;
}
void loader_menu_set_click_callback(
LoaderMenu* loader_menu,
void (*callback)(const char*, bool, void*),
void* context) {
loader_menu->click_callback = callback;
loader_menu->click_callback_context = context;
}
static void loader_menu_callback(void* context, uint32_t index) {
LoaderMenu* loader_menu = context;
const char* name = FLIPPER_APPS[index].name;
if(loader_menu->click_callback) {
loader_menu->click_callback(name, false, loader_menu->click_callback_context);
}
}
static void loader_menu_external_callback(void* context, uint32_t index) {
LoaderMenu* loader_menu = context;
const char* path = (const char*)index;
if(loader_menu->click_callback) {
loader_menu->click_callback(path, true, loader_menu->click_callback_context);
}
}
static void loader_menu_settings_menu_callback(void* context, uint32_t index) {
LoaderMenu* loader_menu = context;
const char* name = FLIPPER_SETTINGS_APPS[index].name;
if(loader_menu->click_callback) {
loader_menu->click_callback(name, false, loader_menu->click_callback_context);
}
}
static void loader_menu_switch_to_settings(void* context, uint32_t index) {
UNUSED(index);
LoaderMenu* loader_menu = context;
view_dispatcher_switch_to_view(loader_menu->view_dispatcher, LoaderMenuViewSettings);
}
static uint32_t loader_menu_switch_to_primary(void* context) {
UNUSED(context);
return LoaderMenuViewPrimary;
}
static uint32_t loader_menu_exit(void* context) {
UNUSED(context);
return VIEW_NONE;
}
bool loader_menu_load_fap_meta(
Storage* storage,
FuriString* path,
FuriString* name,
const Icon** icon) {
*icon = NULL;
uint8_t* icon_buf = malloc(CUSTOM_ICON_MAX_SIZE);
if(!fap_loader_load_name_and_icon(path, storage, &icon_buf, name)) {
free(icon_buf);
icon_buf = NULL;
return false;
}
*icon = malloc(sizeof(Icon));
FURI_CONST_ASSIGN((*icon)->frame_count, 1);
FURI_CONST_ASSIGN((*icon)->frame_rate, 0);
FURI_CONST_ASSIGN((*icon)->width, 10);
FURI_CONST_ASSIGN((*icon)->height, 10);
FURI_CONST_ASSIGN_PTR((*icon)->frames, malloc(sizeof(const uint8_t*)));
FURI_CONST_ASSIGN_PTR((*icon)->frames[0], icon_buf);
return true;
}
static void loader_menu_build_menu(LoaderMenu* loader_menu) {
size_t i;
for(i = 0; i < FLIPPER_APPS_COUNT; i++) {
menu_add_item(
loader_menu->primary_menu,
FLIPPER_APPS[i].name,
FLIPPER_APPS[i].icon,
i,
loader_menu_callback,
(void*)loader_menu);
}
menu_add_item(
loader_menu->primary_menu,
"Settings",
&A_Settings_14,
i++,
loader_menu_switch_to_settings,
loader_menu);
Storage* storage = furi_record_open(RECORD_STORAGE);
FuriString* path = furi_string_alloc();
FuriString* name = furi_string_alloc();
Stream* stream = file_stream_alloc(storage);
if(file_stream_open(stream, XTREME_APPS_PATH, FSAM_READ, FSOM_OPEN_EXISTING)) {
while(stream_read_line(stream, path)) {
furi_string_replace_all(path, "\r", "");
furi_string_replace_all(path, "\n", "");
const Icon* icon;
if(!loader_menu_load_fap_meta(storage, path, name, &icon)) continue;
menu_add_item(
loader_menu->primary_menu,
strdup(furi_string_get_cstr(name)),
icon,
(uint32_t)strdup(furi_string_get_cstr(path)),
loader_menu_external_callback,
(void*)loader_menu);
}
}
file_stream_close(stream);
stream_free(stream);
furi_string_free(name);
furi_string_free(path);
furi_record_close(RECORD_STORAGE);
};
static void loader_menu_build_submenu(LoaderMenu* loader_menu) {
for(size_t i = 0; i < FLIPPER_SETTINGS_APPS_COUNT; i++) {
submenu_add_item(
loader_menu->settings_menu,
FLIPPER_SETTINGS_APPS[i].name,
i,
loader_menu_settings_menu_callback,
loader_menu);
}
}
static int32_t loader_menu_thread(void* p) {
LoaderMenu* loader_menu = p;
furi_assert(loader_menu);
if(!loader_menu->settings) loader_menu_build_menu(loader_menu);
loader_menu_build_submenu(loader_menu);
view_dispatcher_attach_to_gui(
loader_menu->view_dispatcher, loader_menu->gui, ViewDispatcherTypeFullscreen);
// Primary menu
if(!loader_menu->settings) {
View* primary_view = menu_get_view(loader_menu->primary_menu);
view_set_context(primary_view, loader_menu->primary_menu);
view_set_previous_callback(primary_view, loader_menu_exit);
view_dispatcher_add_view(
loader_menu->view_dispatcher, LoaderMenuViewPrimary, primary_view);
}
// Settings menu
View* settings_view = submenu_get_view(loader_menu->settings_menu);
view_set_context(settings_view, loader_menu->settings_menu);
view_set_previous_callback(
settings_view, loader_menu->settings ? loader_menu_exit : loader_menu_switch_to_primary);
view_dispatcher_add_view(loader_menu->view_dispatcher, LoaderMenuViewSettings, settings_view);
view_dispatcher_enable_queue(loader_menu->view_dispatcher);
view_dispatcher_switch_to_view(
loader_menu->view_dispatcher,
loader_menu->settings ? LoaderMenuViewSettings : LoaderMenuViewPrimary);
// run view dispatcher
view_dispatcher_run(loader_menu->view_dispatcher);
if(!loader_menu->settings)
view_dispatcher_remove_view(loader_menu->view_dispatcher, LoaderMenuViewPrimary);
view_dispatcher_remove_view(loader_menu->view_dispatcher, LoaderMenuViewSettings);
if(loader_menu->closed_callback) {
loader_menu->closed_callback(loader_menu->closed_callback_context);
}
return 0;
}

30
applications/services/loader/loader_menu.h Normal file
View File

@@ -0,0 +1,30 @@
#pragma once
#include <furi.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct LoaderMenu LoaderMenu;
LoaderMenu* loader_menu_alloc();
void loader_menu_free(LoaderMenu* loader_menu);
void loader_menu_start(LoaderMenu* loader_menu, bool settings);
void loader_menu_stop(LoaderMenu* loader_menu);
void loader_menu_set_closed_callback(
LoaderMenu* loader_menu,
void (*callback)(void*),
void* context);
void loader_menu_set_click_callback(
LoaderMenu* loader_menu,
void (*callback)(const char*, bool, void*),
void* context);
#ifdef __cplusplus
}
#endif

50
applications/services/rpc/rpc.c
View File

@@ -326,31 +326,35 @@ static int32_t rpc_session_worker(void* context) {
return 0;
}
static void rpc_session_free_callback(FuriThreadState thread_state, void* context) {
furi_assert(context);
static void rpc_session_thread_pending_callback(void* context, uint32_t arg) {
UNUSED(arg);
RpcSession* session = (RpcSession*)context;
for(size_t i = 0; i < COUNT_OF(rpc_systems); ++i) {
if(rpc_systems[i].free) {
(rpc_systems[i].free)(session->system_contexts[i]);
}
}
free(session->system_contexts);
free(session->decoded_message);
RpcHandlerDict_clear(session->handlers);
furi_stream_buffer_free(session->stream);
furi_mutex_acquire(session->callbacks_mutex, FuriWaitForever);
if(session->terminated_callback) {
session->terminated_callback(session->context);
}
furi_mutex_release(session->callbacks_mutex);
furi_mutex_free(session->callbacks_mutex);
furi_thread_join(session->thread);
furi_thread_free(session->thread);
free(session);
}
static void rpc_session_thread_state_callback(FuriThreadState thread_state, void* context) {
if(thread_state == FuriThreadStateStopped) {
for(size_t i = 0; i < COUNT_OF(rpc_systems); ++i) {
if(rpc_systems[i].free) {
rpc_systems[i].free(session->system_contexts[i]);
}
}
free(session->system_contexts);
free(session->decoded_message);
RpcHandlerDict_clear(session->handlers);
furi_stream_buffer_free(session->stream);
furi_mutex_acquire(session->callbacks_mutex, FuriWaitForever);
if(session->terminated_callback) {
session->terminated_callback(session->context);
}
furi_mutex_release(session->callbacks_mutex);
furi_mutex_free(session->callbacks_mutex);
furi_thread_free(session->thread);
free(session);
furi_timer_pending_callback(rpc_session_thread_pending_callback, context, 0);
}
}
@@ -385,7 +389,7 @@ RpcSession* rpc_session_open(Rpc* rpc, RpcOwner owner) {
session->thread = furi_thread_alloc_ex("RpcSessionWorker", 3072, rpc_session_worker, session);
furi_thread_set_state_context(session->thread, session);
furi_thread_set_state_callback(session->thread, rpc_session_free_callback);
furi_thread_set_state_callback(session->thread, rpc_session_thread_state_callback);
furi_thread_start(session->thread);

1
applications/services/storage/storage_external_api.c
View File

@@ -803,6 +803,7 @@ void storage_file_free(File* file) {
}
FuriPubSub* storage_get_pubsub(Storage* storage) {
furi_assert(storage);
return storage->pubsub;
}

1
applications/services/storage/storages/storage_ext.c
View File

@@ -337,6 +337,7 @@ static bool storage_ext_file_close(void* ctx, File* file) {
file->internal_error_id = f_close(file_data);
file->error_id = storage_ext_parse_error(file->internal_error_id);
free(file_data);
storage_set_storage_file_data(file, NULL, storage);
return (file->error_id == FSE_OK);
}

4
applications/settings/about/about.c
View File

@@ -212,7 +212,9 @@ static void draw_battery(Canvas* canvas, PowerInfo* info, int x, int y) {
(uint32_t)(info->voltage_vbus),
(uint32_t)(info->voltage_vbus * 10) % 10,
current);
} else if(current < 0) {
} else if(current < -5) {
// Often gauge reports anything in the range 1~5ma as 5ma
// That brings confusion, so we'll treat it as Napping
snprintf(header, sizeof(header), "%s", "Consumption is");
snprintf(
value,

4
applications/settings/power_settings_app/views/battery_info.c
View File

@@ -53,7 +53,9 @@ static void draw_battery(Canvas* canvas, BatteryInfoModel* data, int x, int y) {
(uint32_t)(data->vbus_voltage),
(uint32_t)(data->vbus_voltage * 10) % 10,
current);
} else if(current < 0) {
} else if(current < -5) {
// Often gauge reports anything in the range 1~5ma as 5ma
// That brings confusion, so we'll treat it as Napping
snprintf(
emote,
sizeof(emote),

1
applications/settings/system/system_settings.c
View File

@@ -43,7 +43,6 @@ static void debug_changed(VariableItem* item) {
} else {
furi_hal_rtc_reset_flag(FuriHalRtcFlagDebug);
}
loader_update_menu();
}
const char* const heap_trace_mode_text[] = {

26
applications/system/updater/cli/updater_cli.c
View File

@@ -85,22 +85,10 @@ static void updater_cli_ep(Cli* cli, FuriString* args, void* context) {
updater_cli_help(args);
}
static int32_t updater_spawner_thread_worker(void* arg) {
static void updater_start_app(void* context, uint32_t arg) {
UNUSED(context);
UNUSED(arg);
Loader* loader = furi_record_open(RECORD_LOADER);
loader_start(loader, "UpdaterApp", NULL);
furi_record_close(RECORD_LOADER);
return 0;
}
static void updater_spawner_thread_cleanup(FuriThreadState state, void* context) {
FuriThread* thread = context;
if(state == FuriThreadStateStopped) {
furi_thread_free(thread);
}
}
static void updater_start_app() {
FuriHalRtcBootMode mode = furi_hal_rtc_get_boot_mode();
if((mode != FuriHalRtcBootModePreUpdate) && (mode != FuriHalRtcBootModePostUpdate)) {
return;
@@ -110,11 +98,9 @@ static void updater_start_app() {
* inside loader process, at startup.
* So, accessing its record would cause a deadlock
*/
FuriThread* thread =
furi_thread_alloc_ex("UpdateAppSpawner", 768, updater_spawner_thread_worker, NULL);
furi_thread_set_state_callback(thread, updater_spawner_thread_cleanup);
furi_thread_set_state_context(thread, thread);
furi_thread_start(thread);
Loader* loader = furi_record_open(RECORD_LOADER);
loader_start(loader, "UpdaterApp", NULL);
furi_record_close(RECORD_LOADER);
}
void updater_on_system_start() {
@@ -126,7 +112,7 @@ void updater_on_system_start() {
UNUSED(updater_cli_ep);
#endif
#ifndef FURI_RAM_EXEC
updater_start_app();
furi_timer_pending_callback(updater_start_app, NULL, 0);
#else
UNUSED(updater_start_app);
#endif

6
applications/system/updater/util/update_task_worker_flasher.c
View File

@@ -346,7 +346,11 @@ int32_t update_task_worker_flash_writer(void* context) {
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModePostUpdate);
// Format LFS before restoring backup on next boot
furi_hal_rtc_set_flag(FuriHalRtcFlagFactoryReset);
#ifdef FURI_NDEBUG
// Production
furi_hal_rtc_set_log_level(FuriLogLevelDefault);
furi_hal_rtc_reset_flag(FuriHalRtcFlagDebug);
#endif
update_task_set_progress(update_task, UpdateTaskStageCompleted, 100);
success = true;
} while(false);

12
firmware/targets/f18/api_symbols.csv
View File

@@ -1,5 +1,5 @@
entry,status,name,type,params
Version,+,23.3,,
Version,+,26.0,,
Header,+,applications/services/bt/bt_service/bt.h,,
Header,+,applications/services/cli/cli.h,,
Header,+,applications/services/cli/cli_vcp.h,,
@@ -892,6 +892,8 @@ Function,+,furi_hal_console_puts,void,const char*
Function,+,furi_hal_console_set_tx_callback,void,"FuriHalConsoleTxCallback, void*"
Function,+,furi_hal_console_tx,void,"const uint8_t*, size_t"
Function,+,furi_hal_console_tx_with_new_line,void,"const uint8_t*, size_t"
Function,+,furi_hal_cortex_comp_enable,void,"FuriHalCortexComp, FuriHalCortexCompFunction, uint32_t, uint32_t, FuriHalCortexCompSize"
Function,+,furi_hal_cortex_comp_reset,void,FuriHalCortexComp
Function,+,furi_hal_cortex_delay_us,void,uint32_t
Function,-,furi_hal_cortex_init_early,void,
Function,+,furi_hal_cortex_instructions_per_microsecond,uint32_t,
@@ -1278,7 +1280,7 @@ Function,+,furi_thread_set_priority,void,"FuriThread*, FuriThreadPriority"
Function,+,furi_thread_set_stack_size,void,"FuriThread*, size_t"
Function,+,furi_thread_set_state_callback,void,"FuriThread*, FuriThreadStateCallback"
Function,+,furi_thread_set_state_context,void,"FuriThread*, void*"
Function,+,furi_thread_set_stdout_callback,_Bool,FuriThreadStdoutWriteCallback
Function,+,furi_thread_set_stdout_callback,void,FuriThreadStdoutWriteCallback
Function,+,furi_thread_start,void,FuriThread*
Function,+,furi_thread_stdout_flush,int32_t,
Function,+,furi_thread_stdout_write,size_t,"const char*, size_t"
@@ -1287,6 +1289,7 @@ Function,+,furi_thread_yield,void,
Function,+,furi_timer_alloc,FuriTimer*,"FuriTimerCallback, FuriTimerType, void*"
Function,+,furi_timer_free,void,FuriTimer*
Function,+,furi_timer_is_running,uint32_t,FuriTimer*
Function,+,furi_timer_pending_callback,void,"FuriTimerPendigCallback, void*, uint32_t"
Function,+,furi_timer_start,FuriStatus,"FuriTimer*, uint32_t"
Function,+,furi_timer_stop,FuriStatus,FuriTimer*
Function,-,fwrite,size_t,"const void*, size_t, size_t, FILE*"
@@ -1376,12 +1379,11 @@ Function,-,ldiv,ldiv_t,"long, long"
Function,-,llabs,long long,long long
Function,-,lldiv,lldiv_t,"long long, long long"
Function,+,loader_get_pubsub,FuriPubSub*,Loader*
Function,+,loader_is_locked,_Bool,const Loader*
Function,+,loader_is_locked,_Bool,Loader*
Function,+,loader_lock,_Bool,Loader*
Function,+,loader_show_menu,void,
Function,+,loader_show_menu,void,Loader*
Function,+,loader_start,LoaderStatus,"Loader*, const char*, const char*"
Function,+,loader_unlock,void,Loader*
Function,+,loader_update_menu,void,
Function,+,loading_alloc,Loading*,
Function,+,loading_free,void,Loading*
Function,+,loading_get_view,View*,Loading*
1 entry status name type params
2 Version + 23.3 26.0
3 Header + applications/services/bt/bt_service/bt.h
4 Header + applications/services/cli/cli.h
5 Header + applications/services/cli/cli_vcp.h
892 Function + furi_hal_console_set_tx_callback void FuriHalConsoleTxCallback, void*
893 Function + furi_hal_console_tx void const uint8_t*, size_t
894 Function + furi_hal_console_tx_with_new_line void const uint8_t*, size_t
895 Function + furi_hal_cortex_comp_enable void FuriHalCortexComp, FuriHalCortexCompFunction, uint32_t, uint32_t, FuriHalCortexCompSize
896 Function + furi_hal_cortex_comp_reset void FuriHalCortexComp
897 Function + furi_hal_cortex_delay_us void uint32_t
898 Function - furi_hal_cortex_init_early void
899 Function + furi_hal_cortex_instructions_per_microsecond uint32_t
1280 Function + furi_thread_set_stack_size void FuriThread*, size_t
1281 Function + furi_thread_set_state_callback void FuriThread*, FuriThreadStateCallback
1282 Function + furi_thread_set_state_context void FuriThread*, void*
1283 Function + furi_thread_set_stdout_callback _Bool void FuriThreadStdoutWriteCallback
1284 Function + furi_thread_start void FuriThread*
1285 Function + furi_thread_stdout_flush int32_t
1286 Function + furi_thread_stdout_write size_t const char*, size_t
1289 Function + furi_timer_alloc FuriTimer* FuriTimerCallback, FuriTimerType, void*
1290 Function + furi_timer_free void FuriTimer*
1291 Function + furi_timer_is_running uint32_t FuriTimer*
1292 Function + furi_timer_pending_callback void FuriTimerPendigCallback, void*, uint32_t
1293 Function + furi_timer_start FuriStatus FuriTimer*, uint32_t
1294 Function + furi_timer_stop FuriStatus FuriTimer*
1295 Function - fwrite size_t const void*, size_t, size_t, FILE*
1379 Function - llabs long long long long
1380 Function - lldiv lldiv_t long long, long long
1381 Function + loader_get_pubsub FuriPubSub* Loader*
1382 Function + loader_is_locked _Bool const Loader* Loader*
1383 Function + loader_lock _Bool Loader*
1384 Function + loader_show_menu void Loader*
1385 Function + loader_start LoaderStatus Loader*, const char*, const char*
1386 Function + loader_unlock void Loader*
Function + loader_update_menu void
1387 Function + loading_alloc Loading*
1388 Function + loading_free void Loading*
1389 Function + loading_get_view View* Loading*

14
firmware/targets/f7/api_symbols.csv
View File

@@ -1,5 +1,5 @@
entry,status,name,type,params
Version,+,23.0,,
Version,+,26.0,,
Header,+,applications/main/fap_loader/fap_loader_app.h,,
Header,+,applications/services/bt/bt_service/bt.h,,
Header,+,applications/services/cli/cli.h,,
@@ -1171,6 +1171,8 @@ Function,+,furi_hal_console_puts,void,const char*
Function,+,furi_hal_console_set_tx_callback,void,"FuriHalConsoleTxCallback, void*"
Function,+,furi_hal_console_tx,void,"const uint8_t*, size_t"
Function,+,furi_hal_console_tx_with_new_line,void,"const uint8_t*, size_t"
Function,+,furi_hal_cortex_comp_enable,void,"FuriHalCortexComp, FuriHalCortexCompFunction, uint32_t, uint32_t, FuriHalCortexCompSize"
Function,+,furi_hal_cortex_comp_reset,void,FuriHalCortexComp
Function,+,furi_hal_cortex_delay_us,void,uint32_t
Function,-,furi_hal_cortex_init_early,void,
Function,+,furi_hal_cortex_instructions_per_microsecond,uint32_t,
@@ -1683,7 +1685,7 @@ Function,+,furi_thread_set_priority,void,"FuriThread*, FuriThreadPriority"
Function,+,furi_thread_set_stack_size,void,"FuriThread*, size_t"
Function,+,furi_thread_set_state_callback,void,"FuriThread*, FuriThreadStateCallback"
Function,+,furi_thread_set_state_context,void,"FuriThread*, void*"
Function,+,furi_thread_set_stdout_callback,_Bool,FuriThreadStdoutWriteCallback
Function,+,furi_thread_set_stdout_callback,void,FuriThreadStdoutWriteCallback
Function,+,furi_thread_start,void,FuriThread*
Function,+,furi_thread_stdout_flush,int32_t,
Function,+,furi_thread_stdout_write,size_t,"const char*, size_t"
@@ -1692,6 +1694,7 @@ Function,+,furi_thread_yield,void,
Function,+,furi_timer_alloc,FuriTimer*,"FuriTimerCallback, FuriTimerType, void*"
Function,+,furi_timer_free,void,FuriTimer*
Function,+,furi_timer_is_running,uint32_t,FuriTimer*
Function,+,furi_timer_pending_callback,void,"FuriTimerPendigCallback, void*, uint32_t"
Function,+,furi_timer_start,FuriStatus,"FuriTimer*, uint32_t"
Function,+,furi_timer_stop,FuriStatus,FuriTimer*
Function,-,fwrite,size_t,"const void*, size_t, size_t, FILE*"
@@ -1921,13 +1924,12 @@ Function,-,llround,long long int,double
Function,-,llroundf,long long int,float
Function,-,llroundl,long long int,long double
Function,+,loader_get_pubsub,FuriPubSub*,Loader*
Function,+,loader_is_locked,_Bool,const Loader*
Function,+,loader_is_locked,_Bool,Loader*
Function,+,loader_lock,_Bool,Loader*
Function,+,loader_show_menu,void,
Function,+,loader_show_settings,void,
Function,+,loader_show_menu,void,Loader*
Function,+,loader_show_settings,void,Loader*
Function,+,loader_start,LoaderStatus,"Loader*, const char*, const char*"
Function,+,loader_unlock,void,Loader*
Function,+,loader_update_menu,void,
Function,+,loading_alloc,Loading*,
Function,+,loading_free,void,Loading*
Function,+,loading_get_view,View*,Loading*
1 entry status name type params
2 Version + 23.0 26.0
3 Header + applications/main/fap_loader/fap_loader_app.h
4 Header + applications/services/bt/bt_service/bt.h
5 Header + applications/services/cli/cli.h
1171 Function + furi_hal_console_set_tx_callback void FuriHalConsoleTxCallback, void*
1172 Function + furi_hal_console_tx void const uint8_t*, size_t
1173 Function + furi_hal_console_tx_with_new_line void const uint8_t*, size_t
1174 Function + furi_hal_cortex_comp_enable void FuriHalCortexComp, FuriHalCortexCompFunction, uint32_t, uint32_t, FuriHalCortexCompSize
1175 Function + furi_hal_cortex_comp_reset void FuriHalCortexComp
1176 Function + furi_hal_cortex_delay_us void uint32_t
1177 Function - furi_hal_cortex_init_early void
1178 Function + furi_hal_cortex_instructions_per_microsecond uint32_t
1685 Function + furi_thread_set_stack_size void FuriThread*, size_t
1686 Function + furi_thread_set_state_callback void FuriThread*, FuriThreadStateCallback
1687 Function + furi_thread_set_state_context void FuriThread*, void*
1688 Function + furi_thread_set_stdout_callback _Bool void FuriThreadStdoutWriteCallback
1689 Function + furi_thread_start void FuriThread*
1690 Function + furi_thread_stdout_flush int32_t
1691 Function + furi_thread_stdout_write size_t const char*, size_t
1694 Function + furi_timer_alloc FuriTimer* FuriTimerCallback, FuriTimerType, void*
1695 Function + furi_timer_free void FuriTimer*
1696 Function + furi_timer_is_running uint32_t FuriTimer*
1697 Function + furi_timer_pending_callback void FuriTimerPendigCallback, void*, uint32_t
1698 Function + furi_timer_start FuriStatus FuriTimer*, uint32_t
1699 Function + furi_timer_stop FuriStatus FuriTimer*
1700 Function - fwrite size_t const void*, size_t, size_t, FILE*
1924 Function - llroundf long long int float
1925 Function - llroundl long long int long double
1926 Function + loader_get_pubsub FuriPubSub* Loader*
1927 Function + loader_is_locked _Bool const Loader* Loader*
1928 Function + loader_lock _Bool Loader*
1929 Function + loader_show_menu void Loader*
1930 Function + loader_show_settings void Loader*
1931 Function + loader_start LoaderStatus Loader*, const char*, const char*
1932 Function + loader_unlock void Loader*
Function + loader_update_menu void
1933 Function + loading_alloc Loading*
1934 Function + loading_free void Loading*
1935 Function + loading_get_view View* Loading*

72
firmware/targets/f7/furi_hal/furi_hal_cortex.c
View File

@@ -1,11 +1,12 @@
#include <furi_hal_cortex.h>
#include <furi.h>
#include <stm32wbxx.h>
#define FURI_HAL_CORTEX_INSTRUCTIONS_PER_MICROSECOND (SystemCoreClock / 1000000)
void furi_hal_cortex_init_early() {
CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
CoreDebug->DEMCR |= (CoreDebug_DEMCR_TRCENA_Msk | CoreDebug_DEMCR_MON_EN_Msk);
DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
DWT->CYCCNT = 0U;
@@ -38,4 +39,71 @@ bool furi_hal_cortex_timer_is_expired(FuriHalCortexTimer cortex_timer) {
void furi_hal_cortex_timer_wait(FuriHalCortexTimer cortex_timer) {
while(!furi_hal_cortex_timer_is_expired(cortex_timer))
;
}
}
// Duck ST
#undef COMP0
#undef COMP1
#undef COMP2
#undef COMP3
void furi_hal_cortex_comp_enable(
FuriHalCortexComp comp,
FuriHalCortexCompFunction function,
uint32_t value,
uint32_t mask,
FuriHalCortexCompSize size) {
uint32_t function_reg = (uint32_t)function | ((uint32_t)size << 10);
switch(comp) {
case FuriHalCortexComp0:
(DWT->COMP0) = value;
(DWT->MASK0) = mask;
(DWT->FUNCTION0) = function_reg;
break;
case FuriHalCortexComp1:
(DWT->COMP1) = value;
(DWT->MASK1) = mask;
(DWT->FUNCTION1) = function_reg;
break;
case FuriHalCortexComp2:
(DWT->COMP2) = value;
(DWT->MASK2) = mask;
(DWT->FUNCTION2) = function_reg;
break;
case FuriHalCortexComp3:
(DWT->COMP3) = value;
(DWT->MASK3) = mask;
(DWT->FUNCTION3) = function_reg;
break;
default:
furi_crash("Invalid parameter");
}
}
void furi_hal_cortex_comp_reset(FuriHalCortexComp comp) {
switch(comp) {
case FuriHalCortexComp0:
(DWT->COMP0) = 0;
(DWT->MASK0) = 0;
(DWT->FUNCTION0) = 0;
break;
case FuriHalCortexComp1:
(DWT->COMP1) = 0;
(DWT->MASK1) = 0;
(DWT->FUNCTION1) = 0;
break;
case FuriHalCortexComp2:
(DWT->COMP2) = 0;
(DWT->MASK2) = 0;
(DWT->FUNCTION2) = 0;
break;
case FuriHalCortexComp3:
(DWT->COMP3) = 0;
(DWT->MASK3) = 0;
(DWT->FUNCTION3) = 0;
break;
default:
furi_crash("Invalid parameter");
}
}

47
firmware/targets/furi_hal_include/furi_hal_cortex.h
View File

@@ -56,6 +56,53 @@ bool furi_hal_cortex_timer_is_expired(FuriHalCortexTimer cortex_timer);
*/
void furi_hal_cortex_timer_wait(FuriHalCortexTimer cortex_timer);
typedef enum {
FuriHalCortexComp0,
FuriHalCortexComp1,
FuriHalCortexComp2,
FuriHalCortexComp3,
} FuriHalCortexComp;
typedef enum {
FuriHalCortexCompSizeWord = 0b10,
FuriHalCortexCompSizeHalfWord = 0b01,
FuriHalCortexCompSizeByte = 0b00,
} FuriHalCortexCompSize;
typedef enum {
FuriHalCortexCompFunctionPC = 0b100,
FuriHalCortexCompFunctionRead = 0b101,
FuriHalCortexCompFunctionWrite = 0b110,
FuriHalCortexCompFunctionReadWrite = 0b110,
} FuriHalCortexCompFunction;
/** Enable DWT comparator
*
* Allows to programmatically set instruction/data breakpoints.
*
* More details on how it works can be found in armv7m official documentation:
* https://developer.arm.com/documentation/ddi0403/d/Debug-Architecture/ARMv7-M-Debug/The-Data-Watchpoint-and-Trace-unit/The-DWT-comparators
* https://developer.arm.com/documentation/ddi0403/d/Debug-Architecture/ARMv7-M-Debug/The-Data-Watchpoint-and-Trace-unit/Comparator-Function-registers--DWT-FUNCTIONn
*
* @param[in] comp The Comparator
* @param[in] function The Comparator Function to use
* @param[in] value The value
* @param[in] mask The mask
* @param[in] size The size
*/
void furi_hal_cortex_comp_enable(
FuriHalCortexComp comp,
FuriHalCortexCompFunction function,
uint32_t value,
uint32_t mask,
FuriHalCortexCompSize size);
/** Reset DWT comparator
*
* @param[in] comp The Comparator
*/
void furi_hal_cortex_comp_reset(FuriHalCortexComp comp);
#ifdef __cplusplus
}
#endif

30
furi/core/thread.c
View File

@@ -164,10 +164,13 @@ FuriThread* furi_thread_alloc_ex(
void furi_thread_free(FuriThread* thread) {
furi_assert(thread);
furi_assert(thread->state == FuriThreadStateStopped);
if(thread->name) free((void*)thread->name);
if(thread->appid) free((void*)thread->appid);
// Ensure that use join before free
furi_assert(thread->state == FuriThreadStateStopped);
furi_assert(thread->task_handle == NULL);
if(thread->name) free(thread->name);
if(thread->appid) free(thread->appid);
furi_string_free(thread->output.buffer);
free(thread);
@@ -176,14 +179,14 @@ void furi_thread_free(FuriThread* thread) {
void furi_thread_set_name(FuriThread* thread, const char* name) {
furi_assert(thread);
furi_assert(thread->state == FuriThreadStateStopped);
if(thread->name) free((void*)thread->name);
if(thread->name) free(thread->name);
thread->name = name ? strdup(name) : NULL;
}
void furi_thread_set_appid(FuriThread* thread, const char* appid) {
furi_assert(thread);
furi_assert(thread->state == FuriThreadStateStopped);
if(thread->appid) free((void*)thread->appid);
if(thread->appid) free(thread->appid);
thread->appid = appid ? strdup(appid) : NULL;
}
@@ -276,7 +279,7 @@ void furi_thread_cleanup_tcb_event(TaskHandle_t task) {
if(thread) {
// clear thread local storage
vTaskSetThreadLocalStoragePointer(task, 0, NULL);
furi_assert(thread->task_handle == task);
thread->task_handle = NULL;
}
}
@@ -332,7 +335,6 @@ FuriThreadId furi_thread_get_current_id() {
FuriThread* furi_thread_get_current() {
FuriThread* thread = pvTaskGetThreadLocalStoragePointer(NULL, 0);
furi_assert(thread != NULL);
return thread;
}
@@ -579,24 +581,22 @@ static int32_t __furi_thread_stdout_flush(FuriThread* thread) {
return 0;
}
bool furi_thread_set_stdout_callback(FuriThreadStdoutWriteCallback callback) {
void furi_thread_set_stdout_callback(FuriThreadStdoutWriteCallback callback) {
FuriThread* thread = furi_thread_get_current();
furi_assert(thread);
__furi_thread_stdout_flush(thread);
thread->output.write_callback = callback;
return true;
}
FuriThreadStdoutWriteCallback furi_thread_get_stdout_callback() {
FuriThread* thread = furi_thread_get_current();
furi_assert(thread);
return thread->output.write_callback;
}
size_t furi_thread_stdout_write(const char* data, size_t size) {
FuriThread* thread = furi_thread_get_current();
furi_assert(thread);
if(size == 0 || data == NULL) {
return __furi_thread_stdout_flush(thread);
} else {
@@ -619,7 +619,9 @@ size_t furi_thread_stdout_write(const char* data, size_t size) {
}
int32_t furi_thread_stdout_flush() {
return __furi_thread_stdout_flush(furi_thread_get_current());
FuriThread* thread = furi_thread_get_current();
furi_assert(thread);
return __furi_thread_stdout_flush(thread);
}
void furi_thread_suspend(FuriThreadId thread_id) {

8
furi/core/thread.h
View File

@@ -233,7 +233,7 @@ FuriThreadId furi_thread_get_current_id();
/** Get FuriThread instance for current thread
*
* @return FuriThread*
* @return pointer to FuriThread or NULL if this thread doesn't belongs to Furi
*/
FuriThread* furi_thread_get_current();
@@ -288,12 +288,10 @@ uint32_t furi_thread_get_stack_space(FuriThreadId thread_id);
FuriThreadStdoutWriteCallback furi_thread_get_stdout_callback();
/** Set STDOUT callback for thread
*
*
* @param callback callback or NULL to clear
*
* @return true on success, otherwise fail
*/
bool furi_thread_set_stdout_callback(FuriThreadStdoutWriteCallback callback);
void furi_thread_set_stdout_callback(FuriThreadStdoutWriteCallback callback);
/** Write data to buffered STDOUT
*

10
furi/core/timer.c
View File

@@ -124,3 +124,13 @@ uint32_t furi_timer_is_running(FuriTimer* instance) {
/* Return 0: not running, 1: running */
return (uint32_t)xTimerIsTimerActive(hTimer);
}
void furi_timer_pending_callback(FuriTimerPendigCallback callback, void* context, uint32_t arg) {
BaseType_t ret = pdFAIL;
if(furi_kernel_is_irq_or_masked()) {
ret = xTimerPendFunctionCallFromISR(callback, context, arg, NULL);
} else {
ret = xTimerPendFunctionCall(callback, context, arg, FuriWaitForever);
}
furi_check(ret == pdPASS);
}

4
furi/core/timer.h
View File

@@ -56,6 +56,10 @@ FuriStatus furi_timer_stop(FuriTimer* instance);
*/
uint32_t furi_timer_is_running(FuriTimer* instance);
typedef void (*FuriTimerPendigCallback)(void* context, uint32_t arg);
void furi_timer_pending_callback(FuriTimerPendigCallback callback, void* context, uint32_t arg);
#ifdef __cplusplus
}
#endif