ETM-Schurig/powersync-app
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge PR #430: Make use of the new caching mechanism in nymea

Browse Source
This commit is contained in:
Jenkins nymea 2020-09-15 19:11:17 +02:00
commit 86ebe59877
34 changed files with 592 additions and 549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
libnymea-app/configuration/networkmanager.cpp
View File

@ -179,12 +179,12 @@ int NetworkManager::disconnectInterface(const QString &interface)
return m_engine->jsonRpcClient()->sendCommand("NetworkManager.DisconnectInterface", params, this, "disconnectResponse"); return m_engine->jsonRpcClient()->sendCommand("NetworkManager.DisconnectInterface", params, this, "disconnectResponse");
} }
void NetworkManager::getStatusResponse(const QVariantMap &params) void NetworkManager::getStatusResponse(int /*commandId*/, const QVariantMap &params)
{ {
m_loading = false; m_loading = false;
emit loadingChanged(); 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)); qWarning() << "NetworkManager error:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
m_available = false; m_available = false;
emit availableChanged(); emit availableChanged();
@ -194,10 +194,10 @@ void NetworkManager::getStatusResponse(const QVariantMap &params)
m_available = true; m_available = true;
emit availableChanged(); emit availableChanged();
QVariantMap statusMap = params.value("params").toMap().value("status").toMap(); QVariantMap statusMap = params.value("status").toMap();
QMetaEnum stateEnum = QMetaEnum::fromType<NetworkManager::NetworkManagerState>(); QMetaEnum stateEnum = QMetaEnum::fromType<NetworkManager::NetworkManagerState>();
NetworkManagerState state = static_cast<NetworkManager::NetworkManagerState>(stateEnum.keyToValue(params.value("params").toMap().value("status").toMap().value("state").toString().toUtf8())); NetworkManagerState state = static_cast<NetworkManager::NetworkManagerState>(stateEnum.keyToValue(statusMap.value("state").toString().toUtf8()));
if (m_state != state) { if (m_state != state) {
m_state = state; m_state = state;
emit stateChanged(); emit stateChanged();
@ -215,11 +215,11 @@ void NetworkManager::getStatusResponse(const QVariantMap &params)
} }
} }
void NetworkManager::getDevicesResponse(const QVariantMap &params) void NetworkManager::getDevicesResponse(int /*commandId*/, const QVariantMap &params)
{ {
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(); QVariantMap deviceMap = deviceVariant.toMap();
WiredNetworkDevice *device = new WiredNetworkDevice(deviceMap.value("macAddress").toString(), deviceMap.value("interface").toString(), this); WiredNetworkDevice *device = new WiredNetworkDevice(deviceMap.value("macAddress").toString(), deviceMap.value("interface").toString(), this);
device->setIpv4Addresses(deviceMap.value("ipv4Addresses").toStringList()); device->setIpv4Addresses(deviceMap.value("ipv4Addresses").toStringList());
@ -230,7 +230,7 @@ void NetworkManager::getDevicesResponse(const QVariantMap &params)
device->setPluggedIn(deviceMap.value("pluggedIn").toBool()); device->setPluggedIn(deviceMap.value("pluggedIn").toBool());
m_wiredNetworkDevices->addNetworkDevice(device); 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(); QVariantMap deviceMap = deviceVariant.toMap();
WirelessNetworkDevice *device = new WirelessNetworkDevice(deviceMap.value("macAddress").toString(), deviceMap.value("interface").toString(), this); WirelessNetworkDevice *device = new WirelessNetworkDevice(deviceMap.value("macAddress").toString(), deviceMap.value("interface").toString(), this);
device->setIpv4Addresses(deviceMap.value("ipv4Addresses").toStringList()); device->setIpv4Addresses(deviceMap.value("ipv4Addresses").toStringList());
@ -251,16 +251,15 @@ void NetworkManager::getDevicesResponse(const QVariantMap &params)
} }
} }
void NetworkManager::getAccessPointsResponse(const QVariantMap &params) void NetworkManager::getAccessPointsResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Access points reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); qDebug() << "Access points reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
int requestId = params.value("id").toInt(); if (!m_apRequests.contains(commandId)) {
if (!m_apRequests.contains(requestId)) {
qWarning() << "NetworkManager received a reply for a request we don't know!"; qWarning() << "NetworkManager received a reply for a request we don't know!";
return; return;
} }
QString interface = m_apRequests.take(requestId); QString interface = m_apRequests.take(commandId);
WirelessNetworkDevice *dev = m_wirelessNetworkDevices->getWirelessNetworkDevice(interface); WirelessNetworkDevice *dev = m_wirelessNetworkDevices->getWirelessNetworkDevice(interface);
if (!dev) { if (!dev) {
@ -270,7 +269,7 @@ void NetworkManager::getAccessPointsResponse(const QVariantMap &params)
dev->accessPoints()->clearModel(); 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(); QVariantMap apMap = apVariant.toMap();
WirelessAccessPoint* ap = new WirelessAccessPoint(this); WirelessAccessPoint* ap = new WirelessAccessPoint(this);
ap->setMacAddress(apMap.value("macAddress").toString()); ap->setMacAddress(apMap.value("macAddress").toString());
@ -283,44 +282,39 @@ void NetworkManager::getAccessPointsResponse(const QVariantMap &params)
} }
void NetworkManager::connectToWiFiResponse(const QVariantMap &params) void NetworkManager::connectToWiFiResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "connect to wifi reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); qDebug() << "connect to wifi reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
int id = params.value("id").toInt(); QString status = params.value("networkManagerError").toString();
QString status = params.value("params").toMap().value("networkManagerError").toString(); emit connectToWiFiReply(commandId, status);
emit connectToWiFiReply(id, status);
} }
void NetworkManager::disconnectResponse(const QVariantMap &params) void NetworkManager::disconnectResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "disconnect reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); qDebug() << "disconnect reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
int id = params.value("id").toInt(); QString status = params.value("networkManagerError").toString();
QString status = params.value("params").toMap().value("networkManagerError").toString(); emit disconnectReply(commandId, status);
emit disconnectReply(id, status);
} }
void NetworkManager::enableNetworkingResponse(const QVariantMap &params) void NetworkManager::enableNetworkingResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "enable networking reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); qDebug() << "enable networking reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
int id = params.value("id").toInt(); QString status = params.value("networkManagerError").toString();
QString status = params.value("params").toMap().value("networkManagerError").toString(); emit enableNetworkingReply(commandId, status);
emit enableNetworkingReply(id, status);
} }
void NetworkManager::enableWirelessNetworkingResponse(const QVariantMap &params) void NetworkManager::enableWirelessNetworkingResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "enable wireless networking reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); qDebug() << "enable wireless networking reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
int id = params.value("id").toInt(); QString status = params.value("networkManagerError").toString();
QString status = params.value("params").toMap().value("networkManagerError").toString(); emit enableWirelessNetworkingReply(commandId, status);
emit enableWirelessNetworkingReply(id, status);
} }
void NetworkManager::startAccessPointResponse(const QVariantMap &params) void NetworkManager::startAccessPointResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Start access point reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); qDebug() << "Start access point reply" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
int id = params.value("id").toInt(); QString status = params.value("networkManagerError").toString();
QString status = params.value("params").toMap().value("networkManagerError").toString(); emit startAccessPointReply(commandId, status);
emit startAccessPointReply(id, status);
} }
void NetworkManager::notificationReceived(const QVariantMap &params) void NetworkManager::notificationReceived(const QVariantMap &params)

16
libnymea-app/configuration/networkmanager.h
View File

@ -113,14 +113,14 @@ signals:
private slots: private slots:
void init(); void init();
void getStatusResponse(const QVariantMap &params); void getStatusResponse(int commandId, const QVariantMap &params);
void getDevicesResponse(const QVariantMap &params); void getDevicesResponse(int commandId, const QVariantMap &params);
void getAccessPointsResponse(const QVariantMap &params); void getAccessPointsResponse(int commandId, const QVariantMap &params);
void connectToWiFiResponse(const QVariantMap &params); void connectToWiFiResponse(int commandId, const QVariantMap &params);
void disconnectResponse(const QVariantMap &params); void disconnectResponse(int commandId, const QVariantMap &params);
void enableNetworkingResponse(const QVariantMap &params); void enableNetworkingResponse(int commandId, const QVariantMap &params);
void enableWirelessNetworkingResponse(const QVariantMap &params); void enableWirelessNetworkingResponse(int commandId, const QVariantMap &params);
void startAccessPointResponse(const QVariantMap &params); void startAccessPointResponse(int commandId, const QVariantMap &params);
void notificationReceived(const QVariantMap &params); void notificationReceived(const QVariantMap &params);

78
libnymea-app/configuration/nymeaconfiguration.cpp
View File

@ -252,34 +252,34 @@ void NymeaConfiguration::deleteMqttPolicy(const QString &clientId)
m_client->sendCommand("Configuration.DeleteMqttPolicy", params, this, "deleteMqttPolicyReply"); m_client->sendCommand("Configuration.DeleteMqttPolicy", params, this, "deleteMqttPolicyReply");
} }
void NymeaConfiguration::getConfigurationsResponse(const QVariantMap &params) void NymeaConfiguration::getConfigurationsResponse(int commandId, const QVariantMap &params)
{ {
// qDebug() << "have config reply" << params; // 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(); m_debugServerEnabled = basicConfig.value("debugServerEnabled").toBool();
emit debugServerEnabledChanged(); emit debugServerEnabledChanged();
m_serverName = basicConfig.value("serverName").toString(); m_serverName = basicConfig.value("serverName").toString();
emit serverNameChanged(); emit serverNameChanged();
QVariantMap cloudConfig = params.value("params").toMap().value("cloud").toMap(); QVariantMap cloudConfig = params.value("cloud").toMap();
m_cloudEnabled = cloudConfig.value("enabled").toBool(); m_cloudEnabled = cloudConfig.value("enabled").toBool();
emit cloudEnabledChanged(); emit cloudEnabledChanged();
tcpServerConfigurations()->clear(); 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; // qDebug() << "tcp server config:" << tcpServerVariant;
QVariantMap tcpConfigMap = tcpServerVariant.toMap(); 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()); 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); m_tcpServerConfigurations->addConfiguration(config);
} }
webSocketServerConfigurations()->clear(); 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(); 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()); 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); m_webSocketServerConfigurations->addConfiguration(config);
} }
webServerConfigurations()->clear(); 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(); 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()); 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()); config->setPublicFolder(webServerConfigMap.value("publicFolder").toString());
@ -287,9 +287,14 @@ void NymeaConfiguration::getConfigurationsResponse(const QVariantMap &params)
} }
} }
void NymeaConfiguration::setServerNameResponse(const QVariantMap &params) void NymeaConfiguration::setServerNameResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Server name set:" << params; qDebug() << "Server name set:" << commandId << params;
}
void NymeaConfiguration::setTimezoneResponse(int commandId, const QVariantMap &params)
{
qDebug() << "Set timezone response" << commandId << params;
} }
void NymeaConfiguration::getCloudConfigurationResponse(const QVariantMap &params) void NymeaConfiguration::getCloudConfigurationResponse(const QVariantMap &params)
@ -297,72 +302,71 @@ void NymeaConfiguration::getCloudConfigurationResponse(const QVariantMap &params
qDebug() << "Cloud config reply" << params; qDebug() << "Cloud config reply" << params;
} }
void NymeaConfiguration::setCloudEnabledResponse(const QVariantMap &params) void NymeaConfiguration::setCloudEnabledResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Set cloud enabled:" << params; qDebug() << "Set cloud enabled:" << commandId << params;
} }
void NymeaConfiguration::setDebugServerEnabledResponse(const QVariantMap &params) void NymeaConfiguration::setDebugServerEnabledResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Debug server set:" << params; qDebug() << "Debug server set:" << commandId << params;
} }
void NymeaConfiguration::setTcpConfigReply(const QVariantMap &params) void NymeaConfiguration::setTcpConfigReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Set TCP server config reply" << params; qDebug() << "Set TCP server config reply" << commandId << params;
} }
void NymeaConfiguration::deleteTcpConfigReply(const QVariantMap &params) void NymeaConfiguration::deleteTcpConfigReply(int commandId, const QVariantMap &params)
{ {
if (params.value("params").toMap().value("configurationError").toString() == "ConfigurationErrorNoError") { qDebug() << "Deöete TCP server config reply" << commandId << params;
}
} }
void NymeaConfiguration::setWebSocketConfigReply(const QVariantMap &params) void NymeaConfiguration::setWebSocketConfigReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "set websocket config reply" << params; qDebug() << "set websocket config reply" << commandId << params;
} }
void NymeaConfiguration::setWebConfigReply(const QVariantMap &params) void NymeaConfiguration::setWebConfigReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "set web server config reply" << params; qDebug() << "set web server config reply" << commandId << params;
} }
void NymeaConfiguration::deleteWebConfigReply(const QVariantMap &params) void NymeaConfiguration::deleteWebConfigReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Delete web server config reply" << params; qDebug() << "Delete web server config reply" << commandId << params;
} }
void NymeaConfiguration::deleteWebSocketConfigReply(const QVariantMap &params) void NymeaConfiguration::deleteWebSocketConfigReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Delete web socket server config reply" << params; qDebug() << "Delete web socket server config reply" << commandId << params;
} }
void NymeaConfiguration::getMqttServerConfigsReply(const QVariantMap &params) void NymeaConfiguration::getMqttServerConfigsReply(int commandId, const QVariantMap &params)
{ {
m_mqttServerConfigurations->clear(); 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(); 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()); 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); m_mqttServerConfigurations->addConfiguration(config);
} }
} }
void NymeaConfiguration::setMqttConfigReply(const QVariantMap &params) void NymeaConfiguration::setMqttConfigReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Set mqtt config reply" << params; qDebug() << "Set mqtt config reply" << commandId << params;
} }
void NymeaConfiguration::deleteMqttConfigReply(const QVariantMap &params) void NymeaConfiguration::deleteMqttConfigReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Delete Mqtt Broker config reply:" << params; qDebug() << "Delete Mqtt Broker config reply:" << commandId << params;
} }
void NymeaConfiguration::getMqttPoliciesReply(const QVariantMap &params) void NymeaConfiguration::getMqttPoliciesReply(int commandId, const QVariantMap &params)
{ {
// qDebug() << "Mqtt polices:" << params; // qDebug() << "Mqtt polices:" << params;
m_mqttPolicies->clear(); 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(); QVariantMap policyMap = policyVariant.toMap();
MqttPolicy *policy = new MqttPolicy( MqttPolicy *policy = new MqttPolicy(
policyMap.value("clientId").toString(), policyMap.value("clientId").toString(),
@ -374,14 +378,14 @@ void NymeaConfiguration::getMqttPoliciesReply(const QVariantMap &params)
} }
} }
void NymeaConfiguration::setMqttPolicyReply(const QVariantMap &params) void NymeaConfiguration::setMqttPolicyReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Set MQTT policy reply" << params; qDebug() << "Set MQTT policy reply" << commandId << params;
} }
void NymeaConfiguration::deleteMqttPolicyReply(const QVariantMap &params) void NymeaConfiguration::deleteMqttPolicyReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Delete MQTT policy reply" << params; qDebug() << "Delete MQTT policy reply" << commandId << params;
} }
void NymeaConfiguration::notificationReceived(const QVariantMap &notification) void NymeaConfiguration::notificationReceived(const QVariantMap &notification)

