DLNAMediaRenderer.h

Go to the documentation of this file.

#pragma once
#include <cctype>
#include <cstring>
#include <functional>
 
#include "DLNAMediaRendererDescr.h"
#include "basic/Printf.h"
#include "basic/Str.h"
#include "dlna/devices/DLNADevice.h"
#include "dlna/udp/IUDPService.h"
#include "dlna/xml/XMLAttributeParser.h"
#include "dlna/xml/XMLParserPrint.h"
#include "http/Server/IHttpServer.h"
 
namespace tiny_dlna {
enum class MediaEvent { SET_URI, PLAY, PAUSE, STOP, SET_VOLUME, SET_MUTE };
 
template <typename ClientType>
class DLNAMediaRenderer : public DLNADeviceInfo {
 public:
  using HttpClient = ClientType;
  using DeviceType = DLNADevice<ClientType>;
  // event handler: (event, reference to MediaRenderer)
  typedef void (*MediaEventHandler)(MediaEvent event,
                                    DLNAMediaRenderer& renderer);
 
  DLNAMediaRenderer() {
    // Constructor
    DlnaLogger.log(DlnaLogLevel::Info, "MediaRenderer::MediaRenderer");
    setUDN(usn);
    setSerialNumber("1.0");
    setDeviceType(st);
    setFriendlyName("ArduinoMediaRenderer");
    setManufacturer("TinyDLNA");
    setModelName("TinyDLNA");
    setModelNumber("1.0");
    setBaseURL("http://localhost:44757");
    setupRules();
    dlna_device.setReference(this);
  }
 
  DLNAMediaRenderer(IHttpServer& server, IUDPService& udp)
      : DLNAMediaRenderer() {
    setHttpServer(server);
    setUdpService(udp);
  }
 
  bool begin() { return dlna_device.begin(*this, *p_udp_member, *p_server); }
 
  void end() {
    if (is_active) stop();
    dlna_device.end();
  }
 
  bool loop(int loopAction = RUN_ALL) { return dlna_device.loop(loopAction); }
 
  void setHttpServer(IHttpServer& server) {
    p_server = &server;
    // prepare handler context and register each service via helpers
    server.setReference(this);
    setupServicesImpl(&server);
  }
 
  void setUdpService(IUDPService& udp) { p_udp_member = &udp; }
 
  void setPossiblePlaybackStorageMedia(const char* v) {
    possiblePlaybackStorageMedia = v ? v : "";
  }
 
  const char* getPossiblePlaybackStorageMedia() const {
    return possiblePlaybackStorageMedia;
  }
 
  void setPossibleRecordStorageMedia(const char* v) {
    possibleRecordStorageMedia = v ? v : "";
  }
 
  const char* getPossibleRecordStorageMedia() const {
    return possibleRecordStorageMedia;
  }
 
  void setPossibleRecordQualityModes(const char* v) {
    possibleRecordQualityModes = v ? v : "";
  }
 
  const char* getPossibleRecordQualityModes() const {
    return possibleRecordQualityModes;
  }
 
  void setPlayMode(const char* v) { currentPlayMode = v ? v : "NORMAL"; }
 
  const char* getPlayMode() const { return currentPlayMode; }
 
  bool isActive() { return is_active; }
 
  void setActive(bool active) {
    DlnaLogger.log(DlnaLogLevel::Info, "Set active: %s",
                   active ? "true" : "false");
    is_active = active;
    if (active) {
      start_time = millis();
    } else {
      // accumulate time
      time_sum += millis() - start_time;
      start_time = 0;
    }
    // reflect state in transport_state so deferred writer can read it
    transport_state = active ? "PLAYING" : "PAUSED_PLAYBACK";
    struct StateWriter {
      static size_t write(Print& out, void* ref) {
        auto self = (DLNAMediaRenderer*)ref;
        size_t written = 0;
 
        written += out.print("<TransportState val=\"");
        written += out.print(self->getTransportState());
        written += out.print("\"/>");
        written += out.print("<CurrentTransportActions val=\"");
        written += out.print(self->getCurrentTransportActions());
        written += out.print("\"/>");
 
        return written;
      }
    };
    addChange("AVT", StateWriter::write);
  }
 
  const char* getMime() {
    // Prefer explicit MIME from DIDL if available
    if (!current_mime.isEmpty()) return current_mime.c_str();
    return nullptr;
  }
 
  void setMediaEventHandler(MediaEventHandler cb) { event_cb = cb; }
 
  uint8_t getVolume() { return current_volume; }
 
  void setVolume(uint8_t vol) {
    current_volume = vol;
    (void)current_volume;  // value used by writer via ref
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      size_t written = 0;
      written += out.print("<Volume val=\"");
      written += out.print(self->current_volume);
      written += out.print("\" channel=\"Master\"/>");
      return written;
    };
    addChange("RCS", writer);
  }
 
  bool isMuted() { return getVolume() == 0; }
 
