Update UA backend

modifyMonitoredItem as well as DataChange filters have been added to the
other backends in the meantime. Add these features to the ua backend as
well.

Change-Id: Ie9e83111e17e1d3435d333f828cd58a85bf2368c
Reviewed-by: Jannis Völker <jannis.voelker@basyskom.com>
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>

4 files changed, 290 insertions, 110 deletions

diff --git a/src/plugins/opcua/uacpp/quacppsubscription.cpp b/src/plugins/opcua/uacpp/quacppsubscription.cpp
index 279bc86..87588c8 100644
--- a/src/plugins/opcua/uacpp/quacppsubscription.cpp
+++ b/src/plugins/opcua/uacpp/quacppsubscription.cpp
@@ -36,7 +36,7 @@ Q_DECLARE_LOGGING_CATEGORY(QT_OPCUA_PLUGINS_UACPP)
 QUACppSubscription::QUACppSubscription(UACppAsyncBackend *backend, const QOpcUaMonitoringParameters &settings)
     : UaSubscriptionCallback()
     , m_backend(backend)
-    , m_parameters(settings)
+    , m_subscriptionParameters(settings)
     , m_nativeSubscription(nullptr)
 {
 }
@@ -50,7 +50,7 @@ quint32 QUACppSubscription::createOnServer()
     UaStatus result;
     ServiceSettings serviceSettings;
     SubscriptionSettings subscriptionSettings;
-    subscriptionSettings.publishingInterval = m_parameters.publishingInterval();
+    subscriptionSettings.publishingInterval = m_subscriptionParameters.publishingInterval();
 
     result = m_backend->m_nativeSession->createSubscription(
                 serviceSettings,
@@ -111,6 +111,8 @@ bool QUACppSubscription::addAttributeMonitoredItem(uintptr_t handle, QOpcUa::Nod
     createRequests[0].RequestedParameters.QueueSize = 1;
     createRequests[0].RequestedParameters.DiscardOldest = OpcUa_True;
     createRequests[0].MonitoringMode = static_cast<OpcUa_MonitoringMode>(parameters.monitoringMode());
+    if (parameters.filter().type() == QVariant::UserType && parameters.filter().userType() == QMetaType::type("QOpcUaMonitoringParameters::DataChangeFilter"))
+        createRequests[0].RequestedParameters.Filter = createFilter(parameters.filter());
 
     result = m_nativeSubscription->createMonitoredItems(settings, OpcUa_TimestampsToReturn_Both,
                                                         createRequests, createResults);
@@ -123,12 +125,6 @@ bool QUACppSubscription::addAttributeMonitoredItem(uintptr_t handle, QOpcUa::Nod
         return false;
     }
 
-    // Store information
-    const auto p = qMakePair(handle, attr);
-    m_monitoredItems.insert(p, createResults[0]);
-    m_monitoredIds.insert(monitorId, p);
-    monitorId++;
-
     QOpcUaMonitoringParameters s;
     s.setSubscriptionId(m_nativeSubscription->subscriptionId());
     s.setPublishingInterval(m_nativeSubscription->publishingInterval());
@@ -138,6 +134,13 @@ bool QUACppSubscription::addAttributeMonitoredItem(uintptr_t handle, QOpcUa::Nod
     s.setSamplingInterval(createResults[0].RevisedSamplingInterval);
     emit m_backend->monitoringEnableDisable(handle, attr, true, s);
 
+    // Store information
+    const auto key = qMakePair(handle, attr);
+    const auto value = qMakePair(createResults[0], parameters);
+    m_monitoredItems.insert(key, value);
+    m_monitoredIds.insert(monitorId, key);
+    monitorId++;
+
     return true;
 }
 
@@ -156,106 +159,66 @@ void QUACppSubscription::modifyMonitoring(uintptr_t handle, QOpcUa::NodeAttribut
 
     // SetPublishingMode service
     if (item == QOpcUaMonitoringParameters::Parameter::PublishingEnabled) {
+        if (value.type() != QVariant::Bool) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP) << "New value for PublishingEnabled is not a boolean";
+            p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return;
+        }
+        ServiceSettings service;
+        const OpcUa_Boolean enable = value.toBool();
+        UaStatus result = m_nativeSubscription->setPublishingMode(service, enable);
+
+        if (result.isNotGood()) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Failed to set publishing mode:" << result.statusCode();
+            p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(result.statusCode()));
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return;
+        }
+
+        p.setPublishingEnabled(value.toBool());
+        p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(result.statusCode()));
         emit m_backend->monitoringStatusChanged(handle, attr, item, p);
         return;
     }
 
     // SetMonitoringMode service
     if (item == QOpcUaMonitoringParameters::Parameter::MonitoringMode) {
-        emit m_backend->monitoringStatusChanged(handle, attr, item, p);
-        return;
-    }
-
-    // ModifySubscription service
-    {
-        SubscriptionSettings settings;
-        settings.maxNotificationsPerPublish = m_nativeSubscription->maxNotificationsPerPublish();
-        settings.publishingInterval = m_nativeSubscription->publishingInterval();
-        settings.lifetimeCount = m_nativeSubscription->lifetimeCount();
-        settings.maxKeepAliveCount = m_nativeSubscription->maxKeepAliveCount();
-
-        bool match = false;
-
-        switch (item) {
-        case QOpcUaMonitoringParameters::Parameter::PublishingInterval: {
-            bool ok;
-            settings.publishingInterval = value.toDouble(&ok);
-
-            if (!ok) {
-                qCWarning(QT_OPCUA_PLUGINS_UACPP, "Could not modify PublishingInterval for %lu, value is not a double", handle);
-                p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
-                emit m_backend->monitoringStatusChanged(handle, attr, item, p);
-                return;
-            }
-            match = true;
-            break;
-        }
-        case QOpcUaMonitoringParameters::Parameter::LifetimeCount: {
-            bool ok;
-            settings.lifetimeCount = value.toUInt(&ok);
-
-            if (!ok) {
-                qCWarning(QT_OPCUA_PLUGINS_UACPP, "Could not modify LifetimeCount for %lu, value is not an integer", handle);
-                p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
-                emit m_backend->monitoringStatusChanged(handle, attr, item, p);
-                return;
-            }
-            match = true;
-            break;
-        }
-        case QOpcUaMonitoringParameters::Parameter::MaxKeepAliveCount: {
-            bool ok;
-            settings.maxKeepAliveCount = value.toUInt(&ok);
-
-            if (!ok) {
-                qCWarning(QT_OPCUA_PLUGINS_UACPP, "Could not modify MaxKeepAliveCount for %lu, value is not an integer", handle);
-                p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
-                emit m_backend->monitoringStatusChanged(handle, attr, item, p);
-                return;
-            }
-            match = true;
-            break;
-        }
-        default:
-            break;
+        if (value.type() != QVariant::UserType || value.userType() != QMetaType::type("QOpcUaMonitoringParameters::MonitoringMode")) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP) << "New value for MonitoringMode is not a monitoring mode";
+            p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return;
         }
 
