🚚 Moves firmware to src and include

2025-07-11 12:12:07 +02:00
parent 743aa073b7
commit a3be035f98
60 changed files with 2 additions and 3 deletions
@@ -0,0 +1,7 @@
+#pragma once
+
+enum class StateUpdateResult {
+    CHANGED = 0, // The update changed the state and propagation should take place if required
+    UNCHANGED,   // The state was unchanged, propagation should not take place
+    ERROR        // There was a problem updating the state, propagation should not take place
+};
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <PsychicHttp.h>
+#include <template/stateful_service.h>
+
+#include <functional>
+
+#define HTTP_ENDPOINT_ORIGIN_ID "http"
+#define HTTPS_ENDPOINT_ORIGIN_ID "https"
+
+template <class T>
+class StatefulHttpEndpoint {
+  protected:
+    JsonStateReader<T> _stateReader;
+    JsonStateUpdater<T> _stateUpdater;
+    StatefulService<T> *_statefulService;
+
+  public:
+    StatefulHttpEndpoint(JsonStateReader<T> stateReader, JsonStateUpdater<T> stateUpdater,
+                         StatefulService<T> *statefulService)
+        : _stateReader(stateReader), _stateUpdater(stateUpdater), _statefulService(statefulService) {}
+
+    esp_err_t handleStateUpdate(PsychicRequest *request, JsonVariant &json) {
+        JsonVariant jsonObject = json.as<JsonVariant>();
+        StateUpdateResult outcome = _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
+
+        if (outcome == StateUpdateResult::ERROR)
+            return request->reply(400);
+        else if ((outcome == StateUpdateResult::CHANGED)) {
+            // persist the changes to the FS
+            _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID);
+        }
+
+        PsychicJsonResponse response = PsychicJsonResponse(request, false);
+        jsonObject = response.getRoot();
+
+        _statefulService->read(jsonObject, _stateReader);
+
+        return response.send();
+    }
+
+    esp_err_t getState(PsychicRequest *request) {
+        PsychicJsonResponse response = PsychicJsonResponse(request, false);
+        JsonVariant jsonObject = response.getRoot();
+        _statefulService->read(jsonObject, _stateReader);
+        return response.send();
+    }
+};
@@ -0,0 +1,120 @@
+#ifndef FSPersistence_h
+#define FSPersistence_h
+
+/**
+ *   ESP32 SvelteKit
+ *
+ *   A simple, secure and extensible framework for IoT projects for ESP32 platforms
+ *   with responsive Sveltekit front-end built with TailwindCSS and DaisyUI.
+ *   https://github.com/theelims/ESP32-sveltekit
+ *
+ *   Copyright (C) 2018 - 2023 rjwats
+ *   Copyright (C) 2023 theelims
+ *   Copyright (C) 2024 runeharlyk
+ *
+ *   All Rights Reserved. This software may be modified and distributed under
+ *   the terms of the LGPL v3 license. See the LICENSE file for details.
+ **/
+
+#include <FS.h>
+#include <template/stateful_service.h>
+#include <filesystem.h>
+
+template <class T>
+class FSPersistence {
+  public:
+    FSPersistence(JsonStateReader<T> stateReader, JsonStateUpdater<T> stateUpdater, StatefulService<T> *statefulService,
+                  const char *filePath)
+        : _stateReader(stateReader),
+          _stateUpdater(stateUpdater),
+          _statefulService(statefulService),
+          _filePath(filePath),
+          _updateHandlerId(0) {
+        enableUpdateHandler();
+    }
+
+    void readFromFS() {
+        File settingsFile = _fs->open(_filePath, "r");
+
+        if (settingsFile) {
+            JsonDocument jsonDocument;
+            DeserializationError error = deserializeJson(jsonDocument, settingsFile);
+            if (error == DeserializationError::Ok) {
+                JsonVariant jsonObject = jsonDocument.as<JsonVariant>();
+                _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
+                settingsFile.close();
+                return;
+            }
+            settingsFile.close();
+        }
+
+        // If we reach here we have not been successful in loading the config
+        // and hard-coded defaults are now applied. The settings are then
+        // written back to the file system so the defaults persist between
+        // resets. This last step is required as in some cases defaults contain
+        // randomly generated values which would otherwise be modified on reset.
+        applyDefaults();
+        writeToFS();
+    }
+
+    bool writeToFS() {
+        JsonDocument jsonDocument;
+        JsonVariant jsonObject = jsonDocument.to<JsonVariant>();
+        _statefulService->read(jsonObject, _stateReader);
+
+        mkdirs();
+
+        File file = _fs->open(_filePath, "w");
+
+        if (!file) return false;
+
+        serializeJson(jsonDocument, file);
+        file.close();
+        return true;
+    }
+
+    void disableUpdateHandler() {
+        if (_updateHandlerId) {
+            _statefulService->removeUpdateHandler(_updateHandlerId);
+            _updateHandlerId = 0;
+        }
+    }
+
+    void enableUpdateHandler() {
+        if (!_updateHandlerId) {
+            _updateHandlerId = _statefulService->addUpdateHandler([&](const String &originId) { writeToFS(); });
+        }
+    }
+
+  private:
+    JsonStateReader<T> _stateReader;
+    JsonStateUpdater<T> _stateUpdater;
+    StatefulService<T> *_statefulService;
+    FS *_fs {&ESPFS};
+    const char *_filePath;
+    size_t _bufferSize;
+    HandlerId _updateHandlerId;
+
+    // We assume we have a _filePath with format
+    // "/directory1/directory2/filename" We create a directory for each missing
+    // parent
+    void mkdirs() {
+        String path(_filePath);
+        int index = 0;
+        while ((index = path.indexOf('/', index + 1)) != -1) {
+            String segment = path.substring(0, index);
+            if (!_fs->exists(segment)) _fs->mkdir(segment);
+        }
+    }
+
+  protected:
+    // We assume the updater supplies sensible defaults if an empty object
+    // is supplied, this virtual function allows that to be changed.
+    virtual void applyDefaults() {
+        JsonDocument jsonDocument;
+        JsonVariant jsonObject = jsonDocument.as<JsonVariant>();
+        _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
+    }
+};
+
+#endif // end FSPersistence
@@ -0,0 +1,158 @@
+#pragma once
+
+#include <Arduino.h>
+#include <ArduinoJson.h>
+
+#include <list>
+#include <functional>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+#include <template/state_result.h>
+
+template <typename T>
+using JsonStateUpdater = std::function<StateUpdateResult(JsonVariant &root, T &settings)>;
+
+template <typename T>
+using JsonStateReader = std::function<void(T &settings, JsonVariant &root)>;
+
+using HandlerId = size_t;
+using StateUpdateCallback = std::function<void(const String &originId)>;
+using StateHookCallback = std::function<void(const String &originId, StateUpdateResult &result)>;
+
+class HandlerBase {
+  protected:
+    static inline HandlerId nextId_ = 1; // Start from 1, 0 is invalid
+    HandlerId id_;
+    bool allowRemove_;
+
+    HandlerBase(bool allowRemove) : id_(nextId_++), allowRemove_(allowRemove) {}
+
+  public:
+    HandlerId getId() const { return id_; }
+    bool isRemovable() const { return allowRemove_; }
+};
+
+class UpdateHandler : public HandlerBase {
+    StateUpdateCallback callback_;
+
+  public:
+    UpdateHandler(StateUpdateCallback callback, bool allowRemove)
+        : HandlerBase(allowRemove), callback_(std::move(callback)) {}
+
+    void invoke(const String &originId) const { callback_(originId); }
+};
+
+class HookHandler : public HandlerBase {
+    StateHookCallback callback_;
+
+  public:
+    HookHandler(StateHookCallback callback, bool allowRemove)
+        : HandlerBase(allowRemove), callback_(std::move(callback)) {}
+
+    void invoke(const String &originId, StateUpdateResult &result) const { callback_(originId, result); }
+};
+
+template <class T>
+class StatefulService {
+  public:
+    template <typename... Args>
+    StatefulService(Args &&...args) : state_(std::forward<Args>(args)...), mutex_(xSemaphoreCreateRecursiveMutex()) {}
+
+    HandlerId addUpdateHandler(StateUpdateCallback callback, bool allowRemove = true) {
+        if (!callback) return 0;
+
+        updateHandlers_.emplace_back(std::move(callback), allowRemove);
+        return updateHandlers_.back().getId();
+    }
+
+    void removeUpdateHandler(HandlerId id) {
+        updateHandlers_.remove_if(
+            [id](const UpdateHandler &handler) { return handler.isRemovable() && handler.getId() == id; });
+    }
+
+    HandlerId addHookHandler(StateHookCallback callback, bool allowRemove = true) {
+        if (!callback) return 0;
+
+        hookHandlers_.emplace_back(std::move(callback), allowRemove);
+        return hookHandlers_.back().getId();
+    }
+
+    void removeHookHandler(HandlerId id) {
+        hookHandlers_.remove_if(
+            [id](const HookHandler &handler) { return handler.isRemovable() && handler.getId() == id; });
+    }
+
+    StateUpdateResult update(std::function<StateUpdateResult(T &)> stateUpdater, const String &originId) {
+        lock();
+        StateUpdateResult result = stateUpdater(state_);
+        unlock();
+        notifyStateChange(originId, result);
+        return result;
+    }
+
+    StateUpdateResult updateWithoutPropagation(std::function<StateUpdateResult(T &)> stateUpdater) {
+        lock();
+        StateUpdateResult result = stateUpdater(state_);
+        unlock();
+        return result;
+    }
+
+    StateUpdateResult update(JsonVariant &jsonObject, JsonStateUpdater<T> stateUpdater, const String &originId) {
+        lock();
+        StateUpdateResult result = stateUpdater(jsonObject, state_);
+        unlock();
+        notifyStateChange(originId, result);
+        return result;
+    }
+
+    StateUpdateResult updateWithoutPropagation(JsonVariant &jsonObject, JsonStateUpdater<T> stateUpdater) {
+        lock();
+        StateUpdateResult result = stateUpdater(jsonObject, state_);
+        unlock();
+        return result;
+    }
+
+    void read(std::function<void(T &)> stateReader) {
+        lock();
+        stateReader(state_);
+        unlock();
+    }
+
+    void read(JsonVariant &jsonObject, JsonStateReader<T> stateReader) {
+        lock();
+        stateReader(state_, jsonObject);
+        unlock();
+    }
+
+    void callUpdateHandlers(const String &originId) {
+        for (const UpdateHandler &updateHandler : updateHandlers_) {
+            updateHandler.invoke(originId);
+        }
+    }
+
+    void callHookHandlers(const String &originId, StateUpdateResult &result) {
+        for (const HookHandler &hookHandler : hookHandlers_) {
+            hookHandler.invoke(originId, result);
+        }
+    }
+
+    T &state() { return state_; }
+
+  private:
+    T state_;
+
+    inline void lock() { xSemaphoreTakeRecursive(mutex_, portMAX_DELAY); }
+    inline void unlock() { xSemaphoreGiveRecursive(mutex_); }
+
+    void notifyStateChange(const String &originId, StateUpdateResult &result) {
+        callHookHandlers(originId, result);
+        if (result == StateUpdateResult::CHANGED) {
+            callUpdateHandlers(originId);
+        }
+    }
+
+    SemaphoreHandle_t mutex_;
+    std::list<UpdateHandler> updateHandlers_;
+    std::list<HookHandler> hookHandlers_;
+};
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <PsychicHttp.h>
+
+#include <event_socket.h>
+#include <template/stateful_service.h>
+
+template <class T>
+class EventEndpoint {
+  public:
+    EventEndpoint(JsonStateReader<T> stateReader, JsonStateUpdater<T> stateUpdater, StatefulService<T> *statefulService,
+                  const char *event)
+        : _stateReader(stateReader), _stateUpdater(stateUpdater), _statefulService(statefulService), _event(event) {
+        _statefulService->addUpdateHandler([&](const String &originId) { syncState(originId); }, false);
+    }
+
+    void begin() {
+        socket.onEvent(_event,
+                       std::bind(&EventEndpoint::updateState, this, std::placeholders::_1, std::placeholders::_2));
+        socket.onSubscribe(_event,
+                           std::bind(&EventEndpoint::syncState, this, std::placeholders::_1, std::placeholders::_2));
+    }
+
+  private:
+    JsonStateReader<T> _stateReader;
+    JsonStateUpdater<T> _stateUpdater;
+    StatefulService<T> *_statefulService;
+    const char *_event;
+
+    void updateState(JsonVariant &root, int originId) {
+        _statefulService->update(root, _stateUpdater, String(originId));
+    }
+
+    void syncState(const String &originId, bool sync = false) {
+        JsonDocument jsonDocument;
+        JsonVariant root = jsonDocument.to<JsonVariant>();
+        _statefulService->read(root, _stateReader);
+        socket.emit(_event, root, originId.c_str(), sync);
+    }
+};