  void setMuted(bool mute) {
    if (mute) {
      // store current volume and set to 0
      muted_volume = current_volume;
      current_volume = 0;
    } else {
      // restore previous volume
      current_volume = muted_volume;
    }
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      size_t written = 0;
      written += out.print("<Mute val=\"");
      written += out.print(self->isMuted() ? 1 : 0);
      written += out.print("\" channel=\"Master\"/>");
      return written;
    };
    addChange("RCS", writer);
  }
 
  const char* getCurrentUri() { return current_uri.c_str(); }
 
  const char* getCurrentUriMetadata() { return current_uri_metadata.c_str(); }
 
  const char* getTransportState() { return transport_state.c_str(); }
 
  IDevice& device() { return dlna_device; }
 
  void setSubscriptionsActive(bool flag) {
    dlna_device.setSubscriptionsActive(flag);
  }
 
  bool isSubscriptionsActive() { return dlna_device.isSubscriptionsActive(); }
 
  bool play() {
    setActive(true);
    return true;
  }
 
  bool play(const char* urlStr) {
    if (urlStr == nullptr) return false;
    DlnaLogger.log(DlnaLogLevel::Info, "play URL: %s", urlStr);
    // store URI
    current_uri.set(urlStr);
    // notify handler about the new URI; do not dispatch PLAY here — action
    // handlers will dispatch media events explicitly.
    is_active = true;
 
    // ensure transport_state reflects playing for subscribers
    transport_state = "PLAYING";
    (void)current_uri;  // writer will fetch it from ref
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      size_t written = 0;
      written += out.print("<CurrentTrack val=\"1\"/>\n");
      written += out.print("<CurrentTrackURI val=\"");
      written += out.print(self->current_uri.c_str());
      written += out.println("\"/>");
      written += out.print("<CurrentTrackMetadata val=\"");
      written += out.print(self->current_uri_metadata.c_str());
      written += out.println("\"/>");
      written += out.print("<TransportState val=\"");
      written += out.print(self->transport_state.c_str());
      written += out.print("\"/>");
      written += out.print("<CurrentTransportActions val=\"");
      written += out.print(self->transport_actions.c_str());
      written += out.print("\"/>");
      return written;
    };
    addChange("AVT", writer);
 
    return true;
  }
 
  bool setPlaybackURL(const char* urlStr) {
    if (urlStr == nullptr) return false;
    DlnaLogger.log(DlnaLogLevel::Info, "setPlaybackURL URL: %s", urlStr);
    // store URI
    current_uri = Str(urlStr);
    // Do not notify application here; event notifications are emitted
    // from the SOAP action handlers (processAction*).
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      size_t written = 0;
      written += out.print("<AVTransportURI val=\"");
      written += out.print(self->current_uri.c_str());
      written += out.println("\"/>");
 
      written += out.print("<AVTransportURIMetaData val=\"");
      written += out.print(self->current_uri_metadata.c_str());
      written += out.println("\"/>");
 
      written += out.print("<NumberOfTracks val=\"1\"/>\n");
      return written;
    };
    addChange("AVT", writer);
 
    return true;
  }
 
  bool stop() {
    DlnaLogger.log(DlnaLogLevel::Info, "Stop playback");
    is_active = false;
    start_time = 0;
    time_sum = 0;
    // reflect stopped state
    transport_state = "STOPPED";
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      size_t written = 0;
      written += out.print("<TransportState val=\"");
      written += out.print(self->getTransportState());
      written += out.print("\"/>");
      written += out.print("<CurrentTransportActions val=\"");
      written += out.print(self->getCurrentTransportActions());
      written += out.print("\"/>");
      return written;
    };
    addChange("AVT", writer);
    return true;
  }
 
  void setPlaybackCompleted() {
    DlnaLogger.log(DlnaLogLevel::Info, "Playback completed");
    transport_state = "STOPPED";
    is_active = false;
    start_time = 0;
    time_sum = 0;
    // Do not notify application here; event notifications are emitted
    // from the SOAP action handlers (processAction*).
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      size_t written = 0;
      written += out.print("<TransportState val=\"");
      written += out.print(self->transport_state.c_str());
      written += out.print("\"/>");
      written += out.print("<CurrentPlayMode val=\"NORMAL\"/>");
      written += out.print("<CurrentTrackURI val=\"\"/>");
      written += out.print("<RelativeTimePosition val=\"00:00:00\"/>");
      written += out.print("<CurrentTransportActions val=\"Play\"/>");
      return written;
    };
    addChange("AVT", writer);
  }
 
  size_t getRelativeTimePositionSec() {
    unsigned long posMs = (millis() - start_time) + time_sum;
    return static_cast<size_t>(posMs / 1000);
  }
 
  void publishGetRelativeTimePositionSec() {
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      size_t written = 0;
      // format hh:mm:ss by printing parts
      int h = static_cast<int>(self->getRelativeTimePositionSec() / 3600);
      int m =
          static_cast<int>((self->getRelativeTimePositionSec() % 3600) / 60);
      int s = static_cast<int>(self->getRelativeTimePositionSec() % 60);
      written += out.print("<RelativeTimePosition val=\"");
      // print two-digit hour
      if (h < 10) written += out.print('0');
      written += out.print(h);
      written += out.print(':');
      if (m < 10) written += out.print('0');
      written += out.print(m);
      written += out.print(':');
      if (s < 10) written += out.print('0');
      written += out.print(s);
      written += out.print("\"/>");
      return written;
    };
    addChange("AVT", writer);
  }
 
  const char* getCurrentTransportActions() {
    if (current_uri.isEmpty()) {
      return "SetAVTransportURI";
    }
    if (is_active) {
      return "Pause,Stop";
    } else {
      return "Play";
    }
  }
  void setCustomActionRule(const char* suffix,
                           bool (*handler)(DLNAMediaRenderer*, ActionRequest&,
                                           IHttpServer&)) {
    for (size_t i = 0; i < rules.size(); ++i) {
      if (StrView(rules[i].suffix).equals(suffix)) {
        rules[i].handler = handler;
        return;
      }
    }
    rules.push_back({suffix, handler});
  }
 
  void setConnectionID(const char* id) { connectionID = id; }
 
  const char* getConnectionID() { return connectionID; }
 
  void setProtocols(const char* source, const char* sink = "") {
    sourceProto = source;
    sinkProto = sink;
    // publish protocol info change to ConnectionManager subscribers
    // Build writer that will use live state from the device at publish time
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      size_t result = 0;
      result += out.print("<SourceProtocolInfo val=\"");
      result += out.print(StrView(self->getSourceProtocols()).c_str());
      result += out.println("\"/>");
      result += out.print("<SinkProtocolInfo val=\"");
      result += out.print(StrView(self->getSinkProtocols()).c_str());
      result += out.println("\"/>");
      return result;
    };
    addChange("CMS", writer);
  }
 
  const char* getSourceProtocols() { return sourceProto; }
 
  const char* getSinkProtocols() { return sinkProto; }
 
  void setTransportDescr(DLNADescr& d) { p_transportDescr = &d; }
 
  DLNADescr& getTransportDescr() { return *p_transportDescr; }
 
  void setControlDescr(DLNADescr& d) { p_controlDescr = &d; }
 
  DLNADescr& getControlDescr() { return *p_controlDescr; }
 
  void setConnectionMgrDescr(DLNADescr& d) { p_connmgrDescr = &d; }
 
  DLNADescr& getConnectionMgrDescr() { return *p_connmgrDescr; }
 
 protected:
  struct ActionRule {
    const char* suffix;
    bool (*handler)(DLNAMediaRenderer*, ActionRequest&, IHttpServer&, IClientHandler&);
  };
 
  tiny_dlna::Str current_uri;
  tiny_dlna::Str current_mime;
  tiny_dlna::Str current_uri_metadata;
  MediaEventHandler event_cb = nullptr;
  uint8_t current_volume = 50;
  uint8_t muted_volume = 0;
  unsigned long start_time = 0;
  unsigned long time_sum = 0;
  // Current state (e.g. "STOPPED", "PLAYING","PAUSED_PLAYBACK")
  tiny_dlna::Str transport_state = "STOPPED";
  const char* st = "urn:schemas-upnp-org:device:MediaRenderer:1";
  const char* usn = "uuid:09349455-2941-4cf7-9847-1dd5ab210e97";
  DeviceType dlna_device;
  IHttpServer* p_server = nullptr;
  IUDPService* p_udp_member = nullptr;
  const char* connectionID = "0";
  const char* sourceProto = "";
  const char* sinkProto = DLNA_PROTOCOL_AUDIO;
  const char* possiblePlaybackStorageMedia = "NETWORK";
  const char* possibleRecordStorageMedia = "NONE";
  const char* possibleRecordQualityModes = "NOT_IMPLEMENTED";
  const char* currentPlayMode = "NORMAL";
  Vector<ActionRule> rules;
 
  // Descriptor instances so callers can customise the SCPD output per device
  DLNAMediaRendererTransportDescr default_transport_desc;
  DLNADescr* p_transportDescr = &default_transport_desc;
  DLNAMediaRendererControlDescr default_control_desc;
  DLNADescr* p_controlDescr = &default_control_desc;
  DLNAMediaRendererConnectionMgrDescr default_connmgr_desc;
  DLNADescr* p_connmgrDescr = &default_connmgr_desc;
 
  // Note: descriptor printing is performed inline in the descriptor
  // callbacks below using non-capturing lambdas passed to
  // IHttpServer::reply. That avoids heap buffering while keeping the
  // callsites concise. The old static helper functions were removed.
 
  void addChange(const char* serviceAbbrev,
                 std::function<size_t(Print&, void*)> changeWriter) {
    dlna_device.addChange(serviceAbbrev, changeWriter, this);
  }
 
  void publishAVT() {
    // Transport state will be built by the writer from the instance (ref)
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      Printf outf{out};
      size_t written = 0;
      written += outf.printf("<TransportState val=\"%s\"/>",
                             self->transport_state.c_str());
      if (!self->current_uri.isEmpty()) {
        written += outf.printf("<CurrentTrackURI val=\"%s\"/>",
                               self->current_uri.c_str());
      }
      written += outf.printf(
          "<RelativeTimePosition val=\"%02d:%02d:%02d\"/>",
          static_cast<int>(self->getRelativeTimePositionSec() / 3600),
          static_cast<int>((self->getRelativeTimePositionSec() % 3600) / 60),
          static_cast<int>(self->getRelativeTimePositionSec() % 60));
      written += outf.printf("<CurrentTransportActions val=\"%s\"/>",
                             self->getCurrentTransportActions());
      return written;
    };
    addChange("AVT", writer);
  }
 
  void publishRCS() {
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      Printf outf{out};
      size_t written = 0;
      written += outf.printf("<Volume val=\"%d\" channel=\"Master\"/>", self->current_volume);
      written += out.println();
      written += outf.printf("<Mute val=\"%d\" channel=\"Master\"/>", self->isMuted() ? 1 : 0);
      written += out.println();
      return written;
    };
    addChange("RCS", writer);
  }
 
  void publishCMS() {
    auto writer = [](Print& out, void* ref) -> size_t {
      DLNAMediaRenderer* self = (DLNAMediaRenderer*)ref;
      Printf printer{out};
      return printer.printf("<CurrentConnectionIDs>%s</CurrentConnectionIDs>");
    };
    addChange("CMS", writer);
  }
 
  void setMime(const char* mime) {
    if (mime) {
      current_mime = mime;
      DlnaLogger.log(DlnaLogLevel::Info, "Set mime: %s", current_mime.c_str());
    }
  }
 
  void setMimeFromDIDL(const char* didl) {
    if (!didl) return;
    // Convenience helper: extract protocolInfo attribute from a tag and
    // return the contentFormat (3rd token) portion, e.g. from
    // protocolInfo="http-get:*:audio/mpeg:*" -> "audio/mpeg".
    char mimeBuf[256] = {0};
    if (XMLAttributeParser::extractAttributeToken(
            didl, "<res", "protocolInfo=", 3, mimeBuf, sizeof(mimeBuf))) {
      setMime(mimeBuf);
    }
  }
 
  // Static descriptor callbacks: print the SCPD XML for each service
  static void transportDescrCB(IClientHandler& client, IHttpServer* server, const char* requestPath,
                               HttpRequestHandlerLine* hl) {
    DLNAMediaRenderer* self = getRenderer(server);
    if (self) {
      client.reply(
          "text/xml",
          [](Print& out, void* ref) -> size_t {
            size_t result = 0;
            auto self = static_cast<DLNAMediaRenderer*>(ref);
            if (self) result += self->getTransportDescr().printDescr(out);
            return result;
          },
          200, nullptr, self);
    } else {
      DlnaLogger.log(DlnaLogLevel::Error,
                     "transportDescrCB: renderer instance not found for %s",
                     requestPath);
      client.replyNotFound();
    }
  }
 
  static void connmgrDescrCB(IClientHandler& client, IHttpServer* server, const char* requestPath,
                             HttpRequestHandlerLine* hl) {
    DLNAMediaRenderer* self = getRenderer(server);
    if (self) {
      client.reply(
          "text/xml",
          [](Print& out, void* ref) -> size_t {
            size_t result = 0;
            auto self = static_cast<DLNAMediaRenderer*>(ref);
            if (self) result += self->getConnectionMgrDescr().printDescr(out);
            return result;
          },
          200, nullptr, self);
    } else {
      DlnaLogger.log(DlnaLogLevel::Error,
                     "connmgrDescrCB: renderer instance not found for %s",
                     requestPath);
      client.replyNotFound();
    }
  }
 
  static void controlDescrCB(IClientHandler& client, IHttpServer* server, const char* requestPath,
                             HttpRequestHandlerLine* hl) {
    DLNAMediaRenderer* self = getRenderer(server);
    if (self) {
      client.reply(
          "text/xml",
          [](Print& out, void* ref) -> size_t {
            size_t result = 0;
            auto self = static_cast<DLNAMediaRenderer*>(ref);
            if (self) result += self->getControlDescr().printDescr(out);
            return result;
          },
          200, nullptr, self);
    } else {
      DlnaLogger.log(DlnaLogLevel::Error,
                     "controlDescrCB: renderer instance not found for %s",
                     requestPath);
      client.replyNotFound();
    }
  }
 
  // Generic control callback: parse SOAP action and dispatch to instance
  static void controlCB(IClientHandler& client, IHttpServer* server, const char* requestPath,
                        HttpRequestHandlerLine* hl) {
    ActionRequest action;
    DeviceType::parseActionRequest(server, client, requestPath, hl, action);
 
    DLNAMediaRenderer* self = getRenderer(server);
 
    // Log incoming SOAPAction header and parsed action for debugging
    const char* soapHdr = client.requestHeader().get("SOAPACTION");
    DlnaLogger.log(DlnaLogLevel::Debug, "controlCB: SOAPAction=%s, action=%s",
                   StrView(soapHdr).c_str(),
                   StrView(action.getAction()).c_str());
 
    if (self) {
      if (self->processAction(action, *server, client)) return;
    }
    client.replyNotFound();
  }
 
  static DLNAMediaRenderer* getRenderer(IHttpServer* server) {
    auto* p_device = static_cast<IDevice*>(server->getReference());
    if (p_device == nullptr) return nullptr;
    return static_cast<DLNAMediaRenderer*>(p_device->getReference());
  }
 
  static void eventSubscriptionHandler(IClientHandler& client, IHttpServer* server,
                       const char* requestPath,
                       HttpRequestHandlerLine* hl) {
    bool is_subscribe = false;
    DeviceType::handleSubscription(server, &client, requestPath, hl, is_subscribe);
    if (is_subscribe) {
      DLNAMediaRenderer* self = getRenderer(server);
      assert(self != nullptr);
      StrView request_path_str(requestPath);
      if (request_path_str.contains("/AVT/"))
        self->publishAVT();
      else if (request_path_str.contains("/RC/"))
        self->publishRCS();
      else if (request_path_str.contains("/CM/"))
        self->publishCMS();
    }
  }
 
  // Setup and register individual services
  void setupTransportService(IHttpServer* server) {
    DLNAServiceInfo avt;
    // Use static descriptor callback and control handler
            avt.setup("urn:schemas-upnp-org:service:AVTransport:1",
              "urn:upnp-org:serviceId:AVTransport", "/AVT/service.xml",
              &DLNAMediaRenderer::transportDescrCB, "/AVT/control",
              (http_callback)&DLNAMediaRenderer::controlCB, "/AVT/event",
              (http_callback)&DLNAMediaRenderer::eventSubscriptionHandler);
    avt.subscription_namespace_abbrev = "AVT";
 
    addService(avt);
  }
 
  void setupConnectionManagerService(IHttpServer* server) {
    DLNAServiceInfo cm;
            cm.setup("urn:schemas-upnp-org:service:ConnectionManager:1",
              "urn:upnp-org:serviceId:ConnectionManager", "/CM/service.xml",
              &DLNAMediaRenderer::connmgrDescrCB, "/CM/control",
              (http_callback)&DLNAMediaRenderer::controlCB, "/CM/event",
              (http_callback)&DLNAMediaRenderer::eventSubscriptionHandler);
    cm.subscription_namespace_abbrev = "CMS";
 
    addService(cm);
  }
 
  void setupRenderingControlService(IHttpServer* server) {
    DLNAServiceInfo rc;
            rc.setup("urn:schemas-upnp-org:service:RenderingControl:1",
              "urn:upnp-org:serviceId:RenderingControl", "/RC/service.xml",
              &DLNAMediaRenderer::controlDescrCB, "/RC/control",
              (http_callback)&DLNAMediaRenderer::controlCB, "/RC/event",
              (http_callback)&DLNAMediaRenderer::eventSubscriptionHandler);
    rc.subscription_namespace_abbrev = "RCS";
 
    addService(rc);
  }
 
  void setupServicesImpl(IHttpServer* server) {
    DlnaLogger.log(DlnaLogLevel::Info, "MediaRenderer::setupServices");
    // register the individual services and register their endpoints on the
    // provided HTTP server
    setupTransportService(server);
    setupConnectionManagerService(server);
    setupRenderingControlService(server);
  }
 
  bool processAction(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    DlnaLogger.log(DlnaLogLevel::Info, "DLNAMediaRenderer::processAction: %s",
                   action.getAction());
    auto& action_str = action.getActionStr();
    if (action_str.isEmpty()) {
      DlnaLogger.log(DlnaLogLevel::Error, "Empty action received");
      client.replyError(400, "Invalid Action");
      return false;
    }
 
    for (const auto& rule : rules) {
      if (action_str.endsWith(rule.suffix)) {
        return rule.handler(this, action, server, client);
      }
    }
    DlnaLogger.log(DlnaLogLevel::Error, "Unsupported action: %s",
                   action.getAction());
    client.replyError(400, "Invalid Action");
    return false;
  }
 
  // Per-action handlers (match MediaServer pattern)
  bool processActionPlay(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    if (event_cb) event_cb(MediaEvent::PLAY, *this);
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          (void)ref;
          return DeviceType::printReplyXML(out, "PlayResponse", "AVTransport");
        },
        200, nullptr, this);
    // setActive(true);
    play();
    return true;
  }
 
  bool processActionListPresets(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          return DeviceType::printReplyXML(
              out, "ListPresetsResponse", "AVTransport",
              [](Print& o, void* /*innerRef*/) -> size_t {
                size_t written = 0;
                written += o.print("<CurrentPresetNameList>FactoryDefault</CurrentPresetNameList>");
                return written;
              },
              nullptr);
        },
        200, nullptr, this);
    return true;
  }
 
  bool processActionPause(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    if (event_cb) event_cb(MediaEvent::PAUSE, *this);
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          (void)ref;
          return DeviceType::printReplyXML(out, "PauseResponse", "AVTransport");
        },
        200, nullptr, this);
    setActive(false);
    return true;
  }
 
  bool processActionStop(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    // use stop() to ensure state reset and application callback are invoked
    if (event_cb) event_cb(MediaEvent::STOP, *this);
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          (void)ref;
          return DeviceType::printReplyXML(out, "StopResponse", "AVTransport");
        },
        200, nullptr, this);
    stop();
    return true;
  }
 
  bool processActionGetCurrentTransportActions(ActionRequest& action,
                                               IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          // Stream reply directly: delegate to printReplyXML which will
          // write headers and invoke the inner writer with the same ref.
          return DeviceType::printReplyXML(
              out, "GetCurrentTransportActionsResponse", "AVTransport",
              [](Print& o, void* innerRef) -> size_t {
                size_t written = 0;
                auto self = (DLNAMediaRenderer*)innerRef;
                written += o.print("<Actions>");
                written += o.print(self->getCurrentTransportActions());
                written += o.print("</Actions>");
                return written;
              },
              ref);
        },
        200, nullptr, this);
    return true;
  }
 
  // ConnectionManager: GetProtocolInfo
  bool processActionGetProtocolInfo(ActionRequest& action,
                                    IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          auto self = (DLNAMediaRenderer*)ref;
          return DeviceType::replyGetProtocolInfo(
              out, self->getSourceProtocols(), self->getSinkProtocols());
        },
        200, nullptr, this);
    return true;
  }
 
  // ConnectionManager: GetCurrentConnectionIDs
  bool processActionGetCurrentConnectionIDs(ActionRequest& action,
                                            IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          auto self = (DLNAMediaRenderer*)ref;
          return DeviceType::replyGetCurrentConnectionIDs(
              out, self->getConnectionID());
        },
        200, nullptr, this);
    return true;
  }
 
  // ConnectionManager: GetCurrentConnectionInfo
  bool processActionGetCurrentConnectionInfo(ActionRequest& action,
                                             IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          auto self = (DLNAMediaRenderer*)ref;
          return DeviceType::replyGetCurrentConnectionInfo(
              out, self->getSinkProtocols(), self->getConnectionID(), "Input");
        },
        200, nullptr, this);
    return true;
  }
 
  // AVTransport: GetDeviceCapabilities
  bool processActionGetDeviceCapabilities(ActionRequest& action,
                                          IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          return DeviceType::printReplyXML(
              out, "GetDeviceCapabilitiesResponse", "AVTransport",
              [](Print& o, void* innerRef) -> size_t {
                auto self = (DLNAMediaRenderer*)innerRef;
                size_t written = 0;
                written += o.print("<PlayMedia>");
                written += o.print(
                    StrView(self->getPossiblePlaybackStorageMedia()).c_str());
                written += o.print("</PlayMedia>");
                written += o.print("<RecMedia>");
                written += o.print(
                    StrView(self->getPossibleRecordStorageMedia()).c_str());
                written += o.print("</RecMedia>");
                written += o.print("<RecQualityModes>");
                written += o.print(
                    StrView(self->getPossibleRecordQualityModes()).c_str());
                written += o.print("</RecQualityModes>");
                return written;
              },
              ref);
        },
        200, nullptr, this);
    return true;
  }
 
  // AVTransport: GetTransportInfo
  bool processActionGetTransportInfo(ActionRequest& action,
                                     IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          return DeviceType::printReplyXML(
              out, "GetTransportInfoResponse", "AVTransport",
              [](Print& o, void* innerRef) -> size_t {
                auto self = (DLNAMediaRenderer*)innerRef;
                size_t written = 0;
                // CurrentTransportState
                written += o.print("<CurrentTransportState>");
                written += o.print(self->getTransportState());
                written += o.print("</CurrentTransportState>");
 
                // CurrentTransportStatus - return OK by default
                written += o.print(
                    "<CurrentTransportStatus>OK</CurrentTransportStatus>");
 
                // CurrentSpeed - simple renderer: report "1"
                written += o.print("<CurrentSpeed>1</CurrentSpeed>");
                return written;
              },
              ref);
        },
        200, nullptr, this);
    return true;
  }
 
  // AVTransport: GetPositionInfo
  bool processActionGetPositionInfo(ActionRequest& action,
                                    IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          return DeviceType::printReplyXML(
              out, "GetPositionInfoResponse", "AVTransport",
              [](Print& o, void* innerRef) -> size_t {
                auto self = (DLNAMediaRenderer*)innerRef;
                size_t written = 0;
                const bool hasUri = self->getCurrentUri() && *self->getCurrentUri();
 
                // Track (1 if URI present, else 0)
                written += o.print("<Track>");
                written += o.print(hasUri ? 1 : 0);
                written += o.print("</Track>");
 
                // TrackDuration (unknown -> 00:00:00)
                written += o.print("<TrackDuration>00:00:00</TrackDuration>");
 
                // TrackMetaData (DIDL-Lite or empty)
                written += o.print("<TrackMetaData>");
                written += o.print(StrView(self->getCurrentUriMetadata()).c_str());
                written += o.print("</TrackMetaData>");
 
                // TrackURI
                written += o.print("<TrackURI>");
                written += o.print(StrView(self->getCurrentUri()).c_str());
                written += o.print("</TrackURI>");
 
                // RelTime (hh:mm:ss based on getRelativeTimePositionSec)
                unsigned long secs = self->getRelativeTimePositionSec();
                int h = static_cast<int>(secs / 3600);
                int m = static_cast<int>((secs % 3600) / 60);
                int s = static_cast<int>(secs % 60);
                written += o.print("<RelTime>");
                if (h < 10) written += o.print('0');
                written += o.print(h);
                written += o.print(':');
                if (m < 10) written += o.print('0');
                written += o.print(m);
                written += o.print(':');
                if (s < 10) written += o.print('0');
                written += o.print(s);
                written += o.print("</RelTime>");
 
                // AbsTime (unknown -> 00:00:00)
                written += o.print("<AbsTime>00:00:00</AbsTime>");
 
                // RelCount, AbsCount (unknown -> 2147483647)
                written += o.print("<RelCount>2147483647</RelCount>");
                written += o.print("<AbsCount>2147483647</AbsCount>");
 
                return written;
              },
              ref);
        },
        200, nullptr, this);
    return true;
  }
 
  // AVTransport: GetTransportSettings
  bool processActionGetTransportSettings(ActionRequest& action,
                                         IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          return DeviceType::printReplyXML(
              out, "GetTransportSettingsResponse", "AVTransport",
              [](Print& o, void* innerRef) -> size_t {
                auto self = (DLNAMediaRenderer*)innerRef;
                size_t written = 0;
                // PlayMode: report configured play mode
                written += o.print("<PlayMode>");
                written += o.print(StrView(self->getPlayMode()).c_str());
                written += o.print("</PlayMode>");
 
                // RecQualityMode: single value - report NOT_IMPLEMENTED by
                // default
                written += o.print("<RecQualityMode>");
                written += o.print("NOT_IMPLEMENTED");
                written += o.print("</RecQualityMode>");
                return written;
              },
              ref);
        },
        200, nullptr, this);
    return true;
  }
 
  // AVTransport: GetMediaInfo
    bool processActionGetMediaInfo(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    client.reply(
      "text/xml",
      [](Print& out, void* ref) -> size_t {
        return DeviceType::printReplyXML(
          out, "GetMediaInfoResponse", "AVTransport",
          [](Print& o, void* innerRef) -> size_t {
          auto self = (DLNAMediaRenderer*)innerRef;
          size_t written = 0;
          // NrTracks: simple heuristic - 1 if a URI is present, 0
          // otherwise
          written += o.print("<NrTracks>");
          written += o.print(
            self->getCurrentUri() && *self->getCurrentUri() ? 1 : 0);
          written += o.print("</NrTracks>");
 
          // MediaDuration: unknown here -> empty string
          written += o.print("<MediaDuration></MediaDuration>");
 
          // CurrentURI and CurrentURIMetaData
          written += o.print("<CurrentURI>");
          written += o.print(StrView(self->getCurrentUri()).c_str());
          written += o.print("</CurrentURI>");
          written += o.print("<CurrentURIMetaData>");
          written +=
            o.print(StrView(self->getCurrentUriMetadata()).c_str());
          written += o.print("</CurrentURIMetaData>");
 
          // NextURI and NextURIMetaData: not supported -> empty
          written += o.print("<NextURI>NOT_IMPLEMENTED</NextURI>");
          written += o.print(
            "<NextURIMetaData>NOT_IMPLEMENTED</NextURIMetaData>");
 
          // PlayMedium / RecordMedium / WriteStatus: use configured
          // defaults
          written += o.print("<PlayMedium>");
          written += o.print(
            StrView(self->getPossiblePlaybackStorageMedia()).c_str());
          written += o.print("</PlayMedium>");
 
          written += o.print("<RecordMedium>");
          written += o.print(
            StrView(self->getPossibleRecordStorageMedia()).c_str());
          written += o.print("</RecordMedium>");
 
          written +=
            o.print("<WriteStatus>NOT_IMPLEMENTED</WriteStatus>");
 
          return written;
          },
          ref);
      },
      200, nullptr, this);
    return true;
    }
 
  bool processActionSetAVTransportURI(ActionRequest& action,
                                      IHttpServer& server, IClientHandler& client) {
    const char* uri = action.getArgumentValue("CurrentURI");
    current_uri_metadata = action.getArgumentValue("CurrentURIMetaData");
    if (uri && *uri) {
      setPlaybackURL(uri);
      if (event_cb) event_cb(MediaEvent::SET_URI, *this);
      client.reply(
          "text/xml",
          [](Print& out, void* ref) -> size_t {
            (void)ref;
            return DeviceType::printReplyXML(out, "SetAVTransportURIResponse",
                                             "AVTransport");
          },
          200, nullptr, this);
      return true;
    } else {
      DlnaLogger.log(DlnaLogLevel::Warning,
                     "SetAVTransportURI called with invalid SOAP payload");
      client.replyError(400, "Invalid Action");
      return false;
    }
  }
 
  bool processActionSetVolume(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    int desiredVolume = action.getArgumentIntValue("DesiredVolume");
    setVolume((uint8_t)desiredVolume);
    if (event_cb) event_cb(MediaEvent::SET_VOLUME, *this);
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          (void)ref;
          return DeviceType::printReplyXML(out, "SetVolumeResponse",
                                           "RenderingControl");
        },
        200, nullptr, this);
    return true;
  }
 
  bool processActionSetMute(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    bool desiredMute = action.getArgumentIntValue("DesiredMute") != 0;
    setMuted(desiredMute);
    if (event_cb) event_cb(MediaEvent::SET_MUTE, *this);
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          (void)ref;
          return DeviceType::printReplyXML(out, "SetMuteResponse",
                                           "RenderingControl");
        },
        200, nullptr, this);
    return true;
  }
 
  bool processActionGetMute(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          return DeviceType::printReplyXML(
              out, "GetMuteResponse", "RenderingControl",
              [](Print& o, void* innerRef) -> size_t {
                auto self = (DLNAMediaRenderer*)innerRef;
                size_t written = 0;
                written += o.print("<CurrentMute>");
                written += o.print(self->isMuted() ? 1 : 0);
                written += o.print("</CurrentMute>");
                return written;
              },
              ref);
        },
        200, nullptr, this);
    return true;
  }
 
  bool processActionGetVolume(ActionRequest& action, IHttpServer& server, IClientHandler& client) {
    client.reply(
        "text/xml",
        [](Print& out, void* ref) -> size_t {
          return DeviceType::printReplyXML(
              out, "GetVolumeResponse", "RenderingControl",
              [](Print& o, void* innerRef) -> size_t {
                auto self = (DLNAMediaRenderer*)innerRef;
                DlnaLogger.log(DlnaLogLevel::Debug, "GetVolume: %d",
                               self->getVolume());
                size_t written = 0;
                written += o.print("<CurrentVolume>");
                written += o.print((int)self->getVolume());
                written += o.print("</CurrentVolume>");
                return written;
              },
              ref);
        },
        200, nullptr, this);
    return true;
  }
 
  void setupRules() {
    rules.push_back({"ListPresets", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionListPresets(action, server, client);
    }});
    rules.push_back({"Play", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionPlay(action, server, client);
    }});
    rules.push_back({"Pause", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionPause(action, server, client);
    }});
    rules.push_back({"Stop", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionStop(action, server, client);
    }});
    rules.push_back({"GetCurrentTransportActions", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionGetCurrentTransportActions(action, server, client);
    }});
    rules.push_back({"GetTransportInfo", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionGetTransportInfo(action, server, client);
    }});
    rules.push_back({"GetTransportSettings", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionGetTransportSettings(action, server, client);
    }});
    rules.push_back({"GetPositionInfo", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionGetPositionInfo(action, server, client);
    }});
    rules.push_back({"GetMediaInfo", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionGetMediaInfo(action, server, client);
    }});
    rules.push_back({"GetDeviceCapabilities", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionGetDeviceCapabilities(action, server, client);
    }});
    rules.push_back({"SetAVTransportURI", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionSetAVTransportURI(action, server, client);
    }});
    rules.push_back({"SetVolume", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionSetVolume(action, server, client);
    }});
    rules.push_back({"SetMute", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionSetMute(action, server, client);
    }});
    rules.push_back({"GetMute", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionGetMute(action, server, client);
    }});
    rules.push_back({"GetVolume", [](DLNAMediaRenderer* self, ActionRequest& action, IHttpServer& server, IClientHandler& client) {
      return self->processActionGetVolume(action, server, client);
    }});
    // ConnectionManager rules
    rules.push_back(
        {"GetProtocolInfo", [](DLNAMediaRenderer* self, ActionRequest& action,
                               IHttpServer& server, IClientHandler& client) {
           return self->processActionGetProtocolInfo(action, server, client);
         }});
    rules.push_back({"GetCurrentConnectionIDs",
                     [](DLNAMediaRenderer* self, ActionRequest& action,
                        IHttpServer& server, IClientHandler& client) {
                       return self->processActionGetCurrentConnectionIDs(
                           action, server, client);
                     }});
    rules.push_back({"GetCurrentConnectionInfo",
                     [](DLNAMediaRenderer* self, ActionRequest& action,
                        IHttpServer& server, IClientHandler& client) {
                       return self->processActionGetCurrentConnectionInfo(
                           action, server, client);
                     }});
  }
};
 
}  // namespace tiny_dlna