DLNADevice.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
 
#include "basic/Icon.h"
#include "basic/Printf.h"
#include "basic/StrView.h"
#include "basic/Url.h"
#include "basic/Vector.h"
#include "dlna/common/Action.h"
#include "dlna/common/DLNADeviceInfo.h"
#include "dlna/common/DLNAServiceInfo.h"
#include "dlna/common/Schedule.h"
#include "dlna/common/Scheduler.h"
#include "dlna/devices/DLNADeviceRequestParser.h"
#include "dlna/devices/IDevice.h"
#include "dlna/devices/SubscriptionMgrDevice.h"
#include "dlna/udp/IUDPService.h"
#include "dlna/xml/XMLParserPrint.h"
#include "dlna/xml/XMLPrinter.h"
#include "http/Http.h"
#include "http/Server/IHttpServer.h"
 
namespace tiny_dlna {
 
template <typename ClientType>
class DLNADevice : public IDevice {
 public:
  DLNADevice() {
    // distribute initial subscription active flag to subscription manager
    setSubscriptionsActive(isSubscriptionsActive());
  }
  bool begin(DLNADeviceInfo& device, IUDPService& udp,
             IHttpServer& server) override {
    DlnaLogger.log(DlnaLogLevel::Info, "DLNADevice::begin");
    server.setReference(this);
    p_server = &server;
    p_udp = &udp;
    setDeviceInfo(device);
    setupParser();
 
    // check base url
    const char* baseUrl = device.getBaseURL();
    DlnaLogger.log(DlnaLogLevel::Info, "base URL: %s", baseUrl);
 
    if (StrView(device.getBaseURL()).contains("localhost")) {
      DlnaLogger.log(DlnaLogLevel::Error, "invalid base address: %s", baseUrl);
      return false;
    }
 
    // setup device
    device.setupServices(server, udp);
 
    // ensure services reflect the current subscriptions-active flag
    // (some callers rely on subscriptions being disabled by default)
    setSubscriptionsActive(isSubscriptionsActive());
 
    // setup web server
    if (!setupDLNAServer(server)) {
      DlnaLogger.log(DlnaLogLevel::Error, "setupDLNAServer failed");
      return false;
    }
 
    // start web server
    Url url{baseUrl};
    if (!p_server->begin()) {
      DlnaLogger.log(DlnaLogLevel::Error, "Server failed");
      return false;
    }
 
    // setup UDP
    if (!p_udp->begin(DLNABroadcastAddress)) {
      DlnaLogger.log(DlnaLogLevel::Error, "UDP begin failed");
      return false;
    }
 
    // setup scheduler
    if (!setupScheduler()) {
      DlnaLogger.log(DlnaLogLevel::Error, "Scheduler failed");
      return false;
    }
    // initialize scheduling timers so the scheduled tasks run immediately
    uint64_t now = millis();
    // set next timeouts to now so the first loop triggers the tasks
    next_scheduler_timeout_ms = now;
    next_subscriptions_timeout_ms = now;
 
    is_active = true;
    DlnaLogger.log(DlnaLogLevel::Info, "Device successfully started");
    return true;
  }
 
  ISubscriptionMgrDevice& getSubscriptionMgr() override {
    return subscription_mgr;
  }
 
  void end() override {
    DlnaLogger.log(DlnaLogLevel::Info, "DLNADevice::end");
    p_server->end();
 
    // send 3 bye messages
    PostByeSchedule* bye = new PostByeSchedule(*p_device_info);
    bye->repeat_ms = 800;
    scheduler.add(bye);
 
    // execute scheduler for 2 seconds
    uint64_t end = millis() + 2000;
    while (millis() < end) {
      scheduler.execute(*p_udp);
    }
 
    // end subscription manager
    getSubscriptionMgr().end();
 
    is_active = false;
  }
 
