DLNAMediaServer.h

Go to the documentation of this file.

// Minimal header-only Digital Media Server (MediaServer) device
#pragma once
 
#include "DLNAMediaServerDescr.h"
#include "MediaItem.h"
#include "basic/EscapingPrint.h"
#include "basic/Str.h"
#include "dlna/Action.h"
#include "dlna/StringRegistry.h"
#include "dlna/devices/DLNADevice.h"
#include "dlna/devices/MediaServer/MediaItem.h"
#include "dlna/xml/XMLParserPrint.h"
#include "dlna/xml/XMLPrinter.h"
#include "http/Http.h"
 
namespace tiny_dlna {
 
class DLNAMediaServer : public DLNADeviceInfo {
 public:
  typedef void (*PrepareDataCallback)(
      const char* objectID, ContentQueryType queryType, const char* filter,
      int startingIndex, int requestedCount, const char* sortCriteria,
      int& numberReturned, int& totalMatches, int& updateID, void* reference);
 
  typedef bool (*GetDataCallback)(int index, MediaItem& item, void* reference);
 
  DLNAMediaServer() {
    setSerialNumber(usn);
    setDeviceType(st);
    setFriendlyName("ArduinoMediaServer");
    setManufacturer("TinyDLNA");
    setManufacturerURL("https://github.com/pschatzmann/arduino-dlna");
    setModelName("TinyDLNA MediaServer");
    setModelNumber("1.0");
    setBaseURL("http://localhost:44757");
    setupRules();
  }
  DLNAMediaServer(HttpServer& server, IUDPService& udp) : DLNAMediaServer() {
    // use setters so derived classes or overrides get a consistent path
    setHttpServer(server);
    setUdpService(udp);
  }
 
  ~DLNAMediaServer() { end(); }
 
  void setHttpServer(HttpServer& server) {
    // ensure instance pointer is available for callbacks
    self = this;
    p_server = &server;
    // prepare handler context and register service endpoints on the provided
    // server
    ref_ctx[0] = this;
    setupServicesImpl(&server);
  }
 
  void setUdpService(IUDPService& udp) { p_udp_member = &udp; }
 
  bool begin() {
    DlnaLogger.log(DlnaLogLevel::Info, "MediaServer::begin");
    return dlna_device.begin(*this, *p_udp_member, *p_server);
  }
 
  void end() {
    DlnaLogger.log(DlnaLogLevel::Info, "MediaServer::end");
    dlna_device.end();
  }
 
  bool loop() { return dlna_device.loop(); }
 
  void setSearchCapabilities(const char* caps) { g_search_capabiities = caps; }
 
  const char* getSearchCapabilities() { return g_search_capabiities; }
 
  void setSortCapabilities(const char* caps) { g_sort_capabilities = caps; }
 
