ControlPointMediaRenderer.h

Go to the documentation of this file.

// Header-only control point helper for MediaRenderer devices
#pragma once
 
#include "dlna/DLNAControlPoint.h"
#include "dlna/service/Action.h"
#include <functional>
 
namespace tiny_dlna {
 
class ControlPointMediaRenderer {
 public:
  ControlPointMediaRenderer(DLNAControlPoint& mgr) : mgr(mgr) {}
 
  void setDeviceTypeFilter(const char* filter) {
    device_type_filter = filter ? filter : device_type_filter_default;
  }
 
  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() {
    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;
  }
 
  void setDeviceIndex(int idx) { device_index = idx; }
 
  typedef void (*NotificationCallback)(void* reference, const char* sid,
                                       const char* varName,
                                       const char* newValue);
 
  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 setInstanceID(const char* id) { instance_id = id; }
 
  bool setMediaURI(const char* uri) {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) {
      DlnaLogger.log(DlnaLogLevel::Error, "No AVTransport service found");
      return false;
    }
    ActionRequest act(svc, "SetAVTransportURI");
    act.addArgument("InstanceID", instance_id);
    act.addArgument("CurrentURI", uri);
    act.addArgument("CurrentURIMetaData", "");
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    return (bool)last_reply;
  }
 
