DLNAControlPointMgr.h

Go to the documentation of this file.

#pragma once
 
#include "DLNAControlPointRequestParser.h"
#include "DLNADevice.h"
#include "DLNADeviceMgr.h"
#include "Schedule.h"
#include "Scheduler.h"
#include "basic/StrPrint.h"
#include "basic/Url.h"
#include "http/HttpServer.h"
#include "xml/XMLDeviceParser.h"
 
namespace tiny_dlna {
 
class DLNAControlPointMgr;
DLNAControlPointMgr* selfDLNAControlPoint = nullptr;
 
class DLNAControlPointMgr {
 public:
  DLNAControlPointMgr() { selfDLNAControlPoint = this; }
  void setParseDevice(bool flag) { is_parse_device = flag; }
  void setLocalURL(Url url) { local_url = url; }
 
  bool begin(DLNAHttpRequest& http, IUDPService &udp,
             const char* searchTarget = "ssdp:all", uint32_t processingTime = 0,
             bool stopWhenFound = true) {
    DlnaLogger.log(DlnaInfo, "DLNADevice::begin");
    search_target = searchTarget;
    is_active = true;
    p_udp = &udp;
    p_http = &http;
 
    // setup multicast UDP
    if (!(p_udp->begin(DLNABroadcastAddress))) {
      DlnaLogger.log(DlnaError, "UDP begin failed");
      return false;
    }
 
    // Send MSearch request via UDP
    MSearchSchedule* search =
        new MSearchSchedule(DLNABroadcastAddress, searchTarget);
    search->end_time = millis() + 3000;
    search->repeat_ms = 1000;
    scheduler.add(search);
 
    // if processingTime > 0 we do some loop processing already here
    uint64_t end = millis() + processingTime;
    while (millis() < end) {
      if (stopWhenFound && devices.size() > 0) break;
      loop();
    }
 
    DlnaLogger.log(DlnaInfo, "Control Point started with %d devices found",
                   devices.size());
    return devices.size() > 0;
  }
 
  void end() {
    // p_server->end();
    for (auto& device : devices) device.clear();
    is_active = false;
  }
 
  ActionRequest& addAction(ActionRequest act) {
    actions.push_back(act);
    return actions[actions.size() - 1];
  }
 
  ActionReply executeActions() {
    ActionReply result = postAllActions();
    actions.clear();
    return result;
  }
 
  bool subscribe(const char* serviceName, int seconds) {
    auto service = getService(serviceName);
    if (!service) {
      DlnaLogger.log(DlnaError, "No service found for %s", serviceName);
      return false;
    }
 
    auto& device = getDevice(service);
    if (!device) {
      DlnaLogger.log(DlnaError, "Device not found");
      return false;
    }
 
    if (StrView(local_url.url()).isEmpty()) {
      DlnaLogger.log(DlnaError, "Local URL not defined");
      return false;
    }
    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", seconds);
    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(DlnaInfo, "Http rc: %s", rc);
    return rc == 200;
  }
 
  // /// Provides the actual state value
  // const char* getStateValue(const char* name) {
  //   for (auto& st : state) {
  //     if (st.name == name) {
  //       return st.value.c_str();
  //     }
  //   }
  //   return nullptr;
  // }
 
  bool loop() {
    if (!is_active) return false;
    DLNAControlPointRequestParser parser;
 
    // process UDP requests
    RequestData req = p_udp->receive();
    if (req) {
      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;
        }
        scheduler.add(schedule);
      }
    }
 
    // execute scheduled udp replys
    scheduler.execute(*p_udp);
 
