DLNAControlPointMediaRenderer.h

Go to the documentation of this file.

// Header-only control point helper for MediaRenderer devices
#pragma once
 
#include <functional>
 
#include "dlna/common/Action.h"
#include "dlna/clients/DLNAControlPoint.h"
#include "dlna/xml/XMLProtocolInfoParser.h"
#include "http/Server/HttpChunkWriter.h"
 
namespace tiny_dlna {
 
class DLNAControlPointMediaRenderer {
 public:
  DLNAControlPointMediaRenderer() = default;
 
  DLNAControlPointMediaRenderer(DLNAControlPoint& m, IHttpRequest& http,
                                IUDPService& udp)
      : p_mgr(&m), p_http(&http), p_udp(&udp) {}
 
  void setDLNAControlPoint(DLNAControlPoint& m) { p_mgr = &m; }
 
  void setDeviceTypeFilter(const char* filter) {
    device_type_filter = filter ? filter : device_type_filter_default;
  }
  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,
                   "ControlPointMediaRenderer::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);
  }
 
  int getDeviceCount() {
    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;
  }
 
  void setDeviceIndex(int idx) { device_index = idx; }
 
  bool subscribe() { return p_mgr->subscribe(); }
 
 
  void setHttp(IHttpRequest& http) { p_http = &http; }
 
  void setUdp(IUDPService& udp) { p_udp = &udp; }
 
