Simplify interface; inline FileSystemSwitcher

Author: dhebbeker

lib/storage/storage.cpp

@@ -27,98 +27,54 @@ static constexpr std::uint16_t blockSize = 512; // Should be 512
 static const esp_partition_t *partition = nullptr;
 static const char *const TAG = "STORAGE";
 
-/**
- * Lists files and directories at path.
- */
-static void listFiles(const char *const dirname, const std::shared_ptr<fs::FS> fs)
+static std::condition_variable stateChangeRequested;
+static std::condition_variable stateChanged;
+static std::atomic<bool> requestFileSystemActive;
+static std::thread stateMachine;
+static std::mutex fileSystemState_mutex; //!< used to lock the actual state
+static bool fileSystemIsActive;          //!< describes the current state
+
+std::shared_ptr<fs::FS> Storage::getFileSystem_locking()
 {
-    std::cout << "Directory: '" << dirname << "'" << std::endl;
-    File root = fs->open(dirname);
-    if (!root || !root.isDirectory())
-    {
-        ESP_LOGE(TAG, "Error: '%s' is not a directory!\n", dirname);
-        return;
-    }
-
-    File file = root.openNextFile();
-    while (file)
+    std::unique_lock fs_state_lock{fileSystemState_mutex};
+    if (!fileSystemIsActive)
     {
-        std::cout << "\t" << file.name() << " (" << (file.isDirectory() ? "d" : "f") << ", " << file.size() << " Bytes)"
-                  << std::endl;
-        file.close();
-        file = root.openNextFile();
+        stateChanged.wait(fs_state_lock, []() { return fileSystemIsActive; });
     }
-    file.close();
-    root.close();
+    fs_state_lock.release();
+    return {&FFat, [](fs::FS *) { fileSystemState_mutex.unlock(); }};
 }
 
-class FileSystemSwitcher
+static void requestState(const bool fileSystemActive)
 {
-  public:
-    void begin(const bool fsIsActive)
-    {
-        fileSystemIsActive = fsIsActive;
-        requestFileSystemActive = fsIsActive;
-        stateMachine = std::thread(&FileSystemSwitcher::processStateRequests, this);
-    }
+    requestFileSystemActive = fileSystemActive;
+    ESP_LOGD(TAG, "request new state: %s", fileSystemActive ? "true" : "false");
+    stateChangeRequested.notify_all();
+}
 
