Change from HTTPClient to WiFiClient (#113)

Author: CelliesProjects

src/OpenStreetMap-esp32.cpp

@@ -205,7 +205,7 @@ void OpenStreetMap::updateCache(const tileList &requiredTiles, uint8_t zoom, Til
     if (!jobs.empty())
     {
         runJobs(jobs);
-        log_d("Updated %i tiles in %lu ms - %i ms/tile", jobs.size(), millis() - startMS, (millis() - startMS) / jobs.size());
+        log_i("Updated %i tiles in %lu ms - %i ms/tile", jobs.size(), millis() - startMS, (millis() - startMS) / jobs.size());
     }
 }
 
@@ -250,7 +250,7 @@ void OpenStreetMap::makeJobList(const tileList &requiredTiles, std::vector<TileJ
 
 void OpenStreetMap::runJobs(const std::vector<TileJob> &jobs)
 {
-    log_d("submitting %i jobs", (int)jobs.size());
+    log_i("submitting %i jobs", (int)jobs.size());
 
     pendingJobs.store(jobs.size());
     for (const TileJob &job : jobs)
@@ -380,46 +380,9 @@ bool OpenStreetMap::fillBuffer(WiFiClient *stream, MemoryBuffer &buffer, size_t
     return true;
 }
 
-std::unique_ptr<MemoryBuffer> OpenStreetMap::urlToBuffer(const char *url, String &result)
+std::unique_ptr<MemoryBuffer> OpenStreetMap::urlToBuffer(const char *url, String &result, ReusableTileFetcher &fetcher)
 {
-    HTTPClientRAII http;
-    if (!http.begin(url))
-    {
-        result = "Failed to initialize HTTP client";
-        return nullptr;
-    }
-
-    const int httpCode = http.GET();
-    if (httpCode != HTTP_CODE_OK)
-    {
-        result = "HTTP Error: " + String(httpCode);
-        return nullptr;
-    }
-
-    const size_t contentSize = http.getSize();
-    if (contentSize < 1)
-    {
-        result = "Empty or chunked response";
-        return nullptr;
-    }
-
-    WiFiClient *stream = http.getStreamPtr();
-    if (!stream)
-    {
-        result = "Failed to get HTTP stream";
-        return nullptr;
-    }
-
-    auto buffer = std::make_unique<MemoryBuffer>(contentSize);
-    if (!buffer->isAllocated())
-    {
-        result = "Failed to allocate buffer";
-        return nullptr;
-    }
-
-    if (!fillBuffer(stream, *buffer, contentSize, result))
-        return nullptr;
-
+    auto buffer = fetcher.fetchToBuffer(url, result);
     return buffer;
 }
 
@@ -429,7 +392,7 @@ void OpenStreetMap::PNGDraw(PNGDRAW *pDraw)
     getPNGCurrentCore()->getLineAsRGB565(pDraw, destRow, PNG_RGB565_BIG_ENDIAN, 0xffffffff);
 }
 
-bool OpenStreetMap::fetchTile(CachedTile &tile, uint32_t x, uint32_t y, uint8_t zoom, String &result)
+bool OpenStreetMap::fetchTile(ReusableTileFetcher &fetcher, CachedTile &tile, uint32_t x, uint32_t y, uint8_t zoom, String &result)
 {
     String url = currentProvider->urlTemplate;
     url.replace("{x}", String(x));
@@ -438,7 +401,7 @@ bool OpenStreetMap::fetchTile(CachedTile &tile, uint32_t x, uint32_t y, uint8_t
     if (currentProvider->requiresApiKey && strstr(url.c_str(), "{apiKey}"))
         url.replace("{apiKey}", currentProvider->apiKey);
 
-    const std::unique_ptr<MemoryBuffer> buffer = urlToBuffer(url.c_str(), result);
+    const std::unique_ptr<MemoryBuffer> buffer = urlToBuffer(url.c_str(), result, fetcher);
     if (!buffer)
         return false;
 
@@ -476,6 +439,7 @@ bool OpenStreetMap::fetchTile(CachedTile &tile, uint32_t x, uint32_t y, uint8_t
 void OpenStreetMap::tileFetcherTask(void *param)
 {
     OpenStreetMap *osm = static_cast<OpenStreetMap *>(param);
+    ReusableTileFetcher fetcher;
     while (true)
     {
         TileJob job;
@@ -486,7 +450,7 @@ void OpenStreetMap::tileFetcherTask(void *param)
             break;
 
         String result;
-        if (!osm->fetchTile(*job.tile, job.x, job.y, job.z, result))
+        if (!osm->fetchTile(fetcher, *job.tile, job.x, job.y, job.z, result))
         {
             const size_t tileByteCount = osm->currentProvider->tileSize * osm->currentProvider->tileSize * 2;
             memset(job.tile->buffer, 0, tileByteCount);

src/OpenStreetMap-esp32.hpp

@@ -37,6 +37,7 @@
 #include "TileJob.hpp"
 #include "MemoryBuffer.hpp"
 #include "HTTPClientRAII.hpp"
+#include "ReusableTileFetcher.hpp"
 #include "fonts/DejaVu9-modded.h"
 
 constexpr uint16_t OSM_BGCOLOR = lgfx::color565(32, 32, 128);
@@ -108,8 +109,8 @@ class OpenStreetMap
     void runJobs(const std::vector<TileJob> &jobs);
     CachedTile *findUnusedTile(const tileList &requiredTiles, uint8_t zoom);
     CachedTile *isTileCached(uint32_t x, uint32_t y, uint8_t z);
-    bool fetchTile(CachedTile &tile, uint32_t x, uint32_t y, uint8_t zoom, String &result);
-    std::unique_ptr<MemoryBuffer> urlToBuffer(const char *url, String &result);
+    bool fetchTile(ReusableTileFetcher &fetcher, CachedTile &tile, uint32_t x, uint32_t y, uint8_t zoom, String &result);
+    std::unique_ptr<MemoryBuffer> urlToBuffer(const char *url, String &result, ReusableTileFetcher &fetcher);
     bool fillBuffer(WiFiClient *stream, MemoryBuffer &buffer, size_t contentSize, String &result);
     bool composeMap(LGFX_Sprite &mapSprite, TileBufferList &tilePointers);
     static void tileFetcherTask(void *param);

src/ReusableTileFetcher.cpp

@@ -0,0 +1,158 @@
+#include "ReusableTileFetcher.hpp"
+
+ReusableTileFetcher::ReusableTileFetcher() {}
+ReusableTileFetcher::~ReusableTileFetcher() { client.stop(); }
+
+std::unique_ptr<MemoryBuffer> ReusableTileFetcher::fetchToBuffer(const String &url, String &result)
+{
+    String host, path;
+    uint16_t port;
+    if (!parseUrl(url, host, path, port))
+    {
+        result = "Invalid URL";
+        return nullptr;
+    }
+
+    if (!ensureConnection(host, port, result))
+        return nullptr;
+
+    if (!sendHttpRequest(host, path))
+    {
+        result = "Failed to send HTTP GET request";
+        return nullptr;
+    }
+
+    size_t contentLength = 0;
+    if (!readHttpHeaders(contentLength, result))
+        return nullptr;
+
+    auto buffer = std::make_unique<MemoryBuffer>(contentLength);
+    if (!buffer->isAllocated())
+    {
+        result = "Buffer allocation failed";
+        return nullptr;
+    }
+
+    if (!readBody(*buffer, contentLength, result))
+        return nullptr;
+
+    return buffer;
+}
+
+bool ReusableTileFetcher::parseUrl(const String &url, String &host, String &path, uint16_t &port)
+{
+    port = 80;
+
+    if (url.startsWith("https://"))
+    {
+        // Not supported in this fetcher (requires WiFiClientSecure)
+        return false;
+    }
+
+    if (!url.startsWith("http://"))
+        return false;
+
+    int idxHostStart = 7; // length of "http://"
+    int idxPath = url.indexOf('/', idxHostStart);
+    if (idxPath == -1)
+        return false;
+
+    host = url.substring(idxHostStart, idxPath);
+    path = url.substring(idxPath);
+    return true;
+}
+
+bool ReusableTileFetcher::ensureConnection(const String &host, uint16_t port, String &result)
+{
+    if (!client.connected() || host != currentHost || port != currentPort)
+    {
+        client.stop(); // Close old connection if mismatched
+        if (!client.connect(host.c_str(), port))
+        {
+            result = "Connection failed to " + host;
+            return false;
+        }
+        currentHost = host;
+        currentPort = port;
+    }
+    return true;
+}
+
+bool ReusableTileFetcher::sendHttpRequest(const String &host, const String &path)
+{
+    client.print(String("GET ") + path + " HTTP/1.1\r\n");
+    client.print(String("Host: ") + host + "\r\n");
+    client.print("User-Agent: OpenStreetMap-esp32/1.0 (+https://github.com/CelliesProjects/OpenStreetMap-esp32)\r\n");
+    client.print("Connection: keep-alive\r\n");
+    client.print("\r\n");
+    return true;
+}
+
+bool ReusableTileFetcher::readHttpHeaders(size_t &contentLength, String &result)
+{
+    String line;
+    contentLength = 0;
+    while (client.connected())
+    {
+        line = client.readStringUntil('\n');
+        line.trim();
+        if (line.length() == 0)
+            break; // End of headers
+
+        if (line.startsWith("Content-Length:"))
+        {
+            contentLength = line.substring(15).toInt();
+        }
+        else if (line.startsWith("HTTP/1.1"))
+        {
+            if (!line.startsWith("HTTP/1.1 200"))
+            {
+                result = "HTTP error: " + line;
+                return false;
+            }
+        }
+    }
+
+    if (contentLength == 0)
+    {
+        result = "Missing or invalid Content-Length";
+        return false;
+    }
+
+    return true;
+}
+
+bool ReusableTileFetcher::readBody(MemoryBuffer &buffer, size_t contentLength, String &result)
+{
+    uint8_t *dest = buffer.get();
+    size_t remaining = contentLength;
+    size_t offset = 0;
+
+    unsigned long start = millis();
+    while (remaining > 0 && millis() - start < 3000)
+    {
+        int len = client.read(dest + offset, remaining);
+        if (len > 0)
+        {
+            remaining -= len;
+            offset += len;
+        }
+        else if (len < 0)
+        {
+            result = "Read error";
+            return false;
+        }
+        else
+        {
+            delay(1);
+        }
+    }
+
+    if (remaining > 0)
+    {
+        result = "Incomplete read";
+        return false;
+    }
+
+    return true;
+}

src/ReusableTileFetcher.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <WiFiClient.h>
+#include <memory>
+#include "MemoryBuffer.hpp" // your existing class
+
+class ReusableTileFetcher {
+public:
+    ReusableTileFetcher();
+    ~ReusableTileFetcher();
+
+    // Not copyable/movable
+    ReusableTileFetcher(const ReusableTileFetcher &) = delete;
+    ReusableTileFetcher &operator=(const ReusableTileFetcher &) = delete;
+
+    std::unique_ptr<MemoryBuffer> fetchToBuffer(const String &url, String &result);
+
+private:
+    WiFiClient client;
+    String currentHost;
+    uint16_t currentPort = 80;
+
+    bool parseUrl(const String &url, String &host, String &path, uint16_t &port);
+    bool ensureConnection(const String &host, uint16_t port, String &result);
+    bool sendHttpRequest(const String &host, const String &path);
+    bool readHttpHeaders(size_t &contentLength, String &result);
+    bool readBody(MemoryBuffer &buffer, size_t contentLength, String &result);
+};