  typedef void (*NotificationCallback)(void* reference, const char* sid,
                                       const char* varName,
                                       const char* newValue);
 
  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 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);
    // Some renderers require the CurrentURIMetaData argument to be present
    // even when empty. Use the Argument constructor to force adding an empty
    // value (the addArgument(name,value) helper skips empty values).
    act.addArgument(Argument("CurrentURIMetaData", ""));
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (last_reply) {
      local_url = uri;
    }
    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");
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (last_reply) {
      setActiveState(true);
      local_transport_state = "PLAYING";
    }
    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);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (last_reply) {
      setActiveState(false);
      local_transport_state = "PAUSED_PLAYBACK";
    }
    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);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (last_reply) {
      setActiveState(false);
      local_transport_state = "STOPPED";
    }
    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);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (last_reply) {
      local_volume = volumePercent;
    }
 
    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");
    p_mgr->addAction(act);
    ActionReply r = p_mgr->executeActions();
    if (r) {
      local_mute = mute;
    }
    return (bool)r;
  }
 
  int getVolume(bool fromRemote = true) {
    if (!fromRemote) {
      return local_volume;
    }
    DLNAServiceInfo& svc =
        selectService("urn:upnp-org:serviceId:RenderingControl");
    selectService("urn:upnp-org:serviceId:RenderingControl");
    if (!svc) return -1;
    ActionRequest act(svc, "GetVolume");
    act.addArgument("InstanceID", instance_id);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    last_reply = p_mgr->executeActions();
    if (!last_reply) return -1;
    const char* v = last_reply.findArgument("CurrentVolume");
    if (!v) return -1;
    return atoi(v);
  }
 
  int getMute(bool fromRemote = true) {
    if (!fromRemote) {
      return local_mute;
    }
    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");
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return -1;
    const char* m = last_reply.findArgument("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);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return 0;
    const char* rel = last_reply.findArgument("RelTime");
    if (!rel) return 0;
    return parseTimeToMs(rel);
  }
 
  const char* getTransportState(bool fromRemote = true) {
    if (!fromRemote) {
      return local_transport_state;
    }
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return nullptr;
    ActionRequest act(svc, "GetTransportInfo");
    act.addArgument("InstanceID", instance_id);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return nullptr;
    return last_reply.findArgument("CurrentTransportState");
  }
 
  const char* getCurrentURI(bool fromRemote = true) {
    if (!fromRemote) {
      return local_url.c_str();
    }
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return nullptr;
    ActionRequest act(svc, "GetMediaInfo");
    act.addArgument("InstanceID", instance_id);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return nullptr;
    return last_reply.findArgument("CurrentURI");
  }
 
  int getNrTracks() {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return -1;
    ActionRequest act(svc, "GetMediaInfo");
    act.addArgument("InstanceID", instance_id);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return -1;
    const char* n = last_reply.findArgument("NrTracks");
    if (!n) return -1;
    return atoi(n);
  }
 
  unsigned long getMediaDurationMs() {
    DLNAServiceInfo& svc =
        p_mgr->getService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return 0;
    ActionRequest act(svc, "GetMediaInfo");
    act.addArgument("InstanceID", instance_id);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return 0;
    const char* d = last_reply.findArgument("MediaDuration");
    if (!d) return 0;
    return parseTimeToMs(d);
  }
 
  int getTrackIndex() {
    DLNAServiceInfo& svc =
        p_mgr->getService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return -1;
    ActionRequest act(svc, "GetPositionInfo");
    act.addArgument("InstanceID", instance_id);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return -1;
    const char* tr = last_reply.findArgument("Track");
    if (!tr) return -1;
    return atoi(tr);
  }
 
  unsigned long getTrackDurationMs() {
    DLNAServiceInfo& svc =
        p_mgr->getService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) return 0;
    ActionRequest act(svc, "GetPositionInfo");
    act.addArgument("InstanceID", instance_id);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return 0;
    const char* td = last_reply.findArgument("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;
  }
 
  bool getCurrentTransportActions(Str& out) {
    DLNAServiceInfo& svc = selectService("urn:upnp-org:serviceId:AVTransport");
    if (!svc) {
      DlnaLogger.log(DlnaLogLevel::Error, "No AVTransport service found");
      return false;
    }
    ActionRequest act(svc, "GetCurrentTransportActions");
    act.addArgument("InstanceID", instance_id);
    p_mgr->addAction(act);
    last_reply = p_mgr->executeActions();
    if (!last_reply) return false;
    const char* actions = last_reply.findArgument("Actions");
    if (!actions) return false;
    out = actions;
    return true;
  }
 
  bool getProtocalInfo(
      std::function<void(const char* entry, ProtocolRole role)> cb) {
    if (!cb) return false;
 
    DLNAServiceInfo& svc =
        p_mgr->getService("urn:upnp-org:serviceId:ConnectionManager");
    if (!svc) {
      DlnaLogger.log(DlnaLogLevel::Error, "No ConnectionManager service found");
      return false;
    }
 
    // build action and enqueue
    ActionRequest act(svc, "GetProtocolInfo");
    p_mgr->addAction(act);
    bool ok = false;
 
    // processor will be invoked with the live Client and the ActionReply so
    // callers can handle the response stream themselves. We simply stream-
    // parse and forward each parsed entry to the provided callback.
    XMLCallback processor = [&cb, &ok](Client& client, ActionReply& reply) {
      ok = XMLProtocolInfoParser::parse(client, cb);
      reply.clear();
      reply.setValid(true);
    };
 
    // execute the queued action and use our processor to handle the reply
    p_mgr->executeActions(processor);
    return ok;
  }
 
 protected:
  DLNAControlPoint* p_mgr = nullptr;
  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;
  // Optional transport references (must be set before calling begin())
  IHttpRequest* p_http = nullptr;
  IUDPService* p_udp = nullptr;
  int local_volume = 0;
  int local_mute = false;
  Str local_url;
  const char* local_transport_state = "STOPPED";
 
  // 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)");
 
    DLNAControlPointMediaRenderer* renderer =
        static_cast<DLNAControlPointMediaRenderer*>(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: 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;
  }
 
  DLNAServiceInfo& selectService(const char* id) {
    // use selected device
    DLNAServiceInfo& s = p_mgr->getDevice().getService(id);
    if (s) return s;
 
    // fallback: global search
    return p_mgr->getService(id);
  }
};
 
}  // namespace tiny_dlna