-        if (match) {
-            ServiceSettings service;
-            const double oldPublishInterval = m_nativeSubscription->publishingInterval();
-            const quint32 oldLifeTimeCount = m_nativeSubscription->lifetimeCount();
-            const quint32 oldMaxKeepAlive = m_nativeSubscription->maxKeepAliveCount();
-            UaStatus result = m_nativeSubscription->modifySubscription(service, settings);
-
-            if (result.isBad()) {
-                p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(result.statusCode()));
-                emit m_backend->monitoringStatusChanged(handle, attr, item, p);
-            } else {
-                p.setStatusCode(QOpcUa::UaStatusCode::Good);
-                p.setPublishingInterval(settings.publishingInterval);
-                p.setLifetimeCount(settings.lifetimeCount);
-                p.setMaxKeepAliveCount(settings.maxKeepAliveCount);
-
-                QOpcUaMonitoringParameters::Parameters changed = item;
-                if (!qFuzzyCompare(p.publishingInterval(), oldPublishInterval))
-                    changed |= QOpcUaMonitoringParameters::Parameter::PublishingInterval;
-                if (p.lifetimeCount() != oldLifeTimeCount)
-                    changed |= QOpcUaMonitoringParameters::Parameter::LifetimeCount;
-                if (p.maxKeepAliveCount() != oldMaxKeepAlive)
-                    changed |= QOpcUaMonitoringParameters::Parameter::MaxKeepAliveCount;
-
-                for (auto it : qAsConst(m_monitoredIds))
-                    emit m_backend->monitoringStatusChanged(it.first, it.second, changed, p);
-            }
+        ServiceSettings service;
+        OpcUa_MonitoringMode mode = static_cast<OpcUa_MonitoringMode>(value.value<QOpcUaMonitoringParameters::MonitoringMode>());
+        UaUInt32Array ids;
+        ids.create(1);
+        ids[0] = m_monitoredItems[key].first.MonitoredItemId;
+        UaStatusCodeArray results;
+        UaStatusCode result = m_nativeSubscription->setMonitoringMode(service, mode, ids, results);
+
+        if (result.isNotGood()) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Failed to set monitoring mode:" << result.statusCode();
+            p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(result.statusCode()));
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
             return;
         }