  bool play() {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) {
      DlnaLogger.log(DlnaLogLevel::Error, "No AVTransport service found");
      return false;
    }
    ActionRequest act(svc, "Play");
    act.addArgument("InstanceID", instance_id);
    act.addArgument("Speed", "1");
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (last_reply) setActiveState(true);
    return (bool)last_reply;
  }
 
  bool play(const char* uri) {
    if (!setMediaURI(uri)) return false;
    return play();
  }
 
  bool pause() {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return false;
    ActionRequest act(svc, "Pause");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (last_reply) setActiveState(false);
    return (bool)last_reply;
  }
 
  bool stop() {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return false;
    ActionRequest act(svc, "Stop");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (last_reply) setActiveState(false);
    return (bool)last_reply;
  }
 
  bool setVolume(int volumePercent) {
    if (volumePercent < 0) volumePercent = 0;
    if (volumePercent > 100) volumePercent = 100;
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:RenderingControl");
    if (!svc) {
      DlnaLogger.log(DlnaLogLevel::Error, "No RenderingControl service found");
      return false;
    }
    char volBuf[8];
    snprintf(volBuf, sizeof(volBuf), "%d", volumePercent);
    ActionRequest act(svc, "SetVolume");
    act.addArgument("InstanceID", "0");
    act.addArgument("Channel", "Master");
    act.addArgument("DesiredVolume", volBuf);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    return (bool)last_reply;
  }
 
  bool setMute(bool mute) {
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:RenderingControl");
    if (!svc) return false;
    ActionRequest act(svc, "SetMute");
    act.addArgument("InstanceID", "0");
    act.addArgument("Channel", "Master");
    act.addArgument("DesiredMute", mute ? "1" : "0");
    mgr.addAction(act);
    ActionReply r = mgr.executeActions();
    return (bool)r;
  }
 
  int getVolume() {
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:RenderingControl");
    if (!svc) return -1;
    ActionRequest act(svc, "GetVolume");
    act.addArgument("InstanceID", instance_id);
    act.addArgument("Channel", "Master");
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return -1;
    const char* v = findArgument(last_reply, "CurrentVolume");
    if (!v) return -1;
    return atoi(v);
  }
 
  int getMute() {
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:RenderingControl");
    if (!svc) return -1;
    ActionRequest act(svc, "GetMute");
    act.addArgument("InstanceID", instance_id);
    act.addArgument("Channel", "Master");
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return -1;
    const char* m = findArgument(last_reply, "CurrentMute");
    if (!m) return -1;
    return atoi(m);
  }
 
  unsigned long getPositionMs() {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return 0;
    ActionRequest act(svc, "GetPositionInfo");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return 0;
    const char* rel = findArgument(last_reply, "RelTime");
    if (!rel) return 0;
    return parseTimeToMs(rel);
  }
 
  const char* getTransportState() {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return nullptr;
    ActionRequest act(svc, "GetTransportInfo");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return nullptr;
    return findArgument(last_reply, "CurrentTransportState");
  }
 
  const char* getCurrentURI() {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return nullptr;
    ActionRequest act(svc, "GetMediaInfo");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return nullptr;
    return findArgument(last_reply, "CurrentURI");
  }
 
  int getNrTracks() {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return -1;
    ActionRequest act(svc, "GetMediaInfo");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return -1;
    const char* n = findArgument(last_reply, "NrTracks");
    if (!n) return -1;
    return atoi(n);
  }
 
  unsigned long getMediaDurationMs() {
    DLNAServiceInfo& svc = mgr.getService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return 0;
    ActionRequest act(svc, "GetMediaInfo");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return 0;
    const char* d = findArgument(last_reply, "MediaDuration");
    if (!d) return 0;
    return parseTimeToMs(d);
  }
 
  int getTrackIndex() {
    DLNAServiceInfo& svc = mgr.getService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return -1;
    ActionRequest act(svc, "GetPositionInfo");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return -1;
    const char* tr = findArgument(last_reply, "Track");
    if (!tr) return -1;
    return atoi(tr);
  }
 
  unsigned long getTrackDurationMs() {
    DLNAServiceInfo& svc = mgr.getService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return 0;
    ActionRequest act(svc, "GetPositionInfo");
    act.addArgument("InstanceID", instance_id);
    mgr.addAction(act);
    last_reply = mgr.executeActions();
    if (!last_reply) return 0;
    const char* td = findArgument(last_reply, "TrackDuration");
    if (!td) return 0;
    return parseTimeToMs(td);
  }
 
  const ActionReply& getLastReply() const { return last_reply; }
 
  bool isActive() { return is_active; }
 
  void setReference(void* ref) { reference = ref; }
 
  void onActiveChanged(std::function<void(bool, void*)> cb) { activeChangedCallback = cb; }
 
 protected:
  DLNAControlPoint& mgr;
  bool is_active = false;
  std::function<void(bool, void*)> activeChangedCallback = nullptr;
  int device_index = 0;
  const char* instance_id = "0";
  const char* device_type_filter_default =
      "urn:schemas-upnp-org:device:MediaRenderer:1";
  const char* device_type_filter = device_type_filter_default;
  ActionReply last_reply;
  void *reference = nullptr;
 
  // Helper to update is_active and notify callback only on change
  void setActiveState(bool s) {
    if (is_active == s) return;
    is_active = s;
    DlnaLogger.log(DlnaLogLevel::Info, "ControlPointMediaRenderer active=%s", is_active ? "true" : "false");
    if (activeChangedCallback) activeChangedCallback(is_active, reference);
  }
 
  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)");
 
    ControlPointMediaRenderer* renderer =
        static_cast<ControlPointMediaRenderer*>(reference);
    if (renderer) {
      // Handle the notification (e.g., update internal state, call callbacks)
      if (StrView(varName) == "TransportState") {
        if (StrView(newValue) == "PLAYING") {
          renderer->setActiveState(true);
        } else {
          renderer->setActiveState(false);
        }
      }
    }
  }
 
  // Helper: find argument by name in ActionReply (returns nullptr if not found)
  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;
  }
 
  // Helper: parse DLNA time string (HH:MM:SS, MM:SS) to milliseconds
  static unsigned long parseTimeToMs(const char* t) {
    if (t == nullptr) return 0;
    int h = 0, m = 0, s = 0;
    int parts = 0;
    // Count colons
    const char* p = t;
    int colonCount = 0;
    while (*p) {
      if (*p == ':') colonCount++;
      p++;
    }
    if (colonCount == 2) {
      parts = sscanf(t, "%d:%d:%d", &h, &m, &s);
    } else if (colonCount == 1) {
      parts = sscanf(t, "%d:%d", &m, &s);
      h = 0;
    } else {
      // maybe it's seconds only
      parts = sscanf(t, "%d", &s);
    }
    if (parts <= 0) return 0;
    unsigned long total =
        (unsigned long)h * 3600UL + (unsigned long)m * 60UL + (unsigned long)s;
    return total * 1000UL;
  }
 
  // Select service on a device filtered by device_type_filter
  DLNAServiceInfo& selectService(const char* id) {
    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++;
    }
    return mgr.getService(id);
  }
};
 
}  // namespace tiny_dlna