33
libnymea-app/configuration/nymeaconfiguration.h
View File

@ -106,23 +106,24 @@ public:
void init(); void init();
private: private:
Q_INVOKABLE void getConfigurationsResponse(const QVariantMap &params); Q_INVOKABLE void getConfigurationsResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getCloudConfigurationResponse(const QVariantMap &params); Q_INVOKABLE void getCloudConfigurationResponse(const QVariantMap &params);
Q_INVOKABLE void setDebugServerEnabledResponse(const QVariantMap &params); Q_INVOKABLE void setDebugServerEnabledResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setServerNameResponse(const QVariantMap &params); Q_INVOKABLE void setServerNameResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setCloudEnabledResponse(const QVariantMap &params); Q_INVOKABLE void setTimezoneResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setTcpConfigReply(const QVariantMap &params); Q_INVOKABLE void setCloudEnabledResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteTcpConfigReply(const QVariantMap &params); Q_INVOKABLE void setTcpConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void setWebSocketConfigReply(const QVariantMap &params); Q_INVOKABLE void deleteTcpConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteWebSocketConfigReply(const QVariantMap &params); Q_INVOKABLE void setWebSocketConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void setWebConfigReply(const QVariantMap &params); Q_INVOKABLE void deleteWebSocketConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteWebConfigReply(const QVariantMap &params); Q_INVOKABLE void setWebConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void getMqttServerConfigsReply(const QVariantMap &params); Q_INVOKABLE void deleteWebConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void setMqttConfigReply(const QVariantMap &params); Q_INVOKABLE void getMqttServerConfigsReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteMqttConfigReply(const QVariantMap &params); Q_INVOKABLE void setMqttConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void getMqttPoliciesReply(const QVariantMap &params); Q_INVOKABLE void deleteMqttConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void setMqttPolicyReply(const QVariantMap &params); Q_INVOKABLE void getMqttPoliciesReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteMqttPolicyReply(const QVariantMap &params); Q_INVOKABLE void setMqttPolicyReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteMqttPolicyReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void notificationReceived(const QVariantMap &notification); Q_INVOKABLE void notificationReceived(const QVariantMap &notification);

6
libnymea-app/devicediscovery.cpp
View File

@ -131,10 +131,10 @@ QString DeviceDiscovery::displayMessage() const
return m_displayMessage; return m_displayMessage;
} }
void DeviceDiscovery::discoverDevicesResponse(const QVariantMap &params) void DeviceDiscovery::discoverDevicesResponse(int /*commandId*/, const QVariantMap &params)
{ {
// qDebug() << "response received" << params; // qDebug() << "response received" << params;
QVariantList descriptors = params.value("params").toMap().value("deviceDescriptors").toList(); QVariantList descriptors = params.value("deviceDescriptors").toList();
foreach (const QVariant &descriptorVariant, descriptors) { foreach (const QVariant &descriptorVariant, descriptors) {
qDebug() << "Found device. Descriptor:" << descriptorVariant; qDebug() << "Found device. Descriptor:" << descriptorVariant;
if (!contains(descriptorVariant.toMap().value("id").toUuid())) { if (!contains(descriptorVariant.toMap().value("id").toUuid())) {
@ -154,7 +154,7 @@ void DeviceDiscovery::discoverDevicesResponse(const QVariantMap &params)
} }
} }
m_displayMessage = params.value("params").toMap().value("displayMessage").toString(); m_displayMessage = params.value("displayMessage").toString();
m_busy = false; m_busy = false;
emit busyChanged(); emit busyChanged();
} }

2
libnymea-app/devicediscovery.h
View File

@ -93,7 +93,7 @@ public:
QString displayMessage() const; QString displayMessage() const;
private slots: private slots:
void discoverDevicesResponse(const QVariantMap &params); void discoverDevicesResponse(int commandId, const QVariantMap &params);
signals: signals:
void busyChanged(); void busyChanged();

164
libnymea-app/devicemanager.cpp
View File

