🪄 Formats ESP32SvelteKit

esp32/lib/ESP32-sveltekit/ESP32SvelteKit.cpp

@@ -15,8 +15,7 @@
 
 #include <ESP32SvelteKit.h>
 
-ESP32SvelteKit::ESP32SvelteKit(PsychicHttpServer *server,
+ESP32SvelteKit::ESP32SvelteKit(PsychicHttpServer *server, unsigned int numberEndpoints)
-                               unsigned int numberEndpoints)
     : _server(server),
       _numberEndpoints(numberEndpoints),
       _taskManager(),
@@ -27,8 +26,7 @@ ESP32SvelteKit::ESP32SvelteKit(PsychicHttpServer *server,
       _wifiStatus(server, &_securitySettingsService),
       _apSettingsService(server, &ESPFS, &_securitySettingsService),
       _apStatus(server, &_securitySettingsService, &_apSettingsService),
-      _socket(server, &_securitySettingsService,
+      _socket(server, &_securitySettingsService, AuthenticationPredicates::IS_AUTHENTICATED),
-              AuthenticationPredicates::IS_AUTHENTICATED),
 #if FT_ENABLED(FT_NTP)
       _ntpSettingsService(server, &ESPFS, &_securitySettingsService),
       _ntpStatus(server, &_securitySettingsService),
@@ -37,8 +35,7 @@ ESP32SvelteKit::ESP32SvelteKit(PsychicHttpServer *server,
       _uploadFirmwareService(server, &_securitySettingsService),
 #endif
 #if FT_ENABLED(FT_DOWNLOAD_FIRMWARE)
-      _downloadFirmwareService(server, &_securitySettingsService, &_socket,
+      _downloadFirmwareService(server, &_securitySettingsService, &_socket, &_taskManager),
-                               &_taskManager),
 #endif
 #if FT_ENABLED(FT_SECURITY)
       _authenticationService(server, &_securitySettingsService),
@@ -69,8 +66,8 @@ ESP32SvelteKit::ESP32SvelteKit(PsychicHttpServer *server,
 #if FT_ENABLED(FT_SERVO)
       _servoController(server, &ESPFS, &_securitySettingsService, &_socket),
 #endif
-      _peripherals(server, &ESPFS, &_securitySettingsService, &_socket)
+      _peripherals(server, &ESPFS, &_securitySettingsService, &_socket) {
-{ }
+}
 
 void ESP32SvelteKit::begin() {
     ESP_LOGV("ESP32SvelteKit", "Loading settings from files system");
@@ -86,8 +83,7 @@ void ESP32SvelteKit::begin() {
     startServices();
 
     ESP_LOGV("ESP32SvelteKit", "Starting loop task");
-    _taskManager.createTask(this->_loopImpl, "Spot main", 4096, this,
+    _taskManager.createTask(this->_loopImpl, "Spot main", 4096, this, (tskIDLE_PRIORITY + 1), NULL,
-                            (tskIDLE_PRIORITY + 1), NULL,
                             ESP32SVELTEKIT_RUNNING_CORE);
 }
 
@@ -96,18 +92,14 @@ void ESP32SvelteKit::setupServer() {
     _server->listen(80);
 
 #ifdef EMBED_WWW
-    ESP_LOGV("ESP32SvelteKit",
+    ESP_LOGV("ESP32SvelteKit", "Registering routes from PROGMEM static resources");
-             "Registering routes from PROGMEM static resources");
+    WWWData::registerRoutes([&](const String &uri, const String &contentType, const uint8_t *content, size_t len) {
-    WWWData::registerRoutes([&](const String &uri, const String &contentType,
+        PsychicHttpRequestCallback requestHandler = [contentType, content, len](PsychicRequest *request) {
-                                const uint8_t *content, size_t len) {
-        PsychicHttpRequestCallback requestHandler =
-            [contentType, content, len](PsychicRequest *request) {
             PsychicResponse response(request);
             response.setCode(200);
             response.setContentType(contentType.c_str());
             response.addHeader("Content-Encoding", "gzip");
-                response.addHeader("Cache-Control",
+            response.addHeader("Cache-Control", "public, immutable, max-age=31536000");
-                                   "public, immutable, max-age=31536000");
             response.setContent(content, len);
             return response.send();
         };
@@ -123,15 +115,13 @@ void ESP32SvelteKit::setupServer() {
     });
 #else
     // Serve static resources from /www/
-    ESP_LOGV("ESP32SvelteKit",
+    ESP_LOGV("ESP32SvelteKit", "Registering routes from FS /www/ static resources");
-             "Registering routes from FS /www/ static resources");
     _server->serveStatic("/_app/", ESPFS, "/www/_app/");
     _server->serveStatic("/favicon.png", ESPFS, "/www/favicon.png");
     //  Serving all other get requests with "/www/index.htm"
     _server->onNotFound([](PsychicRequest *request) {
         if (request->method() == HTTP_GET) {
-            PsychicFileResponse response(request, ESPFS, "/www/index.html",
+            PsychicFileResponse response(request, ESPFS, "/www/index.html", "text/html");
-                                         "text/html");
             return response.send();
             // String url = "http://" + request->host() + "/index.html";
             // request->redirect(url.c_str());
@@ -144,12 +134,9 @@ void ESP32SvelteKit::setupServer() {
 
 #if defined(ENABLE_CORS)
     ESP_LOGV("ESP32SvelteKit", "Enabling CORS headers");
-    DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin",
+    DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", CORS_ORIGIN);
-                                         CORS_ORIGIN);
+    DefaultHeaders::Instance().addHeader("Access-Control-Allow-Headers", "Accept, Content-Type, Authorization");
-    DefaultHeaders::Instance().addHeader("Access-Control-Allow-Headers",
+    DefaultHeaders::Instance().addHeader("Access-Control-Allow-Credentials", "true");
-                                         "Accept, Content-Type, Authorization");
-    DefaultHeaders::Instance().addHeader("Access-Control-Allow-Credentials",
-                                         "true");
 #endif
     DefaultHeaders::Instance().addHeader("Server", _appName);
 }

esp32/lib/ESP32-sveltekit/ESP32SvelteKit.h

@@ -71,124 +71,62 @@
 #define ESP32SVELTEKIT_RUNNING_CORE -1
 #endif
 
-class ESP32SvelteKit
+class ESP32SvelteKit {
-{
   public:
     ESP32SvelteKit(PsychicHttpServer *server, unsigned int numberEndpoints = 115);
 
     void begin();
 
-    FS *getFS()
+    FS *getFS() { return &ESPFS; }
-    {
-        return &ESPFS;
-    }
 
-    PsychicHttpServer *getServer()
+    PsychicHttpServer *getServer() { return _server; }
-    {
-        return _server;
-    }
 
-    SecurityManager *getSecurityManager()
+    SecurityManager *getSecurityManager() { return &_securitySettingsService; }
-    {
-        return &_securitySettingsService;
-    }
 
-    EventSocket *getSocket()
+    EventSocket *getSocket() { return &_socket; }
-    {
-        return &_socket;
-    }
 
-    StatefulService<WiFiSettings> *getWiFiSettingsService()
+    StatefulService<WiFiSettings> *getWiFiSettingsService() { return &_wifiSettingsService; }
-    {
-        return &_wifiSettingsService;
-    }
 
-    StatefulService<APSettings> *getAPSettingsService()
+    StatefulService<APSettings> *getAPSettingsService() { return &_apSettingsService; }
-    {
-        return &_apSettingsService;
-    }
 
 #if FT_ENABLED(FT_NTP)
-    StatefulService<NTPSettings> *getNTPSettingsService()
+    StatefulService<NTPSettings> *getNTPSettingsService() { return &_ntpSettingsService; }
-    {
-        return &_ntpSettingsService;
-    }
 #endif
 
 #if FT_ENABLED(FT_SLEEP)
-    SleepService *getSleepService()
+    SleepService *getSleepService() { return &_sleepService; }
-    {
-        return &_sleepService;
-    }
 #endif
 
 #if FT_ENABLED(FT_BATTERY)
-    BatteryService *getBatteryService()
+    BatteryService *getBatteryService() { return &_batteryService; }
-    {
-        return &_batteryService;
-    }
 #endif
 
-    FeaturesService *getFeatureService()
+    FeaturesService *getFeatureService() { return &_featureService; }
-    {
-        return &_featureService;
-    }
 
-    TaskManager *getTaskManager()
+    TaskManager *getTaskManager() { return &_taskManager; }
-    {
-        return &_taskManager;
-    }
 
-    FileExplorer *getFileExplorer()
+    FileExplorer *getFileExplorer() { return &_fileExplorer; }
-    {
-        return &_fileExplorer;
-    }
 
 #if FT_ENABLED(FT_MOTION)
-    MotionService *getMotionService()
+    MotionService *getMotionService() { return &_motionService; }
-    {
-        return &_motionService;
-    }
 #endif
 
 #if FT_ENABLED(FT_CAMERA)
-    CameraService *getCameraService()
+    CameraService *getCameraService() { return &_cameraService; }
-    {
+    CameraSettingsService *getCameraSettingsService() { return &_cameraSettingsService; }
-        return &_cameraService;
-    }
-
-    CameraSettingsService *getCameraSettingsService()
-    {
-        return &_cameraSettingsService;
-    }
 #endif
 
-    Peripherals *getPeripherals()
+    Peripherals *getPeripherals() { return &_peripherals; }
-    {
-        return &_peripherals;
-    }
 
 #if FT_ENABLED(FT_SERVO)
-    ServoController *getServoController()
+    ServoController *getServoController() { return &_servoController; }
-    {
-        return &_servoController;
-    }
 #endif
 
-    void factoryReset()
+    void factoryReset() { _factoryResetService.factoryReset(); }
-    {
-        _factoryResetService.factoryReset();
-    }
 
-    void setMDNSAppName(String name)
+    void setMDNSAppName(String name) { _appName = name; }
-    {
-        _appName = name;
-    }
 
-    void recoveryMode()
+    void recoveryMode() { _apSettingsService.recoveryMode(); }
-    {
-        _apSettingsService.recoveryMode();
-    }
 
   private:
     PsychicHttpServer *_server;

esp32/lib/ESP32-sveltekit/ServoController.h

@@ -51,8 +51,7 @@ class ServoConfiguration {
     static void read(ServoConfiguration &settings, JsonObject &root) {
         root["is_active"] = settings.is_active;
         root["servo_pwm_frequency"] = settings.servo_pwm_frequency;
-        root["servo_oscillator_frequency"] =
+        root["servo_oscillator_frequency"] = settings.servo_oscillator_frequency;
-            settings.servo_oscillator_frequency;
 
         JsonArray servos = root["servos"].to<JsonArray>();
 
@@ -68,14 +67,10 @@ class ServoConfiguration {
         }
     }
 
-    static StateUpdateResult update(JsonObject &root,
+    static StateUpdateResult update(JsonObject &root, ServoConfiguration &settings) {
-                                    ServoConfiguration &settings) {
         settings.is_active = root["is_active"] | settings.is_active;
-        settings.servo_pwm_frequency =
+        settings.servo_pwm_frequency = root["servo_pwm_frequency"] | settings.servo_pwm_frequency;
-            root["servo_pwm_frequency"] | settings.servo_pwm_frequency;
+        settings.servo_oscillator_frequency = root["servo_oscillator_frequency"] | settings.servo_oscillator_frequency;
-        settings.servo_oscillator_frequency =
-            root["servo_oscillator_frequency"] |
-            settings.servo_oscillator_frequency;
 
         JsonArray servos = root["servos"];
 
@@ -83,8 +78,8 @@ class ServoConfiguration {
             ESP_LOGI("ControllerSettings", "No servos found, adding default servos");
             for (int8_t i = 0; i < FACTORY_SERVO_NUM; i++) {
                 ESP_LOGI("ControllerSettings", "Adding servo %d", i);
-                settings.servos_config.push_back(
+                settings.servos_config.push_back(servo_t {
-                    servo_t{.name = "Servo " + String(i),
+                    .name = "Servo " + String(i),
                     .channel = i,
                     .inverted = 1,
                     .angle = 0,
@@ -99,22 +94,18 @@ class ServoConfiguration {
         for (auto new_servo_json : servos) {
             JsonObject servo_config = new_servo_json.as<JsonObject>();
             int8_t channel = servo_config["channel"] | -1;
-            servo_t *servo =
+            servo_t *servo = get_servo_by_channel(settings.servos_config, channel);
-                get_servo_by_channel(settings.servos_config, channel);
 
             if (servo != nullptr) {
                 servo->name = servo_config["name"].as<String>() || servo->name;
-                if (servo_config["inverted"])
+                if (servo_config["inverted"]) servo->inverted = servo_config["inverted"];
-                    servo->inverted = servo_config["inverted"];
                 if (servo_config["angle"].is<int16_t>()) {
                     servo->angle = servo_config["angle"].as<int16_t>();
                     servo->state = SERVO_STATE_ACTIVE;
                 }
                 if (servo_config["center_angle"].is<int16_t>())
-                    servo->center_angle =
+                    servo->center_angle = servo_config["center_angle"].as<int16_t>();
-                        servo_config["center_angle"].as<int16_t>();
+                if (servo_config["sweep"]) servo->state = SERVO_STATE_SWEEPING_FORWARD;
-                if (servo_config["sweep"])
-                    servo->state = SERVO_STATE_SWEEPING_FORWARD;
                 continue;
             }
 
@@ -131,8 +122,7 @@ class ServoConfiguration {
 
         return StateUpdateResult::CHANGED;
     };
-    static servo_t *get_servo_by_channel(std::vector<servo_t> &servos_config,
+    static servo_t *get_servo_by_channel(std::vector<servo_t> &servos_config, int8_t channel_id) {
-                                         int8_t channel_id) {
         for (auto &servo : servos_config) {
             if (servo.channel == channel_id) {
                 return &servo;
@@ -142,20 +132,16 @@ class ServoConfiguration {
     }
 };
 
-class ServoController : public Adafruit_PWMServoDriver,
+class ServoController : public Adafruit_PWMServoDriver, public StatefulService<ServoConfiguration> {
-                        public StatefulService<ServoConfiguration> {
   public:
-    ServoController(PsychicHttpServer *server, FS *fs,
+    ServoController(PsychicHttpServer *server, FS *fs, SecurityManager *securityManager, EventSocket *socket)
-                    SecurityManager *securityManager, EventSocket *socket)
         : Adafruit_PWMServoDriver(),
           _server(server),
           _securityManager(securityManager),
-          _eventEndpoint(ServoConfiguration::read, ServoConfiguration::update,
+          _eventEndpoint(ServoConfiguration::read, ServoConfiguration::update, this, socket,
-                         this, socket, EVENT_CONFIGURATION_SETTINGS),
+                         EVENT_CONFIGURATION_SETTINGS),
-          _fsPersistence(ServoConfiguration::read, ServoConfiguration::update,
+          _fsPersistence(ServoConfiguration::read, ServoConfiguration::update, this, fs, SERVO_CONFIG_FILE) {
-                         this, fs, SERVO_CONFIG_FILE) {
+        addUpdateHandler([&](const String &originId) { updateServos(); }, false);
-        addUpdateHandler([&](const String &originId) { updateServos(); },
-                         false);
     }
 
     void configure() {
@@ -164,8 +150,7 @@ class ServoController : public Adafruit_PWMServoDriver,
         setOscillatorFrequency(_state.servo_oscillator_frequency);
         setPWMFreq(_state.servo_pwm_frequency);
         deactivate();
-        ESP_LOGI("ServoController",
+        ESP_LOGI("ServoController", "Configured with oscillator frequency %d and PWM frequency %d",
-                 "Configured with oscillator frequency %d and PWM frequency %d",
                  _state.servo_oscillator_frequency, _state.servo_pwm_frequency);
     }
 
@@ -203,9 +188,7 @@ class ServoController : public Adafruit_PWMServoDriver,
         setPWM(channel, 0, angleToPwm(angle));
     }
 
-    uint16_t angleToPwm(int angle) {
+    uint16_t angleToPwm(int angle) { return map(angle, 0, 180, SERVO_MIN, SERVO_MAX); }
-        return map(angle, 0, 180, SERVO_MIN, SERVO_MAX);
-    }
 
     void updateServoState() {
         for (auto &servo : _state.servos_config) {