SubscriptionMgrControlPoint.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
 
#include "basic/Url.h"
#include "basic/Vector.h"
#include "dlna/DLNADeviceInfo.h"
#include "dlna/devices/SubscriptionMgrDevice.h"
#include "dlna/udp/IUDPService.h"
#include "dlna/xml/XMLParserPrint.h"
#include "dlna_config.h"
#include "http/Http.h"
#include "http/Server/IHttpRequest.h"
#include "http/Server/IHttpServer.h"
 
namespace tiny_dlna {
class SubscriptionMgrControlPoint {
 public:
  void setup(IHttpRequest& http, IUDPService& udp, Url& localCallbackUrl,
             DLNADeviceInfo& device) {
    p_http = &http;
    p_udp = &udp;
    // store pointers to shared objects (caller/owner manages lifetime)
    p_local_url = &localCallbackUrl;
    p_device = &device;
    is_setup = true;
    // Initialize event subscription state
    setEventSubscriptionActive(event_subscription_active);
  }
  void setHttpServer(IHttpServer& server) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::setHttpServer");
    p_http_server = &server;
    attachHttpServer(server);
  }
 
  bool hasEventSubscriptionCallback() { return event_callback != nullptr; }
 
  void setEventSubscriptionCallback(
      std::function<void(const char* sid, const char* varName,
                         const char* newValue, void* reference)>
          callback,
      void* ref = nullptr) {
    event_callback = callback;
    event_callback_ref = ref;
  }
 
  void end() {
    // Reset pointers and flags that were initialized by setup()
    p_http = nullptr;
    p_udp = nullptr;
    p_local_url = nullptr;
    p_device = nullptr;
    // Clear manager state related to active subscriptions
    is_setup = false;
    subscription_state = SubscriptionState::Unsubscribed;
    subscribe_timeout = 0;
    last_event_notify_ms = 0;
    event_subscription_active = false;
    processing_timeout = 0;
    // leave p_http_server alone (owner may manage server lifecycle)
  }
 
  void setEventSubscriptionDurationSec(int seconds = 3600) {
    event_subscription_duration_sec = seconds;
  }
 
  void setEventSubscriptionRetryMs(int ms) { event_subscription_retry_ms = ms; }
 
  void setEventSubscriptionActive(bool active) {
    event_subscription_active = active;
 
    // if not setup, ignore
    if (!is_setup) return;
 
    updateSubscriptions();
 
    if (active) {
      is_active = true;
    }
  }
 
  uint64_t getLastEventNotifyMs() { return last_event_notify_ms; }
 
  bool loop() {
    if (!isActive()) return false;
    if (!is_setup) return false;
 
    if (processing_timeout == 0 || millis() < processing_timeout) {
      updateSubscriptions();
      processing_timeout = millis() + event_subscription_retry_ms;
      return true;
    }
    return false;
  }
 
  bool isActive() { return is_active; }
 
 protected:
  void* event_callback_ref = nullptr;
  bool is_active = false;
  SubscriptionState subscription_state = SubscriptionState::Unsubscribed;
  bool is_setup = false;
  uint64_t subscribe_timeout = 0;
  uint32_t event_subscription_duration_sec = 3600;
  uint32_t event_subscription_retry_ms = 0;
  bool event_subscription_active = false;
  uint64_t last_event_notify_ms = 0;  // timestamp of last received NOTIFY
  IHttpRequest* p_http = nullptr;
  IUDPService* p_udp = nullptr;
  IHttpServer* p_http_server = nullptr;
  Url* p_local_url = nullptr;
  DLNADeviceInfo* p_device = nullptr;
  DLNAServiceInfo NO_SERVICE;
  uint64_t processing_timeout = 0;
  std::function<void(const char* sid, const char* varName, const char* newValue,
                     void* reference)>
      event_callback = [](const char* sid, const char* varName,
                          const char* newValue, void* reference) {
        // Default simple logger: print SID, variable name and new value.
        DlnaLogger.log(DlnaLogLevel::Debug,
                       "- Event notification: SID='%s' var='%s' value='%s'",
                       sid ? sid : "", varName ? varName : "",
                       newValue ? newValue : "");
      };
 
