DLNAMediaRenderer.h

Go to the documentation of this file.

#pragma once
#include <cctype>
#include <cstring>
 
#include "DLNAMediaRendererDescr.h"
#include "basic/Str.h"
#include "dlna/devices/DLNADevice.h"
#include "dlna/xml/XMLAttributeParser.h"
#include "dlna/xml/XMLParserPrint.h"
 
namespace tiny_dlna {
enum class MediaEvent { SET_URI, PLAY, PAUSE, STOP, SET_VOLUME, SET_MUTE };
 
class DLNAMediaRenderer : public DLNADeviceInfo {
 public:
  // event handler: (event, reference to MediaRenderer)
  typedef void (*MediaEventHandler)(MediaEvent event,
                                    DLNAMediaRenderer& renderer);
 
  DLNAMediaRenderer() {
    // Constructor
    DlnaLogger.log(DlnaLogLevel::Info, "MediaRenderer::MediaRenderer");
    setSerialNumber(usn);
    setDeviceType(st);
    setFriendlyName("ArduinoMediaRenderer");
    setManufacturer("TinyDLNA");
    setModelName("TinyDLNA");
    setModelNumber("1.0");
    setBaseURL("http://localhost:44757");
    setupRules();
  }
 
  DLNAMediaRenderer(HttpServer& server, IUDPService& udp)
      : DLNAMediaRenderer() {
    setHttpServer(server);
    setUdpService(udp);
  }
 
  // Start the underlying DLNA device using the stored server/udp
  bool begin() { return dlna_device.begin(*this, *p_udp_member, *p_server); }
 
  void end() {
    if (is_active) stop();
    dlna_device.end();
  }
 
  bool loop() { return dlna_device.loop(); }
 
  void setHttpServer(HttpServer& server) {
    p_server = &server;
    // prepare handler context and register each service via helpers
    ref_ctx[0] = this;
    setupServicesImpl(&server);
  }
 
