AudioSourceFTP.h

#include "FTPClient.h"
#include "AudioSource.h"
#include "vector"
 
namespace audio_tools {
 
template <class ClientType>
class AudioSourceFTP : public AudioSource {
 public:
  AudioSourceFTP(FTPClient<ClientType>& client, const char* path, const char* ext,
                 int files = 0) {
    p_client = &client;
    timeout_auto_next_value = 5000;
    if (path) p_path = path;
    setMaxFiles(files);
  }
  AudioSourceFTP(FTPClient<ClientType>& client, const char* path, const char* ext, {…}
 
  void begin()override {
    TRACED();
    idx = 0;
    files.clear();
    addDirectory(p_path);
  }
  void begin()override  {…}
 
  void end() {
    idx = 0;
    files.clear();
  }
  void end() {…}
 
  Stream* nextStream(int offset) override {
    int tmp_idx = idx + offset;
    if (!isValidIdx(tmp_idx)) return nullptr;
    return selectStream(tmp_idx);
  };
  Stream* nextStream(int offset) override  {…}
 
  Stream* previousStream(int offset) override { return nextStream(-offset); };
 
  Stream* selectStream(int index) override {
    if (!isValidIdx(index)) return nullptr;
    idx = index;
    if (file) {
       file.close();  // close the previous file
    }
    file = p_client->open(files[idx].name());
    return &file;
  }
  Stream* selectStream(int index) override  {…}
 
  int index() override { return idx; }
 
  Stream* selectStream(const char* path) override {
    TRACED();
    files.clear();
    idx = 0;
    addDirectory(path);
    return selectStream(0);
  }
  Stream* selectStream(const char* path) override  {…}
 
  const char* toStr() override {
    return file.name();
  }
  const char* toStr() override  {…}
 
  void setMaxFiles(int maxCount) { max_files = maxCount; }
 
  bool addDirectory(const char* path) {
    TRACED();
    if (p_client == nullptr) return false;
    FTPFile dir = p_client->open(path);
    addFiles(dir, 1);
    return true;
  }
  bool addDirectory(const char* path) {…}
 
  size_t size() { return files.size(); }
 
 protected:
  std::vector<FTPFile> files;
  FTPClient<ClientType>* p_client = nullptr;
  FTPFile file;
  int idx = 0;
  size_t max_files = 0;
  const char* p_ext = nullptr;
  const char* p_path = "/";
  bool is_first = true;
 
  void addFiles(FTPFile& dir, int level) {
    if (!endsWith(dir.name(), p_ext)) {
      LOGI("adding file %s", dir.name());
      files.push_back(std::move(dir));
    } else {
      for (const auto& file : p_client->ls(dir.name())) {
        if (endsWith(file.name(), p_ext)) {
          LOGI("adding file %s", file.name());
          files.push_back(std::move(file));
        }
        if (max_files > 0 && files.size() >= max_files) {
          LOGI("max files reached: %d", max_files);
          return;  // stop if we reached the max number of files
        }
      }
    }
  }
  void addFiles(FTPFile& dir, int level) {…}
 
  bool isValidIdx(int index) {
    if (index < 0) return false;
    if (index >= files.size()) {
      LOGE("index %d is out of range (size: %d)", index, files.size());
      return false;
    }
    return true;
  }
 
  bool endsWith(const char* file, const char* ext) {
    if (file == nullptr) return false;
    if (p_ext == nullptr) return true;
    return (StrView(file).endsWith(ext));
  }
};
class AudioSourceFTP : public AudioSource {…};
 
}  // namespace audio_tools