DLNAControlPointMgr.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
 
#include "DLNAControlPointRequestParser.h"
#include "DLNADevice.h"
#include "DLNADeviceInfo.h"
#include "Schedule.h"
#include "Scheduler.h"
#include "basic/StrPrint.h"
#include "basic/Url.h"
#include "http/HttpServer.h"
#include "xml/XMLDeviceParser.h"
#include "xml/XMLParser.h"
#include "xml/XMLParserPrint.h"
 
namespace tiny_dlna {
 
class DLNAControlPointMgr;
DLNAControlPointMgr* selfDLNAControlPoint = nullptr;
 
class DLNAControlPointMgr {
 public:
  DLNAControlPointMgr() { selfDLNAControlPoint = this; }
 
  DLNAControlPointMgr(HttpServer& server, int port = 80)
      : DLNAControlPointMgr() {
    setHttpServer(server, port);
  }
  void setParseDevice(bool flag) { is_parse_device = flag; }
 
  void setLocalURL(Url url) { local_url = url; }
 
  void setSearchRepeatMs(int repeatMs) { msearch_repeat_ms = repeatMs; }
 
  bool begin(DLNAHttpRequest& http, IUDPService& udp,
             const char* searchTarget = "ssdp:all", uint32_t minWaitMs = 3000,
             uint32_t maxWaitMs = 60000) {
    DlnaLogger.log(DlnaLogLevel::Info, "DLNADevice::begin");
    search_target = searchTarget;
    is_active = true;
    p_udp = &udp;
    p_http = &http;
 
    if (p_http_server && http_server_port > 0 && eventCallback != nullptr) {
      // handle server requests
      if (!p_http_server->begin(http_server_port)) {
        DlnaLogger.log(DlnaLogLevel::Error, "HttpServer begin failed");
        return false;
      }
    }
 
    // setup multicast UDP
    if (!(p_udp->begin(DLNABroadcastAddress))) {
      DlnaLogger.log(DlnaLogLevel::Error, "UDP begin failed");
      return false;
    }
 
    // Send MSearch request via UDP. Use maxWaitMs as the emission window.
    MSearchSchedule* search =
        new MSearchSchedule(DLNABroadcastAddress, searchTarget);
 
    // ensure min <= max
    if (minWaitMs > maxWaitMs) minWaitMs = maxWaitMs;
    search->end_time = millis() + maxWaitMs;
    search->repeat_ms = msearch_repeat_ms;
    search->active = true;
    scheduler.add(search);
 
    // if maxWaitMs > 0 we will block here and process events. We guarantee
    // we wait at least minWaitMs before returning; we stop waiting after
    // maxWaitMs or earlier if stopWhenFound is true AND minWaitMs has elapsed
    uint64_t start = millis();
    uint64_t minEnd = start + minWaitMs;
    uint64_t maxEnd = start + maxWaitMs;
    while (millis() < maxEnd) {
      // if a device is found and we've satisfied the minimum wait, we can
      // return early (we always allow early return after minWaitMs when a
      // device has been discovered)
      if (devices.size() > 0 && millis() >= minEnd) break;
      loop();
    }
    // If we exited early because a device was found, deactivate the MSearch
    // schedule so it will stop repeating. The scheduler will clean up
    // inactive schedules on its next pass.
    if (devices.size() > 0 && search != nullptr) {
      search->active = false;
    }
 
    DlnaLogger.log(DlnaLogLevel::Info,
                   "Control Point started with %d devices found",
                   devices.size());
    return devices.size() > 0;
  }
 
  void end() {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::end");
    // p_server->end();
    for (auto& device : devices) device.clear();
    is_active = false;
    if (p_http_server) {
      p_http_server->end();
    }
  }
 
  ActionRequest& addAction(ActionRequest act) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::addAction");
    actions.push_back(act);
    return actions[actions.size() - 1];
  }
 
