SdFatContentProvider.h

Go to the documentation of this file.

 
 
#include "DLNA.h"
#include "SdFatDirectoryTree.h"
 
namespace tiny_dlna {
 
template <typename FS>
class SdFatContentProvider {
 public:
  bool begin(FS& fs, const char* rootPath) {
    return directoryTree.begin(fs, rootPath);
  }
 
  void end() {
    directoryTree.end();
    resultNodes_.clear();
  }
 
  size_t size() { return directoryTree.size(); }
 
  void prepareData(const char* objectID, ContentQueryType queryType,
                   const char* filter, int startingIndex, int requestedCount,
                   const char* sortCriteria, int& numberReturned,
                   int& totalMatches, int& updateID, void* reference) {
    // Store parameters in class variables
    objectID_ = objectID;
    queryType_ = queryType;
    filter_ = filter;
    startingIndex_ = startingIndex;
    requestedCount_ = requestedCount;
    sortCriteria_ = sortCriteria;
    reference_ = reference;
 
    // Clear previous results
    resultNodes_.clear();
 
    // Calculate actual values based on directory tree and query type
    updateID = 0;  // Can increment this when content changes
 
    if (queryType == ContentQueryType::BrowseMetadata) {
      // Metadata for a single object
      TreeNode* node =
          objectID ? findNodeByObjectID(objectID) : &directoryTree.root();
      if (node && !isHidden(node)) {
        resultNodes_.push_back(node);
        totalMatches = 1;
        numberReturned = 1;
      } else {
        totalMatches = 0;
        numberReturned = 0;
      }
    } else if (queryType == ContentQueryType::BrowseChildren) {
      // Browse children of a container (directory)
      TreeNode* parentNode =
          objectID ? findNodeByObjectID(objectID) : &directoryTree.root();
      if (parentNode) {
        // Collect all children, filter out hidden
        resultNodes_.clear();
        for (auto* child : parentNode->children) {
          if (!isHidden(child)) {
            resultNodes_.push_back(child);
          }
        }
        totalMatches = static_cast<int>(resultNodes_.size());
 
        // Apply pagination
        int available = totalMatches - startingIndex;
        if (available < 0) available = 0;
        numberReturned = (requestedCount == 0)
                             ? available
                             : std::min(requestedCount, available);
      } else {
        totalMatches = 0;
        numberReturned = 0;
      }
    } else {
      // Search - return all files, filter out hidden
      auto allFiles = directoryTree.getAllFiles();
      resultNodes_.clear();
      for (auto* node : allFiles) {
        if (!isHidden(node)) {
          resultNodes_.push_back(node);
        }
      }
      totalMatches = static_cast<int>(resultNodes_.size());
 
      // Apply pagination
      int available = totalMatches - startingIndex;
      if (available < 0) available = 0;
      numberReturned = (requestedCount == 0)
                           ? available
                           : std::min(requestedCount, available);
    }
 
    DlnaLogger.log(DlnaLogLevel::Info,
                   "Number of results: Total=%d, Returned=%d", totalMatches,
                   numberReturned);
  }
 
  bool isHidden(TreeNode* node) const {
    return node == nullptr || (!node->file_name.empty() && node->file_name[0] == '.');
  }
 
  bool getData(int index, MediaItem& item, void* reference = nullptr) {
    // Calculate the actual index into resultNodes_
    int adjustedIndex = startingIndex_ + index;
 
    // Validate index
    if (adjustedIndex < 0 ||
        adjustedIndex >= static_cast<int>(resultNodes_.size())) {
      return false;
    }
 
    TreeNode* node = resultNodes_[adjustedIndex];
    if (!node) return false;
 
    // Populate MediaItem from TreeNode
    // Use member strings for pointer lifetime
    currentId_ = std::to_string(node->id);
    item.id = currentId_.c_str();
 
    // Parent ID
    if (node->parent) {
      currentParentId_ = std::to_string(node->parent->id);
      item.parentID = currentParentId_.c_str();
    } else {
      item.parentID = "0";
    }
 
    item.title = node->file_name.c_str();
    item.restricted = true;
 
    if (node->is_dir) {
      item.itemClass = MediaItemClass::Folder;
      item.resourceURI = nullptr;
      item.mimeType = nullptr;
    } else {
      // File - determine class from MIME type
      currentMime_ = node->getMime();
      if (currentMime_.empty()) currentMime_ = "application/octet-stream";
      item.mimeType = currentMime_.c_str();
 
      if (currentMime_.find("audio") != std::string::npos) {
        item.itemClass = MediaItemClass::Music;
      } else if (currentMime_.find("video") != std::string::npos) {
        item.itemClass = MediaItemClass::Video;
      } else if (currentMime_.find("image") != std::string::npos) {
        item.itemClass = MediaItemClass::Photo;
      } else {
        item.itemClass = MediaItemClass::Unknown;
      }
 
      // Resource URI: baseURL + basePath + ?ID=id
      char urlBuffer[80];
      snprintf(urlBuffer, sizeof(urlBuffer), "/%s?ID=%u", path, node->id);
      currentPath_ = urlBuffer;
      item.resourceURI = currentPath_.c_str();
    }
 
    item.albumArtURI = nullptr;
 
    return true;
  }
 
  const char* getPath() {
    return path;
  } 
 
  void setPath(const char* p) {
    path = p;
  } 
 
  TreeNode& getTreeNodeById(uint32_t id) {
    return directoryTree.getTreeNodeById(id);
  }
 
 protected:
  SdFatDirectoryTree<FS> directoryTree;
  const char* path = "/file";
 
  // Store query parameters for getData
  const char* objectID_ = nullptr;
  ContentQueryType queryType_;
  const char* filter_ = nullptr;
  int startingIndex_ = 0;
  int requestedCount_ = 0;
  const char* sortCriteria_ = nullptr;
  void* reference_ = nullptr;
 
  // Collected results from prepareData
  std::vector<TreeNode*, AllocatorPSRAM<TreeNode*>> resultNodes_;
 
  // String storage for MediaItem pointers (lifetime managed by class)
  stringPSRAM currentId_;        
  stringPSRAM currentParentId_;  
  stringPSRAM currentPath_;      
  stringPSRAM currentMime_;      
 
  TreeNode* findNodeByObjectID(const char* objectID) {
    if (!objectID) return nullptr;
    uint32_t id = std::stoul(objectID);
    return &directoryTree.getTreeNodeById(id);
  }
};
 
}  // namespace tiny_dlna