  bool loop(int loopAction = RUN_ALL) override {
    if (!is_active) return false;
    DlnaLogger.log(DlnaLogLevel::Debug, "loop");
    // Platform-specific periodic diagnostics (e.g. ESP32 memory logging)
    logScheduledStatus();
    bool rc = false;
 
    // handle server requests
    if (loopAction & RUN_SERVER) {
      rc = loopServer();
    }
 
    // Use millisecond-based intervals for scheduling so callers can set
    // real-time intervals instead of loop-counts.
    uint64_t now = millis();
    if ((loopAction & RUN_UDP) && isSchedulerActive() &&
        now >= next_scheduler_timeout_ms) {
      int count = loopUDPMessages();
      if (count > 0) rc = true;
      // schedule next run
      next_scheduler_timeout_ms = now + scheduler_interval_ms;
    }
 
    // deliver any queued subscription notifications (if enabled)
    if ((loopAction & RUN_SUBSCRIPTIONS) && isSubscriptionsActive() &&
        now >= next_subscriptions_timeout_ms) {
      int count = loopPublishSubscriptions();
      if (count > 0) rc = true;
      // schedule next run
      next_subscriptions_timeout_ms = now + subscriptions_interval_ms;
    }
 
    // be nice, if we have other tasks
    if (!rc) delay(DLNA_LOOP_DELAY_MS);
    return true;
  }
 
  int loopPublishSubscriptions() { return subscription_mgr.publish(); }
 
  bool loopServer() override {
    DlnaLogger.log(DlnaLogLevel::Debug, "loopServer");
    if (!is_active) return false;
    bool rc = p_server->doLoop();
    DlnaLogger.log(DlnaLogLevel::Debug, "server %s", rc ? "true" : "false");
    return rc;
  }
 
  int loopUDPMessages() {
    // process UDP requests
    DlnaLogger.log(DlnaLogLevel::Debug, "loopUDPMessages");
    RequestData req = p_udp->receive();
    if (req) {
      Schedule* schedule = parser.parse(*p_device_info, req);
      if (schedule != nullptr) {
        scheduler.add(schedule);
      }
    }
 
    // execute scheduled udp replys
    return scheduler.execute(*p_udp);
  }
 
  DLNAServiceInfo& getService(const char* id) override {
    return p_device_info->getService(id);
  }
 
  DLNAServiceInfo& getServiceByAbbrev(const char* abbrev) override {
    return p_device_info->getServiceByAbbrev(abbrev);
  }
 
  DLNAServiceInfo* getServiceByEventPath(const char* requestPath) override {
    DlnaLogger.log(DlnaLogLevel::Debug, "getServiceByEventPath");
    if (p_device_info == nullptr || requestPath == nullptr) return nullptr;
    for (DLNAServiceInfo& s : p_device_info->getServices()) {
      if (StrView(s.event_sub_url).equals(requestPath)) {
        return &s;
      }
    }
    return nullptr;
  }
 
  void addChange(const char* serviceAbbrev,
                 std::function<size_t(Print&, void*)> changeWriter,
                 void* ref) override {
    DlnaLogger.log(DlnaLogLevel::Debug, "addChange");
    auto& mgr = getSubscriptionMgr();
    DLNAServiceInfo& serviceInfo = getServiceByAbbrev(serviceAbbrev);
    if (!serviceInfo) {
      DlnaLogger.log(DlnaLogLevel::Warning,
                     "addChange: No service info available for %s",
                     serviceAbbrev);
      return;
    }
    mgr.addChange(serviceInfo, changeWriter, ref);
  }
 
  DLNADeviceInfo& getDeviceInfo() override { return *p_device_info; }
 
  void setSchedulerActive(bool flag) override { scheduler.setActive(flag); }
 
  bool isSchedulerActive() override { return scheduler.isActive(); }
 
  void setPostAliveRepeatMs(uint32_t ms) override { post_alive_repeat_ms = ms; }
 
  void setSubscriptionsActive(bool flag) override {
    is_subscriptions_active = flag;
    if (p_device_info != nullptr) {
      p_device_info->setSubscriptionActive(flag);
    }
    getSubscriptionMgr().setSubscriptionsActive(flag);
  }
 
  bool isSubscriptionsActive() const override {
    return is_subscriptions_active;
  }
 
