SubscriptionMgrControlPoint.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
 
#include "basic/Url.h"
#include "basic/Vector.h"
#include "dlna/common/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;
    attachHttpServer(*p_http_server);
    // Initialize event subscription state
    setNotificationsActive(event_subscription_active);
  }
  void setHttpServer(IHttpServer& server) {
    DlnaLogger.log(DlnaLogLevel::Debug, "DLNAControlPointMgr::setHttpServer");
    p_http_server = &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 setNotificationsActive(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 = true;
  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;
    void* ctx[1];
    ctx[0] = this;
    const char* path = p_local_url->path();
    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) {
    DlnaLogger.log(DlnaLogLevel::Info, "subscribeToDevice");
    bool ok = true;
    for (auto& service : device.getServices()) {
      if (!subscribeToService(service)) {
        DlnaLogger.log(DlnaLogLevel::Error, "Subscription to service %s failed",
                       service.service_id.c_str());
        ok = false;
      }
    }
    return ok;
  }
 
  bool unsubscribeFromDevice(DLNADeviceInfo& device) {
    DlnaLogger.log(DlnaLogLevel::Info, "unsubscribeFromDevice");
    bool ok = true;
    for (auto& service : device.getServices()) {
      if (!unsubscribeFromService(service)) {
        DlnaLogger.log(DlnaLogLevel::Warning,
                       "Unsubscribe from service %s failed",
                       service.service_id.c_str());
        ok = false;
      }
    }
    return ok;
  }
 
  bool subscribeToService(DLNAServiceInfo& service) {
    if (StrView(service.event_sub_url).isEmpty()) {
      return false;
    }
 
    Url url(getURLString(service).c_str());
 
    // 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);
    char callback_url[256] = {0};
    snprintf(callback_url, sizeof(callback_url), "<%s>",
             p_local_url ? p_local_url->url() : "");
    p_http->request().put("NT", "upnp:event");
    p_http->request().put("TIMEOUT", seconds_txt);
    p_http->request().put("CALLBACK", callback_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());
    }
    p_http->request().put("CONTENT-LENGTH", "0");
 
    int rc = p_http->subscribe(url);
    if (!p_http->isKeepAlive()) {
      p_http->stop();
    }
    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.c_str(), 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(getURLString(service).c_str());
    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.c_str(), rc);
      return false;
    }
    return true;
  }
 
  static void notifyHandler(IClientHandler& client, 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 = client.requestHeader().get("SID");
 
    // 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* p_client = client.client();
    while (p_client && p_client->available()) {
      int read = p_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
    client.replyOK();
  }
 
  Str getURLString(DLNAServiceInfo& service) {
    Str url_str{100};
    if (service.event_sub_url.startsWith("/")) {
      // relative URL: need to build full URL using device base URL
      url_str = p_device->getBaseURL();
      if (url_str.endsWith("/") && service.event_sub_url.startsWith("/"))
        url_str += service.event_sub_url.c_str() + 1;
      else
        url_str += service.event_sub_url.c_str();
 
    } else {
      url_str = service.event_sub_url.c_str();
    }
    return url_str;
  }
};
 
}  // namespace tiny_dlna