  void updateSubscriptions() {
    // subscribe
    if (subscription_state != SubscriptionState::Subscribed &&
        event_subscription_active) {
      subscription_state = SubscriptionState::Subscribing;
      subscribeNotifications(event_subscription_active);
    }
    // or unsubscribe
    if (subscription_state == SubscriptionState::Subscribed &&
        !event_subscription_active) {
      subscription_state = SubscriptionState::Unsubscribing;
      subscribeNotifications(event_subscription_active);
    }
  }
 
  void updateReceived(const char* sid) {
    last_event_notify_ms = millis();
    DLNAServiceInfo& service = getServiceInfoBySID(sid);
    if (&service != &NO_SERVICE) {
      service.time_subscription_confirmed = millis();
      service.subscription_state = SubscriptionState::Subscribed;
    }
  }
 
  // Find service info by matching stored SID. Returns NO_SERVICE if not
  // found.
  DLNAServiceInfo& getServiceInfoBySID(const char* sid) {
    if (sid == nullptr) return NO_SERVICE;
 
    // Search single selected device first (if set)
    if (p_device != nullptr) {
      for (auto& service : p_device->getServices()) {
        const char* ssid = service.subscription_id.c_str();
        if (ssid != nullptr && strcmp(ssid, sid) == 0) return service;
      }
    }
 
    return NO_SERVICE;
  }
 
  void attachHttpServer(IHttpServer& 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 = "/dlna/events";
    if (p_local_url && !StrView(p_local_url->url()).isEmpty())
      path = p_local_url->path();
 
    void* ctx[1];
    ctx[0] = this;
    server.on(path, T_NOTIFY, notifyHandler, ctx, 1);
  }
 
  bool subscribeNotifications(bool subscribe = true) {
    if (p_device == nullptr) return false;
    if (subscribe) return subscribeToDevice(*p_device);
    return unsubscribeFromDevice(*p_device);
  }
  bool subscribeToDevice(DLNADeviceInfo& device) {
    bool ok = true;
    for (auto& service : device.getServices()) {
      if (!subscribeToService(service)) {
        DlnaLogger.log(DlnaLogLevel::Error, "Subscription to service %s failed",
                       service.service_id);
        ok = false;
      }
    }
    return ok;
  }
 
  bool unsubscribeFromDevice(DLNADeviceInfo& device) {
    bool ok = true;
    for (auto& service : device.getServices()) {
      if (!unsubscribeFromService(service)) {
        DlnaLogger.log(DlnaLogLevel::Warning,
                       "Unsubscribe from service %s failed",
                       service.service_id);
        ok = false;
      }
    }
    return ok;
  }
 
