MediaRenderer.h

Go to the documentation of this file.

#pragma once
#include <cctype>
#include <cstring>
 
#include "basic/Str.h"
#include "dlna/DLNADevice.h"
#include "dlna/xml/XMLAttributeParser.h"
#include "mr_conmgr.h"
#include "mr_control.h"
#include "mr_transport.h"
 
namespace tiny_dlna {
enum class MediaEvent { SET_URI, PLAY, PAUSE, STOP, SET_VOLUME, SET_MUTE };
 
class MediaRenderer : public DLNADeviceInfo {
 public:
  // event handler: (event, reference to MediaRenderer)
  typedef void (*MediaEventHandler)(MediaEvent event, MediaRenderer& renderer);
 
  MediaRenderer() {
    // Constructor
    DlnaLogger.log(DlnaLogLevel::Info, "MediaRenderer::MediaRenderer");
    setSerialNumber(usn);
    setDeviceType(st);
    setFriendlyName("MediaRenderer");
    setManufacturer("TinyDLNA");
    setModelName("TinyDLNA");
    setModelNumber("1.0");
    setBaseURL("http://localhost:44757");
  }
 
  void setMediaEventHandler(MediaEventHandler cb) { event_cb = cb; }
 
  bool setVolume(uint8_t volumePercent) {
    if (volumePercent > 100) volumePercent = 100;
    DlnaLogger.log(DlnaLogLevel::Info, "Set volume: %d", volumePercent);
    current_volume = volumePercent;
    if (event_cb) event_cb(MediaEvent::SET_VOLUME, *this);
    return true;
  }
 
  uint8_t getVolume() { return current_volume; }
 
  bool setMute(bool mute) {
    is_muted = mute;
    DlnaLogger.log(DlnaLogLevel::Info, "Set mute: %s", mute ? "true" : "false");
    if (event_cb) event_cb(MediaEvent::SET_MUTE, *this);
    return true;
  }
 
  bool isMuted() { return is_muted; }
 
  bool isActive() { return is_active; }
 
  void setActive(bool active) {
    DlnaLogger.log(DlnaLogLevel::Info, "Set active: %s",
                   active ? "true" : "false");
    is_active = active;
  }
 
  unsigned long getPosition() {
    // Estimate position; return 0 if not active or start_time not set
    if (!is_active || start_time == 0) return 0;
    return millis() - start_time;
  }
 
  const char* getMime() {
    // Prefer explicit MIME from DIDL if available
    if (!current_mime.isEmpty()) return current_mime.c_str();
    return nullptr;
  }
 
  // Access current URI
  const char* getCurrentUri() { return current_uri.c_str(); }
 
  const char* getTransportState() { return transport_state.c_str(); }
 
 protected:
  tiny_dlna::Str current_uri;
  tiny_dlna::Str current_mime;
  MediaEventHandler event_cb = nullptr;
  uint8_t current_volume = 50;
  bool is_muted = false;
  bool is_active = false;
  unsigned long start_time = 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";
 
  void setupServices(HttpServer& server, IUDPService& udp) {
    setupServicesImpl(&server);
  }
 
  bool play(const char* urlStr) {
    if (urlStr == nullptr) return false;
    DlnaLogger.log(DlnaLogLevel::Info, "play 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);
      event_cb(MediaEvent::PLAY, *this);
    }
    is_active = true;
    start_time = millis();
    return true;
  }
 
  void setMime(const char* mime) {
    if (mime) {
      current_mime = mime;
      DlnaLogger.log(DlnaLogLevel::Info, "Set mime: %s", current_mime.c_str());
    }
  }
 
  void playbackCompleted() {
    DlnaLogger.log(DlnaLogLevel::Info, "Playback completed");
    transport_state = "STOPPED";
    is_active = false;
    start_time = 0;
    // notify application handler about the stop
    if (event_cb) event_cb(MediaEvent::STOP, *this);
    // publish UPnP event to subscribers (if subscription manager available)
    SubscriptionMgr* mgr = tiny_dlna::DLNADevice::getSubscriptionMgr();
    if (mgr) {
      mgr->publishProperty("/AVT/event", "TransportState", "STOPPED");
    }
  }
 
  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 const char* reply() {
    static const char* result =
        "<s:Envelope "
        "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/"
        "\"><s:Body><u:%1 "
        "xmlns:u=\"urn:schemas-upnp-org:service:%2:"
        "1\"></u:%1></s:Body></s:Envelope>";
    return result;
  }
 
