DLNADeviceMgr.h

Go to the documentation of this file.

#pragma once
 
#include "DLNADeviceMgr.h"
#include "DLNADevice.h"
#include "DLNADeviceRequestParser.h"
#include "Schedule.h"
#include "basic/Url.h"
#include "http/HttpServer.h"
 
namespace tiny_dlna {
 
class DLNADeviceMgr {
 public:
  bool begin(DLNADevice& device, IUDPService& udp, HttpServer& server) {
    DlnaLogger.log(DlnaInfo, "DLNADevice::begin");
 
    p_server = &server;
    p_udp = &udp;
    setDevice(device);
    setupParser();
 
    // check base url
    const char* baseUrl = device.getBaseURL();
    DlnaLogger.log(DlnaInfo, "base URL: %s", baseUrl);
 
    if (StrView(device.getBaseURL()).contains("localhost")) {
      DlnaLogger.log(DlnaError, "invalid base address: %s", baseUrl);
      return false;
    }
 
    // setup all services
    setupServices(*p_device);
    device.setupServices(server, udp);
 
    // setup web server
    if (!setupDLNAServer(server)) {
      DlnaLogger.log(DlnaError, "setupDLNAServer failed");
      return false;
    }
 
    // start web server
    Url url{baseUrl};
    if (!p_server->begin(url.port())) {
      DlnaLogger.log(DlnaError, "Server failed");
      return false;
    }
 
    // setup UDP
    if (!p_udp->begin(DLNABroadcastAddress)) {
      DlnaLogger.log(DlnaError, "UDP begin failed");
      return false;
    }
 
    if (!setupScheduler()) {
      DlnaLogger.log(DlnaError, "Scheduler failed");
      return false;
    }
 
    is_active = true;
    DlnaLogger.log(DlnaInfo, "Device successfully started");
    return true;
  }
 
  void end() {
    p_server->end();
 
    // send 3 bye messages
    PostByeSchedule* bye = new PostByeSchedule(*p_device);
    bye->repeat_ms = 800;
    scheduler.add(bye);
 
    // execute scheduler for 2 seconds
    uint64_t end = millis() + 2000;
    while (millis() < end) {
      scheduler.execute(*p_udp);
    }
 
    is_active = false;
  }
 
  bool loop() {
    if (!is_active) return false;
 
    // handle server requests
    bool rc = p_server->doLoop();
    DlnaLogger.log(DlnaDebug, "server %s", rc ? "true" : "false");
 
    if (isSchedulerActive()) {
      // process UDP requests
      RequestData req = p_udp->receive();
      if (req) {
        Schedule* schedule = parser.parse(*p_device, req);
        if (schedule != nullptr) {
          scheduler.add(schedule);
        }
      }
 
      // execute scheduled udp replys
      scheduler.execute(*p_udp);
    }
 
    // be nice, if we have other tasks
    p_device->loop();
 
    return true;
  }
 
  DLNAServiceInfo getService(const char* id) {
    return p_device->getService(id);
  }
 
  DLNADevice& getDevice() { return *p_device; }
 
  void setSchedulerActive(bool flag) { scheduler_active = flag; }
 
  bool isSchedulerActive() { return scheduler_active; }
 
  void setPostAliveRepeatMs(uint32_t ms) { post_alive_repeat_ms = ms; }
 
 protected:
  Scheduler scheduler;
  DLNADeviceRequestParser parser;
  IUDPService* p_udp = nullptr;
  DLNADevice* p_device = nullptr;
  HttpServer* p_server = nullptr;
  bool is_active = false;
  bool scheduler_active = true;
  uint32_t post_alive_repeat_ms = 0;
 
  void setDevice(DLNADevice& device) { p_device = &device; }
 
  bool setupParser() {
    parser.addMSearchST("upnp:rootdevice");
    parser.addMSearchST("ssdp:all");
    parser.addMSearchST(p_device->getUDN());
    parser.addMSearchST(p_device->getDeviceType());
    return true;
  }
 
  bool setupScheduler() {
    // schedule post alive messages: Usually repeated 2 times (because UDP
    // messages might be lost)
    PostAliveSchedule* postAlive =
        new PostAliveSchedule(*p_device, post_alive_repeat_ms);
    PostAliveSchedule* postAlive1 =
        new PostAliveSchedule(*p_device, post_alive_repeat_ms);
    postAlive1->time = millis() + 100;
    scheduler.add(postAlive);
    scheduler.add(postAlive1);
    return true;
  }
 
  virtual bool setupDLNAServer(HttpServer& srv) {
    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->getDeviceURL().path();
    const char* prefix = p_device->getBaseURL();
 
    DlnaLogger.log(DlnaInfo, "Setting up device path: %s", device_path);
    void* ref[] = {p_device};
 
    if (!StrView(device_path).isEmpty()) {
      p_server->rewrite("/", device_path);
      p_server->rewrite("/dlna/device.xml", device_path);
      p_server->rewrite("/index.html", device_path);
      p_server->on(device_path, T_GET, deviceXMLCallback, ref, 1);
    }
 
    // Register icon and privide favicon.ico
    Icon icon = p_device->getIcon();
    if (icon.icon_data != nullptr) {
      char tmp[DLNA_MAX_URL_LEN];
      const char* icon_path = url.buildPath(prefix, icon.icon_url);
      p_server->on(icon_path, T_GET, icon.mime, (const uint8_t*)icon.icon_data,
                   icon.icon_size);
      p_server->on("/favicon.ico", T_GET, icon.mime,
                   (const uint8_t*)icon.icon_data, icon.icon_size);
    }
 
    // Register Service URLs
    for (DLNAServiceInfo& service : p_device->getServices()) {
      p_server->on(url.buildPath(prefix, service.scpd_url), T_GET,
                   service.scp_cb, ref, 1);
      p_server->on(url.buildPath(prefix, service.control_url), T_POST,
                   service.control_cb, ref, 1);
      p_server->on(url.buildPath(prefix, service.event_sub_url), T_GET,
                   service.event_sub_cb, ref, 1);
    }
 
    return true;
  }
 
  static void deviceXMLCallback(HttpServer* server, const char* requestPath,
                                HttpRequestHandlerLine* hl) {
    DLNADevice* device_xml = (DLNADevice*)(hl->context[0]);
    assert(device_xml != nullptr);
    if (device_xml != nullptr) {
      Client& client = server->client();
      assert(&client != nullptr);
      DlnaLogger.log(DlnaInfo, "reply %s", "DeviceXML");
      server->replyHeader().setValues(200, "SUCCESS");
      server->replyHeader().put(CONTENT_TYPE, "text/xml");
      server->replyHeader().put(CONNECTION, CON_KEEP_ALIVE);
      server->replyHeader().write(client);
 
      // print xml result
      device_xml->print(client);
      server->endClient();
    } else {
      DlnaLogger.log(DlnaError, "DLNADevice is null");
      server->replyNotFound();
    }
  }
 
  virtual void setupServices(DLNADevice& deviceInfo) {};
};
 
}  // namespace tiny_dlna