WIP

Author: hasselmm

CMakeLists.txt

@@ -34,12 +34,12 @@ find_package(Qt6 QUIET COMPONENTS Core NO_SYSTEM_ENVIRONMENT_PATH)
 
 if (Qt6_FOUND)
     find_package(Qt6 REQUIRED COMPONENTS Network Test)
-    find_package(Qt6 QUIET COMPONENTS Zlib)
+    find_package(Qt6 QUIET COMPONENTS Widgets Zlib)
     set(Qt_DIR ${QT6_INSTALL_PREFIX})
     set(Qt_VERSION ${Qt6_VERSION})
 else()
     find_package(Qt5 5.15 REQUIRED COMPONENTS Network Test)
-    find_package(Qt5 QUIET COMPONENTS Zlib)
+    find_package(Qt5 QUIET COMPONENTS Widgets Zlib)
     set(Qt_VERSION ${Qt5_VERSION})
     set(Qt_DIR ${Qt5_DIR})
 endif()

upnp/CMakeLists.txt

@@ -2,11 +2,18 @@ qnc_add_library(
     QncUpnp STATIC
     upnpresolver.cpp
     upnpresolver.h
+    upnptreemodel.cpp
+    upnptreemodel.h
 )
 
 target_link_libraries(QncUpnp PUBLIC QncSsdp QncXml)
 
 if (NOT IOS) # FIXME Figure out code signing on Github
-    qnc_add_executable(UPNPResolverDemo TYPE tool upnpresolverdemo.cpp)
-    target_link_libraries(UPNPResolverDemo PRIVATE QncUpnp)
+    qnc_add_executable(upnpresolverdemo TYPE tool upnpresolverdemo.cpp)
+    target_link_libraries(upnpresolverdemo PRIVATE QncUpnp)
+
+    if (TARGET Qt::Widgets)
+        qnc_add_executable(upnpviewer TYPE tool upnpviewer.cpp)
+        target_link_libraries(upnpviewer PRIVATE QncUpnp Qt::Widgets)
+    endif()
 endif()

upnp/upnpresolver.cpp