  bool subscribeToService(DLNAServiceInfo& service) {
    if (StrView(service.event_sub_url).isEmpty()) {
      return false;
    }
    Url url(service.event_sub_url);
 
    // If already subscribed and not expired, nothing to do
    if (service.subscription_state == SubscriptionState::Subscribed &&
        millis() < service.time_subscription_expires) {
      return true;
    }
 
    char seconds_txt[80] = {0};
    snprintf(seconds_txt, sizeof(seconds_txt), "Second-%d",
             event_subscription_duration_sec);
    p_http->request().put("NT", "upnp:event");
    p_http->request().put("TIMEOUT", seconds_txt);
    p_http->request().put("CALLBACK", p_local_url ? p_local_url->url() : "");
    // For re-subscribe, include existing SID header if present
    if (!service.subscription_id.isEmpty()) {
      p_http->request().put("SID", service.subscription_id.c_str());
    }
 
    int rc = p_http->subscribe(url);
    if (rc == 200) {
      const char* sid = p_http->reply().get("SID");
      if (sid != nullptr) {
        service.subscription_id = sid;
        service.subscription_state = SubscriptionState::Subscribed;
        service.time_subscription_started = millis();
        service.time_subscription_confirmed = millis();
        service.time_subscription_expires =
            millis() + (event_subscription_duration_sec * 1000);
        subscribe_timeout = service.time_subscription_expires;
        DlnaLogger.log(DlnaLogLevel::Info, "Subscribe %s -> rc=%d", url.url(),
                       rc);
      } else {
        DlnaLogger.log(DlnaLogLevel::Warning,
                       "Subscribe %s succeeded but no SID returned", url.url());
        return false;
      }
    } else {
      // failed to subscribe
      DlnaLogger.log(DlnaLogLevel::Error,
                     "Failed to subscribe to service %s, rc=%d",
                     service.service_id, rc);
      return false;
    }
    return true;
  }
 
  bool unsubscribeFromService(DLNAServiceInfo& service) {
    if (StrView(service.event_sub_url).isEmpty()) {
      return false;
    }
    // If already subscribed and not expired, nothing to do
    if (service.subscription_state == SubscriptionState::Unsubscribed) {
      return true;
    }
 
    Url url(service.event_sub_url);
    int rc = p_http->unsubscribe(url, service.subscription_id.c_str());
    if (rc == 200) {
      DlnaLogger.log(DlnaLogLevel::Info, "Unsubscribe %s -> rc=%d", url.url(),
                     rc);
      // clear SID and metadata regardless of remote rc
      service.subscription_id = "";
      service.subscription_state = SubscriptionState::Unsubscribed;
      service.time_subscription_confirmed = 0;
      service.time_subscription_expires = 0;
      subscribe_timeout = 0;
    } else {
      DlnaLogger.log(DlnaLogLevel::Error,
                     "Failed to unsubscribe from service %s, rc=%d",
                     service.service_id, rc);
      return false;
    }
    return true;
  }
 
  static void notifyHandler(IHttpServer* server, const char* requestPath,
                            HttpRequestHandlerLine* handlerLine) {
    if (handlerLine == nullptr || handlerLine->contextCount < 1) return;
    void* ctx0 = handlerLine->context[0];
    SubscriptionMgrControlPoint* mgr =
        static_cast<SubscriptionMgrControlPoint*>(ctx0);
    if (!mgr) return;
    void* reference = mgr->event_callback_ref;
 
    // read SID header and body
    const char* sid = server->requestHeader().get("SID");
 
    // Use XMLParserPrint to incrementally parse the NOTIFY body and extract
    // property child elements. XMLParserPrint accumulates the buffer and
    // exposes a parse() method that returns the next fragment.
 
    // mark notify received early so subscription metadata gets updated
    mgr->updateReceived(sid);
 
    XMLParserPrint xml_parser;
    uint8_t buffer[XML_PARSER_BUFFER_SIZE];
    Str nodeName;
    Vector<Str> path;
    Str text;
    Str attrs;
    xml_parser.setExpandEncoded(true);
    Client& client = server->client();
 
    while (client.available()) {
      int read = client.read(buffer, XML_PARSER_BUFFER_SIZE);
      xml_parser.write(buffer, read);
 
      while (xml_parser.parse(nodeName, path, text, attrs)) {
        // We care about text nodes that are children of a <property> element
        if (text.isEmpty()) continue;
 
        // dispatch
        DLNAServiceInfo& s = mgr->getServiceInfoBySID(sid);
        if (mgr->event_callback) {
          const char* sid_c = sid ? sid : "";
          mgr->event_callback(sid_c, nodeName.c_str(), text.c_str(), reference);
        }
      }
    }
 
    // reply OK to the NOTIFY
    server->replyOK();
  }
};
 
}  // namespace tiny_dlna