  void setUdpService(IUDPService& udp) { p_udp_member = &udp; }
 
  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";
    (void)transport_state;  // 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("<TransportState val=\"");
        written += out.print(self->transport_state.c_str());
        written += out.print("\"/>");
        return written;
      };
      addChange("AVT", writer);
    }
  }
 
  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("\"/>");
        return written;
      };
      addChange("RCS", writer);
    }
    if (event_cb) event_cb(MediaEvent::SET_VOLUME, *this);
  }
 
  bool isMuted() { return is_muted; }
 
  void setMuted(bool m) {
    is_muted = m;
    (void)is_muted;  // 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("<Mute val=\"");
        written += out.print(self->is_muted ? 1 : 0);
        written += out.print("\"/>");
        return written;
      };
      addChange("RCS", writer);
    }
    if (event_cb) event_cb(MediaEvent::SET_MUTE, *this);
  }
 
  // Access current URI
  const char* getCurrentUri() { return current_uri.c_str(); }
 
  const char* getTransportState() { return transport_state.c_str(); }
 
  DLNADevice& device() { return dlna_device; }
 
  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 and play
    if (event_cb) {
      event_cb(MediaEvent::SET_URI, *this);
      event_cb(MediaEvent::PLAY, *this);
    }
    is_active = true;
    start_time = millis();
    time_sum = 0;
 
    // 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("<CurrentTrackURI val=\"");
        written += out.print(self->current_uri.c_str());
        written += out.print("\"/>\n");
        written += out.print("<TransportState val=\"");
        written += out.print(self->transport_state.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);
    // notify handler about the new URI and play
    if (event_cb) {
      event_cb(MediaEvent::SET_URI, *this);
    }
 
    (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("<CurrentTrackURI val=\"");
        written += out.print(self->current_uri.c_str());
        written += out.print("\"/>\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;
    // notify handler about the stop
    if (event_cb) event_cb(MediaEvent::STOP, *this);
    // 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("\"/>");
      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;
    // notify application handler about the stop
    if (event_cb) event_cb(MediaEvent::STOP, *this);
    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 (is_active) {
      return "Pause,Stop";
    } else {
      return "Play,Stop";
    }
  }
  void setCustomActionRule(const char* suffix,
                           bool (*handler)(DLNAMediaRenderer*, ActionRequest&,
                                           HttpServer&)) {
    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});
  }
 
 protected:
  tiny_dlna::Str current_uri;
  tiny_dlna::Str current_mime;
  MediaEventHandler event_cb = nullptr;
  uint8_t current_volume = 50;
  bool is_muted = false;
  unsigned long start_time = 0;
  unsigned long time_sum = 0;
  // Current transport state string (e.g. "STOPPED", "PLAYING",
  // "PAUSED_PLAYBACK")
  tiny_dlna::Str transport_state = "NO_MEDIA_PRESENT";
  const char* st = "urn:schemas-upnp-org:device:MediaRenderer:1";
  const char* usn = "uuid:09349455-2941-4cf7-9847-1dd5ab210e97";
 
  // internal DLNA device instance owned by this MediaRenderer
  DLNADevice dlna_device;
  HttpServer* p_server = nullptr;
  IUDPService* p_udp_member = nullptr;
  // reusable context pointer array for HttpServer handlers (contains `this`)
  void* ref_ctx[1] = {nullptr};
  Vector<ActionRule> rules;
 
  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;
        StrPrint tmp;
        tmp.printf("<TransportState val=\"%s\"/>",
                   self->transport_state.c_str());
        if (!self->current_uri.isEmpty()) {
          tmp.printf("<CurrentTrackURI val=\"%s\"/>",
                     self->current_uri.c_str());
        }
        tmp.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));
        tmp.printf("<CurrentTransportActions val=\"%s\"/>",
                   self->getCurrentTransportActions());
        return out.print(tmp.c_str());
      };
      addChange("AVT", writer);
    }
  }
 
  void publishRCS() {
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaRenderer*)ref;
      StrPrint tmp;
      tmp.printf("<Volume val=\"%d\"/>", self->current_volume);
      tmp.printf("<Mute val=\"%d\"/>", self->is_muted ? 1 : 0);
      return out.print(tmp.c_str());
    };
    addChange("RCS", writer);
  }
 
  void publishCMS() {
    // Minimal information: list of current connection IDs. Use "0" as default
    // when no active connection is present.
    {
      auto writer = [](Print& out, void* ref) -> size_t {
        (void)ref;
        return out.print("<CurrentConnectionIDs>0</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[64] = {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(HttpServer* server, const char* requestPath,
                               HttpRequestHandlerLine* hl) {
    server->reply("text/xml", [](Print& out) {
      DLNAMediaRendererTransportDescr d;
      d.printDescr(out);
    });
  }
 
  static void connmgrDescrCB(HttpServer* server, const char* requestPath,
                             HttpRequestHandlerLine* hl) {
    server->reply("text/xml", [](Print& out) {
      DLNAMediaRendererConnectionMgrDescr d;
      d.printDescr(out);
    });
  }
 
  static void controlDescrCB(HttpServer* server, const char* requestPath,
                             HttpRequestHandlerLine* hl) {
    server->reply("text/xml", [](Print& out) {
      DLNAMediaRendererControlDescr d;
      d.printDescr(out);
    });
  }
 
  // Generic control callback: parse SOAP action and dispatch to instance
  static void controlCB(HttpServer* server, const char* requestPath,
                        HttpRequestHandlerLine* hl) {
    ActionRequest action;
    DLNADevice::parseActionRequest(server, requestPath, hl, action);
 
    DLNAMediaRenderer* mr = nullptr;
    if (hl && hl->context[0]) mr = (DLNAMediaRenderer*)hl->context[0];
 
    if (mr) {
      if (mr->processAction(action, *server)) return;
    }
 
    server->replyNotFound();
  }
 
  static void eventSubscriptionHandler(HttpServer* server,
                                       const char* requestPath,
                                       HttpRequestHandlerLine* hl) {
    DLNADevice::eventSubscriptionHandler(server, requestPath, hl);
    DLNAMediaRenderer* device = (DLNAMediaRenderer*)(hl->context[0]);
    if (device) {
      StrView request_path_str(requestPath);
      if (request_path_str.contains("/AVT/"))
        device->publishAVT();
      else if (request_path_str.contains("/RC/"))
        device->publishRCS();
      else if (request_path_str.contains("/CM/"))
        device->publishCMS();
    }
  }
 
  // Setup and register individual services
  void setupTransportService(HttpServer* 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",
              &DLNAMediaRenderer::controlCB, "/AVT/event",
              [](HttpServer* server, const char* requestPath,
                 HttpRequestHandlerLine* hl) { server->replyOK(); });
    avt.subscription_namespace_abbrev = "AVT";
    // register URLs on the provided server so SCPD, control and event
    // subscription endpoints are available immediately
    server->on(avt.scpd_url, T_GET, avt.scp_cb, ref_ctx, 1);
    server->on(avt.control_url, T_POST, avt.control_cb, ref_ctx, 1);
    server->on(avt.event_sub_url, T_SUBSCRIBE, eventSubscriptionHandler,
               ref_ctx, 1);
    server->on(avt.event_sub_url, T_UNSUBSCRIBE,
               tiny_dlna::DLNADevice::eventSubscriptionHandler, ref_ctx, 1);
    server->on(avt.event_sub_url, T_POST,
               tiny_dlna::DLNADevice::eventSubscriptionHandler, ref_ctx, 1);
 
    addService(avt);
  }
 
  void setupConnectionManagerService(HttpServer* server) {
    DLNAServiceInfo cm;
    cm.setup(
        "urn:schemas-upnp-org:service:ConnectionManager:1",
        "urn:upnp-org:serviceId:ConnectionManager", "/CM/service.xml",
        &DLNAMediaRenderer::connmgrDescrCB, "/CM/control",
        [](HttpServer* server, const char* requestPath,
           HttpRequestHandlerLine* hl) { server->replyOK(); },
        "/CM/event",
        [](HttpServer* server, const char* requestPath,
           HttpRequestHandlerLine* hl) { server->replyOK(); });
    cm.subscription_namespace_abbrev = "CMS";
 
    server->on(cm.scpd_url, T_GET, cm.scp_cb, ref_ctx, 1);
    server->on(cm.control_url, T_POST, cm.control_cb, ref_ctx, 1);
    server->on(cm.event_sub_url, T_SUBSCRIBE, eventSubscriptionHandler, ref_ctx,
               1);
    server->on(cm.event_sub_url, T_UNSUBSCRIBE,
               tiny_dlna::DLNADevice::eventSubscriptionHandler, ref_ctx, 1);
    server->on(cm.event_sub_url, T_POST,
               tiny_dlna::DLNADevice::eventSubscriptionHandler, ref_ctx, 1);
 
    addService(cm);
  }
 
  void setupRenderingControlService(HttpServer* server) {
    DLNAServiceInfo rc;
    rc.setup("urn:schemas-upnp-org:service:RenderingControl:1",
             "urn:upnp-org:serviceId:RenderingControl", "/RC/service.xml",
             &DLNAMediaRenderer::controlDescrCB, "/RC/control",
             &DLNAMediaRenderer::controlCB, "/RC/event",
             [](HttpServer* server, const char* requestPath,
                HttpRequestHandlerLine* hl) { server->replyOK(); });
    rc.subscription_namespace_abbrev = "RCS";
    server->on(rc.scpd_url, T_GET, rc.scp_cb, ref_ctx, 1);
    server->on(rc.control_url, T_POST, rc.control_cb, ref_ctx, 1);
    server->on(rc.event_sub_url, T_SUBSCRIBE, eventSubscriptionHandler, ref_ctx,
               1);
    server->on(rc.event_sub_url, T_UNSUBSCRIBE,
               tiny_dlna::DLNADevice::eventSubscriptionHandler, ref_ctx, 1);
    server->on(rc.event_sub_url, T_POST,
               tiny_dlna::DLNADevice::eventSubscriptionHandler, ref_ctx, 1);
 
    addService(rc);
  }
 
  void setupServicesImpl(HttpServer* server) {
    DlnaLogger.log(DlnaLogLevel::Info, "MediaRenderer::setupServices");
    // register the individual services and register their endpoints on the
    // provided HttpServer
    setupTransportService(server);
    setupConnectionManagerService(server);
    setupRenderingControlService(server);
  }
 
  static int printReplyXML(Print& out, const char* replyName,
                           const char* serviceId,
                           const char* values = nullptr) {
    XMLPrinter xp(out);
    size_t result = 0;
    result += xp.printNodeBegin(
        "s:Envelope", "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"");
    result += xp.printNodeBegin("s:Body");
    result += xp.printf("<u:%s xmlns:u=\"urn:schemas-upnp-org:service:%s:1\">",
                        replyName, serviceId);
 
    // e.g.<u:return>Stop,Pause,Next,Seek</u:return> for
    // QueryStateVariableResponse
    if (values) {
      result += xp.printf("%s", values);
    }
 
    result += xp.printf("</u:%s>", replyName);
    result += xp.printNodeEnd("s:Body");
    result += xp.printNodeEnd("s:Envelope");
    return result;
  }
 
  // Static reply helper methods for SOAP actions
  static size_t replyPlay(Print& out) {
    return DLNAMediaRenderer::printReplyXML(out, "PlayResponse", "AVTransport");
  }
  static size_t replyPause(Print& out) {
    return DLNAMediaRenderer::printReplyXML(out, "PauseResponse",
                                            "AVTransport");
  }
  static size_t replyStop(Print& out) {
    return DLNAMediaRenderer::printReplyXML(out, "StopResponse", "AVTransport");
  }
  static size_t replySetAVTransportURI(Print& out) {
    return DLNAMediaRenderer::printReplyXML(out, "SetAVTransportURIResponse",
                                            "AVTransport");
  }
  static size_t replySetVolume(Print& out) {
    return DLNAMediaRenderer::printReplyXML(out, "SetVolumeResponse",
                                            "RenderingControl");
  }
  static size_t replySetMute(Print& out) {
    return DLNAMediaRenderer::printReplyXML(out, "SetMuteResponse",
                                            "RenderingControl");
  }
  // Static reply helper for GetMute
  static size_t replyGetMute(Print& out, bool isMuted) {
    StrPrint values;
    values.printf("<CurrentMute>%d</CurrentMute>", isMuted ? 1 : 0);
    return DLNAMediaRenderer::printReplyXML(out, "GetMuteResponse",
                                            "RenderingControl", values.c_str());
  }
 
  // Static reply helper for GetVolume
  static size_t replyGetVolume(Print& out, uint8_t volume) {
    StrPrint values;
    values.printf("<CurrentVolume>%d</CurrentVolume>", volume);
    return DLNAMediaRenderer::printReplyXML(out, "GetVolumeResponse",
                                            "RenderingControl", values.c_str());
  }
 
  bool processAction(ActionRequest& action, HttpServer& server) {
    DlnaLogger.log(DlnaLogLevel::Info, "DLNAMediaRenderer::processAction: %s",
                   action.action);
    StrView action_str(action.action);
    if (action_str.isEmpty()) {
      DlnaLogger.log(DlnaLogLevel::Error, "Empty action received");
      server.replyError(400, "Invalid Action");
      return false;
    }
 
    for (const auto& rule : rules) {
      if (action_str.endsWith(rule.suffix)) {
        return rule.handler(this, action, server);
      }
    }
    DlnaLogger.log(DlnaLogLevel::Error, "Unsupported action: %s",
                   action.action);
    server.replyError(400, "Invalid Action");
    return false;
  }
 
  void setupRules() {
    rules.push_back({"Play", [](DLNAMediaRenderer* self, ActionRequest& action,
                                HttpServer& server) {
                       self->setActive(true);
                       NullPrint nop;
                       server.reply("text/xml",
                                    DLNAMediaRenderer::replyPlay(nop),
                                    &DLNAMediaRenderer::replyPlay);
                       return true;
                     }});
    rules.push_back({"Pause", [](DLNAMediaRenderer* self, ActionRequest& action,
                                 HttpServer& server) {
                       self->setActive(false);
                       NullPrint nop;
                       server.reply("text/xml",
                                    DLNAMediaRenderer::replyPause(nop),
                                    &DLNAMediaRenderer::replyPause);
                       return true;
                     }});
    rules.push_back({"Stop", [](DLNAMediaRenderer* self, ActionRequest& action,
                                HttpServer& server) {
                       self->setActive(false);
                       NullPrint nop;
                       server.reply("text/xml",
                                    DLNAMediaRenderer::replyStop(nop),
                                    &DLNAMediaRenderer::replyStop);
                       return true;
                     }});
    rules.push_back({"GetCurrentTransportActions",
                     [](DLNAMediaRenderer* self, ActionRequest& action,
                        HttpServer& server) {
                       StrPrint returnValue;
                       returnValue.printf("<u:return>%s</u:return>",
                                          self->getCurrentTransportActions());
                       StrPrint xml;
                       DLNAMediaRenderer::printReplyXML(
                           xml, "QueryStateVariableResponse", "AVTransport",
                           returnValue.c_str());
                       server.reply("text/xml", xml.c_str(), xml.length());
                       return true;
                     }});
    rules.push_back(
        {"SetAVTransportURI", [](DLNAMediaRenderer* self, ActionRequest& action,
                                 HttpServer& server) {
           const char* uri = action.getArgumentValue("CurrentURI");
           if (uri && *uri) {
             self->setPlaybackURL(uri);
             NullPrint nop;
             server.reply("text/xml",
                          DLNAMediaRenderer::replySetAVTransportURI(nop),
                          &DLNAMediaRenderer::replySetAVTransportURI);
             return true;
           } else {
             DlnaLogger.log(
                 DlnaLogLevel::Warning,
                 "SetAVTransportURI called with invalid SOAP payload");
             server.replyError(400, "Invalid Action");
             return false;
           }
         }});
    rules.push_back(
        {"SetVolume", [](DLNAMediaRenderer* self, ActionRequest& action,
                         HttpServer& server) {
           int desiredVolume = action.getArgumentIntValue("DesiredVolume");
           self->setVolume((uint8_t)desiredVolume);
           NullPrint nop;
           server.reply("text/xml", DLNAMediaRenderer::replySetVolume(nop),
                        &DLNAMediaRenderer::replySetVolume);
           return true;
         }});
    rules.push_back(
        {"SetMute", [](DLNAMediaRenderer* self, ActionRequest& action,
                       HttpServer& server) {
           bool desiredMute = action.getArgumentIntValue("DesiredMute") != 0;
           self->setMuted(desiredMute);
           NullPrint nop;
           server.reply("text/xml", DLNAMediaRenderer::replySetMute(nop),
                        &DLNAMediaRenderer::replySetMute);
           return true;
         }});
    // Add GetMute rule
    rules.push_back({"GetMute", [](DLNAMediaRenderer* self,
                                   ActionRequest& action, HttpServer& server) {
                       StrPrint str;
                       DLNAMediaRenderer::replyGetMute(str, self->isMuted());
                       server.reply("text/xml", str.c_str());
                       return true;
                     }});
    // Add GetVolume rule
    rules.push_back(
        {"GetVolume", [](DLNAMediaRenderer* self, ActionRequest& action,
                         HttpServer& server) {
           StrPrint str;
           DLNAMediaRenderer::replyGetVolume(str, self->getVolume());
           server.reply("text/xml", str.c_str());
           return true;
         }});
  }
};
 
}  // namespace tiny_dlna