@@ -17,6 +17,8 @@ namespace qnc::xml {
 
 using namespace qnc::upnp;
 
+template <> DeviceModel              &currentObject(DeviceDescription       &device)  { return device.model; }
+template <> DeviceManufacturer       &currentObject(DeviceDescription       &device)  { return device.manufacturer; }
 template <> IconDescription          &currentObject(DeviceDescription       &device)  { return device.icons.last(); }
 template <> ServiceDescription       &currentObject(DeviceDescription       &device)  { return device.services.last(); }
 template <> ActionDescription        &currentObject(ControlPointDescription &service) { return service.actions.last(); }
@@ -160,10 +162,8 @@ class DetailLoader : public QObject
         , m_device{std::move(device)}
     {}
 
-    void fetchIcons();
-    void parseServiceDescription();
-    void parseControlDescription();
-    void parseEventingDescription();
+    void loadIcons();
+    void loadServiceDescription();
 
     const DeviceDescription &device() const { return m_device; }
     QList<QNetworkReply *> pendingReplies() const { return m_pendingReplies; }
@@ -172,6 +172,9 @@ class DetailLoader : public QObject
     void finished();
 
 private:
+    template <class Container>
+    void load(const char *topic, Container *container);
+
     void checkIfAllRequestsFinished();
 
     QNetworkAccessManager *const m_networkAccessManager;
@@ -216,16 +219,16 @@ QList<DeviceDescription> DeviceDescriptionParser::read(const QUrl &deviceUrl, St
             State::Device, {
                 {u"deviceType",         assign<&DeviceDescription::deviceType>(device)},
                 {u"friendlyName",       assign<&DeviceDescription::displayName>(device)},
-                {u"manufacturer",       assign<&DeviceDescription::manufacturerName>(device)},
-                {u"manufacturerURL",    assign<&DeviceDescription::manufacturerUrl>(device)},
-                {u"modelDescription",   assign<&DeviceDescription::modelDescription>(device)},
-                {u"modelName",          assign<&DeviceDescription::modelName>(device)},
-                {u"modelNumber",        assign<&DeviceDescription::modelNumber>(device)},
-                {u"modelURL",           assign<&DeviceDescription::modelUrl>(device)},
+                {u"manufacturer",       assign<&DeviceManufacturer::name>(device)},
+                {u"manufacturerURL",    assign<&DeviceManufacturer::url>(device)},
+                {u"modelDescription",   assign<&DeviceModel::description>(device)},
+                {u"modelName",          assign<&DeviceModel::name>(device)},
+                {u"modelNumber",        assign<&DeviceModel::number>(device)},
+                {u"modelURL",           assign<&DeviceModel::url>(device)},
                 {u"presentationURL",    assign<&DeviceDescription::presentationUrl>(device)},
                 {u"serialNumber",       assign<&DeviceDescription::serialNumber>(device)},
                 {u"UDN",                assign<&DeviceDescription::uniqueDeviceName>(device)},
-                {u"UPC",                assign<&DeviceDescription::universalProductCode>(device)},
+                {u"UPC",                assign<&DeviceModel::universalProductCode>(device)},
 
                 {u"deviceList",         transition<State::DeviceList>()},
                 {u"iconList",           transition<State::IconList>()},
@@ -304,6 +307,7 @@ std::optional<ControlPointDescription> ControlPointDescriptionParser::read(State
             State::Argument, {
                 {u"name",                   assign<&ArgumentDescription::name>(service)},
                 {u"direction",              assign<&ArgumentDescription::direction>(service)},
+                {u"retval",                 assign<&ArgumentDescription::flags, ArgumentDescription::Flag::ReturnValue>(service)},
                 {u"relatedStateVariable",   assign<&ArgumentDescription::stateVariable>(service)},
             }
         }, {
@@ -339,25 +343,67 @@ std::optional<ControlPointDescription> ControlPointDescriptionParser::read(State
     return service;
 }
 
-void DetailLoader::fetchIcons()
+QUrl itemUrl(const IconDescription &icon)
+{
+    return icon.url;
+}
+
+QUrl itemUrl(const ServiceDescription &service)
+{
+    return service.scpdUrl;
+}
+
+bool itemHasData(const IconDescription &icon)
+{
+    return !icon.data.isEmpty();
+}
+
+bool itemHasData(const ServiceDescription &service)
+{
+    return service.scpd.has_value();
+}
+
+void updateItem(IconDescription &icon, QNetworkReply *reply)
+{
+    icon.data = reply->readAll();
+}
+
+void updateItem(ServiceDescription &service, QNetworkReply *reply)
 {
-    for (auto icon = m_device.icons.begin(); icon != m_device.icons.end(); ++icon) {
+    service.scpd = ControlPointDescription::parse(reply);
+}
+
+template <class Container>
+void DetailLoader::load(const char *topic, Container *container)
+{
+    const auto first = container->cbegin();
+    const auto last  = container->cend();
+
+    for (auto it = first; it != last; ++it) {
+        const auto &url = itemUrl(*it);
 
-        if (icon->url.isEmpty())
+        if (url.isEmpty())
             continue;
-        if (!icon->data.isEmpty())
+        if (itemHasData(*it))
             continue;
 
-        const auto index = icon - m_device.icons.begin();
-        const auto reply = m_networkAccessManager->get(QNetworkRequest{icon->url});
+        const auto request = QNetworkRequest{m_device.url.resolved(url)};
+        const auto reply   = m_networkAccessManager->get(request);
+        const auto index   = it - first;
 
-        connect(reply, &QNetworkReply::finished, this, [this, index, reply] {
+        qCInfo(lcResolver,
+               "Downloading %s for %ls from <%ls>", topic,
+               qUtf16Printable(m_device.uniqueDeviceName),
+               qUtf16Printable(request.url().toDisplayString()));
+
+        connect(reply, &QNetworkReply::finished, this, [this, container, index, reply] {
             if (reply->error() != QNetworkReply::NoError) {
-                qCWarning(lcResolver, "Could not download icon from %ls: %ls",
+                qCWarning(lcResolver, "Could not download detail for %ls from %ls: %ls",
+                          qUtf16Printable(m_device.uniqueDeviceName),
                           qUtf16Printable(reply->url().toDisplayString()),
                           qUtf16Printable(reply->errorString()));
             } else {
-                m_device.icons[index].data = reply->readAll();
+                updateItem((*container)[index], reply);
             }
 
             checkIfAllRequestsFinished();
@@ -367,16 +413,14 @@ void DetailLoader::fetchIcons()
     }
 }
 
-void DetailLoader::parseServiceDescription()
-{
-}
-
-void DetailLoader::parseControlDescription()
+void DetailLoader::loadIcons()
 {
+    load("icons", &m_device.icons);
 }
 
-void DetailLoader::parseEventingDescription()
+void DetailLoader::loadServiceDescription()
 {
+    load("services", &m_device.services);
 }
 
 void DetailLoader::checkIfAllRequestsFinished()
@@ -385,6 +429,10 @@ void DetailLoader::checkIfAllRequestsFinished()
         if (reply && reply->isRunning())
             return;
 
+    qCInfo(lcResolver,
+           "All details downloaded for %ls",
+           qUtf16Printable(m_device.uniqueDeviceName));
+
     emit finished();
 }
 
@@ -444,16 +492,33 @@ QNetworkAccessManager *Resolver::networkAccessManager() const
 
 void Resolver::onServiceFound(const ssdp::ServiceDescription &service)
 {
-    if (m_networkAccessManager) {
-        const auto &locationList = service.locations();
+    const auto &locationList = service.locations();
+
+    for (const auto &url : locationList) {
+        if (m_networkAccessManager) {
+            qCInfo(lcResolver,
+                   "Downloading device description for %ls from <%ls>",
+                   qUtf16Printable(service.name()), qUtf16Printable(url.toDisplayString()));
 
-        for (const auto &url: locationList) {
             const auto reply = m_networkAccessManager->get(QNetworkRequest{url});
+
             connect(reply, &QNetworkReply::finished, this, [this, reply] {
                 onDeviceDescriptionReceived(reply);
             });
 
             m_pendingReplies += reply;
+        } else {
+            qCInfo(lcResolver,
+                   "Directly reporting %ls without downloading from <%ls>",
+                   qUtf16Printable(service.name()), qUtf16Printable(url.toDisplayString()));
+
+            auto device = DeviceDescription{};
+
+            device.url              = url;
+            device.deviceType       = service.type();
+            device.uniqueDeviceName = service.name();
+
+            emit deviceFound(device);
         }
     }
 }
@@ -462,22 +527,28 @@ void Resolver::onDeviceDescriptionReceived(QNetworkReply *reply)
 {
     m_pendingReplies.removeOne(reply);
 
-    qInfo() << reply->url() << reply->error() << reply->errorString();
+    if (reply->error() == QNetworkReply::NoError) {
+        qCInfo(lcResolver,
+               "Device description received from <%ls>",
+               qUtf16Printable(reply->url().toDisplayString()));
+    } else {
+        qCWarning(lcResolver,
+                  "Could not download device description received from <%ls>: %ls",
+                  qUtf16Printable(reply->url().toDisplayString()),
+                  qUtf16Printable(reply->errorString()));
+    }
 
     auto deviceList = DeviceDescription::parse(reply, reply->url());
 
     for (auto &device : deviceList) {
         if (m_behaviors && m_networkAccessManager) {
             const auto detailLoader = new DetailLoader{std::move(device), m_networkAccessManager, this};
 
-            if (m_behaviors.testFlag(Behavior::FetchIcons))
-                detailLoader->fetchIcons();
-            if (m_behaviors.testFlag(Behavior::ParseServiceDescription))
-                detailLoader->parseServiceDescription();
-            if (m_behaviors.testFlag(Behavior::ParseControlDescription))
-                detailLoader->parseControlDescription();
-            if (m_behaviors.testFlag(Behavior::ParseEventingDescription))
-                detailLoader->parseEventingDescription();
+            if (m_behaviors.testFlag(Behavior::LoadIcons))
+                detailLoader->loadIcons();
+
+            if (m_behaviors.testFlag(Behavior::LoadServiceDescription))
+                detailLoader->loadServiceDescription();
 
             m_pendingReplies += detailLoader->pendingReplies();
 
@@ -514,4 +585,87 @@ std::optional<ControlPointDescription> ControlPointDescription::parse(QIODevice
 
 } // namespace qnc::upnp
 
+QDebug operator<<(QDebug debug, const qnc::upnp::DeviceDescription &device)
+{
+    const auto _ = QDebugStateSaver{debug};
+
+    const auto verbose = (debug.verbosity() > QDebug::DefaultVerbosity);
+    const auto silent  = (debug.verbosity() < QDebug::DefaultVerbosity);
+
+    if (verbose)
+        debug.nospace() << device.staticMetaObject.className();
+
+    debug << "(udn=" << device.uniqueDeviceName
+          << ", type=" << device.deviceType;
+
+    if (verbose)
+        debug << ", spec=" << device.specVersion;
+
+    if (!device.displayName.isEmpty())
+        debug << ", name=" << device.displayName;
+
+    debug << ", manufacturer=" << device.manufacturer
+          << ", model=" << device.model;
+
+    if (!device.presentationUrl.isEmpty())
+        debug << ", presentationUrl=" << device.presentationUrl;
+    if (!device.serialNumber.isEmpty())
+        debug << ", serialNumber=" << device.serialNumber;
+    if (!device.url.isEmpty())
+        debug << ", url=" << device.url;
+
+    if (!silent) {
+         //     QList<IconDescription>    icons = {};
+         //     QList<ServiceDescription> services = {};
+    }
+
+    return debug << ')';
+}
+
+QDebug operator<<(QDebug debug, const qnc::upnp::DeviceManufacturer &manufacturer)
+{
+    const auto _ = QDebugStateSaver{debug};
+
+    const auto verbose = (debug.verbosity() > QDebug::DefaultVerbosity);
+    const auto silent  = (debug.verbosity() < QDebug::DefaultVerbosity);
+
+    if (verbose)
+        debug.nospace() << manufacturer.staticMetaObject.className();
+
+    debug << '(';
+
+    if (!manufacturer.name.isEmpty())
+        debug << ", name=" << manufacturer.name;
+    if (!silent && !manufacturer.url.isEmpty())
+        debug << ", url=" << manufacturer.url;
+
+    return debug << ')';
+}
+
+QDebug operator<<(QDebug debug, const qnc::upnp::DeviceModel &model)
+{
+    const auto _ = QDebugStateSaver{debug};
+
+    const auto verbose = (debug.verbosity() > QDebug::DefaultVerbosity);
+    const auto silent  = (debug.verbosity() < QDebug::DefaultVerbosity);
+
+    if (verbose)
+        debug.nospace() << model.staticMetaObject.className();
+
+    debug << '(';
+
+    if (!model.universalProductCode.isEmpty())
+        debug << ", universalProductCode=" << model.universalProductCode;
+    if (!model.description.isEmpty())
+        debug << ", description=" << model.description;
+    if (!model.name.isEmpty())
+        debug << ", name=" << model.name;
+    if (!model.number.isEmpty())
+        debug << ", number=" << model.number;
+    if (!silent && !model.url.isEmpty())
+        debug << ", url=" << model.url;
+
+    return debug << ')';
+}
+
 #include "upnpresolver.moc"