  static void parseActionRequest(IHttpServer* server, IClientHandler& client,
                                 const char* requestPath,
                                 HttpRequestHandlerLine* hl,
                                 ActionRequest& action) {
    DlnaLogger.log(DlnaLogLevel::Info, "parseActionRequest");
    auto start = millis();
    XMLParserPrint xp;
    xp.setExpandEncoded(true);
 
    Str outNodeName;
    Vector<Str> outPath;
    Str outText;
    Str outAttributes;
    bool is_attribute = false;
    bool is_action = false;
    Str actionName;
    char buffer[XML_PARSER_BUFFER_SIZE];
    // Client* client = server->client(); // No longer valid, use handler
    // reference
 
    auto* pClient = client.client();
    while (true) {
      size_t len = pClient->readBytes(buffer, sizeof(buffer));
      if (len == 0) break;
      xp.write((const uint8_t*)buffer, len);
 
      while (xp.parse(outNodeName, outPath, outText, outAttributes)) {
        if (is_attribute) {
          const char* argName = outNodeName.c_str();
          action.addArgument(argName, outText.c_str());
          continue;
        }
        if (is_action) {
          is_action = false;
          is_attribute = true;
          action.setAction(outNodeName.c_str());
          DlnaLogger.log(DlnaLogLevel::Info, "action: %s", action.getAction());
          continue;
        }
        // skip SOAP envelope wrappers
        if (outNodeName.equals("s:Envelope") || outNodeName.equals("Body")) {
          continue;
        }
        if (outNodeName.equals("s:Body")) {
          is_action = true;
        }
      }
    }
    xp.end();
    DlnaLogger.log(DlnaLogLevel::Info, "Parse took %d ms", millis() - start);
  }
 