  ActionReply& executeActions() {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::executeActions");
    reply.clear();
    postAllActions();
    actions.clear();
    // Debug: dump collected reply arguments for verification
    DlnaLogger.log(DlnaLogLevel::Info, "Collected reply arguments: %d",
                   (int)reply.arguments.size());
    for (auto& a : reply.arguments) {
      DlnaLogger.log(DlnaLogLevel::Info, "  -> %s = %s",
                     a.name ? a.name : "(null)", a.value.c_str());
    }
    return reply;
  }
 
  bool subscribeNotifications(DLNADeviceInfo& device, int timeoutSeconds = 60) {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "DLNAControlPointMgr::subscribeNotifications");
    if (p_http_server == nullptr) {
      DlnaLogger.log(
          DlnaLogLevel::Error,
          "HttpServer not defined - cannot subscribe to notifications");
      return false;
    }
    if (StrView(local_url.url()).isEmpty()) {
      DlnaLogger.log(DlnaLogLevel::Error, "Local URL not defined");
      return false;
    }
    for (auto& service : device.getServices()) {
      if (StrView(service.event_sub_url).isEmpty()) {
        DlnaLogger.log(DlnaLogLevel::Warning,
                       "Service %s has no eventSubURL defined",
                       service.service_id);
        continue;
      }
      if (!subscribeNotifications(service, timeoutSeconds)) {
        DlnaLogger.log(DlnaLogLevel::Error, "Subscription to service %s failed",
                       service.service_id);
        return false;
      }
      DlnaLogger.log(DlnaLogLevel::Info,
                     "Subscribed to service %s successfully",
                     service.service_id);
    }
    return true;
  }
 
  bool subscribeNotifications(DLNAServiceInfo& service,
                              int timoutSeconds = 60) {
    if (p_http_server == nullptr) {
      DlnaLogger.log(
          DlnaLogLevel::Error,
          "HttpServer not defined - cannot subscribe to notifications");
      return false;
    }
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "DLNAControlPointMgr::subscribeNotifications");
    DLNADeviceInfo& device = getDevice(service);
 
    char url_buffer[200] = {0};
    char seconds_txt[80] = {0};
    Url url{getUrl(device, service.event_sub_url, url_buffer, 200)};
    snprintf(seconds_txt, 80, "Second-%d", timoutSeconds);
    p_http->request().put("NT", "upnp:event");
    p_http->request().put("TIMEOUT", seconds_txt);
    p_http->request().put("CALLBACK", local_url.url());
    int rc = p_http->subscribe(url);
    DlnaLogger.log(DlnaLogLevel::Info, "Http rc: %s", rc);
    return rc == 200;
  }
 
  void onNotification(
      std::function<void(void* reference, const char* sid, const char* varName,
                         const char* newValue)>
          cb) {
    eventCallback = cb;
  }
 
  void setReference(void* ref) { reference = ref; }
 
  void setHttpServer(HttpServer& server, int port = 80) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::setHttpServer");
    p_http_server = &server;
    http_server_port = port;
    attachHttpServer(server);
  }
 
  bool loop() {
    if (!is_active) return false;
    DLNAControlPointRequestParser parser;
 
    // process UDP requests
    RequestData req = p_udp->receive();
    if (req && scheduler.isMSearchActive()) {
      Schedule* schedule = parser.parse(req);
      if (schedule != nullptr) {
        // handle NotifyReplyCP
        if (StrView(schedule->name()).equals("NotifyReplyCP")) {
          NotifyReplyCP& notify_schedule = *(NotifyReplyCP*)schedule;
          // notify_schedule.callback = processDevice;
          processDevice(notify_schedule);
        }
        // handle MSearchReplyCP (HTTP/1.1 200 OK responses to M-SEARCH)
        if (StrView(schedule->name()).equals("MSearchReplyCP")) {
          MSearchReplyCP& ms_schedule = *(MSearchReplyCP*)schedule;
          // Process M-SEARCH replies immediately: they contain LOCATION URLs
          // pointing to device descriptions. Add the device and free the
          // temporary schedule object.
          processMSearchReply(ms_schedule);
        }
      }
    }
 
    // execute scheduled udp replys
    scheduler.execute(*p_udp);
 
    if (p_http_server) {
      // handle server requests
      bool rc = p_http_server->doLoop();
    }
 
    // be nice, if we have other tasks
    delay(5);
    return true;
  }
 
  DLNAServiceInfo& getService(const char* id) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::getService");
    static DLNAServiceInfo no_service(false);
    for (auto& dev : devices) {
      DLNAServiceInfo& result = dev.getService(id);
      if (result) return result;
    }
    return no_service;
  }
 
  DLNADeviceInfo& getDevice(int deviceIdx = 0) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::getDevice");
    return devices[deviceIdx];
  }
 
  DLNADeviceInfo& getDevice(DLNAServiceInfo& service) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::getDevice");
    for (auto& dev : devices) {
      for (auto& srv : dev.getServices()) {
        if (srv == srv) return dev;
      }
    }
    return NO_DEVICE;
  }
 
  DLNADeviceInfo& getDevice(Url location) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::getDevice");
    for (auto& dev : devices) {
      if (dev.getDeviceURL() == location) {
        DlnaLogger.log(DlnaLogLevel::Debug,
                       "DLNAControlPointMgr::getDevice: Found device %s",
                       location.url());
        return dev;
      }
    }
    return NO_DEVICE;
  }
 
  Vector<DLNADeviceInfo>& getDevices() { return devices; }
 
  bool addDevice(DLNADeviceInfo dev) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::addDevice");
    dev.updateTimestamp();
    for (auto& existing_device : devices) {
      if (dev.getUDN() == existing_device.getUDN()) {
        DlnaLogger.log(DlnaLogLevel::Debug, "Device '%s' already exists",
                       dev.getUDN());
        return false;
      }
    }
    DlnaLogger.log(DlnaLogLevel::Info, "Device '%s' has been added",
                   dev.getUDN());
    devices.push_back(dev);
    return true;
  }
 
  bool addDevice(Url url) {
    if (StrView(url.host()).equals("127.0.0.1")){
      DlnaLogger.log(DlnaLogLevel::Info, "Ignoring localhost device");
      return false;
    }
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::addDevice");
    DLNADeviceInfo& device = getDevice(url);
    if (device != NO_DEVICE) {
      // device already exists
      device.setActive(true);
      return true;
    }
    // http get
    StrPrint xml;
    DLNAHttpRequest req;
    int rc = req.get(url, "text/xml");
 
    if (rc != 200) {
      DlnaLogger.log(DlnaLogLevel::Error, "Http get to '%s' failed with %d",
                     url.url(), rc);
      return false;
    }
    // get xml
    uint8_t buffer[512];
    while (true) {
      int len = req.read(buffer, 512);
      if (len == 0) break;
      xml.write(buffer, len);
    }
 
    // parse xml
    DLNADeviceInfo new_device;
    XMLDeviceParser parser;
    parser.parse(new_device, strings, xml.c_str());
    new_device.device_url = url;
    // Avoid adding the same device multiple times: check UDN uniqueness
    for (auto& existing_device : devices) {
      if (existing_device.getUDN() == new_device.getUDN()) {
        DlnaLogger.log(DlnaLogLevel::Debug,
                       "Device '%s' already exists (skipping add)",
                       new_device.getUDN());
        // Make sure the existing device is marked active and keep the URL
        existing_device.setActive(true);
        return true;
      }
    }
 
    DlnaLogger.log(DlnaLogLevel::Info, "Device '%s' has been added",
                   new_device.getUDN());
    devices.push_back(new_device);
    return true;
  }
 
  void setActive(bool flag) { is_active = flag; }
 
  bool isActive() { return is_active; }
 
 protected:
  Scheduler scheduler;
  DLNAHttpRequest* p_http = nullptr;
  IUDPService* p_udp = nullptr;
  Vector<DLNADeviceInfo> devices;
  Vector<ActionRequest> actions;
  ActionReply reply;
  XMLPrinter xml;
  int msearch_repeat_ms = 10000;
  bool is_active = false;
  bool is_parse_device = false;
  DLNADeviceInfo NO_DEVICE{false};
  const char* search_target;
  StringRegistry strings;
  Url local_url;
  HttpServer* p_http_server = nullptr;
  int http_server_port = 0;
  void* reference = nullptr;
  std::function<void(void* reference, const char* sid, const char* varName,
                     const char* newValue)>
      eventCallback;
 
  void attachHttpServer(HttpServer& server) {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "DLNAControlPointMgr::attachHttpServer");
    p_http_server = &server;
    // register handler at the local path. If local_url is not set we use
    // a default path "/dlna/events"
    const char* path =
        StrView(local_url.url()).isEmpty() ? "/dlna/events" : local_url.path();
 
    // handler lambda: reads SID and body, forwards to parseAndDispatchEvent
    auto notifyHandler = [](HttpServer* server, const char* requestPath,
                            HttpRequestHandlerLine* hl) {
      // The DLNAControlPointMgr instance is passed as context[0]
      DLNAControlPointMgr* cp = nullptr;
      if (hl->contextCount > 0)
        cp = static_cast<DLNAControlPointMgr*>(hl->context[0]);
      if (!cp) {
        server->replyNotFound();
        return;
      }
 
      // read headers
      HttpRequestHeader& req = server->requestHeader();
      const char* sid = req.get("SID");
 
      // read body
      Str body = server->contentStr();
 
      // build temporary NotifyReplyCP and forward
      NotifyReplyCP tmp;
      if (sid) tmp.subscription_id = sid;
      tmp.xml = body.c_str();
 
      cp->parseAndDispatchEvent(tmp);
 
      server->replyOK();
    };
 
    void* ctx[1];
    ctx[0] = this;
    server.on(path, T_POST, notifyHandler, ctx, 1);
  }
 
  static bool handleNotifyByebye(Str& usn) {
    // delegate to existing bye handling
    return selfDLNAControlPoint->processBye(usn);
  }
 
  static bool isUdnKnown(const char* usn_c, DLNADeviceInfo*& outDev) {
    outDev = nullptr;
    if (!usn_c || *usn_c == '\0') return false;
    const char* sep = strstr(usn_c, "::");
    int udn_len = sep ? (int)(sep - usn_c) : (int)strlen(usn_c);
    for (auto& dev : selfDLNAControlPoint->devices) {
      const char* known_udn = dev.getUDN();
      if (known_udn && strncmp(known_udn, usn_c, udn_len) == 0 &&
          (int)strlen(known_udn) == udn_len) {
        outDev = &dev;
        return true;
      }
    }
    return false;
  }
 
  static bool handleNotifyAlive(NotifyReplyCP& data) {
    bool select = selfDLNAControlPoint->matches(data.usn.c_str());
    DlnaLogger.log(DlnaLogLevel::Debug, "addDevice: %s -> %s", data.usn.c_str(),
                   select ? "added" : "filtered");
    if (!select) return false;
 
    DLNADeviceInfo* existing = nullptr;
    if (isUdnKnown(data.usn.c_str(), existing)) {
      DlnaLogger.log(DlnaLogLevel::Debug,
                     "Device '%s' already known (skip GET)",
                     existing ? existing->getUDN() : "<unknown>");
      if (existing) existing->setActive(true);
      return true;
    }
 
    // Not known -> fetch and add device description
    Url url{data.location.c_str()};
    selfDLNAControlPoint->addDevice(url);
    return true;
  }
 
  static bool processDevice(NotifyReplyCP& data) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::processDevice");
    Str& nts = data.nts;
    if (nts.equals("ssdp:byebye")) {
      return handleNotifyByebye(nts);
    }
    if (nts.equals("ssdp:alive")) {
      return handleNotifyAlive(data);
    }
    return false;
  }
 
  static bool processMSearchReply(MSearchReplyCP& data) {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "DLNAControlPointMgr::processMSearchReply");
    // data.location contains the device description URL
    if (data.location.isEmpty()) return false;
    DlnaLogger.log(DlnaLogLevel::Info, "MSearchReply -> add device: %s",
                   data.location.c_str());
    // If the reply includes a USN we can avoid fetching multiple
    // different LOCATION URLs for the same device (different network
    // interfaces) by checking for the UDN part in known devices.
    const char* usn_c = data.usn.c_str();
    if (usn_c && *usn_c) {
      const char* sep = strstr(usn_c, "::");
      int udn_len = sep ? (int)(sep - usn_c) : (int)strlen(usn_c);
      for (auto& dev : selfDLNAControlPoint->devices) {
        const char* known_udn = dev.getUDN();
        if (known_udn && strncmp(known_udn, usn_c, udn_len) == 0 &&
            (int)strlen(known_udn) == udn_len) {
          DlnaLogger.log(DlnaLogLevel::Debug,
                         "MSearchReply: device '%s' already known (skip GET)",
                         known_udn);
          dev.setActive(true);
          return true;
        }
      }
    }
 
    Url url{data.location.c_str()};
    selfDLNAControlPoint->addDevice(url);
    return true;
  }
 
  void parseAndDispatchEvent(NotifyReplyCP& data) {
    DlnaLogger.log(DlnaLogLevel::Debug,
                   "DLNAControlPointMgr::parseAndDispatchEvent");
    // data.xml contains the <e:propertyset ...>...</e:propertyset> as a
    // string
    const char* xmlBuf = data.xml.c_str();
    if (xmlBuf == nullptr || *xmlBuf == '\0') return;
 
    struct CBRef {
      DLNAControlPointMgr* self;
      NotifyReplyCP* data;
    } ref;
    ref.self = this;
    ref.data = &data;
 
    // Simple callback: whenever the parser reports a text node (non-empty
    // `text`), treat `nodeName` as the variable name and `text` as its value.
    auto cb = [](Str& nodeName, Vector<Str>& /*path*/, Str& text,
                 Str& /*attributes*/, int /*start*/, int /*len*/, void* vref) {
      CBRef* r = static_cast<CBRef*>(vref);
      if (text.length() > 0 && r->self && r->self->eventCallback) {
        const char* sid = r->data->subscription_id.c_str();
        // store stable copies in the control point's string registry
        const char* namePtr = r->self->strings.add((char*)nodeName.c_str());
        const char* valPtr = r->self->strings.add((char*)text.c_str());
        // pass stored opaque reference as first parameter
        r->self->eventCallback(r->self->reference, sid, namePtr, valPtr);
      }
    };
 
    XMLParser parser(xmlBuf, cb);
    parser.setReference(&ref);
    parser.parse();
  }
 
  bool matches(const char* usn) {
    if (StrView(search_target).equals("ssdp:all")) return true;
    return StrView(usn).contains(search_target);
  }
 
  bool processBye(Str& usn) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::processBye");
    for (auto& dev : devices) {
      if (usn.startsWith(dev.getUDN())) {
        for (auto& srv : dev.getServices()) {
          srv.is_active = false;
          if (usn.endsWith(srv.service_type)) {
            if (srv.is_active) {
              DlnaLogger.log(DlnaLogLevel::Info, "removeDevice: %s", usn);
              srv.is_active = false;
            }
          }
        }
      }
    }
    return false;
  }
 
  size_t createXML(ActionRequest& action) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::createXML");
    size_t result = xml.printXMLHeader();
 
    result += xml.printNodeBegin(
        "Envelope",
        "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
        "s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"",
        "s");
    result += xml.printNodeBegin("Body", nullptr, "s");
 
    char ns[200];
    StrView namespace_str(ns, 200);
    namespace_str = "xmlns:u=\"%1\"";
    bool ok = namespace_str.replace("%1", action.getServiceType());
    DlnaLogger.log(DlnaLogLevel::Debug, "ns = '%s'", namespace_str.c_str());
 
    // assert(ok);
    result += xml.printNodeBegin(action.action, namespace_str.c_str(), "u");
    for (auto arg : action.arguments) {
      result += xml.printNode(arg.name, arg.value.c_str());
    }
    result += xml.printNodeEnd(action.action, "u");
 
    result += xml.printNodeEnd("Body", "s");
    result += xml.printNodeEnd("Envelope", "s");
    return result;
  }
 
  ActionReply& getLastReply() { return reply; }
 
  ActionReply& postAllActions() {
    reply.clear();
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::postAllActions");
    for (auto& action : actions) {
      if (action.getServiceType() != nullptr) postAction(action);
    }
    return reply;
  }
 
  ActionReply& postAction(ActionRequest& action) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::postAction: %s",
                   action.action);
    reply.clear();
    DLNAServiceInfo& service = *action.p_service;
    DLNADeviceInfo& device = getDevice(service);
 
    // Build request body
    StrPrint requestBody;
    buildActionBody(action, requestBody);
 
    // create SOAPACTION header value
    char act[200];
    StrView action_str{act, 200};
    action_str = "\"";
    action_str.add(action.getServiceType());
    action_str.add("#");
    action_str.add(action.action);
    action_str.add("\"");
 
    // crate control url
    char url_buffer[200] = {0};
    Url post_url{getUrl(device, service.control_url, url_buffer, 200)};
 
    // send HTTP POST and collect response into an XMLParserPrint so we can
    // parse incrementally
    return processActionHttpPost(post_url, requestBody, action_str.c_str());
  }
 
  void buildActionBody(ActionRequest& action, StrPrint& out) {
    xml.setOutput(out);
    createXML(action);
  }
 
  // Send an HTTP POST for the given URL and request body. On success the
  ActionReply& processActionHttpPost(Url& post_url, StrPrint& requestBody,
                                     const char* soapAction) {
    XMLParserPrint xml_parser;
    uint8_t buffer[200];
    Str outNodeName;
    Vector<Str> outPath;
    Str outText;
    Str outAttributes;
    xml_parser.setExpandEncoded(true);
 
    // set header and post
    p_http->stop();
    p_http->request().put("SOAPACTION", soapAction);
    int rc = p_http->post(post_url, "text/xml", requestBody.c_str(),
                          requestBody.length());
    if (rc != 200) {
      p_http->stop();
      reply.setValid(false);
      return reply;
    }
 
    reply.setValid(true);
    reply.arguments.clear();
    // parse response
    while (p_http->client()->available()) {
      int len = p_http->client()->read(buffer, 200);
      if (len > 0) {
        // Serial.write(buffer, len);
        xml_parser.write(buffer, len);
        while (xml_parser.parse(outNodeName, outPath, outText, outAttributes)) {
          // skip didl
          if (!outNodeName.equals("Result")) {
            Argument arg;
            // persist the argument name in the control point's string registry
            arg.name = strings.add((char*)outNodeName.c_str());
            arg.value = outText;
            if (!(outText.isEmpty() && outAttributes.isEmpty())) {
              reply.addArgument(arg);
              DlnaLogger.log(DlnaLogLevel::Info, "ActionReplay '%s': %s (%s)",
                             outNodeName.c_str(), outText.c_str(), outAttributes.c_str());
            }
          }
        }
      }
    }
    return reply;
  }
 
  const char* getUrl(DLNADeviceInfo& device, const char* suffix,
                     const char* buffer, int len) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::getUrl");
    StrView url_str{(char*)buffer, len};
    url_str = device.getBaseURL();
    if (url_str == nullptr) {
      url_str.add(device.getDeviceURL().protocol());
      url_str.add("://");
      url_str.add(device.getDeviceURL().host());
      url_str.add(":");
      url_str.add(device.getDeviceURL().port());
    }
    url_str.add(suffix);
    return buffer;
  }
};
 
}  // namespace tiny_dlna