ControlPointMediaServer.h

Go to the documentation of this file.

// Header-only control point helper for MediaServer devices
#pragma once
 
#include "dlna/DLNAControlPoint.h"
#include "dlna/devices/MediaServer/MediaServer.h"
#include "dlna/service/Action.h"
 
namespace tiny_dlna {
 
class ControlPointMediaServer {
 public:
  typedef void (*ItemCallback)(const MediaItem& item, void* ref);
  typedef void (*NotificationCallback)(void* reference, const char* sid,
                                       const char* varName,
                                       const char* newValue);
 
  ControlPointMediaServer(DLNAControlPoint& mgr) : mgr(mgr) {}
 
  bool begin(DLNAHttpRequest& http, IUDPService& udp, uint32_t minWaitMs = 3000,
             uint32_t maxWaitMs = 60000) {
    DlnaLogger.log(DlnaLogLevel::Info,
                   "ControlPointMediaServer::begin device_type_filter='%s'",
                   device_type_filter ? device_type_filter : "(null)");
    return mgr.begin(http, udp, device_type_filter, minWaitMs, maxWaitMs);
  }
 
  int getDeviceCount() {
    // count only devices matching the device_type_filter
    int count = 0;
    for (auto& d : 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) { device_index = idx; }
 
  bool subscribeNotifications(int timeoutSeconds = 60,
                              NotificationCallback cb = nullptr) {
    mgr.setReference(this);
    // register provided callback or fallback to the default processNotification
    if (cb)
      mgr.onNotification(cb);
    else
      mgr.onNotification(processNotification);
    auto& device = mgr.getDevice(device_index);
    return mgr.subscribeNotifications(device, timeoutSeconds);
  }
 
  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, ItemCallback itemCallback,
              int& numberReturned, int& totalMatches, int& updateID,
              const char* browseFlag = nullptr) {
    // Build and post browse action
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return false;
    ActionRequest &act =
        createBrowseAction(svc, browseFlag, startingIndex, requestedCount);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return false;
 
    // parse numeric result fields
    parseNumericFields(last_reply, numberReturned, totalMatches, updateID);
 
    // process DIDL Result and call callback per item
    const char* resultXml = findArgument(last_reply, "Result");
    if (resultXml) processResult(resultXml, itemCallback);
    return true;
  }
 
  int getSystemUpdateID() {
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return -1;
    ActionRequest act(svc, "GetSystemUpdateID");
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return -1;
    const char* v = findArgument(last_reply, "Id");
    if (!v) v = findArgument(last_reply, "Id");
    return v ? atoi(v) : -1;
  }
 
  const char* getSearchCapabilities() {
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return nullptr;
    ActionRequest act(svc, "GetSearchCapabilities");
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return nullptr;
    return findArgument(last_reply, "SearchCaps");
  }
 
  const char* getSortCapabilities() {
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ContentDirectory");
    if (!svc) return nullptr;
    ActionRequest act(svc, "GetSortCapabilities");
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return nullptr;
    return findArgument(last_reply, "SortCaps");
  }
 
  const char* getProtocolInfo() {
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:ConnectionManager");
    if (!svc) return nullptr;
    ActionRequest act(svc, "GetProtocolInfo");
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return nullptr;
    return findArgument(last_reply, "Source");
  }
 
  void setObjectID(const char* id) { object_id = id; }
 
  const char* getObjectID() const { return object_id; }
 
 protected:
  DLNAControlPoint& mgr;
  int device_index = 0;
  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;
  StringRegistry strings;
  void* reference = nullptr;
  const char* object_id = "0";
 
  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) {
    // Build list of devices matching the optional filter
    Vector<DLNADeviceInfo>& all = mgr.getDevices();
    int idx = 0;
    for (auto& d : all) {
      const char* dt = d.getDeviceType();
      if (device_type_filter && !StrView(dt).contains(device_type_filter))
        continue;
      if (idx == device_index) {
        DLNAServiceInfo& s = d.getService(id);
        if (s) return s;
      }
      idx++;
    }
 
    // fallback: global search
    return mgr.getService(id);
  }
 