@ -36,7 +36,10 @@
#include "thinggroup.h" #include "thinggroup.h"
#include "types/interface.h" #include "types/interface.h"
#include "types/ioconnections.h" #include "types/ioconnections.h"
#include <QMetaEnum> #include <QMetaEnum>
#include <QFile>
#include <QStandardPaths>
DeviceManager::DeviceManager(JsonRpcClient* jsonclient, QObject *parent) : DeviceManager::DeviceManager(JsonRpcClient* jsonclient, QObject *parent) :
JsonHandler(parent), JsonHandler(parent),
@ -61,6 +64,8 @@ void DeviceManager::clear()
void DeviceManager::init() void DeviceManager::init()
{ {
m_connectionBenchmark = QDateTime::currentDateTime();
// For old nymea setups we need to register to Events.Notifications. // For old nymea setups we need to register to Events.Notifications.
// Deprecated since JSONRPC 4.0/nymea 0.17 // Deprecated since JSONRPC 4.0/nymea 0.17
if (!m_jsonClient->ensureServerVersion("4.0")) { if (!m_jsonClient->ensureServerVersion("4.0")) {
@ -151,14 +156,14 @@ bool DeviceManager::fetchingData() const
return m_fetchingData; 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(); qDebug() << "add device " << deviceClassId.toString();
QVariantMap params; QVariantMap params;
params.insert("deviceClassId", deviceClassId.toString()); params.insert("deviceClassId", deviceClassId.toString());
params.insert("name", name); params.insert("name", name);
params.insert("deviceParams", deviceParams); 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) void DeviceManager::notificationReceived(const QVariantMap &data)
@ -264,11 +269,11 @@ void DeviceManager::notificationReceived(const QVariantMap &data)
} }
} }
void DeviceManager::getVendorsResponse(const QVariantMap &params) void DeviceManager::getVendorsResponse(int /*commandId*/, const QVariantMap &params)
{ {
// qDebug() << "Got GetSupportedVendors response" << params; // qDebug() << "Got GetSupportedVendors response" << params;
if (params.value("params").toMap().keys().contains("vendors")) { if (params.keys().contains("vendors")) {
QVariantList vendorList = params.value("params").toMap().value("vendors").toList(); QVariantList vendorList = params.value("vendors").toList();
foreach (QVariant vendorVariant, vendorList) { foreach (QVariant vendorVariant, vendorList) {
Vendor *vendor = JsonTypes::unpackVendor(vendorVariant.toMap()); Vendor *vendor = JsonTypes::unpackVendor(vendorVariant.toMap());
m_vendors->addVendor(vendor); m_vendors->addVendor(vendor);
@ -277,11 +282,11 @@ void DeviceManager::getVendorsResponse(const QVariantMap &params)
} }
} }
void DeviceManager::getSupportedDevicesResponse(const QVariantMap &params) void DeviceManager::getSupportedDevicesResponse(int /*commandId*/, const QVariantMap &params)
{ {
// qDebug() << "DeviceClasses received:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); // qDebug() << "DeviceClasses received:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
if (params.value("params").toMap().keys().contains("deviceClasses")) { if (params.keys().contains("deviceClasses")) {
QVariantList deviceClassList = params.value("params").toMap().value("deviceClasses").toList(); QVariantList deviceClassList = params.value("deviceClasses").toList();
foreach (QVariant deviceClassVariant, deviceClassList) { foreach (QVariant deviceClassVariant, deviceClassList) {
DeviceClass *deviceClass = JsonTypes::unpackDeviceClass(deviceClassVariant.toMap(), deviceClasses()); DeviceClass *deviceClass = JsonTypes::unpackDeviceClass(deviceClassVariant.toMap(), deviceClasses());
m_thingClasses->addDeviceClass(deviceClass); m_thingClasses->addDeviceClass(deviceClass);
@ -290,11 +295,11 @@ void DeviceManager::getSupportedDevicesResponse(const QVariantMap &params)
m_jsonClient->sendCommand("Devices.GetConfiguredDevices", this, "getConfiguredDevicesResponse"); m_jsonClient->sendCommand("Devices.GetConfiguredDevices", this, "getConfiguredDevicesResponse");
} }
void DeviceManager::getPluginsResponse(const QVariantMap &params) void DeviceManager::getPluginsResponse(int /*commandId*/, const QVariantMap &params)
{ {
// qDebug() << "received plugins"; // qDebug() << "received plugins";
if (params.value("params").toMap().keys().contains("plugins")) { if (params.keys().contains("plugins")) {
QVariantList pluginList = params.value("params").toMap().value("plugins").toList(); QVariantList pluginList = params.value("plugins").toList();
foreach (QVariant pluginVariant, pluginList) { foreach (QVariant pluginVariant, pluginList) {
Plugin *plugin = JsonTypes::unpackPlugin(pluginVariant.toMap(), plugins()); Plugin *plugin = JsonTypes::unpackPlugin(pluginVariant.toMap(), plugins());
m_plugins->addPlugin(plugin); m_plugins->addPlugin(plugin);
@ -310,7 +315,7 @@ void DeviceManager::getPluginsResponse(const QVariantMap &params)
} }
} }
void DeviceManager::getPluginConfigResponse(const QVariantMap &params) void DeviceManager::getPluginConfigResponse(int /*commandId*/, const QVariantMap &params)
{ {
// qDebug() << "plugin config response" << params; // qDebug() << "plugin config response" << params;
Plugin *p = m_plugins->get(m_currentGetConfigIndex); Plugin *p = m_plugins->get(m_currentGetConfigIndex);
@ -318,7 +323,7 @@ void DeviceManager::getPluginConfigResponse(const QVariantMap &params)
qDebug() << "Received a plugin config for a plugin we don't know"; qDebug() << "Received a plugin config for a plugin we don't know";
return; return;
} }
QVariantList pluginParams = params.value("params").toMap().value("configuration").toList(); QVariantList pluginParams = params.value("configuration").toList();
foreach (const QVariant &paramVariant, pluginParams) { foreach (const QVariant &paramVariant, pluginParams) {
Param* param = new Param(); Param* param = new Param();
JsonTypes::unpackParam(paramVariant.toMap(), param); JsonTypes::unpackParam(paramVariant.toMap(), param);
@ -333,10 +338,10 @@ void DeviceManager::getPluginConfigResponse(const QVariantMap &params)
} }
} }
void DeviceManager::getConfiguredDevicesResponse(const QVariantMap &params) void DeviceManager::getConfiguredDevicesResponse(int /*commandId*/, const QVariantMap &params)
{ {
if (params.value("params").toMap().keys().contains("devices")) { if (params.keys().contains("devices")) {
QVariantList deviceList = params.value("params").toMap().value("devices").toList(); QVariantList deviceList = params.value("devices").toList();
foreach (QVariant deviceVariant, deviceList) { foreach (QVariant deviceVariant, deviceList) {
Device *device = JsonTypes::unpackDevice(this, deviceVariant.toMap(), m_thingClasses); Device *device = JsonTypes::unpackDevice(this, deviceVariant.toMap(), m_thingClasses);
if (!device) { if (!device) {
@ -369,6 +374,7 @@ void DeviceManager::getConfiguredDevicesResponse(const QVariantMap &params)
// qDebug() << "*** Added device:" << endl << device; // qDebug() << "*** Added device:" << endl << device;
} }
} }
qDebug() << "Initializing thing manager took" << m_connectionBenchmark.msecsTo(QDateTime::currentDateTime()) << "ms";
m_fetchingData = false; m_fetchingData = false;
emit fetchingDataChanged(); emit fetchingDataChanged();
@ -377,12 +383,12 @@ void DeviceManager::getConfiguredDevicesResponse(const QVariantMap &params)
m_jsonClient->sendCommand("Devices.GetPlugins", this, "getPluginsResponse"); m_jsonClient->sendCommand("Devices.GetPlugins", this, "getPluginsResponse");
} }
void DeviceManager::addDeviceResponse(const QVariantMap &params) void DeviceManager::addDeviceResponse(int commandId, const QVariantMap &params)
{ {
if (params.value("params").toMap().value("deviceError").toString() != "DeviceErrorNoError") { if (params.value("deviceError").toString() != "DeviceErrorNoError") {
qWarning() << "Failed to add the device:" << params.value("params").toMap().value("deviceError").toString(); qWarning() << "Failed to add the device:" << params.value("deviceError").toString();
} else if (params.value("params").toMap().keys().contains("device")) { } else if (params.keys().contains("device")) {
QVariantMap deviceVariant = params.value("params").toMap().value("device").toMap(); QVariantMap deviceVariant = params.value("device").toMap();
Device *device = JsonTypes::unpackDevice(this, deviceVariant, m_thingClasses); Device *device = JsonTypes::unpackDevice(this, deviceVariant, m_thingClasses);
if (!device) { if (!device) {
qWarning() << "Couldn't parse json in addDeviceResponse"; qWarning() << "Couldn't parse json in addDeviceResponse";
@ -392,57 +398,57 @@ void DeviceManager::addDeviceResponse(const QVariantMap &params)
qDebug() << "Device added" << device->id().toString(); qDebug() << "Device added" << device->id().toString();
m_devices->addDevice(device); m_devices->addDevice(device);
} }
emit addDeviceReply(params.value("params").toMap()); emit addDeviceReply(commandId, params);
} }
void DeviceManager::removeDeviceResponse(const QVariantMap &params) void DeviceManager::removeDeviceResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Device removed response" << params; qDebug() << "Device removed response" << params;
emit removeDeviceReply(params.value("params").toMap()); emit removeDeviceReply(commandId, params);
} }
void DeviceManager::pairDeviceResponse(const QVariantMap &params) void DeviceManager::pairDeviceResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Pair device response:" << params; qDebug() << "Pair device response:" << params;
emit pairDeviceReply(params.value("params").toMap()); emit pairDeviceReply(commandId, params);
} }
void DeviceManager::confirmPairingResponse(const QVariantMap &params) void DeviceManager::confirmPairingResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "ConfirmPairingResponse" << params; qDebug() << "ConfirmPairingResponse" << params;
emit confirmPairingReply(params.value("params").toMap()); emit confirmPairingReply(commandId, params);
} }
void DeviceManager::setPluginConfigResponse(const QVariantMap &params) void DeviceManager::setPluginConfigResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "set plugin config respionse" << params; qDebug() << "set plugin config response" << params;
emit savePluginConfigReply(params); emit savePluginConfigReply(commandId, params);
} }
void DeviceManager::editDeviceResponse(const QVariantMap &params) void DeviceManager::editDeviceResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Edit device response" << params; qDebug() << "Edit device response" << params;
emit editDeviceReply(params); emit editDeviceReply(commandId, params);
} }
void DeviceManager::executeActionResponse(const QVariantMap &params) void DeviceManager::executeActionResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Execute Action response" << params; qDebug() << "Execute Action response" << params;
emit executeActionReply(params); emit executeActionReply(commandId, params);
} }
void DeviceManager::reconfigureDeviceResponse(const QVariantMap &params) void DeviceManager::reconfigureDeviceResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Reconfigure device response" << params; 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); Plugin *p = m_plugins->getPlugin(pluginId);
if (!p) { if (!p) {
qWarning()<< "Error: can't find plugin with id" << pluginId; qWarning()<< "Error: can't find plugin with id" << pluginId;
return; return -1;
} }
QVariantMap params; QVariantMap params;
params.insert("pluginId", pluginId); params.insert("pluginId", pluginId);
@ -451,7 +457,7 @@ void DeviceManager::savePluginConfig(const QUuid &pluginId)
pluginParams.append(JsonTypes::packParam(p->params()->get(i))); pluginParams.append(JsonTypes::packParam(p->params()->get(i)));
} }
params.insert("configuration", pluginParams); 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) ThingGroup *DeviceManager::createGroup(Interface *interface, DevicesProxy *things)
@ -461,7 +467,7 @@ ThingGroup *DeviceManager::createGroup(Interface *interface, DevicesProxy *thing
return group; 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(); qDebug() << "JsonRpc: add discovered device " << deviceClassId.toString();
QVariantMap params; QVariantMap params;
@ -469,10 +475,10 @@ void DeviceManager::addDiscoveredDevice(const QUuid &deviceClassId, const QUuid
params.insert("name", name); params.insert("name", name);
params.insert("deviceDescriptorId", deviceDescriptorId.toString()); params.insert("deviceDescriptorId", deviceDescriptorId.toString());
params.insert("deviceParams", deviceParams); 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(); qDebug() << "JsonRpc: pair discovered device " << deviceDescriptorId.toString();
QVariantMap params; QVariantMap params;
@ -484,20 +490,20 @@ void DeviceManager::pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid
params.insert("deviceClassId", deviceClassId); 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(); qDebug() << "JsonRpc: pair device " << deviceClassId.toString();
QVariantMap params; QVariantMap params;
params.insert("deviceClassId", deviceClassId.toString()); params.insert("deviceClassId", deviceClassId.toString());
params.insert("deviceParams", deviceParams); params.insert("deviceParams", deviceParams);
params.insert("name", name); 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; qDebug() << "JsonRpc: pair device (reconfigure)" << deviceId;
QVariantMap params; QVariantMap params;
@ -506,10 +512,10 @@ void DeviceManager::rePairDevice(const QUuid &deviceId, const QVariantList &devi
if (!name.isEmpty()) { if (!name.isEmpty()) {
params.insert("name", name); 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(); qDebug() << "JsonRpc: confirm pairing" << pairingTransactionId.toString();
QVariantMap params; QVariantMap params;
@ -518,10 +524,10 @@ void DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QStr
if (!username.isEmpty()) { if (!username.isEmpty()) {
params.insert("username", username); 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(); qDebug() << "JsonRpc: delete device" << deviceId.toString();
QVariantMap params; QVariantMap params;
@ -530,34 +536,34 @@ void DeviceManager::removeDevice(const QUuid &deviceId, RemovePolicy removePolic
QMetaEnum policyEnum = QMetaEnum::fromType<DeviceManager::RemovePolicy>(); QMetaEnum policyEnum = QMetaEnum::fromType<DeviceManager::RemovePolicy>();
params.insert("removePolicy", policyEnum.valueToKey(removePolicy)); 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; QVariantMap params;
params.insert("deviceId", deviceId.toString()); params.insert("deviceId", deviceId.toString());
params.insert("name", name); 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; QVariantMap params;
params.insert("deviceId", deviceId); params.insert("deviceId", deviceId);
params.insert("settings", settings); 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; QVariantMap params;
params.insert("deviceId", deviceId.toString()); params.insert("deviceId", deviceId.toString());
params.insert("deviceParams", deviceParams); 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 &paramOverride) int DeviceManager::reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList &paramOverride)
{ {
QVariantMap params; QVariantMap params;
params.insert("deviceId", deviceId.toString()); params.insert("deviceId", deviceId.toString());
@ -566,7 +572,7 @@ void DeviceManager::reconfigureDiscoveredDevice(const QUuid &deviceId, const QUu
params.insert("deviceParams", paramOverride); params.insert("deviceParams", paramOverride);
} }
qDebug() << "Calling ReconfigureDevice" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); 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 &params) int DeviceManager::executeAction(const QUuid &deviceId, const QUuid &actionTypeId, const QVariantList &params)
@ -627,16 +633,15 @@ BrowserItem *DeviceManager::browserItem(const QUuid &deviceId, const QString &it
return item; return item;
} }
void DeviceManager::browseDeviceResponse(const QVariantMap &params) void DeviceManager::browseDeviceResponse(int commandId, const QVariantMap &params)
{ {
// qDebug() << "Browsing response:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); // qDebug() << "Browsing response:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
int id = params.value("id").toInt(); if (!m_browsingRequests.contains(commandId)) {
if (!m_browsingRequests.contains(id)) {
qWarning() << "Received a browsing reply for an id we don't know."; qWarning() << "Received a browsing reply for an id we don't know.";
return; return;
} }
QPointer<BrowserItems> itemModel = m_browsingRequests.take(id); QPointer<BrowserItems> itemModel = m_browsingRequests.take(commandId);
if (!itemModel) { if (!itemModel) {
qDebug() << "BrowserItems model seems to have disappeared. Discarding browsing result."; qDebug() << "BrowserItems model seems to have disappeared. Discarding browsing result.";
return; return;
@ -644,7 +649,7 @@ void DeviceManager::browseDeviceResponse(const QVariantMap &params)
QList<BrowserItem*> itemsToRemove = itemModel->list(); QList<BrowserItem*> 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(); QVariantMap itemMap = itemVariant.toMap();
QString itemId = itemMap.value("id").toString(); QString itemId = itemMap.value("id").toString();
BrowserItem *item = itemModel->getBrowserItem(itemId); BrowserItem *item = itemModel->getBrowserItem(itemId);
@ -676,22 +681,21 @@ void DeviceManager::browseDeviceResponse(const QVariantMap &params)
itemModel->setBusy(false); itemModel->setBusy(false);
} }
void DeviceManager::browserItemResponse(const QVariantMap &params) void DeviceManager::browserItemResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Browser item details response:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); qDebug() << "Browser item details response:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
int id = params.value("id").toInt(); if (!m_browserDetailsRequests.contains(commandId)) {
if (!m_browserDetailsRequests.contains(id)) {
qWarning() << "Received a browser item details reply for an id we don't know."; qWarning() << "Received a browser item details reply for an id we don't know.";
return; return;
} }
QPointer<BrowserItem> item = m_browserDetailsRequests.take(id); QPointer<BrowserItem> item = m_browserDetailsRequests.take(commandId);
if (!item) { if (!item) {
qDebug() << "BrowserItem seems to have disappeared. Discarding browser item details result."; qDebug() << "BrowserItem seems to have disappeared. Discarding browser item details result.";
return; return;
} }
QVariantMap itemMap = params.value("params").toMap().value("item").toMap(); QVariantMap itemMap = params.value("item").toMap();
item->setDisplayName(itemMap.value("displayName").toString()); item->setDisplayName(itemMap.value("displayName").toString());
item->setDescription(itemMap.value("description").toString()); item->setDescription(itemMap.value("description").toString());
item->setIcon(itemMap.value("icon").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"); return m_jsonClient->sendCommand("Actions.ExecuteBrowserItem", params, this, "executeBrowserItemResponse");
} }
void DeviceManager::executeBrowserItemResponse(const QVariantMap &params) void DeviceManager::executeBrowserItemResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Execute Browser Item finished" << params; 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 &params) int DeviceManager::executeBrowserItemAction(const QUuid &deviceId, const QString &itemId, const QUuid &actionTypeId, const QVariantList &params)
@ -747,17 +751,17 @@ int DeviceManager::disconnectIO(const QUuid &ioConnectionId)
return m_jsonClient->sendCommand("Integrations.DisconnectIO", data, this, "disconnectIOResponse"); return m_jsonClient->sendCommand("Integrations.DisconnectIO", data, this, "disconnectIOResponse");
} }
void DeviceManager::executeBrowserItemActionResponse(const QVariantMap &params) void DeviceManager::executeBrowserItemActionResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Execute Browser Item Action finished" << params; qDebug() << "Execute Browser Item Action finished" << params;
emit executeBrowserItemActionReply(params); emit executeBrowserItemActionReply(commandId, params);
} }
void DeviceManager::getIOConnectionsResponse(const QVariantMap &params) void DeviceManager::getIOConnectionsResponse(int /*commandId*/, const QVariantMap &params)
{ {
// qDebug() << "Get IO connections response" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); // 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(); QVariantMap connectionMap = connectionVariant.toMap();
QUuid id = connectionMap.value("id").toUuid(); QUuid id = connectionMap.value("id").toUuid();
QUuid inputThingId = connectionMap.value("inputThingId").toUuid(); QUuid inputThingId = connectionMap.value("inputThingId").toUuid();
@ -770,13 +774,13 @@ void DeviceManager::getIOConnectionsResponse(const QVariantMap &params)
} }
} }
void DeviceManager::connectIOResponse(const QVariantMap &params) void DeviceManager::connectIOResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "ConnectIO response" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); qDebug() << "ConnectIO response" << commandId << qUtf8Printable(QJsonDocument::fromVariant(params).toJson());
} }
void DeviceManager::disconnectIOResponse(const QVariantMap &params) void DeviceManager::disconnectIOResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "DisconnectIO response" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson()); qDebug() << "DisconnectIO response" << commandId << qUtf8Printable(QJsonDocument::fromVariant(params).toJson());
} }

