Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-14 09:18:35 -07:00
Code Issues Packages Projects Releases Wiki Activity

fmt

Browse Source
This commit is contained in:
RogueMaster
2022-11-12 08:37:29 -05:00
parent ffbbc7ecde
commit 4b9f353c78
11 changed files with 524 additions and 497 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
applications/main/archive/scenes/archive_scene_browser.c
View File

@@ -74,10 +74,10 @@ static void archive_run_in_app(ArchiveBrowserView* browser, ArchiveFile_t* selec
strcpy(result, tmpType); strcpy(result, tmpType);
strcat(result, furi_string_get_cstr(selected->path)); strcat(result, furi_string_get_cstr(selected->path));
status = loader_start(loader, "Applications", result); status = loader_start(loader, "Applications", result);
// } else if(strcmp(flipper_app_name[selected->type], "125 kHz RFID") == 0) { // } else if(strcmp(flipper_app_name[selected->type], "125 kHz RFID") == 0) {
// char* tmpType = "/ext/apps/Main/lfrfid.fap¯"; // char* tmpType = "/ext/apps/Main/lfrfid.fap¯";
// char* result = // char* result =
// malloc(strlen(tmpType) + strlen(furi_string_get_cstr(selected->path)) + 1); // malloc(strlen(tmpType) + strlen(furi_string_get_cstr(selected->path)) + 1);
// strcpy(result, tmpType); // strcpy(result, tmpType);
// strcat(result, furi_string_get_cstr(selected->path)); // strcat(result, furi_string_get_cstr(selected->path));

855
applications/main/archive/views/archive_browser_view.c
View File

@@ -59,509 +59,516 @@ static void render_item_menu(Canvas* canvas, ArchiveBrowserViewModel* model) {
ArchiveFile_t* selected = ArchiveFile_t* selected =
files_array_get(model->files, model->item_idx - model->array_offset); files_array_get(model->files, model->item_idx - model->array_offset);
menu[0] = furi_string_alloc_set("Run in app");
menu[1] = furi_string_alloc_set("Pin");
menu[2] = furi_string_alloc_set("Rename");
menu[3] = furi_string_alloc_set("Delete");
menu[0] = furi_string_alloc_set("Run in app"); ArchiveFile_t* selected =
menu[1] = furi_string_alloc_set("Pin"); files_array_get(model->files, model->item_idx - model->array_offset);
menu[2] = furi_string_alloc_set("Rename");
menu[3] = furi_string_alloc_set("Delete");
ArchiveFile_t* selected = files_array_get(model->files, model->item_idx - model->array_offset); if((selected->fav) || (model->tab_idx == ArchiveTabFavorites)) {
furi_string_set(menu[1], "Unpin");
if((selected->fav) || (model->tab_idx == ArchiveTabFavorites)) {
furi_string_set(menu[1], "Unpin");
}
if(!archive_is_known_app(selected->type)) {
furi_string_set(menu[0], "---");
furi_string_set(menu[1], "---");
} else {
if(model->tab_idx == ArchiveTabFavorites) {
furi_string_set(menu[2], "Move");
furi_string_set(menu[3], "---");
} else if(selected->is_app) {
furi_string_set(menu[2], "---");
} }
if(selected->type == ArchiveFileTypeFolder) { if(!archive_is_known_app(selected->type)) {
//FURI_LOG_D(TAG, "Directory type"); furi_string_set(menu[0], "---");
archive_menu_add_item( furi_string_set(menu[1], "---");
menu_array_push_raw(model->context_menu),
item_rename,
ArchiveBrowserEventFileMenuRename);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_delete,
ArchiveBrowserEventFileMenuDelete);
} else if(!archive_is_known_app(selected->type)) {
//FURI_LOG_D(TAG, "Unknown type");
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_info,
ArchiveBrowserEventFileMenuInfo);
if(selected->is_text_file) {
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_show,
ArchiveBrowserEventFileMenuShow);
}
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_rename,
ArchiveBrowserEventFileMenuRename);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_delete,
ArchiveBrowserEventFileMenuDelete);
} else if(model->tab_idx == ArchiveTabFavorites) {
//FURI_LOG_D(TAG, "ArchiveTabFavorites");
furi_string_set(item_rename, "Move");
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_run,
ArchiveBrowserEventFileMenuRun);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_pin,
ArchiveBrowserEventFileMenuPin);
if(selected->type <= ArchiveFileTypeBadUsb) {
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_show,
ArchiveBrowserEventFileMenuShow);
}
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_rename,
ArchiveBrowserEventFileMenuRename);
} else if(selected->is_app) {
//FURI_LOG_D(TAG, "3 types");
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_run,
ArchiveBrowserEventFileMenuRun);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_info,
ArchiveBrowserEventFileMenuInfo);
if(selected->type <= ArchiveFileTypeBadUsb) {
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_show,
ArchiveBrowserEventFileMenuShow);
}
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_pin,
ArchiveBrowserEventFileMenuPin);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_delete,
ArchiveBrowserEventFileMenuDelete);
} else { } else {
//FURI_LOG_D(TAG, "All menu"); if(model->tab_idx == ArchiveTabFavorites) {
archive_menu_add_item( furi_string_set(menu[2], "Move");
menu_array_push_raw(model->context_menu), furi_string_set(menu[3], "---");
item_run, } else if(selected->is_app) {
ArchiveBrowserEventFileMenuRun); furi_string_set(menu[2], "---");
archive_menu_add_item( }
menu_array_push_raw(model->context_menu),
item_pin, if(selected->type == ArchiveFileTypeFolder) {
ArchiveBrowserEventFileMenuPin); //FURI_LOG_D(TAG, "Directory type");
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_info,
ArchiveBrowserEventFileMenuInfo);
if(selected->type <= ArchiveFileTypeBadUsb) {
archive_menu_add_item( archive_menu_add_item(
menu_array_push_raw(model->context_menu), menu_array_push_raw(model->context_menu),
item_show, item_rename,
ArchiveBrowserEventFileMenuShow); ArchiveBrowserEventFileMenuRename);
} archive_menu_add_item(
archive_menu_add_item( menu_array_push_raw(model->context_menu),
menu_array_push_raw(model->context_menu), item_delete,
item_rename, ArchiveBrowserEventFileMenuDelete);
ArchiveBrowserEventFileMenuRename); } else if(!archive_is_known_app(selected->type)) {
archive_menu_add_item( //FURI_LOG_D(TAG, "Unknown type");
menu_array_push_raw(model->context_menu),
item_delete,
ArchiveBrowserEventFileMenuDelete);
}
furi_string_free(item_run); archive_menu_add_item(
furi_string_free(item_pin); menu_array_push_raw(model->context_menu),
furi_string_free(item_info); item_info,
furi_string_free(item_show); ArchiveBrowserEventFileMenuInfo);
furi_string_free(item_rename); if(selected->is_text_file) {
furi_string_free(item_delete); archive_menu_add_item(
} /*else { menu_array_push_raw(model->context_menu),
item_show,
ArchiveBrowserEventFileMenuShow);
}
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_rename,
ArchiveBrowserEventFileMenuRename);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_delete,
ArchiveBrowserEventFileMenuDelete);
} else if(model->tab_idx == ArchiveTabFavorites) {
//FURI_LOG_D(TAG, "ArchiveTabFavorites");
furi_string_set(item_rename, "Move");
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_run,
ArchiveBrowserEventFileMenuRun);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_pin,
ArchiveBrowserEventFileMenuPin);
if(selected->type <= ArchiveFileTypeBadUsb) {
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_show,
ArchiveBrowserEventFileMenuShow);
}
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_rename,
ArchiveBrowserEventFileMenuRename);
} else if(selected->is_app) {
//FURI_LOG_D(TAG, "3 types");
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_run,
ArchiveBrowserEventFileMenuRun);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_info,
ArchiveBrowserEventFileMenuInfo);
if(selected->type <= ArchiveFileTypeBadUsb) {
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_show,
ArchiveBrowserEventFileMenuShow);
}
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_pin,
ArchiveBrowserEventFileMenuPin);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_delete,
ArchiveBrowserEventFileMenuDelete);
} else {
//FURI_LOG_D(TAG, "All menu");
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_run,
ArchiveBrowserEventFileMenuRun);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_pin,
ArchiveBrowserEventFileMenuPin);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_info,
ArchiveBrowserEventFileMenuInfo);
if(selected->type <= ArchiveFileTypeBadUsb) {
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_show,
ArchiveBrowserEventFileMenuShow);
}
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_rename,
ArchiveBrowserEventFileMenuRename);
archive_menu_add_item(
menu_array_push_raw(model->context_menu),
item_delete,
ArchiveBrowserEventFileMenuDelete);
}
furi_string_free(item_run);
furi_string_free(item_pin);
furi_string_free(item_info);
furi_string_free(item_show);
furi_string_free(item_rename);
furi_string_free(item_delete);
} /*else {
FURI_LOG_D(TAG, "menu_array_size already set: %d", menu_array_size(model->context_menu)); FURI_LOG_D(TAG, "menu_array_size already set: %d", menu_array_size(model->context_menu));
}*/ }*/
size_t size_menu = menu_array_size(model->context_menu); size_t size_menu = menu_array_size(model->context_menu);
const uint8_t menu_height = 48; const uint8_t menu_height = 48;
const uint8_t line_height = 10; const uint8_t line_height = 10;
canvas_set_color(canvas, ColorWhite); canvas_set_color(canvas, ColorWhite);
uint8_t calc_height = menu_height - ((MENU_ITEMS - size_menu) * line_height); uint8_t calc_height = menu_height - ((MENU_ITEMS - size_menu) * line_height);
canvas_draw_box(canvas, 71, 1, 57, calc_height + 4); canvas_draw_box(canvas, 71, 1, 57, calc_height + 4);
canvas_set_color(canvas, ColorBlack); canvas_set_color(canvas, ColorBlack);
elements_slightly_rounded_frame(canvas, 70, 2, 58, calc_height + 4); elements_slightly_rounded_frame(canvas, 70, 2, 58, calc_height + 4);
/*FURI_LOG_D( /*FURI_LOG_D(
TAG, TAG,
"size_menu: %d, calc_height: %d, menu_idx: %d", "size_menu: %d, calc_height: %d, menu_idx: %d",
size_menu, size_menu,
calc_height, calc_height,
model->menu_idx);*/ model->menu_idx);*/
for(size_t i = 0; i < size_menu; i++) { for(size_t i = 0; i < size_menu; i++) {
ArchiveContextMenuItem_t* current = menu_array_get(model->context_menu, i); ArchiveContextMenuItem_t* current = menu_array_get(model->context_menu, i);
canvas_draw_str(canvas, 82, 11 + i * line_height, furi_string_get_cstr(current->text)); canvas_draw_str(canvas, 82, 11 + i * line_height, furi_string_get_cstr(current->text));
}
canvas_draw_icon(canvas, 74, 4 + model->menu_idx * line_height, &I_ButtonRight_4x7);
} }
canvas_draw_icon(canvas, 74, 4 + model->menu_idx * line_height, &I_ButtonRight_4x7); static void archive_draw_frame(Canvas * canvas, uint16_t idx, bool scrollbar, bool moving) {
} uint8_t x_offset = moving ? MOVE_OFFSET : 0;
static void archive_draw_frame(Canvas* canvas, uint16_t idx, bool scrollbar, bool moving) { canvas_set_color(canvas, ColorBlack);
uint8_t x_offset = moving ? MOVE_OFFSET : 0; canvas_draw_box(
canvas,
0 + x_offset,
15 + idx * FRAME_HEIGHT,
(scrollbar ? 122 : 127) - x_offset,
FRAME_HEIGHT);
canvas_set_color(canvas, ColorBlack); canvas_set_color(canvas, ColorWhite);
canvas_draw_box( canvas_draw_dot(canvas, 0 + x_offset, 15 + idx * FRAME_HEIGHT);
canvas, canvas_draw_dot(canvas, 1 + x_offset, 15 + idx * FRAME_HEIGHT);
0 + x_offset, canvas_draw_dot(canvas, 0 + x_offset, (15 + idx * FRAME_HEIGHT) + 1);
15 + idx * FRAME_HEIGHT,
(scrollbar ? 122 : 127) - x_offset,
FRAME_HEIGHT);
canvas_set_color(canvas, ColorWhite); canvas_draw_dot(canvas, 0 + x_offset, (15 + idx * FRAME_HEIGHT) + 11);
canvas_draw_dot(canvas, 0 + x_offset, 15 + idx * FRAME_HEIGHT); canvas_draw_dot(canvas, scrollbar ? 121 : 126, 15 + idx * FRAME_HEIGHT);
canvas_draw_dot(canvas, 1 + x_offset, 15 + idx * FRAME_HEIGHT); canvas_draw_dot(canvas, scrollbar ? 121 : 126, (15 + idx * FRAME_HEIGHT) + 11);
canvas_draw_dot(canvas, 0 + x_offset, (15 + idx * FRAME_HEIGHT) + 1); }
canvas_draw_dot(canvas, 0 + x_offset, (15 + idx * FRAME_HEIGHT) + 11); static void archive_draw_loading(Canvas * canvas, ArchiveBrowserViewModel * model) {
canvas_draw_dot(canvas, scrollbar ? 121 : 126, 15 + idx * FRAME_HEIGHT); furi_assert(model);
canvas_draw_dot(canvas, scrollbar ? 121 : 126, (15 + idx * FRAME_HEIGHT) + 11);
}
static void archive_draw_loading(Canvas* canvas, ArchiveBrowserViewModel* model) { uint8_t x = 128 / 2 - 24 / 2;
furi_assert(model); uint8_t y = 64 / 2 - 24 / 2;
uint8_t x = 128 / 2 - 24 / 2; canvas_draw_icon(canvas, x, y, &A_Loading_24);
uint8_t y = 64 / 2 - 24 / 2; }
canvas_draw_icon(canvas, x, y, &A_Loading_24); static void draw_list(Canvas * canvas, ArchiveBrowserViewModel * model) {
} furi_assert(model);
static void draw_list(Canvas* canvas, ArchiveBrowserViewModel* model) { size_t array_size = files_array_size(model->files);
furi_assert(model); bool scrollbar = model->item_cnt > 4;
size_t array_size = files_array_size(model->files); for(uint32_t i = 0; i < MIN(model->item_cnt, MENU_ITEMS); ++i) {
bool scrollbar = model->item_cnt > 4; FuriString* str_buf;
str_buf = furi_string_alloc();
int32_t idx = CLAMP((uint32_t)(i + model->list_offset), model->item_cnt, 0u);
uint8_t x_offset = (model->move_fav && model->item_idx == idx) ? MOVE_OFFSET : 0;
for(uint32_t i = 0; i < MIN(model->item_cnt, MENU_ITEMS); ++i) { ArchiveFileTypeEnum file_type = ArchiveFileTypeLoading;
FuriString* str_buf; uint8_t* custom_icon_data = NULL;
str_buf = furi_string_alloc();
int32_t idx = CLAMP((uint32_t)(i + model->list_offset), model->item_cnt, 0u);
uint8_t x_offset = (model->move_fav && model->item_idx == idx) ? MOVE_OFFSET : 0;
ArchiveFileTypeEnum file_type = ArchiveFileTypeLoading; if(archive_is_item_in_array(model, idx)) {
uint8_t* custom_icon_data = NULL; ArchiveFile_t* file = files_array_get(
model->files, CLAMP(idx - model->array_offset, (int32_t)(array_size - 1), 0));
if(archive_is_item_in_array(model, idx)) { file_type = file->type;
ArchiveFile_t* file = files_array_get( if(file_type == ArchiveFileTypeApplication) {
model->files, CLAMP(idx - model->array_offset, (int32_t)(array_size - 1), 0)); if(file->custom_icon_data) {
file_type = file->type; custom_icon_data = file->custom_icon_data;
if(file_type == ArchiveFileTypeApplication) { furi_string_set(str_buf, file->custom_name);
if(file->custom_icon_data) { } else {
custom_icon_data = file->custom_icon_data; file_type = ArchiveFileTypeUnknown;
furi_string_set(str_buf, file->custom_name); path_extract_filename(
file->path, str_buf, archive_is_known_app(file->type));
}
} else { } else {
file_type = ArchiveFileTypeUnknown;
path_extract_filename(file->path, str_buf, archive_is_known_app(file->type)); path_extract_filename(file->path, str_buf, archive_is_known_app(file->type));
} }
} else { } else {
path_extract_filename(file->path, str_buf, archive_is_known_app(file->type)); furi_string_set(str_buf, "---");
} }
} else {
furi_string_set(str_buf, "---"); elements_string_fit_width(
canvas, str_buf, (scrollbar ? MAX_LEN_PX - 6 : MAX_LEN_PX) - x_offset);
if(model->item_idx == idx) {
archive_draw_frame(canvas, i, scrollbar, model->move_fav);
} else {
canvas_set_color(canvas, ColorBlack);
}
if(custom_icon_data) {
canvas_draw_bitmap(
canvas, 2 + x_offset, 16 + i * FRAME_HEIGHT, 11, 10, custom_icon_data);
} else {
canvas_draw_icon(
canvas, 2 + x_offset, 16 + i * FRAME_HEIGHT, ArchiveItemIcons[file_type]);
}
canvas_draw_str(
canvas, 15 + x_offset, 24 + i * FRAME_HEIGHT, furi_string_get_cstr(str_buf));
furi_string_free(str_buf);
} }
elements_string_fit_width( if(scrollbar) {
canvas, str_buf, (scrollbar ? MAX_LEN_PX - 6 : MAX_LEN_PX) - x_offset); elements_scrollbar_pos(canvas, 126, 15, 49, model->item_idx, model->item_cnt);
if(model->item_idx == idx) {
archive_draw_frame(canvas, i, scrollbar, model->move_fav);
} else {
canvas_set_color(canvas, ColorBlack);
} }
if(custom_icon_data) { if(model->menu) {
canvas_draw_bitmap( render_item_menu(canvas, model);
canvas, 2 + x_offset, 16 + i * FRAME_HEIGHT, 11, 10, custom_icon_data);
} else {
canvas_draw_icon(
canvas, 2 + x_offset, 16 + i * FRAME_HEIGHT, ArchiveItemIcons[file_type]);
} }
canvas_draw_str(
canvas, 15 + x_offset, 24 + i * FRAME_HEIGHT, furi_string_get_cstr(str_buf));
furi_string_free(str_buf);
} }
if(scrollbar) { static void archive_render_status_bar(Canvas * canvas, ArchiveBrowserViewModel * model) {
elements_scrollbar_pos(canvas, 126, 15, 49, model->item_idx, model->item_cnt); furi_assert(model);
const char* tab_name = ArchiveTabNames[model->tab_idx];
canvas_draw_icon(canvas, 0, 0, &I_Background_128x11);
canvas_set_color(canvas, ColorWhite);
canvas_draw_box(canvas, 0, 0, 50, 13);
canvas_draw_box(canvas, 107, 0, 20, 13);
canvas_set_color(canvas, ColorBlack);
canvas_draw_rframe(canvas, 0, 0, 51, 13, 1); // frame
canvas_draw_line(canvas, 49, 1, 49, 11); // shadow right
canvas_draw_line(canvas, 1, 11, 49, 11); // shadow bottom
canvas_draw_str_aligned(canvas, 25, 9, AlignCenter, AlignBottom, tab_name);
canvas_draw_rframe(canvas, 107, 0, 21, 13, 1);
canvas_draw_line(canvas, 126, 1, 126, 11);
canvas_draw_line(canvas, 108, 11, 126, 11);
if(model->move_fav) {
canvas_draw_icon(canvas, 110, 4, &I_ButtonUp_7x4);
canvas_draw_icon(canvas, 117, 4, &I_ButtonDown_7x4);
} else {
canvas_draw_icon(canvas, 111, 2, &I_ButtonLeft_4x7);
canvas_draw_icon(canvas, 119, 2, &I_ButtonRight_4x7);
}
canvas_set_color(canvas, ColorWhite);
canvas_draw_dot(canvas, 50, 0);
canvas_draw_dot(canvas, 127, 0);
canvas_set_color(canvas, ColorBlack);
} }
if(model->menu) { static void archive_view_render(Canvas * canvas, void* mdl) {
render_item_menu(canvas, model); ArchiveBrowserViewModel* model = mdl;
}
}
static void archive_render_status_bar(Canvas* canvas, ArchiveBrowserViewModel* model) { archive_render_status_bar(canvas, mdl);
furi_assert(model);
const char* tab_name = ArchiveTabNames[model->tab_idx]; if(model->folder_loading) {
archive_draw_loading(canvas, model);
canvas_draw_icon(canvas, 0, 0, &I_Background_128x11); } else if(model->item_cnt > 0) {
draw_list(canvas, model);
canvas_set_color(canvas, ColorWhite); } else {
canvas_draw_box(canvas, 0, 0, 50, 13); canvas_draw_str_aligned(
canvas_draw_box(canvas, 107, 0, 20, 13); canvas, GUI_DISPLAY_WIDTH / 2, 40, AlignCenter, AlignCenter, "Empty");
}
canvas_set_color(canvas, ColorBlack);
canvas_draw_rframe(canvas, 0, 0, 51, 13, 1); // frame
canvas_draw_line(canvas, 49, 1, 49, 11); // shadow right
canvas_draw_line(canvas, 1, 11, 49, 11); // shadow bottom
canvas_draw_str_aligned(canvas, 25, 9, AlignCenter, AlignBottom, tab_name);
canvas_draw_rframe(canvas, 107, 0, 21, 13, 1);
canvas_draw_line(canvas, 126, 1, 126, 11);
canvas_draw_line(canvas, 108, 11, 126, 11);
if(model->move_fav) {
canvas_draw_icon(canvas, 110, 4, &I_ButtonUp_7x4);
canvas_draw_icon(canvas, 117, 4, &I_ButtonDown_7x4);
} else {
canvas_draw_icon(canvas, 111, 2, &I_ButtonLeft_4x7);
canvas_draw_icon(canvas, 119, 2, &I_ButtonRight_4x7);
} }
canvas_set_color(canvas, ColorWhite); View* archive_browser_get_view(ArchiveBrowserView * browser) {
canvas_draw_dot(canvas, 50, 0); furi_assert(browser);
canvas_draw_dot(canvas, 127, 0); return browser->view;
canvas_set_color(canvas, ColorBlack);
}
static void archive_view_render(Canvas* canvas, void* mdl) {
ArchiveBrowserViewModel* model = mdl;
archive_render_status_bar(canvas, mdl);
if(model->folder_loading) {
archive_draw_loading(canvas, model);
} else if(model->item_cnt > 0) {
draw_list(canvas, model);
} else {
canvas_draw_str_aligned(
canvas, GUI_DISPLAY_WIDTH / 2, 40, AlignCenter, AlignCenter, "Empty");
} }
}
View* archive_browser_get_view(ArchiveBrowserView* browser) { static bool is_file_list_load_required(ArchiveBrowserViewModel * model) {
furi_assert(browser); size_t array_size = files_array_size(model->files);
return browser->view;
}
static bool is_file_list_load_required(ArchiveBrowserViewModel* model) { if((model->list_loading) || (array_size >= model->item_cnt)) {
size_t array_size = files_array_size(model->files); return false;
}
if((model->array_offset > 0) &&
(model->item_idx < (model->array_offset + FILE_LIST_BUF_LEN / 4))) {
return true;
}
if(((model->array_offset + array_size) < model->item_cnt) &&
(model->item_idx >
(int32_t)(model->array_offset + array_size - FILE_LIST_BUF_LEN / 4))) {
return true;
}
if((model->list_loading) || (array_size >= model->item_cnt)) {
return false; return false;
} }
if((model->array_offset > 0) && static bool archive_view_input(InputEvent * event, void* context) {
(model->item_idx < (model->array_offset + FILE_LIST_BUF_LEN / 4))) { furi_assert(event);
return true; furi_assert(context);
}
if(((model->array_offset + array_size) < model->item_cnt) && ArchiveBrowserView* browser = context;
(model->item_idx > (int32_t)(model->array_offset + array_size - FILE_LIST_BUF_LEN / 4))) {
return true;
}
return false; bool in_menu;
} bool move_fav_mode;
with_view_model(
browser->view,
ArchiveBrowserViewModel * model,
{
in_menu = model->menu;
move_fav_mode = model->move_fav;
},
false);
static bool archive_view_input(InputEvent* event, void* context) { if(in_menu) {
furi_assert(event); if(event->type != InputTypeShort) {
furi_assert(context); return true; // RETURN
}
ArchiveBrowserView* browser = context; if(event->key == InputKeyUp || event->key == InputKeyDown) {
with_view_model(
bool in_menu; browser->view,
bool move_fav_mode; ArchiveBrowserViewModel * model,
with_view_model( {
browser->view, size_t size_menu = menu_array_size(model->context_menu);
ArchiveBrowserViewModel * model, if(event->key == InputKeyUp) {
{ model->menu_idx = ((model->menu_idx - 1) + size_menu) % size_menu;
in_menu = model->menu; } else if(event->key == InputKeyDown) {
move_fav_mode = model->move_fav; model->menu_idx = (model->menu_idx + 1) % size_menu;
}, }
false); },
true);
if(in_menu) { } else if(event->key == InputKeyOk) {
if(event->type != InputTypeShort) { uint32_t idx;
return true; // RETURN with_view_model(
} browser->view,
if(event->key == InputKeyUp || event->key == InputKeyDown) { ArchiveBrowserViewModel * model,
with_view_model( {
browser->view, ArchiveContextMenuItem_t* current =
ArchiveBrowserViewModel * model, menu_array_get(model->context_menu, model->menu_idx);
{ idx = current->event;
size_t size_menu = menu_array_size(model->context_menu); },
if(event->key == InputKeyUp) { false);
model->menu_idx = ((model->menu_idx - 1) + size_menu) % size_menu; browser->callback(idx, browser->context);
} else if(event->key == InputKeyDown) {
model->menu_idx = (model->menu_idx + 1) % size_menu;
}
},
true);
} else if(event->key == InputKeyOk) {
uint32_t idx;
with_view_model(
browser->view,
ArchiveBrowserViewModel * model,
{
ArchiveContextMenuItem_t* current =
menu_array_get(model->context_menu, model->menu_idx);
idx = current->event;
},
false);
browser->callback(idx, browser->context);
} else if(event->key == InputKeyBack) {
browser->callback(ArchiveBrowserEventFileMenuClose, browser->context);
}
} else {
if(event->type == InputTypeShort) {
if(event->key == InputKeyLeft || event->key == InputKeyRight) {
if(move_fav_mode) return false;
archive_switch_tab(browser, event->key);
} else if(event->key == InputKeyBack) { } else if(event->key == InputKeyBack) {
if(move_fav_mode) { browser->callback(ArchiveBrowserEventFileMenuClose, browser->context);
browser->callback(ArchiveBrowserEventExitFavMove, browser->context); }
} else { } else {
browser->callback(ArchiveBrowserEventExit, browser->context); if(event->type == InputTypeShort) {
if(event->key == InputKeyLeft || event->key == InputKeyRight) {
if(move_fav_mode) return false;
archive_switch_tab(browser, event->key);
} else if(event->key == InputKeyBack) {
if(move_fav_mode) {
browser->callback(ArchiveBrowserEventExitFavMove, browser->context);
} else {
browser->callback(ArchiveBrowserEventExit, browser->context);
}
} }
} }
}
if((event->key == InputKeyUp || event->key == InputKeyDown) && if((event->key == InputKeyUp || event->key == InputKeyDown) &&
(event->type == InputTypeShort || event->type == InputTypeRepeat)) { (event->type == InputTypeShort || event->type == InputTypeRepeat)) {
with_view_model( with_view_model(
browser->view, browser->view,
ArchiveBrowserViewModel * model, ArchiveBrowserViewModel * model,
{ {
if(event->key == InputKeyUp) { if(event->key == InputKeyUp) {
model->item_idx = model->item_idx =
((model->item_idx - 1) + model->item_cnt) % model->item_cnt; ((model->item_idx - 1) + model->item_cnt) % model->item_cnt;
if(is_file_list_load_required(model)) { if(is_file_list_load_required(model)) {
model->list_loading = true; model->list_loading = true;
browser->callback(ArchiveBrowserEventLoadPrevItems, browser->context); browser->callback(
ArchiveBrowserEventLoadPrevItems, browser->context);
}
if(move_fav_mode) {
browser->callback(ArchiveBrowserEventFavMoveUp, browser->context);
}
} else if(event->key == InputKeyDown) {
model->item_idx = (model->item_idx + 1) % model->item_cnt;
if(is_file_list_load_required(model)) {
model->list_loading = true;
browser->callback(
ArchiveBrowserEventLoadNextItems, browser->context);
}
if(move_fav_mode) {
browser->callback(
ArchiveBrowserEventFavMoveDown, browser->context);
}
} }
if(move_fav_mode) { },
browser->callback(ArchiveBrowserEventFavMoveUp, browser->context); true);
} archive_update_offset(browser);
} else if(event->key == InputKeyDown) { }
model->item_idx = (model->item_idx + 1) % model->item_cnt;
if(is_file_list_load_required(model)) {
model->list_loading = true;
browser->callback(ArchiveBrowserEventLoadNextItems, browser->context);
}
if(move_fav_mode) {
browser->callback(ArchiveBrowserEventFavMoveDown, browser->context);
}
}
},
true);
archive_update_offset(browser);
}
if(event->key == InputKeyOk) { if(event->key == InputKeyOk) {
ArchiveFile_t* selected = archive_get_current_file(browser); ArchiveFile_t* selected = archive_get_current_file(browser);
if(selected) { if(selected) {
bool favorites = archive_get_tab(browser) == ArchiveTabFavorites; bool favorites = archive_get_tab(browser) == ArchiveTabFavorites;
bool folder = selected->type == ArchiveFileTypeFolder; bool folder = selected->type == ArchiveFileTypeFolder;
if(event->type == InputTypeShort) { if(event->type == InputTypeShort) {
if(favorites) { if(favorites) {
if(move_fav_mode) {
browser->callback(
ArchiveBrowserEventSaveFavMove, browser->context);
} else {
browser->callback(
ArchiveBrowserEventFileMenuRun, browser->context);
}
} else if(folder) {
browser->callback(ArchiveBrowserEventEnterDir, browser->context);
} else {
browser->callback(ArchiveBrowserEventFileMenuOpen, browser->context);
}
} else if(event->type == InputTypeLong) {
if(move_fav_mode) { if(move_fav_mode) {
browser->callback(ArchiveBrowserEventSaveFavMove, browser->context); browser->callback(ArchiveBrowserEventSaveFavMove, browser->context);
} else { } else if(folder || favorites) {
browser->callback(ArchiveBrowserEventFileMenuRun, browser->context); browser->callback(ArchiveBrowserEventFileMenuOpen, browser->context);
} }
} else if(folder) {
browser->callback(ArchiveBrowserEventEnterDir, browser->context);
} else {
browser->callback(ArchiveBrowserEventFileMenuOpen, browser->context);
}
} else if(event->type == InputTypeLong) {
if(move_fav_mode) {
browser->callback(ArchiveBrowserEventSaveFavMove, browser->context);
} else if(folder || favorites) {
browser->callback(ArchiveBrowserEventFileMenuOpen, browser->context);
} }
} }
} }
} }
return true;
} }
return true; ArchiveBrowserView* browser_alloc() {
} ArchiveBrowserView* browser = malloc(sizeof(ArchiveBrowserView));
browser->view = view_alloc();
view_allocate_model(browser->view, ViewModelTypeLocking, sizeof(ArchiveBrowserViewModel));
view_set_context(browser->view, browser);
view_set_draw_callback(browser->view, archive_view_render);
view_set_input_callback(browser->view, archive_view_input);
ArchiveBrowserView* browser_alloc() { browser->path = furi_string_alloc_set(archive_get_default_path(TAB_DEFAULT));
ArchiveBrowserView* browser = malloc(sizeof(ArchiveBrowserView));
browser->view = view_alloc();
view_allocate_model(browser->view, ViewModelTypeLocking, sizeof(ArchiveBrowserViewModel));
view_set_context(browser->view, browser);
view_set_draw_callback(browser->view, archive_view_render);
view_set_input_callback(browser->view, archive_view_input);
browser->path = furi_string_alloc_set(archive_get_default_path(TAB_DEFAULT)); with_view_model(
browser->view,
ArchiveBrowserViewModel * model,
{
files_array_init(model->files);
menu_array_init(model->context_menu);
model->tab_idx = TAB_DEFAULT;
},
true);
with_view_model( return browser;
browser->view,
ArchiveBrowserViewModel * model,
{
files_array_init(model->files);
menu_array_init(model->context_menu);
model->tab_idx = TAB_DEFAULT;
},
true);
return browser;
}
void browser_free(ArchiveBrowserView* browser) {
furi_assert(browser);
if(browser->worker_running) {
file_browser_worker_free(browser->worker);
} }
with_view_model( void browser_free(ArchiveBrowserView * browser) {
browser->view, furi_assert(browser);
ArchiveBrowserViewModel * model,
{
files_array_clear(model->files);
menu_array_clear(model->context_menu);
},
false);
furi_string_free(browser->path); if(browser->worker_running) {
file_browser_worker_free(browser->worker);
}
view_free(browser->view); with_view_model(
free(browser); browser->view,
} ArchiveBrowserViewModel * model,
{
files_array_clear(model->files);
menu_array_clear(model->context_menu);
},
false);
furi_string_free(browser->path);
view_free(browser->view);
free(browser);
}

