ICYStreamBuffered.h

#pragma once
#include "AudioConfig.h" 
#if defined(USE_CONCURRENCY) && defined(USE_URL_ARDUINO)
#include "ICYStream.h"
 
namespace audio_tools {
 
class ICYStreamBuffered : public AbstractURLStream {
 public:
  ICYStreamBuffered(int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACEI();
    urlStream.setReadBufferSize(readBufferSize);
    taskStream.setInput(urlStream);
  }
 
  ICYStreamBuffered(Client& clientPar,
                    int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACEI();
    urlStream.setReadBufferSize(readBufferSize);
    setClient(clientPar);
    taskStream.setInput(urlStream);
  }
 
  ICYStreamBuffered(const char* network, const char* password,
                    int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACEI();
    urlStream.setReadBufferSize(readBufferSize);
    setSSID(network);
    setPassword(password);
    taskStream.setInput(urlStream);
  }
 
  virtual bool setMetadataCallback(void (*fn)(MetaDataType info,
                                              const char* str,
                                              int len)) override {
    TRACED();
    return urlStream.setMetadataCallback(fn);
  }
 
  void setBufferSize(int bufferSize, int bufferCount){
    taskStream.setBufferSize(bufferSize, bufferCount);
  }
 
  virtual bool begin(const char* urlStr, const char* acceptMime = nullptr,
                     MethodID action = GET, const char* reqMime = "",
                     const char* reqData = "") override {
    TRACED();
    // start real stream
    bool result = urlStream.begin(urlStr, acceptMime, action, reqMime, reqData);
    // start reader task
    taskStream.begin();
    return result;
  }
 
  virtual void end() override {
    TRACED();
    taskStream.end();
    urlStream.end();
  }
 
  virtual int available() override { return taskStream.available(); }
 
  virtual size_t readBytes(uint8_t* data, size_t len) override {
    size_t result = taskStream.readBytes(data, len);
    LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
    return result;
  }
 
  virtual int read() override { return taskStream.read(); }
 
  virtual int peek() override { return taskStream.peek(); }
 
  virtual void flush() override {}
 
  virtual HttpRequest& httpRequest() override {
    return urlStream.httpRequest();
  }
 
  void setClient(Client& client) override { urlStream.setClient(client); }
 
  void setSSID(const char* ssid) override { urlStream.setSSID(ssid); }
 
  void setPassword(const char* password) override {
    urlStream.setPassword(password);
  }
  void setPowerSave(bool ps) override { urlStream.setPowerSave(ps); }
 
 protected:
  BufferedTaskStream taskStream;
  ICYStream urlStream;
};
 
}  // namespace audio_tools
 
#endif  // USE_TASK