Merge branch 'ofw-dev' into dev

applications/services/gui/modules/file_browser.c

@@ -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(

applications/services/loader/loader_applications.c

@@ -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);

applications/services/storage/filesystem_api_internal.h

@@ -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

applications/services/storage/storage_processing.c

@@ -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) {

applications/services/storage/storage_sorting.h

@@ -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;