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

Merge branch 'ofw-dev' into dev

Browse Source
This commit is contained in:
MX
2023-07-12 21:19:16 +03:00
parent 4a2cae23ca 92c0baa461
commit c4b04a06bb
68 changed files with 431 additions and 375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
applications/drivers/subghz/cc1101_ext/cc1101_ext.c
View File

@@ -87,6 +87,7 @@ static bool subghz_device_cc1101_ext_check_init() {
subghz_device_cc1101_ext->state = SubGhzDeviceCC1101ExtStateIdle;
bool ret = false;
CC1101Status cc1101_status = {0};
furi_hal_spi_acquire(subghz_device_cc1101_ext->spi_bus_handle);
FuriHalCortexTimer timer = furi_hal_cortex_timer_get(100 * 1000);
@@ -94,16 +95,34 @@ static bool subghz_device_cc1101_ext_check_init() {
// Reset
furi_hal_gpio_init(
subghz_device_cc1101_ext->g0_pin, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
cc1101_reset(subghz_device_cc1101_ext->spi_bus_handle);
cc1101_write_reg(
subghz_device_cc1101_ext->spi_bus_handle, CC1101_IOCFG0, CC1101IocfgHighImpedance);
furi_hal_gpio_init(
subghz_device_cc1101_ext->spi_bus_handle->miso,
GpioModeInput,
GpioPullUp,
GpioSpeedLow);
cc1101_status = cc1101_reset(subghz_device_cc1101_ext->spi_bus_handle);
if(cc1101_status.CHIP_RDYn != 0) {
//timeout or error
break;
}
cc1101_status = cc1101_write_reg(
subghz_device_cc1101_ext->spi_bus_handle, CC1101_IOCFG0, CC1101IocfgHighImpedance);
if(cc1101_status.CHIP_RDYn != 0) {
//timeout or error
break;
}
// Prepare GD0 for power on self test
furi_hal_gpio_init(
subghz_device_cc1101_ext->g0_pin, GpioModeInput, GpioPullNo, GpioSpeedLow);
subghz_device_cc1101_ext->g0_pin, GpioModeInput, GpioPullUp, GpioSpeedLow);
// GD0 low
cc1101_write_reg(subghz_device_cc1101_ext->spi_bus_handle, CC1101_IOCFG0, CC1101IocfgHW);
cc1101_status = cc1101_write_reg(
subghz_device_cc1101_ext->spi_bus_handle, CC1101_IOCFG0, CC1101IocfgHW);
if(cc1101_status.CHIP_RDYn != 0) {
//timeout or error
break;
}
while(furi_hal_gpio_read(subghz_device_cc1101_ext->g0_pin) != false) {
if(furi_hal_cortex_timer_is_expired(timer)) {
//timeout
@@ -116,10 +135,16 @@ static bool subghz_device_cc1101_ext_check_init() {
}
// GD0 high
cc1101_write_reg(
furi_hal_gpio_init(
subghz_device_cc1101_ext->g0_pin, GpioModeInput, GpioPullDown, GpioSpeedLow);
cc1101_status = cc1101_write_reg(
subghz_device_cc1101_ext->spi_bus_handle,
CC1101_IOCFG0,
CC1101IocfgHW | CC1101_IOCFG_INV);
if(cc1101_status.CHIP_RDYn != 0) {
//timeout or error
break;
}
while(furi_hal_gpio_read(subghz_device_cc1101_ext->g0_pin) != true) {
if(furi_hal_cortex_timer_is_expired(timer)) {
//timeout
@@ -132,17 +157,21 @@ static bool subghz_device_cc1101_ext_check_init() {
}
// Reset GD0 to floating state
cc1101_write_reg(
cc1101_status = cc1101_write_reg(
subghz_device_cc1101_ext->spi_bus_handle, CC1101_IOCFG0, CC1101IocfgHighImpedance);
if(cc1101_status.CHIP_RDYn != 0) {
//timeout or error
break;
}
furi_hal_gpio_init(
subghz_device_cc1101_ext->g0_pin, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
// RF switches
furi_hal_gpio_init(&gpio_rf_sw_0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
cc1101_write_reg(subghz_device_cc1101_ext->spi_bus_handle, CC1101_IOCFG2, CC1101IocfgHW);
// Go to sleep
cc1101_shutdown(subghz_device_cc1101_ext->spi_bus_handle);
cc1101_status = cc1101_shutdown(subghz_device_cc1101_ext->spi_bus_handle);
if(cc1101_status.CHIP_RDYn != 0) {
//timeout or error
break;
}
ret = true;
} while(false);
@@ -152,6 +181,8 @@ static bool subghz_device_cc1101_ext_check_init() {
FURI_LOG_I(TAG, "Init OK");
} else {
FURI_LOG_E(TAG, "Init failed");
furi_hal_gpio_init(
subghz_device_cc1101_ext->g0_pin, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
}
return ret;
}

29
applications/main/archive/helpers/archive_browser.c
View File

@@ -70,16 +70,23 @@ static void archive_list_item_cb(
if(!is_last) {
archive_add_file_item(browser, is_folder, furi_string_get_cstr(item_path));
} else {
bool load_again = false;
with_view_model(
browser->view,
ArchiveBrowserViewModel * model,
{
model->list_loading = false;
if(model->item_cnt <= BROWSER_SORT_THRESHOLD) {
files_array_sort(model->files);
}
model->list_loading = false;
if(archive_is_file_list_load_required(model)) {
load_again = true;
}
},
true);
if(load_again) {
archive_file_array_load(browser, 0);
}
}
}
@@ -125,6 +132,26 @@ bool archive_is_item_in_array(ArchiveBrowserViewModel* model, uint32_t idx) {
return true;
}
bool archive_is_file_list_load_required(ArchiveBrowserViewModel* model) {
size_t array_size = files_array_size(model->files);
if((model->list_loading) || (array_size >= model->item_cnt)) {
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;
}
return false;
}
void archive_update_offset(ArchiveBrowserView* browser) {
furi_assert(browser);

1
applications/main/archive/helpers/archive_browser.h
View File

@@ -66,6 +66,7 @@ inline bool archive_is_known_app(ArchiveFileTypeEnum type) {
}
bool archive_is_item_in_array(ArchiveBrowserViewModel* model, uint32_t idx);
bool archive_is_file_list_load_required(ArchiveBrowserViewModel* model);
void archive_update_offset(ArchiveBrowserView* browser);
void archive_update_focus(ArchiveBrowserView* browser, const char* target);

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

@@ -370,24 +370,10 @@ View* archive_browser_get_view(ArchiveBrowserView* browser) {
return browser->view;
}
static bool is_file_list_load_required(ArchiveBrowserViewModel* model) {
size_t array_size = files_array_size(model->files);
if((model->list_loading) || (array_size >= model->item_cnt)) {
return false;
static void file_list_rollover(ArchiveBrowserViewModel* model) {
if(!model->list_loading && files_array_size(model->files) < model->item_cnt) {
files_array_reset(model->files);
}
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;
}
return false;
}
static bool archive_view_input(InputEvent* event, void* context) {
@@ -477,12 +463,13 @@ static bool archive_view_input(InputEvent* event, void* context) {
if(model->item_idx < scroll_speed) {
model->button_held_for_ticks = 0;
model->item_idx = model->item_cnt - 1;
file_list_rollover(model);
} else {
model->item_idx =
((model->item_idx - scroll_speed) + model->item_cnt) %
model->item_cnt;
}
if(is_file_list_load_required(model)) {
if(archive_is_file_list_load_required(model)) {
model->list_loading = true;
browser->callback(ArchiveBrowserEventLoadPrevItems, browser->context);
}
@@ -496,10 +483,11 @@ static bool archive_view_input(InputEvent* event, void* context) {
if(model->item_idx + scroll_speed >= count) {
model->button_held_for_ticks = 0;
model->item_idx = 0;
file_list_rollover(model);
} else {
model->item_idx = (model->item_idx + scroll_speed) % model->item_cnt;
}
if(is_file_list_load_required(model)) {
if(archive_is_file_list_load_required(model)) {
model->list_loading = true;
browser->callback(ArchiveBrowserEventLoadNextItems, browser->context);
}

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

@@ -28,12 +28,20 @@
// Rx RAW | only internal module
// Chat | both
#define TAG "SubGhz CLI"
static void subghz_cli_radio_device_power_on() {
uint8_t attempts = 0;
while(!furi_hal_power_is_otg_enabled() && attempts++ < 5) {
furi_hal_power_enable_otg();
//CC1101 power-up time
furi_delay_ms(10);
uint8_t attempts = 5;
while(--attempts > 0) {
if(furi_hal_power_enable_otg()) break;
}
if(attempts == 0) {
if(furi_hal_power_get_usb_voltage() < 4.5f) {
FURI_LOG_E(
"TAG",
"Error power otg enable. BQ2589 check otg fault = %d",
furi_hal_power_check_otg_fault() ? 1 : 0);
}
}
}
@@ -126,9 +134,9 @@ void subghz_cli_command_rx_carrier(Cli* cli, FuriString* args, void* context) {
furi_hal_subghz_sleep();
}
static const SubGhzDevice* subghz_cli_command_get_device(uint32_t device_ind) {
static const SubGhzDevice* subghz_cli_command_get_device(uint32_t* device_ind) {
const SubGhzDevice* device = NULL;
switch(device_ind) {
switch(*device_ind) {
case 1:
subghz_cli_radio_device_power_on();
device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_EXT_NAME);
@@ -138,6 +146,12 @@ static const SubGhzDevice* subghz_cli_command_get_device(uint32_t device_ind) {
device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME);
break;
}
//check if the device is connected
if(!subghz_devices_is_connect(device)) {
subghz_cli_radio_device_power_off();
device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME);
*device_ind = 0;
}
return device;
}
@@ -175,7 +189,7 @@ void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {
}
}
subghz_devices_init();
const SubGhzDevice* device = subghz_cli_command_get_device(device_ind);
const SubGhzDevice* device = subghz_cli_command_get_device(&device_ind);
if(!subghz_devices_is_frequency_valid(device, frequency)) {
printf(
"Frequency must be in " SUBGHZ_FREQUENCY_RANGE_STR " range, not %lu\r\n", frequency);
@@ -294,7 +308,7 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
}
}
subghz_devices_init();
const SubGhzDevice* device = subghz_cli_command_get_device(device_ind);
const SubGhzDevice* device = subghz_cli_command_get_device(&device_ind);
if(!subghz_devices_is_frequency_valid(device, frequency)) {
printf(
"Frequency must be in " SUBGHZ_FREQUENCY_RANGE_STR " range, not %lu\r\n", frequency);
@@ -681,7 +695,7 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
}
}
subghz_devices_init();
const SubGhzDevice* device = subghz_cli_command_get_device(device_ind);
const SubGhzDevice* device = subghz_cli_command_get_device(&device_ind);
if(!subghz_devices_is_frequency_valid(device, frequency)) {
printf(
"Frequency must be in " SUBGHZ_FREQUENCY_RANGE_STR " range, not %lu\r\n", frequency);

26
applications/services/gui/modules/file_browser.c
View File

@@ -335,6 +335,12 @@ static bool browser_is_list_load_required(FileBrowserModel* model) {
return false;
}
static void browser_list_rollover(FileBrowserModel* model) {
if(!model->list_loading && items_array_size(model->items) < model->item_cnt) {
items_array_reset(model->items);
}
}
static void browser_update_offset(FileBrowser* browser) {
furi_assert(browser);
@@ -417,7 +423,7 @@ static void browser_list_load_cb(void* context, uint32_t list_load_offset) {
}
}
},
true);
false);
BrowserItem_t_clear(&back_item);
}
@@ -462,14 +468,15 @@ static void browser_list_item_cb(
(browser->hide_ext) && (item.type == BrowserItemTypeFile));
}
// We shouldn't update screen on each item if custom callback is not set
// Otherwise it will cause screen flickering
bool instant_update = (browser->item_callback != NULL);
with_view_model(
browser->view,
FileBrowserModel * model,
{
items_array_push_back(model->items, item);
// TODO: calculate if element is visible
},
false);
{ items_array_push_back(model->items, item); },
instant_update);
furi_string_free(item.display_name);
furi_string_free(item.path);
if(item.custom_icon_data) {
@@ -674,11 +681,13 @@ static bool file_browser_view_input_callback(InputEvent* event, void* context) {
if(model->item_idx < scroll_speed) {
model->button_held_for_ticks = 0;
model->item_idx = model->item_cnt - 1;
browser_list_rollover(model);
} else {
model->item_idx =
((model->item_idx - scroll_speed) + model->item_cnt) %
model->item_cnt;
}
if(browser_is_list_load_required(model)) {
model->list_loading = true;
int32_t load_offset = CLAMP(
@@ -692,13 +701,14 @@ static bool file_browser_view_input_callback(InputEvent* event, void* context) {
model->button_held_for_ticks += 1;
} else if(event->key == InputKeyDown) {
int32_t count = model->item_cnt;
if(model->item_idx + scroll_speed >= count) {
if(model->item_idx + scroll_speed >= (int32_t)model->item_cnt) {
model->button_held_for_ticks = 0;
model->item_idx = 0;
browser_list_rollover(model);
} else {
model->item_idx = (model->item_idx + scroll_speed) % model->item_cnt;
}
if(browser_is_list_load_required(model)) {
model->list_loading = true;
int32_t load_offset = CLAMP(

67
applications/services/loader/loader_applications.c
View File

@@ -38,6 +38,11 @@ typedef struct {
FuriString* fap_path;
DialogsApp* dialogs;
Storage* storage;
Loader* loader;
Gui* gui;
ViewHolder* view_holder;
Loading* loading;
} LoaderApplicationsApp;
static LoaderApplicationsApp* loader_applications_app_alloc() {
@@ -45,15 +50,30 @@ static LoaderApplicationsApp* loader_applications_app_alloc() {
app->fap_path = furi_string_alloc_set(EXT_PATH("apps"));
app->dialogs = furi_record_open(RECORD_DIALOGS);
app->storage = furi_record_open(RECORD_STORAGE);
app->loader = furi_record_open(RECORD_LOADER);
app->gui = furi_record_open(RECORD_GUI);
app->view_holder = view_holder_alloc();
app->loading = loading_alloc();
view_holder_attach_to_gui(app->view_holder, app->gui);
view_holder_set_view(app->view_holder, loading_get_view(app->loading));
return app;
} //-V773
static void loader_applications_app_free(LoaderApplicationsApp* loader_applications_app) {
furi_assert(loader_applications_app);
static void loader_applications_app_free(LoaderApplicationsApp* app) {
furi_assert(app);
view_holder_free(app->view_holder);
loading_free(app->loading);
furi_record_close(RECORD_GUI);
furi_record_close(RECORD_LOADER);
furi_record_close(RECORD_DIALOGS);
furi_record_close(RECORD_STORAGE);
furi_string_free(loader_applications_app->fap_path);
free(loader_applications_app);
furi_string_free(app->fap_path);
free(app);
}
static bool loader_applications_item_callback(
@@ -96,47 +116,38 @@ static void loader_pubsub_callback(const void* message, void* context) {
}
}
static void loader_applications_start_app(const char* name) {
// start loading animation
Gui* gui = furi_record_open(RECORD_GUI);
ViewHolder* view_holder = view_holder_alloc();
Loading* loading = loading_alloc();
view_holder_attach_to_gui(view_holder, gui);
view_holder_set_view(view_holder, loading_get_view(loading));
view_holder_start(view_holder);
static void loader_applications_start_app(LoaderApplicationsApp* app) {
const char* name = furi_string_get_cstr(app->fap_path);
// load app
FuriThreadId thread_id = furi_thread_get_current_id();
Loader* loader = furi_record_open(RECORD_LOADER);
FuriPubSubSubscription* subscription =
furi_pubsub_subscribe(loader_get_pubsub(loader), loader_pubsub_callback, thread_id);
furi_pubsub_subscribe(loader_get_pubsub(app->loader), loader_pubsub_callback, thread_id);
LoaderStatus status = loader_start_with_gui_error(loader, name, NULL);
LoaderStatus status = loader_start_with_gui_error(app->loader, name, NULL);
if(status == LoaderStatusOk) {
furi_thread_flags_wait(APPLICATION_STOP_EVENT, FuriFlagWaitAny, FuriWaitForever);
}
furi_pubsub_unsubscribe(loader_get_pubsub(loader), subscription);
furi_record_close(RECORD_LOADER);
// stop loading animation
view_holder_stop(view_holder);
view_holder_free(view_holder);
loading_free(loading);
furi_record_close(RECORD_GUI);
furi_pubsub_unsubscribe(loader_get_pubsub(app->loader), subscription);
}
static int32_t loader_applications_thread(void* p) {
LoaderApplications* loader_applications = p;
LoaderApplicationsApp* loader_applications_app = loader_applications_app_alloc();
LoaderApplicationsApp* app = loader_applications_app_alloc();
while(loader_applications_select_app(loader_applications_app)) {
loader_applications_start_app(furi_string_get_cstr(loader_applications_app->fap_path));
// start loading animation
view_holder_start(app->view_holder);
while(loader_applications_select_app(app)) {
loader_applications_start_app(app);
}
loader_applications_app_free(loader_applications_app);
// stop loading animation
view_holder_stop(app->view_holder);
loader_applications_app_free(app);
if(loader_applications->closed_cb) {
loader_applications->closed_cb(loader_applications->context);

3
applications/services/storage/filesystem_api_internal.h
View File

@@ -19,8 +19,7 @@ struct File {
FileType type;
FS_Error error_id; /**< Standard API error from FS_Error enum */
int32_t internal_error_id; /**< Internal API error value */
void* storage; /**< Storage API pointer */
void* sort_data; /**< Sorted file list for directory */
void* storage;
};
/** File api structure

180
applications/services/storage/storage_processing.c
View File

@@ -1,5 +1,4 @@
#include "storage_processing.h"
#include "storage_sorting.h"
#include <m-list.h>
#include <m-dict.h>
@@ -101,7 +100,7 @@ static FS_Error storage_get_data(Storage* app, FuriString* path, StorageData** s
/******************* File Functions *******************/
static bool storage_process_file_open(
bool storage_process_file_open(
Storage* app,
File* file,
FuriString* path,
@@ -128,7 +127,7 @@ static bool storage_process_file_open(
return ret;
}
static bool storage_process_file_close(Storage* app, File* file) {
bool storage_process_file_close(Storage* app, File* file) {
bool ret = false;
StorageData* storage = get_storage_by_file(file, app->storage);
@@ -261,149 +260,9 @@ static bool storage_process_file_eof(Storage* app, File* file) {
return ret;
}
/*************** Sorting Dir Functions ***************/
static bool storage_process_dir_rewind_internal(StorageData* storage, File* file);
static bool storage_process_dir_read_internal(
StorageData* storage,
File* file,
FileInfo* fileinfo,
char* name,
const uint16_t name_length);
static int storage_sorted_file_record_compare(const void* sorted_a, const void* sorted_b) {
SortedFileRecord* a = (SortedFileRecord*)sorted_a;
SortedFileRecord* b = (SortedFileRecord*)sorted_b;
if(a->info.flags & FSF_DIRECTORY && !(b->info.flags & FSF_DIRECTORY))
return -1;
else if(!(a->info.flags & FSF_DIRECTORY) && b->info.flags & FSF_DIRECTORY)
return 1;
else
return furi_string_cmpi(a->name, b->name);
}
static bool storage_sorted_dir_read_next(
SortedDir* dir,
FileInfo* fileinfo,
char* name,
const uint16_t name_length) {
bool ret = false;
if(dir->index < dir->count) {
SortedFileRecord* sorted = &dir->sorted[dir->index];
if(fileinfo) {
*fileinfo = sorted->info;
}
if(name) {
strncpy(name, furi_string_get_cstr(sorted->name), name_length);
}
dir->index++;
ret = true;
}
return ret;
}
static void storage_sorted_dir_rewind(SortedDir* dir) {
dir->index = 0;
}
static bool storage_sorted_dir_prepare(SortedDir* dir, StorageData* storage, File* file) {
bool ret = true;
dir->count = 0;
dir->index = 0;
FileInfo info;
char name[SORTING_MAX_NAME_LENGTH + 1] = {0};
furi_check(!dir->sorted);
while(storage_process_dir_read_internal(storage, file, &info, name, SORTING_MAX_NAME_LENGTH)) {
if(memmgr_get_free_heap() < SORTING_MIN_FREE_MEMORY) {
ret = false;
break;
}
if(dir->count == 0) { //-V547
dir->sorted = malloc(sizeof(SortedFileRecord));
} else {
// Our realloc actually mallocs a new block and copies the data over,
// so we need to check if we have enough memory for the new block
size_t size = sizeof(SortedFileRecord) * (dir->count + 1);
if(memmgr_heap_get_max_free_block() >= size) {
dir->sorted =
realloc(dir->sorted, sizeof(SortedFileRecord) * (dir->count + 1)); //-V701
} else {
ret = false;
break;
}
}
dir->sorted[dir->count].name = furi_string_alloc_set(name);
dir->sorted[dir->count].info = info;
dir->count++;
}
return ret;
}
static void storage_sorted_dir_sort(SortedDir* dir) {
qsort(dir->sorted, dir->count, sizeof(SortedFileRecord), storage_sorted_file_record_compare);
}
static void storage_sorted_dir_clear_data(SortedDir* dir) {
if(dir->sorted != NULL) {
for(size_t i = 0; i < dir->count; i++) {
furi_string_free(dir->sorted[i].name);
}
free(dir->sorted);
dir->sorted = NULL;
}
}
static void storage_file_remove_sort_data(File* file) {
if(file->sort_data != NULL) {
storage_sorted_dir_clear_data(file->sort_data);
free(file->sort_data);
file->sort_data = NULL;
}
}
static void storage_file_add_sort_data(File* file, StorageData* storage) {
file->sort_data = malloc(sizeof(SortedDir));
if(storage_sorted_dir_prepare(file->sort_data, storage, file)) {
storage_sorted_dir_sort(file->sort_data);
} else {
storage_file_remove_sort_data(file);
storage_process_dir_rewind_internal(storage, file);
}
}
static bool storage_file_has_sort_data(File* file) {
return file->sort_data != NULL;
}
/******************* Dir Functions *******************/
static bool storage_process_dir_read_internal(
StorageData* storage,
File* file,
FileInfo* fileinfo,
char* name,
const uint16_t name_length) {
bool ret = false;
FS_CALL(storage, dir.read(storage, file, fileinfo, name, name_length));
return ret;
}
static bool storage_process_dir_rewind_internal(StorageData* storage, File* file) {
bool ret = false;
FS_CALL(storage, dir.rewind(storage, file));
return ret;
}
static bool storage_process_dir_open(Storage* app, File* file, FuriString* path) {
bool storage_process_dir_open(Storage* app, File* file, FuriString* path) {
bool ret = false;
StorageData* storage;
file->error_id = storage_get_data(app, path, &storage);
@@ -414,17 +273,13 @@ static bool storage_process_dir_open(Storage* app, File* file, FuriString* path)
} else {
storage_push_storage_file(file, path, storage);
FS_CALL(storage, dir.open(storage, file, cstr_path_without_vfs_prefix(path)));
if(file->error_id == FSE_OK) {
storage_file_add_sort_data(file, storage);
}
}
}
return ret;
}
static bool storage_process_dir_close(Storage* app, File* file) {
bool storage_process_dir_close(Storage* app, File* file) {
bool ret = false;
StorageData* storage = get_storage_by_file(file, app->storage);
@@ -432,7 +287,6 @@ static bool storage_process_dir_close(Storage* app, File* file) {
file->error_id = FSE_INVALID_PARAMETER;
} else {
FS_CALL(storage, dir.close(storage, file));
storage_file_remove_sort_data(file);
storage_pop_storage_file(file, storage);
StorageEvent event = {.type = StorageEventTypeDirClose};
@@ -442,7 +296,7 @@ static bool storage_process_dir_close(Storage* app, File* file) {
return ret;
}
static bool storage_process_dir_read(
bool storage_process_dir_read(
Storage* app,
File* file,
FileInfo* fileinfo,
@@ -454,34 +308,20 @@ static bool storage_process_dir_read(
if(storage == NULL) {
file->error_id = FSE_INVALID_PARAMETER;
} else {
if(storage_file_has_sort_data(file)) {
ret = storage_sorted_dir_read_next(file->sort_data, fileinfo, name, name_length);
if(ret) {
file->error_id = FSE_OK;
} else {
file->error_id = FSE_NOT_EXIST;
}
} else {
ret = storage_process_dir_read_internal(storage, file, fileinfo, name, name_length);
}
FS_CALL(storage, dir.read(storage, file, fileinfo, name, name_length));
}
return ret;
}
static bool storage_process_dir_rewind(Storage* app, File* file) {
bool storage_process_dir_rewind(Storage* app, File* file) {
bool ret = false;
StorageData* storage = get_storage_by_file(file, app->storage);
if(storage == NULL) {
file->error_id = FSE_INVALID_PARAMETER;
} else {
if(storage_file_has_sort_data(file)) {
storage_sorted_dir_rewind(file->sort_data);
ret = true;
} else {
ret = storage_process_dir_rewind_internal(storage, file);
}
FS_CALL(storage, dir.rewind(storage, file));
}
return ret;
@@ -621,7 +461,7 @@ static FS_Error storage_process_sd_status(Storage* app) {
/******************** Aliases processing *******************/
static void storage_process_alias(
void storage_process_alias(
Storage* app,
FuriString* path,
FuriThreadId thread_id,
@@ -665,7 +505,7 @@ static void storage_process_alias(
/****************** API calls processing ******************/
static void storage_process_message_internal(Storage* app, StorageMessage* message) {
void storage_process_message_internal(Storage* app, StorageMessage* message) {
FuriString* path = NULL;
switch(message->command) {

22
applications/services/storage/storage_sorting.h
View File

@@ -1,22 +0,0 @@
#pragma once
#include <furi.h>
#define SORTING_MAX_NAME_LENGTH 255
#define SORTING_MIN_FREE_MEMORY (1024 * 40)
/**
* @brief Sorted file record, holds file name and info
*/
typedef struct {
FuriString* name;
FileInfo info;
} SortedFileRecord;
/**
* @brief Sorted directory, holds sorted file records, count and current index
*/
typedef struct {
SortedFileRecord* sorted;
size_t count;
size_t index;
} SortedDir;