refactor: Replace Arduino HTTP Client with esp native

include/http/DownloadCallback.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+
+namespace OpenShock::HTTP {
+  using DownloadCallback = std::function<bool(std::size_t offset, const uint8_t* data, std::size_t len)>;
+}

include/http/GotContentLengthCallback.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+
+namespace OpenShock::HTTP {
+  using GotContentLengthCallback = std::function<bool(int contentLength)>;
+}

include/http/HTTPClient.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "Common.h"
+#include "http/HTTPClientState.h"
+#include "http/HTTPResponse.h"
+#include "http/JsonResponse.h"
+
+#include<esp_err.h>
+
+#include <cstdint>
+#include <memory>
+
+namespace OpenShock::HTTP {
+  class HTTPClient {
+    DISABLE_COPY(HTTPClient);
+    DISABLE_MOVE(HTTPClient);
+
+  public:
+    HTTPClient(uint32_t timeoutMs = 10'000)
+      : m_state(std::make_shared<HTTPClientState>(timeoutMs))
+    {
+    }
+
+    inline esp_err_t SetHeader(const char* key, const char* value) {
+      return m_state->SetHeader(key, value);
+    }
+
+    inline HTTPResponse Get(const char* url) {
+      auto response = GetInternal(url);
+      if (response.error != HTTPError::None) return response.error;
+
+      return HTTP::HTTPResponse(m_state, response.data.statusCode, response.data.contentLength);
+    }
+    template<typename T>
+    inline JsonResponse<T> GetJson(const char* url, JsonParserFn<T> jsonParser) {
+      auto response = GetInternal(url);
+      if (response.error != HTTPError::None) return response.error;
+
+      return HTTP::JsonResponse(m_state, jsonParser, response.data.statusCode, response.data.contentLength);
+    }
+
+    inline esp_err_t Close() {
+      return m_state->Close();
+    }
+  private:
+    struct InternalResult {
+      HTTPError error;
+      HTTPClientState::StartRequestResult data;
+    };
+    InternalResult GetInternal(const char* url);
+
+    std::shared_ptr<HTTPClientState> m_state;
+  };
+}  // namespace OpenShock::HTTP

include/http/HTTPClientState.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "Common.h"
+#include "http/DownloadCallback.h"
+#include "http/HTTPError.h"
+#include "http/JsonParserFn.h"
+#include "http/ReadResult.h"
+
+#include <cJSON.h>
+
+#include <esp_http_client.h>
+
+#include <string>
+#include <string_view>
+#include <variant>
+#include <vector>
+
+namespace OpenShock::HTTP {
+  class HTTPClientState {
+    DISABLE_COPY(HTTPClientState);
+    DISABLE_MOVE(HTTPClientState);
+  public:
+    HTTPClientState(uint32_t timeoutMs);
+    ~HTTPClientState();
+
+    inline esp_err_t SetHeader(const char* key, const char* value) {
+      return esp_http_client_set_header(m_handle, key, value);
+    }
+
+    struct [[nodiscard]] StartRequestResult {
+      uint16_t statusCode;
+      bool isChunked;
+      uint32_t contentLength;
+    };
+
+    std::variant<StartRequestResult, HTTPError> StartRequest(esp_http_client_method_t method, const char* url, int writeLen);
+
+    // High-throughput streaming logic
+    ReadResult<uint32_t> ReadStreamImpl(DownloadCallback cb);
+
+    ReadResult<std::string> ReadStringImpl(uint32_t reserve);
+
+    template<typename T>
+    inline ReadResult<T> ReadJsonImpl(uint32_t reserve, JsonParserFn<T> jsonParser)
+    {
+      auto response = ReadStringImpl(reserve);
+      if (response.error != HTTPError::None) {
+        return response.error;
+      }
+
+      cJSON* json = cJSON_ParseWithLength(response.data.c_str(), response.data.length());
+      if (json == nullptr) {
+        return HTTPError::ParseFailed;
+      }
+
+      T data;
+      if (!jsonParser(json, data)) {
+        return HTTPError::ParseFailed;
+      }
+
+      cJSON_Delete(json);
+
+      return data;
+    }
+
+    inline esp_err_t Close() {
+      return esp_http_client_close(m_handle);
+    }
+  private:
+    static esp_err_t EventHandler(esp_http_client_event_t* evt);
+    esp_err_t EventHeaderHandler(std::string key, std::string value);
+
+    esp_http_client_handle_t m_handle;
+    bool m_reading;
+    std::vector<std::pair<std::string, std::string>> m_headers;
+  };
+} // namespace OpenShock::HTTP

include/http/HTTPError.h

@@ -0,0 +1,44 @@
+#pragma once
+
+namespace OpenShock::HTTP {
+  enum class HTTPError {
+    None,
+    InternalError,
+    RateLimited,
+    InvalidUrl,
+    InvalidHttpMethod,
+    NetworkError,
+    ConnectionClosed,
+    SizeLimitExceeded,
+    Aborted,
+    ParseFailed
+  };
+
+  inline const char* HTTPErrorToString(HTTPError error) {
+    switch (error)
+    {
+    case HTTPError::None:
+      return "";
+    case HTTPError::InternalError:
+      return "";
+    case HTTPError::RateLimited:
+      return "";
+    case HTTPError::InvalidUrl:
+      return "";
+    case HTTPError::InvalidHttpMethod:
+      return "";
+    case HTTPError::NetworkError:
+      return "";
+    case HTTPError::ConnectionClosed:
+      return "";
+    case HTTPError::SizeLimitExceeded:
+      return "";
+    case HTTPError::Aborted:
+      return "";
+    case HTTPError::ParseFailed:
+      return "";
+    default:
+      return "";
+    }
+  }
+} // namespace OpenShock::HTTP

include/http/HTTPResponse.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "Common.h"
+#include "http/DownloadCallback.h"
+#include "http/HTTPClientState.h"
+#include "http/JsonParserFn.h"
+#include "http/ReadResult.h"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+namespace OpenShock::HTTP {
+  class HTTPClient;
+  class [[nodiscard]] HTTPResponse {
+    DISABLE_DEFAULT(HTTPResponse);
+    DISABLE_COPY(HTTPResponse);
+    DISABLE_MOVE(HTTPResponse);
+
+    friend class HTTPClient;
+
+    HTTPResponse(std::shared_ptr<HTTPClientState> state, uint16_t statusCode, uint32_t contentLength)
+      : m_state(state)
+      , m_error(HTTPError::None)
+      , m_statusCode(statusCode)
+      , m_contentLength(contentLength)
+    {
+    }
+  public:
+    HTTPResponse(HTTPError error)
+      : m_state()
+      , m_error(error)
+      , m_statusCode(0)
+      , m_contentLength(0)
+    {
+    }
+
+    inline bool Ok() const { return m_error == HTTPError::None && !m_state.expired(); }
+    inline HTTPError Error() const { return m_error; }
+    inline uint16_t StatusCode() const { return m_statusCode; }
+    inline uint32_t ContentLength() const { return m_contentLength; }
+
+    inline ReadResult<uint32_t> ReadStream(DownloadCallback downloadCallback) {
+      auto locked = m_state.lock();
+      if (locked == nullptr) return HTTPError::ConnectionClosed;
+
+      return locked->ReadStreamImpl(downloadCallback);
+    }
+
+    inline ReadResult<std::string> ReadString() {
+      auto locked = m_state.lock();
+      if (locked == nullptr) return HTTPError::ConnectionClosed;
+
+      return locked->ReadStringImpl(m_contentLength);
+    }
+
+    template<typename T>
+    inline ReadResult<T> ReadJson(JsonParserFn<T> jsonParser)
+    {
+      auto locked = m_state.lock();
+      if (locked == nullptr) return HTTPError::ConnectionClosed;
+
+      return locked->ReadJsonImpl(m_contentLength, jsonParser);
+    }
+  private:
+    std::weak_ptr<HTTPClientState> m_state;
+    HTTPError m_error;
+    uint16_t m_statusCode;
+    uint32_t m_contentLength;
+  };
+} // namespace OpenShock::HTTP

