DLNAControlPointMediaServer.h

Go to the documentation of this file.

// Header-only control point helper for MediaServer devices
#pragma once
 
#include "dlna/common/Action.h"
#include "dlna/clients/DLNAControlPoint.h"
 
namespace tiny_dlna {
 
class DLNAControlPointMediaServer {
 public:
  typedef void (*XMLCallback)(const char* name, const char* test,
                              const char* attributes);
  typedef void (*NotificationCallback)(void* reference, const char* sid,
                                       const char* varName,
                                       const char* newValue);
 
  DLNAControlPointMediaServer() = default;
  DLNAControlPointMediaServer(DLNAControlPoint& mgr, IHttpRequest& http,
                              IUDPService& udp)
      : p_mgr(&mgr), p_http(&http), p_udp(&udp) {}
 
  void setDLNAControlPoint(DLNAControlPoint& m) { p_mgr = &m; }
 
  void setLocalURL(Url url) { p_mgr->setLocalURL(url); }
 
  void setLocalURL(IPAddress url, int port=9001, const char* path="")  {
    this->p_mgr->setLocalURL(url, port, path);
  }
 
  bool begin(uint32_t minWaitMs = 3000, uint32_t maxWaitMs = 60000) {
    DlnaLogger.log(
        DlnaLogLevel::Info,
        "DLNAControlPointMediaServer::begin: device_type_filter='%s'",
        device_type_filter ? device_type_filter : "(null)");
    if (!p_mgr) {
      DlnaLogger.log(DlnaLogLevel::Error, "mgr instance not set");
      return false;
    }
    if (!p_http) {
      DlnaLogger.log(DlnaLogLevel::Error, "http instance not set");
      return false;
    }
    if (!p_udp) {
      DlnaLogger.log(DlnaLogLevel::Error, "udp instance not set");
      return false;
    }
 
    return p_mgr->begin(*p_http, *p_udp, device_type_filter, minWaitMs,
                        maxWaitMs);
  }
 
  void setHttp(IHttpRequest& http) { p_http = &http; }
 
  void setUdp(IUDPService& udp) { p_udp = &udp; }
 
  int getDeviceCount() {
    // count only devices matching the device_type_filter
    int count = 0;
    for (auto& d : p_mgr->getDevices()) {
      const char* dt = d.getDeviceType();
      if (!device_type_filter || StrView(dt).contains(device_type_filter))
        count++;
    }
    return count;
  }
 
  const ActionReply& getLastReply() const { return last_reply; }
 
  void setDeviceIndex(int idx) { p_mgr->setDeviceIndex(idx); }
 
  bool subscribe() { return p_mgr->subscribe(); }  
 
 
  void setNotificationsActive(bool flag) {
    p_mgr->setNotificationsActive(flag);
  }
 
  void setNotificationCallback(
      std::function<void(const char* sid, const char* varName,
                         const char* newValue, void* reference)>
          cb,
      void* ref = nullptr)  {
    p_mgr->setNotificationsActive(true);
    p_mgr->setEventSubscriptionCallback(cb, ref);
  }
 
  void setDeviceTypeFilter(const char* filter) {
    device_type_filter = filter ? filter : device_type_filter_default;
  }
 
  void setReference(void* ref) { reference = ref; }
 
  bool browse(int startingIndex, int requestedCount, ContentQueryType queryType,
              XMLCallback XMLCallback, int& numberReturned, int& totalMatches,
              int& updateID) {
    // Register item callback
    this->p_mgr->onResultNode(XMLCallback);
    // Build and post browse action
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return false;
    ActionRequest& act =
        createBrowseAction(svc, queryType, startingIndex, requestedCount);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return false;
 
    // parse numeric result fields
    parseNumericFields(last_reply, numberReturned, totalMatches, updateID);
 
    return true;
  }
 
  bool search(int startingIndex, int requestedCount, XMLCallback XMLCallback,
              int& numberReturned, int& totalMatches, int& updateID,
              const char* searchCriteria = "", const char* filter = "",
              const char* sortCriteria = "") {
    // Register item callback
    this->p_mgr->onResultNode(XMLCallback);
 
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return false;
 
    ActionRequest& act =
        createSearchAction(svc, searchCriteria, filter, startingIndex,
                           requestedCount, sortCriteria);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return false;
 
    parseNumericFields(last_reply, numberReturned, totalMatches, updateID);
    return true;
  }
 
  int getSystemUpdateID() {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "ControlPointMediaServer::getSystemUpdateID");
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return -1;
    ActionRequest act{svc, "GetSystemUpdateID"};
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return -1;
    const char* v = last_reply.findArgument("Id");
    if (!v) v = last_reply.findArgument("Id");
    return v ? atoi(v) : -1;
  }
 