3
applications/main/bad_usb/bad_usb_script.c
View File

@@ -468,8 +468,7 @@ static int32_t ducky_script_execute_next(BadUsbScript* bad_usb, File* script_fil
FURI_LOG_E( FURI_LOG_E(
WORKER_TAG, "Forbidden empty line at line %u", bad_usb->st.line_cur); WORKER_TAG, "Forbidden empty line at line %u", bad_usb->st.line_cur);
} else { } else {
FURI_LOG_E( FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur);
WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur);
} }
return SCRIPT_STATE_ERROR; return SCRIPT_STATE_ERROR;
} else { } else {

19
applications/main/clock/clock_app.c
View File

@@ -302,24 +302,11 @@ static void clock_render_callback(Canvas* const canvas, void* ctx) {
int32_t elapsed_secs_img2 = (elapsed_secs % 60) % 4; int32_t elapsed_secs_img2 = (elapsed_secs % 60) % 4;
// int32_t elapsed_secs_img3 = (elapsed_secs % 60) % 4; // int32_t elapsed_secs_img3 = (elapsed_secs % 60) % 4;
static const Icon* const count_anim[5] = { static const Icon* const count_anim[5] = {
&I_HappyFlipper_128x64, &I_HappyFlipper_128x64, &I_G0ku, &I_g0ku_1, &I_g0ku_2, &I_g0ku_3};
&I_G0ku,
&I_g0ku_1,
&I_g0ku_2,
&I_g0ku_3
};
static const Icon* const count_anim2[4] = { static const Icon* const count_anim2[4] = {
&I_EviWaiting1_18x21, &I_EviWaiting1_18x21, &I_EviWaiting2_18x21, &I_EviSmile1_18x21, &I_EviSmile2_18x21};
&I_EviWaiting2_18x21,
&I_EviSmile1_18x21,
&I_EviSmile2_18x21
};
static const Icon* const count_anim3[4] = { static const Icon* const count_anim3[4] = {
&I_frame_01, &I_frame_01, &I_frame_02, &I_frame_03, &I_frame_02};
&I_frame_02,
&I_frame_03,
&I_frame_02
};
canvas_draw_icon(canvas, -5, 15, count_anim[elapsed_secs_img]); canvas_draw_icon(canvas, -5, 15, count_anim[elapsed_secs_img]);
canvas_draw_icon(canvas, 90, 0, count_anim2[elapsed_secs_img2]); canvas_draw_icon(canvas, 90, 0, count_anim2[elapsed_secs_img2]);
canvas_draw_icon(canvas, 110, 5, count_anim3[elapsed_secs_img2]); canvas_draw_icon(canvas, 110, 5, count_anim3[elapsed_secs_img2]);

16
applications/main/nfc/scenes/nfc_scene_passport_auth.c
View File

@@ -43,20 +43,22 @@ bool nfc_scene_passport_auth_load(Nfc* nfc) {
FuriString* file_path; FuriString* file_path;
file_path = furi_string_alloc(); file_path = furi_string_alloc();
bool res = dialog_file_browser_show(nfc->dev->dialogs, file_path, mrtd_app_folder, &browser_options); bool res =
dialog_file_browser_show(nfc->dev->dialogs, file_path, mrtd_app_folder, &browser_options);
furi_string_free(mrtd_app_folder); furi_string_free(mrtd_app_folder);
if(res) { if(res) {
mrtd_auth_params_load( mrtd_auth_params_load(
nfc->dev->storage, nfc->dev->storage,
nfc->dev->dialogs, nfc->dev->dialogs,
&nfc->dev->dev_data.mrtd_data.auth, &nfc->dev->dev_data.mrtd_data.auth,
furi_string_get_cstr(file_path), furi_string_get_cstr(file_path),
true); true);
nfc_scene_passport_auth_on_enter(nfc); nfc_scene_passport_auth_on_enter(nfc);
variable_item_list_set_selected_item(nfc->variable_item_list, NfcScenePassportAuthSelectAuth); variable_item_list_set_selected_item(
nfc->variable_item_list, NfcScenePassportAuthSelectAuth);
} }
return res; return res;

7
applications/main/nfc/scenes/nfc_scene_passport_auth_save_name.c
View File

@@ -41,8 +41,8 @@ void nfc_scene_passport_auth_save_name_on_enter(void* context) {
furi_string_set(folder_path, NFC_APP_FOLDER); furi_string_set(folder_path, NFC_APP_FOLDER);
} }
ValidatorIsFile* validator_is_file = validator_is_file_alloc_init( ValidatorIsFile* validator_is_file =
furi_string_get_cstr(folder_path), NFC_APP_EXTENSION, NULL); validator_is_file_alloc_init(furi_string_get_cstr(folder_path), NFC_APP_EXTENSION, NULL);
text_input_set_validator(text_input, validator_is_file_callback, validator_is_file); text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextInput); view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextInput);
@@ -57,7 +57,8 @@ bool nfc_scene_passport_auth_save_name_on_event(void* context, SceneManagerEvent
if(event.type == SceneManagerEventTypeCustom) { if(event.type == SceneManagerEventTypeCustom) {
if(event.event == NfcCustomEventTextInputDone) { if(event.event == NfcCustomEventTextInputDone) {
if(mrtd_auth_params_save(nfc->dev->storage, nfc->dev->dialogs, &mrtd_data->auth, nfc->text_store)) { if(mrtd_auth_params_save(
nfc->dev->storage, nfc->dev->dialogs, &mrtd_data->auth, nfc->text_store)) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess); scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
consumed = true; consumed = true;
} else { } else {

3
applications/main/nfc/scenes/nfc_scene_passport_read_auth.c
View File

@@ -37,7 +37,8 @@ void nfc_scene_passport_read_auth_on_enter(void* context) {
FuriString* temp_str; FuriString* temp_str;
temp_str = furi_string_alloc(); temp_str = furi_string_alloc();
furi_string_set(temp_str, "\e#Passport\n"); furi_string_set(temp_str, "\e#Passport\n");
furi_string_cat_printf(temp_str, "Auth.method: %s\n", mrtd_auth_method_string(mrtd_data->auth_method_used)); furi_string_cat_printf(
temp_str, "Auth.method: %s\n", mrtd_auth_method_string(mrtd_data->auth_method_used));
// TODO: indicate BAC / PACE used // TODO: indicate BAC / PACE used
uint16_t lds_version = mrtd_data->files.EF_COM.lds_version; uint16_t lds_version = mrtd_data->files.EF_COM.lds_version;

8
applications/main/nfc/scenes/nfc_scene_read.c
View File

@@ -92,9 +92,11 @@ bool nfc_scene_read_on_event(void* context, SceneManagerEvent event) {
consumed = true; consumed = true;
} else if(event.event == NfcWorkerEventReadPassport) { } else if(event.event == NfcWorkerEventReadPassport) {
notification_message(nfc->notifications, &sequence_success); notification_message(nfc->notifications, &sequence_success);
FURI_LOG_D("NFC", "Read passport, auth: %d, success: %d", FURI_LOG_D(
nfc->dev->dev_data.mrtd_data.auth.method, "NFC",
nfc->dev->dev_data.mrtd_data.auth_success); "Read passport, auth: %d, success: %d",
nfc->dev->dev_data.mrtd_data.auth.method,
nfc->dev->dev_data.mrtd_data.auth_success);
if(nfc->dev->dev_data.mrtd_data.auth_success) { if(nfc->dev->dev_data.mrtd_data.auth_success) {
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportReadAuthSuccess); scene_manager_next_scene(nfc->scene_manager, NfcScenePassportReadAuthSuccess);
} else { } else {

21
lib/nfc/helpers/mrtd_helpers.c
View File

@@ -13,16 +13,16 @@ static inline unsigned char* ucstr(const char* str) {
const char* mrtd_auth_method_string(MrtdAuthMethod method) { const char* mrtd_auth_method_string(MrtdAuthMethod method) {
switch(method) { switch(method) {
case MrtdAuthMethodBac: case MrtdAuthMethodBac:
return "BAC"; return "BAC";
case MrtdAuthMethodPace: case MrtdAuthMethodPace:
return "PACE"; return "PACE";
case MrtdAuthMethodNone: case MrtdAuthMethodNone:
return "None"; return "None";
case MrtdAuthMethodAny: case MrtdAuthMethodAny:
return "Any"; return "Any";
default: default:
return "Unknown"; return "Unknown";
} }
} }
@@ -46,7 +46,6 @@ bool mrtd_auth_method_parse_string(MrtdAuthMethod* method, const char* str) {
return false; return false;
} }
uint8_t mrtd_bac_check_digit(const char* input, const uint8_t length) { uint8_t mrtd_bac_check_digit(const char* input, const uint8_t length) {
const uint8_t num_weights = 3; const uint8_t num_weights = 3;
uint8_t weights[] = {7, 3, 1}; uint8_t weights[] = {7, 3, 1};

60
lib/nfc/protocols/mrtd.c
View File

@@ -584,18 +584,18 @@ bool mrtd_authenticate(MrtdApplication* app) {
app->mrtd_data->auth_method_used = MrtdAuthMethodNone; app->mrtd_data->auth_method_used = MrtdAuthMethodNone;
FURI_LOG_D(TAG, "Auth method: %d", method); FURI_LOG_D(TAG, "Auth method: %d", method);
switch(method) { switch(method) {
case MrtdAuthMethodAny: case MrtdAuthMethodAny:
//TODO: try PACE, then BAC. For now, fall through to just BAC //TODO: try PACE, then BAC. For now, fall through to just BAC
case MrtdAuthMethodBac: case MrtdAuthMethodBac:
app->mrtd_data->auth_success = mrtd_bac(app, &app->mrtd_data->auth); app->mrtd_data->auth_success = mrtd_bac(app, &app->mrtd_data->auth);
app->mrtd_data->auth_method_used = MrtdAuthMethodBac; app->mrtd_data->auth_method_used = MrtdAuthMethodBac;
break; break;
case MrtdAuthMethodPace: case MrtdAuthMethodPace:
FURI_LOG_E(TAG, "Auth method PACE not implemented"); FURI_LOG_E(TAG, "Auth method PACE not implemented");
break; break;
case MrtdAuthMethodNone: case MrtdAuthMethodNone:
default: default:
break; break;
} }
if(!app->mrtd_data->auth_success) { if(!app->mrtd_data->auth_success) {
@@ -605,16 +605,17 @@ bool mrtd_authenticate(MrtdApplication* app) {
return true; return true;
} }
bool mrtd_auth_params_save(Storage* storage, DialogsApp* dialogs, MrtdAuthData* auth_data, const char* file_name) { bool mrtd_auth_params_save(
return mrtd_auth_params_save_file(storage, dialogs, auth_data, file_name, MRTD_APP_FOLDER, MRTD_APP_EXTENSION); Storage* storage,
DialogsApp* dialogs,
MrtdAuthData* auth_data,
const char* file_name) {
return mrtd_auth_params_save_file(
storage, dialogs, auth_data, file_name, MRTD_APP_FOLDER, MRTD_APP_EXTENSION);
} }
void mrtd_date_prepare_format_string(MrtdDate date, FuriString* format_string) { void mrtd_date_prepare_format_string(MrtdDate date, FuriString* format_string) {
furi_string_printf( furi_string_printf(format_string, "%02u%02u%02u", date.year, date.month, date.day);
format_string, "%02u%02u%02u",
date.year,
date.month,
date.day);
} }
bool mrtd_date_parse_format_string(MrtdDate* date, FuriString* format_string) { bool mrtd_date_parse_format_string(MrtdDate* date, FuriString* format_string) {
@@ -633,7 +634,13 @@ bool mrtd_date_parse_format_string(MrtdDate* date, FuriString* format_string) {
return true; return true;
} }
bool mrtd_auth_params_save_file(Storage* storage, DialogsApp* dialogs, MrtdAuthData* auth_data, const char* file_name, const char* folder, const char* extension) { bool mrtd_auth_params_save_file(
Storage* storage,
DialogsApp* dialogs,
MrtdAuthData* auth_data,
const char* file_name,
const char* folder,
const char* extension) {
furi_assert(auth_data); furi_assert(auth_data);
bool saved = false; bool saved = false;
@@ -650,7 +657,8 @@ bool mrtd_auth_params_save_file(Storage* storage, DialogsApp* dialogs, MrtdAuthD
// Open file // Open file
if(!flipper_format_file_open_always(file, furi_string_get_cstr(temp_str))) break; if(!flipper_format_file_open_always(file, furi_string_get_cstr(temp_str))) break;
// Write header // Write header
if(!flipper_format_write_header_cstr(file, mrtd_auth_file_header, mrtd_auth_file_version)) break; if(!flipper_format_write_header_cstr(file, mrtd_auth_file_header, mrtd_auth_file_version))
break;
// Write auth method // Write auth method
furi_string_set(temp_str, mrtd_auth_method_string(auth_data->method)); furi_string_set(temp_str, mrtd_auth_method_string(auth_data->method));
@@ -679,7 +687,12 @@ bool mrtd_auth_params_save_file(Storage* storage, DialogsApp* dialogs, MrtdAuthD
return saved; return saved;
} }
bool mrtd_auth_params_load(Storage* storage, DialogsApp* dialogs, MrtdAuthData* auth_data, const char* file_path, bool show_dialog) { bool mrtd_auth_params_load(
Storage* storage,
DialogsApp* dialogs,
MrtdAuthData* auth_data,
const char* file_path,
bool show_dialog) {
furi_assert(storage); furi_assert(storage);
furi_assert(dialogs); furi_assert(dialogs);
furi_assert(auth_data); furi_assert(auth_data);
@@ -702,7 +715,8 @@ bool mrtd_auth_params_load(Storage* storage, DialogsApp* dialogs, MrtdAuthData*
uint32_t version = 0; uint32_t version = 0;
if(!flipper_format_read_header(file, temp_str, &version)) break; if(!flipper_format_read_header(file, temp_str, &version)) break;
FURI_LOG_D(TAG, "Version: %s", furi_string_get_cstr(temp_str)); FURI_LOG_D(TAG, "Version: %s", furi_string_get_cstr(temp_str));
if(furi_string_cmp_str(temp_str, mrtd_auth_file_header) || (version != mrtd_auth_file_version)) { if(furi_string_cmp_str(temp_str, mrtd_auth_file_header) ||
(version != mrtd_auth_file_version)) {
deprecated_version = true; deprecated_version = true;
break; break;
} }

21
lib/nfc/protocols/mrtd.h
View File

@@ -23,7 +23,22 @@ bool mrtd_select_app(MrtdApplication* app, AIDValue aid);
bool mrtd_authenticate(MrtdApplication* app); bool mrtd_authenticate(MrtdApplication* app);
bool mrtd_read_parse_file(MrtdApplication* app, EFFile file); bool mrtd_read_parse_file(MrtdApplication* app, EFFile file);
bool mrtd_auth_params_save(Storage* storage, DialogsApp* dialogs, MrtdAuthData* auth_data, const char* file_name); bool mrtd_auth_params_save(
bool mrtd_auth_params_save_file(Storage* storage, DialogsApp* dialogs, MrtdAuthData* auth_data, const char* file_name, const char* folder, const char* extension); Storage* storage,
DialogsApp* dialogs,
MrtdAuthData* auth_data,
const char* file_name);
bool mrtd_auth_params_save_file(
Storage* storage,
DialogsApp* dialogs,
MrtdAuthData* auth_data,
const char* file_name,
const char* folder,
const char* extension);
bool mrtd_auth_params_load(Storage* storage, DialogsApp* dialogs, MrtdAuthData* auth_data, const char* file_path, bool show_dialog); bool mrtd_auth_params_load(
Storage* storage,
DialogsApp* dialogs,
MrtdAuthData* auth_data,
const char* file_path,
bool show_dialog);