include/http/JsonAPI.h

@@ -1,6 +1,7 @@
 #pragma once
 
-#include "http/HTTPRequestManager.h"
+#include "http/HTTPClient.h"
+#include "http/JsonResponse.h"
 #include "serialization/JsonAPI.h"
 
 #include <string_view>
@@ -9,15 +10,15 @@ namespace OpenShock::HTTP::JsonAPI {
   /// @brief Links the hub to the account with the given account link code, returns the hub token. Valid response codes: 200, 404
   /// @param hubToken
   /// @return
-  HTTP::Response<Serialization::JsonAPI::AccountLinkResponse> LinkAccount(std::string_view accountLinkCode);
+  JsonResponse<Serialization::JsonAPI::AccountLinkResponse> LinkAccount(HTTP::HTTPClient& client, std::string_view accountLinkCode);
 
   /// @brief Gets the hub info for the given hub token. Valid response codes: 200, 401
   /// @param hubToken
   /// @return
-  HTTP::Response<Serialization::JsonAPI::HubInfoResponse> GetHubInfo(std::string_view hubToken);
+  JsonResponse<Serialization::JsonAPI::HubInfoResponse> GetHubInfo(HTTP::HTTPClient& client, const char* hubToken);
 
   /// @brief Requests a Live Control Gateway to connect to. Valid response codes: 200, 401
   /// @param hubToken
   /// @return
-  HTTP::Response<Serialization::JsonAPI::AssignLcgResponse> AssignLcg(std::string_view hubToken);
+  JsonResponse<Serialization::JsonAPI::AssignLcgResponse> AssignLcg(HTTP::HTTPClient& client, const char* hubToken);
 }  // namespace OpenShock::HTTP::JsonAPI

include/http/JsonParserFn.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+
+class cJSON;
+
+namespace OpenShock::HTTP {
+  template<typename T>
+  using JsonParserFn = std::function<bool(const cJSON* json, T& data)>;
+}