  const char* findArgument(ActionReply& r, const char* name) {
    for (auto& a : r.arguments) {
      if (a.name != nullptr) {
        StrView nm(a.name);
        if (nm == name) return a.value.c_str();
      }
    }
    return nullptr;
  }
 
  ActionRequest &createBrowseAction(DLNAServiceInfo& svc, const char* browseFlag,
                                   int startingIndex, int requestedCount) {
    static ActionRequest act(svc, "Browse");
    // Use the canonical argument name expected by ContentDirectory: "ObjectID"
    act.addArgument("ObjectID", object_id);
    act.addArgument("BrowseFlag",
                    browseFlag ? browseFlag : "BrowseDirectChildren");
    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;
  }
 
  void parseNumericFields(ActionReply& reply, int& numberReturned,
                          int& totalMatches, int& updateID) {
    const char* nret = findArgument(reply, "NumberReturned");
    const char* tmatch = findArgument(reply, "TotalMatches");
    const char* uid = findArgument(reply, "UpdateID");
    numberReturned = nret ? atoi(nret) : 0;
    totalMatches = tmatch ? atoi(tmatch) : 0;
    updateID = uid ? atoi(uid) : 0;
  }
 
  void processResult(const char* resultXml, ItemCallback itemCallback) {
    if (!resultXml) return;
    StrView res(resultXml);
    int pos = 0;
    while (true) {
      // find next <item or <container element
      int itPos1 = res.indexOf("<item", pos);
      int itPos2 = res.indexOf("<container", pos);
      int itPos = -1;
      bool isContainer = false;
      if (itPos1 >= 0 && (itPos2 < 0 || itPos1 < itPos2)) {
        itPos = itPos1;
        isContainer = false;
      } else if (itPos2 >= 0) {
        itPos = itPos2;
        isContainer = true;
      }
      if (itPos < 0) break;
      int itEnd = isContainer ? res.indexOf("</container>", itPos)
                              : res.indexOf("</item>", itPos);
      if (itEnd < 0) break;
      int headerEnd = res.indexOf('>', itPos);
      if (headerEnd < 0 || headerEnd >= itEnd) break;
 
      tiny_dlna::MediaItem item;
      // extract id attribute
      int idPos = res.indexOf("id=\"", itPos);
      if (idPos >= 0 && idPos < headerEnd) {
        int valStart = idPos + 4;
        int valEnd = res.indexOf('"', valStart);
        if (valEnd > valStart) {
          Str tmp;
          tmp.copyFrom(res.c_str() + valStart, valEnd - valStart);
          item.id = strings.add((char*)tmp.c_str());
        }
      }
 
      // title
      int t1 = res.indexOf("<dc:title>", headerEnd);
      if (t1 >= 0 && t1 < itEnd) {
        int t1s = t1 + strlen("<dc:title>");
        int t1e = res.indexOf("</dc:title>", t1s);
        if (t1e > t1s) {
          Str tmp;
          tmp.copyFrom(res.c_str() + t1s, t1e - t1s);
          item.title = strings.add((char*)tmp.c_str());
        }
      }
 
      // res
      int r1 = res.indexOf("<res", headerEnd);
      if (r1 >= 0 && r1 < itEnd) {
        int r1s = res.indexOf('>', r1);
        if (r1s >= 0 && r1s < itEnd) {
          r1s += 1;
          int r1e = res.indexOf("</res>", r1s);
          if (r1e > r1s) {
            Str tmp;
            tmp.copyFrom(res.c_str() + r1s, r1e - r1s);
            item.res = strings.add((char*)tmp.c_str());
          }
        }
      }
 
      if (itemCallback) itemCallback(item, reference);
      pos = itEnd + 7;
    }
  }
};
 
}  // namespace tiny_dlna