85
libnymea-app/devicemanager.h
View File

@ -86,19 +86,19 @@ public:
bool fetchingData() const; 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 // 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 int 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 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 // 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 int 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 int 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 int confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString(), const QString &username = QString());
Q_INVOKABLE void removeDevice(const QUuid &deviceId, RemovePolicy policy = RemovePolicyNone); Q_INVOKABLE int removeDevice(const QUuid &deviceId, RemovePolicy policy = RemovePolicyNone);
Q_INVOKABLE void editDevice(const QUuid &deviceId, const QString &name); Q_INVOKABLE int editDevice(const QUuid &deviceId, const QString &name);
Q_INVOKABLE void setDeviceSettings(const QUuid &deviceId, const QVariantList &settings); Q_INVOKABLE int setDeviceSettings(const QUuid &deviceId, const QVariantList &settings);
Q_INVOKABLE void reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams); Q_INVOKABLE int reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams);
Q_INVOKABLE void reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList &paramOverride); Q_INVOKABLE int reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList &paramOverride);
Q_INVOKABLE int executeAction(const QUuid &deviceId, const QUuid &actionTypeId, const QVariantList &params = QVariantList()); Q_INVOKABLE int executeAction(const QUuid &deviceId, const QUuid &actionTypeId, const QVariantList &params = QVariantList());
Q_INVOKABLE BrowserItems* browseDevice(const QUuid &deviceId, const QString &itemId = QString()); Q_INVOKABLE BrowserItems* browseDevice(const QUuid &deviceId, const QString &itemId = QString());
Q_INVOKABLE void refreshBrowserItems(BrowserItems *browserItems); Q_INVOKABLE void refreshBrowserItems(BrowserItems *browserItems);
@ -111,43 +111,43 @@ public:
private: private:
Q_INVOKABLE void notificationReceived(const QVariantMap &data); Q_INVOKABLE void notificationReceived(const QVariantMap &data);
Q_INVOKABLE void getVendorsResponse(const QVariantMap &params); Q_INVOKABLE void getVendorsResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getSupportedDevicesResponse(const QVariantMap &params); Q_INVOKABLE void getSupportedDevicesResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getPluginsResponse(const QVariantMap &params); Q_INVOKABLE void getPluginsResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getPluginConfigResponse(const QVariantMap &params); Q_INVOKABLE void getPluginConfigResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getConfiguredDevicesResponse(const QVariantMap &params); Q_INVOKABLE void getConfiguredDevicesResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void addDeviceResponse(const QVariantMap &params); Q_INVOKABLE void addDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void removeDeviceResponse(const QVariantMap &params); Q_INVOKABLE void removeDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void pairDeviceResponse(const QVariantMap &params); Q_INVOKABLE void pairDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void confirmPairingResponse(const QVariantMap &params); Q_INVOKABLE void confirmPairingResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setPluginConfigResponse(const QVariantMap &params); Q_INVOKABLE void setPluginConfigResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void editDeviceResponse(const QVariantMap &params); Q_INVOKABLE void editDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void executeActionResponse(const QVariantMap &params); Q_INVOKABLE void executeActionResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void reconfigureDeviceResponse(const QVariantMap &params); Q_INVOKABLE void reconfigureDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void browseDeviceResponse(const QVariantMap &params); Q_INVOKABLE void browseDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void browserItemResponse(const QVariantMap &params); Q_INVOKABLE void browserItemResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void executeBrowserItemResponse(const QVariantMap &params); Q_INVOKABLE void executeBrowserItemResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void executeBrowserItemActionResponse(const QVariantMap &params); Q_INVOKABLE void executeBrowserItemActionResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getIOConnectionsResponse(const QVariantMap &params); Q_INVOKABLE void getIOConnectionsResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void connectIOResponse(const QVariantMap &params); Q_INVOKABLE void connectIOResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void disconnectIOResponse(const QVariantMap &params); Q_INVOKABLE void disconnectIOResponse(int commandId, const QVariantMap &params);
public slots: public slots:
void savePluginConfig(const QUuid &pluginId); int savePluginConfig(const QUuid &pluginId);
ThingGroup* createGroup(Interface *interface, DevicesProxy *things); ThingGroup* createGroup(Interface *interface, DevicesProxy *things);
signals: signals:
void pairDeviceReply(const QVariantMap &params); void pairDeviceReply(int commandId, const QVariantMap &params);
void confirmPairingReply(const QVariantMap &params); void confirmPairingReply(int commandId, const QVariantMap &params);
void addDeviceReply(const QVariantMap &params); void addDeviceReply(int commandId, const QVariantMap &params);
void removeDeviceReply(const QVariantMap &params); void removeDeviceReply(int commandId, const QVariantMap &params);
void savePluginConfigReply(const QVariantMap &params); void savePluginConfigReply(int commandId, const QVariantMap &params);
void editDeviceReply(const QVariantMap &params); void editDeviceReply(int commandId, const QVariantMap &params);
void reconfigureDeviceReply(const QVariantMap &params); void reconfigureDeviceReply(int commandId, const QVariantMap &params);
void executeActionReply(const QVariantMap &params); void executeActionReply(int commandId, const QVariantMap &params);
void executeBrowserItemReply(const QVariantMap &params); void executeBrowserItemReply(int commandId, const QVariantMap &params);
void executeBrowserItemActionReply(const QVariantMap &params); void executeBrowserItemActionReply(int commandId, const QVariantMap &params);
void fetchingDataChanged(); void fetchingDataChanged();
void notificationReceived(const QString &deviceId, const QString &eventTypeId, const QVariantList &params); void notificationReceived(const QString &deviceId, const QString &eventTypeId, const QVariantList &params);
@ -169,6 +169,7 @@ private:
QHash<int, QPointer<BrowserItems> > m_browsingRequests; QHash<int, QPointer<BrowserItems> > m_browsingRequests;
QHash<int, QPointer<BrowserItem> > m_browserDetailsRequests; QHash<int, QPointer<BrowserItem> > m_browserDetailsRequests;
QDateTime m_connectionBenchmark;
// Deprecated stuff for nymea < 0.17 (JSONRPC < 4.0) // Deprecated stuff for nymea < 0.17 (JSONRPC < 4.0)
EventHandler *m_eventHandler = nullptr; EventHandler *m_eventHandler = nullptr;

266
libnymea-app/jsonrpc/jsonrpcclient.cpp
View File

