[FL-2499] Folders rename fix (#1190)

* Toolbox: dir_walk concept (like os.walk)
* Storage CLI: tree command
* Storage: fix folders copying, stage 1
* UnitTest: proper delays in subghz tests
* Toolbox: dir_walk, recursive and filter options
* dir_walk: unit tests
* Merge: Fix unused param
* SubGhz: cleaned up data parsing routine
* SubGhz unit test: cleaned up logs, yield data load
* SubGhz unit test: naming

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

lib/subghz/subghz_file_encoder_worker.c

@@ -54,27 +54,24 @@ void subghz_file_encoder_worker_add_level_duration(
     }
 }
 
-bool subghz_file_encoder_worker_data_parse(
-    SubGhzFileEncoderWorker* instance,
-    const char* strStart,
-    size_t len) {
+bool subghz_file_encoder_worker_data_parse(SubGhzFileEncoderWorker* instance, const char* strStart) {
     char* str1;
-    size_t ind_start = (size_t)strStart; //store the start address of the beginning of the line
     bool res = false;
+    // Line sample: "RAW_Data: -1, 2, -2..."
+
+    // Look for a key in the line
+    str1 = strstr(strStart, "RAW_Data: ");
 
-    str1 = strstr(
-        strStart, "RAW_Data: "); //looking for the beginning of the desired title in the line
     if(str1 != NULL) {
-        str1 = strchr(
-            str1,
-            ' '); //if found, shift the pointer by 1 element per line "RAW_Data: -1, 2, -2..."
-        while(
-            strchr(str1, ' ') != NULL &&
-            ((size_t)str1 <
-             (len +
-              ind_start))) { //check that there is still an element in the line and that it has not gone beyond the line
+        // Skip key
+        str1 = strchr(str1, ' ');
+
+        // Check that there is still an element in the line
+        while(strchr(str1, ' ') != NULL) {
             str1 = strchr(str1, ' ');
-            str1 += 1; //if found, shift the pointer by next element per line
+
+            // Skip space
+            str1 += 1;
             subghz_file_encoder_worker_add_level_duration(instance, atoi(str1));
         }
         res = true;
@@ -143,9 +140,7 @@ static int32_t subghz_file_encoder_worker_thread(void* context) {
             if(stream_read_line(stream, instance->str_data)) {
                 string_strim(instance->str_data);
                 if(!subghz_file_encoder_worker_data_parse(
-                       instance,
-                       string_get_cstr(instance->str_data),
-                       strlen(string_get_cstr(instance->str_data)))) {
+                       instance, string_get_cstr(instance->str_data))) {
                     //to stop DMA correctly
                     subghz_file_encoder_worker_add_level_duration(instance, LEVEL_DURATION_RESET);
                     subghz_file_encoder_worker_add_level_duration(instance, LEVEL_DURATION_RESET);

lib/toolbox/dir_walk.c

@@ -0,0 +1,152 @@
+#include "dir_walk.h"
+#include <m-list.h>
+
+LIST_DEF(DirIndexList, uint32_t);
+
+struct DirWalk {
+    File* file;
+    string_t path;
+    DirIndexList_t index_list;
+    uint32_t current_index;
+    bool recursive;
+    DirWalkFilterCb filter_cb;
+    void* filter_context;
+};
+
+DirWalk* dir_walk_alloc(Storage* storage) {
+    DirWalk* dir_walk = malloc(sizeof(DirWalk));
+    string_init(dir_walk->path);
+    dir_walk->file = storage_file_alloc(storage);
+    DirIndexList_init(dir_walk->index_list);
+    dir_walk->recursive = true;
+    dir_walk->filter_cb = NULL;
+    return dir_walk;
+}
+
+void dir_walk_free(DirWalk* dir_walk) {
+    storage_file_free(dir_walk->file);
+    string_clear(dir_walk->path);
+    DirIndexList_clear(dir_walk->index_list);
+    free(dir_walk);
+}
+
+void dir_walk_set_recursive(DirWalk* dir_walk, bool recursive) {
+    dir_walk->recursive = recursive;
+}
+
+void dir_walk_set_filter_cb(DirWalk* dir_walk, DirWalkFilterCb cb, void* context) {
+    dir_walk->filter_cb = cb;
+    dir_walk->filter_context = context;
+}
+
+bool dir_walk_open(DirWalk* dir_walk, const char* path) {
+    string_set(dir_walk->path, path);
+    dir_walk->current_index = 0;
+    return storage_dir_open(dir_walk->file, path);
+}
+
+static bool dir_walk_filter(DirWalk* dir_walk, const char* name, FileInfo* fileinfo) {
+    if(dir_walk->filter_cb) {
+        return dir_walk->filter_cb(name, fileinfo, dir_walk->filter_context);
+    } else {
+        return true;
+    }
+}
+
+static DirWalkResult dir_walk_iter(DirWalk* dir_walk, string_t return_path, FileInfo* fileinfo) {
+    DirWalkResult result = DirWalkError;
+    char* name = malloc(256);
+    FileInfo info;
+    bool end = false;
+
+    while(!end) {
+        storage_dir_read(dir_walk->file, &info, name, 255);
+
+        if(storage_file_get_error(dir_walk->file) == FSE_OK) {
+            result = DirWalkOK;
+            dir_walk->current_index++;
+
+            if(dir_walk_filter(dir_walk, name, &info)) {
+                if(return_path != NULL) {
+                    string_printf(return_path, "%s/%s", string_get_cstr(dir_walk->path), name);
+                }
+
+                if(fileinfo != NULL) {
+                    memcpy(fileinfo, &info, sizeof(FileInfo));
+                }
+
+                end = true;
+            }
+
+            if((info.flags & FSF_DIRECTORY) && dir_walk->recursive) {
+                // step into
+                DirIndexList_push_back(dir_walk->index_list, dir_walk->current_index);
+                dir_walk->current_index = 0;
+                storage_dir_close(dir_walk->file);
+
+                string_cat_printf(dir_walk->path, "/%s", name);
+                storage_dir_open(dir_walk->file, string_get_cstr(dir_walk->path));
+            }
+        } else if(storage_file_get_error(dir_walk->file) == FSE_NOT_EXIST) {
+            if(DirIndexList_size(dir_walk->index_list) == 0) {
+                // last
+                result = DirWalkLast;
+                end = true;
+            } else {
+                // step out
+                uint32_t index;
+                DirIndexList_pop_back(&index, dir_walk->index_list);
+                dir_walk->current_index = 0;
+
+                storage_dir_close(dir_walk->file);
+
+                size_t last_char = string_search_rchar(dir_walk->path, '/');
+                if(last_char != STRING_FAILURE) {
+                    string_left(dir_walk->path, last_char);
+                }
+
+                storage_dir_open(dir_walk->file, string_get_cstr(dir_walk->path));
+
+                // rewind
+                while(true) {
+                    if(index == dir_walk->current_index) {
+                        result = DirWalkOK;
+                        break;
+                    }
+
+                    if(!storage_dir_read(dir_walk->file, &info, name, 255)) {
+                        result = DirWalkError;
+                        end = true;
+                        break;
+                    }
+
+                    dir_walk->current_index++;
+                }
+            }
+        } else {
+            result = DirWalkError;
+            end = true;
+        }
+    }
+
+    free(name);
+    return result;
+}
+
+FS_Error dir_walk_get_error(DirWalk* dir_walk) {
+    return storage_file_get_error(dir_walk->file);
+}
+
+DirWalkResult dir_walk_read(DirWalk* dir_walk, string_t return_path, FileInfo* fileinfo) {
+    return dir_walk_iter(dir_walk, return_path, fileinfo);
+}
+
+void dir_walk_close(DirWalk* dir_walk) {
+    if(storage_file_is_open(dir_walk->file)) {
+        storage_dir_close(dir_walk->file);
+    }
+
+    DirIndexList_reset(dir_walk->index_list);
+    string_reset(dir_walk->path);
+    dir_walk->current_index = 0;
+}

lib/toolbox/dir_walk.h

@@ -0,0 +1,79 @@
+#pragma once
+#include <storage/storage.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct DirWalk DirWalk;
+
+typedef enum {
+    DirWalkOK, /**< OK */
+    DirWalkError, /**< Error */
+    DirWalkLast, /**< Last element */
+} DirWalkResult;
+
+typedef bool (*DirWalkFilterCb)(const char* name, FileInfo* fileinfo, void* ctx);
+
+/**
+ * Allocate DirWalk
+ * @param storage 
+ * @return DirWalk* 
+ */
+DirWalk* dir_walk_alloc(Storage* storage);
+
+/**
+ * Free DirWalk
+ * @param dir_walk 
+ */
+void dir_walk_free(DirWalk* dir_walk);
+
+/**
+ * Set recursive mode (true by default)
+ * @param dir_walk 
+ * @param recursive 
+ */
+void dir_walk_set_recursive(DirWalk* dir_walk, bool recursive);
+
+/**
+ * Set filter callback (Should return true if the data is valid)
+ * @param dir_walk 
+ * @param cb 
+ * @param context 
+ */
+void dir_walk_set_filter_cb(DirWalk* dir_walk, DirWalkFilterCb cb, void* context);
+
+/**
+ * Open directory 
+ * @param dir_walk 
+ * @param path 
+ * @return true 
+ * @return false 
+ */
+bool dir_walk_open(DirWalk* dir_walk, const char* path);
+
+/**
+ * Get error id
+ * @param dir_walk 
+ * @return FS_Error 
+ */
+FS_Error dir_walk_get_error(DirWalk* dir_walk);
+
+/**
+ * Read next element from directory
+ * @param dir_walk 
+ * @param return_path 
+ * @param fileinfo 
+ * @return DirWalkResult 
+ */
+DirWalkResult dir_walk_read(DirWalk* dir_walk, string_t return_path, FileInfo* fileinfo);
+
+/**
+ * Close directory
+ * @param dir_walk 
+ */
+void dir_walk_close(DirWalk* dir_walk);
+
+#ifdef __cplusplus
+}
+#endif