AudioSourceFTP.h

Go to the documentation of this file.

#pragma once
 
#include "AudioSource.h"
#include "AudioTools/CoreAudio/AudioBasic/Str.h"
#include "FTPClient.h"
 
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;
    directory = path != nullptr ? path : "/";
    p_ext = ext;
    setMaxFiles(files);
  }

  bool begin() override {
    TRACED();
    idx = 0;
    file.close();
    file_count = count();
    LOGI("Number of files: %d", file_count);
    return file_count > 0;
  }

  void end() {
    idx = 0;
    file.close();
  }

  Stream* nextStream(int offset) override {
    return selectStream(idx + offset);
  };

  Stream* previousStream(int offset) override { return nextStream(-offset); };

  Stream* selectStream(int index) override {
    if (!isValidIdx(index)) return nullptr;
    Str path;
    if (!findFile(index, path)) {
      LOGW("No file at index %d", index);
      return nullptr;
    }
    idx = index;
    return openFile(path.c_str());
  }

  int index() override { return idx; }

  Stream* selectStream(const char* path) override {
    TRACED();
    if (path == nullptr) return nullptr;
    if (p_ext != nullptr && endsWith(path, p_ext)) return openFile(path);
    directory = path;
    if (!begin()) return nullptr;
    return selectStream(0);
  }

  const char* toStr() override { return file.name(); }

  void setMaxFiles(int maxCount) { max_files = maxCount; }

  void setFileExtension(const char* ext) { p_ext = ext; }

  size_t size() { return file_count < 0 ? 0 : file_count; }
 
 protected:
  FTPClient<ClientType>* p_client = nullptr;
  FTPFile file;
  Str directory;
  int idx = 0;
  int file_count = -1;  // -1: unknown
  size_t max_files = 0;
  const char* p_ext = nullptr;
 
  Stream* openFile(const char* path) {
    file.close();  // close the previous file
    LOGI("open %s", path);
    file = p_client->open(path);
    if (!file) {
      LOGE("Could not open %s", path);
      return nullptr;
    }
    return &file;
  }

  bool findFile(int index, Str& path) {
    if (p_client == nullptr) return false;
    int n = 0;
    for (auto it = p_client->ls(directory.c_str()); it != it.end(); ++it) {
      const char* name = it.fileName();
      if (!endsWith(name, p_ext)) continue;
      if (n++ == index) {
        toPath(name, path);
        return true;
      }
    }
    return false;
  }

  int count() {
    if (p_client == nullptr) return 0;
    int n = 0;
    for (auto it = p_client->ls(directory.c_str()); it != it.end(); ++it) {
      if (!endsWith(it.fileName(), p_ext)) continue;
      if (++n >= max_files && max_files > 0) break;
    }
    return n;
  }

  void toPath(const char* name, Str& result) {
    if (strchr(name, '/') != nullptr) {
      result = name;
      return;
    }
    result = directory.c_str();
    if (!result.isEmpty() && !result.endsWith("/")) result += "/";
    result += name;
  }
 
  bool isValidIdx(int index) {
    if (index < 0) return false;
    if (max_files > 0 && index >= (int)max_files) return false;
    if (file_count >= 0 && index >= file_count) {
      LOGW("index %d is out of range (size: %d)", index, file_count);
      return false;
    }
    return true;
  }
 
  bool endsWith(const char* file, const char* ext) {
    if (file == nullptr) return false;
    if (ext == nullptr) return true;
    return StrView(file).endsWithIgnoreCase(ext);
  }
};
 
}  // namespace audio_tools