@ -94,7 +94,31 @@ void JsonRpcClient::unregisterNotificationHandler(JsonHandler *handler)
int JsonRpcClient::sendCommand(const QString &method, const QVariantMap &params, QObject *caller, const QString &callbackMethod) int JsonRpcClient::sendCommand(const QString &method, const QVariantMap &params, QObject *caller, const QString &callbackMethod)
{ {
JsonRpcReply *reply = createReply(method, params, caller, 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); m_replies.insert(reply->commandId(), reply);
sendRequest(reply->requestMap()); sendRequest(reply->requestMap());
return reply->commandId(); return reply->commandId();
@ -102,6 +126,7 @@ int JsonRpcClient::sendCommand(const QString &method, const QVariantMap &params,
int JsonRpcClient::sendCommand(const QString &method, QObject *caller, const QString &callbackMethod) int JsonRpcClient::sendCommand(const QString &method, QObject *caller, const QString &callbackMethod)
{ {
return sendCommand(method, QVariantMap(), caller, callbackMethod); return sendCommand(method, QVariantMap(), caller, callbackMethod);
} }
@ -138,7 +163,7 @@ void JsonRpcClient::getCloudConnectionStatus()
sendRequest(reply->requestMap()); sendRequest(reply->requestMap());
} }
void JsonRpcClient::setNotificationsEnabledResponse(const QVariantMap &params) void JsonRpcClient::setNotificationsEnabledResponse(int /*commandId*/, const QVariantMap &params)
{ {
qDebug() << "Notifications enabled:" << params; qDebug() << "Notifications enabled:" << params;
@ -187,28 +212,28 @@ void JsonRpcClient::notificationReceived(const QVariantMap &data)
qDebug() << "JsonRpcClient: Unhandled notification received" << 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<CloudConnectionState>(); QMetaEnum connectionStateEnum = QMetaEnum::fromType<CloudConnectionState>();
m_cloudConnectionState = static_cast<CloudConnectionState>(connectionStateEnum.keyToValue(data.value("params").toMap().value("connectionState").toByteArray().data())); m_cloudConnectionState = static_cast<CloudConnectionState>(connectionStateEnum.keyToValue(data.value("connectionState").toByteArray().data()));
emit cloudConnectionStateChanged(); 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_serverQtVersion = data.value("qtVersion").toString();
m_serverQtBuildVersion = data.value("params").toMap().value("qtBuildVersion").toString(); m_serverQtBuildVersion = data.value("qtBuildVersion").toString();
if (!m_serverQtVersion.isEmpty()) { if (!m_serverQtVersion.isEmpty()) {
emit serverQtVersionChanged(); emit serverQtVersionChanged();
} }
@ -287,6 +312,11 @@ void JsonRpcClient::deployCertificate(const QByteArray &rootCA, const QByteArray
sendCommand("JSONRPC.SetupCloudConnection", params, this, "deployCertificateReply"); sendCommand("JSONRPC.SetupCloudConnection", params, this, "deployCertificateReply");
} }
QHash<QString, QString> JsonRpcClient::cacheHashes() const
{
return m_cacheHashes;
}
QString JsonRpcClient::serverVersion() const QString JsonRpcClient::serverVersion() const
{ {
return m_serverVersion; return m_serverVersion;
@ -353,13 +383,13 @@ int JsonRpcClient::requestPushButtonAuth(const QString &deviceName)
return reply->commandId(); return reply->commandId();
} }
void JsonRpcClient::setupRemoteAccess(const QString &idToken, const QString &userId) int JsonRpcClient::setupRemoteAccess(const QString &idToken, const QString &userId)
{ {
qDebug() << "Calling SetupRemoteAccess"; qDebug() << "Calling SetupRemoteAccess";
QVariantMap params; QVariantMap params;
params.insert("idToken", idToken); params.insert("idToken", idToken);
params.insert("userId", userId); params.insert("userId", userId);
sendCommand("JSONRPC.SetupRemoteAccess", params, this, "setupRemoteAccessReply"); return sendCommand("JSONRPC.SetupRemoteAccess", params, this, "setupRemoteAccessReply");
} }
bool JsonRpcClient::ensureServerVersion(const QString &jsonRpcVersion) bool JsonRpcClient::ensureServerVersion(const QString &jsonRpcVersion)
@ -367,11 +397,11 @@ bool JsonRpcClient::ensureServerVersion(const QString &jsonRpcVersion)
return QVersionNumber(m_jsonRpcVersion) >= QVersionNumber::fromString(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"; qDebug() << "authentication successful";
m_token = data.value("params").toMap().value("token").toByteArray(); m_token = data.value("token").toByteArray();
QSettings settings; QSettings settings;
settings.beginGroup("jsonTokens"); settings.beginGroup("jsonTokens");
settings.setValue(m_serverUuid, m_token); 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; 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(); emit createUserSucceeded();
m_initialSetupRequired = false; m_initialSetupRequired = false;
emit initialSetupRequiredChanged(); emit initialSetupRequiredChanged();
} else { } else {
qDebug() << "Emitting create user failed"; 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; qDebug() << "requestPushButtonAuth response" << data;
if (data.value("status").toString() == "success" && data.value("params").toMap().value("success").toBool()) { if (data.value("success").toBool()) {
m_pendingPushButtonTransaction = data.value("params").toMap().value("transactionId").toInt(); m_pendingPushButtonTransaction = data.value("transactionId").toInt();
} else { } else {
emit pushButtonAuthFailed(); emit pushButtonAuthFailed();
} }
@ -449,7 +479,7 @@ void JsonRpcClient::sendRequest(const QVariantMap &request)
{ {
QVariantMap newRequest = request; QVariantMap newRequest = request;
newRequest.insert("token", m_token); 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"); 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) void JsonRpcClient::dataReceived(const QByteArray &data)
{ {
// qDebug() << "JsonRpcClient: received data:" << qUtf8Printable(data); // qDebug() << "JsonRpcClient: received data:" << qUtf8Printable(data);
m_receiveBuffer.append(data); m_receiveBuffer.append(data);
int splitIndex = m_receiveBuffer.indexOf("}\n{") + 1; int splitIndex = m_receiveBuffer.indexOf("}\n{") + 1;
@ -516,10 +546,10 @@ void JsonRpcClient::dataReceived(const QByteArray &data)
QJsonParseError error; QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(m_receiveBuffer.left(splitIndex), &error); QJsonDocument jsonDoc = QJsonDocument::fromJson(m_receiveBuffer.left(splitIndex), &error);
if (error.error != QJsonParseError::NoError) { 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; 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); m_receiveBuffer = m_receiveBuffer.right(m_receiveBuffer.length() - splitIndex - 1);
if (!m_receiveBuffer.isEmpty()) { if (!m_receiveBuffer.isEmpty()) {
staticMetaObject.invokeMethod(this, "dataReceived", Qt::QueuedConnection, Q_ARG(QByteArray, QByteArray())); 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 // check if this is a notification
if (dataMap.contains("notification")) { if (dataMap.contains("notification")) {
// qDebug() << "Incoming notification:" << jsonDoc.toJson(); // qDebug() << "Incoming notification:" << jsonDoc.toJson();
QStringList notification = dataMap.value("notification").toString().split("."); QStringList notification = dataMap.value("notification").toString().split(".");
QString nameSpace = notification.first(); QString nameSpace = notification.first();
foreach (JsonHandler *handler, m_notificationHandlers.values(nameSpace)) { foreach (JsonHandler *handler, m_notificationHandlers.values(nameSpace)) {
@ -543,7 +573,7 @@ void JsonRpcClient::dataReceived(const QByteArray &data)
JsonRpcReply *reply = m_replies.take(commandId); JsonRpcReply *reply = m_replies.take(commandId);
if (reply) { if (reply) {
reply->deleteLater(); 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") { if (dataMap.value("status").toString() == "unauthorized") {
qWarning() << "Something's off with the token"; qWarning() << "Something's off with the token";
@ -558,106 +588,134 @@ void JsonRpcClient::dataReceived(const QByteArray &data)
emit authenticatedChanged(); 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()) { 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()); 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; return;
} }
} }
void JsonRpcClient::helloReply(const QVariantMap &params) void JsonRpcClient::helloReply(int /*commandId*/, const QVariantMap &params)
{ {
if (params.value("status").toString() == "error") { m_initialSetupRequired = params.value("initialSetupRequired").toBool();
qWarning() << "Hello call failed. Trying again without locale"; m_authenticationRequired = params.value("authenticationRequired").toBool();
m_id = 0; m_pushButtonAuthAvailable = params.value("pushButtonAuthAvailable").toBool();
sendCommand("JSONRPC.Hello", QVariantMap(), this, "helloReply"); emit pushButtonAuthAvailableChanged();
} 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_serverUuid = dataMap.value("uuid").toString(); m_serverUuid = params.value("uuid").toString();
m_serverVersion = dataMap.value("version").toString(); m_serverVersion = params.value("version").toString();
QString protoVersionString = dataMap.value("protocol version").toString(); QString protoVersionString = params.value("protocol version").toString();
if (!protoVersionString.contains('.')) { if (!protoVersionString.contains('.')) {
protoVersionString.prepend("0."); 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); QVersionNumber minimumRequiredVersion = QVersionNumber(1, 10);
if (m_jsonRpcVersion < minimumRequiredVersion) { if (m_jsonRpcVersion < minimumRequiredVersion) {
qWarning() << "Nymea core doesn't support minimum required version. Required:" << minimumRequiredVersion << "Found:" << m_jsonRpcVersion; qWarning() << "Nymea core doesn't support minimum required version. Required:" << minimumRequiredVersion << "Found:" << m_jsonRpcVersion;
m_connection->disconnect(); m_connection->disconnect();
emit invalidProtocolVersion(m_jsonRpcVersion.toString(), minimumRequiredVersion.toString()); emit invalidProtocolVersion(m_jsonRpcVersion.toString(), minimumRequiredVersion.toString());
return; return;
} }
// Verify SSL certificate // Verify SSL certificate
if (m_connection->isEncrypted()) { if (m_connection->isEncrypted()) {
QByteArray pem; QByteArray pem;
if (!loadPem(m_serverUuid, pem)) { if (!loadPem(m_serverUuid, pem)) {
qDebug() << "No SSL certificate for this host stored. Accepting and pinning new certificate."; qDebug() << "No SSL certificate for this host stored. Accepting and pinning new certificate.";
// No certificate yet! Inform ui about it. // No certificate yet! Inform ui about it.
emit newSslCertificate(); emit newSslCertificate();
storePem(m_serverUuid, m_connection->sslCertificate().toPem()); storePem(m_serverUuid, m_connection->sslCertificate().toPem());
} else { } else {
// We have a certificate pinned already. Check if it's the same // We have a certificate pinned already. Check if it's the same
if (m_connection->sslCertificate().toPem() != pem) { if (m_connection->sslCertificate().toPem() != pem) {
// Uh oh, the certificate has changed // Uh oh, the certificate has changed
qWarning() << "This connections certificate has changed!"; qWarning() << "This connections certificate has changed!";
QSslCertificate certificate = m_connection->sslCertificate(); QSslCertificate certificate = m_connection->sslCertificate();
QVariantMap issuerInfo = certificateIssuerInfo(); QVariantMap issuerInfo = certificateIssuerInfo();
emit verifyConnectionCertificate(m_serverUuid, issuerInfo, certificate.toPem()); emit verifyConnectionCertificate(m_serverUuid, issuerInfo, certificate.toPem());
// Reject the connection until the UI explicitly accepts this... // Reject the connection until the UI explicitly accepts this...
m_connection->disconnectFromHost(); 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; return;
} }
qDebug() << "This connections certificate is trusted.";
}
}
m_authenticated = true; m_cacheHashes.clear();
emit authenticatedChanged(); 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(); m_authenticated = true;
getCloudConnectionStatus(); emit authenticatedChanged();
} }
setNotificationsEnabled();
getCloudConnectionStatus();
} }
JsonRpcReply::JsonRpcReply(int commandId, QString nameSpace, QString method, QVariantMap params, QPointer<QObject> caller, const QString &callback): JsonRpcReply::JsonRpcReply(int commandId, QString nameSpace, QString method, QVariantMap params, QPointer<QObject> caller, const QString &callback):

22
libnymea-app/jsonrpc/jsonrpcclient.h
View File

@ -94,6 +94,7 @@ public:
bool authenticated() const; bool authenticated() const;
CloudConnectionState cloudConnectionState() const; CloudConnectionState cloudConnectionState() const;
void deployCertificate(const QByteArray &rootCA, const QByteArray &certificate, const QByteArray &publicKey, const QByteArray &privateKey, const QString &endpoint); void deployCertificate(const QByteArray &rootCA, const QByteArray &certificate, const QByteArray &publicKey, const QByteArray &privateKey, const QString &endpoint);
QHash<QString, QString> cacheHashes() const;
QString serverVersion() const; QString serverVersion() const;
QString jsonRpcVersion() const; QString jsonRpcVersion() const;
@ -111,7 +112,7 @@ public:
Q_INVOKABLE int createUser(const QString &username, const QString &password); 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 authenticate(const QString &username, const QString &password, const QString &deviceName);
Q_INVOKABLE int requestPushButtonAuth(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: signals:
@ -142,7 +143,7 @@ private slots:
void onInterfaceConnectedChanged(bool connected); void onInterfaceConnectedChanged(bool connected);
void dataReceived(const QByteArray &data); void dataReceived(const QByteArray &data);
void helloReply(const QVariantMap &params); void helloReply(int commandId, const QVariantMap &params);
private: private:
int m_id; int m_id;
@ -168,21 +169,22 @@ private:
QString m_serverQtBuildVersion; QString m_serverQtBuildVersion;
QByteArray m_token; QByteArray m_token;
QByteArray m_receiveBuffer; QByteArray m_receiveBuffer;
QHash<QString, QString> m_cacheHashes;
void setNotificationsEnabled(); void setNotificationsEnabled();
void getCloudConnectionStatus(); void getCloudConnectionStatus();
// json handler // json handler
Q_INVOKABLE void processAuthenticate(const QVariantMap &data); Q_INVOKABLE void processAuthenticate(int commandId, const QVariantMap &data);
Q_INVOKABLE void processCreateUser(const QVariantMap &data); Q_INVOKABLE void processCreateUser(int commandId, const QVariantMap &data);
Q_INVOKABLE void processRequestPushButtonAuth(const QVariantMap &data); Q_INVOKABLE void processRequestPushButtonAuth(int commandId, const QVariantMap &data);
Q_INVOKABLE void setNotificationsEnabledResponse(const QVariantMap &params); Q_INVOKABLE void setNotificationsEnabledResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void notificationReceived(const QVariantMap &data); Q_INVOKABLE void notificationReceived(const QVariantMap &data);
Q_INVOKABLE void isCloudConnectedReply(const QVariantMap &data); Q_INVOKABLE void isCloudConnectedReply(int commandId, const QVariantMap &data);
Q_INVOKABLE void setupRemoteAccessReply(const QVariantMap &data); Q_INVOKABLE void setupRemoteAccessReply(int commandId, const QVariantMap &data);
Q_INVOKABLE void deployCertificateReply(const QVariantMap &data); Q_INVOKABLE void deployCertificateReply(int commandId, const QVariantMap &data);
Q_INVOKABLE void getVersionsReply(const QVariantMap &data); Q_INVOKABLE void getVersionsReply(int commandId, const QVariantMap &data);
void sendRequest(const QVariantMap &request); void sendRequest(const QVariantMap &request);

8
libnymea-app/models/logsmodel.cpp
View File

@ -205,15 +205,15 @@ LogEntry *LogsModel::get(int index) const
return nullptr; 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 offset = data.value("offset").toInt();
int count = data.value("params").toMap().value("count").toInt(); int count = data.value("count").toInt();
// qDebug() << qUtf8Printable(QJsonDocument::fromVariant(data).toJson()); // qDebug() << qUtf8Printable(QJsonDocument::fromVariant(data).toJson());
QList<LogEntry*> newBlock; QList<LogEntry*> newBlock;
QList<QVariant> logEntries = data.value("params").toMap().value("logEntries").toList(); QList<QVariant> logEntries = data.value("logEntries").toList();
foreach (const QVariant &logEntryVariant, logEntries) { foreach (const QVariant &logEntryVariant, logEntries) {
QVariantMap entryMap = logEntryVariant.toMap(); QVariantMap entryMap = logEntryVariant.toMap();
QDateTime timeStamp = QDateTime::fromMSecsSinceEpoch(entryMap.value("timestamp").toLongLong()); QDateTime timeStamp = QDateTime::fromMSecsSinceEpoch(entryMap.value("timestamp").toLongLong());

2
libnymea-app/models/logsmodel.h
View File

@ -112,7 +112,7 @@ signals:
void logEntryAdded(LogEntry *entry); void logEntryAdded(LogEntry *entry);
private slots: private slots:
virtual void logsReply(const QVariantMap &data); virtual void logsReply(int commandId, const QVariantMap &data);
void newLogEntryReceived(const QVariantMap &data); void newLogEntryReceived(const QVariantMap &data);
protected: protected:

8
libnymea-app/models/logsmodelng.cpp
View File

@ -237,15 +237,15 @@ LogEntry *LogsModelNg::get(int index) const
return nullptr; 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 offset = data.value("offset").toInt();
int count = data.value("params").toMap().value("count").toInt(); int count = data.value("count").toInt();
// qDebug() << qUtf8Printable(QJsonDocument::fromVariant(data).toJson()); // qDebug() << qUtf8Printable(QJsonDocument::fromVariant(data).toJson());
QList<LogEntry*> newBlock; QList<LogEntry*> newBlock;
QList<QVariant> logEntries = data.value("params").toMap().value("logEntries").toList(); QList<QVariant> logEntries = data.value("logEntries").toList();
foreach (const QVariant &logEntryVariant, logEntries) { foreach (const QVariant &logEntryVariant, logEntries) {
QVariantMap entryMap = logEntryVariant.toMap(); QVariantMap entryMap = logEntryVariant.toMap();
QDateTime timeStamp = QDateTime::fromMSecsSinceEpoch(entryMap.value("timestamp").toLongLong()); QDateTime timeStamp = QDateTime::fromMSecsSinceEpoch(entryMap.value("timestamp").toLongLong());

2
libnymea-app/models/logsmodelng.h
View File

@ -129,7 +129,7 @@ signals:
private slots: private slots:
void newLogEntryReceived(const QVariantMap &data); void newLogEntryReceived(const QVariantMap &data);
void logsReply(const QVariantMap &data); void logsReply(int commandId, const QVariantMap &data);
private: private:
QList<LogEntry*> m_list; QList<LogEntry*> m_list;

1
libnymea-app/models/tagsproxymodel.cpp
View File

@ -48,7 +48,6 @@ void TagsProxyModel::setTags(Tags *tags)
m_tags = tags; m_tags = tags;
setSourceModel(tags); setSourceModel(tags);
connect(tags, &Tags::countChanged, this, [=](){ connect(tags, &Tags::countChanged, this, [=](){
qWarning() << "Tag count changed!";
invalidateFilter(); invalidateFilter();
emit countChanged(); emit countChanged();
}, Qt::QueuedConnection); }, Qt::QueuedConnection);

52
libnymea-app/rulemanager.cpp
View File

@ -96,26 +96,25 @@ int RuleManager::addRule(Rule *rule)
return m_jsonClient->sendCommand("Rules.AddRule", params, this, "onAddRuleReply"); return m_jsonClient->sendCommand("Rules.AddRule", params, this, "onAddRuleReply");
} }
void RuleManager::removeRule(const QUuid &ruleId) int RuleManager::removeRule(const QUuid &ruleId)
{ {
QVariantMap params; QVariantMap params;
params.insert("ruleId", ruleId); 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); QVariantMap params = packRule(rule);
qWarning() << "Packed rule:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented)); 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; QVariantMap params;
params.insert("ruleId", ruleId); 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 &params) void RuleManager::handleRulesNotification(const QVariantMap &params)
@ -153,14 +152,10 @@ void RuleManager::handleRulesNotification(const QVariantMap &params)
} }
} }
void RuleManager::getRulesReply(const QVariantMap &params) void RuleManager::getRulesReply(int /*commandId*/, const QVariantMap &params)
{ {
if (params.value("status").toString() != "success") {
qWarning() << "Error getting rules:" << params.value("error").toString();
return;
}
// qDebug() << "Get Rules reply" << params; // 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(); QUuid ruleId = ruleDescriptionVariant.toMap().value("id").toUuid();
QString name = ruleDescriptionVariant.toMap().value("name").toString(); QString name = ruleDescriptionVariant.toMap().value("name").toString();
bool enabled = ruleDescriptionVariant.toMap().value("enabled").toBool(); bool enabled = ruleDescriptionVariant.toMap().value("enabled").toBool();
@ -180,9 +175,9 @@ void RuleManager::getRulesReply(const QVariantMap &params)
} }
} }
void RuleManager::getRuleDetailsReply(const QVariantMap &params) void RuleManager::getRuleDetailsReply(int commandId, const QVariantMap &params)
{ {
QVariantMap ruleMap = params.value("params").toMap().value("rule").toMap(); QVariantMap ruleMap = params.value("rule").toMap();
Rule* rule = m_rules->getRule(ruleMap.value("id").toUuid()); Rule* rule = m_rules->getRule(ruleMap.value("id").toUuid());
if (!rule) { if (!rule) {
qWarning() << "Got rule details for a rule we don't know"; qWarning() << "Got rule details for a rule we don't know";
@ -197,36 +192,33 @@ void RuleManager::getRuleDetailsReply(const QVariantMap &params)
// qDebug() << "Rule JSON:" << qUtf8Printable(QJsonDocument::fromVariant(ruleMap).toJson()); // qDebug() << "Rule JSON:" << qUtf8Printable(QJsonDocument::fromVariant(ruleMap).toJson());
} }
void RuleManager::onAddRuleReply(const QVariantMap &params) void RuleManager::onAddRuleReply(int commandId, const QVariantMap &params)
{ {
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()); qWarning() << "Failed to add rule:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson());
} else { } 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 &params) void RuleManager::removeRuleReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Have remove rule reply" << params; qDebug() << "Have remove rule reply" << commandId << params;
} }
void RuleManager::onEditRuleReply(const QVariantMap &params) void RuleManager::onEditRuleReply(int commandId, const QVariantMap &params)
{ {
if (params.value("status").toString() == "error") { if (params.value("ruleError").toString() != "RuleErrorNoError") {
qDebug() << "Bad request editing rule:" << params.value("error").toString(); qDebug() << "Bad rule:" << params.value("ruleError").toString();
} }
if (params.value("params").toMap().value("ruleError").toString() != "RuleErrorNoError") { emit editRuleReply(commandId, params.value("ruleError").toString());
qDebug() << "Bad rule:" << params.value("params").toMap().value("ruleError").toString();
}
emit editRuleReply(params.value("params").toMap().value("ruleError").toString());
} }
void RuleManager::onExecuteRuleActionsReply(const QVariantMap &params) void RuleManager::onExecuteRuleActionsReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "Execute rule actions reply:" << params; qDebug() << "Execute rule actions reply:" << commandId << params;
} }
Rule *RuleManager::parseRule(const QVariantMap &ruleMap) Rule *RuleManager::parseRule(const QVariantMap &ruleMap)

20
libnymea-app/rulemanager.h
View File

@ -65,18 +65,18 @@ public:
Q_INVOKABLE int addRule(const QVariantMap params); Q_INVOKABLE int addRule(const QVariantMap params);
Q_INVOKABLE int addRule(Rule *rule); Q_INVOKABLE int addRule(Rule *rule);
Q_INVOKABLE void removeRule(const QUuid &ruleId); Q_INVOKABLE int removeRule(const QUuid &ruleId);
Q_INVOKABLE void editRule(Rule *rule); Q_INVOKABLE int editRule(Rule *rule);
Q_INVOKABLE void executeActions(const QString &ruleId); Q_INVOKABLE int executeActions(const QString &ruleId);
private slots: private slots:
void handleRulesNotification(const QVariantMap &params); void handleRulesNotification(const QVariantMap &params);
void getRulesReply(const QVariantMap &params); void getRulesReply(int commandId, const QVariantMap &params);
void getRuleDetailsReply(const QVariantMap &params); void getRuleDetailsReply(int commandId, const QVariantMap &params);
void onAddRuleReply(const QVariantMap &params); void onAddRuleReply(int commandId, const QVariantMap &params);
void removeRuleReply(const QVariantMap &params); void removeRuleReply(int commandId, const QVariantMap &params);
void onEditRuleReply(const QVariantMap &params); void onEditRuleReply(int commandId, const QVariantMap &params);
void onExecuteRuleActionsReply(const QVariantMap &params); void onExecuteRuleActionsReply(int commandId, const QVariantMap &params);
private: private:
Rule *parseRule(const QVariantMap &ruleMap); Rule *parseRule(const QVariantMap &ruleMap);
@ -98,7 +98,7 @@ private:
signals: signals:
void addRuleReply(int commandId, const QString &ruleError, const QString &ruleId); void addRuleReply(int commandId, const QString &ruleError, const QString &ruleId);
void editRuleReply(const QString &ruleError); void editRuleReply(int commandId, const QString &ruleError);
private: private:
JsonRpcClient *m_jsonClient; JsonRpcClient *m_jsonClient;

43
libnymea-app/scriptmanager.cpp
View File

@ -96,9 +96,9 @@ int ScriptManager::fetchScript(const QUuid &id)
return m_client->sendCommand("Scripts.GetScriptContent", params, this, "onScriptFetched"); return m_client->sendCommand("Scripts.GetScriptContent", params, this, "onScriptFetched");
} }
void ScriptManager::onScriptsFetched(const QVariantMap &params) void ScriptManager::onScriptsFetched(int /*commandId*/, const QVariantMap &params)
{ {
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(); QUuid id = variant.toMap().value("id").toUuid();
Script *script = new Script(id); Script *script = new Script(id);
script->setName(variant.toMap().value("name").toString()); script->setName(variant.toMap().value("name").toString());
@ -106,38 +106,38 @@ void ScriptManager::onScriptsFetched(const QVariantMap &params)
} }
} }
void ScriptManager::onScriptFetched(const QVariantMap &params) void ScriptManager::onScriptFetched(int commandId, const QVariantMap &params)
{ {
emit fetchScriptReply(params.value("id").toInt(), emit fetchScriptReply(commandId,
params.value("params").toMap().value("scriptError").toString(), params.value("scriptError").toString(),
params.value("params").toMap().value("content").toString()); params.value("content").toString());
} }
void ScriptManager::onScriptAdded(const QVariantMap &params) void ScriptManager::onScriptAdded(int commandId, const QVariantMap &params)
{ {
emit addScriptReply(params.value("id").toInt(), emit addScriptReply(commandId,
params.value("params").toMap().value("scriptError").toString(), params.value("scriptError").toString(),
params.value("params").toMap().value("script").toMap().value("id").toUuid(), params.value("script").toMap().value("id").toUuid(),
params.value("params").toMap().value("errors").toStringList()); params.value("errors").toStringList());
} }
void ScriptManager::onScriptEdited(const QVariantMap &params) void ScriptManager::onScriptEdited(int commandId, const QVariantMap &params)
{ {
emit editScriptReply(params.value("id").toInt(), emit editScriptReply(commandId,
params.value("params").toMap().value("scriptError").toString(), params.value("scriptError").toString(),
params.value("params").toMap().value("errors").toStringList()); params.value("errors").toStringList());
} }
void ScriptManager::onScriptRenamed(const QVariantMap &params) void ScriptManager::onScriptRenamed(int commandId, const QVariantMap &params)
{ {
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 &params) void ScriptManager::onScriptRemoved(int commandId, const QVariantMap &params)
{ {
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 &params) void ScriptManager::onNotificationReceived(const QVariantMap &params)
@ -154,16 +154,11 @@ void ScriptManager::onNotificationReceived(const QVariantMap &params)
Script *script = new Script(scriptMap.value("id").toUuid()); Script *script = new Script(scriptMap.value("id").toUuid());
script->setName(scriptMap.value("name").toString()); script->setName(scriptMap.value("name").toString());
m_scripts->addScript(script); 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") { else if (params.value("notification").toString() == "Scripts.ScriptRemoved") {
QUuid id = params.value("params").toMap().value("id").toUuid(); QUuid id = params.value("params").toMap().value("id").toUuid();
m_scripts->removeScript(id); 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") { else if (params.value("notification").toString() == "Scripts.ScriptChanged") {

12
libnymea-app/scriptmanager.h
View File

@ -68,12 +68,12 @@ signals:
void scriptMessage(const QUuid &scriptId, const QString &type, const QString &message); void scriptMessage(const QUuid &scriptId, const QString &type, const QString &message);
private slots: private slots:
void onScriptsFetched(const QVariantMap &params); void onScriptsFetched(int commandId, const QVariantMap &params);
void onScriptFetched(const QVariantMap &params); void onScriptFetched(int commandId, const QVariantMap &params);
void onScriptAdded(const QVariantMap &params); void onScriptAdded(int commandId, const QVariantMap &params);
void onScriptEdited(const QVariantMap &params); void onScriptEdited(int commandId, const QVariantMap &params);
void onScriptRenamed(const QVariantMap &params); void onScriptRenamed(int commandId, const QVariantMap &params);
void onScriptRemoved(const QVariantMap &params); void onScriptRemoved(int commandId, const QVariantMap &params);
void onNotificationReceived(const QVariantMap &params); void onNotificationReceived(const QVariantMap &params);
private: private:

79
libnymea-app/system/systemcontroller.cpp
View File

@ -152,13 +152,13 @@ QDateTime SystemController::serverTime() const
return m_serverTime; return m_serverTime;
} }
void SystemController::setServerTime(const QDateTime &serverTime) int SystemController::setServerTime(const QDateTime &serverTime)
{ {
QVariantMap params; QVariantMap params;
params.insert("automaticTime", false); params.insert("automaticTime", false);
params.insert("time", serverTime.toSecsSinceEpoch()); params.insert("time", serverTime.toSecsSinceEpoch());
params.insert("timeZone", serverTime.timeZone().id()); 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 QStringList SystemController::timeZones() const
@ -179,11 +179,11 @@ QString SystemController::serverTimeZone() const
return m_serverTimeZone; return m_serverTimeZone;
} }
void SystemController::setServerTimeZone(const QString &serverTimeZone) int SystemController::setServerTimeZone(const QString &serverTimeZone)
{ {
QVariantMap params; QVariantMap params;
params.insert("timeZone", serverTimeZone); 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 bool SystemController::automaticTimeAvailable() const
@ -196,22 +196,22 @@ bool SystemController::automaticTime() const
return m_automaticTime; return m_automaticTime;
} }
void SystemController::setAutomaticTime(bool automaticTime) int SystemController::setAutomaticTime(bool automaticTime)
{ {
QVariantMap params; QVariantMap params;
params.insert("automaticTime", automaticTime); 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(); emit powerManagementAvailableChanged();
m_updateManagementAvailable = data.value("params").toMap().value("updateManagement").toBool(); m_updateManagementAvailable = data.value("updateManagement").toBool();
emit updateManagementAvailableChanged(); emit updateManagementAvailableChanged();
m_timeManagementAvailable = data.value("params").toMap().value("timeManagement").toBool(); m_timeManagementAvailable = data.value("timeManagement").toBool();
emit timeManagementAvailableChanged(); emit timeManagementAvailableChanged();
if (m_updateManagementAvailable) { 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; 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_updateManagementBusy = data.value("busy").toBool();
m_updateRunning = data.value("params").toMap().value("updateRunning").toBool(); m_updateRunning = data.value("updateRunning").toBool();
emit updateRunningChanged(); 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 id = packageVariant.toMap().value("id").toString();
QString displayName = packageVariant.toMap().value("displayName").toString(); QString displayName = packageVariant.toMap().value("displayName").toString();
Package *p = new Package(id, displayName); 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 id = repoVariant.toMap().value("id").toString();
QString displayName = repoVariant.toMap().value("displayName").toString(); QString displayName = repoVariant.toMap().value("displayName").toString();
Repository *repo = new Repository(id, displayName); Repository *repo = new Repository(id, displayName);
@ -262,61 +262,58 @@ void SystemController::getRepositoriesResponse(const QVariantMap &data)
} }
} }
void SystemController::removePackageResponse(const QVariantMap &params) void SystemController::removePackageResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Remove result" << params; qDebug() << "Remove result" << commandId << params;
} }
void SystemController::enableRepositoryResponse(const QVariantMap &params) void SystemController::enableRepositoryResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "Enable repo response" << params; 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 &params) void SystemController::getServerTimeResponse(int commandId, const QVariantMap &params)
{ {
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 // 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 // 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 // https://bugreports.qt.io/browse/QTBUG-83438
// m_serverTime.setTimeZone(QTimeZone(params.value("params").toMap().value("timeZone").toString().toUtf8())); // m_serverTime.setTimeZone(QTimeZone(params.value("timeZone").toString().toUtf8()));
m_serverTimeZone = params.value("params").toMap().value("timeZone").toString(); m_serverTimeZone = params.value("timeZone").toString();
emit serverTimeChanged(); emit serverTimeChanged();
emit serverTimeZoneChanged(); emit serverTimeZoneChanged();
m_automaticTimeAvailable = params.value("params").toMap().value("automaticTimeAvailable").toBool(); m_automaticTimeAvailable = params.value("automaticTimeAvailable").toBool();
emit automaticTimeAvailableChanged(); emit automaticTimeAvailableChanged();
m_automaticTime = params.value("params").toMap().value("automaticTime").toBool(); m_automaticTime = params.value("automaticTime").toBool();
emit automaticTimeChanged(); emit automaticTimeChanged();
qDebug() << "Server time:" << m_serverTime << "Automatic Time available:" << m_automaticTimeAvailable << "Automatic time:" << m_automaticTime; qDebug() << "Server time:" << m_serverTime << "Automatic Time available:" << m_automaticTimeAvailable << "Automatic time:" << m_automaticTime;
} }
void SystemController::setTimeResponse(const QVariantMap &params) void SystemController::setTimeResponse(int commandId, const QVariantMap &params)
{ {
qDebug() << "set time response" << params; qDebug() << "set time response" << commandId << params;
} }
void SystemController::restartResponse(const QVariantMap &params) void SystemController::restartResponse(int commandId, const QVariantMap &params)
{ {
int id = params.value("id").toInt(); bool success = params.value("success").toBool();
bool success = params.value("params").toMap().value("success").toBool(); emit restartReply(commandId, success);
emit restartReply(id, success);
} }
void SystemController::rebootResponse(const QVariantMap &params) void SystemController::rebootResponse(int commandId, const QVariantMap &params)
{ {
int id = params.value("id").toInt(); bool success = params.value("success").toBool();
bool success = params.value("params").toMap().value("success").toBool(); emit rebootReply(commandId, success);
emit rebootReply(id, success);
} }
void SystemController::shutdownResponse(const QVariantMap &params) void SystemController::shutdownResponse(int commandId, const QVariantMap &params)
{ {
int id = params.value("id").toInt(); bool success = params.value("success").toBool();
bool success = params.value("params").toMap().value("success").toBool(); emit shutdownReply(commandId, success);
emit shutdownReply(id, success);
} }
void SystemController::notificationReceived(const QVariantMap &data) void SystemController::notificationReceived(const QVariantMap &data)

