URLStream.h

Go to the documentation of this file.

#pragma once
 
#include "AudioToolsConfig.h"
 
#if defined(USE_WIFI)
#include "AudioTools/Communication/Network/Network.h"
#endif
 
#include "AudioTools/CoreAudio/AudioBasic/Str.h"
#include "AudioTools/Communication/HTTP/AbstractURLStream.h"
#include "AudioTools/Communication/HTTP/HttpRequest.h"
#include "AudioTools/Communication/HTTP/URLStreamBufferedT.h"
 
namespace audio_tools {
 
class URLStream : public AbstractURLStream {
 public:
  URLStream(int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACED();
    setReadBufferSize(readBufferSize);
  }
 
  URLStream(Client& clientPar, int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACED();
    setReadBufferSize(readBufferSize);
    setClient(clientPar);
  }
 
  URLStream(const char* network, const char* password,
            int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACED();
    setReadBufferSize(readBufferSize);
    setSSID(network);
    setPassword(password);
  }
 
  URLStream(const URLStream&) = delete;
 
  ~URLStream() {
    TRACED();
    end();
    if (client_secure != nullptr) {
      delete client_secure;
      client_secure = nullptr;
    }
    if (client_insecure != nullptr) {
      delete client_insecure;
      client_insecure = nullptr;
    }
  }
 
  void setClient(Client& clientPar) override { client = &clientPar; }
 
  void setSSID(const char* ssid) override { this->network = ssid; }
 
  void setPassword(const char* password) override { this->password = password; }
 
  void setReadBufferSize(int readBufferSize) {
    read_buffer_size = readBufferSize;
  }
 
  virtual bool begin(const char* urlStr, const char* acceptMime = nullptr,
                     MethodID action = GET, const char* reqMime = "",
                     const char* reqData = "") override {
    LOGI("%s: %s", LOG_METHOD, urlStr);
    if (!preProcess(urlStr, acceptMime)) {
      LOGE("preProcess failed");
      return false;
    }
    int result = process<const char*>(action, url, reqMime, reqData);
    if (result > 0) {
      content_length = request.contentLength();
      LOGI("contentLength: %d", (int)content_length);
      if (content_length >= 0 && wait_for_data) {
        waitForData(client_timeout);
      }
    }
    total_read = 0;
    active = result == 200;
    LOGI("==> http result: %d", result);
    return active;
  }
 
  virtual bool begin(const char* urlStr, const char* acceptMime,
                     MethodID action, const char* reqMime, Stream& reqData,
                     int len = -1) {
    LOGI("%s: %s", LOG_METHOD, urlStr);
    if (!preProcess(urlStr, acceptMime)) {
      LOGE("preProcess failed");
      return false;
    }
    int result = process<Stream&>(action, url, reqMime, reqData, len);
    if (result > 0) {
      content_length = request.contentLength();
      LOGI("size: %d", (int)content_length);
      if (content_length >= 0 && wait_for_data) {
        waitForData(client_timeout);
      }
    }
    total_read = 0;
    active = result == 200;
    LOGI("==> http status: %d", result);
    return active;
  }
 
  virtual void end() override {
    if (active) request.stop();
    active = false;
    clear();
  }
 
  virtual int available() override {
    if (!active) return 0;
 
    int result = request.available();
    LOGD("available: %d", result);
    return result;
  }
 
  virtual size_t readBytes(uint8_t* data, size_t len) override {
    if (!active) return 0;
 
    int read = request.read(data, len);
    if (read < 0) {
      read = 0;
    }
    total_read += read;
    LOGD("readBytes %d -> %d", (int)len, read);
    return read;
  }
 
  virtual int read() override {
    if (!active) return -1;
    // lazy allocation since this is rarely used
    read_buffer.resize(read_buffer_size);
 
    fillBuffer();
    total_read++;
    return isEOS() ? -1 : read_buffer[read_pos++];
  }
 
  virtual int peek() override {
    if (!active) return -1;
    // lazy allocation since this is rarely used
    read_buffer.resize(read_buffer_size);
 
    fillBuffer();
    return isEOS() ? -1 : read_buffer[read_pos];
  }
 
  virtual void flush() override {}
 
  virtual size_t write(uint8_t) override { return not_supported(0); }
 
  virtual size_t write(const uint8_t*, size_t len) override {
    return not_supported(0);
  }
 
  virtual HttpRequest& httpRequest() override { return request; }
 
  operator bool() override { return active && request.isReady(); }
 
  virtual void setTimeout(int ms) { client_timeout = ms; }
 
  void setPowerSave(bool ps) override { is_power_save = ps; }
 
  void setAutoCreateLines(bool flag) {
    httpRequest().reply().setAutoCreateLines(flag);
  }
 
  void setConnectionClose(bool close) override {
    httpRequest().setConnection(close ? CON_CLOSE : CON_KEEP_ALIVE);
  }
 
  void clear() {
    httpRequest().reply().clear();
    httpRequest().header().clear();
    read_buffer.resize(0);
    read_pos = 0;
    read_size = 0;
  }
 
  void addRequestHeader(const char* key, const char* value) override {
    request.header().put(key, value);
  }
 
  const char* getReplyHeader(const char* key) override {
    return request.reply().get(key);
  }
 
  void setOnConnectCallback(void (*callback)(
      HttpRequest& request, Url& url, HttpRequestHeader& request_header)) {
    request.setOnConnectCallback(callback);
  }
 
  void setWaitForData(bool flag) { wait_for_data = flag; }
 
