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

[FL-2565] Archive: switch to browser worker #1295

Browse Source
This commit is contained in:
Nikolay Minaylov
2022-06-09 10:09:52 +03:00
committed by GitHub
parent 8b54436950
commit 41cf421234
19 changed files with 377 additions and 360 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
applications/archive/helpers/archive_apps.c
View File

@@ -7,8 +7,14 @@ static const char* known_apps[] = {
};
ArchiveAppTypeEnum archive_get_app_type(const char* path) {
const char* app_name = strchr(path, ':');
if(app_name == NULL) {
return ArchiveAppTypeUnknown;
}
app_name++;
for(size_t i = 0; i < COUNT_OF(known_apps); i++) {
if(strncmp(path, known_apps[i], strlen(known_apps[i])) == 0) {
if(strncmp(app_name, known_apps[i], strlen(known_apps[i])) == 0) {
return i;
}
}

277
applications/archive/helpers/archive_browser.c
View File

@@ -1,8 +1,91 @@
#include "archive/views/archive_browser_view.h"
#include "archive_files.h"
#include "archive_apps.h"
#include "archive_browser.h"
#include "furi/common_defines.h"
#include "furi/log.h"
#include "gui/modules/file_browser_worker.h"
#include "m-string.h"
#include <math.h>
static void
archive_folder_open_cb(void* context, uint32_t item_cnt, int32_t file_idx, bool is_root) {
furi_assert(context);
ArchiveBrowserView* browser = (ArchiveBrowserView*)context;
int32_t load_offset = 0;
browser->is_root = is_root;
if((item_cnt == 0) && (archive_is_home(browser))) {
archive_switch_tab(browser, browser->last_tab_switch_dir);
} else if(!string_start_with_str_p(browser->path, "/app:")) {
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
files_array_reset(model->files);
model->item_cnt = item_cnt;
model->item_idx = (file_idx > 0) ? file_idx : 0;
load_offset =
CLAMP(model->item_idx - FILE_LIST_BUF_LEN / 2, (int32_t)model->item_cnt, 0);
model->array_offset = 0;
model->list_offset = 0;
model->list_loading = true;
model->folder_loading = false;
return false;
});
archive_update_offset(browser);
file_browser_worker_load(browser->worker, load_offset, FILE_LIST_BUF_LEN);
}
}
static void archive_list_load_cb(void* context, uint32_t list_load_offset) {
furi_assert(context);
ArchiveBrowserView* browser = (ArchiveBrowserView*)context;
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
files_array_reset(model->files);
model->array_offset = list_load_offset;
return false;
});
}
static void archive_list_item_cb(void* context, string_t item_path, bool is_folder, bool is_last) {
furi_assert(context);
ArchiveBrowserView* browser = (ArchiveBrowserView*)context;
if(!is_last) {
archive_add_file_item(browser, is_folder, string_get_cstr(item_path));
} else {
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
model->list_loading = false;
return true;
});
}
}
static void archive_long_load_cb(void* context) {
furi_assert(context);
ArchiveBrowserView* browser = (ArchiveBrowserView*)context;
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
model->folder_loading = true;
return true;
});
}
void archive_file_browser_set_callbacks(ArchiveBrowserView* browser) {
furi_assert(browser);
file_browser_worker_set_callback_context(browser->worker, browser);
file_browser_worker_set_folder_callback(browser->worker, archive_folder_open_cb);
file_browser_worker_set_list_callback(browser->worker, archive_list_load_cb);
file_browser_worker_set_item_callback(browser->worker, archive_list_item_cb);
file_browser_worker_set_long_load_callback(browser->worker, archive_long_load_cb);
}
bool archive_is_item_in_array(ArchiveBrowserViewModel* model, uint32_t idx) {
size_t array_size = files_array_size(model->files);
@@ -39,9 +122,9 @@ void archive_update_focus(ArchiveBrowserView* browser, const char* target) {
furi_assert(browser);
furi_assert(target);
archive_get_filenames(browser, string_get_cstr(browser->path));
archive_get_items(browser, string_get_cstr(browser->path));
if(!archive_file_get_array_size(browser) && !archive_get_depth(browser)) {
if(!archive_file_get_array_size(browser) && archive_is_home(browser)) {
archive_switch_tab(browser, TAB_RIGHT);
} else {
with_view_model(
@@ -49,7 +132,7 @@ void archive_update_focus(ArchiveBrowserView* browser, const char* target) {
uint16_t idx = 0;
while(idx < files_array_size(model->files)) {
ArchiveFile_t* current = files_array_get(model->files, idx);
if(!string_search(current->name, target)) {
if(!string_search(current->path, target)) {
model->item_idx = idx + model->array_offset;
break;
}
@@ -102,7 +185,7 @@ void archive_file_array_rm_selected(ArchiveBrowserView* browser) {
return false;
});
if((items_cnt == 0) && (archive_get_depth(browser) == 0)) {
if((items_cnt == 0) && (archive_is_home(browser))) {
archive_switch_tab(browser, TAB_RIGHT);
}
@@ -145,7 +228,7 @@ void archive_file_array_rm_all(ArchiveBrowserView* browser) {
});
}
bool archive_file_array_load(ArchiveBrowserView* browser, int8_t dir) {
void archive_file_array_load(ArchiveBrowserView* browser, int8_t dir) {
furi_assert(browser);
int32_t offset_new = 0;
@@ -160,22 +243,17 @@ bool archive_file_array_load(ArchiveBrowserView* browser, int8_t dir) {
} else {
offset_new = model->item_idx - FILE_LIST_BUF_LEN / 4 * 1;
}
offset_new = CLAMP(offset_new, (int32_t)model->item_cnt - FILE_LIST_BUF_LEN, 0);
if(offset_new > 0) {
offset_new =
CLAMP(offset_new, (int32_t)model->item_cnt - FILE_LIST_BUF_LEN, 0);
} else {
offset_new = 0;
}
}
return false;
});
bool res = archive_dir_read_items(
browser, string_get_cstr(browser->path), offset_new, FILE_LIST_BUF_LEN);
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
model->array_offset = offset_new;
model->list_loading = false;
return true;
});
return res;
file_browser_worker_load(browser->worker, offset_new, FILE_LIST_BUF_LEN);
}
ArchiveFile_t* archive_get_current_file(ArchiveBrowserView* browser) {
@@ -218,26 +296,20 @@ ArchiveTabEnum archive_get_tab(ArchiveBrowserView* browser) {
return tab_id;
}
uint8_t archive_get_depth(ArchiveBrowserView* browser) {
bool archive_is_home(ArchiveBrowserView* browser) {
furi_assert(browser);
uint8_t depth;
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
depth = idx_last_array_size(model->idx_last);
return false;
});
if(browser->is_root) {
return true;
}
return depth;
}
const char* archive_get_path(ArchiveBrowserView* browser) {
return string_get_cstr(browser->path);
const char* default_path = archive_get_default_path(archive_get_tab(browser));
return (string_cmp_str(browser->path, default_path) == 0);
}
const char* archive_get_name(ArchiveBrowserView* browser) {
ArchiveFile_t* selected = archive_get_current_file(browser);
return string_get_cstr(selected->name);
return string_get_cstr(selected->path);
}
void archive_set_tab(ArchiveBrowserView* browser, ArchiveTabEnum tab) {
@@ -249,37 +321,15 @@ void archive_set_tab(ArchiveBrowserView* browser, ArchiveTabEnum tab) {
return false;
});
}
void archive_set_last_tab(ArchiveBrowserView* browser, ArchiveTabEnum tab) {
UNUSED(tab); // FIXME?
furi_assert(browser);
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
model->last_tab = model->tab_idx;
return false;
});
}
void archive_add_app_item(ArchiveBrowserView* browser, const char* name) {
furi_assert(browser);
furi_assert(name);
ArchiveFile_t item;
string_t full_name;
string_init_set(full_name, browser->path);
string_cat_printf(full_name, "/%s", name);
char* app_name = strchr(string_get_cstr(full_name), ':');
if(app_name == NULL) {
string_clear(full_name);
return;
}
ArchiveFile_t_init(&item);
string_init_set_str(item.name, name);
archive_set_file_type(&item, NULL, app_name + 1, true);
string_set_str(item.path, name);
archive_set_file_type(&item, name, false, true);
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
@@ -288,29 +338,24 @@ void archive_add_app_item(ArchiveBrowserView* browser, const char* name) {
return false;
});
ArchiveFile_t_clear(&item);
string_clear(full_name);
}
void archive_add_file_item(ArchiveBrowserView* browser, FileInfo* file_info, const char* name) {
void archive_add_file_item(ArchiveBrowserView* browser, bool is_folder, const char* name) {
furi_assert(browser);
furi_assert(file_info);
furi_assert(name);
ArchiveFile_t item;
if(archive_filter_by_extension(
file_info, archive_get_tab_ext(archive_get_tab(browser)), name)) {
ArchiveFile_t_init(&item);
string_init_set_str(item.name, name);
archive_set_file_type(&item, file_info, archive_get_path(browser), false);
ArchiveFile_t_init(&item);
string_init_set_str(item.path, name);
archive_set_file_type(&item, string_get_cstr(browser->path), is_folder, false);
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
files_array_push_back(model->files, item);
return false;
});
ArchiveFile_t_clear(&item);
}
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
files_array_push_back(model->files, item);
return false;
});
ArchiveFile_t_clear(&item);
}
void archive_show_file_menu(ArchiveBrowserView* browser, bool show) {
@@ -323,7 +368,7 @@ void archive_show_file_menu(ArchiveBrowserView* browser, bool show) {
model->menu_idx = 0;
ArchiveFile_t* selected =
files_array_get(model->files, model->item_idx - model->array_offset);
selected->fav = archive_is_favorite("%s", string_get_cstr(selected->name));
selected->fav = archive_is_favorite("%s", string_get_cstr(selected->path));
}
} else {
model->menu = false;
@@ -344,36 +389,40 @@ void archive_favorites_move_mode(ArchiveBrowserView* browser, bool active) {
});
}
void archive_switch_dir(ArchiveBrowserView* browser, const char* path) {
furi_assert(browser);
furi_assert(path);
string_set(browser->path, path);
archive_get_filenames(browser, string_get_cstr(browser->path));
archive_update_offset(browser);
}
void archive_switch_tab(ArchiveBrowserView* browser, InputKey key) {
furi_assert(browser);
ArchiveTabEnum tab = archive_get_tab(browser);
browser->last_tab_switch_dir = key;
if(key == InputKeyLeft) {
tab = ((tab - 1) + ArchiveTabTotal) % ArchiveTabTotal;
} else if(key == InputKeyRight) {
} else {
tab = (tab + 1) % ArchiveTabTotal;
}
browser->is_root = true;
archive_set_tab(browser, tab);
const char* path = archive_get_default_path(tab);
string_set_str(browser->path, archive_get_default_path(tab));
bool tab_empty = true;
if(tab == ArchiveTabFavorites) {
if(archive_favorites_count(browser) > 0) tab_empty = false;
} else if(strncmp(path, "/app:", 5) == 0) {
if(archive_app_is_available(browser, path)) tab_empty = false;
if(archive_favorites_count(browser) > 0) {
tab_empty = false;
}
} else if(string_start_with_str_p(browser->path, "/app:")) {
char* app_name = strchr(string_get_cstr(browser->path), ':');
if(app_name != NULL) {
if(archive_app_is_available(browser, string_get_cstr(browser->path))) {
tab_empty = false;
}
}
} else {
uint32_t files_cnt = archive_dir_count_items(browser, archive_get_default_path(tab));
if(files_cnt > 0) tab_empty = false;
ArchiveTabEnum tab = archive_get_tab(browser);
bool skip_assets = (strcmp(archive_get_tab_ext(tab), "*") == 0) ? false : true;
file_browser_worker_set_config(
browser->worker, browser->path, archive_get_tab_ext(tab), skip_assets);
tab_empty = false; // Empty check will be performed later
}
if((tab_empty) && (tab != ArchiveTabBrowser)) {
@@ -381,60 +430,46 @@ void archive_switch_tab(ArchiveBrowserView* browser, InputKey key) {
} else {
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
if(model->last_tab != model->tab_idx) {
model->item_idx = 0;
model->array_offset = 0;
idx_last_array_reset(model->idx_last);
}
model->item_idx = 0;
model->array_offset = 0;
return false;
});
archive_switch_dir(browser, archive_get_default_path(tab));
archive_get_items(browser, string_get_cstr(browser->path));
archive_update_offset(browser);
}
archive_set_last_tab(browser, tab);
}
void archive_enter_dir(ArchiveBrowserView* browser, string_t name) {
void archive_enter_dir(ArchiveBrowserView* browser, string_t path) {
furi_assert(browser);
furi_assert(name);
furi_assert(path);
if(string_size(name) >= (MAX_NAME_LEN - 1)) {
return;
}
int32_t idx_temp = 0;
if(string_cmp(browser->path, name) != 0) {
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
idx_last_array_push_back(model->idx_last, model->item_idx);
model->array_offset = 0;
model->item_idx = 0;
return false;
});
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
idx_temp = model->item_idx;
return false;
});
string_set(browser->path, name);
}
archive_dir_count_items(browser, string_get_cstr(name));
archive_switch_dir(browser, string_get_cstr(browser->path));
string_set(browser->path, path);
file_browser_worker_folder_enter(browser->worker, path, idx_temp);
}
void archive_leave_dir(ArchiveBrowserView* browser) {
furi_assert(browser);
const char* path = archive_get_path(browser);
char* last_char_ptr = strrchr(path, '/');
file_browser_worker_folder_exit(browser->worker);
}
if(last_char_ptr) {
size_t pos = last_char_ptr - path;
string_left(browser->path, pos);
}
void archive_refresh_dir(ArchiveBrowserView* browser) {
furi_assert(browser);
archive_dir_count_items(browser, path);
int32_t idx_temp = 0;
with_view_model(
browser->view, (ArchiveBrowserViewModel * model) {
idx_last_array_pop_back(&model->item_idx, model->idx_last);
idx_temp = model->item_idx;
return false;
});
archive_switch_dir(browser, path);
file_browser_worker_folder_refresh(browser->worker, idx_temp);
}

