C++ refactoring (#91)

Tactility/Source/app/Files/FileUtils.cpp

@@ -0,0 +1,72 @@
+#include "FileUtils.h"
+#include "TactilityCore.h"
+#include <cstdlib>
+#include <cstring>
+
+namespace tt::app::files {
+
+#define TAG "file_utils"
+
+#define SCANDIR_LIMIT 128
+
+int dirent_filter_dot_entries(const struct dirent* entry) {
+    return (strcmp(entry->d_name, "..") == 0 || strcmp(entry->d_name, ".") == 0) ? -1 : 0;
+}
+
+int dirent_sort_alpha_and_type(const struct dirent** left, const struct dirent** right) {
+    bool left_is_dir = (*left)->d_type == TT_DT_DIR;
+    bool right_is_dir = (*right)->d_type == TT_DT_DIR;
+    if (left_is_dir == right_is_dir) {
+        return strcmp((*left)->d_name, (*right)->d_name);
+    } else {
+        return (left_is_dir < right_is_dir) ? 1 : -1;
+    }
+}
+
+int dirent_sort_alpha(const struct dirent** left, const struct dirent** right) {
+    return strcmp((*left)->d_name, (*right)->d_name);
+}
+
+int scandir(
+    const char* path,
+    struct dirent*** output,
+    ScandirFilter _Nullable filter,
+    ScandirSort _Nullable sort
+) {
+    DIR* dir = opendir(path);
+    if (dir == nullptr) {
+        return -1;
+    }
+
+    *output = static_cast<dirent**>(malloc(sizeof(void*) * SCANDIR_LIMIT));
+    struct dirent** dirent_array = *output;
+    int dirent_buffer_index = 0;
+
+    struct dirent* current_entry;
+    while ((current_entry = readdir(dir)) != nullptr) {
+        if (filter(current_entry) == 0) {
+            dirent_array[dirent_buffer_index] = static_cast<dirent*>(malloc(sizeof(struct dirent)));
+            memcpy(dirent_array[dirent_buffer_index], current_entry, sizeof(struct dirent));
+
+            dirent_buffer_index++;
+            if (dirent_buffer_index >= SCANDIR_LIMIT) {
+                TT_LOG_E(TAG, "Directory has more than %d files", SCANDIR_LIMIT);
+                break;
+            }
+        }
+    }
+
+    if (dirent_buffer_index == 0) {
+        free(*output);
+        *output = nullptr;
+    } else {
+        if (sort) {
+            qsort(dirent_array, dirent_buffer_index, sizeof(struct dirent*), (__compar_fn_t)sort);
+        }
+    }
+
+    closedir(dir);
+    return dirent_buffer_index;
+};
+
+}

Tactility/Source/app/Files/FileUtils.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <dirent.h>
+
+namespace tt::app::files {
+
+    /** File types for `dirent`'s `d_type`. */
+enum {
+    TT_DT_UNKNOWN = 0,
+#define TT_DT_UNKNOWN TT_DT_UNKNOWN
+    TT_DT_FIFO = 1,
+#define TT_DT_FIFO TT_DT_FIFO
+    TT_DT_CHR = 2,
+#define TT_DT_CHR TT_DT_CHR
+    TT_DT_DIR = 4,
+#define TT_DT_DIR TT_DT_DIR
+    TT_DT_BLK = 6,
+#define TT_DT_BLK TT_DT_BLK
+    TT_DT_REG = 8,
+#define TT_DT_REG TT_DT_REG
+    TT_DT_LNK = 10,
+#define TT_DT_LNK TT_DT_LNK
+    TT_DT_SOCK = 12,
+#define TT_DT_SOCK TT_DT_SOCK
+    TT_DT_WHT = 14
+#define TT_DT_WHT TT_DT_WHT
+};
+
+typedef int (*ScandirFilter)(const struct dirent*);
+
+typedef int (*ScandirSort)(const struct dirent**, const struct dirent**);
+
+/**
+ * Alphabetic sorting function for tt_scandir()
+ * @param left left-hand side part for comparison
+ * @param right right-hand side part for comparison
+ * @return 0, -1 or 1
+ */
+int	dirent_sort_alpha(const struct dirent** left, const struct dirent** right);
+
+int dirent_sort_alpha_and_type(const struct dirent** left, const struct dirent** right);
+
+int dirent_filter_dot_entries(const struct dirent* entry);
+
+/**
+ * A scandir()-like implementation that works on ESP32.
+ * It does not return "." and ".." items but otherwise functions the same.
+ * It returns an allocated output array with allocated dirent instances.
+ * The caller is responsible for free-ing the memory of these.
+ *
+ * @param[in] path path the scan for files and directories
+ * @param[out] output a pointer to an array of dirent*
+ * @param[in] filter an optional filter to filter out specific items
+ * @param[in] sort an optional sorting function
+ * @return the amount of items that were stored in "output" or -1 when an error occurred
+ */
+int scandir(
+    const char* path,
+    struct dirent*** output,
+    ScandirFilter _Nullable filter,
+    ScandirSort _Nullable sort
+);
+
+} // namespace

Tactility/Source/app/Files/Files.cpp

@@ -0,0 +1,234 @@
+#include "FilesData.h"
+#include "Tactility.h"
+#include "app/App.h"
+#include "Assets.h"
+#include "Check.h"
+#include "FileUtils.h"
+#include "StringUtils.h"
+#include "app/ImageViewer/ImageViewer.h"
+#include "app/TextViewer/TextViewer.h"
+#include "lvgl.h"
+#include "service/loader/Loader.h"
+#include "ui/Toolbar.h"
+#include <dirent.h>
+#include <unistd.h>
+
+namespace tt::app::files {
+
+#define TAG "files_app"
+
+/**
+ * Case-insensitive check to see if the given file matches the provided file extension.
+ * @param path the full path to the file
+ * @param extension the extension to look for, including the period symbol, in lower case
+ * @return true on match
+ */
+static bool has_file_extension(const char* path, const char* extension) {
+    size_t postfix_len = strlen(extension);
+    size_t base_len = strlen(path);
+    if (base_len < postfix_len) {
+        return false;
+    }
+
+    for (int i = (int)postfix_len - 1; i >= 0; i--) {
+        if (tolower(path[base_len - postfix_len + i]) != tolower(extension[i])) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool is_supported_image_file(const char* filename) {
+    // Currently only the PNG library is built into Tactility
+    return has_file_extension(filename, ".png");
+}
+
+static bool is_supported_text_file(const char* filename) {
+    return has_file_extension(filename, ".txt") ||
+        has_file_extension(filename, ".ini") ||
+        has_file_extension(filename, ".json") ||
+        has_file_extension(filename, ".yaml") ||
+        has_file_extension(filename, ".yml") ||
+        has_file_extension(filename, ".lua") ||
+        has_file_extension(filename, ".js") ||
+        has_file_extension(filename, ".properties");
+}
+
+// region Views
+
+static void update_views(Data* data);
+
+static void on_navigate_up_pressed(lv_event_t* event) {
+    auto* files_data = (Data*)lv_event_get_user_data(event);
+    if (strcmp(files_data->current_path, "/") != 0) {
+        TT_LOG_I(TAG, "Navigating upwards");
+        char new_absolute_path[MAX_PATH_LENGTH];
+        if (string_get_path_parent(files_data->current_path, new_absolute_path)) {
+            data_set_entries_for_path(files_data, new_absolute_path);
+        }
+    }
+    update_views(files_data);
+}
+
+static void on_exit_app_pressed(TT_UNUSED lv_event_t* event) {
+    service::loader::stop_app();
+}
+
+static void view_file(const char* path, const char* filename) {
+    size_t path_len = strlen(path);
+    size_t filename_len = strlen(filename);
+    char* filepath = static_cast<char*>(malloc(path_len + filename_len + 2));
+    sprintf(filepath, "%s/%s", path, filename);
+
+    // For PC we need to make the path relative to the current work directory,
+    // because that's how LVGL maps its 'drive letter' to the file system.
+    char* processed_filepath;
+    if (get_platform() == PlatformPc) {
+        char cwd[PATH_MAX];
+        if (getcwd(cwd, sizeof(cwd)) == nullptr) {
+            TT_LOG_E(TAG, "Failed to get current working directory");
+            return;
+        }
+        if (!strstr(filepath, cwd)) {
+            TT_LOG_E(TAG, "Can only work with files in working directory %s", cwd);
+            return;
+        }
+        char* substr = filepath + strlen(cwd);
+        processed_filepath = substr;
+    } else {
+        processed_filepath = filepath;
+    }
+
+    TT_LOG_I(TAG, "Clicked %s", filepath);
+
+    if (is_supported_image_file(filename)) {
+        Bundle bundle;
+        bundle.putString(IMAGE_VIEWER_FILE_ARGUMENT, processed_filepath);
+        service::loader::start_app("ImageViewer", false, bundle);
+    } else if (is_supported_text_file(filename)) {
+        Bundle bundle;
+        if (get_platform() == PlatformEsp) {
+            bundle.putString(TEXT_VIEWER_FILE_ARGUMENT, processed_filepath);
+        } else {
+            // Remove forward slash, because we need a relative path
+            bundle.putString(TEXT_VIEWER_FILE_ARGUMENT, processed_filepath + 1);
+        }
+        service::loader::start_app("TextViewer", false, bundle);
+    } else {
+        TT_LOG_W(TAG, "opening files of this type is not supported");
+    }
+
+    free(filepath);
+}
+
+static void on_file_pressed(lv_event_t* event) {
+    lv_event_code_t code = lv_event_get_code(event);
+    if (code == LV_EVENT_CLICKED) {
+        lv_obj_t* button = lv_event_get_current_target_obj(event);
+        auto* files_data = static_cast<Data*>(lv_obj_get_user_data(button));
+
+        auto* dir_entry = static_cast<dirent*>(lv_event_get_user_data(event));
+        TT_LOG_I(TAG, "Pressed %s %d", dir_entry->d_name, dir_entry->d_type);
+
+        switch (dir_entry->d_type) {
+            case TT_DT_DIR:
+                data_set_entries_for_child_path(files_data, dir_entry->d_name);
+                update_views(files_data);
+                break;
+            case TT_DT_LNK:
+                TT_LOG_W(TAG, "opening links is not supported");
+                break;
+            case TT_DT_REG:
+                view_file(files_data->current_path, dir_entry->d_name);
+                break;
+            default:
+                // Assume it's a file
+                // TODO: Find a better way to identify a file
+                view_file(files_data->current_path, dir_entry->d_name);
+                break;
+        }
+    }
+}
+
+static void create_file_widget(Data* files_data, lv_obj_t* parent, struct dirent* dir_entry) {
+    tt_check(parent);
+    auto* list = (lv_obj_t*)parent;
+    const char* symbol;
+    if (dir_entry->d_type == TT_DT_DIR) {
+        symbol = LV_SYMBOL_DIRECTORY;
+    } else if (is_supported_image_file(dir_entry->d_name)) {
+        symbol = LV_SYMBOL_IMAGE;
+    } else if (dir_entry->d_type == TT_DT_LNK) {
+        symbol = LV_SYMBOL_LOOP;
+    } else {
+        symbol = LV_SYMBOL_FILE;
+    }
+    lv_obj_t* button = lv_list_add_button(list, symbol, dir_entry->d_name);
+    lv_obj_set_user_data(button, files_data);
+    lv_obj_add_event_cb(button, &on_file_pressed, LV_EVENT_CLICKED, (void*)dir_entry);
+}
+
+static void update_views(Data* data) {
+    lv_obj_clean(data->list);
+    for (int i = 0; i < data->dir_entries_count; ++i) {
+        create_file_widget(data, data->list, data->dir_entries[i]);
+    }
+}
+
+// endregion Views
+
+// region Lifecycle
+
+static void on_show(App app, lv_obj_t* parent) {
+    auto* data = static_cast<Data*>(tt_app_get_data(app));
+
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+
+    lv_obj_t* toolbar = lvgl::toolbar_create(parent, "Files");
+    lvgl::toolbar_set_nav_action(toolbar, LV_SYMBOL_CLOSE, &on_exit_app_pressed, nullptr);
+    lvgl::toolbar_add_action(toolbar, LV_SYMBOL_UP, "Navigate up", &on_navigate_up_pressed, data);
+
+    data->list = lv_list_create(parent);
+    lv_obj_set_width(data->list, LV_PCT(100));
+    lv_obj_set_flex_grow(data->list, 1);
+
+    update_views(data);
+}
+
+static void on_start(App app) {
+    auto* data = data_alloc();
+    // PC platform is bound to current work directory because of the LVGL file system mapping
+    if (get_platform() == PlatformPc) {
+        char cwd[PATH_MAX];
+        if (getcwd(cwd, sizeof(cwd)) != nullptr) {
+            data_set_entries_for_path(data, cwd);
+        } else {
+            TT_LOG_E(TAG, "Failed to get current work directory files");
+            data_set_entries_for_path(data, "/");
+        }
+    } else {
+        data_set_entries_for_path(data, "/");
+    }
+
+    tt_app_set_data(app, data);
+}
+
+static void on_stop(App app) {
+    auto* data = static_cast<Data*>(tt_app_get_data(app));
+    data_free(data);
+}
+
+// endregion Lifecycle
+
+extern const Manifest manifest = {
+    .id = "Files",
+    .name = "Files",
+    .icon = TT_ASSETS_APP_ICON_FILES,
+    .type = TypeSystem,
+    .on_start = &on_start,
+    .on_stop = &on_stop,
+    .on_show = &on_show,
+};
+
+} // namespace

Tactility/Source/app/Files/FilesData.cpp

@@ -0,0 +1,114 @@
+#include "FilesData.h"
+#include "FileUtils.h"
+#include "StringUtils.h"
+#include "TactilityCore.h"
+
+namespace tt::app::files {
+
+#define TAG "files_app"
+
+static bool get_child_path(char* base_path, const char* child_path, char* out_path, size_t max_chars) {
+    size_t current_path_length = strlen(base_path);
+    size_t added_path_length = strlen(child_path);
+    size_t total_path_length = current_path_length + added_path_length + 1; // two paths with `/`
+
+    if (total_path_length >= max_chars) {
+        TT_LOG_E(TAG, "Path limit reached (%d chars)", MAX_PATH_LENGTH);
+        return false;
+    } else {
+        // Postfix with "/" when the current path isn't "/"
+        if (current_path_length != 1) {
+            sprintf(out_path, "%s/%s", base_path, child_path);
+        } else {
+            sprintf(out_path, "/%s", child_path);
+        }
+        return true;
+    }
+}
+
+Data* data_alloc() {
+    auto* data = static_cast<Data*>(malloc(sizeof(Data)));
+    *data = (Data) {
+        .current_path = { 0x00 },
+        .dir_entries = nullptr,
+        .dir_entries_count = 0
+    };
+    return data;
+}
+
+void data_free(Data* data) {
+    data_free_entries(data);
+    free(data);
+}
+
+void data_free_entries(Data* data) {
+    for (int i = 0; i < data->dir_entries_count; ++i) {
+        free(data->dir_entries[i]);
+    }
+    free(data->dir_entries);
+    data->dir_entries = nullptr;
+    data->dir_entries_count = 0;
+}
+
+static void data_set_entries(Data* data, struct dirent** entries, int count) {
+    if (data->dir_entries != nullptr) {
+        data_free_entries(data);
+    }
+
+    data->dir_entries = entries;
+    data->dir_entries_count = count;
+}
+
+bool data_set_entries_for_path(Data* data, const char* path) {
+    TT_LOG_I(TAG, "Changing path: %s -> %s", data->current_path, path);
+
+    /**
+     * ESP32 does not have a root directory, so we have to create it manually.
+     * We'll add the NVS Flash partitions and the binding for the sdcard.
+     */
+    if (get_platform() == PlatformEsp && strcmp(path, "/") == 0) {
+        int dir_entries_count = 3;
+        auto** dir_entries = static_cast<dirent**>(malloc(sizeof(struct dirent*) * 3));
+
+        dir_entries[0] = static_cast<dirent*>(malloc(sizeof(struct dirent)));
+        dir_entries[0]->d_type = TT_DT_DIR;
+        strcpy(dir_entries[0]->d_name, "assets");
+
+        dir_entries[1] = static_cast<dirent*>(malloc(sizeof(struct dirent)));
+        dir_entries[1]->d_type = TT_DT_DIR;
+        strcpy(dir_entries[1]->d_name, "config");
+
+        dir_entries[2] = static_cast<dirent*>(malloc(sizeof(struct dirent)));
+        dir_entries[2]->d_type = TT_DT_DIR;
+        strcpy(dir_entries[2]->d_name, "sdcard");
+
+        data_set_entries(data, dir_entries, dir_entries_count);
+        strcpy(data->current_path, path);
+        return true;
+    } else {
+        struct dirent** entries = nullptr;
+        int count = tt::app::files::scandir(path, &entries, &dirent_filter_dot_entries, &dirent_sort_alpha_and_type);
+        if (count >= 0) {
+            TT_LOG_I(TAG, "%s has %u entries", path, count);
+            data_set_entries(data, entries, count);
+            strcpy(data->current_path, path);
+            return true;
+        } else {
+            TT_LOG_E(TAG, "Failed to fetch entries for %s", path);
+            return false;
+        }
+    }
+}
+
+bool data_set_entries_for_child_path(Data* data, const char* child_path) {
+    char new_absolute_path[MAX_PATH_LENGTH + 1];
+    if (get_child_path(data->current_path, child_path, new_absolute_path, MAX_PATH_LENGTH)) {
+        TT_LOG_I(TAG, "Navigating from %s to %s", data->current_path, new_absolute_path);
+        return data_set_entries_for_path(data, new_absolute_path);
+    } else {
+        TT_LOG_I(TAG, "Failed to get child path for %s/%s", data->current_path, child_path);
+        return false;
+    }
+}
+
+} // namespace

Tactility/Source/app/Files/FilesData.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <dirent.h>
+#include "lvgl.h"
+
+namespace tt::app::files {
+
+#define MAX_PATH_LENGTH 256
+
+typedef struct {
+    char current_path[MAX_PATH_LENGTH];
+    struct dirent** dir_entries;
+    int dir_entries_count;
+    lv_obj_t* list;
+} Data;
+
+Data* data_alloc();
+void data_free(Data* data);
+void data_free_entries(Data* data);
+bool data_set_entries_for_child_path(Data* data, const char* child_path);
+bool data_set_entries_for_path(Data* data, const char* path);
+
+} // namespace