    // be nice, if we have other tasks
    delay(5);
    return true;
  }
 
  DLNAServiceInfo& getService(const char* id) {
    static DLNAServiceInfo no_service(false);
    for (auto& dev : devices) {
      DLNAServiceInfo& result = dev.getService(id);
      if (result) return result;
    }
    return no_service;
  }
 
  DLNADevice& getDevice(int deviceIdx = 0) { return devices[deviceIdx]; }
 
  DLNADevice& getDevice(DLNAServiceInfo& service) {
    for (auto& dev : devices) {
      for (auto& srv : dev.getServices()) {
        if (srv == srv) return dev;
      }
    }
    return NO_DEVICE;
  }
 
  DLNADevice& getDevice(Url location) {
    for (auto& dev : devices) {
      if (dev.getDeviceURL() == location) {
        return dev;
      }
    }
    return NO_DEVICE;
  }
 
  Vector<DLNADevice>& getDevices() { return devices; }
 
  bool addDevice(DLNADevice dev) {
    dev.updateTimestamp();
    for (auto& existing_device : devices) {
      if (dev.getUDN() == existing_device.getUDN()) {
        DlnaLogger.log(DlnaInfo, "Device '%s' already exists", dev.getUDN());
        return false;
      }
    }
    DlnaLogger.log(DlnaInfo, "Device '%s' has been added", dev.getUDN());
    devices.push_back(dev);
    return true;
  }
 
  bool addDevice(Url url) {
    DLNADevice& 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(DlnaError, "Http get to '%s' failed with %d", url.url(),
                     rc);
      req.stop();
      return false;
    }
    // get xml
    uint8_t buffer[512];
    while (true) {
      int len = req.read(buffer, 512);
      if (len == 0) break;
      xml.write(buffer, len);
    }
    req.stop();
 
    // parse xml
    DLNADevice new_device;
    XMLDeviceParser parser;
    parser.parse(new_device, strings, xml.c_str());
    new_device.device_url = url;
    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<DLNADevice> devices;
  Vector<ActionRequest> actions;
  XMLPrinter xml;
  bool is_active = false;
  bool is_parse_device = false;
  DLNADevice NO_DEVICE{false};
  const char* search_target;
  StringRegistry strings;
  Url local_url;
 
  static bool processDevice(NotifyReplyCP& data) {
    Str& nts = data.nts;
    if (nts.equals("ssdp:byebye")) {
      selfDLNAControlPoint->processBye(nts);
      return true;
    }
    if (nts.equals("ssdp:alive")) {
      bool select = selfDLNAControlPoint->matches(data.usn.c_str());
      DlnaLogger.log(DlnaInfo, "addDevice: %s -> %s", data.usn.c_str(),
                     select ? "added" : "filtered");
      Url url{data.location.c_str()};
      selfDLNAControlPoint->addDevice(url);
      return true;
    }
    return false;
  }
 
  bool matches(const char* usn) {
    if (StrView(search_target).equals("ssdp:all")) return true;
    return StrView(usn).contains(search_target);
  }
 
  bool processBye(Str& usn) {
    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(DlnaInfo, "removeDevice: %s", usn);
              srv.is_active = false;
            }
          }
        }
      }
    }
    return false;
  }
 
  size_t createXML(ActionRequest& action) {
    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(DlnaDebug, "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 postAllActions() {
    ActionReply result;
    for (auto& action : actions) {
      if (action.getServiceType() != nullptr) result.add(postAction(action));
    }
    return result;
  }
 
  ActionReply postAction(ActionRequest& action) {
    DLNAServiceInfo& service = *action.p_service;
    DLNADevice& device = getDevice(service);
 
    // create XML
    StrPrint str_print;
    xml.setOutput(str_print);
    createXML(action);
 
    // create SOAPACTION header
    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("\"");
 
    p_http->request().put("SOAPACTION", action_str.c_str());
 
    // crate control url
    char url_buffer[200] = {0};
    Url post_url{getUrl(device, service.control_url, url_buffer, 200)};
 
    // post the request
    int rc = p_http->post(post_url, "text/xml", str_print.c_str(),
                          str_print.length());
 
    // check result
    DlnaLogger.log(DlnaInfo, "==> http rc %d", rc);
    ActionReply result(rc == 200);
    if (rc != 200) {
      p_http->stop();
      return result;
    }
 
    // log xml request
    DlnaLogger.log(DlnaDebug, str_print.c_str());
 
    // receive result
    str_print.reset();
    uint8_t buffer[200];
    while (p_http->client()->available()) {
      int len = p_http->client()->read(buffer, 200);
      str_print.write(buffer, len);
    }
 
    // log result
    DlnaLogger.log(DlnaDebug, str_print.c_str());
    p_http->stop();
 
    return result;
  }
 
  const char* getUrl(DLNADevice& device, const char* suffix, const char* buffer,
                     int len) {
    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