AudioSourceSMB.h

Go to the documentation of this file.

#pragma once
 
#include "AudioSource.h"
#include "AudioTools/CoreAudio/AudioBasic/Str.h"
#include "SMB.h"
 
namespace audio_tools {
 
class AudioSourceSMB : public AudioSource {
 public:
  AudioSourceSMB(smb::SMBClient& client, const char* path = "/",
                 const char* ext = nullptr, int files = 0) {
    p_client = &client;
    timeout_auto_next_value = 5000;
    setDirectory(path);
    p_ext = ext;
    setMaxFiles(files);
  }
 
  bool begin() override {
    TRACED();
    end();
    if (p_client == nullptr) return false;
    file_count = 0;
    if (!walk(directory, -1, file_count, nullptr)) {
      LOGE("Could not list directory: %s", directory.c_str());
      file_count = -1;
      return false;
    }
    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;
    int n = 0;
    if (p_client == nullptr || !walk(directory, index, n, &path) ||
        path.isEmpty()) {
      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 (p_client == nullptr || path == nullptr) return nullptr;
    smb::FileInfo info;
    if (!p_client->stat(path, info)) {
      LOGE("Path not found: %s", path);
      return nullptr;
    }
    if (info.isDirectory) {
      setDirectory(path);
      if (!begin()) return nullptr;
      return selectStream(0);
    }
    return openFile(path);
  }
 
  const char* toStr() override { return file.path(); }
 
  void setDirectory(const char* path) {
    directory = "/";
    if (path != nullptr) directory = path;
    if (!directory.startsWith("/")) {
      Str tmp{"/"};
      tmp += directory.c_str();
      directory = tmp.c_str();
    }
  }
 
  void setMaxFiles(int maxCount) { max_files = maxCount; }
 
  void setFileExtension(const char* ext) { p_ext = ext; }
 
  void setBufferSize(size_t size) { buffer_size = size; }
 
  size_t size() { return file_count < 0 ? 0 : file_count; }
 
 protected:
  smb::SMBClient* p_client = nullptr;
  smb::SMBFile file;
  Str directory;
  int idx = 0;
  int file_count = -1;  // -1: unknown
  size_t max_files = 0;
  size_t buffer_size = 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, "r");
    if (!file || file.isDirectory()) {
      LOGE("Could not open %s", path);
      return nullptr;
    }
    if (buffer_size > 0) file.setBufferSize(buffer_size);
    return &file;
  }
 
  bool walk(Str& dir, int target, int& n, Str* result) {
    bool done = false;
    bool ok = p_client->listDir(dir.c_str(), [&](const smb::FileInfo& info) {
      if (info.name.empty() || info.name == "." || info.name == "..")
        return true;
      Str path{dir.c_str()};
      if (!path.endsWith("/")) path += "/";
      path += info.name.c_str();
      if (info.isDirectory) {
        walk(path, target, n, result);
      } else if (endsWith(info.name.c_str(), p_ext)) {
        if (n == target && result != nullptr) {
          *result = path.c_str();
        }
        n++;
      }
      done = (target >= 0 && n > target) || isMaxReached(n);
      return !done;
    });
    return ok;
  }
 
  bool isMaxReached(int n) { return max_files > 0 && n >= (int)max_files; }
 
  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