  // Transport control handler
  static void transportControlCB(HttpServer* server, const char* requestPath,
                                 HttpRequestHandlerLine* hl) {
    // Parse SOAP request and extract action
    Str soap = server->contentStr();
    DlnaLogger.log(DlnaLogLevel::Info, "Transport Control: %s", soap.c_str());
    MediaRenderer& media_renderer = *((MediaRenderer*)hl->context[0]);
 
    Str reply_str{reply()};
    reply_str.replaceAll("%2", "AVTransport");
    if (soap.indexOf("Play") >= 0) {
      media_renderer.setActive(true);
      reply_str.replaceAll("%1", "PlayResponse");
      server->reply("text/xml", reply_str.c_str());
    } else if (soap.indexOf("Pause") >= 0) {
      media_renderer.setActive(false);
      reply_str.replaceAll("%1", "PauseResponse");
      server->reply("text/xml", reply_str.c_str());
    } else if (soap.indexOf("Stop") >= 0) {
      media_renderer.setActive(false);
      reply_str.replaceAll("%1", "StopResponse");
      server->reply("text/xml", reply_str.c_str());
    } else if (soap.indexOf("SetAVTransportURI") >= 0) {
      // Extract URL from SOAP request safely
      int urlTagStart = soap.indexOf("<CurrentURI>");
      int urlTagEnd = soap.indexOf("</CurrentURI>");
      if (urlTagStart >= 0 && urlTagEnd > urlTagStart) {
        int urlStart = urlTagStart + (int)strlen("<CurrentURI>");
        Str url = soap.substring(urlStart, urlTagEnd);
        media_renderer.play(url.c_str());
      } else {
        DlnaLogger.log(DlnaLogLevel::Warning,
                       "SetAVTransportURI called with invalid SOAP payload");
      }
      reply_str.replaceAll("%1", "SetAVTransportURIResponse");
      server->reply("text/xml", reply_str.c_str());
    } else {
      // Handle other transport controls
      reply_str.replaceAll("%1", "ActionResponse");
      server->reply("text/xml", reply_str.c_str());
    }
  }
 
  // Rendering control handler
  static void renderingControlCB(HttpServer* server, const char* requestPath,
                                 HttpRequestHandlerLine* hl) {
    // Parse SOAP request and extract action
    MediaRenderer& media_renderer = *((MediaRenderer*)hl->context[0]);
    Str soap = server->contentStr();
    DlnaLogger.log(DlnaLogLevel::Info, "Rendering Control: %s", soap.c_str());
    Str reply_str{reply()};
    reply_str.replaceAll("%2", "RenderingControl");
 
    if (soap.indexOf("SetVolume") >= 0) {
      // Extract volume from SOAP request safely
      int volTagStart = soap.indexOf("<DesiredVolume>");
      int volTagEnd = soap.indexOf("</DesiredVolume>");
      if (volTagStart >= 0 && volTagEnd > volTagStart) {
        int volStart = volTagStart + (int)strlen("<DesiredVolume>");
        int volume = soap.substring(volStart, volTagEnd).toInt();
        media_renderer.setVolume(volume);
      } else {
        DlnaLogger.log(DlnaLogLevel::Warning,
                       "SetVolume called with invalid SOAP payload");
      }
      reply_str.replaceAll("%1", "SetVolumeResponse");
      server->reply("text/xml", reply_str.c_str());
    } else if (soap.indexOf("SetMute") >= 0) {
      // Extract mute state from SOAP request safely
      int muteTagStart = soap.indexOf("<DesiredMute>");
      int muteTagEnd = soap.indexOf("</DesiredMute>");
      if (muteTagStart >= 0 && muteTagEnd > muteTagStart) {
        int muteStart = muteTagStart + (int)strlen("<DesiredMute>");
        bool mute = (soap.substring(muteStart, muteTagEnd) == "1");
        media_renderer.setMute(mute);
      } else {
        DlnaLogger.log(DlnaLogLevel::Warning,
                       "SetMute called with invalid SOAP payload");
      }
      reply_str.replaceAll("%1", "SetMuteResponse");
      server->reply("text/xml", reply_str.c_str());
    } else {
      // Handle other rendering controls
      reply_str.replaceAll("%1", "RenderingControl");
      server->reply("text/xml", reply_str.c_str());
    }
  };
 
  void setupServicesImpl(HttpServer* server) {
    DlnaLogger.log(DlnaLogLevel::Info, "MediaRenderer::setupServices");
 
    auto transportCB = [](HttpServer* server, const char* requestPath,
                          HttpRequestHandlerLine* hl) {
            server->reply("text/xml", [](Print& out){ mr_connmgr_xml_printer(out); });
    };
 
    auto connmgrCB = [](HttpServer* server, const char* requestPath,
                        HttpRequestHandlerLine* hl) {
      server->reply("text/xml", [](Print& out){ mr_connmgr_xml_printer(out); });
    };
 
    auto controlCB = [](HttpServer* server, const char* requestPath,
                        HttpRequestHandlerLine* hl) {
      server->reply("text/xml", [](Print& out){ mr_control_xml_printer(out); });
    };
 
    // define services
    DLNAServiceInfo rc, cm, avt;
    avt.setup("urn:schemas-upnp-org:service:AVTransport:1",
              "urn:upnp-org:serviceId:AVTransport", "/AVT/service.xml",
              transportCB, "/AVT/control", transportControlCB, "/AVT/event",
              [](HttpServer* server, const char* requestPath,
                 HttpRequestHandlerLine* hl) { server->replyOK(); });
 
    cm.setup(
        "urn:schemas-upnp-org:service:ConnectionManager:1",
        "urn:upnp-org:serviceId:ConnectionManager", "/CM/service.xml",
        connmgrCB, "/CM/control",
        [](HttpServer* server, const char* requestPath,
           HttpRequestHandlerLine* hl) { server->replyOK(); },
        "/CM/event",
        [](HttpServer* server, const char* requestPath,
           HttpRequestHandlerLine* hl) { server->replyOK(); });
 
    rc.setup("urn:schemas-upnp-org:service:RenderingControl:1",
             "urn:upnp-org:serviceId:RenderingControl", "/RC/service.xml",
             controlCB, "/RC/control", renderingControlCB, "/RC/event",
             [](HttpServer* server, const char* requestPath,
                HttpRequestHandlerLine* hl) { server->replyOK(); });
 
    addService(rc);
    addService(cm);
    addService(avt);
  }
};
 
}  // namespace tiny_dlna