28
libnymea-app/system/systemcontroller.h
View File

@ -80,13 +80,13 @@ public:
bool timeManagementAvailable() const; bool timeManagementAvailable() const;
QDateTime serverTime() const; QDateTime serverTime() const;
void setServerTime(const QDateTime &serverTime); int setServerTime(const QDateTime &serverTime);
QStringList timeZones() const; QStringList timeZones() const;
QString serverTimeZone() const; QString serverTimeZone() const;
void setServerTimeZone(const QString &serverTimeZone); int setServerTimeZone(const QString &serverTimeZone);
bool automaticTimeAvailable() const; bool automaticTimeAvailable() const;
bool automaticTime() const; bool automaticTime() const;
void setAutomaticTime(bool automaticTime); int setAutomaticTime(bool automaticTime);
signals: signals:
void powerManagementAvailableChanged(); void powerManagementAvailableChanged();
@ -105,17 +105,17 @@ signals:
void shutdownReply(int id, bool success); void shutdownReply(int id, bool success);
private slots: private slots:
void getCapabilitiesResponse(const QVariantMap &data); void getCapabilitiesResponse(int commandId, const QVariantMap &data);
void getUpdateStatusResponse(const QVariantMap &data); void getUpdateStatusResponse(int commandId, const QVariantMap &data);
void getPackagesResponse(const QVariantMap &data); void getPackagesResponse(int commandId, const QVariantMap &data);
void getRepositoriesResponse(const QVariantMap &data); void getRepositoriesResponse(int commandId, const QVariantMap &data);
void removePackageResponse(const QVariantMap &params); void removePackageResponse(int commandId, const QVariantMap &params);
void enableRepositoryResponse(const QVariantMap &params); void enableRepositoryResponse(int commandId, const QVariantMap &params);
void getServerTimeResponse(const QVariantMap &params); void getServerTimeResponse(int commandId, const QVariantMap &params);
void setTimeResponse(const QVariantMap &params); void setTimeResponse(int commandId, const QVariantMap &params);
void restartResponse(const QVariantMap &params); void restartResponse(int commandId, const QVariantMap &params);
void rebootResponse(const QVariantMap &params); void rebootResponse(int commandId, const QVariantMap &params);
void shutdownResponse(const QVariantMap &params); void shutdownResponse(int commandId, const QVariantMap &params);
void notificationReceived(const QVariantMap &data); void notificationReceived(const QVariantMap &data);