  const char* getSearchCapabilities() {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "ControlPointMediaServer::getSearchCapabilities");
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return nullptr;
    ActionRequest act{svc, "GetSearchCapabilities"};
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return nullptr;
    return last_reply.findArgument("SearchCaps");
  }
 
  const char* getSortCapabilities() {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "ControlPointMediaServer::getSortCapabilities");
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return nullptr;
    ActionRequest act{svc, "GetSortCapabilities"};
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return nullptr;
    return last_reply.findArgument("SortCaps");
  }
 
  const char* getProtocolInfo() {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "ControlPointMediaServer::getProtocolInfo");
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ConnectionManager");
    if (!svc) return nullptr;
    ActionRequest act{svc, "GetProtocolInfo"};
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return nullptr;
    return last_reply.findArgument("Source");
  }
 
  void setObjectID(const char* id) { object_id = id; }
 
  const char* getObjectID() const { return object_id; }
 
 protected:
  DLNAControlPoint* p_mgr = nullptr;
  const char* device_type_filter_default =
      "urn:schemas-upnp-org:device:MediaServer:1";
  const char* device_type_filter = device_type_filter_default;
  ActionReply last_reply;
  void* reference = nullptr;
  const char* object_id = "0";
  // transport references (optional) - must be set before calling begin()
  IHttpRequest* p_http = nullptr;
  IUDPService* p_udp = nullptr;
 
  static void processNotification(void* reference, const char* sid,
                                  const char* varName, const char* newValue) {
    // Log every notification invocation for debugging/visibility
    DlnaLogger.log(DlnaLogLevel::Info,
                   "processNotification sid='%s' var='%s' value='%s'",
                   sid ? sid : "(null)", varName ? varName : "(null)",
                   newValue ? newValue : "(null)");
  }
 
  DLNAServiceInfo& selectService(const char* id) {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "ControlPointMediaServer::selectService: id='%s'", id);
    // Build list of devices matching the optional filter
    DLNAServiceInfo& s = p_mgr->getDevice().getService(id);
    if (s) return s;
 
    // fallback: global search
    return p_mgr->getService(id);
  }
 
  ActionRequest& createBrowseAction(DLNAServiceInfo& svc,
                                    ContentQueryType queryType,
                                    int startingIndex, int requestedCount) {
    const char* browseFlag = (queryType == ContentQueryType::BrowseMetadata)
                                 ? "BrowseMetadata"
                                 : "BrowseDirectChildren";
    static ActionRequest act{svc, "Browse"};
    // Use the canonical argument name expected by ContentDirectory: "ObjectID"
    act.addArgument("ObjectID", object_id);
    act.addArgument("BrowseFlag", browseFlag);
    act.addArgument("Filter", "");
    char buf[32];
    snprintf(buf, sizeof(buf), "%d", startingIndex);
    act.addArgument("StartingIndex", buf);
    snprintf(buf, sizeof(buf), "%d", requestedCount);
    act.addArgument("RequestedCount", buf);
    act.addArgument("SortCriteria", "");
    return act;
  }
 
  ActionRequest& createSearchAction(DLNAServiceInfo& svc,
                                    const char* searchCriteria,
                                    const char* filter, int startingIndex,
                                    int requestedCount,
                                    const char* sortCriteria) {
    static ActionRequest act{svc, "Search"};
    act.addArgument("ContainerID", object_id);
    act.addArgument("SearchCriteria", searchCriteria ? searchCriteria : "");
    act.addArgument("Filter", filter ? filter : "");
    char buf[32];
    snprintf(buf, sizeof(buf), "%d", startingIndex);
    act.addArgument("StartingIndex", buf);
    snprintf(buf, sizeof(buf), "%d", requestedCount);
    act.addArgument("RequestedCount", buf);
    act.addArgument("SortCriteria", sortCriteria ? sortCriteria : "");
    return act;
  }
 
  void parseNumericFields(ActionReply& reply, int& numberReturned,
                          int& totalMatches, int& updateID) {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "ControlPointMediaServer::parseNumericFields");
    const char* nret = reply.findArgument("NumberReturned");
    const char* tmatch = reply.findArgument("TotalMatches");
    const char* uid = reply.findArgument("UpdateID");
    numberReturned = nret ? atoi(nret) : 0;
    totalMatches = tmatch ? atoi(tmatch) : 0;
    updateID = uid ? atoi(uid) : 0;
  }
};
 
}  // namespace tiny_dlna