-    std::shared_ptr<fs::FS> getFileSystem_locking()
+static void processStateRequests()
+{
+    while (true)
     {
         std::unique_lock fs_state_lock{fileSystemState_mutex};
-        if (!fileSystemIsActive)
+        ESP_LOGD(TAG, "waiting for state change request");
+        stateChangeRequested.wait(fs_state_lock, []() { return requestFileSystemActive != fileSystemIsActive; });
+        if (fileSystemIsActive = requestFileSystemActive)
         {
-            stateChanged.wait(fs_state_lock, [this]() { return fileSystemIsActive; });
+            ESP_LOGI(TAG, "mount FS");
+            usbMsc.mediaPresent(false);
+            FFat.end();           // invalidate cache
+            assert(FFat.begin()); // update data
         }
-        fs_state_lock.release();
-        return {&FFat, [this](fs::FS *) { fileSystemState_mutex.unlock(); }};
-    }
-    void requestState(const bool fileSystemActive)
-    {
-        requestFileSystemActive = fileSystemActive;
-        ESP_LOGD(TAG, "request new state: %s", fileSystemActive ? "true" : "false");
-        stateChangeRequested.notify_all();
-    }
-
-  protected:
-    bool isFileSystemActive() const
-    {
-        return fileSystemIsActive;
-    }
-    void processStateRequests()
-    {
-        while (true)
+        else
         {
-            std::unique_lock fs_state_lock{fileSystemState_mutex};
-            ESP_LOGD(TAG, "waiting for state change request");
-            stateChangeRequested.wait(fs_state_lock,
-                                      [this]() { return requestFileSystemActive != fileSystemIsActive; });
-            if (fileSystemIsActive = requestFileSystemActive)
-            {
-                ESP_LOGD(TAG, "mount FS");
-                usbMsc.mediaPresent(false);
-                FFat.end();           // invalidate cache
-                assert(FFat.begin()); // update data
-            }
-            else
-            {
-                ESP_LOGD(TAG, "unmount FS");
-                FFat.end(); // flush and unmount
-                usbMsc.mediaPresent(true);
-            }
-            stateChanged.notify_all();
+            ESP_LOGI(TAG, "unmount FS");
+            FFat.end(); // flush and unmount
+            usbMsc.mediaPresent(true);
         }
+        stateChanged.notify_all();
     }
-
-  private:
-    std::condition_variable stateChangeRequested;
-    std::condition_variable stateChanged;
-    std::atomic<bool> requestFileSystemActive;
-    std::thread stateMachine;
-    std::mutex fileSystemState_mutex; //!< used to lock the actual state
-    bool fileSystemIsActive;          //!< describes the current state
-};
-
-static FileSystemSwitcher fileSystemSwitcher;
+}
 
 /**
  * Callback invoked when received WRITE10 command.
@@ -174,12 +130,12 @@ static void usbStoppedCallback(void *, esp_event_base_t, int32_t, void *)
         return;
     }
     usbIsRunning = false;
-    fileSystemSwitcher.requestState(true);
+    requestState(true);
 }
 static void usbStartedCallback(void *, esp_event_base_t, int32_t, void *)
 {
     usbIsRunning = true;
-    fileSystemSwitcher.requestState(false);
+    requestState(false);
 }
 
 void Storage::begin()
@@ -190,7 +146,7 @@ void Storage::begin()
         ESP_LOGE(TAG, "Failed to init files system, flash may not be formatted");
         return;
     }
-    ESP_LOGI(TAG, "FatFS erfolgreich gemountet.");
+    ESP_LOGI(TAG, "file system initialized");
 
     partition = check_ffat_partition(FFAT_PARTITION_LABEL);
     if (!partition)
@@ -200,7 +156,10 @@ void Storage::begin()
     }
     ESP_LOGI(TAG, "Flash has a size of %u bytes\n", FFat.totalBytes());
 
-    fileSystemSwitcher.begin(true); // define state before callbacks are activated
+    // define state before callbacks are activated
+    fileSystemIsActive = true;
+    requestFileSystemActive = true;
+    stateMachine = std::thread(processStateRequests);
 
     usbMsc.vendorID("ESP32");      // max 8 chars
     usbMsc.productID("USB_MSC");   // max 16 chars
@@ -230,9 +189,3 @@ void Storage::end()
     usbIsRunning = false;
     FFat.end();
 }
-
-void Storage::test()
-{
-    auto fs_p = fileSystemSwitcher.getFileSystem_locking();
-    listFiles("/", fs_p);
-}

lib/storage/storage.hpp

@@ -1,10 +1,16 @@
 #pragma once
 #include <cstddef>
+#include <memory>
+
+namespace fs
+{
+class FS;
+}
 
 struct Storage
 {
     static void begin();
     static void end();
-    static void test();
+    static std::shared_ptr<fs::FS> getFileSystem_locking();
     static std::size_t size();
 };

platformio.ini

@@ -21,5 +21,5 @@ build_flags =
     -DARDUINO_USB_MSC_ON_BOOT=0
     -DARDUINO_USB_DFU_ON_BOOT=0
     -DCONFIG_ARDUHAL_LOG_COLORS=1
-    -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_VERBOSE
+    -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_INFO
     -std=gnu++17

src/main.cpp

@@ -1,4 +1,5 @@
 #include <Arduino.h>
+#include <FS.h>
 #include <chrono>
 #include <esp32-hal-log.h>
 #include <esp_err.h>
@@ -16,6 +17,31 @@ using namespace std::chrono_literals;
 
 static const char *const TAG = "MAIN";
 
+/**
+ * Lists files and directories at path.
+ */
+static void listFiles(const char *const dirname, const std::shared_ptr<fs::FS> fs)
+{
+    std::cout << "Directory: '" << dirname << "'" << std::endl;
+    File root = fs->open(dirname);
+    if (!root || !root.isDirectory())
+    {
+        ESP_LOGE(TAG, "Error: '%s' is not a directory!\n", dirname);
+        return;
+    }
+
+    File file = root.openNextFile();
+    while (file)
+    {
+        std::cout << "\t" << file.name() << " (" << (file.isDirectory() ? "d" : "f") << ", " << file.size() << " Bytes)"
+                  << std::endl;
+        file.close();
+        file = root.openNextFile();
+    }
+    file.close();
+    root.close();
+}
+
 void setup()
 {
     HWSerial.begin(115200);
@@ -32,6 +58,6 @@ void setup()
 
 void loop()
 {
-    Storage::test();
+    listFiles("/", Storage::getFileSystem_locking());
     std::this_thread::sleep_for(3s);
 }