28
libnymea-app/tagsmanager.cpp
View File

@ -68,7 +68,7 @@ Tags *TagsManager::tags() const
return m_tags; 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 params;
QVariantMap tag; QVariantMap tag;
@ -77,10 +77,10 @@ void TagsManager::tagDevice(const QString &deviceId, const QString &tagId, const
tag.insert("tagId", tagId); tag.insert("tagId", tagId);
tag.insert("value", value); tag.insert("value", value);
params.insert("tag", tag); 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 params;
QVariantMap tag; QVariantMap tag;
@ -88,10 +88,10 @@ void TagsManager::untagDevice(const QString &deviceId, const QString &tagId)
tag.insert("appId", "nymea:app"); tag.insert("appId", "nymea:app");
tag.insert("tagId", tagId); tag.insert("tagId", tagId);
params.insert("tag", tag); 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 params;
QVariantMap tag; QVariantMap tag;
@ -100,10 +100,10 @@ void TagsManager::tagRule(const QString &ruleId, const QString &tagId, const QSt
tag.insert("tagId", tagId); tag.insert("tagId", tagId);
tag.insert("value", value); tag.insert("value", value);
params.insert("tag", tag); 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 params;
QVariantMap tag; QVariantMap tag;
@ -111,7 +111,7 @@ void TagsManager::untagRule(const QString &ruleId, const QString &tagId)
tag.insert("appId", "nymea:app"); tag.insert("appId", "nymea:app");
tag.insert("tagId", tagId); tag.insert("tagId", tagId);
params.insert("tag", tag); 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 &params) void TagsManager::handleTagsNotification(const QVariantMap &params)
@ -164,10 +164,10 @@ void TagsManager::handleTagsNotification(const QVariantMap &params)
} }
} }
void TagsManager::getTagsReply(const QVariantMap &params) void TagsManager::getTagsReply(int /*commandId*/, const QVariantMap &params)
{ {
QList<Tag*> tags; QList<Tag*> 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()); Tag *tag = unpackTag(tagVariant.toMap());
if (tag) { if (tag) {
tags.append(tag); tags.append(tag);
@ -179,14 +179,14 @@ void TagsManager::getTagsReply(const QVariantMap &params)
emit busyChanged(); emit busyChanged();
} }
void TagsManager::addTagReply(const QVariantMap &params) void TagsManager::addTagReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "AddTag reply" << params; qDebug() << "AddTag reply" << commandId << params;
} }
void TagsManager::removeTagReply(const QVariantMap &params) void TagsManager::removeTagReply(int commandId, const QVariantMap &params)
{ {
qDebug() << "RemoveTag reply" << params; qDebug() << "RemoveTag reply" << commandId << params;
} }
Tag* TagsManager::unpackTag(const QVariantMap &tagMap) Tag* TagsManager::unpackTag(const QVariantMap &tagMap)

14
libnymea-app/tagsmanager.h
View File

