From 354f567593daeca7d414c5f57c5697a2380134c1 Mon Sep 17 00:00:00 2001 From: Michael Zanetti Date: Tue, 15 Sep 2020 15:08:02 +0200 Subject: [PATCH] Make use of the new caching mechanism in nymea --- libnymea-app/configuration/networkmanager.cpp | 60 ++-- libnymea-app/configuration/networkmanager.h | 16 +- .../configuration/nymeaconfiguration.cpp | 78 ++--- .../configuration/nymeaconfiguration.h | 33 +-- libnymea-app/devicediscovery.cpp | 6 +- libnymea-app/devicediscovery.h | 2 +- libnymea-app/devicemanager.cpp | 164 +++++------ libnymea-app/devicemanager.h | 85 +++--- libnymea-app/jsonrpc/jsonrpcclient.cpp | 266 +++++++++++------- libnymea-app/jsonrpc/jsonrpcclient.h | 22 +- libnymea-app/models/logsmodel.cpp | 8 +- libnymea-app/models/logsmodel.h | 2 +- libnymea-app/models/logsmodelng.cpp | 8 +- libnymea-app/models/logsmodelng.h | 2 +- libnymea-app/models/tagsproxymodel.cpp | 1 - libnymea-app/rulemanager.cpp | 52 ++-- libnymea-app/rulemanager.h | 20 +- libnymea-app/scriptmanager.cpp | 43 ++- libnymea-app/scriptmanager.h | 12 +- libnymea-app/system/systemcontroller.cpp | 79 +++--- libnymea-app/system/systemcontroller.h | 28 +- libnymea-app/tagsmanager.cpp | 28 +- libnymea-app/tagsmanager.h | 14 +- libnymea-app/thinggroup.cpp | 8 +- libnymea-app/usermanager.cpp | 28 +- libnymea-app/usermanager.h | 8 +- nymea-app/ui/components/Dial.qml | 10 +- .../ui/devicepages/DeviceBrowserPage.qml | 18 +- .../FingerprintReaderDevicePage.qml | 2 +- .../ui/devicepages/GenericDevicePage.qml | 6 +- nymea-app/ui/devicepages/LightDevicePage.qml | 2 +- nymea-app/ui/devicepages/MediaDevicePage.qml | 22 +- nymea-app/ui/experiences/heating/Main.qml | 4 +- nymea-app/ui/system/PluginParamsPage.qml | 4 +- 34 files changed, 592 insertions(+), 549 deletions(-) diff --git a/libnymea-app/configuration/networkmanager.cpp b/libnymea-app/configuration/networkmanager.cpp index 242eba4e..c1ad6396 100644 --- a/libnymea-app/configuration/networkmanager.cpp +++ b/libnymea-app/configuration/networkmanager.cpp @@ -179,12 +179,12 @@ int NetworkManager::disconnectInterface(const QString &interface) return m_engine->jsonRpcClient()->sendCommand("NetworkManager.DisconnectInterface", params, this, "disconnectResponse"); } -void NetworkManager::getStatusResponse(const QVariantMap ¶ms) +void NetworkManager::getStatusResponse(int /*commandId*/, const QVariantMap ¶ms) { m_loading = false; emit loadingChanged(); - if (params.value("params").toMap().value("networkManagerError").toString() != "NetworkManagerErrorNoError") { + if (params.value("networkManagerError").toString() != "NetworkManagerErrorNoError") { qWarning() << "NetworkManager error:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); m_available = false; emit availableChanged(); @@ -194,10 +194,10 @@ void NetworkManager::getStatusResponse(const QVariantMap ¶ms) m_available = true; emit availableChanged(); - QVariantMap statusMap = params.value("params").toMap().value("status").toMap(); + QVariantMap statusMap = params.value("status").toMap(); QMetaEnum stateEnum = QMetaEnum::fromType(); - NetworkManagerState state = static_cast(stateEnum.keyToValue(params.value("params").toMap().value("status").toMap().value("state").toString().toUtf8())); + NetworkManagerState state = static_cast(stateEnum.keyToValue(statusMap.value("state").toString().toUtf8())); if (m_state != state) { m_state = state; emit stateChanged(); @@ -215,11 +215,11 @@ void NetworkManager::getStatusResponse(const QVariantMap ¶ms) } } -void NetworkManager::getDevicesResponse(const QVariantMap ¶ms) +void NetworkManager::getDevicesResponse(int /*commandId*/, const QVariantMap ¶ms) { - qDebug() << "Devices reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); +// qDebug() << "Devices reply" << commandId << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - foreach (const QVariant &deviceVariant, params.value("params").toMap().value("wiredNetworkDevices").toList()) { + foreach (const QVariant &deviceVariant, params.value("wiredNetworkDevices").toList()) { QVariantMap deviceMap = deviceVariant.toMap(); WiredNetworkDevice *device = new WiredNetworkDevice(deviceMap.value("macAddress").toString(), deviceMap.value("interface").toString(), this); device->setIpv4Addresses(deviceMap.value("ipv4Addresses").toStringList()); @@ -230,7 +230,7 @@ void NetworkManager::getDevicesResponse(const QVariantMap ¶ms) device->setPluggedIn(deviceMap.value("pluggedIn").toBool()); m_wiredNetworkDevices->addNetworkDevice(device); } - foreach (const QVariant &deviceVariant, params.value("params").toMap().value("wirelessNetworkDevices").toList()) { + foreach (const QVariant &deviceVariant, params.value("wirelessNetworkDevices").toList()) { QVariantMap deviceMap = deviceVariant.toMap(); WirelessNetworkDevice *device = new WirelessNetworkDevice(deviceMap.value("macAddress").toString(), deviceMap.value("interface").toString(), this); device->setIpv4Addresses(deviceMap.value("ipv4Addresses").toStringList()); @@ -251,16 +251,15 @@ void NetworkManager::getDevicesResponse(const QVariantMap ¶ms) } } -void NetworkManager::getAccessPointsResponse(const QVariantMap ¶ms) +void NetworkManager::getAccessPointsResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Access points reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - int requestId = params.value("id").toInt(); - if (!m_apRequests.contains(requestId)) { + if (!m_apRequests.contains(commandId)) { qWarning() << "NetworkManager received a reply for a request we don't know!"; return; } - QString interface = m_apRequests.take(requestId); + QString interface = m_apRequests.take(commandId); WirelessNetworkDevice *dev = m_wirelessNetworkDevices->getWirelessNetworkDevice(interface); if (!dev) { @@ -270,7 +269,7 @@ void NetworkManager::getAccessPointsResponse(const QVariantMap ¶ms) dev->accessPoints()->clearModel(); - foreach (const QVariant &apVariant, params.value("params").toMap().value("wirelessAccessPoints").toList()) { + foreach (const QVariant &apVariant, params.value("wirelessAccessPoints").toList()) { QVariantMap apMap = apVariant.toMap(); WirelessAccessPoint* ap = new WirelessAccessPoint(this); ap->setMacAddress(apMap.value("macAddress").toString()); @@ -283,44 +282,39 @@ void NetworkManager::getAccessPointsResponse(const QVariantMap ¶ms) } -void NetworkManager::connectToWiFiResponse(const QVariantMap ¶ms) +void NetworkManager::connectToWiFiResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "connect to wifi reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - int id = params.value("id").toInt(); - QString status = params.value("params").toMap().value("networkManagerError").toString(); - emit connectToWiFiReply(id, status); + QString status = params.value("networkManagerError").toString(); + emit connectToWiFiReply(commandId, status); } -void NetworkManager::disconnectResponse(const QVariantMap ¶ms) +void NetworkManager::disconnectResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "disconnect reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - int id = params.value("id").toInt(); - QString status = params.value("params").toMap().value("networkManagerError").toString(); - emit disconnectReply(id, status); + QString status = params.value("networkManagerError").toString(); + emit disconnectReply(commandId, status); } -void NetworkManager::enableNetworkingResponse(const QVariantMap ¶ms) +void NetworkManager::enableNetworkingResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "enable networking reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - int id = params.value("id").toInt(); - QString status = params.value("params").toMap().value("networkManagerError").toString(); - emit enableNetworkingReply(id, status); + QString status = params.value("networkManagerError").toString(); + emit enableNetworkingReply(commandId, status); } -void NetworkManager::enableWirelessNetworkingResponse(const QVariantMap ¶ms) +void NetworkManager::enableWirelessNetworkingResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "enable wireless networking reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - int id = params.value("id").toInt(); - QString status = params.value("params").toMap().value("networkManagerError").toString(); - emit enableWirelessNetworkingReply(id, status); + QString status = params.value("networkManagerError").toString(); + emit enableWirelessNetworkingReply(commandId, status); } -void NetworkManager::startAccessPointResponse(const QVariantMap ¶ms) +void NetworkManager::startAccessPointResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Start access point reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - int id = params.value("id").toInt(); - QString status = params.value("params").toMap().value("networkManagerError").toString(); - emit startAccessPointReply(id, status); + QString status = params.value("networkManagerError").toString(); + emit startAccessPointReply(commandId, status); } void NetworkManager::notificationReceived(const QVariantMap ¶ms) diff --git a/libnymea-app/configuration/networkmanager.h b/libnymea-app/configuration/networkmanager.h index 72d02919..75a7b9e5 100644 --- a/libnymea-app/configuration/networkmanager.h +++ b/libnymea-app/configuration/networkmanager.h @@ -113,14 +113,14 @@ signals: private slots: void init(); - void getStatusResponse(const QVariantMap ¶ms); - void getDevicesResponse(const QVariantMap ¶ms); - void getAccessPointsResponse(const QVariantMap ¶ms); - void connectToWiFiResponse(const QVariantMap ¶ms); - void disconnectResponse(const QVariantMap ¶ms); - void enableNetworkingResponse(const QVariantMap ¶ms); - void enableWirelessNetworkingResponse(const QVariantMap ¶ms); - void startAccessPointResponse(const QVariantMap ¶ms); + void getStatusResponse(int commandId, const QVariantMap ¶ms); + void getDevicesResponse(int commandId, const QVariantMap ¶ms); + void getAccessPointsResponse(int commandId, const QVariantMap ¶ms); + void connectToWiFiResponse(int commandId, const QVariantMap ¶ms); + void disconnectResponse(int commandId, const QVariantMap ¶ms); + void enableNetworkingResponse(int commandId, const QVariantMap ¶ms); + void enableWirelessNetworkingResponse(int commandId, const QVariantMap ¶ms); + void startAccessPointResponse(int commandId, const QVariantMap ¶ms); void notificationReceived(const QVariantMap ¶ms); diff --git a/libnymea-app/configuration/nymeaconfiguration.cpp b/libnymea-app/configuration/nymeaconfiguration.cpp index 2b5b3565..ce4472cd 100644 --- a/libnymea-app/configuration/nymeaconfiguration.cpp +++ b/libnymea-app/configuration/nymeaconfiguration.cpp @@ -252,34 +252,34 @@ void NymeaConfiguration::deleteMqttPolicy(const QString &clientId) m_client->sendCommand("Configuration.DeleteMqttPolicy", params, this, "deleteMqttPolicyReply"); } -void NymeaConfiguration::getConfigurationsResponse(const QVariantMap ¶ms) +void NymeaConfiguration::getConfigurationsResponse(int commandId, const QVariantMap ¶ms) { // qDebug() << "have config reply" << params; - QVariantMap basicConfig = params.value("params").toMap().value("basicConfiguration").toMap(); + QVariantMap basicConfig = params.value("basicConfiguration").toMap(); m_debugServerEnabled = basicConfig.value("debugServerEnabled").toBool(); emit debugServerEnabledChanged(); m_serverName = basicConfig.value("serverName").toString(); emit serverNameChanged(); - QVariantMap cloudConfig = params.value("params").toMap().value("cloud").toMap(); + QVariantMap cloudConfig = params.value("cloud").toMap(); m_cloudEnabled = cloudConfig.value("enabled").toBool(); emit cloudEnabledChanged(); tcpServerConfigurations()->clear(); - foreach (const QVariant &tcpServerVariant, params.value("params").toMap().value("tcpServerConfigurations").toList()) { + foreach (const QVariant &tcpServerVariant, params.value("tcpServerConfigurations").toList()) { // qDebug() << "tcp server config:" << tcpServerVariant; QVariantMap tcpConfigMap = tcpServerVariant.toMap(); ServerConfiguration *config = new ServerConfiguration(tcpConfigMap.value("id").toString(), QHostAddress(tcpConfigMap.value("address").toString()), tcpConfigMap.value("port").toInt(), tcpConfigMap.value("authenticationEnabled").toBool(), tcpConfigMap.value("sslEnabled").toBool()); m_tcpServerConfigurations->addConfiguration(config); } webSocketServerConfigurations()->clear(); - foreach (const QVariant &websocketServerVariant, params.value("params").toMap().value("webSocketServerConfigurations").toList()) { + foreach (const QVariant &websocketServerVariant, params.value("webSocketServerConfigurations").toList()) { QVariantMap websocketConfigMap = websocketServerVariant.toMap(); ServerConfiguration *config = new ServerConfiguration(websocketConfigMap.value("id").toString(), QHostAddress(websocketConfigMap.value("address").toString()), websocketConfigMap.value("port").toInt(), websocketConfigMap.value("authenticationEnabled").toBool(), websocketConfigMap.value("sslEnabled").toBool()); m_webSocketServerConfigurations->addConfiguration(config); } webServerConfigurations()->clear(); - foreach (const QVariant &webServerVariant, params.value("params").toMap().value("webServerConfigurations").toList()) { + foreach (const QVariant &webServerVariant, params.value("webServerConfigurations").toList()) { QVariantMap webServerConfigMap = webServerVariant.toMap(); WebServerConfiguration* config = new WebServerConfiguration(webServerConfigMap.value("id").toString(), QHostAddress(webServerConfigMap.value("address").toString()), webServerConfigMap.value("port").toInt(), webServerConfigMap.value("authenticationEnabled").toBool(), webServerConfigMap.value("sslEnabled").toBool()); config->setPublicFolder(webServerConfigMap.value("publicFolder").toString()); @@ -287,9 +287,14 @@ void NymeaConfiguration::getConfigurationsResponse(const QVariantMap ¶ms) } } -void NymeaConfiguration::setServerNameResponse(const QVariantMap ¶ms) +void NymeaConfiguration::setServerNameResponse(int commandId, const QVariantMap ¶ms) { - qDebug() << "Server name set:" << params; + qDebug() << "Server name set:" << commandId << params; +} + +void NymeaConfiguration::setTimezoneResponse(int commandId, const QVariantMap ¶ms) +{ + qDebug() << "Set timezone response" << commandId << params; } void NymeaConfiguration::getCloudConfigurationResponse(const QVariantMap ¶ms) @@ -297,72 +302,71 @@ void NymeaConfiguration::getCloudConfigurationResponse(const QVariantMap ¶ms qDebug() << "Cloud config reply" << params; } -void NymeaConfiguration::setCloudEnabledResponse(const QVariantMap ¶ms) +void NymeaConfiguration::setCloudEnabledResponse(int commandId, const QVariantMap ¶ms) { - qDebug() << "Set cloud enabled:" << params; + qDebug() << "Set cloud enabled:" << commandId << params; } -void NymeaConfiguration::setDebugServerEnabledResponse(const QVariantMap ¶ms) +void NymeaConfiguration::setDebugServerEnabledResponse(int commandId, const QVariantMap ¶ms) { - qDebug() << "Debug server set:" << params; + qDebug() << "Debug server set:" << commandId << params; } -void NymeaConfiguration::setTcpConfigReply(const QVariantMap ¶ms) +void NymeaConfiguration::setTcpConfigReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Set TCP server config reply" << params; + qDebug() << "Set TCP server config reply" << commandId << params; } -void NymeaConfiguration::deleteTcpConfigReply(const QVariantMap ¶ms) +void NymeaConfiguration::deleteTcpConfigReply(int commandId, const QVariantMap ¶ms) { - if (params.value("params").toMap().value("configurationError").toString() == "ConfigurationErrorNoError") { - } + qDebug() << "Deöete TCP server config reply" << commandId << params; } -void NymeaConfiguration::setWebSocketConfigReply(const QVariantMap ¶ms) +void NymeaConfiguration::setWebSocketConfigReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "set websocket config reply" << params; + qDebug() << "set websocket config reply" << commandId << params; } -void NymeaConfiguration::setWebConfigReply(const QVariantMap ¶ms) +void NymeaConfiguration::setWebConfigReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "set web server config reply" << params; + qDebug() << "set web server config reply" << commandId << params; } -void NymeaConfiguration::deleteWebConfigReply(const QVariantMap ¶ms) +void NymeaConfiguration::deleteWebConfigReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Delete web server config reply" << params; + qDebug() << "Delete web server config reply" << commandId << params; } -void NymeaConfiguration::deleteWebSocketConfigReply(const QVariantMap ¶ms) +void NymeaConfiguration::deleteWebSocketConfigReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Delete web socket server config reply" << params; + qDebug() << "Delete web socket server config reply" << commandId << params; } -void NymeaConfiguration::getMqttServerConfigsReply(const QVariantMap ¶ms) +void NymeaConfiguration::getMqttServerConfigsReply(int commandId, const QVariantMap ¶ms) { m_mqttServerConfigurations->clear(); - foreach (const QVariant &mqttServerVariant, params.value("params").toMap().value("mqttServerConfigurations").toList()) { + foreach (const QVariant &mqttServerVariant, params.value("mqttServerConfigurations").toList()) { QVariantMap mqttConfigMap = mqttServerVariant.toMap(); ServerConfiguration *config = new ServerConfiguration(mqttConfigMap.value("id").toString(), QHostAddress(mqttConfigMap.value("address").toString()), mqttConfigMap.value("port").toInt(), mqttConfigMap.value("authenticationEnabled").toBool(), mqttConfigMap.value("sslEnabled").toBool()); m_mqttServerConfigurations->addConfiguration(config); } } -void NymeaConfiguration::setMqttConfigReply(const QVariantMap ¶ms) +void NymeaConfiguration::setMqttConfigReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Set mqtt config reply" << params; + qDebug() << "Set mqtt config reply" << commandId << params; } -void NymeaConfiguration::deleteMqttConfigReply(const QVariantMap ¶ms) +void NymeaConfiguration::deleteMqttConfigReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Delete Mqtt Broker config reply:" << params; + qDebug() << "Delete Mqtt Broker config reply:" << commandId << params; } -void NymeaConfiguration::getMqttPoliciesReply(const QVariantMap ¶ms) +void NymeaConfiguration::getMqttPoliciesReply(int commandId, const QVariantMap ¶ms) { // qDebug() << "Mqtt polices:" << params; m_mqttPolicies->clear(); - foreach (const QVariant &policyVariant, params.value("params").toMap().value("mqttPolicies").toList()) { + foreach (const QVariant &policyVariant, params.value("mqttPolicies").toList()) { QVariantMap policyMap = policyVariant.toMap(); MqttPolicy *policy = new MqttPolicy( policyMap.value("clientId").toString(), @@ -374,14 +378,14 @@ void NymeaConfiguration::getMqttPoliciesReply(const QVariantMap ¶ms) } } -void NymeaConfiguration::setMqttPolicyReply(const QVariantMap ¶ms) +void NymeaConfiguration::setMqttPolicyReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Set MQTT policy reply" << params; + qDebug() << "Set MQTT policy reply" << commandId << params; } -void NymeaConfiguration::deleteMqttPolicyReply(const QVariantMap ¶ms) +void NymeaConfiguration::deleteMqttPolicyReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Delete MQTT policy reply" << params; + qDebug() << "Delete MQTT policy reply" << commandId << params; } void NymeaConfiguration::notificationReceived(const QVariantMap ¬ification) diff --git a/libnymea-app/configuration/nymeaconfiguration.h b/libnymea-app/configuration/nymeaconfiguration.h index 339a33c6..30ebb5d8 100644 --- a/libnymea-app/configuration/nymeaconfiguration.h +++ b/libnymea-app/configuration/nymeaconfiguration.h @@ -106,23 +106,24 @@ public: void init(); private: - Q_INVOKABLE void getConfigurationsResponse(const QVariantMap ¶ms); + Q_INVOKABLE void getConfigurationsResponse(int commandId, const QVariantMap ¶ms); Q_INVOKABLE void getCloudConfigurationResponse(const QVariantMap ¶ms); - Q_INVOKABLE void setDebugServerEnabledResponse(const QVariantMap ¶ms); - Q_INVOKABLE void setServerNameResponse(const QVariantMap ¶ms); - Q_INVOKABLE void setCloudEnabledResponse(const QVariantMap ¶ms); - Q_INVOKABLE void setTcpConfigReply(const QVariantMap ¶ms); - Q_INVOKABLE void deleteTcpConfigReply(const QVariantMap ¶ms); - Q_INVOKABLE void setWebSocketConfigReply(const QVariantMap ¶ms); - Q_INVOKABLE void deleteWebSocketConfigReply(const QVariantMap ¶ms); - Q_INVOKABLE void setWebConfigReply(const QVariantMap ¶ms); - Q_INVOKABLE void deleteWebConfigReply(const QVariantMap ¶ms); - Q_INVOKABLE void getMqttServerConfigsReply(const QVariantMap ¶ms); - Q_INVOKABLE void setMqttConfigReply(const QVariantMap ¶ms); - Q_INVOKABLE void deleteMqttConfigReply(const QVariantMap ¶ms); - Q_INVOKABLE void getMqttPoliciesReply(const QVariantMap ¶ms); - Q_INVOKABLE void setMqttPolicyReply(const QVariantMap ¶ms); - Q_INVOKABLE void deleteMqttPolicyReply(const QVariantMap ¶ms); + Q_INVOKABLE void setDebugServerEnabledResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setServerNameResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setTimezoneResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setCloudEnabledResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setTcpConfigReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void deleteTcpConfigReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setWebSocketConfigReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void deleteWebSocketConfigReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setWebConfigReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void deleteWebConfigReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void getMqttServerConfigsReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setMqttConfigReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void deleteMqttConfigReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void getMqttPoliciesReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setMqttPolicyReply(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void deleteMqttPolicyReply(int commandId, const QVariantMap ¶ms); Q_INVOKABLE void notificationReceived(const QVariantMap ¬ification); diff --git a/libnymea-app/devicediscovery.cpp b/libnymea-app/devicediscovery.cpp index ccf94315..8576ee45 100644 --- a/libnymea-app/devicediscovery.cpp +++ b/libnymea-app/devicediscovery.cpp @@ -131,10 +131,10 @@ QString DeviceDiscovery::displayMessage() const return m_displayMessage; } -void DeviceDiscovery::discoverDevicesResponse(const QVariantMap ¶ms) +void DeviceDiscovery::discoverDevicesResponse(int /*commandId*/, const QVariantMap ¶ms) { // qDebug() << "response received" << params; - QVariantList descriptors = params.value("params").toMap().value("deviceDescriptors").toList(); + QVariantList descriptors = params.value("deviceDescriptors").toList(); foreach (const QVariant &descriptorVariant, descriptors) { qDebug() << "Found device. Descriptor:" << descriptorVariant; if (!contains(descriptorVariant.toMap().value("id").toUuid())) { @@ -154,7 +154,7 @@ void DeviceDiscovery::discoverDevicesResponse(const QVariantMap ¶ms) } } - m_displayMessage = params.value("params").toMap().value("displayMessage").toString(); + m_displayMessage = params.value("displayMessage").toString(); m_busy = false; emit busyChanged(); } diff --git a/libnymea-app/devicediscovery.h b/libnymea-app/devicediscovery.h index 5a98675c..95e014aa 100644 --- a/libnymea-app/devicediscovery.h +++ b/libnymea-app/devicediscovery.h @@ -93,7 +93,7 @@ public: QString displayMessage() const; private slots: - void discoverDevicesResponse(const QVariantMap ¶ms); + void discoverDevicesResponse(int commandId, const QVariantMap ¶ms); signals: void busyChanged(); diff --git a/libnymea-app/devicemanager.cpp b/libnymea-app/devicemanager.cpp index 7021b7ca..a2eaafd1 100644 --- a/libnymea-app/devicemanager.cpp +++ b/libnymea-app/devicemanager.cpp @@ -36,7 +36,10 @@ #include "thinggroup.h" #include "types/interface.h" #include "types/ioconnections.h" + #include +#include +#include DeviceManager::DeviceManager(JsonRpcClient* jsonclient, QObject *parent) : JsonHandler(parent), @@ -61,6 +64,8 @@ void DeviceManager::clear() void DeviceManager::init() { + m_connectionBenchmark = QDateTime::currentDateTime(); + // For old nymea setups we need to register to Events.Notifications. // Deprecated since JSONRPC 4.0/nymea 0.17 if (!m_jsonClient->ensureServerVersion("4.0")) { @@ -151,14 +156,14 @@ bool DeviceManager::fetchingData() const return m_fetchingData; } -void DeviceManager::addDevice(const QUuid &deviceClassId, const QString &name, const QVariantList &deviceParams) +int DeviceManager::addDevice(const QUuid &deviceClassId, const QString &name, const QVariantList &deviceParams) { qDebug() << "add device " << deviceClassId.toString(); QVariantMap params; params.insert("deviceClassId", deviceClassId.toString()); params.insert("name", name); params.insert("deviceParams", deviceParams); - m_jsonClient->sendCommand("Devices.AddConfiguredDevice", params, this, "addDeviceResponse"); + return m_jsonClient->sendCommand("Devices.AddConfiguredDevice", params, this, "addDeviceResponse"); } void DeviceManager::notificationReceived(const QVariantMap &data) @@ -264,11 +269,11 @@ void DeviceManager::notificationReceived(const QVariantMap &data) } } -void DeviceManager::getVendorsResponse(const QVariantMap ¶ms) +void DeviceManager::getVendorsResponse(int /*commandId*/, const QVariantMap ¶ms) { // qDebug() << "Got GetSupportedVendors response" << params; - if (params.value("params").toMap().keys().contains("vendors")) { - QVariantList vendorList = params.value("params").toMap().value("vendors").toList(); + if (params.keys().contains("vendors")) { + QVariantList vendorList = params.value("vendors").toList(); foreach (QVariant vendorVariant, vendorList) { Vendor *vendor = JsonTypes::unpackVendor(vendorVariant.toMap()); m_vendors->addVendor(vendor); @@ -277,11 +282,11 @@ void DeviceManager::getVendorsResponse(const QVariantMap ¶ms) } } -void DeviceManager::getSupportedDevicesResponse(const QVariantMap ¶ms) +void DeviceManager::getSupportedDevicesResponse(int /*commandId*/, const QVariantMap ¶ms) { // qDebug() << "DeviceClasses received:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - if (params.value("params").toMap().keys().contains("deviceClasses")) { - QVariantList deviceClassList = params.value("params").toMap().value("deviceClasses").toList(); + if (params.keys().contains("deviceClasses")) { + QVariantList deviceClassList = params.value("deviceClasses").toList(); foreach (QVariant deviceClassVariant, deviceClassList) { DeviceClass *deviceClass = JsonTypes::unpackDeviceClass(deviceClassVariant.toMap(), deviceClasses()); m_thingClasses->addDeviceClass(deviceClass); @@ -290,11 +295,11 @@ void DeviceManager::getSupportedDevicesResponse(const QVariantMap ¶ms) m_jsonClient->sendCommand("Devices.GetConfiguredDevices", this, "getConfiguredDevicesResponse"); } -void DeviceManager::getPluginsResponse(const QVariantMap ¶ms) +void DeviceManager::getPluginsResponse(int /*commandId*/, const QVariantMap ¶ms) { // qDebug() << "received plugins"; - if (params.value("params").toMap().keys().contains("plugins")) { - QVariantList pluginList = params.value("params").toMap().value("plugins").toList(); + if (params.keys().contains("plugins")) { + QVariantList pluginList = params.value("plugins").toList(); foreach (QVariant pluginVariant, pluginList) { Plugin *plugin = JsonTypes::unpackPlugin(pluginVariant.toMap(), plugins()); m_plugins->addPlugin(plugin); @@ -310,7 +315,7 @@ void DeviceManager::getPluginsResponse(const QVariantMap ¶ms) } } -void DeviceManager::getPluginConfigResponse(const QVariantMap ¶ms) +void DeviceManager::getPluginConfigResponse(int /*commandId*/, const QVariantMap ¶ms) { // qDebug() << "plugin config response" << params; Plugin *p = m_plugins->get(m_currentGetConfigIndex); @@ -318,7 +323,7 @@ void DeviceManager::getPluginConfigResponse(const QVariantMap ¶ms) qDebug() << "Received a plugin config for a plugin we don't know"; return; } - QVariantList pluginParams = params.value("params").toMap().value("configuration").toList(); + QVariantList pluginParams = params.value("configuration").toList(); foreach (const QVariant ¶mVariant, pluginParams) { Param* param = new Param(); JsonTypes::unpackParam(paramVariant.toMap(), param); @@ -333,10 +338,10 @@ void DeviceManager::getPluginConfigResponse(const QVariantMap ¶ms) } } -void DeviceManager::getConfiguredDevicesResponse(const QVariantMap ¶ms) +void DeviceManager::getConfiguredDevicesResponse(int /*commandId*/, const QVariantMap ¶ms) { - if (params.value("params").toMap().keys().contains("devices")) { - QVariantList deviceList = params.value("params").toMap().value("devices").toList(); + if (params.keys().contains("devices")) { + QVariantList deviceList = params.value("devices").toList(); foreach (QVariant deviceVariant, deviceList) { Device *device = JsonTypes::unpackDevice(this, deviceVariant.toMap(), m_thingClasses); if (!device) { @@ -369,6 +374,7 @@ void DeviceManager::getConfiguredDevicesResponse(const QVariantMap ¶ms) // qDebug() << "*** Added device:" << endl << device; } } + qDebug() << "Initializing thing manager took" << m_connectionBenchmark.msecsTo(QDateTime::currentDateTime()) << "ms"; m_fetchingData = false; emit fetchingDataChanged(); @@ -377,12 +383,12 @@ void DeviceManager::getConfiguredDevicesResponse(const QVariantMap ¶ms) m_jsonClient->sendCommand("Devices.GetPlugins", this, "getPluginsResponse"); } -void DeviceManager::addDeviceResponse(const QVariantMap ¶ms) +void DeviceManager::addDeviceResponse(int commandId, const QVariantMap ¶ms) { - if (params.value("params").toMap().value("deviceError").toString() != "DeviceErrorNoError") { - qWarning() << "Failed to add the device:" << params.value("params").toMap().value("deviceError").toString(); - } else if (params.value("params").toMap().keys().contains("device")) { - QVariantMap deviceVariant = params.value("params").toMap().value("device").toMap(); + if (params.value("deviceError").toString() != "DeviceErrorNoError") { + qWarning() << "Failed to add the device:" << params.value("deviceError").toString(); + } else if (params.keys().contains("device")) { + QVariantMap deviceVariant = params.value("device").toMap(); Device *device = JsonTypes::unpackDevice(this, deviceVariant, m_thingClasses); if (!device) { qWarning() << "Couldn't parse json in addDeviceResponse"; @@ -392,57 +398,57 @@ void DeviceManager::addDeviceResponse(const QVariantMap ¶ms) qDebug() << "Device added" << device->id().toString(); m_devices->addDevice(device); } - emit addDeviceReply(params.value("params").toMap()); + emit addDeviceReply(commandId, params); } -void DeviceManager::removeDeviceResponse(const QVariantMap ¶ms) +void DeviceManager::removeDeviceResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Device removed response" << params; - emit removeDeviceReply(params.value("params").toMap()); + emit removeDeviceReply(commandId, params); } -void DeviceManager::pairDeviceResponse(const QVariantMap ¶ms) +void DeviceManager::pairDeviceResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Pair device response:" << params; - emit pairDeviceReply(params.value("params").toMap()); + emit pairDeviceReply(commandId, params); } -void DeviceManager::confirmPairingResponse(const QVariantMap ¶ms) +void DeviceManager::confirmPairingResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "ConfirmPairingResponse" << params; - emit confirmPairingReply(params.value("params").toMap()); + emit confirmPairingReply(commandId, params); } -void DeviceManager::setPluginConfigResponse(const QVariantMap ¶ms) +void DeviceManager::setPluginConfigResponse(int commandId, const QVariantMap ¶ms) { - qDebug() << "set plugin config respionse" << params; - emit savePluginConfigReply(params); + qDebug() << "set plugin config response" << params; + emit savePluginConfigReply(commandId, params); } -void DeviceManager::editDeviceResponse(const QVariantMap ¶ms) +void DeviceManager::editDeviceResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Edit device response" << params; - emit editDeviceReply(params); + emit editDeviceReply(commandId, params); } -void DeviceManager::executeActionResponse(const QVariantMap ¶ms) +void DeviceManager::executeActionResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Execute Action response" << params; - emit executeActionReply(params); + emit executeActionReply(commandId, params); } -void DeviceManager::reconfigureDeviceResponse(const QVariantMap ¶ms) +void DeviceManager::reconfigureDeviceResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Reconfigure device response" << params; - emit reconfigureDeviceReply(params.value("params").toMap()); + emit reconfigureDeviceReply(commandId, params); } -void DeviceManager::savePluginConfig(const QUuid &pluginId) +int DeviceManager::savePluginConfig(const QUuid &pluginId) { Plugin *p = m_plugins->getPlugin(pluginId); if (!p) { qWarning()<< "Error: can't find plugin with id" << pluginId; - return; + return -1; } QVariantMap params; params.insert("pluginId", pluginId); @@ -451,7 +457,7 @@ void DeviceManager::savePluginConfig(const QUuid &pluginId) pluginParams.append(JsonTypes::packParam(p->params()->get(i))); } params.insert("configuration", pluginParams); - m_jsonClient->sendCommand("Devices.SetPluginConfiguration", params, this, "setPluginConfigResponse"); + return m_jsonClient->sendCommand("Devices.SetPluginConfiguration", params, this, "setPluginConfigResponse"); } ThingGroup *DeviceManager::createGroup(Interface *interface, DevicesProxy *things) @@ -461,7 +467,7 @@ ThingGroup *DeviceManager::createGroup(Interface *interface, DevicesProxy *thing return group; } -void DeviceManager::addDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QString &name, const QVariantList &deviceParams) +int DeviceManager::addDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QString &name, const QVariantList &deviceParams) { qDebug() << "JsonRpc: add discovered device " << deviceClassId.toString(); QVariantMap params; @@ -469,10 +475,10 @@ void DeviceManager::addDiscoveredDevice(const QUuid &deviceClassId, const QUuid params.insert("name", name); params.insert("deviceDescriptorId", deviceDescriptorId.toString()); params.insert("deviceParams", deviceParams); - m_jsonClient->sendCommand("Devices.AddConfiguredDevice", params, this, "addDeviceResponse"); + return m_jsonClient->sendCommand("Devices.AddConfiguredDevice", params, this, "addDeviceResponse"); } -void DeviceManager::pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QVariantList &deviceParams, const QString &name) +int DeviceManager::pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QVariantList &deviceParams, const QString &name) { qDebug() << "JsonRpc: pair discovered device " << deviceDescriptorId.toString(); QVariantMap params; @@ -484,20 +490,20 @@ void DeviceManager::pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid params.insert("deviceClassId", deviceClassId); } - m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse"); + return m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse"); } -void DeviceManager::pairDevice(const QUuid &deviceClassId, const QVariantList &deviceParams, const QString &name) +int DeviceManager::pairDevice(const QUuid &deviceClassId, const QVariantList &deviceParams, const QString &name) { qDebug() << "JsonRpc: pair device " << deviceClassId.toString(); QVariantMap params; params.insert("deviceClassId", deviceClassId.toString()); params.insert("deviceParams", deviceParams); params.insert("name", name); - m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse"); + return m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse"); } -void DeviceManager::rePairDevice(const QUuid &deviceId, const QVariantList &deviceParams, const QString &name) +int DeviceManager::rePairDevice(const QUuid &deviceId, const QVariantList &deviceParams, const QString &name) { qDebug() << "JsonRpc: pair device (reconfigure)" << deviceId; QVariantMap params; @@ -506,10 +512,10 @@ void DeviceManager::rePairDevice(const QUuid &deviceId, const QVariantList &devi if (!name.isEmpty()) { params.insert("name", name); } - m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse"); + return m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse"); } -void DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QString &secret, const QString &username) +int DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QString &secret, const QString &username) { qDebug() << "JsonRpc: confirm pairing" << pairingTransactionId.toString(); QVariantMap params; @@ -518,10 +524,10 @@ void DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QStr if (!username.isEmpty()) { params.insert("username", username); } - m_jsonClient->sendCommand("Devices.ConfirmPairing", params, this, "confirmPairingResponse"); + return m_jsonClient->sendCommand("Devices.ConfirmPairing", params, this, "confirmPairingResponse"); } -void DeviceManager::removeDevice(const QUuid &deviceId, RemovePolicy removePolicy) +int DeviceManager::removeDevice(const QUuid &deviceId, RemovePolicy removePolicy) { qDebug() << "JsonRpc: delete device" << deviceId.toString(); QVariantMap params; @@ -530,34 +536,34 @@ void DeviceManager::removeDevice(const QUuid &deviceId, RemovePolicy removePolic QMetaEnum policyEnum = QMetaEnum::fromType(); params.insert("removePolicy", policyEnum.valueToKey(removePolicy)); } - m_jsonClient->sendCommand("Devices.RemoveConfiguredDevice", params, this, "removeDeviceResponse"); + return m_jsonClient->sendCommand("Devices.RemoveConfiguredDevice", params, this, "removeDeviceResponse"); } -void DeviceManager::editDevice(const QUuid &deviceId, const QString &name) +int DeviceManager::editDevice(const QUuid &deviceId, const QString &name) { QVariantMap params; params.insert("deviceId", deviceId.toString()); params.insert("name", name); - m_jsonClient->sendCommand("Devices.EditDevice", params, this, "editDeviceResponse"); + return m_jsonClient->sendCommand("Devices.EditDevice", params, this, "editDeviceResponse"); } -void DeviceManager::setDeviceSettings(const QUuid &deviceId, const QVariantList &settings) +int DeviceManager::setDeviceSettings(const QUuid &deviceId, const QVariantList &settings) { QVariantMap params; params.insert("deviceId", deviceId); params.insert("settings", settings); - m_jsonClient->sendCommand("Devices.SetDeviceSettings", params); + return m_jsonClient->sendCommand("Devices.SetDeviceSettings", params); } -void DeviceManager::reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams) +int DeviceManager::reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams) { QVariantMap params; params.insert("deviceId", deviceId.toString()); params.insert("deviceParams", deviceParams); - m_jsonClient->sendCommand("Devices.ReconfigureDevice", params, this, "reconfigureDeviceResponse"); + return m_jsonClient->sendCommand("Devices.ReconfigureDevice", params, this, "reconfigureDeviceResponse"); } -void DeviceManager::reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList ¶mOverride) +int DeviceManager::reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList ¶mOverride) { QVariantMap params; params.insert("deviceId", deviceId.toString()); @@ -566,7 +572,7 @@ void DeviceManager::reconfigureDiscoveredDevice(const QUuid &deviceId, const QUu params.insert("deviceParams", paramOverride); } qDebug() << "Calling ReconfigureDevice" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); - m_jsonClient->sendCommand("Devices.ReconfigureDevice", params, this, "reconfigureDeviceResponse"); + return m_jsonClient->sendCommand("Devices.ReconfigureDevice", params, this, "reconfigureDeviceResponse"); } int DeviceManager::executeAction(const QUuid &deviceId, const QUuid &actionTypeId, const QVariantList ¶ms) @@ -627,16 +633,15 @@ BrowserItem *DeviceManager::browserItem(const QUuid &deviceId, const QString &it return item; } -void DeviceManager::browseDeviceResponse(const QVariantMap ¶ms) +void DeviceManager::browseDeviceResponse(int commandId, const QVariantMap ¶ms) { // qDebug() << "Browsing response:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - int id = params.value("id").toInt(); - if (!m_browsingRequests.contains(id)) { + if (!m_browsingRequests.contains(commandId)) { qWarning() << "Received a browsing reply for an id we don't know."; return; } - QPointer itemModel = m_browsingRequests.take(id); + QPointer itemModel = m_browsingRequests.take(commandId); if (!itemModel) { qDebug() << "BrowserItems model seems to have disappeared. Discarding browsing result."; return; @@ -644,7 +649,7 @@ void DeviceManager::browseDeviceResponse(const QVariantMap ¶ms) QList itemsToRemove = itemModel->list(); - foreach (const QVariant &itemVariant, params.value("params").toMap().value("items").toList()) { + foreach (const QVariant &itemVariant, params.value("items").toList()) { QVariantMap itemMap = itemVariant.toMap(); QString itemId = itemMap.value("id").toString(); BrowserItem *item = itemModel->getBrowserItem(itemId); @@ -676,22 +681,21 @@ void DeviceManager::browseDeviceResponse(const QVariantMap ¶ms) itemModel->setBusy(false); } -void DeviceManager::browserItemResponse(const QVariantMap ¶ms) +void DeviceManager::browserItemResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Browser item details response:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - int id = params.value("id").toInt(); - if (!m_browserDetailsRequests.contains(id)) { + if (!m_browserDetailsRequests.contains(commandId)) { qWarning() << "Received a browser item details reply for an id we don't know."; return; } - QPointer item = m_browserDetailsRequests.take(id); + QPointer item = m_browserDetailsRequests.take(commandId); if (!item) { qDebug() << "BrowserItem seems to have disappeared. Discarding browser item details result."; return; } - QVariantMap itemMap = params.value("params").toMap().value("item").toMap(); + QVariantMap itemMap = params.value("item").toMap(); item->setDisplayName(itemMap.value("displayName").toString()); item->setDescription(itemMap.value("description").toString()); item->setIcon(itemMap.value("icon").toString()); @@ -712,10 +716,10 @@ int DeviceManager::executeBrowserItem(const QUuid &deviceId, const QString &item return m_jsonClient->sendCommand("Actions.ExecuteBrowserItem", params, this, "executeBrowserItemResponse"); } -void DeviceManager::executeBrowserItemResponse(const QVariantMap ¶ms) +void DeviceManager::executeBrowserItemResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Execute Browser Item finished" << params; - emit executeBrowserItemReply(params); + emit executeBrowserItemReply(commandId, params); } int DeviceManager::executeBrowserItemAction(const QUuid &deviceId, const QString &itemId, const QUuid &actionTypeId, const QVariantList ¶ms) @@ -747,17 +751,17 @@ int DeviceManager::disconnectIO(const QUuid &ioConnectionId) return m_jsonClient->sendCommand("Integrations.DisconnectIO", data, this, "disconnectIOResponse"); } -void DeviceManager::executeBrowserItemActionResponse(const QVariantMap ¶ms) +void DeviceManager::executeBrowserItemActionResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Execute Browser Item Action finished" << params; - emit executeBrowserItemActionReply(params); + emit executeBrowserItemActionReply(commandId, params); } -void DeviceManager::getIOConnectionsResponse(const QVariantMap ¶ms) +void DeviceManager::getIOConnectionsResponse(int /*commandId*/, const QVariantMap ¶ms) { // qDebug() << "Get IO connections response" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); - foreach (const QVariant &connectionVariant, params.value("params").toMap().value("ioConnections").toList()) { + foreach (const QVariant &connectionVariant, params.value("ioConnections").toList()) { QVariantMap connectionMap = connectionVariant.toMap(); QUuid id = connectionMap.value("id").toUuid(); QUuid inputThingId = connectionMap.value("inputThingId").toUuid(); @@ -770,13 +774,13 @@ void DeviceManager::getIOConnectionsResponse(const QVariantMap ¶ms) } } -void DeviceManager::connectIOResponse(const QVariantMap ¶ms) +void DeviceManager::connectIOResponse(int commandId, const QVariantMap ¶ms) { - qDebug() << "ConnectIO response" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); + qDebug() << "ConnectIO response" << commandId << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); } -void DeviceManager::disconnectIOResponse(const QVariantMap ¶ms) +void DeviceManager::disconnectIOResponse(int commandId, const QVariantMap ¶ms) { - qDebug() << "DisconnectIO response" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); + qDebug() << "DisconnectIO response" << commandId << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); } diff --git a/libnymea-app/devicemanager.h b/libnymea-app/devicemanager.h index 23726671..b09d3ddc 100644 --- a/libnymea-app/devicemanager.h +++ b/libnymea-app/devicemanager.h @@ -86,19 +86,19 @@ public: bool fetchingData() const; - Q_INVOKABLE void addDevice(const QUuid &deviceClassId, const QString &name, const QVariantList &deviceParams); + Q_INVOKABLE int addDevice(const QUuid &deviceClassId, const QString &name, const QVariantList &deviceParams); // param deviceClassId is deprecated and should be removed when minimum JSONRPC version is 3.1 - Q_INVOKABLE void addDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QString &name, const QVariantList &deviceParams); - Q_INVOKABLE void pairDevice(const QUuid &deviceClassId, const QVariantList &deviceParams, const QString &name); + Q_INVOKABLE int addDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QString &name, const QVariantList &deviceParams); + Q_INVOKABLE int pairDevice(const QUuid &deviceClassId, const QVariantList &deviceParams, const QString &name); // param deviceClassId is deprecated and should be removed when minimum JSONRPC version is 3.1 - Q_INVOKABLE void pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QVariantList &deviceParams, const QString &name); - Q_INVOKABLE void rePairDevice(const QUuid &deviceId, const QVariantList &deviceParams, const QString &name = QString()); - Q_INVOKABLE void confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString(), const QString &username = QString()); - Q_INVOKABLE void removeDevice(const QUuid &deviceId, RemovePolicy policy = RemovePolicyNone); - Q_INVOKABLE void editDevice(const QUuid &deviceId, const QString &name); - Q_INVOKABLE void setDeviceSettings(const QUuid &deviceId, const QVariantList &settings); - Q_INVOKABLE void reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams); - Q_INVOKABLE void reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList ¶mOverride); + Q_INVOKABLE int pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QVariantList &deviceParams, const QString &name); + Q_INVOKABLE int rePairDevice(const QUuid &deviceId, const QVariantList &deviceParams, const QString &name = QString()); + Q_INVOKABLE int confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString(), const QString &username = QString()); + Q_INVOKABLE int removeDevice(const QUuid &deviceId, RemovePolicy policy = RemovePolicyNone); + Q_INVOKABLE int editDevice(const QUuid &deviceId, const QString &name); + Q_INVOKABLE int setDeviceSettings(const QUuid &deviceId, const QVariantList &settings); + Q_INVOKABLE int reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams); + Q_INVOKABLE int reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList ¶mOverride); Q_INVOKABLE int executeAction(const QUuid &deviceId, const QUuid &actionTypeId, const QVariantList ¶ms = QVariantList()); Q_INVOKABLE BrowserItems* browseDevice(const QUuid &deviceId, const QString &itemId = QString()); Q_INVOKABLE void refreshBrowserItems(BrowserItems *browserItems); @@ -111,43 +111,43 @@ public: private: Q_INVOKABLE void notificationReceived(const QVariantMap &data); - Q_INVOKABLE void getVendorsResponse(const QVariantMap ¶ms); - Q_INVOKABLE void getSupportedDevicesResponse(const QVariantMap ¶ms); - Q_INVOKABLE void getPluginsResponse(const QVariantMap ¶ms); - Q_INVOKABLE void getPluginConfigResponse(const QVariantMap ¶ms); - Q_INVOKABLE void getConfiguredDevicesResponse(const QVariantMap ¶ms); - Q_INVOKABLE void addDeviceResponse(const QVariantMap ¶ms); - Q_INVOKABLE void removeDeviceResponse(const QVariantMap ¶ms); - Q_INVOKABLE void pairDeviceResponse(const QVariantMap ¶ms); - Q_INVOKABLE void confirmPairingResponse(const QVariantMap ¶ms); - Q_INVOKABLE void setPluginConfigResponse(const QVariantMap ¶ms); - Q_INVOKABLE void editDeviceResponse(const QVariantMap ¶ms); - Q_INVOKABLE void executeActionResponse(const QVariantMap ¶ms); - Q_INVOKABLE void reconfigureDeviceResponse(const QVariantMap ¶ms); - Q_INVOKABLE void browseDeviceResponse(const QVariantMap ¶ms); - Q_INVOKABLE void browserItemResponse(const QVariantMap ¶ms); - Q_INVOKABLE void executeBrowserItemResponse(const QVariantMap ¶ms); - Q_INVOKABLE void executeBrowserItemActionResponse(const QVariantMap ¶ms); - Q_INVOKABLE void getIOConnectionsResponse(const QVariantMap ¶ms); - Q_INVOKABLE void connectIOResponse(const QVariantMap ¶ms); - Q_INVOKABLE void disconnectIOResponse(const QVariantMap ¶ms); + Q_INVOKABLE void getVendorsResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void getSupportedDevicesResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void getPluginsResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void getPluginConfigResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void getConfiguredDevicesResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void addDeviceResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void removeDeviceResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void pairDeviceResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void confirmPairingResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void setPluginConfigResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void editDeviceResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void executeActionResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void reconfigureDeviceResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void browseDeviceResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void browserItemResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void executeBrowserItemResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void executeBrowserItemActionResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void getIOConnectionsResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void connectIOResponse(int commandId, const QVariantMap ¶ms); + Q_INVOKABLE void disconnectIOResponse(int commandId, const QVariantMap ¶ms); public slots: - void savePluginConfig(const QUuid &pluginId); + int savePluginConfig(const QUuid &pluginId); ThingGroup* createGroup(Interface *interface, DevicesProxy *things); signals: - void pairDeviceReply(const QVariantMap ¶ms); - void confirmPairingReply(const QVariantMap ¶ms); - void addDeviceReply(const QVariantMap ¶ms); - void removeDeviceReply(const QVariantMap ¶ms); - void savePluginConfigReply(const QVariantMap ¶ms); - void editDeviceReply(const QVariantMap ¶ms); - void reconfigureDeviceReply(const QVariantMap ¶ms); - void executeActionReply(const QVariantMap ¶ms); - void executeBrowserItemReply(const QVariantMap ¶ms); - void executeBrowserItemActionReply(const QVariantMap ¶ms); + void pairDeviceReply(int commandId, const QVariantMap ¶ms); + void confirmPairingReply(int commandId, const QVariantMap ¶ms); + void addDeviceReply(int commandId, const QVariantMap ¶ms); + void removeDeviceReply(int commandId, const QVariantMap ¶ms); + void savePluginConfigReply(int commandId, const QVariantMap ¶ms); + void editDeviceReply(int commandId, const QVariantMap ¶ms); + void reconfigureDeviceReply(int commandId, const QVariantMap ¶ms); + void executeActionReply(int commandId, const QVariantMap ¶ms); + void executeBrowserItemReply(int commandId, const QVariantMap ¶ms); + void executeBrowserItemActionReply(int commandId, const QVariantMap ¶ms); void fetchingDataChanged(); void notificationReceived(const QString &deviceId, const QString &eventTypeId, const QVariantList ¶ms); @@ -169,6 +169,7 @@ private: QHash > m_browsingRequests; QHash > m_browserDetailsRequests; + QDateTime m_connectionBenchmark; // Deprecated stuff for nymea < 0.17 (JSONRPC < 4.0) EventHandler *m_eventHandler = nullptr; diff --git a/libnymea-app/jsonrpc/jsonrpcclient.cpp b/libnymea-app/jsonrpc/jsonrpcclient.cpp index 394f57ae..71709fad 100644 --- a/libnymea-app/jsonrpc/jsonrpcclient.cpp +++ b/libnymea-app/jsonrpc/jsonrpcclient.cpp @@ -94,7 +94,31 @@ void JsonRpcClient::unregisterNotificationHandler(JsonHandler *handler) int JsonRpcClient::sendCommand(const QString &method, const QVariantMap ¶ms, QObject *caller, const QString &callbackMethod) { + JsonRpcReply *reply = createReply(method, params, caller, callbackMethod); + + if (m_cacheHashes.contains(method)) { + QString hash = m_cacheHashes.value(method); + QString callSignature = method + '-' + QJsonDocument::fromVariant(params).toJson() + '-' + QLocale().name(); + QString callSignatureHash = QCryptographicHash::hash(callSignature.toUtf8(), QCryptographicHash::Md5).toHex(); + QFile f(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + '/' + method + '-' + callSignatureHash + '-' + hash + ".cache"); + if (f.exists() && f.open(QFile::ReadOnly)) { + QJsonParseError error; + QVariantMap cachedParams = QJsonDocument::fromJson(f.readAll(), &error).toVariant().toMap(); + f.close(); + if (error.error == QJsonParseError::NoError) { + qDebug() << "Loaded results for" << reply->nameSpace() + '.' + reply->method() << "from cache"; + // We want to make sure this is an async operation even if we have stuff in cache, so only call callbacks using Qt::QueuedConnection + if (!reply->caller().isNull() && !reply->callback().isEmpty()) { + QMetaObject::invokeMethod(reply->caller(), reply->callback().toLatin1().data(), Qt::QueuedConnection, Q_ARG(int, reply->commandId()), Q_ARG(QVariantMap, cachedParams)); + } + QMetaObject::invokeMethod(this, "responseReceived", Qt::QueuedConnection, Q_ARG(int, reply->commandId()), Q_ARG(QVariantMap, cachedParams)); + QMetaObject::invokeMethod(reply, "deleteLater", Qt::QueuedConnection); + return reply->commandId(); + } + } + } + m_replies.insert(reply->commandId(), reply); sendRequest(reply->requestMap()); return reply->commandId(); @@ -102,6 +126,7 @@ int JsonRpcClient::sendCommand(const QString &method, const QVariantMap ¶ms, int JsonRpcClient::sendCommand(const QString &method, QObject *caller, const QString &callbackMethod) { + return sendCommand(method, QVariantMap(), caller, callbackMethod); } @@ -138,7 +163,7 @@ void JsonRpcClient::getCloudConnectionStatus() sendRequest(reply->requestMap()); } -void JsonRpcClient::setNotificationsEnabledResponse(const QVariantMap ¶ms) +void JsonRpcClient::setNotificationsEnabledResponse(int /*commandId*/, const QVariantMap ¶ms) { qDebug() << "Notifications enabled:" << params; @@ -187,28 +212,28 @@ void JsonRpcClient::notificationReceived(const QVariantMap &data) qDebug() << "JsonRpcClient: Unhandled notification received" << data; } -void JsonRpcClient::isCloudConnectedReply(const QVariantMap &data) +void JsonRpcClient::isCloudConnectedReply(int /*commandId*/, const QVariantMap &data) { -// qDebug() << "Cloud is connected" << data; + // qDebug() << "Cloud is connected" << data; QMetaEnum connectionStateEnum = QMetaEnum::fromType(); - m_cloudConnectionState = static_cast(connectionStateEnum.keyToValue(data.value("params").toMap().value("connectionState").toByteArray().data())); + m_cloudConnectionState = static_cast(connectionStateEnum.keyToValue(data.value("connectionState").toByteArray().data())); emit cloudConnectionStateChanged(); } -void JsonRpcClient::setupRemoteAccessReply(const QVariantMap &data) +void JsonRpcClient::setupRemoteAccessReply(int commandId, const QVariantMap &data) { - qDebug() << "Setup Remote Access reply" << data; + qDebug() << "Setup Remote Access reply" << commandId << data; } -void JsonRpcClient::deployCertificateReply(const QVariantMap &data) +void JsonRpcClient::deployCertificateReply(int commandId, const QVariantMap &data) { - qDebug() << "deploy certificate reply:" << data; + qDebug() << "deploy certificate reply:" << commandId << data; } -void JsonRpcClient::getVersionsReply(const QVariantMap &data) +void JsonRpcClient::getVersionsReply(int /*commandId*/, const QVariantMap &data) { - m_serverQtVersion = data.value("params").toMap().value("qtVersion").toString(); - m_serverQtBuildVersion = data.value("params").toMap().value("qtBuildVersion").toString(); + m_serverQtVersion = data.value("qtVersion").toString(); + m_serverQtBuildVersion = data.value("qtBuildVersion").toString(); if (!m_serverQtVersion.isEmpty()) { emit serverQtVersionChanged(); } @@ -287,6 +312,11 @@ void JsonRpcClient::deployCertificate(const QByteArray &rootCA, const QByteArray sendCommand("JSONRPC.SetupCloudConnection", params, this, "deployCertificateReply"); } +QHash JsonRpcClient::cacheHashes() const +{ + return m_cacheHashes; +} + QString JsonRpcClient::serverVersion() const { return m_serverVersion; @@ -353,13 +383,13 @@ int JsonRpcClient::requestPushButtonAuth(const QString &deviceName) return reply->commandId(); } -void JsonRpcClient::setupRemoteAccess(const QString &idToken, const QString &userId) +int JsonRpcClient::setupRemoteAccess(const QString &idToken, const QString &userId) { qDebug() << "Calling SetupRemoteAccess"; QVariantMap params; params.insert("idToken", idToken); params.insert("userId", userId); - sendCommand("JSONRPC.SetupRemoteAccess", params, this, "setupRemoteAccessReply"); + return sendCommand("JSONRPC.SetupRemoteAccess", params, this, "setupRemoteAccessReply"); } bool JsonRpcClient::ensureServerVersion(const QString &jsonRpcVersion) @@ -367,11 +397,11 @@ bool JsonRpcClient::ensureServerVersion(const QString &jsonRpcVersion) return QVersionNumber(m_jsonRpcVersion) >= QVersionNumber::fromString(jsonRpcVersion); } -void JsonRpcClient::processAuthenticate(const QVariantMap &data) +void JsonRpcClient::processAuthenticate(int /*commandId*/, const QVariantMap &data) { - if (data.value("status").toString() == "success" && data.value("params").toMap().value("success").toBool()) { + if (data.value("success").toBool()) { qDebug() << "authentication successful"; - m_token = data.value("params").toMap().value("token").toByteArray(); + m_token = data.value("token").toByteArray(); QSettings settings; settings.beginGroup("jsonTokens"); settings.setValue(m_serverUuid, m_token); @@ -388,24 +418,24 @@ void JsonRpcClient::processAuthenticate(const QVariantMap &data) } } -void JsonRpcClient::processCreateUser(const QVariantMap &data) +void JsonRpcClient::processCreateUser(int /*commandId*/, const QVariantMap &data) { qDebug() << "create user response:" << data; - if (data.value("status").toString() == "success" && data.value("params").toMap().value("error").toString() == "UserErrorNoError") { + if (data.value("error").toString() == "UserErrorNoError") { emit createUserSucceeded(); m_initialSetupRequired = false; emit initialSetupRequiredChanged(); } else { qDebug() << "Emitting create user failed"; - emit createUserFailed(data.value("params").toMap().value("error").toString()); + emit createUserFailed(data.value("error").toString()); } } -void JsonRpcClient::processRequestPushButtonAuth(const QVariantMap &data) +void JsonRpcClient::processRequestPushButtonAuth(int /*commandId*/, const QVariantMap &data) { qDebug() << "requestPushButtonAuth response" << data; - if (data.value("status").toString() == "success" && data.value("params").toMap().value("success").toBool()) { - m_pendingPushButtonTransaction = data.value("params").toMap().value("transactionId").toInt(); + if (data.value("success").toBool()) { + m_pendingPushButtonTransaction = data.value("transactionId").toInt(); } else { emit pushButtonAuthFailed(); } @@ -449,7 +479,7 @@ void JsonRpcClient::sendRequest(const QVariantMap &request) { QVariantMap newRequest = request; newRequest.insert("token", m_token); -// qDebug() << "Sending request" << qUtf8Printable(QJsonDocument::fromVariant(newRequest).toJson()); + // qDebug() << "Sending request" << qUtf8Printable(QJsonDocument::fromVariant(newRequest).toJson()); m_connection->sendData(QJsonDocument::fromVariant(newRequest).toJson(QJsonDocument::Compact) + "\n"); } @@ -506,7 +536,7 @@ void JsonRpcClient::onInterfaceConnectedChanged(bool connected) void JsonRpcClient::dataReceived(const QByteArray &data) { -// qDebug() << "JsonRpcClient: received data:" << qUtf8Printable(data); + // qDebug() << "JsonRpcClient: received data:" << qUtf8Printable(data); m_receiveBuffer.append(data); int splitIndex = m_receiveBuffer.indexOf("}\n{") + 1; @@ -516,10 +546,10 @@ void JsonRpcClient::dataReceived(const QByteArray &data) QJsonParseError error; QJsonDocument jsonDoc = QJsonDocument::fromJson(m_receiveBuffer.left(splitIndex), &error); if (error.error != QJsonParseError::NoError) { -// qWarning() << "Could not parse json data from nymea" << m_receiveBuffer.left(splitIndex) << error.errorString(); + // qWarning() << "Could not parse json data from nymea" << m_receiveBuffer.left(splitIndex) << error.errorString(); return; } -// qDebug() << "received response" << qUtf8Printable(jsonDoc.toJson(QJsonDocument::Indented)); + // qDebug() << "received response" << qUtf8Printable(jsonDoc.toJson(QJsonDocument::Indented)); m_receiveBuffer = m_receiveBuffer.right(m_receiveBuffer.length() - splitIndex - 1); if (!m_receiveBuffer.isEmpty()) { staticMetaObject.invokeMethod(this, "dataReceived", Qt::QueuedConnection, Q_ARG(QByteArray, QByteArray())); @@ -529,7 +559,7 @@ void JsonRpcClient::dataReceived(const QByteArray &data) // check if this is a notification if (dataMap.contains("notification")) { -// qDebug() << "Incoming notification:" << jsonDoc.toJson(); + // qDebug() << "Incoming notification:" << jsonDoc.toJson(); QStringList notification = dataMap.value("notification").toString().split("."); QString nameSpace = notification.first(); foreach (JsonHandler *handler, m_notificationHandlers.values(nameSpace)) { @@ -543,7 +573,7 @@ void JsonRpcClient::dataReceived(const QByteArray &data) JsonRpcReply *reply = m_replies.take(commandId); if (reply) { reply->deleteLater(); -// qDebug() << QString("JsonRpc: got response for %1.%2: %3").arg(reply->nameSpace(), reply->method(), QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Indented))) << reply->callback() << reply->callback(); + // qDebug() << QString("JsonRpc: got response for %1.%2: %3").arg(reply->nameSpace(), reply->method(), QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Indented))) << reply->callback() << reply->callback(); if (dataMap.value("status").toString() == "unauthorized") { qWarning() << "Something's off with the token"; @@ -558,106 +588,134 @@ void JsonRpcClient::dataReceived(const QByteArray &data) emit authenticatedChanged(); } + if (dataMap.value("status").toString() == "error") { + qWarning() << "An error happened in the JSONRPC layer!"; + if (reply->nameSpace() == "JSONRPC" && reply->method() == "Hello") { + qWarning() << "Hello call failed. Trying again without locale"; + m_id = 0; + sendCommand("JSONRPC.Hello", QVariantMap(), this, "helloReply"); + } + } + // Note: We're still forwarding a failed call, params will be empty tho... + // This should never really happen as errors on this layer indicate a but in the caller code in the first place + // Some methods however, like authenticate might fail on an invalid token tho and stil need to act on it + if (!reply->caller().isNull() && !reply->callback().isEmpty()) { - QMetaObject::invokeMethod(reply->caller(), reply->callback().toLatin1().data(), Q_ARG(QVariantMap, dataMap)); + QMetaObject::invokeMethod(reply->caller(), reply->callback().toLatin1().data(), Q_ARG(int, commandId), Q_ARG(QVariantMap, dataMap.value("params").toMap())); } emit responseReceived(reply->commandId(), dataMap.value("params").toMap()); + + + // If the server supports cache hashes, cache stuff locally + QString fullMethod = reply->nameSpace() + '.' + reply->method(); + if (m_cacheHashes.contains(fullMethod)) { + QString hash = m_cacheHashes.value(fullMethod); + QString callSignature = fullMethod + '-' + QJsonDocument::fromVariant(reply->params()).toJson() + '-' + QLocale().name(); + QString callSignatureHash = QCryptographicHash::hash(callSignature.toUtf8(), QCryptographicHash::Md5).toHex(); + QFile f(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + '/' + fullMethod + '-' + callSignatureHash + '-' + hash + ".cache"); + if (!f.exists() && f.open(QFile::WriteOnly | QFile::Truncate)) { + f.write(QJsonDocument::fromVariant(dataMap.value("params")).toJson()); + f.close(); + } + } + return; } } -void JsonRpcClient::helloReply(const QVariantMap ¶ms) +void JsonRpcClient::helloReply(int /*commandId*/, const QVariantMap ¶ms) { - if (params.value("status").toString() == "error") { - qWarning() << "Hello call failed. Trying again without locale"; - m_id = 0; - sendCommand("JSONRPC.Hello", QVariantMap(), this, "helloReply"); - } else { - QVariantMap dataMap = params.value("params").toMap(); - m_initialSetupRequired = dataMap.value("initialSetupRequired").toBool(); - m_authenticationRequired = dataMap.value("authenticationRequired").toBool(); - m_pushButtonAuthAvailable = dataMap.value("pushButtonAuthAvailable").toBool(); - emit pushButtonAuthAvailableChanged(); + m_initialSetupRequired = params.value("initialSetupRequired").toBool(); + m_authenticationRequired = params.value("authenticationRequired").toBool(); + m_pushButtonAuthAvailable = params.value("pushButtonAuthAvailable").toBool(); + emit pushButtonAuthAvailableChanged(); - m_serverUuid = dataMap.value("uuid").toString(); - m_serverVersion = dataMap.value("version").toString(); + m_serverUuid = params.value("uuid").toString(); + m_serverVersion = params.value("version").toString(); - QString protoVersionString = dataMap.value("protocol version").toString(); - if (!protoVersionString.contains('.')) { - protoVersionString.prepend("0."); - } + QString protoVersionString = params.value("protocol version").toString(); + if (!protoVersionString.contains('.')) { + protoVersionString.prepend("0."); + } - m_jsonRpcVersion = QVersionNumber::fromString(protoVersionString); + m_jsonRpcVersion = QVersionNumber::fromString(protoVersionString); - qDebug() << "Handshake reply:" << "Protocol version:" << protoVersionString << "InitRequired:" << m_initialSetupRequired << "AuthRequired:" << m_authenticationRequired << "PushButtonAvailable:" << m_pushButtonAuthAvailable;; + qDebug() << "Handshake reply:" << "Protocol version:" << protoVersionString << "InitRequired:" << m_initialSetupRequired << "AuthRequired:" << m_authenticationRequired << "PushButtonAvailable:" << m_pushButtonAuthAvailable;; - QVersionNumber minimumRequiredVersion = QVersionNumber(1, 10); - if (m_jsonRpcVersion < minimumRequiredVersion) { - qWarning() << "Nymea core doesn't support minimum required version. Required:" << minimumRequiredVersion << "Found:" << m_jsonRpcVersion; - m_connection->disconnect(); - emit invalidProtocolVersion(m_jsonRpcVersion.toString(), minimumRequiredVersion.toString()); - return; - } + QVersionNumber minimumRequiredVersion = QVersionNumber(1, 10); + if (m_jsonRpcVersion < minimumRequiredVersion) { + qWarning() << "Nymea core doesn't support minimum required version. Required:" << minimumRequiredVersion << "Found:" << m_jsonRpcVersion; + m_connection->disconnect(); + emit invalidProtocolVersion(m_jsonRpcVersion.toString(), minimumRequiredVersion.toString()); + return; + } - // Verify SSL certificate - if (m_connection->isEncrypted()) { - QByteArray pem; - if (!loadPem(m_serverUuid, pem)) { - qDebug() << "No SSL certificate for this host stored. Accepting and pinning new certificate."; - // No certificate yet! Inform ui about it. - emit newSslCertificate(); - storePem(m_serverUuid, m_connection->sslCertificate().toPem()); - } else { - // We have a certificate pinned already. Check if it's the same - if (m_connection->sslCertificate().toPem() != pem) { - // Uh oh, the certificate has changed - qWarning() << "This connections certificate has changed!"; + // Verify SSL certificate + if (m_connection->isEncrypted()) { + QByteArray pem; + if (!loadPem(m_serverUuid, pem)) { + qDebug() << "No SSL certificate for this host stored. Accepting and pinning new certificate."; + // No certificate yet! Inform ui about it. + emit newSslCertificate(); + storePem(m_serverUuid, m_connection->sslCertificate().toPem()); + } else { + // We have a certificate pinned already. Check if it's the same + if (m_connection->sslCertificate().toPem() != pem) { + // Uh oh, the certificate has changed + qWarning() << "This connections certificate has changed!"; - QSslCertificate certificate = m_connection->sslCertificate(); - QVariantMap issuerInfo = certificateIssuerInfo(); - emit verifyConnectionCertificate(m_serverUuid, issuerInfo, certificate.toPem()); + QSslCertificate certificate = m_connection->sslCertificate(); + QVariantMap issuerInfo = certificateIssuerInfo(); + emit verifyConnectionCertificate(m_serverUuid, issuerInfo, certificate.toPem()); - // Reject the connection until the UI explicitly accepts this... - m_connection->disconnectFromHost(); + // Reject the connection until the UI explicitly accepts this... + m_connection->disconnectFromHost(); - return; - } - qDebug() << "This connections certificate is trusted."; - } - } - - - emit handshakeReceived(); - - if (m_connection->currentHost()->uuid().isNull()) { - qDebug() << "Updating Server UUID in connection:" << m_connection->currentHost()->uuid().toString() << "->" << m_serverUuid; - m_connection->currentHost()->setUuid(m_serverUuid); - } - - if (m_initialSetupRequired) { - emit initialSetupRequiredChanged(); - return; - } - - if (m_authenticationRequired) { - QSettings settings; - settings.beginGroup("jsonTokens"); - m_token = settings.value(m_serverUuid).toByteArray(); - settings.endGroup(); - emit authenticationRequiredChanged(); - - if (m_token.isEmpty()) { return; } + qDebug() << "This connections certificate is trusted."; + } + } - m_authenticated = true; - emit authenticatedChanged(); + m_cacheHashes.clear(); + qDebug() << "Hello reply:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); + QVariantList cacheHashes = params.value("cacheHashes").toList(); + foreach (const QVariant &cacheHash, cacheHashes) { + m_cacheHashes.insert(cacheHash.toMap().value("method").toString(), cacheHash.toMap().value("hash").toString()); + } + qDebug() << "Caches:" << m_cacheHashes; + + emit handshakeReceived(); + + if (m_connection->currentHost()->uuid().isNull()) { + qDebug() << "Updating Server UUID in connection:" << m_connection->currentHost()->uuid().toString() << "->" << m_serverUuid; + m_connection->currentHost()->setUuid(m_serverUuid); + } + + if (m_initialSetupRequired) { + emit initialSetupRequiredChanged(); + return; + } + + if (m_authenticationRequired) { + QSettings settings; + settings.beginGroup("jsonTokens"); + m_token = settings.value(m_serverUuid).toByteArray(); + settings.endGroup(); + emit authenticationRequiredChanged(); + + if (m_token.isEmpty()) { + return; } - setNotificationsEnabled(); - getCloudConnectionStatus(); + m_authenticated = true; + emit authenticatedChanged(); } + + setNotificationsEnabled(); + getCloudConnectionStatus(); + } JsonRpcReply::JsonRpcReply(int commandId, QString nameSpace, QString method, QVariantMap params, QPointer caller, const QString &callback): diff --git a/libnymea-app/jsonrpc/jsonrpcclient.h b/libnymea-app/jsonrpc/jsonrpcclient.h index 85854c23..60726577 100644 --- a/libnymea-app/jsonrpc/jsonrpcclient.h +++ b/libnymea-app/jsonrpc/jsonrpcclient.h @@ -94,6 +94,7 @@ public: bool authenticated() const; CloudConnectionState cloudConnectionState() const; void deployCertificate(const QByteArray &rootCA, const QByteArray &certificate, const QByteArray &publicKey, const QByteArray &privateKey, const QString &endpoint); + QHash cacheHashes() const; QString serverVersion() const; QString jsonRpcVersion() const; @@ -111,7 +112,7 @@ public: Q_INVOKABLE int createUser(const QString &username, const QString &password); Q_INVOKABLE int authenticate(const QString &username, const QString &password, const QString &deviceName); Q_INVOKABLE int requestPushButtonAuth(const QString &deviceName); - Q_INVOKABLE void setupRemoteAccess(const QString &idToken, const QString &userId); + Q_INVOKABLE int setupRemoteAccess(const QString &idToken, const QString &userId); signals: @@ -142,7 +143,7 @@ private slots: void onInterfaceConnectedChanged(bool connected); void dataReceived(const QByteArray &data); - void helloReply(const QVariantMap ¶ms); + void helloReply(int commandId, const QVariantMap ¶ms); private: int m_id; @@ -168,21 +169,22 @@ private: QString m_serverQtBuildVersion; QByteArray m_token; QByteArray m_receiveBuffer; + QHash m_cacheHashes; void setNotificationsEnabled(); void getCloudConnectionStatus(); // json handler - Q_INVOKABLE void processAuthenticate(const QVariantMap &data); - Q_INVOKABLE void processCreateUser(const QVariantMap &data); - Q_INVOKABLE void processRequestPushButtonAuth(const QVariantMap &data); + Q_INVOKABLE void processAuthenticate(int commandId, const QVariantMap &data); + Q_INVOKABLE void processCreateUser(int commandId, const QVariantMap &data); + Q_INVOKABLE void processRequestPushButtonAuth(int commandId, const QVariantMap &data); - Q_INVOKABLE void setNotificationsEnabledResponse(const QVariantMap ¶ms); + Q_INVOKABLE void setNotificationsEnabledResponse(int commandId, const QVariantMap ¶ms); Q_INVOKABLE void notificationReceived(const QVariantMap &data); - Q_INVOKABLE void isCloudConnectedReply(const QVariantMap &data); - Q_INVOKABLE void setupRemoteAccessReply(const QVariantMap &data); - Q_INVOKABLE void deployCertificateReply(const QVariantMap &data); - Q_INVOKABLE void getVersionsReply(const QVariantMap &data); + Q_INVOKABLE void isCloudConnectedReply(int commandId, const QVariantMap &data); + Q_INVOKABLE void setupRemoteAccessReply(int commandId, const QVariantMap &data); + Q_INVOKABLE void deployCertificateReply(int commandId, const QVariantMap &data); + Q_INVOKABLE void getVersionsReply(int commandId, const QVariantMap &data); void sendRequest(const QVariantMap &request); diff --git a/libnymea-app/models/logsmodel.cpp b/libnymea-app/models/logsmodel.cpp index d947d4d8..606539ce 100644 --- a/libnymea-app/models/logsmodel.cpp +++ b/libnymea-app/models/logsmodel.cpp @@ -205,15 +205,15 @@ LogEntry *LogsModel::get(int index) const return nullptr; } -void LogsModel::logsReply(const QVariantMap &data) +void LogsModel::logsReply(int /*commandId*/, const QVariantMap &data) { - int offset = data.value("params").toMap().value("offset").toInt(); - int count = data.value("params").toMap().value("count").toInt(); + int offset = data.value("offset").toInt(); + int count = data.value("count").toInt(); // qDebug() << qUtf8Printable(QJsonDocument::fromVariant(data).toJson()); QList newBlock; - QList logEntries = data.value("params").toMap().value("logEntries").toList(); + QList logEntries = data.value("logEntries").toList(); foreach (const QVariant &logEntryVariant, logEntries) { QVariantMap entryMap = logEntryVariant.toMap(); QDateTime timeStamp = QDateTime::fromMSecsSinceEpoch(entryMap.value("timestamp").toLongLong()); diff --git a/libnymea-app/models/logsmodel.h b/libnymea-app/models/logsmodel.h index 11dfb1aa..0326de9b 100644 --- a/libnymea-app/models/logsmodel.h +++ b/libnymea-app/models/logsmodel.h @@ -112,7 +112,7 @@ signals: void logEntryAdded(LogEntry *entry); private slots: - virtual void logsReply(const QVariantMap &data); + virtual void logsReply(int commandId, const QVariantMap &data); void newLogEntryReceived(const QVariantMap &data); protected: diff --git a/libnymea-app/models/logsmodelng.cpp b/libnymea-app/models/logsmodelng.cpp index 8e475355..bdc3261d 100644 --- a/libnymea-app/models/logsmodelng.cpp +++ b/libnymea-app/models/logsmodelng.cpp @@ -237,15 +237,15 @@ LogEntry *LogsModelNg::get(int index) const return nullptr; } -void LogsModelNg::logsReply(const QVariantMap &data) +void LogsModelNg::logsReply(int commandId, const QVariantMap &data) { - int offset = data.value("params").toMap().value("offset").toInt(); - int count = data.value("params").toMap().value("count").toInt(); + int offset = data.value("offset").toInt(); + int count = data.value("count").toInt(); // qDebug() << qUtf8Printable(QJsonDocument::fromVariant(data).toJson()); QList newBlock; - QList logEntries = data.value("params").toMap().value("logEntries").toList(); + QList logEntries = data.value("logEntries").toList(); foreach (const QVariant &logEntryVariant, logEntries) { QVariantMap entryMap = logEntryVariant.toMap(); QDateTime timeStamp = QDateTime::fromMSecsSinceEpoch(entryMap.value("timestamp").toLongLong()); diff --git a/libnymea-app/models/logsmodelng.h b/libnymea-app/models/logsmodelng.h index c9c6fb64..4908cf58 100644 --- a/libnymea-app/models/logsmodelng.h +++ b/libnymea-app/models/logsmodelng.h @@ -129,7 +129,7 @@ signals: private slots: void newLogEntryReceived(const QVariantMap &data); - void logsReply(const QVariantMap &data); + void logsReply(int commandId, const QVariantMap &data); private: QList m_list; diff --git a/libnymea-app/models/tagsproxymodel.cpp b/libnymea-app/models/tagsproxymodel.cpp index 9cd4fd5c..64f4ca86 100644 --- a/libnymea-app/models/tagsproxymodel.cpp +++ b/libnymea-app/models/tagsproxymodel.cpp @@ -48,7 +48,6 @@ void TagsProxyModel::setTags(Tags *tags) m_tags = tags; setSourceModel(tags); connect(tags, &Tags::countChanged, this, [=](){ - qWarning() << "Tag count changed!"; invalidateFilter(); emit countChanged(); }, Qt::QueuedConnection); diff --git a/libnymea-app/rulemanager.cpp b/libnymea-app/rulemanager.cpp index 3755c069..e344fb93 100644 --- a/libnymea-app/rulemanager.cpp +++ b/libnymea-app/rulemanager.cpp @@ -96,26 +96,25 @@ int RuleManager::addRule(Rule *rule) return m_jsonClient->sendCommand("Rules.AddRule", params, this, "onAddRuleReply"); } -void RuleManager::removeRule(const QUuid &ruleId) +int RuleManager::removeRule(const QUuid &ruleId) { QVariantMap params; params.insert("ruleId", ruleId); - m_jsonClient->sendCommand("Rules.RemoveRule", params, this, "removeRuleReply"); + return m_jsonClient->sendCommand("Rules.RemoveRule", params, this, "removeRuleReply"); } -void RuleManager::editRule(Rule *rule) +int RuleManager::editRule(Rule *rule) { QVariantMap params = packRule(rule); qWarning() << "Packed rule:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); - m_jsonClient->sendCommand("Rules.EditRule", params, this, "onEditRuleReply"); - + return m_jsonClient->sendCommand("Rules.EditRule", params, this, "onEditRuleReply"); } -void RuleManager::executeActions(const QString &ruleId) +int RuleManager::executeActions(const QString &ruleId) { QVariantMap params; params.insert("ruleId", ruleId); - m_jsonClient->sendCommand("Rules.ExecuteActions", params, this, "onExecuteRuleActionsReply"); + return m_jsonClient->sendCommand("Rules.ExecuteActions", params, this, "onExecuteRuleActionsReply"); } void RuleManager::handleRulesNotification(const QVariantMap ¶ms) @@ -153,14 +152,10 @@ void RuleManager::handleRulesNotification(const QVariantMap ¶ms) } } -void RuleManager::getRulesReply(const QVariantMap ¶ms) +void RuleManager::getRulesReply(int /*commandId*/, const QVariantMap ¶ms) { - if (params.value("status").toString() != "success") { - qWarning() << "Error getting rules:" << params.value("error").toString(); - return; - } // qDebug() << "Get Rules reply" << params; - foreach (const QVariant &ruleDescriptionVariant, params.value("params").toMap().value("ruleDescriptions").toList()) { + foreach (const QVariant &ruleDescriptionVariant, params.value("ruleDescriptions").toList()) { QUuid ruleId = ruleDescriptionVariant.toMap().value("id").toUuid(); QString name = ruleDescriptionVariant.toMap().value("name").toString(); bool enabled = ruleDescriptionVariant.toMap().value("enabled").toBool(); @@ -180,9 +175,9 @@ void RuleManager::getRulesReply(const QVariantMap ¶ms) } } -void RuleManager::getRuleDetailsReply(const QVariantMap ¶ms) +void RuleManager::getRuleDetailsReply(int commandId, const QVariantMap ¶ms) { - QVariantMap ruleMap = params.value("params").toMap().value("rule").toMap(); + QVariantMap ruleMap = params.value("rule").toMap(); Rule* rule = m_rules->getRule(ruleMap.value("id").toUuid()); if (!rule) { qWarning() << "Got rule details for a rule we don't know"; @@ -197,36 +192,33 @@ void RuleManager::getRuleDetailsReply(const QVariantMap ¶ms) // qDebug() << "Rule JSON:" << qUtf8Printable(QJsonDocument::fromVariant(ruleMap).toJson()); } -void RuleManager::onAddRuleReply(const QVariantMap ¶ms) +void RuleManager::onAddRuleReply(int commandId, const QVariantMap ¶ms) { - if (params.value("params").toMap().value("ruleError").toString() != "RuleErrorNoError") { + if (params.value("ruleError").toString() != "RuleErrorNoError") { qWarning() << "Failed to add rule:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); } else { - qDebug() << "Rule added successfully. Rule ID:" << params.value("params").toMap().value("ruleId").toString(); + qDebug() << "Rule added successfully. Rule ID:" << params.value("ruleId").toString(); } - emit addRuleReply(params.value("id").toInt(), params.value("params").toMap().value("ruleError").toString(), params.value("params").toMap().value("ruleId").toString()); + emit addRuleReply(commandId, params.value("ruleError").toString(), params.value("ruleId").toString()); } -void RuleManager::removeRuleReply(const QVariantMap ¶ms) +void RuleManager::removeRuleReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Have remove rule reply" << params; + qDebug() << "Have remove rule reply" << commandId << params; } -void RuleManager::onEditRuleReply(const QVariantMap ¶ms) +void RuleManager::onEditRuleReply(int commandId, const QVariantMap ¶ms) { - if (params.value("status").toString() == "error") { - qDebug() << "Bad request editing rule:" << params.value("error").toString(); + if (params.value("ruleError").toString() != "RuleErrorNoError") { + qDebug() << "Bad rule:" << params.value("ruleError").toString(); } - if (params.value("params").toMap().value("ruleError").toString() != "RuleErrorNoError") { - qDebug() << "Bad rule:" << params.value("params").toMap().value("ruleError").toString(); - } - emit editRuleReply(params.value("params").toMap().value("ruleError").toString()); + emit editRuleReply(commandId, params.value("ruleError").toString()); } -void RuleManager::onExecuteRuleActionsReply(const QVariantMap ¶ms) +void RuleManager::onExecuteRuleActionsReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Execute rule actions reply:" << params; + qDebug() << "Execute rule actions reply:" << commandId << params; } Rule *RuleManager::parseRule(const QVariantMap &ruleMap) diff --git a/libnymea-app/rulemanager.h b/libnymea-app/rulemanager.h index 2df2f602..f76d4f4c 100644 --- a/libnymea-app/rulemanager.h +++ b/libnymea-app/rulemanager.h @@ -65,18 +65,18 @@ public: Q_INVOKABLE int addRule(const QVariantMap params); Q_INVOKABLE int addRule(Rule *rule); - Q_INVOKABLE void removeRule(const QUuid &ruleId); - Q_INVOKABLE void editRule(Rule *rule); - Q_INVOKABLE void executeActions(const QString &ruleId); + Q_INVOKABLE int removeRule(const QUuid &ruleId); + Q_INVOKABLE int editRule(Rule *rule); + Q_INVOKABLE int executeActions(const QString &ruleId); private slots: void handleRulesNotification(const QVariantMap ¶ms); - void getRulesReply(const QVariantMap ¶ms); - void getRuleDetailsReply(const QVariantMap ¶ms); - void onAddRuleReply(const QVariantMap ¶ms); - void removeRuleReply(const QVariantMap ¶ms); - void onEditRuleReply(const QVariantMap ¶ms); - void onExecuteRuleActionsReply(const QVariantMap ¶ms); + void getRulesReply(int commandId, const QVariantMap ¶ms); + void getRuleDetailsReply(int commandId, const QVariantMap ¶ms); + void onAddRuleReply(int commandId, const QVariantMap ¶ms); + void removeRuleReply(int commandId, const QVariantMap ¶ms); + void onEditRuleReply(int commandId, const QVariantMap ¶ms); + void onExecuteRuleActionsReply(int commandId, const QVariantMap ¶ms); private: Rule *parseRule(const QVariantMap &ruleMap); @@ -98,7 +98,7 @@ private: signals: void addRuleReply(int commandId, const QString &ruleError, const QString &ruleId); - void editRuleReply(const QString &ruleError); + void editRuleReply(int commandId, const QString &ruleError); private: JsonRpcClient *m_jsonClient; diff --git a/libnymea-app/scriptmanager.cpp b/libnymea-app/scriptmanager.cpp index e9189089..9ec689ac 100644 --- a/libnymea-app/scriptmanager.cpp +++ b/libnymea-app/scriptmanager.cpp @@ -96,9 +96,9 @@ int ScriptManager::fetchScript(const QUuid &id) return m_client->sendCommand("Scripts.GetScriptContent", params, this, "onScriptFetched"); } -void ScriptManager::onScriptsFetched(const QVariantMap ¶ms) +void ScriptManager::onScriptsFetched(int /*commandId*/, const QVariantMap ¶ms) { - foreach (const QVariant &variant, params.value("params").toMap().value("scripts").toList()) { + foreach (const QVariant &variant, params.value("scripts").toList()) { QUuid id = variant.toMap().value("id").toUuid(); Script *script = new Script(id); script->setName(variant.toMap().value("name").toString()); @@ -106,38 +106,38 @@ void ScriptManager::onScriptsFetched(const QVariantMap ¶ms) } } -void ScriptManager::onScriptFetched(const QVariantMap ¶ms) +void ScriptManager::onScriptFetched(int commandId, const QVariantMap ¶ms) { - emit fetchScriptReply(params.value("id").toInt(), - params.value("params").toMap().value("scriptError").toString(), - params.value("params").toMap().value("content").toString()); + emit fetchScriptReply(commandId, + params.value("scriptError").toString(), + params.value("content").toString()); } -void ScriptManager::onScriptAdded(const QVariantMap ¶ms) +void ScriptManager::onScriptAdded(int commandId, const QVariantMap ¶ms) { - emit addScriptReply(params.value("id").toInt(), - params.value("params").toMap().value("scriptError").toString(), - params.value("params").toMap().value("script").toMap().value("id").toUuid(), - params.value("params").toMap().value("errors").toStringList()); + emit addScriptReply(commandId, + params.value("scriptError").toString(), + params.value("script").toMap().value("id").toUuid(), + params.value("errors").toStringList()); } -void ScriptManager::onScriptEdited(const QVariantMap ¶ms) +void ScriptManager::onScriptEdited(int commandId, const QVariantMap ¶ms) { - emit editScriptReply(params.value("id").toInt(), - params.value("params").toMap().value("scriptError").toString(), - params.value("params").toMap().value("errors").toStringList()); + emit editScriptReply(commandId, + params.value("scriptError").toString(), + params.value("errors").toStringList()); } -void ScriptManager::onScriptRenamed(const QVariantMap ¶ms) +void ScriptManager::onScriptRenamed(int commandId, const QVariantMap ¶ms) { - emit renameScriptReply(params.value("id").toInt(), params.value("params").toMap().value("scriptError").toString()); + emit renameScriptReply(commandId, params.value("scriptError").toString()); } -void ScriptManager::onScriptRemoved(const QVariantMap ¶ms) +void ScriptManager::onScriptRemoved(int commandId, const QVariantMap ¶ms) { - emit removeScriptReply(params.value("id").toInt(), params.value("params").toMap().value("scriptError").toString()); + emit removeScriptReply(commandId, params.value("scriptError").toString()); } void ScriptManager::onNotificationReceived(const QVariantMap ¶ms) @@ -154,16 +154,11 @@ void ScriptManager::onNotificationReceived(const QVariantMap ¶ms) Script *script = new Script(scriptMap.value("id").toUuid()); script->setName(scriptMap.value("name").toString()); m_scripts->addScript(script); - emit addScriptReply(params.value("id").toInt(), - params.value("params").toMap().value("scriptError").toString(), - params.value("params").toMap().value("scriptId").toUuid(), - params.value("params").toMap().value("errors").toStringList()); } else if (params.value("notification").toString() == "Scripts.ScriptRemoved") { QUuid id = params.value("params").toMap().value("id").toUuid(); m_scripts->removeScript(id); - emit removeScriptReply(params.value("id").toInt(), params.value("params").toMap().value("scriptError").toString()); } else if (params.value("notification").toString() == "Scripts.ScriptChanged") { diff --git a/libnymea-app/scriptmanager.h b/libnymea-app/scriptmanager.h index abf74a58..1431e7e8 100644 --- a/libnymea-app/scriptmanager.h +++ b/libnymea-app/scriptmanager.h @@ -68,12 +68,12 @@ signals: void scriptMessage(const QUuid &scriptId, const QString &type, const QString &message); private slots: - void onScriptsFetched(const QVariantMap ¶ms); - void onScriptFetched(const QVariantMap ¶ms); - void onScriptAdded(const QVariantMap ¶ms); - void onScriptEdited(const QVariantMap ¶ms); - void onScriptRenamed(const QVariantMap ¶ms); - void onScriptRemoved(const QVariantMap ¶ms); + void onScriptsFetched(int commandId, const QVariantMap ¶ms); + void onScriptFetched(int commandId, const QVariantMap ¶ms); + void onScriptAdded(int commandId, const QVariantMap ¶ms); + void onScriptEdited(int commandId, const QVariantMap ¶ms); + void onScriptRenamed(int commandId, const QVariantMap ¶ms); + void onScriptRemoved(int commandId, const QVariantMap ¶ms); void onNotificationReceived(const QVariantMap ¶ms); private: diff --git a/libnymea-app/system/systemcontroller.cpp b/libnymea-app/system/systemcontroller.cpp index f16a2db5..2a4925d2 100644 --- a/libnymea-app/system/systemcontroller.cpp +++ b/libnymea-app/system/systemcontroller.cpp @@ -152,13 +152,13 @@ QDateTime SystemController::serverTime() const return m_serverTime; } -void SystemController::setServerTime(const QDateTime &serverTime) +int SystemController::setServerTime(const QDateTime &serverTime) { QVariantMap params; params.insert("automaticTime", false); params.insert("time", serverTime.toSecsSinceEpoch()); params.insert("timeZone", serverTime.timeZone().id()); - m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse"); + return m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse"); } QStringList SystemController::timeZones() const @@ -179,11 +179,11 @@ QString SystemController::serverTimeZone() const return m_serverTimeZone; } -void SystemController::setServerTimeZone(const QString &serverTimeZone) +int SystemController::setServerTimeZone(const QString &serverTimeZone) { QVariantMap params; params.insert("timeZone", serverTimeZone); - m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse"); + return m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse"); } bool SystemController::automaticTimeAvailable() const @@ -196,22 +196,22 @@ bool SystemController::automaticTime() const return m_automaticTime; } -void SystemController::setAutomaticTime(bool automaticTime) +int SystemController::setAutomaticTime(bool automaticTime) { QVariantMap params; params.insert("automaticTime", automaticTime); - m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse"); + return m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse"); } -void SystemController::getCapabilitiesResponse(const QVariantMap &data) +void SystemController::getCapabilitiesResponse(int /*commandId*/, const QVariantMap &data) { - m_powerManagementAvailable = data.value("params").toMap().value("powerManagement").toBool(); + m_powerManagementAvailable = data.value("powerManagement").toBool(); emit powerManagementAvailableChanged(); - m_updateManagementAvailable = data.value("params").toMap().value("updateManagement").toBool(); + m_updateManagementAvailable = data.value("updateManagement").toBool(); emit updateManagementAvailableChanged(); - m_timeManagementAvailable = data.value("params").toMap().value("timeManagement").toBool(); + m_timeManagementAvailable = data.value("timeManagement").toBool(); emit timeManagementAvailableChanged(); if (m_updateManagementAvailable) { @@ -227,16 +227,16 @@ void SystemController::getCapabilitiesResponse(const QVariantMap &data) qDebug() << "nymea:core capabilities: Power management:" << m_powerManagementAvailable << "Update management:" << m_updateManagementAvailable << "Time management:" << m_timeManagementAvailable; } -void SystemController::getUpdateStatusResponse(const QVariantMap &data) +void SystemController::getUpdateStatusResponse(int /*commandId*/, const QVariantMap &data) { - m_updateManagementBusy = data.value("params").toMap().value("busy").toBool(); - m_updateRunning = data.value("params").toMap().value("updateRunning").toBool(); + m_updateManagementBusy = data.value("busy").toBool(); + m_updateRunning = data.value("updateRunning").toBool(); emit updateRunningChanged(); } -void SystemController::getPackagesResponse(const QVariantMap &data) +void SystemController::getPackagesResponse(int commandId, const QVariantMap &data) { - foreach (const QVariant &packageVariant, data.value("params").toMap().value("packages").toList()) { + foreach (const QVariant &packageVariant, data.value("packages").toList()) { QString id = packageVariant.toMap().value("id").toString(); QString displayName = packageVariant.toMap().value("displayName").toString(); Package *p = new Package(id, displayName); @@ -251,9 +251,9 @@ void SystemController::getPackagesResponse(const QVariantMap &data) } } -void SystemController::getRepositoriesResponse(const QVariantMap &data) +void SystemController::getRepositoriesResponse(int /*commandId*/, const QVariantMap &data) { - foreach (const QVariant &repoVariant, data.value("params").toMap().value("repositories").toList()) { + foreach (const QVariant &repoVariant, data.value("repositories").toList()) { QString id = repoVariant.toMap().value("id").toString(); QString displayName = repoVariant.toMap().value("displayName").toString(); Repository *repo = new Repository(id, displayName); @@ -262,61 +262,58 @@ void SystemController::getRepositoriesResponse(const QVariantMap &data) } } -void SystemController::removePackageResponse(const QVariantMap ¶ms) +void SystemController::removePackageResponse(int commandId, const QVariantMap ¶ms) { - qDebug() << "Remove result" << params; + qDebug() << "Remove result" << commandId << params; } -void SystemController::enableRepositoryResponse(const QVariantMap ¶ms) +void SystemController::enableRepositoryResponse(int commandId, const QVariantMap ¶ms) { qDebug() << "Enable repo response" << params; - emit enableRepositoryFinished(params.value("id").toInt(), params.value("params").toMap().value("success").toBool()); + emit enableRepositoryFinished(commandId, params.value("success").toBool()); } -void SystemController::getServerTimeResponse(const QVariantMap ¶ms) +void SystemController::getServerTimeResponse(int commandId, const QVariantMap ¶ms) { - m_serverTime = QDateTime::fromSecsSinceEpoch(params.value("params").toMap().value("time").toUInt()); + m_serverTime = QDateTime::fromSecsSinceEpoch(params.value("time").toUInt()); // NOTE: Ideally we'd just set the TimeZone of our serverTime prooperly, however, there's a bug on Android // Which doesn't allow to create QTimeZone objects by IANA id.... So, let's keep that separated in a string // https://bugreports.qt.io/browse/QTBUG-83438 -// m_serverTime.setTimeZone(QTimeZone(params.value("params").toMap().value("timeZone").toString().toUtf8())); - m_serverTimeZone = params.value("params").toMap().value("timeZone").toString(); +// m_serverTime.setTimeZone(QTimeZone(params.value("timeZone").toString().toUtf8())); + m_serverTimeZone = params.value("timeZone").toString(); emit serverTimeChanged(); emit serverTimeZoneChanged(); - m_automaticTimeAvailable = params.value("params").toMap().value("automaticTimeAvailable").toBool(); + m_automaticTimeAvailable = params.value("automaticTimeAvailable").toBool(); emit automaticTimeAvailableChanged(); - m_automaticTime = params.value("params").toMap().value("automaticTime").toBool(); + m_automaticTime = params.value("automaticTime").toBool(); emit automaticTimeChanged(); qDebug() << "Server time:" << m_serverTime << "Automatic Time available:" << m_automaticTimeAvailable << "Automatic time:" << m_automaticTime; } -void SystemController::setTimeResponse(const QVariantMap ¶ms) +void SystemController::setTimeResponse(int commandId, const QVariantMap ¶ms) { - qDebug() << "set time response" << params; + qDebug() << "set time response" << commandId << params; } -void SystemController::restartResponse(const QVariantMap ¶ms) +void SystemController::restartResponse(int commandId, const QVariantMap ¶ms) { - int id = params.value("id").toInt(); - bool success = params.value("params").toMap().value("success").toBool(); - emit restartReply(id, success); + bool success = params.value("success").toBool(); + emit restartReply(commandId, success); } -void SystemController::rebootResponse(const QVariantMap ¶ms) +void SystemController::rebootResponse(int commandId, const QVariantMap ¶ms) { - int id = params.value("id").toInt(); - bool success = params.value("params").toMap().value("success").toBool(); - emit rebootReply(id, success); + bool success = params.value("success").toBool(); + emit rebootReply(commandId, success); } -void SystemController::shutdownResponse(const QVariantMap ¶ms) +void SystemController::shutdownResponse(int commandId, const QVariantMap ¶ms) { - int id = params.value("id").toInt(); - bool success = params.value("params").toMap().value("success").toBool(); - emit shutdownReply(id, success); + bool success = params.value("success").toBool(); + emit shutdownReply(commandId, success); } void SystemController::notificationReceived(const QVariantMap &data) diff --git a/libnymea-app/system/systemcontroller.h b/libnymea-app/system/systemcontroller.h index c264b7f7..8213bbcd 100644 --- a/libnymea-app/system/systemcontroller.h +++ b/libnymea-app/system/systemcontroller.h @@ -80,13 +80,13 @@ public: bool timeManagementAvailable() const; QDateTime serverTime() const; - void setServerTime(const QDateTime &serverTime); + int setServerTime(const QDateTime &serverTime); QStringList timeZones() const; QString serverTimeZone() const; - void setServerTimeZone(const QString &serverTimeZone); + int setServerTimeZone(const QString &serverTimeZone); bool automaticTimeAvailable() const; bool automaticTime() const; - void setAutomaticTime(bool automaticTime); + int setAutomaticTime(bool automaticTime); signals: void powerManagementAvailableChanged(); @@ -105,17 +105,17 @@ signals: void shutdownReply(int id, bool success); private slots: - void getCapabilitiesResponse(const QVariantMap &data); - void getUpdateStatusResponse(const QVariantMap &data); - void getPackagesResponse(const QVariantMap &data); - void getRepositoriesResponse(const QVariantMap &data); - void removePackageResponse(const QVariantMap ¶ms); - void enableRepositoryResponse(const QVariantMap ¶ms); - void getServerTimeResponse(const QVariantMap ¶ms); - void setTimeResponse(const QVariantMap ¶ms); - void restartResponse(const QVariantMap ¶ms); - void rebootResponse(const QVariantMap ¶ms); - void shutdownResponse(const QVariantMap ¶ms); + void getCapabilitiesResponse(int commandId, const QVariantMap &data); + void getUpdateStatusResponse(int commandId, const QVariantMap &data); + void getPackagesResponse(int commandId, const QVariantMap &data); + void getRepositoriesResponse(int commandId, const QVariantMap &data); + void removePackageResponse(int commandId, const QVariantMap ¶ms); + void enableRepositoryResponse(int commandId, const QVariantMap ¶ms); + void getServerTimeResponse(int commandId, const QVariantMap ¶ms); + void setTimeResponse(int commandId, const QVariantMap ¶ms); + void restartResponse(int commandId, const QVariantMap ¶ms); + void rebootResponse(int commandId, const QVariantMap ¶ms); + void shutdownResponse(int commandId, const QVariantMap ¶ms); void notificationReceived(const QVariantMap &data); diff --git a/libnymea-app/tagsmanager.cpp b/libnymea-app/tagsmanager.cpp index 506df48d..3c7b5f93 100644 --- a/libnymea-app/tagsmanager.cpp +++ b/libnymea-app/tagsmanager.cpp @@ -68,7 +68,7 @@ Tags *TagsManager::tags() const return m_tags; } -void TagsManager::tagDevice(const QString &deviceId, const QString &tagId, const QString &value) +int TagsManager::tagDevice(const QString &deviceId, const QString &tagId, const QString &value) { QVariantMap params; QVariantMap tag; @@ -77,10 +77,10 @@ void TagsManager::tagDevice(const QString &deviceId, const QString &tagId, const tag.insert("tagId", tagId); tag.insert("value", value); params.insert("tag", tag); - m_jsonClient->sendCommand("Tags.AddTag", params, this, "addTagReply"); + return m_jsonClient->sendCommand("Tags.AddTag", params, this, "addTagReply"); } -void TagsManager::untagDevice(const QString &deviceId, const QString &tagId) +int TagsManager::untagDevice(const QString &deviceId, const QString &tagId) { QVariantMap params; QVariantMap tag; @@ -88,10 +88,10 @@ void TagsManager::untagDevice(const QString &deviceId, const QString &tagId) tag.insert("appId", "nymea:app"); tag.insert("tagId", tagId); params.insert("tag", tag); - m_jsonClient->sendCommand("Tags.RemoveTag", params, this, "removeTagReply"); + return m_jsonClient->sendCommand("Tags.RemoveTag", params, this, "removeTagReply"); } -void TagsManager::tagRule(const QString &ruleId, const QString &tagId, const QString &value) +int TagsManager::tagRule(const QString &ruleId, const QString &tagId, const QString &value) { QVariantMap params; QVariantMap tag; @@ -100,10 +100,10 @@ void TagsManager::tagRule(const QString &ruleId, const QString &tagId, const QSt tag.insert("tagId", tagId); tag.insert("value", value); params.insert("tag", tag); - m_jsonClient->sendCommand("Tags.AddTag", params, this, "addTagReply"); + return m_jsonClient->sendCommand("Tags.AddTag", params, this, "addTagReply"); } -void TagsManager::untagRule(const QString &ruleId, const QString &tagId) +int TagsManager::untagRule(const QString &ruleId, const QString &tagId) { QVariantMap params; QVariantMap tag; @@ -111,7 +111,7 @@ void TagsManager::untagRule(const QString &ruleId, const QString &tagId) tag.insert("appId", "nymea:app"); tag.insert("tagId", tagId); params.insert("tag", tag); - m_jsonClient->sendCommand("Tags.RemoveTag", params, this, "removeTagReply"); + return m_jsonClient->sendCommand("Tags.RemoveTag", params, this, "removeTagReply"); } void TagsManager::handleTagsNotification(const QVariantMap ¶ms) @@ -164,10 +164,10 @@ void TagsManager::handleTagsNotification(const QVariantMap ¶ms) } } -void TagsManager::getTagsReply(const QVariantMap ¶ms) +void TagsManager::getTagsReply(int /*commandId*/, const QVariantMap ¶ms) { QList tags; - foreach (const QVariant &tagVariant, params.value("params").toMap().value("tags").toList()) { + foreach (const QVariant &tagVariant, params.value("tags").toList()) { Tag *tag = unpackTag(tagVariant.toMap()); if (tag) { tags.append(tag); @@ -179,14 +179,14 @@ void TagsManager::getTagsReply(const QVariantMap ¶ms) emit busyChanged(); } -void TagsManager::addTagReply(const QVariantMap ¶ms) +void TagsManager::addTagReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "AddTag reply" << params; + qDebug() << "AddTag reply" << commandId << params; } -void TagsManager::removeTagReply(const QVariantMap ¶ms) +void TagsManager::removeTagReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "RemoveTag reply" << params; + qDebug() << "RemoveTag reply" << commandId << params; } Tag* TagsManager::unpackTag(const QVariantMap &tagMap) diff --git a/libnymea-app/tagsmanager.h b/libnymea-app/tagsmanager.h index 0d5135f0..5a9a29cb 100644 --- a/libnymea-app/tagsmanager.h +++ b/libnymea-app/tagsmanager.h @@ -52,19 +52,19 @@ public: Tags* tags() const; - Q_INVOKABLE void tagDevice(const QString &deviceId, const QString &tagId, const QString &value); - Q_INVOKABLE void untagDevice(const QString &deviceId, const QString &tagId); - Q_INVOKABLE void tagRule(const QString &ruleId, const QString &tagId, const QString &value); - Q_INVOKABLE void untagRule(const QString &ruleId, const QString &tagId); + Q_INVOKABLE int tagDevice(const QString &deviceId, const QString &tagId, const QString &value); + Q_INVOKABLE int untagDevice(const QString &deviceId, const QString &tagId); + Q_INVOKABLE int tagRule(const QString &ruleId, const QString &tagId, const QString &value); + Q_INVOKABLE int untagRule(const QString &ruleId, const QString &tagId); signals: void busyChanged(); private slots: void handleTagsNotification(const QVariantMap ¶ms); - void getTagsReply(const QVariantMap ¶ms); - void addTagReply(const QVariantMap ¶ms); - void removeTagReply(const QVariantMap ¶ms); + void getTagsReply(int commandId, const QVariantMap ¶ms); + void addTagReply(int commandId, const QVariantMap ¶ms); + void removeTagReply(int commandId, const QVariantMap ¶ms); private: Tag *unpackTag(const QVariantMap &tagMap); diff --git a/libnymea-app/thinggroup.cpp b/libnymea-app/thinggroup.cpp index 6659ed4b..8d93e143 100644 --- a/libnymea-app/thinggroup.cpp +++ b/libnymea-app/thinggroup.cpp @@ -56,11 +56,11 @@ ThingGroup::ThingGroup(DeviceManager *deviceManager, DeviceClass *deviceClass, D syncStates(); }); - connect(m_thingManager, &DeviceManager::executeActionReply, this, [this](const QVariantMap ¶ms){ - int returningId = params.value("id").toInt(); + connect(m_thingManager, &DeviceManager::executeActionReply, this, [this](int commandId, const QVariantMap &/*params*/){ + // This should maybe check the params and only emit NoError if there is at least one thing that returned without error? foreach (int id, m_pendingActions.keys()) { - if (m_pendingActions.value(id).contains(returningId)) { - m_pendingActions[id].removeAll(returningId); + if (m_pendingActions.value(id).contains(commandId)) { + m_pendingActions[id].removeAll(commandId); if (m_pendingActions[id].isEmpty()) { m_pendingActions.remove(id); emit actionExecutionFinished(id, "DeviceErrorNoError"); diff --git a/libnymea-app/usermanager.cpp b/libnymea-app/usermanager.cpp index 4693e372..e60aeffb 100644 --- a/libnymea-app/usermanager.cpp +++ b/libnymea-app/usermanager.cpp @@ -73,17 +73,17 @@ void UserManager::notificationReceived(const QVariantMap &data) qDebug() << "Users notification" << data; } -void UserManager::getUserInfoReply(const QVariantMap &data) +void UserManager::getUserInfoReply(int commandId, const QVariantMap &data) { - qDebug() << "User info reply" << data; + qDebug() << "User info reply" << commandId << data; - m_userInfo->setUsername(data.value("params").toMap().value("userInfo").toMap().value("username").toString()); + m_userInfo->setUsername(data.value("userInfo").toMap().value("username").toString()); } -void UserManager::getTokensReply(const QVariantMap &data) +void UserManager::getTokensReply(int /*commandId*/, const QVariantMap &data) { - foreach (const QVariant &tokenVariant, data.value("params").toMap().value("tokenInfoList").toList()) { + foreach (const QVariant &tokenVariant, data.value("tokenInfoList").toList()) { // qDebug() << "Token received" << tokenVariant.toMap(); QVariantMap token = tokenVariant.toMap(); QUuid id = token.value("id").toString(); @@ -98,32 +98,28 @@ void UserManager::getTokensReply(const QVariantMap &data) -void UserManager::deleteTokenReply(const QVariantMap &payload) +void UserManager::deleteTokenReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Delete token reply" << payload; - int callId = payload.value("id").toInt(); - QUuid tokenId = m_tokensToBeRemoved.take(callId); - QVariantMap params = payload.value("params").toMap(); + qDebug() << "Delete token reply" << commandId << params; + QUuid tokenId = m_tokensToBeRemoved.take(commandId); QString errorString = params.value("error").toString(); QMetaEnum metaEnum = QMetaEnum::fromType(); UserError error = static_cast(metaEnum.keyToValue(errorString.toUtf8())); - emit deleteTokenResponse(callId, error); + emit deleteTokenResponse(commandId, error); if (error == UserErrorNoError) { m_tokenInfos->removeToken(tokenId); } } -void UserManager::changePasswordReply(const QVariantMap &data) +void UserManager::changePasswordReply(int commandId, const QVariantMap ¶ms) { - qDebug() << "Change password reply" << data; + qDebug() << "Change password reply" << commandId << params; - int callId = data.value("id").toInt(); - QVariantMap params = data.value("params").toMap(); QString errorString = params.value("error").toString(); QMetaEnum metaEnum = QMetaEnum::fromType(); UserError error = static_cast(metaEnum.keyToValue(errorString.toUtf8())); - emit changePasswordResponse(callId, error); + emit changePasswordResponse(commandId, error); } diff --git a/libnymea-app/usermanager.h b/libnymea-app/usermanager.h index d66cd44a..9e874588 100644 --- a/libnymea-app/usermanager.h +++ b/libnymea-app/usermanager.h @@ -55,10 +55,10 @@ signals: private slots: void notificationReceived(const QVariantMap &data); - void getUserInfoReply(const QVariantMap &data); - void getTokensReply(const QVariantMap &data); - void deleteTokenReply(const QVariantMap &data); - void changePasswordReply(const QVariantMap &data); + void getUserInfoReply(int commandId, const QVariantMap &data); + void getTokensReply(int commandId, const QVariantMap &data); + void deleteTokenReply(int commandId, const QVariantMap ¶ms); + void changePasswordReply(int commandId, const QVariantMap ¶ms); private: Engine *m_engine = nullptr; diff --git a/nymea-app/ui/components/Dial.qml b/nymea-app/ui/components/Dial.qml index ed5649c0..8749c781 100644 --- a/nymea-app/ui/components/Dial.qml +++ b/nymea-app/ui/components/Dial.qml @@ -99,10 +99,12 @@ ColumnLayout { Connections { target: engine.deviceManager onExecuteActionReply: { - d.pendingActionId = -1 - if (d.valueCacheDirty) { - d.executeAction(d.valueCache) - d.valueCacheDirty = false; + if (d.pendingActionId == commandId) { + d.pendingActionId = -1 + if (d.valueCacheDirty) { + d.executeAction(d.valueCache) + d.valueCacheDirty = false; + } } } } diff --git a/nymea-app/ui/devicepages/DeviceBrowserPage.qml b/nymea-app/ui/devicepages/DeviceBrowserPage.qml index de0f534f..000b859f 100644 --- a/nymea-app/ui/devicepages/DeviceBrowserPage.qml +++ b/nymea-app/ui/devicepages/DeviceBrowserPage.qml @@ -66,20 +66,18 @@ Page { Connections { target: engine.deviceManager - onExecuteBrowserItemReply: actionExecuted(params) - onExecuteBrowserItemActionReply: actionExecuted(params) + onExecuteBrowserItemReply: actionExecuted(commandId, params) + onExecuteBrowserItemActionReply: actionExecuted(commandId, params) } - function actionExecuted(params) { - if (params.id === d.pendingBrowserItemId) { + function actionExecuted(commandId, params) { + if (commandId === d.pendingBrowserItemId) { d.pendingBrowserItemId = -1; d.pendingItemId = "" - if (params.status !== "success") { - header.showInfo(params.error, true); - } else if (params.params.deviceError !== "DeviceErrorNoError") { - if (params.params.displayMessage.length > 0) { - header.showInfo(qsTr("Error: %1").arg(params.params.displayMessage), true) + if (params.deviceError !== "DeviceErrorNoError") { + if (params.displayMessage.length > 0) { + header.showInfo(qsTr("Error: %1").arg(params.displayMessage), true) } else { - header.showInfo(qsTr("Error: %1").arg(params.params.deviceError), true) + header.showInfo(qsTr("Error: %1").arg(params.deviceError), true) } } } diff --git a/nymea-app/ui/devicepages/FingerprintReaderDevicePage.qml b/nymea-app/ui/devicepages/FingerprintReaderDevicePage.qml index 6acef592..7a66d13d 100644 --- a/nymea-app/ui/devicepages/FingerprintReaderDevicePage.qml +++ b/nymea-app/ui/devicepages/FingerprintReaderDevicePage.qml @@ -192,7 +192,7 @@ DevicePageBase { target: engine.deviceManager onExecuteActionReply: { print("Execute action reply:", JSON.stringify(params)); - addUserPage.error = params["params"]["deviceError"] !== "DeviceErrorNoError" + addUserPage.error = params["deviceError"] !== "DeviceErrorNoError" var masks =[] masks.push({x: 0, y: 0, width: 1, height: 1}); addUserPage.done = true diff --git a/nymea-app/ui/devicepages/GenericDevicePage.qml b/nymea-app/ui/devicepages/GenericDevicePage.qml index 83345f58..3f814233 100644 --- a/nymea-app/ui/devicepages/GenericDevicePage.qml +++ b/nymea-app/ui/devicepages/GenericDevicePage.qml @@ -283,7 +283,7 @@ DevicePageBase { Connections { target: engine.deviceManager onExecuteActionReply: { - if (stateDelegate.pendingActionId === params.id) { + if (stateDelegate.pendingActionId === commandId) { stateDelegate.pendingActionId = -1 if (stateDelegate.valueCacheDirty) { stateDelegate.executeAction(stateDelegate.valueCache) @@ -308,9 +308,9 @@ DevicePageBase { Connections { target: engine.deviceManager onExecuteActionReply: { - if (params["id"] === actionDelegate.pendingActionId) { + if (commandId === actionDelegate.pendingActionId) { pendingTimer.start(); - actionDelegate.lastSuccess = params["params"]["deviceError"] === "DeviceErrorNoError" + actionDelegate.lastSuccess = params["deviceError"] === "DeviceErrorNoError" actionDelegate.pendingActionId = -1 } } diff --git a/nymea-app/ui/devicepages/LightDevicePage.qml b/nymea-app/ui/devicepages/LightDevicePage.qml index 3cb014bb..de8dae6a 100644 --- a/nymea-app/ui/devicepages/LightDevicePage.qml +++ b/nymea-app/ui/devicepages/LightDevicePage.qml @@ -302,7 +302,7 @@ DevicePageBase { target: engine.deviceManager onExecuteActionReply: { print("action finished", JSON.stringify(params)) - if (params.id === colorPicker.pendingCommand) { + if (commandId === colorPicker.pendingCommand) { colorPicker.pendingCommand = -1; if (colorPicker.queuedColor) { colorPicker.sendColor(colorPicker.queuedColor); diff --git a/nymea-app/ui/devicepages/MediaDevicePage.qml b/nymea-app/ui/devicepages/MediaDevicePage.qml index 6e2d29f6..454b7bfe 100644 --- a/nymea-app/ui/devicepages/MediaDevicePage.qml +++ b/nymea-app/ui/devicepages/MediaDevicePage.qml @@ -108,15 +108,15 @@ DevicePageBase { Connections { target: engine.deviceManager - onExecuteBrowserItemReply: executionFinished(params) - onExecuteBrowserItemActionReply: executionFinished(params) + onExecuteBrowserItemReply: executionFinished(commandId, params) + onExecuteBrowserItemActionReply: executionFinished(commandId, params) onExecuteActionReply: { - print("actionfinished", params["id"]) - if (params["id"] === d.pendingVolumeId) { + print("actionfinished", commandId) + if (commandId === d.pendingVolumeId) { d.pendingVolumeId = -1 print("volume action finished") - if (params.params.deviceError !== "DeviceErrorNoError") { - print("Error setting volume", params.params.deviceError) + if (params.deviceError !== "DeviceErrorNoError") { + print("Error setting volume", params.deviceError) d.pendingVolumeValue = -1; return; } @@ -129,16 +129,16 @@ DevicePageBase { } } } - function executionFinished(params) { - print("Execute reply:", params, params.id, params["id"], d.pendingBrowserItemId) - if (params.id === d.pendingBrowserItemId) { + function executionFinished(commandId, params) { + print("Execute reply:", params, commandId, d.pendingBrowserItemId) + if (commandId === d.pendingBrowserItemId) { d.pendingBrowserItemId = -1; d.pendingItemId = "" print("yep finished") - if (params.params.deviceError === "DeviceErrorNoError") { + if (params.deviceError === "DeviceErrorNoError") { swipeView.currentIndex = 0; } else { - header.showInfo(qsTr("Error: %1").arg(params.params.deviceError), true) + header.showInfo(qsTr("Error: %1").arg(params.deviceError), true) } } } diff --git a/nymea-app/ui/experiences/heating/Main.qml b/nymea-app/ui/experiences/heating/Main.qml index 43fffdc0..2bc8e387 100644 --- a/nymea-app/ui/experiences/heating/Main.qml +++ b/nymea-app/ui/experiences/heating/Main.qml @@ -119,8 +119,8 @@ Item { Connections { target: engine.deviceManager onExecuteActionReply: { - print("executeActionReply:", params["id"]) - if (params["id"] === d.pendingCallId) { + print("executeActionReply:", commandId) + if (commandId === d.pendingCallId) { d.pendingCallId = -1; if (d.setTempPending) { setTargetTemp(d.queuedTargetTemp) diff --git a/nymea-app/ui/system/PluginParamsPage.qml b/nymea-app/ui/system/PluginParamsPage.qml index 818fdccc..c9cc74a0 100644 --- a/nymea-app/ui/system/PluginParamsPage.qml +++ b/nymea-app/ui/system/PluginParamsPage.qml @@ -56,11 +56,11 @@ Page { Connections { target: engine.deviceManager onSavePluginConfigReply: { - if (params.params.deviceError === "DeviceErrorNoError") { + if (params.deviceError === "DeviceErrorNoError") { pageStack.pop(); } else { console.warn("Error saving plugin params:", JSON.stringify(params)) - var dialog = errorDialog.createObject(root, {errorCode: params.params.deviceError}); + var dialog = errorDialog.createObject(root, {errorCode: params.deviceError}); dialog.open(); } }