[FL-1371] New LF-RFID app. Second encounter. (#547)

* File worker: file operations helper.
* Notification app: removed yield
* File worker: write operations, calls to system file widgets
* App ibutton: use file worker
* Lfrfid: generic key loading, add path helper and hex conversion to lib
* FileWorker: plain C verison
* FileWorker: add to lib.mk
* FileWorker: add to C sources, instead of CPP
* Lfrfid: save scene
* App lfrfid: add key scene, saved key menu
* App lfrfid: saved key info scene
* App lfrfid: delete key scene

lib/app-scened-template/file-worker-cpp.cpp

@@ -0,0 +1,68 @@
+#include "file-worker-cpp.h"
+#include <hex.h>
+
+FileWorkerCpp::FileWorkerCpp(bool _silent) {
+    file_worker = file_worker_alloc(_silent);
+}
+
+FileWorkerCpp::~FileWorkerCpp() {
+    file_worker_free(file_worker);
+}
+
+bool FileWorkerCpp::open(const char* filename, FS_AccessMode access_mode, FS_OpenMode open_mode) {
+    return file_worker_open(file_worker, filename, access_mode, open_mode);
+}
+
+bool FileWorkerCpp::close() {
+    return file_worker_close(file_worker);
+}
+
+bool FileWorkerCpp::mkdir(const char* dirname) {
+    return file_worker_mkdir(file_worker, dirname);
+}
+
+bool FileWorkerCpp::remove(const char* filename) {
+    return file_worker_remove(file_worker, filename);
+}
+
+bool FileWorkerCpp::read(void* buffer, uint16_t bytes_to_read) {
+    return file_worker_read(file_worker, buffer, bytes_to_read);
+}
+
+bool FileWorkerCpp::read_until(string_t str_result, char separator) {
+    return file_worker_read_until(file_worker, str_result, separator);
+}
+
+bool FileWorkerCpp::read_hex(uint8_t* buffer, uint16_t bytes_to_read) {
+    return file_worker_read_hex(file_worker, buffer, bytes_to_read);
+}
+
+bool FileWorkerCpp::tell(uint64_t* position) {
+    return file_worker_tell(file_worker, position);
+}
+
+bool FileWorkerCpp::seek(uint64_t position, bool from_start) {
+    return file_worker_seek(file_worker, position, from_start);
+}
+
+bool FileWorkerCpp::write(const void* buffer, uint16_t bytes_to_write) {
+    return file_worker_write(file_worker, buffer, bytes_to_write);
+}
+
+bool FileWorkerCpp::write_hex(const uint8_t* buffer, uint16_t bytes_to_write) {
+    return file_worker_write_hex(file_worker, buffer, bytes_to_write);
+}
+
+void FileWorkerCpp::show_error(const char* error_text) {
+    file_worker_show_error(file_worker, error_text);
+}
+
+bool FileWorkerCpp::file_select(
+    const char* path,
+    const char* extension,
+    char* result,
+    uint8_t result_size,
+    char* selected_filename) {
+    return file_worker_file_select(
+        file_worker, path, extension, result, result_size, selected_filename);
+}

lib/app-scened-template/file-worker-cpp.h

@@ -0,0 +1,135 @@
+#pragma once
+#include "file-worker.h"
+
+/**
+ * @brief File operations helper class.
+ * Automatically opens API records, shows error message on error.
+ */
+class FileWorkerCpp {
+public:
+    FileWorkerCpp(bool silent = false);
+    ~FileWorkerCpp();
+
+    /**
+     * @brief Open file
+     * 
+     * @param filename 
+     * @param access_mode 
+     * @param open_mode 
+     * @return true on success
+     */
+    bool open(const char* filename, FS_AccessMode access_mode, FS_OpenMode open_mode);
+
+    /**
+     * @brief Close file
+     * 
+     * @return true on success
+     */
+    bool close();
+
+    /**
+     * @brief Creates a directory. Doesn't show error if directory exist. 
+     * 
+     * @param dirname 
+     * @return true on success
+     */
+    bool mkdir(const char* dirname);
+
+    /**
+     * @brief Removes the file. Doesn't show error if file doesn't exist.
+     * 
+     * @param filename 
+     * @return true on success  
+     */
+    bool remove(const char* filename);
+
+    /**
+     * @brief Reads data from a file.
+     * 
+     * @param buffer 
+     * @param bytes_to_read 
+     * @return true on success  
+     */
+    bool read(void* buffer, uint16_t bytes_to_read = 1);
+
+    /**
+     * @brief Reads data from a file until separator or EOF is found. 
+     * Moves seek pointer to the next symbol after the separator. The separator is not included in the result.
+     * 
+     * @param result 
+     * @param separator 
+     * @return true on success  
+     */
+    bool read_until(string_t result, char separator = '\n');
+
+    /**
+     * @brief Reads data in hexadecimal space-delimited format. For example "AF FF" in a file - [175, 255] in a read buffer.
+     * 
+     * @param buffer 
+     * @param bytes_to_read 
+     * @return true on success  
+     */
+    bool read_hex(uint8_t* buffer, uint16_t bytes_to_read = 1);
+
+    /**
+     * @brief Read seek pointer value
+     * 
+     * @param position 
+     * @return true on success  
+     */
+    bool tell(uint64_t* position);
+
+    /**
+     * @brief Set seek pointer value
+     * 
+     * @param position 
+     * @param from_start 
+     * @return true on success  
+     */
+    bool seek(uint64_t position, bool from_start);
+
+    /**
+     * @brief Write data to file.
+     * 
+     * @param buffer 
+     * @param bytes_to_write 
+     * @return true on success  
+     */
+    bool write(const void* buffer, uint16_t bytes_to_write = 1);
+
+    /**
+     * @brief Write data to file in hexadecimal space-delimited format. For example [175, 255] in a write buffer - "AF FF" in a file.
+     * 
+     * @param buffer 
+     * @param bytes_to_write 
+     * @return true on success  
+     */
+    bool write_hex(const uint8_t* buffer, uint16_t bytes_to_write = 1);
+
+    /**
+     * @brief Show system file error message
+     * 
+     * @param error_text 
+     */
+    void show_error(const char* error_text);
+
+    /**
+     * @brief Show system file select widget
+     * 
+     * @param path 
+     * @param extension 
+     * @param result 
+     * @param result_size 
+     * @param selected_filename 
+     * @return true if file was selected
+     */
+    bool file_select(
+        const char* path,
+        const char* extension,
+        char* result,
+        uint8_t result_size,
+        char* selected_filename);
+
+private:
+    FileWorker* file_worker;
+};

lib/app-scened-template/file-worker.c

@@ -0,0 +1,280 @@
+#include "file-worker.h"
+#include <hex.h>
+#include <sd-card-api.h>
+#include <furi.h>
+
+struct FileWorker {
+    FS_Api* fs_api;
+    SdCard_Api* sd_ex_api;
+    bool silent;
+    File file;
+};
+
+bool file_worker_check_common_errors(FileWorker* file_worker);
+void file_worker_show_error_internal(FileWorker* file_worker, const char* error_text);
+bool file_worker_read_internal(FileWorker* file_worker, void* buffer, uint16_t bytes_to_read);
+bool file_worker_write_internal(
+    FileWorker* file_worker,
+    const void* buffer,
+    uint16_t bytes_to_write);
+bool file_worker_tell_internal(FileWorker* file_worker, uint64_t* position);
+bool file_worker_seek_internal(FileWorker* file_worker, uint64_t position, bool from_start);
+
+FileWorker* file_worker_alloc(bool _silent) {
+    FileWorker* file_worker = malloc(sizeof(FileWorker));
+    file_worker->silent = _silent;
+    file_worker->fs_api = furi_record_open("sdcard");
+    file_worker->sd_ex_api = furi_record_open("sdcard-ex");
+
+    return file_worker;
+}
+
+void file_worker_free(FileWorker* file_worker) {
+    furi_record_close("sdcard");
+    furi_record_close("sdcard-ex");
+    free(file_worker);
+}
+
+bool file_worker_open(
+    FileWorker* file_worker,
+    const char* filename,
+    FS_AccessMode access_mode,
+    FS_OpenMode open_mode) {
+    bool result =
+        file_worker->fs_api->file.open(&file_worker->file, filename, access_mode, open_mode);
+
+    if(!result) {
+        file_worker_show_error_internal(file_worker, "Cannot open\nfile");
+        return false;
+    }
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_close(FileWorker* file_worker) {
+    file_worker->fs_api->file.close(&file_worker->file);
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_mkdir(FileWorker* file_worker, const char* dirname) {
+    FS_Error fs_result = file_worker->fs_api->common.mkdir(dirname);
+
+    if(fs_result != FSE_OK && fs_result != FSE_EXIST) {
+        file_worker_show_error_internal(file_worker, "Cannot create\nfolder");
+        return false;
+    };
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_remove(FileWorker* file_worker, const char* filename) {
+    FS_Error fs_result = file_worker->fs_api->common.remove(filename);
+    if(fs_result != FSE_OK && fs_result != FSE_NOT_EXIST) {
+        file_worker_show_error_internal(file_worker, "Cannot remove\nold file");
+        return false;
+    };
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_read(FileWorker* file_worker, void* buffer, uint16_t bytes_to_read) {
+    if(!file_worker_read_internal(file_worker, buffer, bytes_to_read)) {
+        return false;
+    }
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_read_until(FileWorker* file_worker, string_t str_result, char separator) {
+    string_clean(str_result);
+    const uint8_t buffer_size = 32;
+    uint8_t buffer[buffer_size];
+
+    do {
+        uint16_t read_count =
+            file_worker->fs_api->file.read(&file_worker->file, buffer, buffer_size);
+        if(file_worker->file.error_id != FSE_OK) {
+            file_worker_show_error_internal(file_worker, "Cannot read\nfile");
+            return false;
+        }
+
+        bool result = false;
+        for(uint16_t i = 0; i < read_count; i++) {
+            if(buffer[i] == separator) {
+                uint64_t position;
+                if(!file_worker_tell_internal(file_worker, &position)) {
+                    return false;
+                }
+
+                position = position - read_count + i + 1;
+
+                if(!file_worker_seek_internal(file_worker, position, true)) {
+                    return false;
+                }
+
+                result = true;
+                break;
+            } else {
+                string_push_back(str_result, buffer[i]);
+            }
+        }
+
+        if(result || read_count == 0) {
+            break;
+        }
+    } while(true);
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_read_hex(FileWorker* file_worker, uint8_t* buffer, uint16_t bytes_to_read) {
+    uint8_t hi_nibble_value, low_nibble_value;
+    uint8_t text[2];
+
+    for(uint8_t i = 0; i < bytes_to_read; i++) {
+        if(i != 0) {
+            // space
+            if(!file_worker_read_internal(file_worker, text, 1)) {
+                return false;
+            }
+        }
+
+        // actual data
+        if(!file_worker_read_internal(file_worker, text, 2)) {
+            return false;
+        }
+
+        // convert hex value to byte
+        if(hex_char_to_hex_nibble(text[0], &hi_nibble_value) &&
+           hex_char_to_hex_nibble(text[1], &low_nibble_value)) {
+            buffer[i] = (hi_nibble_value << 4) | low_nibble_value;
+        } else {
+            file_worker_show_error_internal(file_worker, "Cannot parse\nfile");
+            return false;
+        }
+    }
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_tell(FileWorker* file_worker, uint64_t* position) {
+    if(!file_worker_tell_internal(file_worker, position)) {
+        return false;
+    }
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_seek(FileWorker* file_worker, uint64_t position, bool from_start) {
+    if(!file_worker_seek_internal(file_worker, position, from_start)) {
+        return false;
+    }
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_write(FileWorker* file_worker, const void* buffer, uint16_t bytes_to_write) {
+    if(!file_worker_write_internal(file_worker, buffer, bytes_to_write)) {
+        return false;
+    }
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+bool file_worker_write_hex(FileWorker* file_worker, const uint8_t* buffer, uint16_t bytes_to_write) {
+    const uint8_t byte_text_size = 3;
+    char byte_text[byte_text_size];
+
+    for(uint8_t i = 0; i < bytes_to_write; i++) {
+        sniprintf(byte_text, byte_text_size, "%02X", buffer[i]);
+
+        if(i != 0) {
+            // space
+            const char* space = " ";
+            if(!file_worker_write_internal(file_worker, space, 1)) {
+                return false;
+            }
+        }
+
+        if(!file_worker_write_internal(file_worker, byte_text, 2)) {
+            return false;
+        }
+    }
+
+    return file_worker_check_common_errors(file_worker);
+}
+
+void file_worker_show_error(FileWorker* file_worker, const char* error_text) {
+    file_worker->sd_ex_api->show_error(file_worker->sd_ex_api->context, error_text);
+}
+
+bool file_worker_file_select(
+    FileWorker* file_worker,
+    const char* path,
+    const char* extension,
+    char* result,
+    uint8_t result_size,
+    char* selected_filename) {
+    return file_worker->sd_ex_api->file_select(
+        file_worker->sd_ex_api->context, path, extension, result, result_size, selected_filename);
+}
+
+bool file_worker_check_common_errors(FileWorker* file_worker) {
+    file_worker->sd_ex_api->check_error(file_worker->sd_ex_api->context);
+    return true;
+}
+
+void file_worker_show_error_internal(FileWorker* file_worker, const char* error_text) {
+    if(!file_worker->silent) {
+        file_worker_show_error(file_worker, error_text);
+    }
+}
+
+bool file_worker_read_internal(FileWorker* file_worker, void* buffer, uint16_t bytes_to_read) {
+    uint16_t read_count =
+        file_worker->fs_api->file.read(&file_worker->file, buffer, bytes_to_read);
+
+    if(file_worker->file.error_id != FSE_OK || read_count != bytes_to_read) {
+        file_worker_show_error_internal(file_worker, "Cannot read\nfile");
+        return false;
+    }
+
+    return true;
+}
+
+bool file_worker_write_internal(
+    FileWorker* file_worker,
+    const void* buffer,
+    uint16_t bytes_to_write) {
+    uint16_t write_count =
+        file_worker->fs_api->file.write(&file_worker->file, buffer, bytes_to_write);
+
+    if(file_worker->file.error_id != FSE_OK || write_count != bytes_to_write) {
+        file_worker_show_error_internal(file_worker, "Cannot write\nto file");
+        return false;
+    }
+
+    return true;
+}
+
+bool file_worker_tell_internal(FileWorker* file_worker, uint64_t* position) {
+    *position = file_worker->fs_api->file.tell(&file_worker->file);
+
+    if(file_worker->file.error_id != FSE_OK) {
+        file_worker_show_error_internal(file_worker, "Cannot tell\nfile offset");
+        return false;
+    }
+
+    return true;
+}
+
+bool file_worker_seek_internal(FileWorker* file_worker, uint64_t position, bool from_start) {
+    file_worker->fs_api->file.seek(&file_worker->file, position, from_start);
+    if(file_worker->file.error_id != FSE_OK) {
+        file_worker_show_error_internal(file_worker, "Cannot seek\nfile");
+        return false;
+    }
+
+    return true;
+}

lib/app-scened-template/file-worker.cpp

@@ -1,237 +0,0 @@
-#include "file-worker.h"
-
-FileWorker::FileWorker(bool _silent)
-    : fs_api{"sdcard"}
-    , sd_ex_api{"sdcard-ex"} {
-    silent = _silent;
-}
-
-FileWorker::~FileWorker() {
-}
-
-bool FileWorker::open(const char* filename, FS_AccessMode access_mode, FS_OpenMode open_mode) {
-    bool result = fs_api.get()->file.open(&file, filename, access_mode, open_mode);
-
-    if(!result) {
-        show_error_internal("Cannot open\nfile");
-        close();
-        return false;
-    }
-
-    return check_common_errors();
-}
-
-bool FileWorker::close() {
-    fs_api.get()->file.close(&file);
-
-    return check_common_errors();
-}
-
-bool FileWorker::mkdir(const char* dirname) {
-    FS_Error fs_result = fs_api.get()->common.mkdir(dirname);
-
-    if(fs_result != FSE_OK && fs_result != FSE_EXIST) {
-        show_error_internal("Cannot create\nfolder");
-        return false;
-    };
-
-    return check_common_errors();
-}
-
-bool FileWorker::remove(const char* filename) {
-    FS_Error fs_result = fs_api.get()->common.remove(filename);
-    if(fs_result != FSE_OK && fs_result != FSE_NOT_EXIST) {
-        show_error_internal("Cannot remove\nold file");
-        return false;
-    };
-
-    return check_common_errors();
-}
-
-bool FileWorker::read(void* buffer, uint16_t bytes_to_read) {
-    if(!read_internal(buffer, bytes_to_read)) {
-        return false;
-    }
-
-    return check_common_errors();
-}
-
-bool FileWorker::read_until(string_t str_result, char separator) {
-    string_clean(str_result);
-    const uint8_t buffer_size = 32;
-    uint8_t buffer[buffer_size];
-
-    do {
-        uint16_t read_count = fs_api.get()->file.read(&file, buffer, buffer_size);
-        if(file.error_id != FSE_OK) {
-            show_error_internal("Cannot read\nfile");
-            return false;
-        }
-
-        bool result = false;
-        for(uint16_t i = 0; i < read_count; i++) {
-            if(buffer[i] == separator) {
-                uint64_t position;
-                if(!tell_internal(&position)) {
-                    return false;
-                }
-
-                position = position - read_count + i + 1;
-
-                if(!seek_internal(position, true)) {
-                    return false;
-                }
-
-                result = true;
-                break;
-            } else {
-                string_push_back(str_result, buffer[i]);
-            }
-        }
-
-        if(result || read_count == 0) {
-            break;
-        }
-    } while(true);
-
-    return check_common_errors();
-}
-
-bool FileWorker::read_hex(uint8_t* buffer, uint16_t bytes_to_read) {
-    uint8_t text[2];
-
-    for(uint8_t i = 0; i < bytes_to_read; i++) {
-        if(i != 0) {
-            // space
-            if(!read_internal(text, 1)) {
-                return false;
-            }
-        }
-
-        // actual data
-        if(!read_internal(text, 2)) {
-            return false;
-        }
-
-        // convert hex value to byte
-        buffer[i] = strtol(reinterpret_cast<char*>(text), NULL, 16);
-    }
-
-    return check_common_errors();
-}
-
-bool FileWorker::tell(uint64_t* position) {
-    if(!tell_internal(position)) {
-        return false;
-    }
-
-    return check_common_errors();
-}
-
-bool FileWorker::seek(uint64_t position, bool from_start) {
-    if(!seek_internal(position, from_start)) {
-        return false;
-    }
-
-    return check_common_errors();
-}
-
-bool FileWorker::write(const void* buffer, uint16_t bytes_to_write) {
-    if(!write_internal(buffer, bytes_to_write)) {
-        return false;
-    }
-
-    return check_common_errors();
-}
-
-bool FileWorker::write_hex(const uint8_t* buffer, uint16_t bytes_to_write) {
-    const uint8_t byte_text_size = 3;
-    char byte_text[byte_text_size];
-
-    for(uint8_t i = 0; i < bytes_to_write; i++) {
-        sniprintf(byte_text, byte_text_size, "%02X", buffer[i]);
-
-        if(i != 0) {
-            // space
-            const char* space = " ";
-            if(!write_internal(space, 1)) {
-                return false;
-            }
-        }
-
-        if(!write_internal(byte_text, 2)) {
-            return false;
-        }
-    }
-
-    return check_common_errors();
-}
-
-void FileWorker::show_error(const char* error_text) {
-    sd_ex_api.get()->show_error(sd_ex_api.get()->context, error_text);
-}
-
-bool FileWorker::file_select(
-    const char* path,
-    const char* extension,
-    char* result,
-    uint8_t result_size,
-    char* selected_filename) {
-    return sd_ex_api.get()->file_select(
-        sd_ex_api.get()->context, path, extension, result, result_size, selected_filename);
-
-}
-
-bool FileWorker::check_common_errors() {
-    sd_ex_api.get()->check_error(sd_ex_api.get()->context);
-    return true;
-}
-
-void FileWorker::show_error_internal(const char* error_text) {
-    if(!silent) {
-        show_error(error_text);
-    }
-}
-
-bool FileWorker::read_internal(void* buffer, uint16_t bytes_to_read) {
-    uint16_t read_count = fs_api.get()->file.read(&file, buffer, bytes_to_read);
-
-    if(file.error_id != FSE_OK || read_count != bytes_to_read) {
-        show_error_internal("Cannot read\nfile");
-        return false;
-    }
-
-    return true;
-}
-
-bool FileWorker::write_internal(const void* buffer, uint16_t bytes_to_write) {
-    uint16_t write_count = fs_api.get()->file.write(&file, buffer, bytes_to_write);
-
-    if(file.error_id != FSE_OK || write_count != bytes_to_write) {
-        show_error_internal("Cannot write\nto file");
-        return false;
-    }
-
-    return true;
-}
-
-bool FileWorker::tell_internal(uint64_t* position) {
-    *position = fs_api.get()->file.tell(&file);
-
-    if(file.error_id != FSE_OK) {
-        show_error_internal("Cannot tell\nfile offset");
-        return false;
-    }
-
-    return true;
-}
-
-bool FileWorker::seek_internal(uint64_t position, bool from_start) {
-    fs_api.get()->file.seek(&file, position, from_start);
-    if(file.error_id != FSE_OK) {
-        show_error_internal("Cannot seek\nfile");
-        return false;
-    }
-
-    return true;
-}

lib/app-scened-template/file-worker.h

@@ -1,151 +1,170 @@
 #pragma once
-#include "record-controller.hpp"
-#include <sd-card-api.h>
-#include <filesystem-api.h>
 #include <m-string.h>
+#include <filesystem-api.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /**
  * @brief File operations helper class.
  * Automatically opens API records, shows error message on error.
  */
-class FileWorker {
-public:
-    FileWorker(bool silent = false);
-    ~FileWorker();
+typedef struct FileWorker FileWorker;
 
-    RecordController<FS_Api> fs_api;
-    RecordController<SdCard_Api> sd_ex_api;
+/**
+ * @brief Allocate FileWorker
+ * 
+ * @param silent do not show errors except from file_worker_show_error fn
+ * @return FileWorker* 
+ */
+FileWorker* file_worker_alloc(bool silent);
 
-    /**
-     * @brief Open file
-     * 
-     * @param filename 
-     * @param access_mode 
-     * @param open_mode 
-     * @return true on success
-     */
-    bool open(const char* filename, FS_AccessMode access_mode, FS_OpenMode open_mode);
+/**
+ * @brief free FileWorker
+ * 
+ * @param file_worker 
+ */
+void file_worker_free(FileWorker* file_worker);
 
-    /**
-     * @brief Close file
-     * 
-     * @return true on success
-     */
-    bool close();
+/**
+ * @brief Open file
+ * 
+ * @param file_worker FileWorker instance 
+ * @param filename 
+ * @param access_mode 
+ * @param open_mode 
+ * @return true on success
+ */
+bool file_worker_open(
+    FileWorker* file_worker,
+    const char* filename,
+    FS_AccessMode access_mode,
+    FS_OpenMode open_mode);
 
-    /**
-     * @brief Creates a directory. Doesn't show error if directory exist. 
-     * 
-     * @param dirname 
-     * @return true on success
-     */
-    bool mkdir(const char* dirname);
+/**
+ * @brief Close file
+ * 
+ * @param file_worker FileWorker instance 
+ * @return true on success
+ */
+bool file_worker_close(FileWorker* file_worker);
 
-    /**
-     * @brief Removes the file. Doesn't show error if file doesn't exist.
-     * 
-     * @param filename 
-     * @return true on success  
-     */
-    bool remove(const char* filename);
+/**
+ * @brief Creates a directory. Doesn't show error if directory exist. 
+ * 
+ * @param file_worker FileWorker instance 
+ * @param dirname 
+ * @return true on success
+ */
+bool file_worker_mkdir(FileWorker* file_worker, const char* dirname);
 
-    /**
-     * @brief Reads data from a file.
-     * 
-     * @param buffer 
-     * @param bytes_to_read 
-     * @return true on success  
-     */
-    bool read(void* buffer, uint16_t bytes_to_read = 1);
+/**
+ * @brief Removes the file. Doesn't show error if file doesn't exist.
+ * 
+ * @param file_worker FileWorker instance 
+ * @param filename 
+ * @return true on success  
+ */
+bool file_worker_remove(FileWorker* file_worker, const char* filename);
 
-    /**
-     * @brief Reads data from a file until separator or EOF is found. 
-     * Moves seek pointer to the next symbol after the separator. The separator is not included in the result.
-     * 
-     * @param result 
-     * @param separator 
-     * @return true on success  
-     */
-    bool read_until(string_t result, char separator = '\n');
+/**
+ * @brief Reads data from a file.
+ * 
+ * @param file_worker FileWorker instance 
+ * @param buffer 
+ * @param bytes_to_read 
+ * @return true on success  
+ */
+bool file_worker_read(FileWorker* file_worker, void* buffer, uint16_t bytes_to_read);
 
-    /**
-     * @brief Reads data in hexadecimal space-delimited format. For example "AF FF" in a file - [175, 255] in a read buffer.
-     * 
-     * @param buffer 
-     * @param bytes_to_read 
-     * @return true on success  
-     */
-    bool read_hex(uint8_t* buffer, uint16_t bytes_to_read = 1);
+/**
+ * @brief Reads data from a file until separator or EOF is found. 
+ * Moves seek pointer to the next symbol after the separator. The separator is not included in the result.
+ * 
+ * @param file_worker FileWorker instance 
+ * @param result 
+ * @param separator 
+ * @return true on success  
+ */
+bool file_worker_read_until(FileWorker* file_worker, string_t result, char separator);
 
-    /**
-     * @brief Read seek pointer value
-     * 
-     * @param position 
-     * @return true on success  
-     */
-    bool tell(uint64_t* position);
+/**
+ * @brief Reads data in hexadecimal space-delimited format. For example "AF FF" in a file - [175, 255] in a read buffer.
+ * 
+ * @param file_worker FileWorker instance 
+ * @param buffer 
+ * @param bytes_to_read 
+ * @return true on success  
+ */
+bool file_worker_read_hex(FileWorker* file_worker, uint8_t* buffer, uint16_t bytes_to_read);
 
-    /**
-     * @brief Set seek pointer value
-     * 
-     * @param position 
-     * @param from_start 
-     * @return true on success  
-     */
-    bool seek(uint64_t position, bool from_start);
+/**
+ * @brief Read seek pointer value
+ * 
+ * @param file_worker FileWorker instance 
+ * @param position 
+ * @return true on success  
+ */
+bool file_worker_tell(FileWorker* file_worker, uint64_t* position);
 
-    /**
-     * @brief Write data to file.
-     * 
-     * @param buffer 
-     * @param bytes_to_write 
-     * @return true on success  
-     */
-    bool write(const void* buffer, uint16_t bytes_to_write = 1);
+/**
+ * @brief Set seek pointer value
+ * 
+ * @param file_worker FileWorker instance 
+ * @param position 
+ * @param from_start 
+ * @return true on success  
+ */
+bool file_worker_seek(FileWorker* file_worker, uint64_t position, bool from_start);
 
-    /**
-     * @brief Write data to file in hexadecimal space-delimited format. For example [175, 255] in a write buffer - "AF FF" in a file.
-     * 
-     * @param buffer 
-     * @param bytes_to_write 
-     * @return true on success  
-     */
-    bool write_hex(const uint8_t* buffer, uint16_t bytes_to_write = 1);
+/**
+ * @brief Write data to file.
+ * 
+ * @param file_worker FileWorker instance 
+ * @param buffer 
+ * @param bytes_to_write 
+ * @return true on success  
+ */
+bool file_worker_write(FileWorker* file_worker, const void* buffer, uint16_t bytes_to_write);
 
-    /**
-     * @brief Show system file error message
-     * 
-     * @param error_text 
-     */
-    void show_error(const char* error_text);
+/**
+ * @brief Write data to file in hexadecimal space-delimited format. For example [175, 255] in a write buffer - "AF FF" in a file.
+ * 
+ * @param file_worker FileWorker instance 
+ * @param buffer 
+ * @param bytes_to_write 
+ * @return true on success  
+ */
+bool file_worker_write_hex(FileWorker* file_worker, const uint8_t* buffer, uint16_t bytes_to_write);
 
-    /**
-     * @brief Show system file select widget
-     * 
-     * @param path 
-     * @param extension 
-     * @param result 
-     * @param result_size 
-     * @param selected_filename 
-     * @return true if file was selected
-     */
-    bool file_select(
-        const char* path,
-        const char* extension,
-        char* result,
-        uint8_t result_size,
-        char* selected_filename);
+/**
+ * @brief Show system file error message
+ * 
+ * @param file_worker FileWorker instance 
+ * @param error_text 
+ */
+void file_worker_show_error(FileWorker* file_worker, const char* error_text);
 
-private:
-    File file;
-    bool silent;
+/**
+ * @brief Show system file select widget
+ * 
+ * @param file_worker FileWorker instance 
+ * @param path 
+ * @param extension 
+ * @param result 
+ * @param result_size 
+ * @param selected_filename 
+ * @return true if file was selected
+ */
+bool file_worker_file_select(
+    FileWorker* file_worker,
+    const char* path,
+    const char* extension,
+    char* result,
+    uint8_t result_size,
+    char* selected_filename);
 
-    bool check_common_errors();
-
-    void show_error_internal(const char* error_text);
-
-    bool read_internal(void* buffer, uint16_t bytes_to_read = 1);
-    bool write_internal(const void* buffer, uint16_t bytes_to_write = 1);
-    bool tell_internal(uint64_t* position);
-    bool seek_internal(uint64_t position, bool from_start);
-};
+#ifdef __cplusplus
+}
+#endif

lib/app-scened-template/scene-controller.hpp

@@ -2,7 +2,7 @@
 #include <forward_list>
 #include <initializer_list>
 
-#define GENERIC_SCENE_ENUM_VALUES Uninitalized, Exit, Start
+#define GENERIC_SCENE_ENUM_VALUES Exit, Start
 #define GENERIC_EVENT_ENUM_VALUES Tick, Back
 
 /**
@@ -54,22 +54,85 @@ public:
      * 
      * @param scene_index_list list of scene indexes to which you want to switch
      */
-    void search_and_switch_to_previous_scene(
+    bool search_and_switch_to_previous_scene(
         const std::initializer_list<typename TApp::SceneType>& scene_index_list) {
-        auto previous_scene_index = TApp::SceneType::Start;
+        auto previous_scene_index = TApp::SceneType::Exit;
         bool scene_found = false;
+        bool result = false;
 
         while(!scene_found) {
             previous_scene_index = get_previous_scene_index();
             for(const auto& element : scene_index_list) {
                 if(previous_scene_index == element) {
+                    scene_found = true;
+                    result = true;
+                    break;
+                }
+
+                if(previous_scene_index == TApp::SceneType::Exit) {
                     scene_found = true;
                     break;
                 }
             }
         }
 
-        switch_to_scene(previous_scene_index, true);
+        if(result) {
+            switch_to_scene(previous_scene_index, true);
+        }
+
+        return result;
+    }
+
+    bool search_and_switch_to_another_scene(
+        const std::initializer_list<typename TApp::SceneType>& scene_index_list,
+        typename TApp::SceneType scene_index) {
+        auto previous_scene_index = TApp::SceneType::Exit;
+        bool scene_found = false;
+        bool result = false;
+
+        while(!scene_found) {
+            previous_scene_index = get_previous_scene_index();
+            for(const auto& element : scene_index_list) {
+                if(previous_scene_index == element) {
+                    scene_found = true;
+                    result = true;
+                    break;
+                }
+
+                if(previous_scene_index == TApp::SceneType::Exit) {
+                    scene_found = true;
+                    break;
+                }
+            }
+        }
+
+        if(result) {
+            switch_to_scene(scene_index, true);
+        }
+
+        return result;
+    }
+
+    bool
+    has_previous_scene(const std::initializer_list<typename TApp::SceneType>& scene_index_list) {
+        bool result = false;
+
+        for(auto const& previous_element : previous_scenes_list) {
+            for(const auto& element : scene_index_list) {
+                if(previous_element == element) {
+                    result = true;
+                    break;
+                }
+
+                if(previous_element == TApp::SceneType::Exit) {
+                    break;
+                }
+            }
+
+            if(result) break;
+        }
+
+        return result;
     }
 
     /**
@@ -77,12 +140,14 @@ public:
      * 
      * @param tick_length_ms tick event length in milliseconds
      */
-    void process(uint32_t tick_length_ms = 100) {
+    void process(
+        uint32_t tick_length_ms = 100,
+        typename TApp::SceneType start_scene_index = TApp::SceneType::Start) {
         typename TApp::Event event;
         bool consumed;
         bool exit = false;
 
-        current_scene_index = TApp::SceneType::Start;
+        current_scene_index = start_scene_index;
         scenes[current_scene_index]->on_enter(app, false);
 
         while(!exit) {
@@ -124,7 +189,7 @@ public:
      */
     SceneController(TApp* app_pointer) {
         app = app_pointer;
-        current_scene_index = TApp::SceneType::Uninitalized;
+        current_scene_index = TApp::SceneType::Exit;
     }
 
     /**