14
applications/archive/helpers/archive_browser.h
View File

@@ -2,11 +2,12 @@
#include "../archive_i.h"
#define TAB_RIGHT InputKeyRight //default tab swith direction
#define TAB_RIGHT InputKeyRight // Default tab swith direction
#define TAB_DEFAULT ArchiveTabFavorites // Start tab
#define FILE_LIST_BUF_LEN 100
static const char* tab_default_paths[] = {
[ArchiveTabFavorites] = "/any/favorites",
[ArchiveTabFavorites] = "/app:favorites",
[ArchiveTabIButton] = "/any/ibutton",
[ArchiveTabNFC] = "/any/nfc",
[ArchiveTabSubGhz] = "/any/subghz",
@@ -62,7 +63,7 @@ bool archive_is_item_in_array(ArchiveBrowserViewModel* model, uint32_t idx);
void archive_update_offset(ArchiveBrowserView* browser);
void archive_update_focus(ArchiveBrowserView* browser, const char* target);
bool archive_file_array_load(ArchiveBrowserView* browser, int8_t dir);
void archive_file_array_load(ArchiveBrowserView* browser, int8_t dir);
size_t archive_file_get_array_size(ArchiveBrowserView* browser);
void archive_file_array_rm_selected(ArchiveBrowserView* browser);
void archive_file_array_swap(ArchiveBrowserView* browser, int8_t dir);
@@ -73,15 +74,16 @@ void archive_set_item_count(ArchiveBrowserView* browser, uint32_t count);
ArchiveFile_t* archive_get_current_file(ArchiveBrowserView* browser);
ArchiveFile_t* archive_get_file_at(ArchiveBrowserView* browser, size_t idx);
ArchiveTabEnum archive_get_tab(ArchiveBrowserView* browser);
uint8_t archive_get_depth(ArchiveBrowserView* browser);
const char* archive_get_path(ArchiveBrowserView* browser);
bool archive_is_home(ArchiveBrowserView* browser);
const char* archive_get_name(ArchiveBrowserView* browser);
void archive_add_app_item(ArchiveBrowserView* browser, const char* name);
void archive_add_file_item(ArchiveBrowserView* browser, FileInfo* file_info, const char* name);
void archive_add_file_item(ArchiveBrowserView* browser, bool is_folder, const char* name);
void archive_show_file_menu(ArchiveBrowserView* browser, bool show);
void archive_favorites_move_mode(ArchiveBrowserView* browser, bool active);
void archive_switch_tab(ArchiveBrowserView* browser, InputKey key);
void archive_enter_dir(ArchiveBrowserView* browser, string_t name);
void archive_leave_dir(ArchiveBrowserView* browser);
void archive_refresh_dir(ArchiveBrowserView* browser);
void archive_file_browser_set_callbacks(ArchiveBrowserView* browser);

5
applications/archive/helpers/archive_favorites.c
View File

@@ -168,7 +168,8 @@ bool archive_favorites_read(void* context) {
if(file_exists) {
storage_common_stat(fs_api, string_get_cstr(buffer), &file_info);
storage_file_close(fav_item_file);
archive_add_file_item(browser, &file_info, string_get_cstr(buffer));
archive_add_file_item(
browser, (file_info.flags & FSF_DIRECTORY), string_get_cstr(buffer));
file_count++;
} else {
storage_file_close(fav_item_file);
@@ -337,7 +338,7 @@ void archive_favorites_save(void* context) {
for(size_t i = 0; i < archive_file_get_array_size(browser); i++) {
ArchiveFile_t* item = archive_get_file_at(browser, i);
archive_file_append(ARCHIVE_FAV_TEMP_PATH, "%s\n", string_get_cstr(item->name));
archive_file_append(ARCHIVE_FAV_TEMP_PATH, "%s\n", string_get_cstr(item->path));
}
storage_common_remove(fs_api, ARCHIVE_FAV_PATH);

153
applications/archive/helpers/archive_files.c
View File

@@ -6,59 +6,18 @@
#define ASSETS_DIR "assets"
bool archive_filter_by_extension(FileInfo* file_info, const char* tab_ext, const char* name) {
furi_assert(file_info);
furi_assert(tab_ext);
furi_assert(name);
bool result = false;
if(strcmp(tab_ext, "*") == 0) {
result = true;
} else if(strstr(name, tab_ext) != NULL) {
result = true;
} else if(file_info->flags & FSF_DIRECTORY) {
if(strstr(name, ASSETS_DIR) != NULL) {
result = false; // Skip assets folder in all tabs except browser
} else {
result = true;
}
}
return result;
}
void archive_trim_file_path(char* name, bool ext) {
char* slash = strrchr(name, '/') + 1;
if(strlen(slash)) strlcpy(name, slash, strlen(slash) + 1);
if(ext) {
char* dot = strrchr(name, '.');
if(strlen(dot)) *dot = '\0';
}
}
void archive_get_file_extension(char* name, char* ext) {
char* dot = strrchr(name, '.');
if(dot == NULL)
*ext = '\0';
else
strncpy(ext, dot, MAX_EXT_LEN);
}
void archive_set_file_type(ArchiveFile_t* file, FileInfo* file_info, const char* path, bool is_app) {
void archive_set_file_type(ArchiveFile_t* file, const char* path, bool is_folder, bool is_app) {
furi_assert(file);
file->is_app = is_app;
if(is_app) {
file->type = archive_get_app_filetype(archive_get_app_type(path));
} else {
furi_assert(file_info);
for(size_t i = 0; i < COUNT_OF(known_ext); i++) {
if((known_ext[i][0] == '?') || (known_ext[i][0] == '*')) continue;
if(string_search_str(file->name, known_ext[i], 0) != STRING_FAILURE) {
if(string_search_str(file->path, known_ext[i], 0) != STRING_FAILURE) {
if(i == ArchiveFileTypeBadUsb) {
if(string_search_str(file->name, archive_get_default_path(ArchiveTabBadUsb)) ==
if(string_search_str(file->path, archive_get_default_path(ArchiveTabBadUsb)) ==
0) {
file->type = i;
return; // *.txt file is a BadUSB script only if it is in BadUSB folder
@@ -70,7 +29,7 @@ void archive_set_file_type(ArchiveFile_t* file, FileInfo* file_info, const char*
}
}
if(file_info->flags & FSF_DIRECTORY) {
if(is_folder) {
file->type = ArchiveFileTypeFolder;
} else {
file->type = ArchiveFileTypeUnknown;
@@ -78,120 +37,20 @@ void archive_set_file_type(ArchiveFile_t* file, FileInfo* file_info, const char*
}
}
bool archive_get_filenames(void* context, const char* path) {
bool archive_get_items(void* context, const char* path) {
furi_assert(context);
bool res;
bool res = false;
ArchiveBrowserView* browser = context;
if(archive_get_tab(browser) == ArchiveTabFavorites) {
res = archive_favorites_read(browser);
} else if(strncmp(path, "/app:", 5) == 0) {
res = archive_app_read_dir(browser, path);
} else {
res = archive_file_array_load(browser, 0);
}
return res;
}
uint32_t archive_dir_count_items(void* context, const char* path) {
furi_assert(context);
ArchiveBrowserView* browser = context;
FileInfo file_info;
Storage* fs_api = furi_record_open("storage");
File* directory = storage_file_alloc(fs_api);
char name[MAX_NAME_LEN];
if(!storage_dir_open(directory, path)) {
storage_dir_close(directory);
storage_file_free(directory);
return 0;
}
uint32_t files_found = 0;
while(1) {
if(!storage_dir_read(directory, &file_info, name, MAX_NAME_LEN)) {
break;
}
if((storage_file_get_error(directory) == FSE_OK) && (name[0])) {
if(archive_filter_by_extension(
&file_info, archive_get_tab_ext(archive_get_tab(browser)), name)) {
files_found++;
}
}
}
storage_dir_close(directory);
storage_file_free(directory);
furi_record_close("storage");
archive_set_item_count(browser, files_found);
return files_found;
}
uint32_t archive_dir_read_items(void* context, const char* path, uint32_t offset, uint32_t count) {
furi_assert(context);
ArchiveBrowserView* browser = context;
FileInfo file_info;
Storage* fs_api = furi_record_open("storage");
File* directory = storage_file_alloc(fs_api);
char name[MAX_NAME_LEN];
snprintf(name, MAX_NAME_LEN, "%s/", path);
size_t path_len = strlen(name);
if(!storage_dir_open(directory, path)) {
storage_dir_close(directory);
storage_file_free(directory);
return false;
}
// Skip items before offset
uint32_t items_cnt = 0;
while(items_cnt < offset) {
if(!storage_dir_read(directory, &file_info, &name[path_len], MAX_NAME_LEN)) {
break;
}
if(storage_file_get_error(directory) == FSE_OK) {
if(archive_filter_by_extension(
&file_info, archive_get_tab_ext(archive_get_tab(browser)), name)) {
items_cnt++;
}
} else {
break;
}
}
if(items_cnt != offset) {
storage_dir_close(directory);
storage_file_free(directory);
furi_record_close("storage");
return false;
}
items_cnt = 0;
archive_file_array_rm_all(browser);
while(items_cnt < count) {
if(!storage_dir_read(directory, &file_info, &name[path_len], MAX_NAME_LEN - path_len)) {
break;
}
if(storage_file_get_error(directory) == FSE_OK) {
archive_add_file_item(browser, &file_info, name);
items_cnt++;
} else {
break;
}
}
storage_dir_close(directory);
storage_file_free(directory);
furi_record_close("storage");
return (items_cnt == count);
}
void archive_file_append(const char* path, const char* format, ...) {
furi_assert(path);

19
applications/archive/helpers/archive_files.h
View File

@@ -19,7 +19,7 @@ typedef enum {
} ArchiveFileTypeEnum;
typedef struct {
string_t name;
string_t path;
ArchiveFileTypeEnum type;
bool fav;
bool is_app;
@@ -29,25 +29,25 @@ static void ArchiveFile_t_init(ArchiveFile_t* obj) {
obj->type = ArchiveFileTypeUnknown;
obj->is_app = false;
obj->fav = false;
string_init(obj->name);
string_init(obj->path);
}
static void ArchiveFile_t_init_set(ArchiveFile_t* obj, const ArchiveFile_t* src) {
obj->type = src->type;
obj->is_app = src->is_app;
obj->fav = src->fav;
string_init_set(obj->name, src->name);
string_init_set(obj->path, src->path);
}
static void ArchiveFile_t_set(ArchiveFile_t* obj, const ArchiveFile_t* src) {
obj->type = src->type;
obj->is_app = src->is_app;
obj->fav = src->fav;
string_set(obj->name, src->name);
string_set(obj->path, src->path);
}
static void ArchiveFile_t_clear(ArchiveFile_t* obj) {
string_clear(obj->name);
string_clear(obj->path);
}
ARRAY_DEF(
@@ -58,12 +58,7 @@ ARRAY_DEF(
INIT_SET(API_6(ArchiveFile_t_init_set)),
CLEAR(API_2(ArchiveFile_t_clear))))
bool archive_filter_by_extension(FileInfo* file_info, const char* tab_ext, const char* name);
void archive_set_file_type(ArchiveFile_t* file, FileInfo* file_info, const char* path, bool is_app);
void archive_trim_file_path(char* name, bool ext);
void archive_get_file_extension(char* name, char* ext);
bool archive_get_filenames(void* context, const char* path);
uint32_t archive_dir_count_items(void* context, const char* path);
uint32_t archive_dir_read_items(void* context, const char* path, uint32_t offset, uint32_t count);
void archive_set_file_type(ArchiveFile_t* file, const char* path, bool is_folder, bool is_app);
bool archive_get_items(void* context, const char* path);
void archive_file_append(const char* path, const char* format, ...);
void archive_delete_file(void* context, const char* format, ...);