-    }
 
-    // ModifyMonitoredItems service
-    {
-        // ### TODO: Add support for uacpp
+        if (results.length() && OpcUa_IsGood(results[0]))
+            p.setMonitoringMode(value.value<QOpcUaMonitoringParameters::MonitoringMode>());
+
+        p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(results.length() ? results[0] : result.statusCode()));
+        emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+        return;
     }
 
+    if (modifySubscriptionParameters(handle, attr, item, value))
+        return;
+    if (modifyMonitoredItemParameters(handle, attr, item, value))
+        return;
+
     qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Modifying" << item << "is not implemented.";
     p.setStatusCode(QOpcUa::UaStatusCode::BadNotImplemented);
     emit m_backend->monitoringStatusChanged(handle, attr, item, p);
@@ -277,7 +240,7 @@ bool QUACppSubscription::removeAttributeMonitoredItem(uintptr_t handle, QOpcUa::
 
     UaUInt32Array removeIds;
     removeIds.resize(1);
-    removeIds[0] = monitoredItem.MonitoredItemId;
+    removeIds[0] = monitoredItem.first.MonitoredItemId;
     UaStatusCodeArray removeResults;
     result = m_nativeSubscription->deleteMonitoredItems(settings, removeIds, removeResults);
     if (result.isBad() || removeResults.length() != 1 || OpcUa_IsBad(removeResults[0])) {
@@ -298,7 +261,7 @@ bool QUACppSubscription::removeAttributeMonitoredItem(uintptr_t handle, QOpcUa::
 
 double QUACppSubscription::interval() const
 {
-    return m_parameters.publishingInterval();
+    return m_subscriptionParameters.publishingInterval();
 }
 
 quint32 QUACppSubscription::subscriptionId() const
@@ -313,7 +276,7 @@ int QUACppSubscription::monitoredItemsCount() const
 
 QOpcUaMonitoringParameters::SubscriptionType QUACppSubscription::shared() const
 {
-    return m_parameters.shared();
+    return m_subscriptionParameters.shared();
 }
 
 void QUACppSubscription::subscriptionStatusChanged(OpcUa_UInt32 clientSubscriptionHandle, const UaStatus &status)
@@ -354,4 +317,223 @@ void QUACppSubscription::newEvents(OpcUa_UInt32 clientSubscriptionHandle, UaEven
     qCWarning(QT_OPCUA_PLUGINS_UACPP) << "eventsChange unhandled";
 }
 
+OpcUa_ExtensionObject QUACppSubscription::createFilter(const QVariant &filterData)
+{
+    OpcUa_ExtensionObject obj;
+    OpcUa_ExtensionObject_Initialize(&obj);
+
+    if (filterData.type() == QVariant::UserType && filterData.userType() == QMetaType::type("QOpcUaMonitoringParameters::DataChangeFilter")) {
+        const QOpcUaMonitoringParameters::DataChangeFilter temp = filterData.value<QOpcUaMonitoringParameters::DataChangeFilter>();
+
+        OpcUa_DataChangeFilter *filter = nullptr;
+
+        OpcUa_EncodeableObject_CreateExtension(&OpcUa_DataChangeFilter_EncodeableType,
+                                               &obj,
+                                               reinterpret_cast<OpcUa_Void **>(&filter));
+
+        if (!filter) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Could not create DataChangeFilter";
+            return obj;
+        }
+        filter->DeadbandType = static_cast<OpcUa_UInt32>(temp.deadbandType);
+        filter->DeadbandValue = static_cast<OpcUa_Double>(temp.deadbandValue);
+        filter->Trigger = static_cast<OpcUa_DataChangeTrigger>(temp.trigger);
+
+        return obj;
+    }
+
+    if (filterData.isValid())
+        qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Could not create filter, invalid input.";
+
+    return obj;
+}
+
+bool QUACppSubscription::modifySubscriptionParameters(uintptr_t handle, QOpcUa::NodeAttribute attr, const QOpcUaMonitoringParameters::Parameter &item, const QVariant &value)
+{
+    QOpcUaMonitoringParameters p;
+    SubscriptionSettings settings;
+    settings.maxNotificationsPerPublish = m_nativeSubscription->maxNotificationsPerPublish();
+    settings.publishingInterval = m_nativeSubscription->publishingInterval();
+    settings.lifetimeCount = m_nativeSubscription->lifetimeCount();
+    settings.maxKeepAliveCount = m_nativeSubscription->maxKeepAliveCount();
+
+    bool match = true;
+
+    switch (item) {
+    case QOpcUaMonitoringParameters::Parameter::PublishingInterval: {
+        bool ok;
+        settings.publishingInterval = value.toDouble(&ok);
+
+        if (!ok) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP, "Could not modify PublishingInterval for %lu, value is not a double", handle);
+            p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return true;
+        }
+        break;
+    }
+    case QOpcUaMonitoringParameters::Parameter::LifetimeCount: {
+        bool ok;
+        settings.lifetimeCount = value.toUInt(&ok);
+
+        if (!ok) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP, "Could not modify LifetimeCount for %lu, value is not an integer", handle);
+            p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return true;
+        }
+        break;
+    }
+    case QOpcUaMonitoringParameters::Parameter::MaxKeepAliveCount: {
+        bool ok;
+        settings.maxKeepAliveCount = value.toUInt(&ok);
+
+        if (!ok) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP, "Could not modify MaxKeepAliveCount for %lu, value is not an integer", handle);
+            p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return true;
+        }
+        break;
+    }
+    default:
+        match = false;
+        break;
+    }
+
+    if (match) {
+        ServiceSettings service;
+        const double oldPublishInterval = m_nativeSubscription->publishingInterval();
+        const quint32 oldLifeTimeCount = m_nativeSubscription->lifetimeCount();
+        const quint32 oldMaxKeepAlive = m_nativeSubscription->maxKeepAliveCount();
+        UaStatus result = m_nativeSubscription->modifySubscription(service, settings);
+
+        if (result.isBad()) {
+            p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(result.statusCode()));
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+        } else {
+            p.setStatusCode(QOpcUa::UaStatusCode::Good);
+            p.setPublishingInterval(settings.publishingInterval);
+            p.setLifetimeCount(settings.lifetimeCount);
+            p.setMaxKeepAliveCount(settings.maxKeepAliveCount);
+
+            QOpcUaMonitoringParameters::Parameters changed = item;
+            if (!qFuzzyCompare(p.publishingInterval(), oldPublishInterval))
+                changed |= QOpcUaMonitoringParameters::Parameter::PublishingInterval;
+            if (p.lifetimeCount() != oldLifeTimeCount)
+                changed |= QOpcUaMonitoringParameters::Parameter::LifetimeCount;
+            if (p.maxKeepAliveCount() != oldMaxKeepAlive)
+                changed |= QOpcUaMonitoringParameters::Parameter::MaxKeepAliveCount;
+
+            m_subscriptionParameters.setLifetimeCount(p.lifetimeCount());
+            m_subscriptionParameters.setMaxKeepAliveCount(p.maxKeepAliveCount());
+            m_subscriptionParameters.setPublishingInterval(p.publishingInterval());
+
+            for (auto it : qAsConst(m_monitoredIds))
+                emit m_backend->monitoringStatusChanged(it.first, it.second, changed, p);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool QUACppSubscription::modifyMonitoredItemParameters(uintptr_t handle, QOpcUa::NodeAttribute attr, const QOpcUaMonitoringParameters::Parameter &item, const QVariant &value)
+{
+    // Get hold of OpcUa_MonitoredItemCreateResult
+    const QPair<uintptr_t, QOpcUa::NodeAttribute> key(handle, attr);
+    if (!m_monitoredItems.contains(key)) {
+        qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Did not find monitored item";
+        return false;
+    }
+    auto valuePair = m_monitoredItems[key];
+    OpcUa_MonitoredItemCreateResult createResult = valuePair.first;
+
+    OpcUa_MonitoredItemModifyRequest modifyRequest;
+    OpcUa_MonitoredItemModifyRequest_Initialize(&modifyRequest);
+    modifyRequest.MonitoredItemId = createResult.MonitoredItemId;
+
+    modifyRequest.RequestedParameters.ClientHandle = m_monitoredIds.key(key);
+    QOpcUaMonitoringParameters p = valuePair.second;
+
+    if (item != QOpcUaMonitoringParameters::Parameter::Filter)
+        modifyRequest.RequestedParameters.Filter = createFilter(valuePair.second.filter());
+
+    bool match = true;
+
+    switch (item) {
+    case QOpcUaMonitoringParameters::Parameter::DiscardOldest: {
+        if (value.type() != QVariant::Bool) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Could not modify DiscardOldest for" << handle << ", value is not a bool";
+            p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return true;
+        }
+        modifyRequest.RequestedParameters.DiscardOldest = value.toBool();
+        break;
+    }
+    case QOpcUaMonitoringParameters::Parameter::QueueSize: {
+        if (value.type() != QVariant::UInt) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Could not modify QueueSize for" << handle << ", value is not an integer";
+            p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return true;
+        }
+        modifyRequest.RequestedParameters.QueueSize = value.toUInt();
+        break;
+    }
+    case QOpcUaMonitoringParameters::Parameter::SamplingInterval: {
+        if (value.type() != QVariant::Double) {
+            qCWarning(QT_OPCUA_PLUGINS_UACPP) << "Could not modify SamplingInterval for" << handle << ", value is not a double";
+            p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+            return true;
+        }
+        modifyRequest.RequestedParameters.SamplingInterval = value.toDouble();
+        break;
+    }
+    case QOpcUaMonitoringParameters::Parameter::Filter: {
+        modifyRequest.RequestedParameters.Filter = createFilter(value);
+        break;
+    }
+    default:
+        match = false;
+        break;
+    }
+
+    if (match) {
+        ServiceSettings service;
+        UaMonitoredItemModifyRequests requests(1, &modifyRequest);
+        UaMonitoredItemModifyResults results;
+        UaStatus result = m_nativeSubscription->modifyMonitoredItems(service, OpcUa_TimestampsToReturn_Both, requests, results);
+
+        if (result.isBad() || OpcUa_IsNotGood(results[0].StatusCode)) {
+            p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(result.isGood() ?
+                                                                  results[0].StatusCode :
+                                                                  result.statusCode()));
+            emit m_backend->monitoringStatusChanged(handle, attr, item, p);
+        } else {
+            p.setStatusCode(QOpcUa::UaStatusCode::Good);
+            QOpcUaMonitoringParameters::Parameters changed = item;
+            if (!qFuzzyCompare(p.samplingInterval(), results[0].RevisedSamplingInterval)) {
+                p.setSamplingInterval(results[0].RevisedSamplingInterval);
+                changed |= QOpcUaMonitoringParameters::Parameter::SamplingInterval;
+            }
+            if (p.queueSize() != results[0].RevisedQueueSize) {
+                p.setQueueSize(results[0].RevisedQueueSize);
+                changed |= QOpcUaMonitoringParameters::Parameter::QueueSize;
+            }
+            if (item == QOpcUaMonitoringParameters::Parameter::DiscardOldest) {
+                p.setDiscardOldest(value.toBool());
+                changed | QOpcUaMonitoringParameters::Parameter::DiscardOldest;
+            }
+
+            emit m_backend->monitoringStatusChanged(handle, attr, changed, p);
+            m_monitoredItems[key].second = p;
+        }
+        return true;
+    }
+
+    return false;
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/opcua/uacpp/quacppsubscription.h b/src/plugins/opcua/uacpp/quacppsubscription.h
index 05ebdf9..b58be99 100644
--- a/src/plugins/opcua/uacpp/quacppsubscription.h
+++ b/src/plugins/opcua/uacpp/quacppsubscription.h
@@ -54,10 +54,16 @@ public:
     void dataChange(OpcUa_UInt32 clientSubscriptionHandle, const UaMonitoredItemNotifications &dataNotifications, const UaDiagnosticInfos &diagnosticInfos) override;
     void newEvents(OpcUa_UInt32 clientSubscriptionHandle, UaEventFieldLists &eventFieldList) override;
 private:
+    OpcUa_ExtensionObject createFilter(const QVariant &filterData);
+
+    bool modifySubscriptionParameters(uintptr_t handle, QOpcUa::NodeAttribute attr, const QOpcUaMonitoringParameters::Parameter &item, const QVariant &value);
+    bool modifyMonitoredItemParameters(uintptr_t handle, QOpcUa::NodeAttribute attr, const QOpcUaMonitoringParameters::Parameter &item, const QVariant &value);
+
     UACppAsyncBackend *m_backend;
-    QOpcUaMonitoringParameters m_parameters;
+    QOpcUaMonitoringParameters m_subscriptionParameters;
     UaClientSdk::UaSubscription *m_nativeSubscription;
-    QHash<QPair<uintptr_t, QOpcUa::NodeAttribute>, OpcUa_MonitoredItemCreateResult> m_monitoredItems;
+    QHash<QPair<uintptr_t, QOpcUa::NodeAttribute>,
+        QPair<OpcUa_MonitoredItemCreateResult, QOpcUaMonitoringParameters>> m_monitoredItems;
     QHash<quint32, QPair<uintptr_t, QOpcUa::NodeAttribute>> m_monitoredIds;
 };
 
diff --git a/src/plugins/opcua/uacpp/uacpp.pro b/src/plugins/opcua/uacpp/uacpp.pro
index d53953c..723f81e 100644
--- a/src/plugins/opcua/uacpp/uacpp.pro
+++ b/src/plugins/opcua/uacpp/uacpp.pro
@@ -14,6 +14,8 @@ win32 {
     # The UA SDK bundles hardcoded builds of libxml and openssl. Preferably we should get rid of
     # this at some point.
     LIBS += libeay32.lib libxml2.lib
+
+    DEFINES += _UA_STACK_USE_DLL
 }
 unix {
     LIBS += -luaclient -luamodule -luamodels -lcoremodule -luabase -luastack -lxmlparser -luapki -lcrypto -lssl -lxml2
diff --git a/tests/auto/qopcuaclient/tst_client.cpp b/tests/auto/qopcuaclient/tst_client.cpp
index 6eb6ee6..061e6d9 100644
--- a/tests/auto/qopcuaclient/tst_client.cpp
+++ b/tests/auto/qopcuaclient/tst_client.cpp
@@ -1854,9 +1854,6 @@ void Tst_QOpcUaClient::subscriptionDataChangeFilter()
 
     if (opcuaClient->backend() == QLatin1String("freeopcua"))
         QSKIP("DataChangeFilter support is not implemented in the freeopcua plugin");
-    if (opcuaClient->backend() == QLatin1String("uacpp"))
-        QSKIP("DataChangeFilter support is not implemented in the unified automation plugin");
-
 
     QScopedPointer<QOpcUaNode> doubleNode(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Double"));
     QVERIFY(doubleNode != 0);
@@ -1923,8 +1920,6 @@ void Tst_QOpcUaClient::modifyPublishingMode()
 
     if (opcuaClient->backend() == QLatin1String("freeopcua"))
         QSKIP("Modification of monitoring is not supported in the freeopcua plugin");
-    if (opcuaClient->backend() == QLatin1String("uacpp"))
-        QSKIP("Modification of monitoring is not supported in the unified automation plugin");
 
     QScopedPointer<QOpcUaNode> doubleNode(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Double"));
     QVERIFY(doubleNode != 0);
@@ -1978,8 +1973,6 @@ void Tst_QOpcUaClient::modifyMonitoringMode()
 
     if (opcuaClient->backend() == QLatin1String("freeopcua"))
         QSKIP("Modification of monitoring is not supported in the freeopcua plugin");
-    if (opcuaClient->backend() == QLatin1String("uacpp"))
-        QSKIP("Modification of monitoring is not supported in the unified automation plugin");
 
     QScopedPointer<QOpcUaNode> doubleNode(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Double"));
     QVERIFY(doubleNode != 0);
@@ -2034,9 +2027,6 @@ void Tst_QOpcUaClient::modifyMonitoredItem()
 
     if (opcuaClient->backend() == QLatin1String("freeopcua"))
         QSKIP("Modification of monitoring is not supported in the freeopcua plugin");
-    if (opcuaClient->backend() == QLatin1String("uacpp"))
-        QSKIP("Modification of monitoring is not supported in the unified automation plugin");
-
 
     QScopedPointer<QOpcUaNode> doubleNode(opcuaClient->node("ns=2;s=Demo.Static.Scalar.Double"));
     QVERIFY(doubleNode != 0);