@ -52,19 +52,19 @@ public:
Tags* tags() const; Tags* tags() const;
Q_INVOKABLE void tagDevice(const QString &deviceId, const QString &tagId, const QString &value); Q_INVOKABLE int tagDevice(const QString &deviceId, const QString &tagId, const QString &value);
Q_INVOKABLE void untagDevice(const QString &deviceId, const QString &tagId); Q_INVOKABLE int untagDevice(const QString &deviceId, const QString &tagId);
Q_INVOKABLE void tagRule(const QString &ruleId, const QString &tagId, const QString &value); Q_INVOKABLE int tagRule(const QString &ruleId, const QString &tagId, const QString &value);
Q_INVOKABLE void untagRule(const QString &ruleId, const QString &tagId); Q_INVOKABLE int untagRule(const QString &ruleId, const QString &tagId);
signals: signals:
void busyChanged(); void busyChanged();
private slots: private slots:
void handleTagsNotification(const QVariantMap &params); void handleTagsNotification(const QVariantMap &params);
void getTagsReply(const QVariantMap &params); void getTagsReply(int commandId, const QVariantMap &params);
void addTagReply(const QVariantMap &params); void addTagReply(int commandId, const QVariantMap &params);
void removeTagReply(const QVariantMap &params); void removeTagReply(int commandId, const QVariantMap &params);
private: private:
Tag *unpackTag(const QVariantMap &tagMap); Tag *unpackTag(const QVariantMap &tagMap);

8
libnymea-app/thinggroup.cpp
View File

@ -56,11 +56,11 @@ ThingGroup::ThingGroup(DeviceManager *deviceManager, DeviceClass *deviceClass, D
syncStates(); syncStates();
}); });
connect(m_thingManager, &DeviceManager::executeActionReply, this, [this](const QVariantMap &params){ connect(m_thingManager, &DeviceManager::executeActionReply, this, [this](int commandId, const QVariantMap &/*params*/){
int returningId = params.value("id").toInt(); // 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()) { foreach (int id, m_pendingActions.keys()) {
if (m_pendingActions.value(id).contains(returningId)) { if (m_pendingActions.value(id).contains(commandId)) {
m_pendingActions[id].removeAll(returningId); m_pendingActions[id].removeAll(commandId);
if (m_pendingActions[id].isEmpty()) { if (m_pendingActions[id].isEmpty()) {
m_pendingActions.remove(id); m_pendingActions.remove(id);
emit actionExecutionFinished(id, "DeviceErrorNoError"); emit actionExecutionFinished(id, "DeviceErrorNoError");

28
libnymea-app/usermanager.cpp
View File

@ -73,17 +73,17 @@ void UserManager::notificationReceived(const QVariantMap &data)
qDebug() << "Users notification" << 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(); // qDebug() << "Token received" << tokenVariant.toMap();
QVariantMap token = tokenVariant.toMap(); QVariantMap token = tokenVariant.toMap();
QUuid id = token.value("id").toString(); 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 &params)
{ {
qDebug() << "Delete token reply" << payload; qDebug() << "Delete token reply" << commandId << params;
int callId = payload.value("id").toInt(); QUuid tokenId = m_tokensToBeRemoved.take(commandId);
QUuid tokenId = m_tokensToBeRemoved.take(callId);
QVariantMap params = payload.value("params").toMap();
QString errorString = params.value("error").toString(); QString errorString = params.value("error").toString();
QMetaEnum metaEnum = QMetaEnum::fromType<UserManager::UserError>(); QMetaEnum metaEnum = QMetaEnum::fromType<UserManager::UserError>();
UserError error = static_cast<UserError>(metaEnum.keyToValue(errorString.toUtf8())); UserError error = static_cast<UserError>(metaEnum.keyToValue(errorString.toUtf8()));
emit deleteTokenResponse(callId, error); emit deleteTokenResponse(commandId, error);
if (error == UserErrorNoError) { if (error == UserErrorNoError) {
m_tokenInfos->removeToken(tokenId); m_tokenInfos->removeToken(tokenId);
} }
} }
void UserManager::changePasswordReply(const QVariantMap &data) void UserManager::changePasswordReply(int commandId, const QVariantMap &params)
{ {
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(); QString errorString = params.value("error").toString();
QMetaEnum metaEnum = QMetaEnum::fromType<UserManager::UserError>(); QMetaEnum metaEnum = QMetaEnum::fromType<UserManager::UserError>();
UserError error = static_cast<UserError>(metaEnum.keyToValue(errorString.toUtf8())); UserError error = static_cast<UserError>(metaEnum.keyToValue(errorString.toUtf8()));
emit changePasswordResponse(callId, error); emit changePasswordResponse(commandId, error);
} }

8
libnymea-app/usermanager.h
View File

@ -55,10 +55,10 @@ signals:
private slots: private slots:
void notificationReceived(const QVariantMap &data); void notificationReceived(const QVariantMap &data);
void getUserInfoReply(const QVariantMap &data); void getUserInfoReply(int commandId, const QVariantMap &data);
void getTokensReply(const QVariantMap &data); void getTokensReply(int commandId, const QVariantMap &data);
void deleteTokenReply(const QVariantMap &data); void deleteTokenReply(int commandId, const QVariantMap &params);
void changePasswordReply(const QVariantMap &data); void changePasswordReply(int commandId, const QVariantMap &params);
private: private:
Engine *m_engine = nullptr; Engine *m_engine = nullptr;

10
nymea-app/ui/components/Dial.qml
View File

@ -99,10 +99,12 @@ ColumnLayout {
Connections { Connections {
target: engine.deviceManager target: engine.deviceManager
onExecuteActionReply: { onExecuteActionReply: {
d.pendingActionId = -1 if (d.pendingActionId == commandId) {
if (d.valueCacheDirty) { d.pendingActionId = -1
d.executeAction(d.valueCache) if (d.valueCacheDirty) {
d.valueCacheDirty = false; d.executeAction(d.valueCache)
d.valueCacheDirty = false;
}
} }
} }
} }

18
nymea-app/ui/devicepages/DeviceBrowserPage.qml
View File

@ -66,20 +66,18 @@ Page {
Connections { Connections {
target: engine.deviceManager target: engine.deviceManager
onExecuteBrowserItemReply: actionExecuted(params) onExecuteBrowserItemReply: actionExecuted(commandId, params)
onExecuteBrowserItemActionReply: actionExecuted(params) onExecuteBrowserItemActionReply: actionExecuted(commandId, params)
} }
function actionExecuted(params) { function actionExecuted(commandId, params) {
if (params.id === d.pendingBrowserItemId) { if (commandId === d.pendingBrowserItemId) {
d.pendingBrowserItemId = -1; d.pendingBrowserItemId = -1;
d.pendingItemId = "" d.pendingItemId = ""
if (params.status !== "success") { if (params.deviceError !== "DeviceErrorNoError") {
header.showInfo(params.error, true); if (params.displayMessage.length > 0) {
} else if (params.params.deviceError !== "DeviceErrorNoError") { header.showInfo(qsTr("Error: %1").arg(params.displayMessage), true)
if (params.params.displayMessage.length > 0) {
header.showInfo(qsTr("Error: %1").arg(params.params.displayMessage), true)
} else { } else {
header.showInfo(qsTr("Error: %1").arg(params.params.deviceError), true) header.showInfo(qsTr("Error: %1").arg(params.deviceError), true)
} }
} }
} }

2
nymea-app/ui/devicepages/FingerprintReaderDevicePage.qml
View File

@ -192,7 +192,7 @@ DevicePageBase {
target: engine.deviceManager target: engine.deviceManager
onExecuteActionReply: { onExecuteActionReply: {
print("Execute action reply:", JSON.stringify(params)); print("Execute action reply:", JSON.stringify(params));
addUserPage.error = params["params"]["deviceError"] !== "DeviceErrorNoError" addUserPage.error = params["deviceError"] !== "DeviceErrorNoError"
var masks =[] var masks =[]
masks.push({x: 0, y: 0, width: 1, height: 1}); masks.push({x: 0, y: 0, width: 1, height: 1});
addUserPage.done = true addUserPage.done = true

6
nymea-app/ui/devicepages/GenericDevicePage.qml
View File

@ -283,7 +283,7 @@ DevicePageBase {
Connections { Connections {
target: engine.deviceManager target: engine.deviceManager
onExecuteActionReply: { onExecuteActionReply: {
if (stateDelegate.pendingActionId === params.id) { if (stateDelegate.pendingActionId === commandId) {
stateDelegate.pendingActionId = -1 stateDelegate.pendingActionId = -1
if (stateDelegate.valueCacheDirty) { if (stateDelegate.valueCacheDirty) {
stateDelegate.executeAction(stateDelegate.valueCache) stateDelegate.executeAction(stateDelegate.valueCache)
@ -308,9 +308,9 @@ DevicePageBase {
Connections { Connections {
target: engine.deviceManager target: engine.deviceManager
onExecuteActionReply: { onExecuteActionReply: {
if (params["id"] === actionDelegate.pendingActionId) { if (commandId === actionDelegate.pendingActionId) {
pendingTimer.start(); pendingTimer.start();
actionDelegate.lastSuccess = params["params"]["deviceError"] === "DeviceErrorNoError" actionDelegate.lastSuccess = params["deviceError"] === "DeviceErrorNoError"
actionDelegate.pendingActionId = -1 actionDelegate.pendingActionId = -1
} }
} }

2
nymea-app/ui/devicepages/LightDevicePage.qml
View File

@ -302,7 +302,7 @@ DevicePageBase {
target: engine.deviceManager target: engine.deviceManager
onExecuteActionReply: { onExecuteActionReply: {
print("action finished", JSON.stringify(params)) print("action finished", JSON.stringify(params))
if (params.id === colorPicker.pendingCommand) { if (commandId === colorPicker.pendingCommand) {
colorPicker.pendingCommand = -1; colorPicker.pendingCommand = -1;
if (colorPicker.queuedColor) { if (colorPicker.queuedColor) {
colorPicker.sendColor(colorPicker.queuedColor); colorPicker.sendColor(colorPicker.queuedColor);

22
nymea-app/ui/devicepages/MediaDevicePage.qml
View File

@ -108,15 +108,15 @@ DevicePageBase {
Connections { Connections {
target: engine.deviceManager target: engine.deviceManager
onExecuteBrowserItemReply: executionFinished(params) onExecuteBrowserItemReply: executionFinished(commandId, params)
onExecuteBrowserItemActionReply: executionFinished(params) onExecuteBrowserItemActionReply: executionFinished(commandId, params)
onExecuteActionReply: { onExecuteActionReply: {
print("actionfinished", params["id"]) print("actionfinished", commandId)
if (params["id"] === d.pendingVolumeId) { if (commandId === d.pendingVolumeId) {
d.pendingVolumeId = -1 d.pendingVolumeId = -1
print("volume action finished") print("volume action finished")
if (params.params.deviceError !== "DeviceErrorNoError") { if (params.deviceError !== "DeviceErrorNoError") {
print("Error setting volume", params.params.deviceError) print("Error setting volume", params.deviceError)
d.pendingVolumeValue = -1; d.pendingVolumeValue = -1;
return; return;
} }
@ -129,16 +129,16 @@ DevicePageBase {
} }
} }
} }
function executionFinished(params) { function executionFinished(commandId, params) {
print("Execute reply:", params, params.id, params["id"], d.pendingBrowserItemId) print("Execute reply:", params, commandId, d.pendingBrowserItemId)
if (params.id === d.pendingBrowserItemId) { if (commandId === d.pendingBrowserItemId) {
d.pendingBrowserItemId = -1; d.pendingBrowserItemId = -1;
d.pendingItemId = "" d.pendingItemId = ""
print("yep finished") print("yep finished")
if (params.params.deviceError === "DeviceErrorNoError") { if (params.deviceError === "DeviceErrorNoError") {
swipeView.currentIndex = 0; swipeView.currentIndex = 0;
} else { } else {
header.showInfo(qsTr("Error: %1").arg(params.params.deviceError), true) header.showInfo(qsTr("Error: %1").arg(params.deviceError), true)
} }
} }
} }

4
nymea-app/ui/experiences/heating/Main.qml
View File

@ -119,8 +119,8 @@ Item {
Connections { Connections {
target: engine.deviceManager target: engine.deviceManager
onExecuteActionReply: { onExecuteActionReply: {
print("executeActionReply:", params["id"]) print("executeActionReply:", commandId)
if (params["id"] === d.pendingCallId) { if (commandId === d.pendingCallId) {
d.pendingCallId = -1; d.pendingCallId = -1;
if (d.setTempPending) { if (d.setTempPending) {
setTargetTemp(d.queuedTargetTemp) setTargetTemp(d.queuedTargetTemp)

4
nymea-app/ui/system/PluginParamsPage.qml
View File

@ -56,11 +56,11 @@ Page {
Connections { Connections {
target: engine.deviceManager target: engine.deviceManager
onSavePluginConfigReply: { onSavePluginConfigReply: {
if (params.params.deviceError === "DeviceErrorNoError") { if (params.deviceError === "DeviceErrorNoError") {
pageStack.pop(); pageStack.pop();
} else { } else {
console.warn("Error saving plugin params:", JSON.stringify(params)) 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(); dialog.open();
} }
} }