Implemented LaunchId and FileSelection, updated Notes (#281)

- Implemented `LaunchId` to keep track of the apps that are started
- Implemented `FileSelection` app to select existing and/or new files.
- Moved some re-usable file functionality to `tt::file::`
- Renamed `Files` app to `FileBrowser`
- Updated `Notes` app to use new `FileSelection` functionality, and cleaned it up a bit.
- General code cleanliness improvements

Tactility/Private/Tactility/app/AppInstance.h

@@ -25,22 +25,21 @@ enum class State {
  */
 class AppInstance : public AppContext {
 
-private:
-
     Mutex mutex = Mutex(Mutex::Type::Normal);
     const std::shared_ptr<AppManifest> manifest;
     State state = State::Initial;
+    LaunchId launchId;
     Flags flags = { .showStatusbar = true };
     /** @brief Optional parameters to start the app with
      * When these are stored in the app struct, the struct takes ownership.
      * Do not mutate after app creation.
      */
-    std::shared_ptr<const tt::Bundle> _Nullable parameters;
+    std::shared_ptr<const Bundle> _Nullable parameters;
 
     std::shared_ptr<App> app;
 
-    static std::shared_ptr<app::App> createApp(
-        const std::shared_ptr<app::AppManifest>& manifest
+    static std::shared_ptr<App> createApp(
+        const std::shared_ptr<AppManifest>& manifest
     ) {
         if (manifest->location.isInternal()) {
             assert(manifest->createApp != nullptr);
@@ -50,7 +49,7 @@ private:
                 TT_LOG_W("", "Manifest specifies createApp, but this is not used with external apps");
             }
 #ifdef ESP_PLATFORM
-            return app::createElfApp(manifest);
+            return createElfApp(manifest);
 #else
             tt_crash("not supported");
 #endif
@@ -61,18 +60,23 @@ private:
 
 public:
 
-    explicit AppInstance(const std::shared_ptr<AppManifest>& manifest) :
+    explicit AppInstance(const std::shared_ptr<AppManifest>& manifest, LaunchId launchId) :
         manifest(manifest),
+        launchId(launchId),
         app(createApp(manifest))
     {}
 
-    AppInstance(const std::shared_ptr<AppManifest>& manifest, std::shared_ptr<const Bundle> parameters) :
+    AppInstance(const std::shared_ptr<AppManifest>& manifest, LaunchId launchId, std::shared_ptr<const Bundle> parameters) :
         manifest(manifest),
+        launchId(launchId),
         parameters(std::move(parameters)),
-        app(createApp(manifest)) {}
+        app(createApp(manifest))
+    {}
 
     ~AppInstance() override = default;
 
+    LaunchId getLaunchId() const { return launchId; }
+
     void setState(State state);
     State getState() const;
 

Tactility/Private/Tactility/app/filebrowser/State.h

@@ -6,7 +6,7 @@
 #include <vector>
 #include <dirent.h>
 
-namespace tt::app::files {
+namespace tt::app::filebrowser {
 
 class State {
 

Tactility/Private/Tactility/app/filebrowser/SupportedFiles.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+
+namespace tt::app::filebrowser {
+
+bool isSupportedExecutableFile(const std::string& filename);
+bool isSupportedImageFile(const std::string& filename);
+bool isSupportedTextFile(const std::string& filename);
+
+} // namespace

Tactility/Private/Tactility/app/filebrowser/View.h

@@ -7,7 +7,7 @@
 #include <lvgl.h>
 #include <memory>
 
-namespace tt::app::files {
+namespace tt::app::filebrowser {
 
 class View {
     std::shared_ptr<State> state;

Tactility/Private/Tactility/app/files/FileUtils.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include <dirent.h>
-#include <string>
-#include <sys/stat.h>
-#include <vector>
-
-namespace tt::app::files {
-
-/** File types for `dirent`'s `d_type`. */
-enum {
-    TT_DT_UNKNOWN = 0,
-#define TT_DT_UNKNOWN TT_DT_UNKNOWN // Unknown type
-    TT_DT_FIFO = 1,
-#define TT_DT_FIFO TT_DT_FIFO // Named pipe or FIFO
-    TT_DT_CHR = 2,
-#define TT_DT_CHR TT_DT_CHR // Character device
-    TT_DT_DIR = 4,
-#define TT_DT_DIR TT_DT_DIR // Directory
-    TT_DT_BLK = 6,
-#define TT_DT_BLK TT_DT_BLK // Block device
-    TT_DT_REG = 8,
-#define TT_DT_REG TT_DT_REG // Regular file
-    TT_DT_LNK = 10,
-#define TT_DT_LNK TT_DT_LNK // Symbolic link
-    TT_DT_SOCK = 12,
-#define TT_DT_SOCK TT_DT_SOCK // Local-domain socket
-    TT_DT_WHT = 14
-#define TT_DT_WHT TT_DT_WHT // Whiteout inodes
-};
-
-
-std::string getChildPath(const std::string& basePath, const std::string& childPath);
-
-typedef int (*ScandirFilter)(const struct dirent*);
-
-typedef bool (*ScandirSort)(const struct dirent&, const struct dirent&);
-
-bool 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] outList a pointer to vector 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 std::string& path,
-    std::vector<dirent>& outList,
-    ScandirFilter _Nullable filter,
-    ScandirSort _Nullable sort
-);
-
-bool isSupportedExecutableFile(const std::string& filename);
-bool isSupportedImageFile(const std::string& filename);
-bool isSupportedTextFile(const std::string& filename);
-
-} // namespace

Tactility/Private/Tactility/app/fileselection/FileSelectionPrivate.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <Tactility/Bundle.h>
+
+namespace tt::app::fileselection {
+
+enum class Mode {
+    Existing = 0,
+    ExistingOrNew = 1
+};
+
+Mode getMode(const Bundle& bundle);
+
+}

Tactility/Private/Tactility/app/fileselection/State.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <Tactility/Mutex.h>
+
+#include <string>
+#include <vector>
+#include <dirent.h>
+
+namespace tt::app::fileselection {
+
+class State {
+
+    Mutex mutex = Mutex(Mutex::Type::Recursive);
+    std::vector<dirent> dir_entries;
+    std::string current_path;
+    std::string selected_child_entry;
+
+public:
+
+    State();
+
+    void freeEntries() {
+        dir_entries.clear();
+    }
+
+    ~State() {
+        freeEntries();
+    }
+
+    bool setEntriesForChildPath(const std::string& child_path);
+    bool setEntriesForPath(const std::string& path);
+
+    template <std::invocable<const std::vector<dirent> &> Func>
+    void withEntries(Func&& onEntries) const {
+        mutex.withLock([&]() {
+            std::invoke(std::forward<Func>(onEntries), dir_entries);
+        });
+    }
+
+    bool getDirent(uint32_t index, dirent& dirent);
+
+    void setSelectedChildEntry(const std::string& newFile) {
+        selected_child_entry = newFile;
+    }
+
+    std::string getSelectedChildEntry() const { return selected_child_entry; }
+    std::string getCurrentPath() const { return current_path; }
+    std::string getCurrentPathWithTrailingSlash() const {
+        if (current_path.length() > 1) {
+            return current_path + "/";
+        } else {
+            return current_path;
+        }
+    }
+
+    std::string getSelectedChildPath() const;
+};
+
+}

Tactility/Private/Tactility/app/fileselection/View.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "./State.h"
+#include "./FileSelectionPrivate.h"
+
+#include "Tactility/app/AppManifest.h"
+
+#include <lvgl.h>
+#include <memory>
+
+namespace tt::app::fileselection {
+
+class View {
+    std::shared_ptr<State> state;
+
+    lv_obj_t* dir_entry_list = nullptr;
+    lv_obj_t* navigate_up_button = nullptr;
+    lv_obj_t* path_textarea = nullptr;
+    lv_obj_t* select_button = nullptr;
+    std::function<void(std::string path)> on_file_selected;
+
+    void onTapFile(const std::string&path, const std::string&filename);
+    static void onSelectButtonPressed(lv_event_t* event);
+    static void onPathTextChanged(lv_event_t* event);
+    void createDirEntryWidget(lv_obj_t* parent, dirent& dir_entry);
+
+public:
+
+    explicit View(const std::shared_ptr<State>& state, std::function<void(const std::string& path)> onFileSelected) :
+        state(state),
+        on_file_selected(std::move(onFileSelected))
+    {}
+
+    void init(lv_obj_t* parent, Mode mode);
+    void update();
+
+    void onNavigateUpPressed();
+    void onDirEntryPressed(uint32_t index);
+    void onFileSelected(const std::string& path) const {
+        on_file_selected(path);
+    }
+};
+
+}