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

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

@ -113,14 +113,14 @@ signals:
private slots:
void init();
void getStatusResponse(const QVariantMap &params);
void getDevicesResponse(const QVariantMap &params);
void getAccessPointsResponse(const QVariantMap &params);
void connectToWiFiResponse(const QVariantMap &params);
void disconnectResponse(const QVariantMap &params);
void enableNetworkingResponse(const QVariantMap &params);
void enableWirelessNetworkingResponse(const QVariantMap &params);
void startAccessPointResponse(const QVariantMap &params);
void getStatusResponse(int commandId, const QVariantMap &params);
void getDevicesResponse(int commandId, const QVariantMap &params);
void getAccessPointsResponse(int commandId, const QVariantMap &params);
void connectToWiFiResponse(int commandId, const QVariantMap &params);
void disconnectResponse(int commandId, const QVariantMap &params);
void enableNetworkingResponse(int commandId, const QVariantMap &params);
void enableWirelessNetworkingResponse(int commandId, const QVariantMap &params);
void startAccessPointResponse(int commandId, 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");
}
void NymeaConfiguration::getConfigurationsResponse(const QVariantMap &params)
void NymeaConfiguration::getConfigurationsResponse(int commandId, const QVariantMap &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();
emit debugServerEnabledChanged();
m_serverName = basicConfig.value("serverName").toString();
emit serverNameChanged();
QVariantMap cloudConfig = params.value("params").toMap().value("cloud").toMap();
QVariantMap cloudConfig = params.value("cloud").toMap();
m_cloudEnabled = cloudConfig.value("enabled").toBool();
emit cloudEnabledChanged();
tcpServerConfigurations()->clear();
foreach (const QVariant &tcpServerVariant, params.value("params").toMap().value("tcpServerConfigurations").toList()) {
foreach (const QVariant &tcpServerVariant, params.value("tcpServerConfigurations").toList()) {
// qDebug() << "tcp server config:" << tcpServerVariant;
QVariantMap tcpConfigMap = tcpServerVariant.toMap();
ServerConfiguration *config = new ServerConfiguration(tcpConfigMap.value("id").toString(), QHostAddress(tcpConfigMap.value("address").toString()), tcpConfigMap.value("port").toInt(), tcpConfigMap.value("authenticationEnabled").toBool(), tcpConfigMap.value("sslEnabled").toBool());
m_tcpServerConfigurations->addConfiguration(config);
}
webSocketServerConfigurations()->clear();
foreach (const QVariant &websocketServerVariant, params.value("params").toMap().value("webSocketServerConfigurations").toList()) {
foreach (const QVariant &websocketServerVariant, params.value("webSocketServerConfigurations").toList()) {
QVariantMap websocketConfigMap = websocketServerVariant.toMap();
ServerConfiguration *config = new ServerConfiguration(websocketConfigMap.value("id").toString(), QHostAddress(websocketConfigMap.value("address").toString()), websocketConfigMap.value("port").toInt(), websocketConfigMap.value("authenticationEnabled").toBool(), websocketConfigMap.value("sslEnabled").toBool());
m_webSocketServerConfigurations->addConfiguration(config);
}
webServerConfigurations()->clear();
foreach (const QVariant &webServerVariant, params.value("params").toMap().value("webServerConfigurations").toList()) {
foreach (const QVariant &webServerVariant, params.value("webServerConfigurations").toList()) {
QVariantMap webServerConfigMap = webServerVariant.toMap();
WebServerConfiguration* config = new WebServerConfiguration(webServerConfigMap.value("id").toString(), QHostAddress(webServerConfigMap.value("address").toString()), webServerConfigMap.value("port").toInt(), webServerConfigMap.value("authenticationEnabled").toBool(), webServerConfigMap.value("sslEnabled").toBool());
config->setPublicFolder(webServerConfigMap.value("publicFolder").toString());
@ -287,9 +287,14 @@ void NymeaConfiguration::getConfigurationsResponse(const QVariantMap &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)
@ -297,72 +302,71 @@ void NymeaConfiguration::getCloudConfigurationResponse(const QVariantMap &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();
foreach (const QVariant &mqttServerVariant, params.value("params").toMap().value("mqttServerConfigurations").toList()) {
foreach (const QVariant &mqttServerVariant, params.value("mqttServerConfigurations").toList()) {
QVariantMap mqttConfigMap = mqttServerVariant.toMap();
ServerConfiguration *config = new ServerConfiguration(mqttConfigMap.value("id").toString(), QHostAddress(mqttConfigMap.value("address").toString()), mqttConfigMap.value("port").toInt(), mqttConfigMap.value("authenticationEnabled").toBool(), mqttConfigMap.value("sslEnabled").toBool());
m_mqttServerConfigurations->addConfiguration(config);
}
}
void NymeaConfiguration::setMqttConfigReply(const QVariantMap &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;
m_mqttPolicies->clear();
foreach (const QVariant &policyVariant, params.value("params").toMap().value("mqttPolicies").toList()) {
foreach (const QVariant &policyVariant, params.value("mqttPolicies").toList()) {
QVariantMap policyMap = policyVariant.toMap();
MqttPolicy *policy = new MqttPolicy(
policyMap.value("clientId").toString(),
@ -374,14 +378,14 @@ void NymeaConfiguration::getMqttPoliciesReply(const QVariantMap &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)

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

@ -106,23 +106,24 @@ public:
void init();
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 setDebugServerEnabledResponse(const QVariantMap &params);
Q_INVOKABLE void setServerNameResponse(const QVariantMap &params);
Q_INVOKABLE void setCloudEnabledResponse(const QVariantMap &params);
Q_INVOKABLE void setTcpConfigReply(const QVariantMap &params);
Q_INVOKABLE void deleteTcpConfigReply(const QVariantMap &params);
Q_INVOKABLE void setWebSocketConfigReply(const QVariantMap &params);
Q_INVOKABLE void deleteWebSocketConfigReply(const QVariantMap &params);
Q_INVOKABLE void setWebConfigReply(const QVariantMap &params);
Q_INVOKABLE void deleteWebConfigReply(const QVariantMap &params);
Q_INVOKABLE void getMqttServerConfigsReply(const QVariantMap &params);
Q_INVOKABLE void setMqttConfigReply(const QVariantMap &params);
Q_INVOKABLE void deleteMqttConfigReply(const QVariantMap &params);
Q_INVOKABLE void getMqttPoliciesReply(const QVariantMap &params);
Q_INVOKABLE void setMqttPolicyReply(const QVariantMap &params);
Q_INVOKABLE void deleteMqttPolicyReply(const QVariantMap &params);
Q_INVOKABLE void setDebugServerEnabledResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setServerNameResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setTimezoneResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setCloudEnabledResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setTcpConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteTcpConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void setWebSocketConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteWebSocketConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void setWebConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteWebConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void getMqttServerConfigsReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void setMqttConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void deleteMqttConfigReply(int commandId, const QVariantMap &params);
Q_INVOKABLE void getMqttPoliciesReply(int commandId, 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);

6
libnymea-app/devicediscovery.cpp
View File

@ -131,10 +131,10 @@ QString DeviceDiscovery::displayMessage() const
return m_displayMessage;
}
void DeviceDiscovery::discoverDevicesResponse(const QVariantMap &params)
void DeviceDiscovery::discoverDevicesResponse(int /*commandId*/, const QVariantMap &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) {
qDebug() << "Found device. Descriptor:" << descriptorVariant;
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;
emit busyChanged();
}

2
libnymea-app/devicediscovery.h
View File

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

164
libnymea-app/devicemanager.cpp
View File

@ -36,7 +36,10 @@
#include "thinggroup.h"
#include "types/interface.h"
#include "types/ioconnections.h"
#include <QMetaEnum>
#include <QFile>
#include <QStandardPaths>
DeviceManager::DeviceManager(JsonRpcClient* jsonclient, QObject *parent) :
JsonHandler(parent),
@ -61,6 +64,8 @@ void DeviceManager::clear()
void DeviceManager::init()
{
m_connectionBenchmark = QDateTime::currentDateTime();
// For old nymea setups we need to register to Events.Notifications.
// Deprecated since JSONRPC 4.0/nymea 0.17
if (!m_jsonClient->ensureServerVersion("4.0")) {
@ -151,14 +156,14 @@ bool DeviceManager::fetchingData() const
return m_fetchingData;
}
void DeviceManager::addDevice(const QUuid &deviceClassId, const QString &name, const QVariantList &deviceParams)
int DeviceManager::addDevice(const QUuid &deviceClassId, const QString &name, const QVariantList &deviceParams)
{
qDebug() << "add device " << deviceClassId.toString();
QVariantMap params;
params.insert("deviceClassId", deviceClassId.toString());
params.insert("name", name);
params.insert("deviceParams", deviceParams);
m_jsonClient->sendCommand("Devices.AddConfiguredDevice", params, this, "addDeviceResponse");
return m_jsonClient->sendCommand("Devices.AddConfiguredDevice", params, this, "addDeviceResponse");
}
void DeviceManager::notificationReceived(const QVariantMap &data)
@ -264,11 +269,11 @@ void DeviceManager::notificationReceived(const QVariantMap &data)
}
}
void DeviceManager::getVendorsResponse(const QVariantMap &params)
void DeviceManager::getVendorsResponse(int /*commandId*/, const QVariantMap &params)
{
// qDebug() << "Got GetSupportedVendors response" << params;
if (params.value("params").toMap().keys().contains("vendors")) {
QVariantList vendorList = params.value("params").toMap().value("vendors").toList();
if (params.keys().contains("vendors")) {
QVariantList vendorList = params.value("vendors").toList();
foreach (QVariant vendorVariant, vendorList) {
Vendor *vendor = JsonTypes::unpackVendor(vendorVariant.toMap());
m_vendors->addVendor(vendor);
@ -277,11 +282,11 @@ void DeviceManager::getVendorsResponse(const QVariantMap &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));
if (params.value("params").toMap().keys().contains("deviceClasses")) {
QVariantList deviceClassList = params.value("params").toMap().value("deviceClasses").toList();
if (params.keys().contains("deviceClasses")) {
QVariantList deviceClassList = params.value("deviceClasses").toList();
foreach (QVariant deviceClassVariant, deviceClassList) {
DeviceClass *deviceClass = JsonTypes::unpackDeviceClass(deviceClassVariant.toMap(), deviceClasses());
m_thingClasses->addDeviceClass(deviceClass);
@ -290,11 +295,11 @@ void DeviceManager::getSupportedDevicesResponse(const QVariantMap &params)
m_jsonClient->sendCommand("Devices.GetConfiguredDevices", this, "getConfiguredDevicesResponse");
}
void DeviceManager::getPluginsResponse(const QVariantMap &params)
void DeviceManager::getPluginsResponse(int /*commandId*/, const QVariantMap &params)
{
// qDebug() << "received plugins";
if (params.value("params").toMap().keys().contains("plugins")) {
QVariantList pluginList = params.value("params").toMap().value("plugins").toList();
if (params.keys().contains("plugins")) {
QVariantList pluginList = params.value("plugins").toList();
foreach (QVariant pluginVariant, pluginList) {
Plugin *plugin = JsonTypes::unpackPlugin(pluginVariant.toMap(), plugins());
m_plugins->addPlugin(plugin);
@ -310,7 +315,7 @@ void DeviceManager::getPluginsResponse(const QVariantMap &params)
}
}
void DeviceManager::getPluginConfigResponse(const QVariantMap &params)
void DeviceManager::getPluginConfigResponse(int /*commandId*/, const QVariantMap &params)
{
// qDebug() << "plugin config response" << params;
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";
return;
}
QVariantList pluginParams = params.value("params").toMap().value("configuration").toList();
QVariantList pluginParams = params.value("configuration").toList();
foreach (const QVariant &paramVariant, pluginParams) {
Param* param = new 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")) {
QVariantList deviceList = params.value("params").toMap().value("devices").toList();
if (params.keys().contains("devices")) {
QVariantList deviceList = params.value("devices").toList();
foreach (QVariant deviceVariant, deviceList) {
Device *device = JsonTypes::unpackDevice(this, deviceVariant.toMap(), m_thingClasses);
if (!device) {
@ -369,6 +374,7 @@ void DeviceManager::getConfiguredDevicesResponse(const QVariantMap &params)
// qDebug() << "*** Added device:" << endl << device;
}
}
qDebug() << "Initializing thing manager took" << m_connectionBenchmark.msecsTo(QDateTime::currentDateTime()) << "ms";
m_fetchingData = false;
emit fetchingDataChanged();
@ -377,12 +383,12 @@ void DeviceManager::getConfiguredDevicesResponse(const QVariantMap &params)
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") {
qWarning() << "Failed to add the device:" << params.value("params").toMap().value("deviceError").toString();
} else if (params.value("params").toMap().keys().contains("device")) {
QVariantMap deviceVariant = params.value("params").toMap().value("device").toMap();
if (params.value("deviceError").toString() != "DeviceErrorNoError") {
qWarning() << "Failed to add the device:" << params.value("deviceError").toString();
} else if (params.keys().contains("device")) {
QVariantMap deviceVariant = params.value("device").toMap();
Device *device = JsonTypes::unpackDevice(this, deviceVariant, m_thingClasses);
if (!device) {
qWarning() << "Couldn't parse json in addDeviceResponse";
@ -392,57 +398,57 @@ void DeviceManager::addDeviceResponse(const QVariantMap &params)
qDebug() << "Device added" << device->id().toString();
m_devices->addDevice(device);
}
emit addDeviceReply(params.value("params").toMap());
emit addDeviceReply(commandId, params);
}
void DeviceManager::removeDeviceResponse(const QVariantMap &params)
void DeviceManager::removeDeviceResponse(int commandId, const QVariantMap &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;
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;
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;
emit savePluginConfigReply(params);
qDebug() << "set plugin config response" << params;
emit savePluginConfigReply(commandId, params);
}
void DeviceManager::editDeviceResponse(const QVariantMap &params)
void DeviceManager::editDeviceResponse(int commandId, const QVariantMap &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;
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;
emit reconfigureDeviceReply(params.value("params").toMap());
emit reconfigureDeviceReply(commandId, params);
}
void DeviceManager::savePluginConfig(const QUuid &pluginId)
int DeviceManager::savePluginConfig(const QUuid &pluginId)
{
Plugin *p = m_plugins->getPlugin(pluginId);
if (!p) {
qWarning()<< "Error: can't find plugin with id" << pluginId;
return;
return -1;
}
QVariantMap params;
params.insert("pluginId", pluginId);
@ -451,7 +457,7 @@ void DeviceManager::savePluginConfig(const QUuid &pluginId)
pluginParams.append(JsonTypes::packParam(p->params()->get(i)));
}
params.insert("configuration", pluginParams);
m_jsonClient->sendCommand("Devices.SetPluginConfiguration", params, this, "setPluginConfigResponse");
return m_jsonClient->sendCommand("Devices.SetPluginConfiguration", params, this, "setPluginConfigResponse");
}
ThingGroup *DeviceManager::createGroup(Interface *interface, DevicesProxy *things)
@ -461,7 +467,7 @@ ThingGroup *DeviceManager::createGroup(Interface *interface, DevicesProxy *thing
return group;
}
void DeviceManager::addDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QString &name, const QVariantList &deviceParams)
int DeviceManager::addDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QString &name, const QVariantList &deviceParams)
{
qDebug() << "JsonRpc: add discovered device " << deviceClassId.toString();
QVariantMap params;
@ -469,10 +475,10 @@ void DeviceManager::addDiscoveredDevice(const QUuid &deviceClassId, const QUuid
params.insert("name", name);
params.insert("deviceDescriptorId", deviceDescriptorId.toString());
params.insert("deviceParams", deviceParams);
m_jsonClient->sendCommand("Devices.AddConfiguredDevice", params, this, "addDeviceResponse");
return m_jsonClient->sendCommand("Devices.AddConfiguredDevice", params, this, "addDeviceResponse");
}
void DeviceManager::pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QVariantList &deviceParams, const QString &name)
int DeviceManager::pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QVariantList &deviceParams, const QString &name)
{
qDebug() << "JsonRpc: pair discovered device " << deviceDescriptorId.toString();
QVariantMap params;
@ -484,20 +490,20 @@ void DeviceManager::pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid
params.insert("deviceClassId", deviceClassId);
}
m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse");
return m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse");
}
void DeviceManager::pairDevice(const QUuid &deviceClassId, const QVariantList &deviceParams, const QString &name)
int DeviceManager::pairDevice(const QUuid &deviceClassId, const QVariantList &deviceParams, const QString &name)
{
qDebug() << "JsonRpc: pair device " << deviceClassId.toString();
QVariantMap params;
params.insert("deviceClassId", deviceClassId.toString());
params.insert("deviceParams", deviceParams);
params.insert("name", name);
m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse");
return m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse");
}
void DeviceManager::rePairDevice(const QUuid &deviceId, const QVariantList &deviceParams, const QString &name)
int DeviceManager::rePairDevice(const QUuid &deviceId, const QVariantList &deviceParams, const QString &name)
{
qDebug() << "JsonRpc: pair device (reconfigure)" << deviceId;
QVariantMap params;
@ -506,10 +512,10 @@ void DeviceManager::rePairDevice(const QUuid &deviceId, const QVariantList &devi
if (!name.isEmpty()) {
params.insert("name", name);
}
m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse");
return m_jsonClient->sendCommand("Devices.PairDevice", params, this, "pairDeviceResponse");
}
void DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QString &secret, const QString &username)
int DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QString &secret, const QString &username)
{
qDebug() << "JsonRpc: confirm pairing" << pairingTransactionId.toString();
QVariantMap params;
@ -518,10 +524,10 @@ void DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QStr
if (!username.isEmpty()) {
params.insert("username", username);
}
m_jsonClient->sendCommand("Devices.ConfirmPairing", params, this, "confirmPairingResponse");
return m_jsonClient->sendCommand("Devices.ConfirmPairing", params, this, "confirmPairingResponse");
}
void DeviceManager::removeDevice(const QUuid &deviceId, RemovePolicy removePolicy)
int DeviceManager::removeDevice(const QUuid &deviceId, RemovePolicy removePolicy)
{
qDebug() << "JsonRpc: delete device" << deviceId.toString();
QVariantMap params;
@ -530,34 +536,34 @@ void DeviceManager::removeDevice(const QUuid &deviceId, RemovePolicy removePolic
QMetaEnum policyEnum = QMetaEnum::fromType<DeviceManager::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;
params.insert("deviceId", deviceId.toString());
params.insert("name", name);
m_jsonClient->sendCommand("Devices.EditDevice", params, this, "editDeviceResponse");
return m_jsonClient->sendCommand("Devices.EditDevice", params, this, "editDeviceResponse");
}
void DeviceManager::setDeviceSettings(const QUuid &deviceId, const QVariantList &settings)
int DeviceManager::setDeviceSettings(const QUuid &deviceId, const QVariantList &settings)
{
QVariantMap params;
params.insert("deviceId", deviceId);
params.insert("settings", settings);
m_jsonClient->sendCommand("Devices.SetDeviceSettings", params);
return m_jsonClient->sendCommand("Devices.SetDeviceSettings", params);
}
void DeviceManager::reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams)
int DeviceManager::reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams)
{
QVariantMap params;
params.insert("deviceId", deviceId.toString());
params.insert("deviceParams", deviceParams);
m_jsonClient->sendCommand("Devices.ReconfigureDevice", params, this, "reconfigureDeviceResponse");
return m_jsonClient->sendCommand("Devices.ReconfigureDevice", params, this, "reconfigureDeviceResponse");
}
void DeviceManager::reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList &paramOverride)
int DeviceManager::reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList &paramOverride)
{
QVariantMap params;
params.insert("deviceId", deviceId.toString());
@ -566,7 +572,7 @@ void DeviceManager::reconfigureDiscoveredDevice(const QUuid &deviceId, const QUu
params.insert("deviceParams", paramOverride);
}
qDebug() << "Calling ReconfigureDevice" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson());
m_jsonClient->sendCommand("Devices.ReconfigureDevice", params, this, "reconfigureDeviceResponse");
return m_jsonClient->sendCommand("Devices.ReconfigureDevice", params, this, "reconfigureDeviceResponse");
}
int DeviceManager::executeAction(const QUuid &deviceId, const QUuid &actionTypeId, const QVariantList &params)
@ -627,16 +633,15 @@ BrowserItem *DeviceManager::browserItem(const QUuid &deviceId, const QString &it
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));
int id = params.value("id").toInt();
if (!m_browsingRequests.contains(id)) {
if (!m_browsingRequests.contains(commandId)) {
qWarning() << "Received a browsing reply for an id we don't know.";
return;
}
QPointer<BrowserItems> itemModel = m_browsingRequests.take(id);
QPointer<BrowserItems> itemModel = m_browsingRequests.take(commandId);
if (!itemModel) {
qDebug() << "BrowserItems model seems to have disappeared. Discarding browsing result.";
return;
@ -644,7 +649,7 @@ void DeviceManager::browseDeviceResponse(const QVariantMap &params)
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();
QString itemId = itemMap.value("id").toString();
BrowserItem *item = itemModel->getBrowserItem(itemId);
@ -676,22 +681,21 @@ void DeviceManager::browseDeviceResponse(const QVariantMap &params)
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));
int id = params.value("id").toInt();
if (!m_browserDetailsRequests.contains(id)) {
if (!m_browserDetailsRequests.contains(commandId)) {
qWarning() << "Received a browser item details reply for an id we don't know.";
return;
}
QPointer<BrowserItem> item = m_browserDetailsRequests.take(id);
QPointer<BrowserItem> item = m_browserDetailsRequests.take(commandId);
if (!item) {
qDebug() << "BrowserItem seems to have disappeared. Discarding browser item details result.";
return;
}
QVariantMap itemMap = params.value("params").toMap().value("item").toMap();
QVariantMap itemMap = params.value("item").toMap();
item->setDisplayName(itemMap.value("displayName").toString());
item->setDescription(itemMap.value("description").toString());
item->setIcon(itemMap.value("icon").toString());
@ -712,10 +716,10 @@ int DeviceManager::executeBrowserItem(const QUuid &deviceId, const QString &item
return m_jsonClient->sendCommand("Actions.ExecuteBrowserItem", params, this, "executeBrowserItemResponse");
}
void DeviceManager::executeBrowserItemResponse(const QVariantMap &params)
void DeviceManager::executeBrowserItemResponse(int commandId, const QVariantMap &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)
@ -747,17 +751,17 @@ int DeviceManager::disconnectIO(const QUuid &ioConnectionId)
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;
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());
foreach (const QVariant &connectionVariant, params.value("params").toMap().value("ioConnections").toList()) {
foreach (const QVariant &connectionVariant, params.value("ioConnections").toList()) {
QVariantMap connectionMap = connectionVariant.toMap();
QUuid id = connectionMap.value("id").toUuid();
QUuid inputThingId = connectionMap.value("inputThingId").toUuid();
@ -770,13 +774,13 @@ void DeviceManager::getIOConnectionsResponse(const QVariantMap &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;
Q_INVOKABLE void addDevice(const QUuid &deviceClassId, const QString &name, const QVariantList &deviceParams);
Q_INVOKABLE int addDevice(const QUuid &deviceClassId, const QString &name, const QVariantList &deviceParams);
// param deviceClassId is deprecated and should be removed when minimum JSONRPC version is 3.1
Q_INVOKABLE void addDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QString &name, const QVariantList &deviceParams);
Q_INVOKABLE void pairDevice(const QUuid &deviceClassId, const QVariantList &deviceParams, const QString &name);
Q_INVOKABLE int addDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QString &name, const QVariantList &deviceParams);
Q_INVOKABLE int pairDevice(const QUuid &deviceClassId, const QVariantList &deviceParams, const QString &name);
// param deviceClassId is deprecated and should be removed when minimum JSONRPC version is 3.1
Q_INVOKABLE void pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QVariantList &deviceParams, const QString &name);
Q_INVOKABLE void rePairDevice(const QUuid &deviceId, const QVariantList &deviceParams, const QString &name = QString());
Q_INVOKABLE void confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString(), const QString &username = QString());
Q_INVOKABLE void removeDevice(const QUuid &deviceId, RemovePolicy policy = RemovePolicyNone);
Q_INVOKABLE void editDevice(const QUuid &deviceId, const QString &name);
Q_INVOKABLE void setDeviceSettings(const QUuid &deviceId, const QVariantList &settings);
Q_INVOKABLE void reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams);
Q_INVOKABLE void reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList &paramOverride);
Q_INVOKABLE int pairDiscoveredDevice(const QUuid &deviceClassId, const QUuid &deviceDescriptorId, const QVariantList &deviceParams, const QString &name);
Q_INVOKABLE int rePairDevice(const QUuid &deviceId, const QVariantList &deviceParams, const QString &name = QString());
Q_INVOKABLE int confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString(), const QString &username = QString());
Q_INVOKABLE int removeDevice(const QUuid &deviceId, RemovePolicy policy = RemovePolicyNone);
Q_INVOKABLE int editDevice(const QUuid &deviceId, const QString &name);
Q_INVOKABLE int setDeviceSettings(const QUuid &deviceId, const QVariantList &settings);
Q_INVOKABLE int reconfigureDevice(const QUuid &deviceId, const QVariantList &deviceParams);
Q_INVOKABLE int reconfigureDiscoveredDevice(const QUuid &deviceId, const QUuid &deviceDescriptorId, const QVariantList &paramOverride);
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 void refreshBrowserItems(BrowserItems *browserItems);
@ -111,43 +111,43 @@ public:
private:
Q_INVOKABLE void notificationReceived(const QVariantMap &data);
Q_INVOKABLE void getVendorsResponse(const QVariantMap &params);
Q_INVOKABLE void getSupportedDevicesResponse(const QVariantMap &params);
Q_INVOKABLE void getPluginsResponse(const QVariantMap &params);
Q_INVOKABLE void getPluginConfigResponse(const QVariantMap &params);
Q_INVOKABLE void getConfiguredDevicesResponse(const QVariantMap &params);
Q_INVOKABLE void addDeviceResponse(const QVariantMap &params);
Q_INVOKABLE void removeDeviceResponse(const QVariantMap &params);
Q_INVOKABLE void pairDeviceResponse(const QVariantMap &params);
Q_INVOKABLE void confirmPairingResponse(const QVariantMap &params);
Q_INVOKABLE void setPluginConfigResponse(const QVariantMap &params);
Q_INVOKABLE void editDeviceResponse(const QVariantMap &params);
Q_INVOKABLE void executeActionResponse(const QVariantMap &params);
Q_INVOKABLE void reconfigureDeviceResponse(const QVariantMap &params);
Q_INVOKABLE void browseDeviceResponse(const QVariantMap &params);
Q_INVOKABLE void browserItemResponse(const QVariantMap &params);
Q_INVOKABLE void executeBrowserItemResponse(const QVariantMap &params);
Q_INVOKABLE void executeBrowserItemActionResponse(const QVariantMap &params);
Q_INVOKABLE void getIOConnectionsResponse(const QVariantMap &params);
Q_INVOKABLE void connectIOResponse(const QVariantMap &params);
Q_INVOKABLE void disconnectIOResponse(const QVariantMap &params);
Q_INVOKABLE void getVendorsResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getSupportedDevicesResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getPluginsResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getPluginConfigResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getConfiguredDevicesResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void addDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void removeDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void pairDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void confirmPairingResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void setPluginConfigResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void editDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void executeActionResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void reconfigureDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void browseDeviceResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void browserItemResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void executeBrowserItemResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void executeBrowserItemActionResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void getIOConnectionsResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void connectIOResponse(int commandId, const QVariantMap &params);
Q_INVOKABLE void disconnectIOResponse(int commandId, const QVariantMap &params);
public slots:
void savePluginConfig(const QUuid &pluginId);
int savePluginConfig(const QUuid &pluginId);
ThingGroup* createGroup(Interface *interface, DevicesProxy *things);
signals:
void pairDeviceReply(const QVariantMap &params);
void confirmPairingReply(const QVariantMap &params);
void addDeviceReply(const QVariantMap &params);
void removeDeviceReply(const QVariantMap &params);
void savePluginConfigReply(const QVariantMap &params);
void editDeviceReply(const QVariantMap &params);
void reconfigureDeviceReply(const QVariantMap &params);
void executeActionReply(const QVariantMap &params);
void executeBrowserItemReply(const QVariantMap &params);
void executeBrowserItemActionReply(const QVariantMap &params);
void pairDeviceReply(int commandId, const QVariantMap &params);
void confirmPairingReply(int commandId, const QVariantMap &params);
void addDeviceReply(int commandId, const QVariantMap &params);
void removeDeviceReply(int commandId, const QVariantMap &params);
void savePluginConfigReply(int commandId, const QVariantMap &params);
void editDeviceReply(int commandId, const QVariantMap &params);
void reconfigureDeviceReply(int commandId, const QVariantMap &params);
void executeActionReply(int commandId, const QVariantMap &params);
void executeBrowserItemReply(int commandId, const QVariantMap &params);
void executeBrowserItemActionReply(int commandId, const QVariantMap &params);
void fetchingDataChanged();
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<BrowserItem> > m_browserDetailsRequests;
QDateTime m_connectionBenchmark;
// Deprecated stuff for nymea < 0.17 (JSONRPC < 4.0)
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)
{
JsonRpcReply *reply = createReply(method, params, caller, callbackMethod);
if (m_cacheHashes.contains(method)) {
QString hash = m_cacheHashes.value(method);
QString callSignature = method + '-' + QJsonDocument::fromVariant(params).toJson() + '-' + QLocale().name();
QString callSignatureHash = QCryptographicHash::hash(callSignature.toUtf8(), QCryptographicHash::Md5).toHex();
QFile f(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + '/' + method + '-' + callSignatureHash + '-' + hash + ".cache");
if (f.exists() && f.open(QFile::ReadOnly)) {
QJsonParseError error;
QVariantMap cachedParams = QJsonDocument::fromJson(f.readAll(), &error).toVariant().toMap();
f.close();
if (error.error == QJsonParseError::NoError) {
qDebug() << "Loaded results for" << reply->nameSpace() + '.' + reply->method() << "from cache";
// We want to make sure this is an async operation even if we have stuff in cache, so only call callbacks using Qt::QueuedConnection
if (!reply->caller().isNull() && !reply->callback().isEmpty()) {
QMetaObject::invokeMethod(reply->caller(), reply->callback().toLatin1().data(), Qt::QueuedConnection, Q_ARG(int, reply->commandId()), Q_ARG(QVariantMap, cachedParams));
}
QMetaObject::invokeMethod(this, "responseReceived", Qt::QueuedConnection, Q_ARG(int, reply->commandId()), Q_ARG(QVariantMap, cachedParams));
QMetaObject::invokeMethod(reply, "deleteLater", Qt::QueuedConnection);
return reply->commandId();
}
}
}
m_replies.insert(reply->commandId(), reply);
sendRequest(reply->requestMap());
return reply->commandId();
@ -102,6 +126,7 @@ int JsonRpcClient::sendCommand(const QString &method, const QVariantMap &params,
int JsonRpcClient::sendCommand(const QString &method, QObject *caller, const QString &callbackMethod)
{
return sendCommand(method, QVariantMap(), caller, callbackMethod);
}
@ -138,7 +163,7 @@ void JsonRpcClient::getCloudConnectionStatus()
sendRequest(reply->requestMap());
}
void JsonRpcClient::setNotificationsEnabledResponse(const QVariantMap &params)
void JsonRpcClient::setNotificationsEnabledResponse(int /*commandId*/, const QVariantMap &params)
{
qDebug() << "Notifications enabled:" << params;
@ -187,28 +212,28 @@ void JsonRpcClient::notificationReceived(const QVariantMap &data)
qDebug() << "JsonRpcClient: Unhandled notification received" << data;
}
void JsonRpcClient::isCloudConnectedReply(const QVariantMap &data)
void JsonRpcClient::isCloudConnectedReply(int /*commandId*/, const QVariantMap &data)
{
// qDebug() << "Cloud is connected" << data;
// qDebug() << "Cloud is connected" << data;
QMetaEnum connectionStateEnum = QMetaEnum::fromType<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();
}
void JsonRpcClient::setupRemoteAccessReply(const QVariantMap &data)
void JsonRpcClient::setupRemoteAccessReply(int commandId, const QVariantMap &data)
{
qDebug() << "Setup Remote Access reply" << data;
qDebug() << "Setup Remote Access reply" << commandId << data;
}
void JsonRpcClient::deployCertificateReply(const QVariantMap &data)
void JsonRpcClient::deployCertificateReply(int commandId, const QVariantMap &data)
{
qDebug() << "deploy certificate reply:" << data;
qDebug() << "deploy certificate reply:" << commandId << data;
}
void JsonRpcClient::getVersionsReply(const QVariantMap &data)
void JsonRpcClient::getVersionsReply(int /*commandId*/, const QVariantMap &data)
{
m_serverQtVersion = data.value("params").toMap().value("qtVersion").toString();
m_serverQtBuildVersion = data.value("params").toMap().value("qtBuildVersion").toString();
m_serverQtVersion = data.value("qtVersion").toString();
m_serverQtBuildVersion = data.value("qtBuildVersion").toString();
if (!m_serverQtVersion.isEmpty()) {
emit serverQtVersionChanged();
}
@ -287,6 +312,11 @@ void JsonRpcClient::deployCertificate(const QByteArray &rootCA, const QByteArray
sendCommand("JSONRPC.SetupCloudConnection", params, this, "deployCertificateReply");
}
QHash<QString, QString> JsonRpcClient::cacheHashes() const
{
return m_cacheHashes;
}
QString JsonRpcClient::serverVersion() const
{
return m_serverVersion;
@ -353,13 +383,13 @@ int JsonRpcClient::requestPushButtonAuth(const QString &deviceName)
return reply->commandId();
}
void JsonRpcClient::setupRemoteAccess(const QString &idToken, const QString &userId)
int JsonRpcClient::setupRemoteAccess(const QString &idToken, const QString &userId)
{
qDebug() << "Calling SetupRemoteAccess";
QVariantMap params;
params.insert("idToken", idToken);
params.insert("userId", userId);
sendCommand("JSONRPC.SetupRemoteAccess", params, this, "setupRemoteAccessReply");
return sendCommand("JSONRPC.SetupRemoteAccess", params, this, "setupRemoteAccessReply");
}
bool JsonRpcClient::ensureServerVersion(const QString &jsonRpcVersion)
@ -367,11 +397,11 @@ bool JsonRpcClient::ensureServerVersion(const QString &jsonRpcVersion)
return QVersionNumber(m_jsonRpcVersion) >= QVersionNumber::fromString(jsonRpcVersion);
}
void JsonRpcClient::processAuthenticate(const QVariantMap &data)
void JsonRpcClient::processAuthenticate(int /*commandId*/, const QVariantMap &data)
{
if (data.value("status").toString() == "success" && data.value("params").toMap().value("success").toBool()) {
if (data.value("success").toBool()) {
qDebug() << "authentication successful";
m_token = data.value("params").toMap().value("token").toByteArray();
m_token = data.value("token").toByteArray();
QSettings settings;
settings.beginGroup("jsonTokens");
settings.setValue(m_serverUuid, m_token);
@ -388,24 +418,24 @@ void JsonRpcClient::processAuthenticate(const QVariantMap &data)
}
}
void JsonRpcClient::processCreateUser(const QVariantMap &data)
void JsonRpcClient::processCreateUser(int /*commandId*/, const QVariantMap &data)
{
qDebug() << "create user response:" << data;
if (data.value("status").toString() == "success" && data.value("params").toMap().value("error").toString() == "UserErrorNoError") {
if (data.value("error").toString() == "UserErrorNoError") {
emit createUserSucceeded();
m_initialSetupRequired = false;
emit initialSetupRequiredChanged();
} else {
qDebug() << "Emitting create user failed";
emit createUserFailed(data.value("params").toMap().value("error").toString());
emit createUserFailed(data.value("error").toString());
}
}
void JsonRpcClient::processRequestPushButtonAuth(const QVariantMap &data)
void JsonRpcClient::processRequestPushButtonAuth(int /*commandId*/, const QVariantMap &data)
{
qDebug() << "requestPushButtonAuth response" << data;
if (data.value("status").toString() == "success" && data.value("params").toMap().value("success").toBool()) {
m_pendingPushButtonTransaction = data.value("params").toMap().value("transactionId").toInt();
if (data.value("success").toBool()) {
m_pendingPushButtonTransaction = data.value("transactionId").toInt();
} else {
emit pushButtonAuthFailed();
}
@ -449,7 +479,7 @@ void JsonRpcClient::sendRequest(const QVariantMap &request)
{
QVariantMap newRequest = request;
newRequest.insert("token", m_token);
// qDebug() << "Sending request" << qUtf8Printable(QJsonDocument::fromVariant(newRequest).toJson());
// qDebug() << "Sending request" << qUtf8Printable(QJsonDocument::fromVariant(newRequest).toJson());
m_connection->sendData(QJsonDocument::fromVariant(newRequest).toJson(QJsonDocument::Compact) + "\n");
}
@ -506,7 +536,7 @@ void JsonRpcClient::onInterfaceConnectedChanged(bool connected)
void JsonRpcClient::dataReceived(const QByteArray &data)
{
// qDebug() << "JsonRpcClient: received data:" << qUtf8Printable(data);
// qDebug() << "JsonRpcClient: received data:" << qUtf8Printable(data);
m_receiveBuffer.append(data);
int splitIndex = m_receiveBuffer.indexOf("}\n{") + 1;
@ -516,10 +546,10 @@ void JsonRpcClient::dataReceived(const QByteArray &data)
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(m_receiveBuffer.left(splitIndex), &error);
if (error.error != QJsonParseError::NoError) {
// qWarning() << "Could not parse json data from nymea" << m_receiveBuffer.left(splitIndex) << error.errorString();
// qWarning() << "Could not parse json data from nymea" << m_receiveBuffer.left(splitIndex) << error.errorString();
return;
}
// qDebug() << "received response" << qUtf8Printable(jsonDoc.toJson(QJsonDocument::Indented));
// qDebug() << "received response" << qUtf8Printable(jsonDoc.toJson(QJsonDocument::Indented));
m_receiveBuffer = m_receiveBuffer.right(m_receiveBuffer.length() - splitIndex - 1);
if (!m_receiveBuffer.isEmpty()) {
staticMetaObject.invokeMethod(this, "dataReceived", Qt::QueuedConnection, Q_ARG(QByteArray, QByteArray()));
@ -529,7 +559,7 @@ void JsonRpcClient::dataReceived(const QByteArray &data)
// check if this is a notification
if (dataMap.contains("notification")) {
// qDebug() << "Incoming notification:" << jsonDoc.toJson();
// qDebug() << "Incoming notification:" << jsonDoc.toJson();
QStringList notification = dataMap.value("notification").toString().split(".");
QString nameSpace = notification.first();
foreach (JsonHandler *handler, m_notificationHandlers.values(nameSpace)) {
@ -543,7 +573,7 @@ void JsonRpcClient::dataReceived(const QByteArray &data)
JsonRpcReply *reply = m_replies.take(commandId);
if (reply) {
reply->deleteLater();
// qDebug() << QString("JsonRpc: got response for %1.%2: %3").arg(reply->nameSpace(), reply->method(), QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Indented))) << reply->callback() << reply->callback();
// qDebug() << QString("JsonRpc: got response for %1.%2: %3").arg(reply->nameSpace(), reply->method(), QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Indented))) << reply->callback() << reply->callback();
if (dataMap.value("status").toString() == "unauthorized") {
qWarning() << "Something's off with the token";
@ -558,106 +588,134 @@ void JsonRpcClient::dataReceived(const QByteArray &data)
emit authenticatedChanged();
}
if (dataMap.value("status").toString() == "error") {
qWarning() << "An error happened in the JSONRPC layer!";
if (reply->nameSpace() == "JSONRPC" && reply->method() == "Hello") {
qWarning() << "Hello call failed. Trying again without locale";
m_id = 0;
sendCommand("JSONRPC.Hello", QVariantMap(), this, "helloReply");
}
}
// Note: We're still forwarding a failed call, params will be empty tho...
// This should never really happen as errors on this layer indicate a but in the caller code in the first place
// Some methods however, like authenticate might fail on an invalid token tho and stil need to act on it
if (!reply->caller().isNull() && !reply->callback().isEmpty()) {
QMetaObject::invokeMethod(reply->caller(), reply->callback().toLatin1().data(), Q_ARG(QVariantMap, dataMap));
QMetaObject::invokeMethod(reply->caller(), reply->callback().toLatin1().data(), Q_ARG(int, commandId), Q_ARG(QVariantMap, dataMap.value("params").toMap()));
}
emit responseReceived(reply->commandId(), dataMap.value("params").toMap());
// If the server supports cache hashes, cache stuff locally
QString fullMethod = reply->nameSpace() + '.' + reply->method();
if (m_cacheHashes.contains(fullMethod)) {
QString hash = m_cacheHashes.value(fullMethod);
QString callSignature = fullMethod + '-' + QJsonDocument::fromVariant(reply->params()).toJson() + '-' + QLocale().name();
QString callSignatureHash = QCryptographicHash::hash(callSignature.toUtf8(), QCryptographicHash::Md5).toHex();
QFile f(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + '/' + fullMethod + '-' + callSignatureHash + '-' + hash + ".cache");
if (!f.exists() && f.open(QFile::WriteOnly | QFile::Truncate)) {
f.write(QJsonDocument::fromVariant(dataMap.value("params")).toJson());
f.close();
}
}
return;
}
}
void JsonRpcClient::helloReply(const QVariantMap &params)
void JsonRpcClient::helloReply(int /*commandId*/, const QVariantMap &params)
{
if (params.value("status").toString() == "error") {
qWarning() << "Hello call failed. Trying again without locale";
m_id = 0;
sendCommand("JSONRPC.Hello", QVariantMap(), this, "helloReply");
} else {
QVariantMap dataMap = params.value("params").toMap();
m_initialSetupRequired = dataMap.value("initialSetupRequired").toBool();
m_authenticationRequired = dataMap.value("authenticationRequired").toBool();
m_pushButtonAuthAvailable = dataMap.value("pushButtonAuthAvailable").toBool();
emit pushButtonAuthAvailableChanged();
m_initialSetupRequired = params.value("initialSetupRequired").toBool();
m_authenticationRequired = params.value("authenticationRequired").toBool();
m_pushButtonAuthAvailable = params.value("pushButtonAuthAvailable").toBool();
emit pushButtonAuthAvailableChanged();
m_serverUuid = dataMap.value("uuid").toString();
m_serverVersion = dataMap.value("version").toString();
m_serverUuid = params.value("uuid").toString();
m_serverVersion = params.value("version").toString();
QString protoVersionString = dataMap.value("protocol version").toString();
if (!protoVersionString.contains('.')) {
protoVersionString.prepend("0.");
}
QString protoVersionString = params.value("protocol version").toString();
if (!protoVersionString.contains('.')) {
protoVersionString.prepend("0.");
}
m_jsonRpcVersion = QVersionNumber::fromString(protoVersionString);
m_jsonRpcVersion = QVersionNumber::fromString(protoVersionString);
qDebug() << "Handshake reply:" << "Protocol version:" << protoVersionString << "InitRequired:" << m_initialSetupRequired << "AuthRequired:" << m_authenticationRequired << "PushButtonAvailable:" << m_pushButtonAuthAvailable;;
qDebug() << "Handshake reply:" << "Protocol version:" << protoVersionString << "InitRequired:" << m_initialSetupRequired << "AuthRequired:" << m_authenticationRequired << "PushButtonAvailable:" << m_pushButtonAuthAvailable;;
QVersionNumber minimumRequiredVersion = QVersionNumber(1, 10);
if (m_jsonRpcVersion < minimumRequiredVersion) {
qWarning() << "Nymea core doesn't support minimum required version. Required:" << minimumRequiredVersion << "Found:" << m_jsonRpcVersion;
m_connection->disconnect();
emit invalidProtocolVersion(m_jsonRpcVersion.toString(), minimumRequiredVersion.toString());
return;
}
QVersionNumber minimumRequiredVersion = QVersionNumber(1, 10);
if (m_jsonRpcVersion < minimumRequiredVersion) {
qWarning() << "Nymea core doesn't support minimum required version. Required:" << minimumRequiredVersion << "Found:" << m_jsonRpcVersion;
m_connection->disconnect();
emit invalidProtocolVersion(m_jsonRpcVersion.toString(), minimumRequiredVersion.toString());
return;
}
// Verify SSL certificate
if (m_connection->isEncrypted()) {
QByteArray pem;
if (!loadPem(m_serverUuid, pem)) {
qDebug() << "No SSL certificate for this host stored. Accepting and pinning new certificate.";
// No certificate yet! Inform ui about it.
emit newSslCertificate();
storePem(m_serverUuid, m_connection->sslCertificate().toPem());
} else {
// We have a certificate pinned already. Check if it's the same
if (m_connection->sslCertificate().toPem() != pem) {
// Uh oh, the certificate has changed
qWarning() << "This connections certificate has changed!";
// Verify SSL certificate
if (m_connection->isEncrypted()) {
QByteArray pem;
if (!loadPem(m_serverUuid, pem)) {
qDebug() << "No SSL certificate for this host stored. Accepting and pinning new certificate.";
// No certificate yet! Inform ui about it.
emit newSslCertificate();
storePem(m_serverUuid, m_connection->sslCertificate().toPem());
} else {
// We have a certificate pinned already. Check if it's the same
if (m_connection->sslCertificate().toPem() != pem) {
// Uh oh, the certificate has changed
qWarning() << "This connections certificate has changed!";
QSslCertificate certificate = m_connection->sslCertificate();
QVariantMap issuerInfo = certificateIssuerInfo();
emit verifyConnectionCertificate(m_serverUuid, issuerInfo, certificate.toPem());
QSslCertificate certificate = m_connection->sslCertificate();
QVariantMap issuerInfo = certificateIssuerInfo();
emit verifyConnectionCertificate(m_serverUuid, issuerInfo, certificate.toPem());
// Reject the connection until the UI explicitly accepts this...
m_connection->disconnectFromHost();
// Reject the connection until the UI explicitly accepts this...
m_connection->disconnectFromHost();
return;
}
qDebug() << "This connections certificate is trusted.";
}
}
emit handshakeReceived();
if (m_connection->currentHost()->uuid().isNull()) {
qDebug() << "Updating Server UUID in connection:" << m_connection->currentHost()->uuid().toString() << "->" << m_serverUuid;
m_connection->currentHost()->setUuid(m_serverUuid);
}
if (m_initialSetupRequired) {
emit initialSetupRequiredChanged();
return;
}
if (m_authenticationRequired) {
QSettings settings;
settings.beginGroup("jsonTokens");
m_token = settings.value(m_serverUuid).toByteArray();
settings.endGroup();
emit authenticationRequiredChanged();
if (m_token.isEmpty()) {
return;
}
qDebug() << "This connections certificate is trusted.";
}
}
m_authenticated = true;
emit authenticatedChanged();
m_cacheHashes.clear();
qDebug() << "Hello reply:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson());
QVariantList cacheHashes = params.value("cacheHashes").toList();
foreach (const QVariant &cacheHash, cacheHashes) {
m_cacheHashes.insert(cacheHash.toMap().value("method").toString(), cacheHash.toMap().value("hash").toString());
}
qDebug() << "Caches:" << m_cacheHashes;
emit handshakeReceived();
if (m_connection->currentHost()->uuid().isNull()) {
qDebug() << "Updating Server UUID in connection:" << m_connection->currentHost()->uuid().toString() << "->" << m_serverUuid;
m_connection->currentHost()->setUuid(m_serverUuid);
}
if (m_initialSetupRequired) {
emit initialSetupRequiredChanged();
return;
}
if (m_authenticationRequired) {
QSettings settings;
settings.beginGroup("jsonTokens");
m_token = settings.value(m_serverUuid).toByteArray();
settings.endGroup();
emit authenticationRequiredChanged();
if (m_token.isEmpty()) {
return;
}
setNotificationsEnabled();
getCloudConnectionStatus();
m_authenticated = true;
emit authenticatedChanged();
}
setNotificationsEnabled();
getCloudConnectionStatus();
}
JsonRpcReply::JsonRpcReply(int commandId, QString nameSpace, QString method, QVariantMap params, QPointer<QObject> caller, const QString &callback):

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

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

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

@ -205,15 +205,15 @@ LogEntry *LogsModel::get(int index) const
return nullptr;
}
void LogsModel::logsReply(const QVariantMap &data)
void LogsModel::logsReply(int /*commandId*/, const QVariantMap &data)
{
int offset = data.value("params").toMap().value("offset").toInt();
int count = data.value("params").toMap().value("count").toInt();
int offset = data.value("offset").toInt();
int count = data.value("count").toInt();
// qDebug() << qUtf8Printable(QJsonDocument::fromVariant(data).toJson());
QList<LogEntry*> newBlock;
QList<QVariant> logEntries = data.value("params").toMap().value("logEntries").toList();
QList<QVariant> logEntries = data.value("logEntries").toList();
foreach (const QVariant &logEntryVariant, logEntries) {
QVariantMap entryMap = logEntryVariant.toMap();
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);
private slots:
virtual void logsReply(const QVariantMap &data);
virtual void logsReply(int commandId, const QVariantMap &data);
void newLogEntryReceived(const QVariantMap &data);
protected:

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

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

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

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

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

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

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");
}
void RuleManager::removeRule(const QUuid &ruleId)
int RuleManager::removeRule(const QUuid &ruleId)
{
QVariantMap params;
params.insert("ruleId", ruleId);
m_jsonClient->sendCommand("Rules.RemoveRule", params, this, "removeRuleReply");
return m_jsonClient->sendCommand("Rules.RemoveRule", params, this, "removeRuleReply");
}
void RuleManager::editRule(Rule *rule)
int RuleManager::editRule(Rule *rule)
{
QVariantMap params = packRule(rule);
qWarning() << "Packed rule:" << qUtf8Printable(QJsonDocument::fromVariant(params).toJson(QJsonDocument::Indented));
m_jsonClient->sendCommand("Rules.EditRule", params, this, "onEditRuleReply");
return m_jsonClient->sendCommand("Rules.EditRule", params, this, "onEditRuleReply");
}
void RuleManager::executeActions(const QString &ruleId)
int RuleManager::executeActions(const QString &ruleId)
{
QVariantMap params;
params.insert("ruleId", ruleId);
m_jsonClient->sendCommand("Rules.ExecuteActions", params, this, "onExecuteRuleActionsReply");
return m_jsonClient->sendCommand("Rules.ExecuteActions", params, this, "onExecuteRuleActionsReply");
}
void RuleManager::handleRulesNotification(const QVariantMap &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;
foreach (const QVariant &ruleDescriptionVariant, params.value("params").toMap().value("ruleDescriptions").toList()) {
foreach (const QVariant &ruleDescriptionVariant, params.value("ruleDescriptions").toList()) {
QUuid ruleId = ruleDescriptionVariant.toMap().value("id").toUuid();
QString name = ruleDescriptionVariant.toMap().value("name").toString();
bool enabled = ruleDescriptionVariant.toMap().value("enabled").toBool();
@ -180,9 +175,9 @@ void RuleManager::getRulesReply(const QVariantMap &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());
if (!rule) {
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());
}
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());
} 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") {
qDebug() << "Bad request editing rule:" << params.value("error").toString();
if (params.value("ruleError").toString() != "RuleErrorNoError") {
qDebug() << "Bad rule:" << params.value("ruleError").toString();
}
if (params.value("params").toMap().value("ruleError").toString() != "RuleErrorNoError") {
qDebug() << "Bad rule:" << params.value("params").toMap().value("ruleError").toString();
}
emit editRuleReply(params.value("params").toMap().value("ruleError").toString());
emit editRuleReply(commandId, params.value("ruleError").toString());
}
void RuleManager::onExecuteRuleActionsReply(const QVariantMap &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)

20
libnymea-app/rulemanager.h
View File

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

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");
}
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();
Script *script = new Script(id);
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(),
params.value("params").toMap().value("scriptError").toString(),
params.value("params").toMap().value("content").toString());
emit fetchScriptReply(commandId,
params.value("scriptError").toString(),
params.value("content").toString());
}
void ScriptManager::onScriptAdded(const QVariantMap &params)
void ScriptManager::onScriptAdded(int commandId, const QVariantMap &params)
{
emit addScriptReply(params.value("id").toInt(),
params.value("params").toMap().value("scriptError").toString(),
params.value("params").toMap().value("script").toMap().value("id").toUuid(),
params.value("params").toMap().value("errors").toStringList());
emit addScriptReply(commandId,
params.value("scriptError").toString(),
params.value("script").toMap().value("id").toUuid(),
params.value("errors").toStringList());
}
void ScriptManager::onScriptEdited(const QVariantMap &params)
void ScriptManager::onScriptEdited(int commandId, const QVariantMap &params)
{
emit editScriptReply(params.value("id").toInt(),
params.value("params").toMap().value("scriptError").toString(),
params.value("params").toMap().value("errors").toStringList());
emit editScriptReply(commandId,
params.value("scriptError").toString(),
params.value("errors").toStringList());
}
void ScriptManager::onScriptRenamed(const QVariantMap &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)
@ -154,16 +154,11 @@ void ScriptManager::onNotificationReceived(const QVariantMap &params)
Script *script = new Script(scriptMap.value("id").toUuid());
script->setName(scriptMap.value("name").toString());
m_scripts->addScript(script);
emit addScriptReply(params.value("id").toInt(),
params.value("params").toMap().value("scriptError").toString(),
params.value("params").toMap().value("scriptId").toUuid(),
params.value("params").toMap().value("errors").toStringList());
}
else if (params.value("notification").toString() == "Scripts.ScriptRemoved") {
QUuid id = params.value("params").toMap().value("id").toUuid();
m_scripts->removeScript(id);
emit removeScriptReply(params.value("id").toInt(), params.value("params").toMap().value("scriptError").toString());
}
else if (params.value("notification").toString() == "Scripts.ScriptChanged") {

12
libnymea-app/scriptmanager.h
View File

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

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

@ -152,13 +152,13 @@ QDateTime SystemController::serverTime() const
return m_serverTime;
}
void SystemController::setServerTime(const QDateTime &serverTime)
int SystemController::setServerTime(const QDateTime &serverTime)
{
QVariantMap params;
params.insert("automaticTime", false);
params.insert("time", serverTime.toSecsSinceEpoch());
params.insert("timeZone", serverTime.timeZone().id());
m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse");
return m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse");
}
QStringList SystemController::timeZones() const
@ -179,11 +179,11 @@ QString SystemController::serverTimeZone() const
return m_serverTimeZone;
}
void SystemController::setServerTimeZone(const QString &serverTimeZone)
int SystemController::setServerTimeZone(const QString &serverTimeZone)
{
QVariantMap params;
params.insert("timeZone", serverTimeZone);
m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse");
return m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse");
}
bool SystemController::automaticTimeAvailable() const
@ -196,22 +196,22 @@ bool SystemController::automaticTime() const
return m_automaticTime;
}
void SystemController::setAutomaticTime(bool automaticTime)
int SystemController::setAutomaticTime(bool automaticTime)
{
QVariantMap params;
params.insert("automaticTime", automaticTime);
m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse");
return m_jsonRpcClient->sendCommand("System.SetTime", params, this, "setTimeResponse");
}
void SystemController::getCapabilitiesResponse(const QVariantMap &data)
void SystemController::getCapabilitiesResponse(int /*commandId*/, const QVariantMap &data)
{
m_powerManagementAvailable = data.value("params").toMap().value("powerManagement").toBool();
m_powerManagementAvailable = data.value("powerManagement").toBool();
emit powerManagementAvailableChanged();
m_updateManagementAvailable = data.value("params").toMap().value("updateManagement").toBool();
m_updateManagementAvailable = data.value("updateManagement").toBool();
emit updateManagementAvailableChanged();
m_timeManagementAvailable = data.value("params").toMap().value("timeManagement").toBool();
m_timeManagementAvailable = data.value("timeManagement").toBool();
emit timeManagementAvailableChanged();
if (m_updateManagementAvailable) {
@ -227,16 +227,16 @@ void SystemController::getCapabilitiesResponse(const QVariantMap &data)
qDebug() << "nymea:core capabilities: Power management:" << m_powerManagementAvailable << "Update management:" << m_updateManagementAvailable << "Time management:" << m_timeManagementAvailable;
}
void SystemController::getUpdateStatusResponse(const QVariantMap &data)
void SystemController::getUpdateStatusResponse(int /*commandId*/, const QVariantMap &data)
{
m_updateManagementBusy = data.value("params").toMap().value("busy").toBool();
m_updateRunning = data.value("params").toMap().value("updateRunning").toBool();
m_updateManagementBusy = data.value("busy").toBool();
m_updateRunning = data.value("updateRunning").toBool();
emit updateRunningChanged();
}
void SystemController::getPackagesResponse(const QVariantMap &data)
void SystemController::getPackagesResponse(int commandId, const QVariantMap &data)
{
foreach (const QVariant &packageVariant, data.value("params").toMap().value("packages").toList()) {
foreach (const QVariant &packageVariant, data.value("packages").toList()) {
QString id = packageVariant.toMap().value("id").toString();
QString displayName = packageVariant.toMap().value("displayName").toString();
Package *p = new Package(id, displayName);
@ -251,9 +251,9 @@ void SystemController::getPackagesResponse(const QVariantMap &data)
}
}
void SystemController::getRepositoriesResponse(const QVariantMap &data)
void SystemController::getRepositoriesResponse(int /*commandId*/, const QVariantMap &data)
{
foreach (const QVariant &repoVariant, data.value("params").toMap().value("repositories").toList()) {
foreach (const QVariant &repoVariant, data.value("repositories").toList()) {
QString id = repoVariant.toMap().value("id").toString();
QString displayName = repoVariant.toMap().value("displayName").toString();
Repository *repo = new Repository(id, displayName);
@ -262,61 +262,58 @@ void SystemController::getRepositoriesResponse(const QVariantMap &data)
}
}
void SystemController::removePackageResponse(const QVariantMap &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;
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
// Which doesn't allow to create QTimeZone objects by IANA id.... So, let's keep that separated in a string
// https://bugreports.qt.io/browse/QTBUG-83438
// m_serverTime.setTimeZone(QTimeZone(params.value("params").toMap().value("timeZone").toString().toUtf8()));
m_serverTimeZone = params.value("params").toMap().value("timeZone").toString();
// m_serverTime.setTimeZone(QTimeZone(params.value("timeZone").toString().toUtf8()));
m_serverTimeZone = params.value("timeZone").toString();
emit serverTimeChanged();
emit serverTimeZoneChanged();
m_automaticTimeAvailable = params.value("params").toMap().value("automaticTimeAvailable").toBool();
m_automaticTimeAvailable = params.value("automaticTimeAvailable").toBool();
emit automaticTimeAvailableChanged();
m_automaticTime = params.value("params").toMap().value("automaticTime").toBool();
m_automaticTime = params.value("automaticTime").toBool();
emit automaticTimeChanged();
qDebug() << "Server time:" << m_serverTime << "Automatic Time available:" << m_automaticTimeAvailable << "Automatic time:" << m_automaticTime;
}
void SystemController::setTimeResponse(const QVariantMap &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("params").toMap().value("success").toBool();
emit restartReply(id, success);
bool success = params.value("success").toBool();
emit restartReply(commandId, 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("params").toMap().value("success").toBool();
emit rebootReply(id, success);
bool success = params.value("success").toBool();
emit rebootReply(commandId, 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("params").toMap().value("success").toBool();
emit shutdownReply(id, success);
bool success = params.value("success").toBool();
emit shutdownReply(commandId, success);
}
void SystemController::notificationReceived(const QVariantMap &data)

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

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

28
libnymea-app/tagsmanager.cpp
View File

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

14
libnymea-app/tagsmanager.h
View File

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

8
libnymea-app/thinggroup.cpp
View File

@ -56,11 +56,11 @@ ThingGroup::ThingGroup(DeviceManager *deviceManager, DeviceClass *deviceClass, D
syncStates();
});
connect(m_thingManager, &DeviceManager::executeActionReply, this, [this](const QVariantMap &params){
int returningId = params.value("id").toInt();
connect(m_thingManager, &DeviceManager::executeActionReply, this, [this](int commandId, const QVariantMap &/*params*/){
// This should maybe check the params and only emit NoError if there is at least one thing that returned without error?
foreach (int id, m_pendingActions.keys()) {
if (m_pendingActions.value(id).contains(returningId)) {
m_pendingActions[id].removeAll(returningId);
if (m_pendingActions.value(id).contains(commandId)) {
m_pendingActions[id].removeAll(commandId);
if (m_pendingActions[id].isEmpty()) {
m_pendingActions.remove(id);
emit actionExecutionFinished(id, "DeviceErrorNoError");

28
libnymea-app/usermanager.cpp
View File

@ -73,17 +73,17 @@ void UserManager::notificationReceived(const QVariantMap &data)
qDebug() << "Users notification" << data;
}
void UserManager::getUserInfoReply(const QVariantMap &data)
void UserManager::getUserInfoReply(int commandId, const QVariantMap &data)
{
qDebug() << "User info reply" << data;
qDebug() << "User info reply" << commandId << data;
m_userInfo->setUsername(data.value("params").toMap().value("userInfo").toMap().value("username").toString());
m_userInfo->setUsername(data.value("userInfo").toMap().value("username").toString());
}
void UserManager::getTokensReply(const QVariantMap &data)
void UserManager::getTokensReply(int /*commandId*/, const QVariantMap &data)
{
foreach (const QVariant &tokenVariant, data.value("params").toMap().value("tokenInfoList").toList()) {
foreach (const QVariant &tokenVariant, data.value("tokenInfoList").toList()) {
// qDebug() << "Token received" << tokenVariant.toMap();
QVariantMap token = tokenVariant.toMap();
QUuid id = token.value("id").toString();
@ -98,32 +98,28 @@ void UserManager::getTokensReply(const QVariantMap &data)
void UserManager::deleteTokenReply(const QVariantMap &payload)
void UserManager::deleteTokenReply(int commandId, const QVariantMap &params)
{
qDebug() << "Delete token reply" << payload;
int callId = payload.value("id").toInt();
QUuid tokenId = m_tokensToBeRemoved.take(callId);
QVariantMap params = payload.value("params").toMap();
qDebug() << "Delete token reply" << commandId << params;
QUuid tokenId = m_tokensToBeRemoved.take(commandId);
QString errorString = params.value("error").toString();
QMetaEnum metaEnum = QMetaEnum::fromType<UserManager::UserError>();
UserError error = static_cast<UserError>(metaEnum.keyToValue(errorString.toUtf8()));
emit deleteTokenResponse(callId, error);
emit deleteTokenResponse(commandId, error);
if (error == UserErrorNoError) {
m_tokenInfos->removeToken(tokenId);
}
}
void UserManager::changePasswordReply(const QVariantMap &data)
void UserManager::changePasswordReply(int commandId, const QVariantMap &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();
QMetaEnum metaEnum = QMetaEnum::fromType<UserManager::UserError>();
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:
void notificationReceived(const QVariantMap &data);
void getUserInfoReply(const QVariantMap &data);
void getTokensReply(const QVariantMap &data);
void deleteTokenReply(const QVariantMap &data);
void changePasswordReply(const QVariantMap &data);
void getUserInfoReply(int commandId, const QVariantMap &data);
void getTokensReply(int commandId, const QVariantMap &data);
void deleteTokenReply(int commandId, const QVariantMap &params);
void changePasswordReply(int commandId, const QVariantMap &params);
private:
Engine *m_engine = nullptr;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -56,11 +56,11 @@ Page {
Connections {
target: engine.deviceManager
onSavePluginConfigReply: {
if (params.params.deviceError === "DeviceErrorNoError") {
if (params.deviceError === "DeviceErrorNoError") {
pageStack.pop();
} else {
console.warn("Error saving plugin params:", JSON.stringify(params))
var dialog = errorDialog.createObject(root, {errorCode: params.params.deviceError});
var dialog = errorDialog.createObject(root, {errorCode: params.deviceError});
dialog.open();
}
}