  static size_t printReplyXML(
      Print& out, const char* replyName, const char* serviceId,
      std::function<size_t(Print&, void*)> valuesWriter = nullptr,
      void* ref = nullptr) {
    DlnaLogger.log(DlnaLogLevel::Debug, "printReplyXML");
    XMLPrinter xp(out);
    size_t result = 0;
    result += xp.printNodeBegin(
        "s:Envelope",
        "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"\n");
    result += xp.printNodeBegin("s:Body");
    result +=
        xp.printf("<u:%s xmlns:u=\"urn:schemas-upnp-org:service:%s:1\">\n",
                  replyName, serviceId);
 
    // e.g.<u:return>Stop,Pause,Next,Seek</u:return> for
    // QueryStateVariableResponse
    if (valuesWriter) {
      result += valuesWriter(out, ref);
    }
 
    result += xp.printf("</u:%s>\n", replyName);
    result += xp.printNodeEnd("s:Body");
    result += xp.printNodeEnd("s:Envelope");
    return result;
  }
  static size_t replyGetProtocolInfo(Print& out, const char* source = "",
                                     const char* sink = "") {
    DlnaLogger.log(DlnaLogLevel::Debug, "replyGetProtocolInfo");
    return printReplyXML(out, "GetProtocolInfoResponse", "ConnectionManager",
                         [source, sink](Print& o, void* ref) -> size_t {
                           (void)ref;
                           size_t written = 0;
                           written += o.print("<Source>");
                           written += o.print(StrView(source).c_str());
                           written += o.print("</Source>");
                           written += o.print("<Sink>");
                           written += o.print(StrView(sink).c_str());
                           written += o.print("</Sink>");
                           return written;
                         });
  }
 
  static size_t replyGetCurrentConnectionIDs(Print& out, const char* ids) {
    DlnaLogger.log(DlnaLogLevel::Debug, "replyGetCurrentConnectionIDs");
    return printReplyXML(out, "GetCurrentConnectionIDsResponse",
                         "ConnectionManager",
                         [ids](Print& o, void* ref) -> size_t {
                           (void)ref;
                           size_t written = 0;
                           // UPnP spec uses "CurrentConnectionIDs" as the
                           // response element name
                           written += o.print("<CurrentConnectionIDs>");
                           written += o.print(StrView(ids ? ids : "0").c_str());
                           written += o.print("</CurrentConnectionIDs>");
                           return written;
                         });
  }
 
  static size_t replyGetCurrentConnectionInfo(Print& out,
                                              const char* protocolInfo,
                                              const char* connectionID,
                                              const char* direction) {
    DlnaLogger.log(DlnaLogLevel::Debug, "handleSubscription");
    return printReplyXML(
        out, "GetCurrentConnectionInfoResponse", "ConnectionManager",
        [protocolInfo, connectionID, direction](Print& o, void* ref) -> size_t {
          (void)ref;
          size_t written = 0;
          // Write directly to out to avoid using a fixed-size intermediate
          // buffer.
          written += o.print("<RcsID>0</RcsID>");
          written += o.print("<AVTransportID>0</AVTransportID>");
          written += o.print("<ProtocolInfo>");
          written += o.print(StrView(protocolInfo).c_str());
          written += o.print("</ProtocolInfo>");
          written += o.print("<PeerConnectionManager></PeerConnectionManager>");
          written += o.print("<PeerConnectionID>");
          written += o.print(StrView(connectionID).c_str());
          written += o.print("</PeerConnectionID>");
          written += o.print("<Direction>");
          written += o.print(StrView(direction).c_str());
          written += o.print("</Direction>");
          written += o.print("<Status>OK</Status>");
          return written;
        });
  }
 
  static bool handleSubscription(IHttpServer* server, IClientHandler* client,
                                 const char* requestPath,
                                 HttpRequestHandlerLine* hl,
                                 bool& is_subscribe) {
    DlnaLogger.log(DlnaLogLevel::Debug, "handleSubscription");
    // logic separated and easier to test.
    is_subscribe = false;
    // Use client handler for request header and error reply
    if (client) {
      HttpRequestHeader& req = client->requestHeader();
      if (req.method() == T_SUBSCRIBE) {
        is_subscribe = true;
        return handleSubscribe(client, server, requestPath, hl);  // If needed
      }
      if (req.method() == T_UNSUBSCRIBE || req.method() == T_POST) {
        return handleUnsubscribe(client, server, requestPath, hl);  // If
      }
    }
 
    // default reply OK for other methods
    client->replyError(501, "Unsupported Method");
    return false;
  }
 
  void setReference(void* ref) override { reference = ref; }
 
  void* getReference() override { return reference; }
 
  void logStatus() {
    DlnaLogger.log(DlnaLogLevel::Info,
                   "Subscriptions: active=%d pending=%d / Scheduler: size=%d "
                   "active = %s",
                   subscription_mgr.subscriptionsCount(),
                   subscription_mgr.pendingCount(), scheduler.size(),
                   isSchedulerActive() ? "true" : "false");
#ifdef ESP32
    DlnaLogger.log(DlnaLogLevel::Info, "Memory: freeHeap=%u freePsram=%u",
                   (unsigned)ESP.getFreeHeap(), (unsigned)ESP.getFreePsram());
#endif
  }
 
 protected:
  bool is_active = false;
  bool is_subscriptions_active = true;
  uint32_t post_alive_repeat_ms = 0;
  Scheduler scheduler;
  SubscriptionMgrDevice<ClientType> subscription_mgr;
  DLNADeviceRequestParser parser;
  DLNADeviceInfo* p_device_info = nullptr;
  IUDPService* p_udp = nullptr;
  IHttpServer* p_server = nullptr;
  uint64_t scheduler_interval_ms = (uint64_t)DLNA_RUN_SCHEDULER_EVERY_MS;
  uint64_t subscriptions_interval_ms =
      (uint64_t)DLNA_RUN_SUBSCRIPTIONS_EVERY_MS;
  uint64_t next_scheduler_timeout_ms = 0;
  uint64_t next_subscriptions_timeout_ms = 0;
  void* reference = nullptr;
 
  void setDeviceInfo(DLNADeviceInfo& device) {
    DlnaLogger.log(DlnaLogLevel::Debug, "setDeviceInfo");
    p_device_info = &device;
    device.setSubscriptionActive(isSubscriptionsActive());
  }
 
  void setSchedulerIntervalMs(uint32_t ms) { scheduler_interval_ms = ms; }
 
  uint32_t getSchedulerIntervalMs() const {
    return (uint32_t)scheduler_interval_ms;
  }
 
  void setSubscriptionsIntervalMs(uint32_t ms) {
    subscriptions_interval_ms = ms;
  }
 
  uint32_t getSubscriptionsIntervalMs() const {
    return (uint32_t)subscriptions_interval_ms;
  }
 
  void logScheduledStatus(bool runImmediately = false) {
    static uint64_t last_mem_log = 0;
    const uint64_t MEM_LOG_INTERVAL_MS = 10000;
    uint64_t now = millis();
    if (runImmediately ||
        (uint64_t)(now - last_mem_log) >= MEM_LOG_INTERVAL_MS) {
      // update timestamp for next interval on all platforms
      last_mem_log = now;
      logStatus();
    }
  }
 
  bool setupParser() {
    DlnaLogger.log(DlnaLogLevel::Debug, "setupParser");
    parser.addMSearchST("upnp:rootdevice");
    parser.addMSearchST("ssdp:all");
    parser.addMSearchST(p_device_info->getUDN());
    parser.addMSearchST(p_device_info->getDeviceType());
    return true;
  }
 
  bool setupScheduler() {
    DlnaLogger.log(DlnaLogLevel::Debug, "setupScheduler");
    // schedule post alive messages: Usually repeated 2 times (because UDP
    // messages might be lost)
    PostAliveSchedule* postAlive =
        new PostAliveSchedule(*p_device_info, post_alive_repeat_ms);
    PostAliveSchedule* postAlive1 =
        new PostAliveSchedule(*p_device_info, post_alive_repeat_ms);
    postAlive1->time = millis() + 100;
    scheduler.add(postAlive);
    scheduler.add(postAlive1);
    return true;
  }
 
  bool validateServiceInfo(const DLNAServiceInfo& service) {
    DlnaLogger.log(DlnaLogLevel::Debug, "validateServiceInfo");
    bool has_error = false;
 
    if (!service.scpd_url || !*service.scpd_url) {
      DlnaLogger.log(DlnaLogLevel::Error, "Service missing scpd_url");
      has_error = true;
    }
    if (!service.control_url || !*service.control_url) {
      DlnaLogger.log(DlnaLogLevel::Error, "Service missing control_url");
      has_error = true;
    }
    if (!service.event_sub_url || !*service.event_sub_url) {
      DlnaLogger.log(DlnaLogLevel::Error, "Service missing event_sub_url");
      has_error = true;
    }
    if (!service.scp_cb) {
      DlnaLogger.log(DlnaLogLevel::Error, "Service missing scp_cb for %s",
                     service.scpd_url ? service.scpd_url : "(null)");
      has_error = true;
    }
    if (!service.control_cb) {
      DlnaLogger.log(DlnaLogLevel::Error, "Service missing control_cb for %s",
                     service.control_url ? service.control_url : "(null)");
      has_error = true;
    }
    if (!service.event_sub_cb) {
      DlnaLogger.log(DlnaLogLevel::Error, "Service missing event_sub_cb for %s",
                     service.event_sub_url ? service.event_sub_url : "(null)");
      has_error = true;
    }
 
    if (has_error) {
      DlnaLogger.log(DlnaLogLevel::Error,
                     "Service validation failed - missing URLs/callbacks");
    }
 
    return !has_error;
  }
 
  virtual bool setupDLNAServer(IHttpServer& srv) {
    DlnaLogger.log(DlnaLogLevel::Debug, "setupDLNAServer");
    char buffer[DLNA_MAX_URL_LEN] = {0};
    StrView url(buffer, DLNA_MAX_URL_LEN);
 
    // add device url to server
    const char* device_path = p_device_info->getDeviceURL().path();
    const char* prefix = p_device_info->getBaseURL();
 
    DlnaLogger.log(DlnaLogLevel::Info, "Setting up device path: %s",
                   device_path);
    void* ref[] = {p_device_info};
 
    if (!StrView(device_path).isEmpty()) {
      p_server->rewrite("/", device_path);
      p_server->rewrite("/dlna/device.xml", device_path);
      p_server->rewrite("/device.xml", device_path);
      p_server->rewrite("/index.html", device_path);
      p_server->on(device_path, T_GET, deviceXMLCallback, ref, 1);
    }
 
    // Register icons and favicon.ico
    for (Icon &icon : p_device_info->getIcons()) {
      char tmp[DLNA_MAX_URL_LEN];
      // const char* icon_path = url.buildPath(prefix, icon.icon_url);
      p_server->on(icon.icon_url, T_GET, icon.mime,
                   (const uint8_t*)icon.icon_data, icon.icon_size);
      if (icon.isfavicon)  // provide favicon.ico         
        p_server->on("/favicon.ico", T_GET, icon.mime,
                   (const uint8_t*)icon.icon_data, icon.icon_size);
    }
 
    for (DLNAServiceInfo& service : p_device_info->getServices()) {
      // Validate service before registering
      if (!validateServiceInfo(service)) {
        DlnaLogger.log(
            DlnaLogLevel::Error,
            "Skipping service registration due to validation failure");
        continue;
      }
 
      p_server->on(service.scpd_url, T_GET, (web_callback_fn)service.scp_cb);
      p_server->on(service.control_url, T_POST,
                   (web_callback_fn)service.control_cb);
      p_server->on(service.event_sub_url, T_SUBSCRIBE,
                   (web_callback_fn)service.event_sub_cb);
      p_server->on(service.event_sub_url, T_UNSUBSCRIBE,
                   (web_callback_fn)service.event_sub_cb);
      p_server->on(service.event_sub_url, T_POST,
                   (web_callback_fn)service.event_sub_cb);
    }
 
    return true;
  }
 
  static void deviceXMLCallback(IClientHandler& client, IHttpServer* server,
                                const char* requestPath,
                                HttpRequestHandlerLine* hl) {
    DlnaLogger.log(DlnaLogLevel::Debug, "deviceXMLCallback");
 
    DLNADeviceInfo* device_xml = (DLNADeviceInfo*)(hl->context[0]);
    assert(device_xml != nullptr);
    if (device_xml != nullptr) {
      DlnaLogger.log(DlnaLogLevel::Info, "reply %s", "DeviceXML");
      // Use server->reply with a callback so the Content-Length is computed
      // and headers are written correctly before streaming the body.
      client.reply(
          "text/xml",
          [](Print& out, void* ref) -> size_t {
            return ((DLNADeviceInfo*)ref)->print(out, ref);
          },
          200, "SUCCESS", device_xml);
    } else {
      DlnaLogger.log(DlnaLogLevel::Error, "DLNADevice is null");
      client.replyNotFound();
    }
  }
 
  static bool handleSubscribe(IClientHandler* client, IHttpServer* server,
                              const char* requestPath,
                              HttpRequestHandlerLine* hl) {
    DlnaLogger.log(DlnaLogLevel::Debug, "handleSubscribe");
    auto* device = static_cast<IDevice*>(server->getReference());
    assert(device != nullptr);
    DLNAServiceInfo* svc = device->getServiceByEventPath(requestPath);
    assert(svc != nullptr);
 
    // Delegate all HTTP processing to SubscriptionMgrDevice
    return device->getSubscriptionMgr().processSubscribeRequest(*server, *svc,
                                                                client);
  }
 
  static bool handleUnsubscribe(IClientHandler* client, IHttpServer* server,
                                const char* requestPath,
                                HttpRequestHandlerLine* hl) {
    DlnaLogger.log(DlnaLogLevel::Debug, "handleUnsubscribe");
    auto* device = static_cast<IDevice*>(server->getReference());
    assert(device != nullptr);
    DLNAServiceInfo* svc = device->getServiceByEventPath(requestPath);
    assert(svc != nullptr);
 
    // Delegate all HTTP processing to SubscriptionMgrDevice
    return device->getSubscriptionMgr().processUnsubscribeRequest(*server, *svc,
                                                                  client);
  }
};
 
}  // namespace tiny_dlna