  int contentLength() override { return content_length; }
 
  size_t totalRead() override { return total_read; }
 
  bool waitForData (int timeout) override{
    TRACED();
    uint32_t end = millis() + timeout;
    if (request.available() == 0) {
      LOGI("Request written ... waiting for reply");
      while (request.available() == 0) {
        if (millis() > end) break;
        // stop waiting if we got an error
        int rc = request.reply().statusCode();
         if (rc >= 300) {
          LOGE("Error code %d recieved: stop waiting for reply", rc);
          break;
        }
        delay(500);
      }
    }
    int avail = request.available();
    LOGD("available: %d", avail);
    return avail > 0;
  }
 
  const char* urlStr() override { return url_str.c_str(); }
 
  void setCACert(const char* cert) override{
    if (client_secure!=nullptr) client_secure->setCACert(cert);
  }
 
  size_t size() { return content_length; }
 
 protected:
  HttpRequest request;
  Str url_str;
  Url url;
  long content_length = 0;
  long total_read = 0;
  // buffered single byte read
  Vector<uint8_t> read_buffer{0};
  uint16_t read_buffer_size = DEFAULT_BUFFER_SIZE;
  uint16_t read_pos = 0;
  uint16_t read_size = 0;
  bool active = false;
  bool wait_for_data = true;
  Client* client = nullptr; // client defined via setClient
  WiFiClient* client_insecure = nullptr; // wifi client for http
  WiFiClientSecure* client_secure = nullptr; // wifi client for https
  int client_timeout = URL_CLIENT_TIMEOUT;                  // 60000;
  unsigned long handshake_timeout = URL_HANDSHAKE_TIMEOUT;  // 120000
  bool is_power_save = false;
  // optional
  const char* network = nullptr;
  const char* password = nullptr;
 
  bool preProcess(const char* urlStr, const char* acceptMime) {
    TRACED();
    url_str = urlStr;
    url.setUrl(url_str.c_str());
    int result = -1;
 
    // close it - if we have an active connection
    if (active) end();
 
    // optional: login if necessary if no external client is defined
    if (client == nullptr){
      if (!login()){
        LOGE("Not connected");
        return false;
      }
    }
 
    // request.reply().setAutoCreateLines(false);
    if (acceptMime != nullptr) {
      request.setAcceptMime(acceptMime);
    }
 
    // setup client
    Client& client = getClient(url.isSecure());
    request.setClient(client);
    request.setTimeout(client_timeout);
 
#if defined(ESP32)
    // Performance optimization for ESP32
    if (!is_power_save) {
      esp_wifi_set_ps(WIFI_PS_NONE);
    }
#endif
 
    return true;
  }
 
  template <typename T>
  int process(MethodID action, Url& url, const char* reqMime, T reqData,
              int len = -1) {
    TRACED();
    // keep icy across redirect requests ?
    const char* icy = request.header().get("Icy-MetaData");
 
    int status_code = request.process(action, url, reqMime, reqData, len);
    // redirect
    while (request.reply().isRedirectStatus()) {
      const char* redirect_url = request.reply().get(LOCATION);
      if (redirect_url != nullptr) {
        LOGW("Redirected to: %s", redirect_url);
        url.setUrl(redirect_url);
        Client* p_client = &getClient(url.isSecure());
        p_client->stop();
        request.setClient(*p_client);
        if (icy) {
          request.header().put("Icy-MetaData", icy);
        }
        status_code = request.process(action, url, reqMime, reqData, len);
      } else {
        LOGE("Location is null");
        break;
      }
    }
    return status_code;
  }
 
  Client& getClient(bool isSecure) {
    if (isSecure) {
      if (client_secure == nullptr) {
        client_secure = new WiFiClientSecure();
        client_secure->setInsecure();
        client_secure->setTimeout(client_timeout);
#ifdef ESP32
  #if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3,0,0)
        client_secure->setConnectionTimeout(client_timeout);
  #endif 
        client_secure->setHandshakeTimeout(handshake_timeout);
#endif
#ifdef RP2040_HOWER
        client_secure->setTLSConnectTimeout(client_timeout);
#endif
      }
      LOGI("WiFiClientSecure");
      return *client_secure;
    }
    if (client_insecure == nullptr) {
      client_insecure = new WiFiClient();
      client_insecure->setTimeout(client_timeout);
#ifdef ESP32
  #if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3,0,0)
      client_insecure->setConnectionTimeout(client_timeout);
  #else
      client_insecure->setTimeout(client_timeout);
  #endif 
#endif
      LOGI("WiFiClient");
    }
    return *client_insecure;
  }
 
  inline void fillBuffer() {
    if (isEOS()) {
      // if we consumed all bytes we refill the buffer
      read_size = readBytes(&read_buffer[0], read_buffer_size);
      read_pos = 0;
    }
  }
 
  inline bool isEOS() { return read_pos >= read_size; }
 
  bool login() {
    if (network != nullptr && password != nullptr &&
        WiFi.status() != WL_CONNECTED) {
      TRACEI();
      WiFi.begin(network, password);
      while (WiFi.status() != WL_CONNECTED) {
        Serial.print(".");
        delay(500);
      }
      Serial.println();
      delay(10);
      return WiFi.status() == WL_CONNECTED;
    }
    return WiFi.status() == WL_CONNECTED;
  }
};
 
 
#if defined(USE_CONCURRENCY)
using URLStreamBuffered = URLStreamBufferedT<URLStream>;
 
#endif
 
}  // namespace audio_tools