  const char* getSortCapabilities() { return g_sort_capabilities; }
 
  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 = (DLNAMediaServer*)ref;
      size_t result = 0;
      result += out.print("<SourceProtocolInfo>\n");
      result += out.print(StringRegistry::nullStr(self->getSourceProtocols()));
      result += out.print("</SourceProtocolInfo>\n");
      result += out.print("<SinkProtocolInfo>\n");
      result += out.print(StringRegistry::nullStr(self->getSinkProtocols()));
      result += out.print("</SinkProtocolInfo>\n");
      return result;
    };
    addChange("CMS", writer);
  }
 
  const char* getSourceProtocols() { return sourceProto; }
 
  const char* getSinkProtocols() { return sinkProto; }
 
  void setPrepareDataCallback(PrepareDataCallback cb) { prepare_data_cb = cb; }
 
  void setGetDataCallback(GetDataCallback cb) { get_data_cb = cb; }
 
  void setReference(void* ref) { reference_ = ref; }
 
  HttpServer* getHttpServer() { return p_server; }
 
  int getSystemUpdateID() { return g_stream_updateID; }
 
  int incrementSystemUpdateID() { return ++g_stream_updateID; }
 
  DLNADevice& device() { return dlna_device; }
 
  void setCustomActionRule(const char* suffix,
                           bool (*handler)(DLNAMediaServer*, 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:
  // Action rule struct for ContentDirectory
  struct ActionRule {
    const char* suffix;
    bool (*handler)(DLNAMediaServer*, ActionRequest&, HttpServer&);
  };
 
  static inline DLNAMediaServer* self = nullptr;
  // internal DLNA device instance owned by this MediaServer
  DLNADevice dlna_device;
  // stored callbacks
  PrepareDataCallback prepare_data_cb = nullptr;
  GetDataCallback get_data_cb = nullptr;
 
  HttpServer* p_server = nullptr;
  IUDPService* p_udp_member = nullptr;
  void* ref_ctx[1] = {nullptr};
  void* reference_ = nullptr;
  GetDataCallback g_stream_get_data_cb = nullptr;
  int g_stream_numberReturned = 0;
  int g_stream_totalMatches = 0;
  int g_stream_updateID = 1;
  int g_instance_id = 1;
  void* g_stream_reference = nullptr;
  const char* st = "urn:schemas-upnp-org:device:MediaServer:1";
  const char* usn = "uuid:media-server-0000-0000-0000-000000000001";
  const char* g_search_capabiities =
      "dc:title,dc:creator,upnp:class,upnp:genre,"
      "upnp:album,upnp:artist,upnp:albumArtURI";
  const char* g_sort_capabilities =
      "dc:title,dc:date,upnp:class,upnp:album,upnp:episodeNumber,upnp:"
      "originalTrackNumber";
  // Default protocol info values (use DLNA_PROTOCOL by default)
  const char* sourceProto = DLNA_PROTOCOL_AUDIO;
  const char* sinkProto = "";
  const char* connectionID = "0";
  Vector<ActionRule> rules;
 
  void addChange(const char* serviceAbbrev,
                 std::function<size_t(Print&, void*)> changeWriter) {
    dlna_device.addChange(serviceAbbrev, changeWriter, this);
  }
 
  void publishAVT() {
    DlnaLogger.log(DlnaLogLevel::Info, "MediaServer::publishAVT");
    // Publish SystemUpdateID using a writer that reads the current value
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaServer*)ref;
      size_t result = 0;
      result += out.print("<SystemUpdateID val=\"");
      result += out.print(self->g_stream_updateID);
      result += out.print("\"/>\n");
      return result;
    };
    addChange("AVT", writer);
  }
 
  void publishCMS() {
    DlnaLogger.log(DlnaLogLevel::Info, "MediaServer::publishCMS");
    // Publish current ConnectionManager properties using a writer that
    // reads live state from the device
    auto writer = [](Print& out, void* ref) -> size_t {
      auto self = (DLNAMediaServer*)ref;
      size_t result = 0;
      result += out.print("<SourceProtocolInfo>\n");
      result += out.print(StringRegistry::nullStr(self->sourceProto));
      result += out.print("</SourceProtocolInfo>\n");
      result += out.print("<SinkProtocolInfo>\n");
      result += out.print(StringRegistry::nullStr(self->sinkProto));
      result += out.print("</SinkProtocolInfo>\n");
      result += out.print("<CurrentConnectionIDs>");
      result += out.print(StringRegistry::nullStr(self->connectionID));
      result += out.print("</CurrentConnectionIDs>\n");
      return result;
    };
    addChange("CMS", writer);
  }
 
  void setupServicesImpl(HttpServer* server) {
    DlnaLogger.log(DlnaLogLevel::Info, "MediaServer::setupServices");
 
    // register the individual services via helpers
    setupContentDirectoryService(server);
    setupConnectionManagerService(server);
  }
 
  static void contentDescCB(HttpServer* server, const char* requestPath,
                            HttpRequestHandlerLine* hl) {
    server->reply("text/xml", [](Print& out) {
      tiny_dlna::DLNAMediaServerContentDirectoryDescr descr;
      descr.printDescr(out);
    });
  }
 
  static void connDescCB(HttpServer* server, const char* requestPath,
                         HttpRequestHandlerLine* hl) {
    server->reply("text/xml", [](Print& out) {
      tiny_dlna::DLNAMediaServerConnectionMgrDescr descr;
      descr.printDescr(out);
    });
  }
 
  static void eventSubscriptionHandler(HttpServer* server,
                                       const char* requestPath,
                                       HttpRequestHandlerLine* hl) {
    DLNADevice::eventSubscriptionHandler(server, requestPath, hl);
    DLNAMediaServer* device = (DLNAMediaServer*)(hl->context[0]);
    if (device) {
      StrView request_path_str(requestPath);
      if (request_path_str.contains("/CD/"))
        device->publishAVT();
      else if (request_path_str.contains("/CM/"))
        device->publishCMS();
      else
        DlnaLogger.log(DlnaLogLevel::Warning,
                       "eventSubscriptionHandler: Unknown request path: %s",
                       requestPath);
    }
  }
 
  void setupContentDirectoryService(HttpServer* server) {
    DLNAServiceInfo cd;
    cd.setup("urn:schemas-upnp-org:service:ContentDirectory:1",
             "urn:upnp-org:serviceId:ContentDirectory", "/CD/service.xml",
             &DLNAMediaServer::contentDescCB, "/CD/control",
             &DLNAMediaServer::contentDirectoryControlCB, "/CD/event",
             [](HttpServer* server, const char* requestPath,
                HttpRequestHandlerLine* hl) { server->replyOK(); });
 
    // subscription namespace abbreviation used for event publishing
    cd.subscription_namespace_abbrev = "AVT";
 
    // register URLs on the provided server so SCPD, control and event
    // subscription endpoints are available immediately
    server->on(cd.scpd_url, T_GET, cd.scp_cb, ref_ctx, 1);
    server->on(cd.control_url, T_POST, cd.control_cb, ref_ctx, 1);
    // Register event subscription handlers for SUBSCRIBE, UNSUBSCRIBE and
    // POST so the server accepts subscription requests and related POSTS on
    // the same event URL.
    server->on(cd.event_sub_url, T_SUBSCRIBE, eventSubscriptionHandler, ref_ctx,
               1);
    server->on(cd.event_sub_url, T_UNSUBSCRIBE,
               tiny_dlna::DLNADevice::eventSubscriptionHandler, ref_ctx, 1);
    server->on(cd.event_sub_url, T_POST,
               tiny_dlna::DLNADevice::eventSubscriptionHandler, ref_ctx, 1);
 
    addService(cd);
  }
 
  void setupConnectionManagerService(HttpServer* server) {
    DLNAServiceInfo cm;
    cm.setup("urn:schemas-upnp-org:service:ConnectionManager:1",
             "urn:upnp-org:serviceId:ConnectionManager", "/CM/service.xml",
             &DLNAMediaServer::connDescCB, "/CM/control",
             &DLNAMediaServer::connmgrControlCB, "/CM/event",
             [](HttpServer* server, const char* requestPath,
                HttpRequestHandlerLine* hl) { server->replyOK(); });
 
    // subscription namespace abbreviation used for event publishing
    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);
    // Register event subscription handlers for SUBSCRIBE, UNSUBSCRIBE and
    // POST so the server accepts subscription requests and related POSTS on
    // the same event URL.
    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);
  }
 
  bool processAction(ActionRequest& action, HttpServer& server) {
    DlnaLogger.log(DlnaLogLevel::Info, "DLNAMediaServer::processAction: %s",
                   StringRegistry::nullStr(action.action));
    StrView action_str(action.action);
    if (action_str.isEmpty()) {
      DlnaLogger.log(DlnaLogLevel::Error, "Empty action received");
      server.replyNotFound();
      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.replyNotFound();
    return false;
  }
 
  bool processActionBrowse(ActionRequest& action, HttpServer& server) {
    DlnaLogger.log(DlnaLogLevel::Info, "processActionBrowse");
    int numberReturned = 0;
    int totalMatches = 0;
    int updateID = g_stream_updateID;
 
    // extract paging args
    int startingIndex = action.getArgumentIntValue("StartingIndex");
    int requestedCount = action.getArgumentIntValue("RequestedCount");
 
    // determine query type (BrowseDirectChildren / BrowseMetadata / Search)
    ContentQueryType qtype =
        parseContentQueryType(action.getArgumentValue("BrowseFlag"));
    // query for data
    if (prepare_data_cb) {
      prepare_data_cb(action.getArgumentValue("ObjectID"), qtype,
                      action.getArgumentValue("Filter"), startingIndex,
                      requestedCount, action.getArgumentValue("SortCriteria"),
                      numberReturned, totalMatches, updateID, reference_);
    }
 
    // provide result
    return streamActionItems("BrowseResponse",
                             action.getArgumentValue("ObjectID"), qtype,
                             action.getArgumentValue("Filter"), startingIndex,
                             requestedCount, server);
  }
 
  bool processActionSearch(ActionRequest& action, HttpServer& server) {
    DlnaLogger.log(DlnaLogLevel::Info, "processActionSearch");
 
    int numberReturned = 0;
    int totalMatches = 0;
    int updateID = g_stream_updateID;
 
    // extract paging args
    int startingIndex = action.getArgumentIntValue("StartingIndex");
    int requestedCount = action.getArgumentIntValue("RequestedCount");
 
    // For Search actions we always use the Search query type regardless of
    // any provided BrowseFlag; this ensures Search semantics are preserved.
    ContentQueryType qtype = ContentQueryType::Search;
    // query for data
    if (prepare_data_cb) {
      prepare_data_cb(action.getArgumentValue("ContainerID"), qtype,
                      action.getArgumentValue("Filter"), startingIndex,
                      requestedCount, action.getArgumentValue("SortCriteria"),
                      numberReturned, totalMatches, updateID, reference_);
    }
 
    // provide result
    return streamActionItems("SearchResponse",
                             action.getArgumentValue("ContainerID"), qtype,
                             action.getArgumentValue("SearchCriteria"),
                             startingIndex, requestedCount, server);
  }
 
  bool processActionGetSearchCapabilities(ActionRequest& action,
                                          HttpServer& server) {
    ChunkPrint chunk{server.client()};
    server.replyChunked("text/xml");
 
    soapEnvelopeStart(chunk);
    actionResponseStart(chunk, "GetSearchCapabilitiesResponse",
                        "urn:schemas-upnp-org:service:ContentDirectory:1");
 
    chunk.print("<SearchCaps>");
    chunk.print(StringRegistry::nullStr(g_search_capabiities));
    chunk.println("</SearchCaps>");
 
    actionResponseEnd(chunk, "GetSearchCapabilitiesResponse");
    soapEnvelopeEnd(chunk);
    chunk.end();
    DlnaLogger.log(DlnaLogLevel::Info,
                   "processActionGetSearchCapabilities (streamed)");
    return true;
  }
 
  bool processActionGetSortCapabilities(ActionRequest& action,
                                        HttpServer& server) {
    ChunkPrint chunk{server.client()};
    server.replyChunked("text/xml");
 
    soapEnvelopeStart(chunk);
    actionResponseStart(chunk, "GetSortCapabilitiesResponse",
                        "urn:schemas-upnp-org:service:ContentDirectory:1");
 
    chunk.print("<SortCaps>");
    chunk.print(StringRegistry::nullStr(g_sort_capabilities));
    chunk.println("</SortCaps>");
 
    actionResponseEnd(chunk, "GetSortCapabilitiesResponse");
    soapEnvelopeEnd(chunk);
    chunk.end();
    DlnaLogger.log(DlnaLogLevel::Info,
                   "processActionGetSortCapabilities (streamed)");
    return true;
  }
 
  bool processActionGetSystemUpdateID(ActionRequest& action,
                                      HttpServer& server) {
    ChunkPrint chunk{server.client()};
    server.replyChunked("text/xml");
 
    soapEnvelopeStart(chunk);
    actionResponseStart(chunk, "GetSystemUpdateIDResponse",
                        "urn:schemas-upnp-org:service:ContentDirectory:1");
 
    chunk.printf("<Id>%d</Id>\r\n", g_stream_updateID);
 
    actionResponseEnd(chunk, "GetSystemUpdateIDResponse");
    soapEnvelopeEnd(chunk);
    chunk.end();
    DlnaLogger.log(DlnaLogLevel::Info,
                   "processActionGetSystemUpdateID (streamed): %d",
                   g_stream_updateID);
    return true;
  }
 
  bool processActionGetProtocolInfo(ActionRequest& action, HttpServer& server) {
    // Stream the GetProtocolInfo response using chunked encoding to avoid
    // building large in-memory strings and to keep behavior consistent with
    // other actions (e.g. Browse/Search).
    ChunkPrint chunk{server.client()};
    server.replyChunked("text/xml");
 
    soapEnvelopeStart(chunk);
    actionResponseStart(chunk, "GetProtocolInfoResponse",
                        "urn:schemas-upnp-org:service:ConnectionManager:1");
 
    chunk.print("<Source>");
    chunk.print(StringRegistry::nullStr(sourceProto));
    chunk.println("</Source>");
 
    chunk.print("<Sink>");
    chunk.print(StringRegistry::nullStr(sinkProto));
    chunk.println("</Sink>");
 
    actionResponseEnd(chunk, "GetProtocolInfoResponse");
    soapEnvelopeEnd(chunk);
    chunk.end();
    return true;
  }
 
  bool processActionGetCurrentConnectionIDs(ActionRequest& action,
                                            HttpServer& server) {
    // Stream the empty ConnectionIDs response using chunked encoding to avoid
    // allocating the full response in memory and keep consistent streaming
    // behavior with other services.
    ChunkPrint chunk{server.client()};
    server.replyChunked("text/xml");
 
    soapEnvelopeStart(chunk);
    actionResponseStart(chunk, "GetCurrentConnectionIDsResponse",
                        "urn:schemas-upnp-org:service:ConnectionManager:1");
 
    // list with one default value now
    chunk.println("<ConnectionIDs>01</ConnectionIDs>");
 
    actionResponseEnd(chunk, "GetCurrentConnectionIDsResponse");
    soapEnvelopeEnd(chunk);
    chunk.end();
    return true;
  }
  bool processActionGetCurrentConnectionInfo(ActionRequest& action,
                                             HttpServer& server) {
    // Read requested ConnectionID (not used in this simple implementation)
    int connId = action.getArgumentIntValue("ConnectionID");
 
    // Stream the GetCurrentConnectionInfo response using chunked encoding
    // to avoid building the full response in memory and to remain
    // consistent with other handlers.
    ChunkPrint chunk{server.client()};
    server.replyChunked("text/xml");
 
    soapEnvelopeStart(chunk);
    actionResponseStart(chunk, "GetCurrentConnectionInfoResponse",
                        "urn:schemas-upnp-org:service:ConnectionManager:1");
 
    // RcsID and AVTransportID
    chunk.println("<RcsID>0</RcsID>");
    chunk.println("<AVTransportID>0</AVTransportID>");
 
    // ProtocolInfo (empty by default)
    chunk.print("<ProtocolInfo>");
    chunk.print(StringRegistry::nullStr(sourceProto));
    chunk.println("</ProtocolInfo>");
 
    // PeerConnectionManager and PeerConnectionID
    chunk.print("<PeerConnectionManager>");
    chunk.println("</PeerConnectionManager>");
    chunk.println("<PeerConnectionID>0</PeerConnectionID>");
 
    // Direction and Status
    chunk.println("<Direction>Output</Direction><Status>OK</Status>");
 
    actionResponseEnd(chunk, "GetCurrentConnectionInfoResponse");
    soapEnvelopeEnd(chunk);
    chunk.end();
    return true;
  }
 
  ContentQueryType parseContentQueryType(const char* flag) {
    StrView fv(flag);
    if (fv.equals("BrowseDirectChildren"))
      return ContentQueryType::BrowseChildren;
    if (fv.equals("BrowseMetadata")) return ContentQueryType::BrowseMetadata;
    // fallback
    return ContentQueryType::BrowseMetadata;
  }
  void soapEnvelopeStart(ChunkPrint& chunk) {
    chunk.print("<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n");
    chunk.print(
        "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
        "\r\n");
    chunk.print(
        "s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n");
    chunk.print("<s:Body>\r\n");
  }
 
  void soapEnvelopeEnd(ChunkPrint& chunk) {
    chunk.print("</s:Body>\r\n");
    chunk.print("</s:Envelope>\r\n");
  }
 
  void actionResponseStart(ChunkPrint& chunk, const char* responseName,
                           const char* serviceNS) {
    // writes: <u:ResponseName xmlns:u="serviceNS">
    chunk.printf("<u:%s xmlns:u=\"%s\">\r\n", responseName, serviceNS);
  }
 
  void actionResponseEnd(ChunkPrint& chunk, const char* responseName) {
    chunk.printf("</u:%s>\r\n", responseName);
  }
 
  bool streamActionItems(const char* responseName, const char* objectID,
                         ContentQueryType queryType, const char* filter,
                         int startingIndex, int requestedCount,
                         HttpServer& server) {
    int numberReturned = 0;
    int totalMatches = 0;
    int updateID = g_stream_updateID;
 
    // allow caller to prepare counts/updateID
    if (prepare_data_cb) {
      prepare_data_cb(objectID, queryType, filter, startingIndex,
                      requestedCount, nullptr, numberReturned, totalMatches,
                      updateID, reference_);
    }
 
    ChunkPrint chunk_writer{server.client()};
    server.replyChunked("text/xml");
 
    // SOAP envelope start and response wrapper
    soapEnvelopeStart(chunk_writer);
    // responseName is assumed to be e.g. "BrowseResponse" or "SearchResponse"
    actionResponseStart(chunk_writer, responseName,
                        "urn:schemas-upnp-org:service:ContentDirectory:1");
 
    // Result -> DIDL-Lite
    chunk_writer.println("<Result>");
    // DIDL root with namespaces
    streamDIDL(chunk_writer, numberReturned, startingIndex);
    chunk_writer.print("</Result>\r\n");
 
    // numeric fields
    chunk_writer.printf("<NumberReturned>%d</NumberReturned>\r\n",
                        numberReturned);
    chunk_writer.printf("<TotalMatches>%d</TotalMatches>\r\n", totalMatches);
    chunk_writer.printf("<UpdateID>%d</UpdateID>\r\n", updateID);
 
    actionResponseEnd(chunk_writer, responseName);
    soapEnvelopeEnd(chunk_writer);
    chunk_writer.end();
    return true;
  }
 
  void streamDIDL(ChunkPrint& chunk_writer, int numberReturned,
                  int startingIndex) {
    // Stream DIDL-Lite Result payload using helper
    chunk_writer.print(
        "&lt;DIDL-Lite xmlns:dc=\"http://purl.org/dc/elements/1.1/\" "
        "xmlns:upnp=\"urn:schemas-upnp-org:metadata-1-0/upnp/\" "
        "xmlns=\"urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/\"&gt;\r\n");
 
    if (get_data_cb) {
      Str url{160};
      for (int i = 0; i < numberReturned; ++i) {
        MediaItem item;
        int idx = startingIndex + i;
        if (!get_data_cb(idx, item, reference_)) break;
 
        const char* mediaItemClassStr = toStr(item.itemClass);
        const char* nodeName =
            (item.itemClass == MediaItemClass::Folder) ? "container" : "item";
 
        chunk_writer.printf(
            "&lt;%s id=\"%s\" parentID=\"%s\" restricted=\"%d\"&gt;", nodeName,
            item.id ? item.id : "", item.parentID ? item.parentID : "0",
            item.restricted ? 1 : 0);
 
        // title
        chunk_writer.print("&lt;dc:title&gt;");
        chunk_writer.print(StringRegistry::nullStr(item.title));
        chunk_writer.print("&lt;/dc:title&gt;\r\n");
        if (mediaItemClassStr != nullptr) {
          chunk_writer.printf("&lt;upnp:class&gt;%s&lt;/upnp:class&gt;\r\n",
                              mediaItemClassStr);
        }
 
        // res with optional protocolInfo attribute
        url.set(item.resourceURL);
        if (!url.isEmpty()) {
          url.replaceAll("&", "&amp;");
          if (!StrView(item.mimeType).isEmpty()) {
            chunk_writer.printf("&lt;res protocolInfo=\"http-get:*:%s:*\"&gt;",
                                item.mimeType);
            chunk_writer.print(StringRegistry::nullStr(url.c_str()));
            chunk_writer.print("&lt;/res&gt;\r\n");
          } else {
            chunk_writer.print("&lt;res&gt;");
            chunk_writer.print(StringRegistry::nullStr(url.c_str()));
            chunk_writer.print("&lt;/res&gt;\r\n");
          }
        }
 
        chunk_writer.printf("&lt;/%s&gt;\r\n", nodeName);
      }
    }
 
    chunk_writer.print("&lt;/DIDL-Lite&gt;\r\n");
  }
 
  const char* toStr(MediaItemClass itemClass) {
    switch (itemClass) {
      case MediaItemClass::Music:
        return "object.item.audioItem.musicTrack";
      case MediaItemClass::Radio:
        return "object.item.audioItem.audioBroadcast";
      case MediaItemClass::Video:
        return "object.item.videoItem.movie";
      case MediaItemClass::Photo:
        return "object.item.imageItem.photo";
      case MediaItemClass::Folder:
        return "object.container";
      default:
        return nullptr;
    }
  }
 
  static void contentDirectoryControlCB(HttpServer* server,
                                        const char* requestPath,
                                        HttpRequestHandlerLine* hl) {
    ActionRequest action;
    DLNADevice::parseActionRequest(server, requestPath, hl, action);
 
    // If a user-provided callback is registered, hand over the parsed
    // ActionRequest for custom handling. The callback is responsible for
    // writing the HTTP reply if it handles the action.
    DLNAMediaServer* ms = nullptr;
    if (hl && hl->context[0]) ms = (DLNAMediaServer*)hl->context[0];
 
    // process the requested action using instance method if available
    if (ms) {
      if (ms->processAction(action, *server)) return;
    }
 
    server->replyNotFound();
  }
 
  static void connmgrControlCB(HttpServer* server, const char* requestPath,
                               HttpRequestHandlerLine* hl) {
    ActionRequest action;
    DLNADevice::parseActionRequest(server, requestPath, hl, action);
 
    DLNAMediaServer* ms = nullptr;
    if (hl && hl->context[0]) ms = (DLNAMediaServer*)hl->context[0];
    if (!ms) {
      server->replyNotFound();
      return;
    }
 
    // Use rules-based dispatch for ConnectionManager actions
    if (ms->processAction(action, *server)) return;
    server->replyNotFound();
  }
 
  void setupRules() {
    // ContentDirectory rules
    rules.push_back({"Browse", [](DLNAMediaServer* self, ActionRequest& action,
                                  HttpServer& server) {
                       return self->processActionBrowse(action, server);
                     }});
    rules.push_back({"Search", [](DLNAMediaServer* self, ActionRequest& action,
                                  HttpServer& server) {
                       return self->processActionSearch(action, server);
                     }});
    rules.push_back(
        {"GetSearchCapabilities",
         [](DLNAMediaServer* self, ActionRequest& action, HttpServer& server) {
           return self->processActionGetSearchCapabilities(action, server);
         }});
    rules.push_back(
        {"GetSortCapabilities",
         [](DLNAMediaServer* self, ActionRequest& action, HttpServer& server) {
           return self->processActionGetSortCapabilities(action, server);
         }});
    rules.push_back(
        {"GetSystemUpdateID",
         [](DLNAMediaServer* self, ActionRequest& action, HttpServer& server) {
           return self->processActionGetSystemUpdateID(action, server);
         }});
    // ConnectionManager rules
    rules.push_back(
        {"GetProtocolInfo",
         [](DLNAMediaServer* self, ActionRequest& action, HttpServer& server) {
           return self->processActionGetProtocolInfo(action, server);
         }});
    rules.push_back(
        {"GetCurrentConnectionIDs",
         [](DLNAMediaServer* self, ActionRequest& action, HttpServer& server) {
           return self->processActionGetCurrentConnectionIDs(action, server);
         }});
    rules.push_back(
        {"GetCurrentConnectionInfo",
         [](DLNAMediaServer* self, ActionRequest& action, HttpServer& server) {
           return self->processActionGetCurrentConnectionInfo(action, server);
         }});
  }
};
 
}  // namespace tiny_dlna