Remove psychichttp

esp32/include/ap_service.h

@@ -3,8 +3,9 @@
 #include <template/stateful_persistence.h>
 #include <settings/ap_settings.h>
 #include <utils/timing.h>
-#include <WiFi.h>
-#include "esp_timer.h"
+#include <utils/http_utils.h>
+#include <esp_http_server.h>
+#include <esp_timer.h>
 #include <string>
 
 class APService : public StatefulService<APSettings> {
@@ -16,14 +17,13 @@ class APService : public StatefulService<APSettings> {
     void loop();
     void recoveryMode();
 
-    esp_err_t getStatus(PsychicRequest *request);
+    esp_err_t getStatus(httpd_req_t *req);
     void status(JsonObject &root);
     APNetworkStatus getAPNetworkStatus();
 
     StatefulHttpEndpoint<APSettings> endpoint;
 
   private:
-    PsychicHttpServer *_server;
     FSPersistence<APSettings> _persistence;
 
     DNSServer *_dnsServer;

esp32/include/communication/websocket_adapter.h

@@ -1,8 +1,9 @@
 #ifndef Socket_h
 #define Socket_h
 
-#include <PsychicHttp.h>
+#include <esp_http_server.h>
 #include <template/stateful_service.h>
+#include <utils/websocket_server.h>
 #include <list>
 #include <map>
 #include <vector>
@@ -12,7 +13,7 @@
 
 class Websocket : CommAdapterBase {
   public:
-    Websocket(PsychicHttpServer &server, const char *route = "/api/ws");
+    Websocket(httpd_handle_t *server, const char *route = "/api/ws");
 
     void begin() override;
 
@@ -20,17 +21,21 @@ class Websocket : CommAdapterBase {
 
     void emit(const char *event, JsonVariant &payload, const char *originId = "", bool onlyToSameOrigin = false);
 
-  private:
-    PsychicWebSocketHandler _socket;
-    PsychicHttpServer &_server;
-    const char *_route;
+    httpd_uri_t *getUriHandler() { return &_ws_uri; }
 
-    void onWSOpen(PsychicWebSocketClient *client);
-    void onWSClose(PsychicWebSocketClient *client);
-    esp_err_t onFrame(PsychicWebSocketRequest *request, httpd_ws_frame *frame);
+  private:
+    websocket::WebSocketServer _socket;
+    httpd_handle_t *_server;
+    const char *_route;
+    httpd_uri_t _ws_uri;
+
+    void onWSOpen(int fd);
+    void onWSClose(int fd);
+    esp_err_t onFrame(httpd_req_t *req, httpd_ws_frame_t *frame);
 
     void send(const uint8_t *data, size_t len, int cid = -1) override;
+
+    static esp_err_t ws_handler_wrapper(httpd_req_t *req);
 };
 
 #endif
-

esp32/include/features.h

@@ -1,9 +1,8 @@
 #ifndef Features_h
 #define Features_h
 
-#include <WiFi.h>
 #include <ArduinoJson.h>
-#include <PsychicHttp.h>
+#include <esp_http_server.h>
 
 #define FT_ENABLED(feature) feature
 
@@ -83,7 +82,7 @@ void printFeatureConfiguration();
 
 void features(JsonObject &root);
 
-esp_err_t getFeatures(PsychicRequest *request);
+esp_err_t getFeatures(httpd_req_t *req);
 
 } // namespace feature_service
 

esp32/include/mdns_service.h

@@ -1,34 +1,15 @@
 #pragma once
 
-#include <PsychicHttp.h>
-#include <ESPmDNS.h>
-#include <template/stateful_service.h>
-#include <template/stateful_endpoint.h>
-#include <template/stateful_persistence.h>
-#include <settings/mdns_settings.h>
-#include <utils/timing.h>
+#include <mdns.h>
+#include <esp_http_server.h>
+#include <utils/http_utils.h>
 #include <string>
 
-class MDNSService : public StatefulService<MDNSSettings> {
-  private:
-    FSPersistence<MDNSSettings> _persistence;
-    bool _started {false};
+namespace mdns_service {
 
-    void reconfigureMDNS();
-    void startMDNS();
-    void stopMDNS();
-    void addServices();
+void begin(const char *hostname);
+void end();
+void addService(const char *service, const char *proto, uint16_t port);
+void addServiceTxt(const char *service, const char *proto, const char *key, const char *value);
 
-  public:
-    MDNSService();
-    ~MDNSService();
-
-    void begin();
-
-    esp_err_t getStatus(PsychicRequest *request);
-    void getStatus(JsonVariant &root);
-
-    static esp_err_t queryServices(PsychicRequest *request, JsonVariant &json);
-
-    StatefulHttpEndpoint<MDNSSettings> endpoint;
-};
+} // namespace mdns_service

esp32/include/peripherals/camera_service.h

@@ -2,8 +2,8 @@
 #define CameraService_h
 
 #include <ArduinoJson.h>
-#include <PsychicHttp.h>
-#include <WiFi.h>
+#include <esp_http_server.h>
+#include <utils/http_utils.h>
 #include <async_worker.h>
 
 #include <features.h>
@@ -35,8 +35,8 @@ class CameraService : public StatefulService<CameraSettings> {
 
     esp_err_t begin();
 
-    esp_err_t cameraStill(PsychicRequest *request);
-    esp_err_t cameraStream(PsychicRequest *request);
+    esp_err_t cameraStill(httpd_req_t *req);
+    esp_err_t cameraStream(httpd_req_t *req);
 
     StatefulHttpEndpoint<CameraSettings> endpoint;
 

esp32/include/system_service.h

@@ -1,23 +1,21 @@
 #pragma once
 
-#include <ESPmDNS.h>
-#include <PsychicHttp.h>
-#include <WiFi.h>
-// #include <communication/websocket_adapter.h>
+#include <esp_http_server.h>
 #include <filesystem.h>
 #include <global.h>
-#include "esp_timer.h"
+#include <esp_timer.h>
+#include <utils/http_utils.h>
 #include <string>
 
 #define MAX_ESP_ANALYTICS_SIZE 2024
 #define EVENT_ANALYTICS "analytics"
 
 namespace system_service {
-esp_err_t handleReset(PsychicRequest *request);
-esp_err_t handleRestart(PsychicRequest *request);
-esp_err_t handleSleep(PsychicRequest *request);
-esp_err_t getStatus(PsychicRequest *request);
-esp_err_t getMetrics(PsychicRequest *request);
+esp_err_t handleReset(httpd_req_t *req);
+esp_err_t handleRestart(httpd_req_t *req);
+esp_err_t handleSleep(httpd_req_t *req);
+esp_err_t getStatus(httpd_req_t *req);
+esp_err_t getMetrics(httpd_req_t *req);
 
 void reset();
 void restart();

esp32/include/template/stateful_endpoint.h

@@ -1,7 +1,8 @@
 #pragma once
 
-#include <PsychicHttp.h>
+#include <esp_http_server.h>
 #include <template/stateful_service.h>
+#include <utils/http_utils.h>
 
 #include <functional>
 
@@ -20,29 +21,27 @@ class StatefulHttpEndpoint {
                          StatefulService<T> *statefulService)
         : _stateReader(stateReader), _stateUpdater(stateUpdater), _statefulService(statefulService) {}
 
-    esp_err_t handleStateUpdate(PsychicRequest *request, JsonVariant &json) {
+    esp_err_t handleStateUpdate(httpd_req_t *req, 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
+        if (outcome == StateUpdateResult::ERROR) {
+            return http_utils::send_error(req, 400);
+        } else if ((outcome == StateUpdateResult::CHANGED)) {
             _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID);
         }
 
-        PsychicJsonResponse response = PsychicJsonResponse(request, false);
-        jsonObject = response.getRoot();
-
+        JsonDocument doc;
+        jsonObject = doc.to<JsonVariant>();
         _statefulService->read(jsonObject, _stateReader);
 
-        return response.send();
+        return http_utils::send_json_response(req, doc);
     }
 
-    esp_err_t getState(PsychicRequest *request) {
-        PsychicJsonResponse response = PsychicJsonResponse(request, false);
-        JsonVariant jsonObject = response.getRoot();
+    esp_err_t getState(httpd_req_t *req) {
+        JsonDocument doc;
+        JsonVariant jsonObject = doc.to<JsonVariant>();
         _statefulService->read(jsonObject, _stateReader);
-        return response.send();
+        return http_utils::send_json_response(req, doc);
     }
 };

esp32/include/utils/http_utils.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <esp_http_server.h>
+#include <ArduinoJson.h>
+
+namespace http_utils {
+
+esp_err_t send_json_response(httpd_req_t *req, JsonDocument &doc, int status_code = 200);
+
+esp_err_t send_error(httpd_req_t *req, int status_code, const char *message = nullptr);
+
+esp_err_t send_empty_response(httpd_req_t *req, int status_code = 200);
+
+esp_err_t add_cors_headers(httpd_req_t *req);
+
+esp_err_t add_standard_headers(httpd_req_t *req);
+
+esp_err_t parse_json_body(httpd_req_t *req, JsonDocument &doc);
+
+esp_err_t handle_options_cors(httpd_req_t *req);
+
+const char *get_client_ip(httpd_req_t *req);
+
+} // namespace http_utils

esp32/include/utils/websocket_server.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <esp_http_server.h>
+#include <map>
+#include <list>
+#include <functional>
+
+namespace websocket {
+
+struct WebSocketClient {
+    int fd;
+    uint64_t last_seen;
+};
+
+typedef std::function<void(int fd)> ClientCallback;
+typedef std::function<esp_err_t(httpd_req_t *req, httpd_ws_frame_t *frame)> FrameCallback;
+
+class WebSocketServer {
+  public:
+    WebSocketServer();
+    ~WebSocketServer();
+
+    void setOpenCallback(ClientCallback callback);
+    void setCloseCallback(ClientCallback callback);
+    void setFrameCallback(FrameCallback callback);
+
+    esp_err_t handleWebSocket(httpd_req_t *req);
+
+    void addClient(int fd);
+    void removeClient(int fd);
+    WebSocketClient *getClient(int fd);
+
+    esp_err_t sendText(int fd, const char *data, size_t len);
+    esp_err_t sendBinary(int fd, const uint8_t *data, size_t len);
+    esp_err_t sendToAll(httpd_ws_type_t type, const uint8_t *data, size_t len);
+
+    bool hasClients() const { return !_clients.empty(); }
+    size_t clientCount() const { return _clients.size(); }
+
+  public:
+    void setServer(httpd_handle_t server) { _server = server; }
+
+  private:
+    std::map<int, WebSocketClient> _clients;
+    ClientCallback _onOpen;
+    ClientCallback _onClose;
+    FrameCallback _onFrame;
+    SemaphoreHandle_t _mutex;
+    httpd_handle_t _server;
+
+    friend esp_err_t websocket_handler(httpd_req_t *req);
+};
+
+esp_err_t websocket_handler(httpd_req_t *req);
+
+} // namespace websocket

esp32/include/wifi_service.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <PsychicHttp.h>
-#include <WiFi.h>
-#include <ESPmDNS.h>
+#include <esp_http_server.h>
+#include <esp_wifi.h>
 #include <string>
 
 #include <filesystem.h>
 #include <utils/timing.h>
+#include <utils/http_utils.h>
 #include <template/stateful_service.h>
 #include <template/stateful_persistence.h>
 #include <template/stateful_endpoint.h>
@@ -43,9 +43,9 @@ class WiFiService : public StatefulService<WiFiSettings> {
 
     const char *getHostname() { return state().hostname.c_str(); }
 
-    static esp_err_t handleScan(PsychicRequest *request);
-    static esp_err_t getNetworks(PsychicRequest *request);
-    static esp_err_t getNetworkStatus(PsychicRequest *request);
+    static esp_err_t handleScan(httpd_req_t *req);
+    static esp_err_t getNetworks(httpd_req_t *req);
+    static esp_err_t getNetworkStatus(httpd_req_t *req);
 
     StatefulHttpEndpoint<WiFiSettings> endpoint;
 };

esp32/include/www_mount.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include <PsychicHttp.h>
+#include <esp_http_server.h>
 #include "WWWData.h"
 
-void mountStaticAssets(PsychicHttpServer& s);
+void mountStaticAssets(httpd_handle_t server);