switch json api to better type system and enhance error reporting

libguh/devicemanager.cpp

@@ -139,14 +139,14 @@ DevicePlugin *DeviceManager::plugin(const PluginId &id) const
     return m_devicePlugins.value(id);
 }
 
-QPair<DeviceManager::DeviceError, QString> DeviceManager::setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig)
+DeviceManager::DeviceError DeviceManager::setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig)
 {
     DevicePlugin *plugin = m_devicePlugins.value(pluginId);
     if (!plugin) {
-        return report(DeviceErrorPluginNotFound, QString("No plugin with id % 1").arg(pluginId.toString()));
+        return DeviceErrorPluginNotFound;
     }
-    QPair<DeviceError, QString> result = plugin->setConfiguration(pluginConfig);
+    DeviceError result = plugin->setConfiguration(pluginConfig);
-    if (result.first != DeviceErrorNoError) {
+    if (result != DeviceErrorNoError) {
         return result;
     }
     QSettings settings;
@@ -257,67 +257,67 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassI
     return addConfiguredDeviceInternal(deviceClassId, descriptor.params(), deviceId);
 }
 
-QPair<DeviceManager::DeviceError, QString> DeviceManager::pairDevice(const DeviceClassId &deviceClassId, const ParamList &params)
+DeviceManager::DeviceError DeviceManager::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
 {
     DeviceClass deviceClass = findDeviceClass(deviceClassId);
     if (deviceClass.id().isNull()) {
         qWarning() << "cannot find a device class with id" << deviceClassId;
-        return qMakePair<DeviceError, QString>(DeviceErrorDeviceClassNotFound, deviceClassId.toString());
+        return DeviceErrorDeviceClassNotFound;
     }
 
-    if (deviceClass.setupMethod() == DeviceClass::SetupMethodJustAdd) {
+    switch (deviceClass.setupMethod()) {
+    case DeviceClass::SetupMethodJustAdd:
         qWarning() << "Cannot setup this device this way. No need to pair this device.";
-        return qMakePair<DeviceError, QString>(DeviceErrorCreationMethodNotSupported, "No need to pair this device.");
+        return DeviceErrorSetupMethodNotSupported;
+    case DeviceClass::SetupMethodDisplayPin:
+        qWarning() << "SetupMethodDisplayPin not implemented yet for this CreateMethod";
+        return DeviceErrorSetupFailed;
+    case DeviceClass::SetupMethodEnterPin:
+        qWarning() << "SetupMethodEnterPin not implemented yet for this CreateMethod";
+        return DeviceErrorSetupFailed;
+    case DeviceClass::SetupMethodPushButton:
+        qWarning() << "SetupMethodPushButton not implemented yet for this CreateMethod";
+        return DeviceErrorSetupFailed;
     }
 
-    QUuid pairingTransactionId = QUuid::createUuid();
+    return DeviceErrorNoError;
-    m_pairingsJustAdd.insert(pairingTransactionId, qMakePair<DeviceClassId, ParamList>(deviceClassId, params));
-
-    if (deviceClass.setupMethod() == DeviceClass::SetupMethodDisplayPin) {
-        // TODO: fetch PIN from device plugin
-        qWarning() << "SetupMethodDisplayPin not implemented yet";
-        return qMakePair<DeviceError, QString>(DeviceErrorSetupFailed, "SetupMethodDisplayPin Not implemented yet.");
-    }
-
-    return qMakePair<DeviceError, QString>(DeviceErrorNoError, pairingTransactionId.toString());
 }
 
-QPair<DeviceManager::DeviceError, QString> DeviceManager::pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId)
+DeviceManager::DeviceError DeviceManager::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId)
 {
     DeviceClass deviceClass = findDeviceClass(deviceClassId);
     if (deviceClass.id().isNull()) {
         qWarning() << "cannot find a device class with id" << deviceClassId;
-        return qMakePair<DeviceError, QString>(DeviceErrorDeviceClassNotFound, deviceClassId.toString());
+        return DeviceErrorDeviceClassNotFound;
     }
 
     if (deviceClass.setupMethod() == DeviceClass::SetupMethodJustAdd) {
         qWarning() << "Cannot setup this device this way. No need to pair this device.";
-        return qMakePair<DeviceError, QString>(DeviceErrorCreationMethodNotSupported, "No need to pair this device.");
+        return DeviceErrorCreationMethodNotSupported;
     }
 
     if (!m_discoveredDevices.contains(deviceDescriptorId)) {
         qWarning() << "Cannot find a DeviceDescriptor with ID" << deviceClassId.toString();
-        return qMakePair<DeviceError, QString>(DeviceErrorDeviceDescriptorNotFound, deviceDescriptorId.toString());
+        return DeviceErrorDeviceDescriptorNotFound;
     }
 
-    QUuid pairingTransactionId = QUuid::createUuid();
     m_pairingsDiscovery.insert(pairingTransactionId, qMakePair<DeviceClassId, DeviceDescriptorId>(deviceClassId, deviceDescriptorId));
 
     if (deviceClass.setupMethod() == DeviceClass::SetupMethodDisplayPin) {
         // TODO: fetch PIN from device plugin
         qWarning() << "SetupMethodDisplayPin not implemented yet";
-        return qMakePair<DeviceError, QString>(DeviceErrorSetupFailed, "SetupMethodDisplayPin Not implemented yet.");
+        return DeviceErrorSetupFailed;
     }
 
-    return qMakePair<DeviceError, QString>(DeviceErrorNoError, pairingTransactionId.toString());
+    return DeviceErrorNoError;
 }
 
-QPair<DeviceManager::DeviceError, QString> DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QString &secret)
+DeviceManager::DeviceError DeviceManager::confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret)
 {
     if (m_pairingsJustAdd.contains(pairingTransactionId)) {
         qWarning() << "this SetupMethod is not implemented yet";
         m_pairingsJustAdd.remove(pairingTransactionId);
-        return qMakePair<DeviceError, QString>(DeviceErrorSetupFailed, "Not implemented yet");
+        return DeviceErrorSetupFailed;
     }
 
     if (m_pairingsDiscovery.contains(pairingTransactionId)) {
@@ -330,23 +330,23 @@ QPair<DeviceManager::DeviceError, QString> DeviceManager::confirmPairing(const Q
 
         if (!plugin) {
             qWarning() << "Can't find a plugin for this device class";
-            return report(DeviceErrorPluginNotFound, m_supportedDevices.value(deviceClassId).pluginId().toString());
+            return DeviceErrorPluginNotFound;
         }
 
-        QPair<DeviceSetupStatus, QString> status = plugin->confirmPairing(pairingTransactionId, deviceClassId, deviceDescriptor.params());
+        DeviceSetupStatus status = plugin->confirmPairing(pairingTransactionId, deviceClassId, deviceDescriptor.params());
-        switch (status.first) {
+        switch (status) {
         case DeviceSetupStatusSuccess:
             m_pairingsDiscovery.remove(pairingTransactionId);
-            return report(DeviceErrorNoError);
+            return DeviceErrorNoError;
         case DeviceSetupStatusFailure:
             m_pairingsDiscovery.remove(pairingTransactionId);
-            return report(DeviceErrorSetupFailed, status.second);
+            return DeviceErrorSetupFailed;
         case DeviceSetupStatusAsync:
-            return report(DeviceErrorAsync);
+            return DeviceErrorAsync;
         }
     }
 
-    return report(DeviceErrorPairingTransactionIdNotFound, pairingTransactionId.toString());
+    return DeviceErrorPairingTransactionIdNotFound;
 }
 
 DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId id)
@@ -381,8 +381,8 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const Devi
     device->setName(deviceClass.name());
     device->setParams(effectiveParams);
 
-    QPair<DeviceSetupStatus, QString> status = setupDevice(device);
+    DeviceSetupStatus status = setupDevice(device);
-    switch (status.first) {
+    switch (status) {
     case DeviceSetupStatusFailure:
         qWarning() << "Device setup failed. Not adding device to system.";
         delete device;
@@ -400,11 +400,11 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const Devi
     return DeviceErrorNoError;
 }
 
-QPair<DeviceManager::DeviceError, QString> DeviceManager::removeConfiguredDevice(const DeviceId &deviceId)
+DeviceManager::DeviceError DeviceManager::removeConfiguredDevice(const DeviceId &deviceId)
 {
     Device *device = findConfiguredDevice(deviceId);
     if (!device) {
-        return qMakePair<DeviceError, QString>(DeviceErrorDeviceNotFound, deviceId.toString());
+        return DeviceErrorDeviceNotFound;
     }
 
     m_configuredDevices.removeAll(device);
@@ -423,7 +423,7 @@ QPair<DeviceManager::DeviceError, QString> DeviceManager::removeConfiguredDevice
     settings.remove("");
     settings.endGroup();
 
-    return qMakePair<DeviceError, QString>(DeviceErrorNoError, QString());
+    return DeviceErrorNoError;
 }
 
 /*! Returns the \l{Device} with the given \a id. Null if the id couldn't be found. */
@@ -473,7 +473,6 @@ DeviceClass DeviceManager::findDeviceClass(const DeviceClassId &deviceClassId) c
 DeviceManager::DeviceError DeviceManager::executeAction(const Action &action)
 {
     Action finalAction = action;
-    qDebug() << "should execute action";
     foreach (Device *device, m_configuredDevices) {
         if (action.deviceId() == device->id()) {
             // found device
@@ -482,7 +481,6 @@ DeviceManager::DeviceError DeviceManager::executeAction(const Action &action)
             DeviceClass deviceClass = findDeviceClass(device->deviceClassId());
             bool found = false;
             foreach (const ActionType &actionType, deviceClass.actionTypes()) {
-                qDebug() << "checking" << actionType.id() << action.actionTypeId();
                 if (actionType.id() == action.actionTypeId()) {
                     ParamList finalParams = action.params();
                     DeviceError paramCheck = verifyParams(actionType.paramTypes(), finalParams);
@@ -573,6 +571,12 @@ void DeviceManager::loadPlugins()
                 if (status.first != DeviceErrorNoError) {
                     qWarning() << "Error setting params to plugin. Broken configuration?" << status.second;
                 }
+            }
+            settings.endGroup();
+            DeviceError status = pluginIface->setConfiguration(params);
+            if (status != DeviceErrorNoError) {
+                qWarning() << "Error setting params to plugin. Broken configuration?";
+            }
 
                 m_devicePlugins.insert(pluginIface->pluginId(), pluginIface);
                 connect(pluginIface, &DevicePlugin::emitEvent, this, &DeviceManager::eventTriggered);
@@ -607,8 +611,6 @@ void DeviceManager::loadConfiguredDevices()
         settings.endGroup();
         settings.endGroup();
 
-        //qDebug() << "found stored device" << device->id() << device->name() << device->deviceClassId() << device->pluginId();
-
         // We always add the device to the list in this case. If its in the storedDevices
         // it means that it was working at some point so lets still add it as there might
         // be rules associated with this device. Device::setupCompleted() will be false.
@@ -655,7 +657,7 @@ void DeviceManager::slotDevicesDiscovered(const DeviceClassId &deviceClassId, co
     emit devicesDiscovered(deviceClassId, deviceDescriptors);
 }
 
-void DeviceManager::slotDeviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status, const QString &errorMessage)
+void DeviceManager::slotDeviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status)
 {
     Q_ASSERT_X(device, "DeviceManager", "Device must be a valid pointer.");
     if (!device) {
@@ -677,11 +679,11 @@ void DeviceManager::slotDeviceSetupFinished(Device *device, DeviceManager::Devic
     if (status == DeviceSetupStatusFailure) {
         if (m_configuredDevices.contains(device)) {
             qWarning() << QString("Error in device setup. Device %1 (%2) will not be functional.").arg(device->name()).arg(device->id().toString());
-            emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed, QString("Device setup failed: %1").arg(errorMessage));
+            emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed);
             return;
         } else {
             qWarning() << QString("Error in device setup. Device %1 (%2) will not be added to the configured devices.").arg(device->name()).arg(device->id().toString());
-            emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed, QString("Device setup failed: %1").arg(errorMessage));
+            emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed);
             return;
         }
     }
@@ -706,10 +708,10 @@ void DeviceManager::slotDeviceSetupFinished(Device *device, DeviceManager::Devic
     connect(device, SIGNAL(stateValueChanged(QUuid,QVariant)), this, SLOT(slotDeviceStateValueChanged(QUuid,QVariant)));
 
     device->setupCompleted();
-    emit deviceSetupFinished(device, DeviceManager::DeviceErrorNoError, QString());
+    emit deviceSetupFinished(device, DeviceManager::DeviceErrorNoError);
 }
 
-void DeviceManager::slotPairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceSetupStatus status, const QString &errorMessage)
+void DeviceManager::slotPairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceSetupStatus status)
 {
     if (!m_pairingsJustAdd.contains(pairingTransactionId) && !m_pairingsDiscovery.contains(pairingTransactionId)) {
         DevicePlugin *plugin = dynamic_cast<DevicePlugin*>(sender());
@@ -741,11 +743,8 @@ void DeviceManager::slotPairingFinished(const QUuid &pairingTransactionId, Devic
         params = descriptor.params();
     }
 
-
-    qDebug() << "pairingfinsihed!" << errorMessage;
     if (status != DeviceSetupStatusSuccess) {
-        qDebug() << "emitting shit";
+        emit pairingFinished(pairingTransactionId, DeviceErrorSetupFailed);
-        emit pairingFinished(pairingTransactionId, DeviceErrorSetupFailed, errorMessage);
         return;
     }
 
@@ -759,20 +758,18 @@ void DeviceManager::slotPairingFinished(const QUuid &pairingTransactionId, Devic
 
     // Ok... pairing went fine... Let consumers know about it and inform them about the ongoing setup with a deviceId.
     DeviceId id = DeviceId::createDeviceId();
-    emit pairingFinished(pairingTransactionId, DeviceErrorNoError, QString(), id);
+    emit pairingFinished(pairingTransactionId, DeviceErrorNoError, id);
 
     QList<DeviceId> newDevices;
-    QString setupErrorMessage;
     Device *device = new Device(plugin->pluginId(), id, deviceClassId, this);
     device->setName(deviceClass.name());
     device->setParams(params);
 
-    QPair<DeviceSetupStatus, QString> setupStatus = setupDevice(device);
+    DeviceSetupStatus setupStatus = setupDevice(device);
-    switch (setupStatus.first) {
+    switch (setupStatus) {
     case DeviceSetupStatusFailure:
         qWarning() << "Device setup failed. Not adding device to system.";
-        setupErrorMessage = setupStatus.second;
+        emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed);
-        emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed, QString("Device setup failed: %1").arg(errorMessage));
         delete device;
         break;
     case DeviceSetupStatusAsync:
@@ -786,7 +783,7 @@ void DeviceManager::slotPairingFinished(const QUuid &pairingTransactionId, Devic
     m_configuredDevices.append(device);
     storeConfiguredDevices();
 
-    emit deviceSetupFinished(device, DeviceError::DeviceErrorNoError, QString());
+    emit deviceSetupFinished(device, DeviceError::DeviceErrorNoError);
 }
 
 void DeviceManager::autoDevicesAppeared(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> &deviceDescriptors)
@@ -805,18 +802,18 @@ void DeviceManager::autoDevicesAppeared(const DeviceClassId &deviceClassId, cons
         device->setName(deviceClass.name());
         device->setParams(deviceDescriptor.params());
 
-        QPair<DeviceSetupStatus, QString> setupStatus = setupDevice(device);
+        DeviceSetupStatus setupStatus = setupDevice(device);
-        switch (setupStatus.first) {
+        switch (setupStatus) {
         case DeviceSetupStatusFailure:
             qWarning() << "Device setup failed. Not adding device to system.";
-            emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed, QString("Device setup failed: %1").arg(setupStatus.second));
+            emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed);
             delete device;
             break;
         case DeviceSetupStatusAsync:
             break;
         case DeviceSetupStatusSuccess:
             qDebug() << "Device setup complete.";
-            emit deviceSetupFinished(device, DeviceError::DeviceErrorNoError, QString());
+            emit deviceSetupFinished(device, DeviceError::DeviceErrorNoError);
             m_configuredDevices.append(device);
             storeConfiguredDevices();
             break;
@@ -884,13 +881,14 @@ bool DeviceManager::verifyPluginMetadata(const QJsonObject &data)
     return true;
 }
 
-QPair<DeviceManager::DeviceSetupStatus,QString> DeviceManager::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DeviceManager::setupDevice(Device *device)
 {
     DeviceClass deviceClass = findDeviceClass(device->deviceClassId());
     DevicePlugin *plugin = m_devicePlugins.value(deviceClass.pluginId());
 
     if (!plugin) {
-        return qMakePair<DeviceSetupStatus, QString>(DeviceSetupStatusFailure, "Can't find a plugin for this device");
+        qWarning() << "Can't find a plugin for this device" << device->id();
+        return DeviceSetupStatusFailure;
     }
 
     QList<State> states;
@@ -901,8 +899,8 @@ QPair<DeviceManager::DeviceSetupStatus,QString> DeviceManager::setupDevice(Devic
     }
     device->setStates(states);
 
-    QPair<DeviceSetupStatus, QString> status = plugin->setupDevice(device);
+    DeviceSetupStatus status = plugin->setupDevice(device);
-    if (status.first != DeviceSetupStatusSuccess) {
+    if (status != DeviceSetupStatusSuccess) {
         return status;
     }
 
@@ -995,8 +993,3 @@ DeviceManager::DeviceError DeviceManager::verifyParam(const ParamType &paramType
     qWarning() << "Parameter name" << param.name() << "does not match with ParamType name" << paramType.name();
     return DeviceErrorInvalidParameter;
 }
-
-QPair<DeviceManager::DeviceError, QString> DeviceManager::report(DeviceManager::DeviceError error, const QString &message)
-{
-    return qMakePair<DeviceManager::DeviceError, QString>(error, message);
-}

libguh/devicemanager.h

@@ -49,21 +49,24 @@ public:
 
     enum DeviceError {
         DeviceErrorNoError,
+        DeviceErrorPluginNotFound,
         DeviceErrorDeviceNotFound,
         DeviceErrorDeviceClassNotFound,
         DeviceErrorActionTypeNotFound,
+        DeviceErrorStateTypeNotFound,
+        DeviceErrorEventTypeNotFound,
+        DeviceErrorDeviceDescriptorNotFound,
         DeviceErrorMissingParameter,
         DeviceErrorInvalidParameter,
-        DeviceErrorPluginNotFound,
         DeviceErrorSetupFailed,
         DeviceErrorDuplicateUuid,
         DeviceErrorCreationMethodNotSupported,
-        DeviceErrorActionParameterError,
+        DeviceErrorSetupMethodNotSupported,
         DeviceErrorHardwareNotAvailable,
-        DeviceErrorDeviceDescriptorNotFound,
+        DeviceErrorHardwareFailure,
         DeviceErrorAsync,
+        DeviceErrorDeviceInUse,
         DeviceErrorPairingTransactionIdNotFound,
-        // Don't forget to update JsonTypes!
     };
 
     enum DeviceSetupStatus {
@@ -77,7 +80,7 @@ public:
 
     QList<DevicePlugin*> plugins() const;
     DevicePlugin* plugin(const PluginId &id) const;
-    QPair<DeviceError, QString> setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig);
+    DeviceError setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig);
 
     QList<Vendor> supportedVendors() const;
     QList<DeviceClass> supportedDevices(const VendorId &vendorId = VendorId()) const;
@@ -86,10 +89,10 @@ public:
     QList<Device*> configuredDevices() const;
     DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId id = DeviceId::createDeviceId());
     DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &id = DeviceId::createDeviceId());
-    QPair<DeviceError, QString> pairDevice(const DeviceClassId &deviceClassId, const ParamList &params);
+    DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params);
-    QPair<DeviceError, QString> pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId);
+    DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId);
-    QPair<DeviceError, QString> confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString());
+    DeviceError confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret = QString());
-    QPair<DeviceError, QString> removeConfiguredDevice(const DeviceId &deviceId);
+    DeviceError removeConfiguredDevice(const DeviceId &deviceId);
 
     Device* findConfiguredDevice(const DeviceId &id) const;
     QList<Device*> findConfiguredDevices(const DeviceClassId &deviceClassId) const;
@@ -100,9 +103,9 @@ signals:
     void eventTriggered(const Event &event);
     void deviceStateChanged(Device *device, const QUuid &stateTypeId, const QVariant &value);
     void devicesDiscovered(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> &devices);
-    void deviceSetupFinished(Device *device, DeviceError status, const QString &errorMessage);
+    void deviceSetupFinished(Device *device, DeviceError status);
-    void pairingFinished(const QUuid &pairingTransactionId, DeviceError status, const QString &errorMessage, const DeviceId &deviceId = DeviceId());
+    void pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceError status, const DeviceId &deviceId = DeviceId());
-    void actionExecutionFinished(const ActionId, DeviceError status, const QString &errorMessage);
+    void actionExecutionFinished(const ActionId, DeviceError status);
 
 public slots:
     DeviceError executeAction(const Action &action);
@@ -113,8 +116,8 @@ private slots:
     void storeConfiguredDevices();
     void startMonitoringAutoDevices();
     void slotDevicesDiscovered(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> deviceDescriptors);
-    void slotDeviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status, const QString &errorMessage);
+    void slotDeviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status);
-    void slotPairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceSetupStatus status, const QString &errorMessage);
+    void slotPairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceSetupStatus status);
     void autoDevicesAppeared(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> &deviceDescriptors);
 
     // Only connect this to Devices. It will query the sender()
@@ -126,13 +129,11 @@ private slots:
 private:
     bool verifyPluginMetadata(const QJsonObject &data);
     DeviceError addConfiguredDeviceInternal(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId id = DeviceId::createDeviceId());
-    QPair<DeviceSetupStatus, QString> setupDevice(Device *device);
+    DeviceSetupStatus setupDevice(Device *device);
     DeviceError verifyParams(const QList<ParamType> paramTypes, ParamList &params, bool requireAll = true);
     DeviceError verifyParam(const QList<ParamType> paramTypes, const Param &param);
     DeviceError verifyParam(const ParamType &paramType, const Param &param);
 
-    QPair<DeviceError, QString> report(DeviceError error = DeviceErrorNoError, const QString &message = QString());
-
 private:
 
     QHash<VendorId, Vendor> m_supportedVendors;

libguh/plugin/deviceplugin.cpp

@@ -78,7 +78,7 @@ pure virtual methods: \l{DevicePlugin::pluginName()}, \l{DevicePlugin::pluginId(
  */
 
 /*!
-  \fn void DevicePlugin::actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage)
+  \fn void DevicePlugin::actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status)
   This signal is to be emitted when you previously have returned DeviceManager::DeviceErrorAsync
   in a call of executeAction(). It is used to deliver the return value that previously has
   been omitted by filling in DeviceErrorAsync.
@@ -163,7 +163,6 @@ QList<DeviceClass> DevicePlugin::supportedDevices() const
             deviceClass.setCreateMethods(createMethods);
 
             deviceClass.setDiscoveryParamTypes(parseParamTypes(jo.value("discoveryParamTypes").toArray()));
-            qDebug() << "loaded deviceClass" << deviceClass.discoveryParamTypes();
 
             QString setupMethod = jo.value("setupMethod").toString();
             if (setupMethod == "pushButton") {
@@ -179,7 +178,6 @@ QList<DeviceClass> DevicePlugin::supportedDevices() const
             deviceClass.setParamTypes(parseParamTypes(jo.value("paramTypes").toArray()));
 
             QList<StateType> stateTypes;
-            qDebug() << "############### s" << jo;
             foreach (const QJsonValue &stateTypesJson, jo.value("stateTypes").toArray()) {
                 QJsonObject st = stateTypesJson.toObject();
                 QVariant::Type t = QVariant::nameToType(st.value("type").toString().toLatin1().data());
@@ -197,7 +195,6 @@ QList<DeviceClass> DevicePlugin::supportedDevices() const
                 ActionType actionType(at.value("id").toString());
                 actionType.setName(at.value("name").toString());
                 actionType.setParamTypes(parseParamTypes(at.value("paramTypes").toArray()));
-                qDebug() << "***got actionType" << actionType.id();
                 actionTypes.append(actionType);
             }
             deviceClass.setActionTypes(actionTypes);
@@ -250,10 +247,10 @@ DeviceManager::DeviceError DevicePlugin::discoverDevices(const DeviceClassId &de
     \l{deviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status)} to report
     the status.
 */
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePlugin::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DevicePlugin::setupDevice(Device *device)
 {
     Q_UNUSED(device)
-    return reportDeviceSetup();
+    return DeviceManager::DeviceSetupStatusSuccess;
 }
 
 /*! This will be called when a device removed. The plugin has the chance to do some teardown.
@@ -265,13 +262,14 @@ void DevicePlugin::deviceRemoved(Device *device)
     Q_UNUSED(device)
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePlugin::confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
+DeviceManager::DeviceSetupStatus DevicePlugin::confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
 {
     Q_UNUSED(pairingTransactionId)
     Q_UNUSED(deviceClassId)
     Q_UNUSED(params)
 
-    return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Plugin does not implement pairing.");
+    qWarning() << "Plugin does not implement pairing.";
+    return DeviceManager::DeviceSetupStatusFailure;
 }
 
 QList<ParamType> DevicePlugin::configurationDescription() const
@@ -340,58 +338,62 @@ QVariant DevicePlugin::configValue(const QString &paramName) const
 /*!
  Will be called by the DeviceManager to set a plugin's \a configuration.
  */
-QPair<DeviceManager::DeviceError, QString> DevicePlugin::setConfiguration(const ParamList &configuration)
+DeviceManager::DeviceError DevicePlugin::setConfiguration(const ParamList &configuration)
 {
     foreach (const Param &param, configuration) {
         qDebug() << "setting config" << param;
-        QPair<DeviceManager::DeviceError, QString> result = setConfigValue(param.name(), param.value());
+        DeviceManager::DeviceError result = setConfigValue(param.name(), param.value());
-        if (result.first != DeviceManager::DeviceErrorNoError) {
+        if (result != DeviceManager::DeviceErrorNoError) {
             return result;
         }
     }
-    return report();
+    return DeviceManager::DeviceErrorNoError;
 }
 
 /*!
  Will be called by the DeviceManager to set a plugin's \a configuration.
  */
-QPair<DeviceManager::DeviceError, QString> DevicePlugin::setConfigValue(const QString &paramName, const QVariant &value)
+DeviceManager::DeviceError DevicePlugin::setConfigValue(const QString &paramName, const QVariant &value)
 {
     bool found = false;
     foreach (const ParamType &paramType, configurationDescription()) {
         if (paramType.name() == paramName) {
             if (!value.canConvert(paramType.type())) {
-                return report(DeviceManager::DeviceErrorInvalidParameter, QString("Wrong parameter type for param %1. Got %2. Expected %3.")
+                qWarning() << QString("Wrong parameter type for param %1. Got %2. Expected %3.")
-                              .arg(paramName).arg(value.toString()).arg(QVariant::typeToName(paramType.type())));
+                    .arg(paramName).arg(value.toString()).arg(QVariant::typeToName(paramType.type()));
+                return DeviceManager::DeviceErrorInvalidParameter;
             }
 
             if (paramType.maxValue().isValid() && value > paramType.maxValue()) {
-                return report(DeviceManager::DeviceErrorInvalidParameter, QString("Value out of range for param %1. Got %2. Max: %3.")
+                qWarning() << QString("Value out of range for param %1. Got %2. Max: %3.")
-                              .arg(paramName).arg(value.toString()).arg(paramType.maxValue().toString()));
+                        .arg(paramName).arg(value.toString()).arg(paramType.maxValue().toString());
+                return DeviceManager::DeviceErrorInvalidParameter;
             }
             if (paramType.minValue().isValid() && value < paramType.minValue()) {
-                return report(DeviceManager::DeviceErrorInvalidParameter, QString("Value out of range for param %1. Got: %2. Min: %3.")
+                qWarning() << QString("Value out of range for param %1. Got: %2. Min: %3.")
-                              .arg(paramName).arg(value.toString()).arg(paramType.minValue().toString()));
+                        .arg(paramName).arg(value.toString()).arg(paramType.minValue().toString());
+                return DeviceManager::DeviceErrorInvalidParameter;
             }
             found = true;
             break;
         }
     }
     if (!found) {
-        return report(DeviceManager::DeviceErrorInvalidParameter, QString("Invalid parameter %1.").arg(paramName));
+        qWarning() << QString("Invalid parameter %1.").arg(paramName);
+        return DeviceManager::DeviceErrorInvalidParameter;
     }
     for (int i = 0; i < m_config.count(); i++) {
         if (m_config.at(i).name() == paramName) {
             m_config[i].setValue(value);
             emit configValueChanged(paramName, value);
-            return report();
+            return DeviceManager::DeviceErrorNoError;
         }
     }
     // Still here? need to create the param
     Param newParam(paramName, value);
     m_config.append(newParam);
     emit configValueChanged(paramName, value);
-    return report();
+    return DeviceManager::DeviceErrorNoError;
 }
 
 /*!
@@ -463,19 +465,3 @@ bool DevicePlugin::transmitData(int delay, QList<int> rawData)
     }
     return false;
 }
-
-/*!
- Constructs a status report to be returned. By default (when called without
- arguments) this will report \l{DeviceManager::DeviceErrorNoError} and an
- empty message.
- Keep the message short, the DeviceManager will format it for you.
- */
-QPair<DeviceManager::DeviceError, QString> DevicePlugin::report(DeviceManager::DeviceError error, const QString &message)
-{
-    return qMakePair<DeviceManager::DeviceError, QString>(error, message);
-}
-
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePlugin::reportDeviceSetup(DeviceManager::DeviceSetupStatus status, const QString &message)
-{
-    return qMakePair<DeviceManager::DeviceSetupStatus, QString>(status, message);
-}

libguh/plugin/deviceplugin.h

@@ -53,10 +53,10 @@ public:
     virtual void startMonitoringAutoDevices();
     virtual DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params);
 
-    virtual QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device);
+    virtual DeviceManager::DeviceSetupStatus setupDevice(Device *device);
     virtual void deviceRemoved(Device *device);
 
-    virtual QPair<DeviceManager::DeviceSetupStatus, QString> confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params);
+    virtual DeviceManager::DeviceSetupStatus confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params);
 
     // Hardware input
     virtual void radioData(const QList<int> &rawData) {Q_UNUSED(rawData)}
@@ -64,10 +64,10 @@ public:
 
     // Configuration
     virtual QList<ParamType> configurationDescription() const;
-    QPair<DeviceManager::DeviceError, QString> setConfiguration(const ParamList &configuration);
+    DeviceManager::DeviceError setConfiguration(const ParamList &configuration);
     ParamList configuration() const;
     QVariant configValue(const QString &paramName) const;
-    QPair<DeviceManager::DeviceError, QString> setConfigValue(const QString &paramName, const QVariant &value);
+    DeviceManager::DeviceError setConfigValue(const QString &paramName, const QVariant &value);
 
 public slots:
     virtual DeviceManager::DeviceError executeAction(Device *device, const Action &action) {
@@ -78,9 +78,9 @@ public slots:
 signals:
     void emitEvent(const Event &event);
     void devicesDiscovered(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> &deviceDescriptors);
-    void deviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status, const QString &errorMessage);
+    void deviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status);
-    void pairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceSetupStatus status, const QString &errorMessage);
+    void pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceSetupStatus status);
-    void actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage);
+    void actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status);
     void configValueChanged(const QString &paramName, const QVariant &value);
     void autoDevicesAppeared(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> &deviceDescriptors);
 
@@ -91,8 +91,6 @@ protected:
 
     bool transmitData(int delay, QList<int> rawData);
 
-    QPair<DeviceManager::DeviceError, QString> report(DeviceManager::DeviceError error = DeviceManager::DeviceErrorNoError, const QString &message = QString());
-    QPair<DeviceManager::DeviceSetupStatus, QString> reportDeviceSetup(DeviceManager::DeviceSetupStatus status = DeviceManager::DeviceSetupStatusSuccess, const QString &message = QString());
 private:
     void initPlugin(const QJsonObject &metaData, DeviceManager *deviceManager);
 

libguh/typeutils.h

@@ -50,6 +50,8 @@ DECLARE_TYPE_ID(Action)
 DECLARE_TYPE_ID(Plugin)
 DECLARE_TYPE_ID(Rule)
 
+DECLARE_TYPE_ID(PairingTransaction)
+
 class Types
 {
     Q_GADGET

plugins/deviceplugins/eq-3/deviceplugineq-3.cpp

@@ -261,7 +261,7 @@ void DevicePluginEQ3::startMonitoringAutoDevices()
 
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginEQ3::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DevicePluginEQ3::setupDevice(Device *device)
 {
     qDebug() << "setupDevice" << device->params();
 
@@ -269,7 +269,7 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginEQ3::setupDevice(De
         foreach (MaxCube *cube, m_cubes.keys()) {
             if(cube->serialNumber() == device->paramValue("serial number").toString()){
                 qDebug() << cube->serialNumber() << " allready exists...";
-                return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure,QString("Cube allready in added"));
+                return DeviceManager::DeviceSetupStatusFailure;
             }
         }
 
@@ -286,13 +286,13 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginEQ3::setupDevice(De
 
         cube->connectToCube();
 
-        return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync);
+        return DeviceManager::DeviceSetupStatusAsync;
     }
     if(device->deviceClassId() == wallThermostateDeviceClassId){
         device->setName("Max! Wall Thermostat (" + device->paramValue("serial number").toString() + ")");
     }
 
-    return reportDeviceSetup();
+    return DeviceManager::DeviceSetupStatusSuccess;
 }
 
 void DevicePluginEQ3::deviceRemoved(Device *device)
@@ -354,7 +354,7 @@ void DevicePluginEQ3::cubeConnectionStatusChanged(const bool &connected)
             device = m_cubes.value(cube);
             device->setName("Max! Cube " + cube->serialNumber());
             device->setStateValue(connectionStateTypeId,true);
-            emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess, QString());
+            emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess);
         }
     }else{
         MaxCube *cube = static_cast<MaxCube*>(sender());
@@ -362,7 +362,7 @@ void DevicePluginEQ3::cubeConnectionStatusChanged(const bool &connected)
         if (m_cubes.contains(cube)){
             device = m_cubes.value(cube);
             device->setStateValue(connectionStateTypeId,false);
-            emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure, QString("Could not connect to cube."));
+            emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure);
         }
     }
 }
@@ -391,9 +391,9 @@ void DevicePluginEQ3::discoveryDone(const QList<MaxCube *> &cubeList)
 void DevicePluginEQ3::commandActionFinished(const bool &succeeded, const ActionId &actionId)
 {
     if(succeeded){
-        emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorNoError,QString());
+        emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorNoError);
     }else{
-        emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorSetupFailed,QString("Could not execute action on cube, unknown error"));
+        emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorSetupFailed);
     }
 }
 

plugins/deviceplugins/eq-3/deviceplugineq-3.h

@@ -43,7 +43,7 @@ public:
 
     void startMonitoringAutoDevices() override;
 
-    QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
+    DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
     void deviceRemoved(Device *device) override;
     void guhTimer() override;
 

plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.cpp

@@ -78,7 +78,7 @@ DeviceManager::DeviceError DevicePluginLgSmartTv::discoverDevices(const DeviceCl
     return DeviceManager::DeviceErrorAsync;
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginLgSmartTv::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DevicePluginLgSmartTv::setupDevice(Device *device)
 {
 
     device->setName("LG Smart Tv (" + device->paramValue("model").toString() + ")");
@@ -102,7 +102,7 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginLgSmartTv::setupDev
     tvDevice->requestPairing();
     m_tvList.insert(tvDevice,device);
 
-    return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync);
+    return DeviceManager::DeviceSetupStatusAsync;
 }
 
 DeviceManager::HardwareResources DevicePluginLgSmartTv::requiredHardware() const
@@ -201,19 +201,19 @@ void DevicePluginLgSmartTv::pairingFinished(const bool &success)
     Device *device = m_tvList.value(tvDevice);
 
     if(success){
-        emit deviceSetupFinished(device,DeviceManager::DeviceSetupStatusSuccess,QString(""));
+        emit deviceSetupFinished(device,DeviceManager::DeviceSetupStatusSuccess);
         tvDevice->refresh();
     }else{
-        emit deviceSetupFinished(device,DeviceManager::DeviceSetupStatusFailure,QString("Could not pair with tv."));
+        emit deviceSetupFinished(device,DeviceManager::DeviceSetupStatusFailure);
     }
 }
 
 void DevicePluginLgSmartTv::sendingCommandFinished(const bool &success, const ActionId &actionId)
 {
     if(success){
-        emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorNoError,QString());
+        emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorNoError);
     }else{
-        emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorActionTypeNotFound,QString("Could not send command"));
+        emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorHardwareFailure);
     }
 }
 

plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.h

@@ -35,7 +35,7 @@ public:
     TvDiscovery *m_discovery;
 
     DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
-    QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
+    DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
     DeviceManager::HardwareResources requiredHardware() const override;
     DeviceManager::DeviceError executeAction(Device *device, const Action &action) override;
 

plugins/deviceplugins/mailnotification/devicepluginmailnotification.cpp

@@ -245,7 +245,7 @@ DevicePluginMailNotification::~DevicePluginMailNotification()
     m_smtpClient->deleteLater();
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginMailNotification::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DevicePluginMailNotification::setupDevice(Device *device)
 {
     // Google mail
 //    if(device->deviceClassId() == googleMailDeviceClassId){
@@ -255,7 +255,7 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginMailNotification::s
 //        m_smtpClient->setHost("smtp.gmail.com");
 //        m_smtpClient->login(device->paramValue("user").toString(), device->paramValue("password").toString());
 //    }
-    return reportDeviceSetup();
+    return DeviceManager::DeviceSetupStatusSuccess;
 }
 
 DeviceManager::HardwareResources DevicePluginMailNotification::requiredHardware() const

plugins/deviceplugins/mailnotification/devicepluginmailnotification.h

@@ -33,7 +33,7 @@ public:
     explicit DevicePluginMailNotification();
     ~DevicePluginMailNotification();
 
-    QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
+    DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
     DeviceManager::HardwareResources requiredHardware() const override;
     DeviceManager::DeviceError executeAction(Device *device, const Action &action) override;
 

plugins/deviceplugins/mock/devicepluginmock.cpp

@@ -58,20 +58,21 @@ DeviceManager::DeviceError DevicePluginMock::discoverDevices(const DeviceClassId
     return DeviceManager::DeviceErrorAsync;
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginMock::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DevicePluginMock::setupDevice(Device *device)
 {
     qDebug() << "Mockdevice created returning true" << device->paramValue("httpport").toInt() << device->paramValue("async").toBool() << device->paramValue("broken").toBool();
 
     if (device->paramValue("broken").toBool()) {
-        return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "This device is intentionally broken.");
+        qWarning() << "This device is intentionally broken.";
+        return DeviceManager::DeviceSetupStatusFailure;
     }
 
     HttpDaemon *daemon = new HttpDaemon(device, this);
     m_daemons.insert(device, daemon);
 
     if (!daemon->isListening()) {
-        qDebug() << "HTTP port opening failed.";
+        qWarning() << "HTTP port opening failed.";
-        return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, QString("Could not bind port."));
+        return DeviceManager::DeviceSetupStatusFailure;
     }
 
     connect(daemon, &HttpDaemon::triggerEvent, this, &DevicePluginMock::triggerEvent);
@@ -80,9 +81,9 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginMock::setupDevice(D
     if (device->paramValue("async").toBool()) {
         m_asyncSetupDevices.append(device);
         QTimer::singleShot(1000, this, SLOT(emitDeviceSetupFinished()));
-        return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync);
+        return DeviceManager::DeviceSetupStatusAsync;
     }
-    return reportDeviceSetup();
+    return DeviceManager::DeviceSetupStatusSuccess;
 }
 
 void DevicePluginMock::deviceRemoved(Device *device)
@@ -129,7 +130,6 @@ QList<ParamType> DevicePluginMock::configurationDescription() const
 DeviceManager::DeviceError DevicePluginMock::executeAction(Device *device, const Action &action)
 {
     if (!myDevices().contains(device)) {
-        qWarning() << "Should execute action for a device which doesn't seem to be mine.";
         return DeviceManager::DeviceErrorDeviceNotFound;
     }
 
@@ -143,7 +143,6 @@ DeviceManager::DeviceError DevicePluginMock::executeAction(Device *device, const
         return DeviceManager::DeviceErrorSetupFailed;
     }
 
-    qDebug() << "Should execute action" << action.actionTypeId();
     m_daemons.value(device)->actionExecuted(action.actionTypeId());
     return DeviceManager::DeviceErrorNoError;
 }
@@ -204,9 +203,9 @@ void DevicePluginMock::emitDeviceSetupFinished()
     qDebug() << "emitting setup finised";
     Device *device = m_asyncSetupDevices.takeFirst();
     if (device->paramValue("broken").toBool()) {
-        emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure, QString("This device is intentionally broken"));
+        emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure);
     } else {
-        emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess, QString());
+        emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess);
     }
 }
 
@@ -215,8 +214,8 @@ void DevicePluginMock::emitActionExecuted()
     QPair<Action, Device*> action = m_asyncActions.takeFirst();
     if (action.first.actionTypeId() == mockActionIdAsync) {
         m_daemons.value(action.second)->actionExecuted(action.first.actionTypeId());
-        emit actionExecutionFinished(action.first.id(), DeviceManager::DeviceErrorNoError, QString());
+        emit actionExecutionFinished(action.first.id(), DeviceManager::DeviceErrorNoError);
     } else if (action.first.actionTypeId() == mockActionIdAsyncFailing) {
-        emit actionExecutionFinished(action.first.id(), DeviceManager::DeviceErrorSetupFailed, QString());
+        emit actionExecutionFinished(action.first.id(), DeviceManager::DeviceErrorSetupFailed);
     }
 }

plugins/deviceplugins/mock/devicepluginmock.h

@@ -39,7 +39,7 @@ public:
     DeviceManager::HardwareResources requiredHardware() const override;
     DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
 
-    QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
+    DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
     void deviceRemoved(Device *device) override;
 
     void startMonitoringAutoDevices() override;

plugins/deviceplugins/mock/httpdaemon.cpp

@@ -160,7 +160,6 @@ QString HttpDaemon::generateWebPage()
 
     body.append("<table>");
     for (int i = 0; i < deviceClass.eventTypes().count(); ++i) {
-        qDebug() << "adding eventType" << deviceClass.eventTypes().at(i).name();
         const EventType &eventType = deviceClass.eventTypes().at(i);
         body.append(QString(
         "<tr>"

plugins/deviceplugins/openweathermap/devicepluginopenweathermap.cpp

@@ -325,18 +325,19 @@ DeviceManager::DeviceError DevicePluginOpenweathermap::discoverDevices(const Dev
     return DeviceManager::DeviceErrorAsync;
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginOpenweathermap::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DevicePluginOpenweathermap::setupDevice(Device *device)
 {
     foreach (Device *deviceListDevice, deviceManager()->findConfiguredDevices(openweathermapDeviceClassId)) {
         if(deviceListDevice->paramValue("id").toString() == device->paramValue("id").toString()){
-            return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure,QString("Location " + device->paramValue("location").toString() + " already added."));
+            qWarning() << QString("Location " + device->paramValue("location").toString() + "already in added");
+            return DeviceManager::DeviceSetupStatusFailure;
         }
     }
 
     device->setName("Weather from OpenWeatherMap (" + device->paramValue("location").toString() + ")");
     m_openweaher->update(device->paramValue("id").toString(), device->id());
 
-    return reportDeviceSetup(DeviceManager::DeviceSetupStatusSuccess);
+    return DeviceManager::DeviceSetupStatusSuccess;
 }
 
 DeviceManager::HardwareResources DevicePluginOpenweathermap::requiredHardware() const

plugins/deviceplugins/openweathermap/devicepluginopenweathermap.h

@@ -36,7 +36,7 @@ public:
     OpenWeatherMap *m_openweaher;
 
     DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
-    QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
+    DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
     DeviceManager::HardwareResources requiredHardware() const override;
     DeviceManager::DeviceError executeAction(Device *device, const Action &action) override;
 

plugins/deviceplugins/philipshue/devicepluginphilipshue.cpp

@@ -77,7 +77,7 @@ DeviceManager::DeviceError DevicePluginPhilipsHue::discoverDevices(const DeviceC
     return DeviceManager::DeviceErrorAsync;
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DevicePluginPhilipsHue::setupDevice(Device *device)
 {
     qDebug() << "setupDevice" << device->params();
 
@@ -90,7 +90,8 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::setupDe
             device->setParamValue("number", light->id());
         } else {
             // this shouldn't ever happen
-            return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Device not configured yet and no discovered devices around.");
+            qWarning() << "Device not configured yet and no discovered devices around. This should not happen.";
+            return DeviceManager::DeviceSetupStatusFailure;
         }
     } else {
         // In this case it most likely comes from the config. Just read all values from there...
@@ -116,11 +117,10 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::setupDe
         descriptorList.append(descriptor);
     }
     if (!descriptorList.isEmpty()) {
-        qDebug() << "adding" << descriptorList.count() << "autodevices";
         metaObject()->invokeMethod(this, "autoDevicesAppeared", Qt::QueuedConnection, Q_ARG(DeviceClassId, hueDeviceClassId), Q_ARG(QList<DeviceDescriptor>, descriptorList));
     }
 
-    return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync);
+    return DeviceManager::DeviceSetupStatusAsync;
 }
 
 void DevicePluginPhilipsHue::deviceRemoved(Device *device)
@@ -134,7 +134,7 @@ void DevicePluginPhilipsHue::deviceRemoved(Device *device)
     m_unconfiguredLights.append(light);
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
+DeviceManager::DeviceSetupStatus DevicePluginPhilipsHue::confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
 {
     Param ipParam;
     foreach (const Param &param, params) {
@@ -143,7 +143,8 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::confirm
         }
     }
     if (!ipParam.isValid()) {
-        return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Missing parameter: ip");
+        qWarning() << "Missing parameter: ip";
+        return DeviceManager::DeviceSetupStatusFailure;
     }
     Param usernameParam;
     foreach (const Param &param, params) {
@@ -152,7 +153,8 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::confirm
         }
     }
     if (!usernameParam.isValid()) {
-        return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Missing parameter: username");
+        qWarning() << "Missing parameter: username";
+        return DeviceManager::DeviceSetupStatusFailure;
     }
 
     int id = m_bridge->createUser(QHostAddress(ipParam.value().toString()), usernameParam.value().toString());
@@ -161,7 +163,7 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::confirm
     pi.ipParam = ipParam;
     pi.usernameParam = usernameParam;
     m_pairings.insert(id, pi);
-    return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync);
+    return DeviceManager::DeviceSetupStatusAsync;
 }
 
 void DevicePluginPhilipsHue::guhTimer()
@@ -173,8 +175,6 @@ void DevicePluginPhilipsHue::guhTimer()
 
 DeviceManager::DeviceError DevicePluginPhilipsHue::executeAction(Device *device, const Action &action)
 {
-    qDebug() << "Should execute action in hue plugin";
-
     Light *light = m_lights.key(device);
     if (!light) {
         return DeviceManager::DeviceErrorDeviceNotFound;
@@ -222,7 +222,7 @@ void DevicePluginPhilipsHue::createUserFinished(int id, const QVariant &response
     PairingInfo pairingInfo = m_pairings.take(id);
     if (response.toMap().contains("error")) {
         qDebug() << "Failed to pair Hue bridge:" << response.toMap().value("error").toMap().value("description");
-        emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusFailure, "Pairing failed:" + response.toMap().value("error").toMap().value("description").toString());
+        emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusFailure);
         return;
     }
 
@@ -240,7 +240,7 @@ void DevicePluginPhilipsHue::getLightsFinished(int id, const QVariant &params)
 
     if (params.toMap().count() == 0) {
         qWarning() << "No light bulbs found on this hue bridge... Cannot proceed with pairing.";
-        emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusFailure, "No light bulbs found on this Hue bridge.");
+        emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusFailure);
         return;
     }
 
@@ -250,7 +250,7 @@ void DevicePluginPhilipsHue::getLightsFinished(int id, const QVariant &params)
         m_unconfiguredLights.insert(lightId.toInt(), light);
     }
 
-    emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusSuccess, QString());
+    emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusSuccess);
 
     // If we have more than one device on that bridge, tell DeviceManager that there are more.
     if (params.toMap().count() > 1) {
@@ -271,7 +271,7 @@ void DevicePluginPhilipsHue::lightStateChanged()
     if (m_asyncSetups.contains(light)) {
         device = m_asyncSetups.take(light);
         device->setName(light->name());
-        emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess, QString());
+        emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess);
     } else {
         device = m_lights.value(light);
     }

plugins/deviceplugins/philipshue/devicepluginphilipshue.h

@@ -43,10 +43,10 @@ public:
     QList<ParamType> configurationDescription() const override;
     DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
 
-    QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
+    DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
     void deviceRemoved(Device *device) override;
 
-    QPair<DeviceManager::DeviceSetupStatus, QString> confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params) override;
+    DeviceManager::DeviceSetupStatus confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params) override;
 
     void guhTimer() override;
 
@@ -67,7 +67,7 @@ private:
 
     class PairingInfo {
     public:
-        QUuid pairingTransactionId;
+        PairingTransactionId pairingTransactionId;
         Param ipParam;
         Param usernameParam;
     };

plugins/deviceplugins/wemo/devicepluginwemo.cpp

@@ -157,13 +157,13 @@ DeviceManager::DeviceError DevicePluginWemo::discoverDevices(const DeviceClassId
     return DeviceManager::DeviceErrorAsync;
 }
 
-QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginWemo::setupDevice(Device *device)
+DeviceManager::DeviceSetupStatus DevicePluginWemo::setupDevice(Device *device)
 {
     if(device->deviceClassId() == wemoSwitchDeviceClassId){
         foreach (WemoSwitch *wemoSwitch, m_wemoSwitches.keys()) {
             if(wemoSwitch->serialNumber() == device->paramValue("serial number").toString()){
                 qWarning() << wemoSwitch->serialNumber() << " allready exists...";
-                return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure,QString("Device allready added"));
+                return DeviceManager::DeviceSetupStatusFailure;
             }
         }
 
@@ -186,9 +186,9 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginWemo::setupDevice(D
 
         m_wemoSwitches.insert(wemoSwitch,device);
         wemoSwitch->refresh();
-        return reportDeviceSetup();
+        return DeviceManager::DeviceSetupStatusSuccess;
     }
-    return reportDeviceSetup(DeviceManager::DeviceSetupStatusSuccess);
+    return DeviceManager::DeviceSetupStatusSuccess;
 }
 
 DeviceManager::HardwareResources DevicePluginWemo::requiredHardware() const
@@ -267,9 +267,9 @@ void DevicePluginWemo::wemoSwitchStateChanged()
 void DevicePluginWemo::setPowerFinished(const bool &succeeded, const ActionId &actionId)
 {
     if(succeeded){
-        emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorNoError,QString());
+        emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorNoError);
     }else{
-        emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorDeviceNotFound,QString("Action could not be executed."));
+        emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorHardwareFailure);
     }
 }
 

plugins/deviceplugins/wemo/devicepluginwemo.h

@@ -33,7 +33,7 @@ public:
     explicit DevicePluginWemo();
 
     DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
-    QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
+    DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
     DeviceManager::HardwareResources requiredHardware() const override;
     DeviceManager::DeviceError executeAction(Device *device, const Action &action) override;
 

server/guhcore.cpp

@@ -63,7 +63,7 @@ QList<DevicePlugin *> GuhCore::plugins() const
     return m_deviceManager->plugins();
 }
 
-QPair<DeviceManager::DeviceError, QString> GuhCore::setPluginConfig(const PluginId &pluginId, const ParamList &params)
+DeviceManager::DeviceError GuhCore::setPluginConfig(const PluginId &pluginId, const ParamList &params)
 {
     return m_deviceManager->setPluginConfig(pluginId, params);
 }
@@ -78,7 +78,7 @@ QList<DeviceClass> GuhCore::supportedDevices(const VendorId &vendorId) const
     return m_deviceManager->supportedDevices(vendorId);
 }
 
-QPair<DeviceManager::DeviceError, QString> GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList)
+DeviceManager::DeviceError GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList)
 {
     QHash<RuleId, RuleEngine::RemovePolicy> toBeChanged;
     QList<RuleId> unhandledRules;
@@ -97,7 +97,8 @@ QPair<DeviceManager::DeviceError, QString> GuhCore::removeConfiguredDevice(const
     }
 
     if (!unhandledRules.isEmpty()) {
-        return qMakePair<DeviceManager::DeviceError, QString>(DeviceManager::DeviceErrorMissingParameter, "There are unhandled rules which depend on this device.");
+        qWarning() << "There are unhandled rules which depend on this device.";
+        return DeviceManager::DeviceErrorDeviceInUse;
     }
 
     // Update the rules...
@@ -112,17 +113,17 @@ QPair<DeviceManager::DeviceError, QString> GuhCore::removeConfiguredDevice(const
     return m_deviceManager->removeConfiguredDevice(deviceId);
 }
 
-QPair<DeviceManager::DeviceError, QString> GuhCore::pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId)
+DeviceManager::DeviceError GuhCore::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId)
 {
-    return m_deviceManager->pairDevice(deviceClassId, deviceDescriptorId);
+    return m_deviceManager->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId);
 }
 
-QPair<DeviceManager::DeviceError, QString> GuhCore::pairDevice(const DeviceClassId &deviceClassId, const ParamList &params)
+DeviceManager::DeviceError GuhCore::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
 {
-    return m_deviceManager->pairDevice(deviceClassId, params);
+    return m_deviceManager->pairDevice(pairingTransactionId, deviceClassId, params);
 }
 
-QPair<DeviceManager::DeviceError, QString> GuhCore::confirmPairing(const QUuid &pairingTransactionId, const QString &secret)
+DeviceManager::DeviceError GuhCore::confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret)
 {
     return m_deviceManager->confirmPairing(pairingTransactionId, secret);
 }
@@ -259,7 +260,7 @@ void GuhCore::gotEvent(const Event &event)
         case DeviceManager::DeviceErrorSetupFailed:
             qDebug() << "Error executing action. Device setup failed.";
             break;
-        case DeviceManager::DeviceErrorActionParameterError:
+        case DeviceManager::DeviceErrorInvalidParameter:
             qDebug() << "Error executing action. Invalid action parameter.";
             break;
         default:

server/guhcore.h

@@ -43,7 +43,7 @@ public:
     void destroy();
 
     QList<DevicePlugin *> plugins() const;
-    QPair<DeviceManager::DeviceError, QString> setPluginConfig(const PluginId &pluginId, const ParamList &params);
+    DeviceManager::DeviceError setPluginConfig(const PluginId &pluginId, const ParamList &params);
 
     // Device handling
     QList<Vendor> supportedVendors() const;
@@ -55,11 +55,11 @@ public:
     QList<Device*> configuredDevices() const;
     Device *findConfiguredDevice(const DeviceId &deviceId) const;
     QList<Device*> findConfiguredDevices(const DeviceClassId &deviceClassId) const;
-    QPair<DeviceManager::DeviceError, QString> removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList);
+    DeviceManager::DeviceError removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList);
 
-    QPair<DeviceManager::DeviceError, QString> pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId);
+    DeviceManager::DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId);
-    QPair<DeviceManager::DeviceError, QString> pairDevice(const DeviceClassId &deviceClassId, const ParamList &params);
+    DeviceManager::DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params);
-    QPair<DeviceManager::DeviceError, QString> confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString());
+    DeviceManager::DeviceError confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret = QString());
 
     DeviceManager::DeviceError executeAction(const Action &action);
 
@@ -73,11 +73,11 @@ public:
 signals:
     void eventTriggered(const Event &event);
     void deviceStateChanged(Device *device, const QUuid &stateTypeId, const QVariant &value);
-    void actionExecuted(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage);
+    void actionExecuted(const ActionId &id, DeviceManager::DeviceError status);
 
     void devicesDiscovered(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> deviceDescriptors);
     void deviceSetupFinished(Device *device, DeviceManager::DeviceError status);
-    void pairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceError status, const QString &errorMessage, const DeviceId &deviceId);
+    void pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceError status, const DeviceId &deviceId);
 
 private:
     RuleEngine *ruleEngine() const;

server/jsonrpc/actionhandler.cpp

@@ -33,15 +33,14 @@ ActionHandler::ActionHandler(QObject *parent) :
     params.clear(); returns.clear();
     setDescription("ExecuteAction", "Execute a single action.");
     setParams("ExecuteAction", JsonTypes::actionDescription());
-    returns.insert("success", "bool");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
-    returns.insert("errorMessage", "string");
     setReturns("ExecuteAction", returns);
 
     params.clear(); returns.clear();
     setDescription("GetActionType", "Get the ActionType for the given ActionTypeId");
-    params.insert("actionTypeId", "uuid");
+    params.insert("actionTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("GetActionType", params);
-    returns.insert("deviceError", "int");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
     returns.insert("o:actionType", JsonTypes::actionTypeDescription());
     setReturns("GetActionType", returns);
 
@@ -63,9 +62,6 @@ JsonReply* ActionHandler::ExecuteAction(const QVariantMap &params)
     Action action(actionTypeId, deviceId);
     action.setParams(actionParams);
 
-    qDebug() << "actions params in json" << action.params() << params;
-
-
     DeviceManager::DeviceError status = GuhCore::instance()->executeAction(action);
     if (status == DeviceManager::DeviceErrorAsync) {
         JsonReply *reply = createAsyncReply("ExecuteAction");
@@ -73,9 +69,7 @@ JsonReply* ActionHandler::ExecuteAction(const QVariantMap &params)
         return reply;
     }
 
-    QVariantMap returns;
+    return createReply(statusToReply(status));
-    returns.insert("deviceError", status);
-    return createReply(returns);
 }
 
 JsonReply *ActionHandler::GetActionType(const QVariantMap &params) const
@@ -84,32 +78,29 @@ JsonReply *ActionHandler::GetActionType(const QVariantMap &params) const
     foreach (const DeviceClass &deviceClass, GuhCore::instance()->supportedDevices()) {
         foreach (const ActionType &actionType, deviceClass.actionTypes()) {
             if (actionType.id() == actionTypeId) {
-                QVariantMap data;
+                QVariantMap data = statusToReply(DeviceManager::DeviceErrorNoError);
-                data.insert("deviceError", DeviceManager::DeviceErrorNoError);
                 data.insert("actionType", JsonTypes::packActionType(actionType));
                 return createReply(data);
             }
         }
     }
-    QVariantMap data;
+    return createReply(statusToReply(DeviceManager::DeviceErrorActionTypeNotFound));
-    data.insert("deviceError", DeviceManager::DeviceErrorActionTypeNotFound);
-    return createReply(data);
 }
 
-void ActionHandler::actionExecuted(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage)
+void ActionHandler::actionExecuted(const ActionId &id, DeviceManager::DeviceError status)
 {
     if (!m_asyncActionExecutions.contains(id)) {
         return; // Not the action we are waiting for.
     }
 
     JsonReply *reply = m_asyncActionExecutions.take(id);
-    reply->setData(statusToReply(status, errorMessage));
+    reply->setData(statusToReply(status));
     reply->finished();
 }
 
-QVariantMap ActionHandler::statusToReply(DeviceManager::DeviceError status, const QString &errorMessage)
+QVariantMap ActionHandler::statusToReply(DeviceManager::DeviceError status) const
 {
     QVariantMap returns;
-    returns.insert("deviceError", status);
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
     return returns;
 }

server/jsonrpc/actionhandler.h

@@ -35,10 +35,10 @@ public:
     Q_INVOKABLE JsonReply* GetActionType(const QVariantMap &params) const;
 
 private slots:
-    void actionExecuted(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage);
+    void actionExecuted(const ActionId &id, DeviceManager::DeviceError status);
 
 private:
-    QVariantMap statusToReply(DeviceManager::DeviceError status, const QString &errorMessage);
+    QVariantMap statusToReply(DeviceManager::DeviceError status) const;
 
 private:
     QHash<ActionId, JsonReply*> m_asyncActionExecutions;

server/jsonrpc/devicehandler.cpp

@@ -41,7 +41,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
 
     params.clear(); returns.clear();
     setDescription("GetSupportedDevices", "Returns a list of supported Device classes, optionally filtered by vendorId.");
-    params.insert("o:vendorId", "uuid");
+    params.insert("o:vendorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("GetSupportedDevices", params);
     QVariantList deviceClasses;
     deviceClasses.append(JsonTypes::deviceClassRef());
@@ -58,20 +58,20 @@ DeviceHandler::DeviceHandler(QObject *parent) :
 
     params.clear(); returns.clear();
     setDescription("GetPluginConfiguration", "Get a plugin's params.");
-    params.insert("pluginId", "uuid");
+    params.insert("pluginId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("GetPluginConfiguration", params);
     QVariantList pluginParams;
     pluginParams.append(JsonTypes::paramRef());
-    returns.insert("deviceError", "DeviceError");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
     returns.insert("o:configuration", pluginParams);
     setReturns("GetPluginConfiguration", returns);
 
     params.clear(); returns.clear();
     setDescription("SetPluginConfiguration", "Set a plugin's params.");
-    params.insert("pluginId", "uuid");
+    params.insert("pluginId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     params.insert("configuration", pluginParams);
     setParams("SetPluginConfiguration", params);
-    returns.insert("deviceError", "DeviceError");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
     setReturns("SetPluginConfiguration", returns);
 
     params.clear(); returns.clear();
@@ -81,14 +81,14 @@ DeviceHandler::DeviceHandler(QObject *parent) :
                    "CreateMethodJustAdd takes the parameters you want to have with that device. "
                    "CreateMethodDiscovery requires the use of a deviceDescriptorId."
                    );
-    params.insert("deviceClassId", "uuid");
+    params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
-    params.insert("o:deviceDescriptorId", "uuid");
+    params.insert("o:deviceDescriptorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     QVariantList deviceParams;
     deviceParams.append(JsonTypes::paramRef());
     params.insert("o:deviceParams", deviceParams);
     setParams("AddConfiguredDevice", params);
-    returns.insert("deviceError", "DeviceError");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
-    returns.insert("o:deviceId", "uuid");
+    returns.insert("o:deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setReturns("AddConfiguredDevice", returns);
 
     returns.clear(); // Reused params from above!
@@ -102,19 +102,19 @@ DeviceHandler::DeviceHandler(QObject *parent) :
                    " or PairDevice."
                    );
     setParams("PairDevice", params);
-    returns.insert("deviceError", "DeviceError");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
-    returns.insert("o:pairingTransactionId", "uuid");
+    returns.insert("o:pairingTransactionId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
-    returns.insert("o:displayMessage", "string");
+    returns.insert("o:displayMessage", JsonTypes::basicTypeToString(JsonTypes::String));
-    returns.insert("o:setupMethod", JsonTypes::setupMethodTypesRef());
+    returns.insert("o:setupMethod", JsonTypes::setupMethodRef());
     setReturns("PairDevice", returns);
 
     params.clear(); returns.clear();
     setDescription("ConfirmPairing", "Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params.");
-    params.insert("pairingTransactionId", "uuid");
+    params.insert("pairingTransactionId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
-    params.insert("o:secret", "string");
+    params.insert("o:secret", JsonTypes::basicTypeToString(JsonTypes::String));
     setParams("ConfirmPairing", params);
-    returns.insert("deviceError", "DeviceError");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
-    returns.insert("o:deviceId", "uuid");
+    returns.insert("o:deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setReturns("ConfirmPairing", returns);
 
     params.clear(); returns.clear();
@@ -127,12 +127,12 @@ DeviceHandler::DeviceHandler(QObject *parent) :
 
     params.clear(); returns.clear();
     setDescription("GetDiscoveredDevices", "Performs a device discovery and returns the results. This function may take a while to return.");
-    params.insert("deviceClassId", "uuid");
+    params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     QVariantList discoveryParams;
     discoveryParams.append(JsonTypes::paramRef());
     params.insert("o:discoveryParams", discoveryParams);
     setParams("GetDiscoveredDevices", params);
-    returns.insert("deviceError", "DeviceError");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
     QVariantList deviceDescriptors;
     deviceDescriptors.append(JsonTypes::deviceDescriptorRef());
     returns.insert("o:deviceDescriptors", deviceDescriptors);
@@ -140,20 +140,20 @@ DeviceHandler::DeviceHandler(QObject *parent) :
 
     params.clear(); returns.clear();
     setDescription("RemoveConfiguredDevice", "Remove a device from the system.");
-    params.insert("deviceId", "uuid");
+    params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     QVariantList removePolicyList;
     QVariantMap policy;
-    policy.insert("ruleId", "uuid");
+    policy.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
-    policy.insert("policy", JsonTypes::removePolicyTypesRef());
+    policy.insert("policy", JsonTypes::removePolicyRef());
     removePolicyList.append(policy);
     params.insert("o:removePolicyList", removePolicyList);
     setParams("RemoveConfiguredDevice", params);
-    returns.insert("deviceError", "DeviceError");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
     setReturns("RemoveConfiguredDevice", returns);
 
     params.clear(); returns.clear();
     setDescription("GetEventTypes", "Get event types for a specified deviceClassId.");
-    params.insert("deviceClassId", "uuid");
+    params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("GetEventTypes", params);
     QVariantList events;
     events.append(JsonTypes::eventTypeRef());
@@ -162,7 +162,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
 
     params.clear(); returns.clear();
     setDescription("GetActionTypes", "Get action types for a specified deviceClassId.");
-    params.insert("deviceClassId", "uuid");
+    params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("GetActionTypes", params);
     QVariantList actions;
     actions.append(JsonTypes::actionTypeRef());
@@ -171,7 +171,7 @@ DeviceHandler::DeviceHandler(QObject *parent) :
 
     params.clear(); returns.clear();
     setDescription("GetStateTypes", "Get state types for a specified deviceClassId.");
-    params.insert("deviceClassId", "uuid");
+    params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("GetStateTypes", params);
     QVariantList states;
     states.append(JsonTypes::stateTypeRef());
@@ -180,19 +180,19 @@ DeviceHandler::DeviceHandler(QObject *parent) :
 
     params.clear(); returns.clear();
     setDescription("GetStateValue", "Get the value of the given device and the given stateType");
-    params.insert("deviceId", "uuid");
+    params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
-    params.insert("stateTypeId", "uuid");
+    params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("GetStateValue", params);
-    returns.insert("deviceError", "DeviceError");
+    returns.insert("deviceError", JsonTypes::deviceErrorRef());
-    returns.insert("o:value", "variant");
+    returns.insert("o:value", JsonTypes::basicTypeToString(JsonTypes::Variant));
     setReturns("GetStateValue", returns);
 
     // Notifications
     params.clear(); returns.clear();
     setDescription("StateChanged", "Emitted whenever a State of a device changes.");
-    params.insert("deviceId", "uuid");
+    params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
-    params.insert("stateTypeId", "uuid");
+    params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
-    params.insert("variant", "value");
+    params.insert("value", JsonTypes::basicTypeToString(JsonTypes::Variant));
     setParams("StateChanged", params);
 
     connect(GuhCore::instance(), &GuhCore::deviceStateChanged, this, &DeviceHandler::deviceStateChanged);
@@ -249,7 +249,7 @@ JsonReply *DeviceHandler::GetDiscoveredDevices(const QVariantMap &params) const
         m_discoverRequests.insert(deviceClassId, reply);
         return reply;
     }
-    returns.insert("deviceError", status);
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
     return createReply(returns);
 }
 
@@ -284,8 +284,7 @@ JsonReply *DeviceHandler::GetPluginConfiguration(const QVariantMap &params) cons
 
     QVariantMap returns;
     if (!plugin) {
-        returns.insert("success", false);
+        returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorPluginNotFound));
-        returns.insert("errorMessage", QString("Plugin not found: %1").arg(params.value("pluginId").toString()));
         return createReply(returns);
     }
 
@@ -294,8 +293,7 @@ JsonReply *DeviceHandler::GetPluginConfiguration(const QVariantMap &params) cons
         paramVariantList.append(JsonTypes::packParam(param));
     }
     returns.insert("configuration", paramVariantList);
-    returns.insert("success", true);
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorNoError));
-    returns.insert("errorMessage", QString());
     return createReply(returns);
 }
 
@@ -304,9 +302,8 @@ JsonReply* DeviceHandler::SetPluginConfiguration(const QVariantMap &params)
     QVariantMap returns;
     PluginId pluginId = PluginId(params.value("pluginId").toString());
     ParamList pluginParams = JsonTypes::unpackParams(params.value("configuration").toList());
-    QPair<DeviceManager::DeviceError, QString> result = GuhCore::instance()->setPluginConfig(pluginId, pluginParams);
+    DeviceManager::DeviceError result = GuhCore::instance()->setPluginConfig(pluginId, pluginParams);
-    returns.insert("success", result.first == DeviceManager::DeviceErrorNoError);
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(result));
-    returns.insert("errorMessage", result.second);
     return createReply(returns);
 }
 
@@ -318,10 +315,8 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap &params)
     DeviceId newDeviceId = DeviceId::createDeviceId();
     DeviceManager::DeviceError status;
     if (deviceDescriptorId.isNull()) {
-        qDebug() << "adding a manual device.";
         status = GuhCore::instance()->addConfiguredDevice(deviceClass, deviceParams, newDeviceId);
     } else {
-        qDebug() << "adding a discovered device.";
         status = GuhCore::instance()->addConfiguredDevice(deviceClass, deviceDescriptorId, newDeviceId);
     }
     QVariantMap returns;
@@ -334,7 +329,7 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap &params)
     case DeviceManager::DeviceErrorNoError:
         returns.insert("deviceId", newDeviceId);
     default:
-        returns.insert("deviceError", status);
+        returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
     }
     return createReply(returns);
 }
@@ -344,65 +339,40 @@ JsonReply *DeviceHandler::PairDevice(const QVariantMap &params)
     DeviceClassId deviceClassId(params.value("deviceClassId").toString());
     DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(deviceClassId);
 
-    QPair<DeviceManager::DeviceError, QString> status;
+    DeviceManager::DeviceError status;
+    PairingTransactionId pairingTransactionId = PairingTransactionId::createPairingTransactionId();
     if (params.contains("deviceDescriptorId")) {
         DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
-        status = GuhCore::instance()->pairDevice(deviceClassId, deviceDescriptorId);
+        status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId);
     } else {
         ParamList deviceParams = JsonTypes::unpackParams(params.value("deviceParams").toList());
-        status = GuhCore::instance()->pairDevice(deviceClassId, deviceParams);
+        status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceParams);
     }
 
     QVariantMap returns;
-    switch (status.first) {
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
-    case DeviceManager::DeviceErrorNoError:
+    if (status == DeviceManager::DeviceErrorNoError) {
-        returns.insert("success", true);
-        returns.insert("errorMessage", "");
         returns.insert("displayMessage", deviceClass.pairingInfo());
-        returns.insert("pairingTransactionId", status.second);
+        returns.insert("pairingTransactionId", pairingTransactionId.toString());
-        returns.insert("setupMethod", JsonTypes::setupMethodTypes().at(deviceClass.setupMethod()));
+        returns.insert("setupMethod", JsonTypes::setupMethod().at(deviceClass.setupMethod()));
-        break;
-    case DeviceManager::DeviceErrorDeviceClassNotFound:
-        returns.insert("errorMessage", QString("Error pairing device. Device class not found: %1").arg(status.second));
-        returns.insert("success", false);
-        break;
-    case DeviceManager::DeviceErrorDeviceDescriptorNotFound:
-        returns.insert("errorMessage", QString("Error pairing device. Device descriptor not found: %1").arg(status.second));
-        returns.insert("success", false);
-        break;
-    case DeviceManager::DeviceErrorCreationMethodNotSupported:
-        returns.insert("errorMessage", QString("Error pairing device. This device can't be created this way: %1").arg(status.second));
-        returns.insert("success", false);
-        break;
-    case DeviceManager::DeviceErrorPairingTransactionIdNotFound:
-        returns.insert("errorMessage", QString("Error pairing device. PairingTransactionId not found: %1").arg(status.second));
-        returns.insert("success", false);
-        break;
     }
     return createReply(returns);
 }
 
 JsonReply *DeviceHandler::ConfirmPairing(const QVariantMap &params)
 {
-    QUuid pairingTransactionId = params.value("pairingTransactionId").toUuid();
+    PairingTransactionId pairingTransactionId = PairingTransactionId(params.value("pairingTransactionId").toString());
     QString secret = params.value("secret").toString();
-    QPair<DeviceManager::DeviceError, QString> status = GuhCore::instance()->confirmPairing(pairingTransactionId, secret);
+    DeviceManager::DeviceError status = GuhCore::instance()->confirmPairing(pairingTransactionId, secret);
 
     JsonReply *reply = 0;
-    QVariantMap returns;
+    if (status == DeviceManager::DeviceErrorAsync) {
-    switch (status.first) {
-    case DeviceManager::DeviceErrorAsync:
         reply = createAsyncReply("ConfirmPairing");
         m_asyncPairingRequests.insert(pairingTransactionId, reply);
         return reply;
-    case DeviceManager::DeviceErrorNoError:
-        returns.insert("success", true);
-        returns.insert("errorMessage", QString());
-    case DeviceManager::DeviceErrorSetupFailed:
-    default:
-        returns.insert("success", false);
-        returns.insert("errorMessage", status.second);
     }
+    QVariantMap returns;
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
     reply = createReply(returns);
     return reply;
 }
@@ -430,25 +400,8 @@ JsonReply* DeviceHandler::RemoveConfiguredDevice(const QVariantMap &params)
     }
 
     QVariantMap returns;
-    QPair<DeviceManager::DeviceError, QString> status = GuhCore::instance()->removeConfiguredDevice(deviceId, removePolicyList);
+    DeviceManager::DeviceError status = GuhCore::instance()->removeConfiguredDevice(deviceId, removePolicyList);
-    switch(status.first) {
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
-    case DeviceManager::DeviceErrorNoError:
-        returns.insert("success", true);
-        returns.insert("errorMessage", "");
-        break;
-    case DeviceManager::DeviceErrorDeviceNotFound:
-        returns.insert("success", false);
-        returns.insert("errorMessage", QString("No such device: %1").arg(status.second));
-        break;
-    case DeviceManager::DeviceErrorMissingParameter:
-        returns.insert("success", false);
-        returns.insert("errorMessage", QString("Missing Parameter: %1").arg(status.second));
-        break;
-    default:
-        returns.insert("success", false);
-        returns.insert("errorMessage", "Unknown error.");
-        break;
-    }
     return createReply(returns);
 }
 
@@ -497,19 +450,16 @@ JsonReply* DeviceHandler::GetStateValue(const QVariantMap &params) const
 
     Device *device = GuhCore::instance()->findConfiguredDevice(DeviceId(params.value("deviceId").toString()));
     if (!device) {
-        returns.insert("success", false);
+        returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorDeviceNotFound));
-        returns.insert("errorMessage", "No such device");
         return createReply(returns);
     }
     if (!device->hasState(StateTypeId(params.value("stateTypeId").toString()))) {
-        returns.insert("success", false);
+        returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorStateTypeNotFound));
-        returns.insert("errorMessage", QString("Device %1 %2 doesn't have such a state.").arg(device->name()).arg(device->id().toString()));
         return createReply(returns);
     }
     QVariant stateValue = device->stateValue(StateTypeId(params.value("stateTypeId").toString()));
 
-    returns.insert("success", true);
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorNoError));
-    returns.insert("errorMessage", "");
     returns.insert("value", stateValue);
     return createReply(returns);
 }
@@ -537,8 +487,7 @@ void DeviceHandler::devicesDiscovered(const DeviceClassId &deviceClassId, const
     }
     QVariantMap returns;
     returns.insert("deviceDescriptors", list);
-    returns.insert("success", true);
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorNoError));
-    returns.insert("errorMessage", "");
 
     reply->setData(returns);
     reply->finished();
@@ -554,24 +503,16 @@ void DeviceHandler::deviceSetupFinished(Device *device, DeviceManager::DeviceErr
     JsonReply *reply = m_asynDeviceAdditions.take(device->id());
 
     QVariantMap returns;
+    returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
 
     if(status == DeviceManager::DeviceErrorNoError) {
-        returns.insert("success", true);
-        returns.insert("errorMessage", "");
         returns.insert("deviceId", device->id());
-    } else if (status == DeviceManager::DeviceErrorSetupFailed) {
-        returns.insert("errorMessage", QString("Error creating device. Device setup failed."));
-        returns.insert("success", false);
-    } else {
-        Q_ASSERT_X(false, "DeviceHandler", "Unhandled status code for deviceSetupFinished");
-        returns.insert("errorMessage", "Unknown error.");
-        returns.insert("success", false);
     }
     reply->setData(returns);
     reply->finished();
 }
 
-void DeviceHandler::pairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceError status, const QString &errorMessage, const DeviceId &deviceId)
+void DeviceHandler::pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceError status, const DeviceId &deviceId)
 {
     qDebug() << "handler: pairing finished";
     JsonReply *reply = m_asyncPairingRequests.take(pairingTransactionId);
@@ -582,8 +523,7 @@ void DeviceHandler::pairingFinished(const QUuid &pairingTransactionId, DeviceMan
 
     if (status != DeviceManager::DeviceErrorNoError) {
         QVariantMap returns;
-        returns.insert("success", false);
+        returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
-        returns.insert("errorMessage", errorMessage);
         reply->setData(returns);
         reply->finished();
         return;

server/jsonrpc/devicehandler.h

@@ -70,7 +70,7 @@ private slots:
 
     void deviceSetupFinished(Device *device, DeviceManager::DeviceError status);
 
-    void pairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceError status, const QString &errorMessage, const DeviceId &deviceId);
+    void pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceError status, const DeviceId &deviceId);
 
 private:
     // A cache for async replies

server/jsonrpc/jsonrpcserver.cpp

@@ -42,7 +42,7 @@
 #include <QJsonDocument>
 #include <QStringList>
 
-#define JSON_PROTOCOL_VERSION 5
+#define JSON_PROTOCOL_VERSION 6
 
 JsonRPCServer::JsonRPCServer(QObject *parent):
     JsonHandler(parent),
@@ -60,23 +60,22 @@ JsonRPCServer::JsonRPCServer(QObject *parent):
     params.clear(); returns.clear();
     setDescription("Introspect", "Introspect this API.");
     setParams("Introspect", params);
-    returns.insert("methods", "object");
+    returns.insert("methods", JsonTypes::basicTypeToString(JsonTypes::Object));
-    returns.insert("types", "object");
+    returns.insert("types", JsonTypes::basicTypeToString(JsonTypes::Object));
     setReturns("Introspect", returns);
 
     params.clear(); returns.clear();
     setDescription("Version", "Version of this Guh/JSONRPC interface.");
     setParams("Version", params);
-    returns.insert("version", "string");
+    returns.insert("version", JsonTypes::basicTypeToString(JsonTypes::String));
-    returns.insert("protocol version", "string");
+    returns.insert("protocol version", JsonTypes::basicTypeToString(JsonTypes::String));
     setReturns("Version", returns);
 
     params.clear(); returns.clear();
     setDescription("SetNotificationStatus", "Enable/Disable notifications for this connections.");
-    params.insert("enabled", "bool");
+    params.insert("enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
     setParams("SetNotificationStatus", params);
-    returns.insert("success", "bool");
+    returns.insert("enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
-    returns.insert("enabled", "bool");
     setReturns("SetNotificationStatus", returns);
 
     // Now set up the logic
@@ -130,7 +129,6 @@ JsonReply* JsonRPCServer::SetNotificationStatus(const QVariantMap &params)
 //    qDebug() << "got client socket" << clientId;
     m_clients[clientId] = params.value("enabled").toBool();
     QVariantMap returns;
-    returns.insert("success", "true");
     returns.insert("enabled", m_clients[clientId]);
     return createReply(returns);
 }
@@ -198,7 +196,6 @@ void JsonRPCServer::processData(const QUuid &clientId, const QByteArray &jsonDat
     JsonReply *reply;
     QMetaObject::invokeMethod(handler, method.toLatin1().data(), Q_RETURN_ARG(JsonReply*, reply), Q_ARG(QVariantMap, params));
     if (reply->type() == JsonReply::TypeAsync) {
-        qDebug() << "got an async reply...";
         reply->setClientId(clientId);
         reply->setCommandId(commandId);
         connect(reply, &JsonReply::finished, this, &JsonRPCServer::asyncReplyFinished);
@@ -238,7 +235,6 @@ void JsonRPCServer::sendNotification(const QVariantMap &params)
 void JsonRPCServer::asyncReplyFinished()
 {
     JsonReply *reply = qobject_cast<JsonReply*>(sender());
-    qDebug() << "got async reply:" << reply->method() << reply->data();
     Q_ASSERT(reply->handler()->validateReturns(reply->method(), reply->data()).first);
     sendResponse(reply->clientId(), reply->commandId(), reply->data());
     reply->deleteLater();

server/jsonrpc/jsontypes.cpp

@@ -30,14 +30,14 @@
 bool JsonTypes::s_initialized = false;
 QString JsonTypes::s_lastError;
 
-QVariantList JsonTypes::s_basicTypes;
+QVariantList JsonTypes::s_basicType;
-QVariantList JsonTypes::s_stateOperatorTypes;
+QVariantList JsonTypes::s_stateOperator;
-QVariantList JsonTypes::s_valueOperatorTypes;
+QVariantList JsonTypes::s_valueOperator;
-QVariantList JsonTypes::s_createMethodTypes;
+QVariantList JsonTypes::s_createMethod;
-QVariantList JsonTypes::s_setupMethodTypes;
+QVariantList JsonTypes::s_setupMethod;
-QVariantList JsonTypes::s_removePolicyTypes;
+QVariantList JsonTypes::s_removePolicy;
-QVariantList JsonTypes::s_deviceErrorTypes;
+QVariantList JsonTypes::s_deviceError;
-QVariantList JsonTypes::s_ruleErrorTypes;
+QVariantList JsonTypes::s_ruleError;
 
 QVariantMap JsonTypes::s_paramType;
 QVariantMap JsonTypes::s_param;
@@ -61,114 +61,114 @@ QVariantMap JsonTypes::s_rule;
 void JsonTypes::init()
 {
     // BasicTypes
-    s_basicTypes = enumToStrings(JsonTypes::staticMetaObject, "BasicTypes");
+    s_basicType = enumToStrings(JsonTypes::staticMetaObject, "BasicTypes");
-    s_stateOperatorTypes = enumToStrings(Types::staticMetaObject, "StateOperator");
+    s_stateOperator = enumToStrings(Types::staticMetaObject, "StateOperator");
-    s_valueOperatorTypes = enumToStrings(Types::staticMetaObject, "ValueOperator");
+    s_valueOperator = enumToStrings(Types::staticMetaObject, "ValueOperator");
-    s_createMethodTypes = enumToStrings(DeviceClass::staticMetaObject, "CreateMethod");
+    s_createMethod = enumToStrings(DeviceClass::staticMetaObject, "CreateMethod");
-    s_setupMethodTypes = enumToStrings(DeviceClass::staticMetaObject, "SetupMethod");
+    s_setupMethod = enumToStrings(DeviceClass::staticMetaObject, "SetupMethod");
-    s_removePolicyTypes = enumToStrings(RuleEngine::staticMetaObject, "RemovePolicy");
+    s_removePolicy = enumToStrings(RuleEngine::staticMetaObject, "RemovePolicy");
-    s_deviceErrorTypes  = enumToStrings(DeviceManager::staticMetaObject, "DeviceError");
+    s_deviceError = enumToStrings(DeviceManager::staticMetaObject, "DeviceError");
-    s_ruleErrorTypes = enumToStrings(RuleEngine::staticMetaObject, "RuleError");
+    s_ruleError = enumToStrings(RuleEngine::staticMetaObject, "RuleError");
 
     // ParamType
-    s_paramType.insert("name", "string");
+    s_paramType.insert("name", basicTypeToString(String));
-    s_paramType.insert("type", basicTypesRef());
+    s_paramType.insert("type", basicTypeRef());
-    s_paramType.insert("o:defaultValue", "variant");
+    s_paramType.insert("o:defaultValue", basicTypeToString(Variant));
-    s_paramType.insert("o:minValue", "variant");
+    s_paramType.insert("o:minValue", basicTypeToString(Variant));
-    s_paramType.insert("o:maxValue", "variant");
+    s_paramType.insert("o:maxValue", basicTypeToString(Variant));
-    s_paramType.insert("o:allowedValues", QVariantList() << "variant");
+    s_paramType.insert("o:allowedValues", QVariantList() << basicTypeToString(Variant));
 
     // Param
-    s_param.insert("name", "string");
+    s_param.insert("name", basicTypeToString(String));
-    s_param.insert("value", basicTypesRef());
+    s_param.insert("value", basicTypeRef());
 
     // ParamDescriptor
-    s_paramDescriptor.insert("name", "string");
+    s_paramDescriptor.insert("name", basicTypeToString(String));
-    s_paramDescriptor.insert("value", basicTypesRef());
+    s_paramDescriptor.insert("value", basicTypeRef());
-    s_paramDescriptor.insert("operator", valueOperatorTypesRef());
+    s_paramDescriptor.insert("operator", valueOperatorRef());
 
     // StateType
-    s_stateType.insert("id", "uuid");
+    s_stateType.insert("id", basicTypeToString(Uuid));
-    s_stateType.insert("name", "string");
+    s_stateType.insert("name", basicTypeToString(String));
-    s_stateType.insert("type", basicTypesRef());
+    s_stateType.insert("type", basicTypeRef());
-    s_stateType.insert("defaultValue", "variant");
+    s_stateType.insert("defaultValue", basicTypeToString(Variant));
 
     // State
-    s_state.insert("stateTypeId", "uuid");
+    s_state.insert("stateTypeId", basicTypeToString(Uuid));
-    s_state.insert("deviceId", "uuid");
+    s_state.insert("deviceId", basicTypeToString(Uuid));
-    s_state.insert("value", "variant");
+    s_state.insert("value", basicTypeToString(Variant));
 
     // StateDescriptor
-    s_stateDescriptor.insert("stateTypeId", "uuid");
+    s_stateDescriptor.insert("stateTypeId", basicTypeToString(Uuid));
-    s_stateDescriptor.insert("deviceId", "uuid");
+    s_stateDescriptor.insert("deviceId", basicTypeToString(Uuid));
-    s_stateDescriptor.insert("value", "variant");
+    s_stateDescriptor.insert("value", basicTypeToString(Variant));
-    s_stateDescriptor.insert("operator", valueOperatorTypesRef());
+    s_stateDescriptor.insert("operator", valueOperatorRef());
 
     // StateEvaluator
     s_stateEvaluator.insert("o:stateDescriptor", stateDescriptorRef());
     s_stateEvaluator.insert("o:childEvaluators", QVariantList() << stateEvaluatorRef());
-    s_stateEvaluator.insert("o:operator", stateOperatorTypesRef());
+    s_stateEvaluator.insert("o:operator", stateOperatorRef());
 
     // EventType
-    s_eventType.insert("id", "uuid");
+    s_eventType.insert("id", basicTypeToString(Uuid));
-    s_eventType.insert("name", "string");
+    s_eventType.insert("name", basicTypeToString(String));
     s_eventType.insert("paramTypes", QVariantList() << paramTypeRef());
 
     // Event
-    s_event.insert("eventTypeId", "uuid");
+    s_event.insert("eventTypeId", basicTypeToString(Uuid));
-    s_event.insert("deviceId", "uuid");
+    s_event.insert("deviceId", basicTypeToString(Uuid));
     s_event.insert("o:params", QVariantList() << paramRef());
 
     // EventDescriptor
-    s_eventDescriptor.insert("eventTypeId", "uuid");
+    s_eventDescriptor.insert("eventTypeId", basicTypeToString(Uuid));
-    s_eventDescriptor.insert("deviceId", "uuid");
+    s_eventDescriptor.insert("deviceId", basicTypeToString(Uuid));
     s_eventDescriptor.insert("o:paramDescriptors", QVariantList() << paramDescriptorRef());
 
     // ActionType
-    s_actionType.insert("id", "uuid");
+    s_actionType.insert("id", basicTypeToString(Uuid));
-    s_actionType.insert("name", "string");
+    s_actionType.insert("name", basicTypeToString(Uuid));
     s_actionType.insert("paramTypes", QVariantList() << paramTypeRef());
 
     // Action
-    s_action.insert("actionTypeId", "uuid");
+    s_action.insert("actionTypeId", basicTypeToString(Uuid));
-    s_action.insert("deviceId", "uuid");
+    s_action.insert("deviceId", basicTypeToString(Uuid));
     s_action.insert("o:params", QVariantList() << paramRef());
 
     // Pugin
-    s_plugin.insert("id", "uuid");
+    s_plugin.insert("id", basicTypeToString(Uuid));
-    s_plugin.insert("name", "string");
+    s_plugin.insert("name", basicTypeToString(String));
     s_plugin.insert("params", QVariantList() << paramRef());
 
     // Vendor
-    s_vendor.insert("id", "uuid");
+    s_vendor.insert("id", basicTypeToString(Uuid));
-    s_vendor.insert("name", "string");
+    s_vendor.insert("name", basicTypeToString(String));
 
     // DeviceClass
-    s_deviceClass.insert("id", "uuid");
+    s_deviceClass.insert("id", basicTypeToString(Uuid));
-    s_deviceClass.insert("vendorId", "uuid");
+    s_deviceClass.insert("vendorId", basicTypeToString(Uuid));
-    s_deviceClass.insert("name", "string");
+    s_deviceClass.insert("name", basicTypeToString(String));
     s_deviceClass.insert("stateTypes", QVariantList() << stateTypeRef());
     s_deviceClass.insert("eventTypes", QVariantList() << eventTypeRef());
     s_deviceClass.insert("actionTypes", QVariantList() << actionTypeRef());
     s_deviceClass.insert("paramTypes", QVariantList() << paramTypeRef());
     s_deviceClass.insert("discoveryParamTypes", QVariantList() << paramTypeRef());
-    s_deviceClass.insert("setupMethod", setupMethodTypesRef());
+    s_deviceClass.insert("setupMethod", setupMethodRef());
-    s_deviceClass.insert("createMethods", createMethodTypesRef());
+    s_deviceClass.insert("createMethods", QVariantList() << createMethodRef());
 
     // Device
-    s_device.insert("id", "uuid");
+    s_device.insert("id", basicTypeToString(Uuid));
-    s_device.insert("deviceClassId", "uuid");
+    s_device.insert("deviceClassId", basicTypeToString(Uuid));
-    s_device.insert("name", "string");
+    s_device.insert("name", basicTypeToString(String));
     s_device.insert("params", QVariantList() << paramRef());
-    s_device.insert("setupComplete", "bool");
+    s_device.insert("setupComplete", basicTypeToString(Bool));
 
     // DeviceDescription
-    s_deviceDescriptor.insert("id", "uuid");
+    s_deviceDescriptor.insert("id", basicTypeToString(Uuid));
-    s_deviceDescriptor.insert("title", "string");
+    s_deviceDescriptor.insert("title", basicTypeToString(String));
-    s_deviceDescriptor.insert("description", "string");
+    s_deviceDescriptor.insert("description", basicTypeToString(String));
 
     // Rule
-    s_rule.insert("id", "uuid");
+    s_rule.insert("id", basicTypeToString(Uuid));
     s_rule.insert("eventDescriptors", QVariantList() << eventDescriptorRef());
     s_rule.insert("actions", QVariantList() << actionRef());
     s_rule.insert("stateEvaluator", stateEvaluatorRef());
@@ -186,7 +186,6 @@ QVariantList JsonTypes::enumToStrings(const QMetaObject &metaObject, const QStri
     int enumIndex = metaObject.indexOfEnumerator(enumName.toLatin1().data());
     QMetaEnum metaEnum = metaObject.enumerator(enumIndex);
 
-    qDebug() << "*** have enum" << metaEnum.name();
     QVariantList enumStrings;
     for (int i = 0; i < metaEnum.keyCount(); i++) {
         enumStrings << metaEnum.valueToKey(metaEnum.value(i));
@@ -197,15 +196,15 @@ QVariantList JsonTypes::enumToStrings(const QMetaObject &metaObject, const QStri
 QVariantMap JsonTypes::allTypes()
 {
     QVariantMap allTypes;
-    allTypes.insert("BasicType", basicTypes());
+    allTypes.insert("BasicType", basicType());
     allTypes.insert("ParamType", paramTypeDescription());
-    allTypes.insert("CreateMethodType", createMethodTypes());
+    allTypes.insert("CreateMethod", createMethod());
-    allTypes.insert("SetupMethodType", setupMethodTypes());
+    allTypes.insert("SetupMethod", setupMethod());
-    allTypes.insert("ValueOperatorType", valueOperatorTypes());
+    allTypes.insert("ValueOperator", valueOperator());
-    allTypes.insert("StateOperatorType", stateOperatorTypes());
+    allTypes.insert("StateOperator", stateOperator());
-    allTypes.insert("RemovePolicyType", removePolicyTypes());
+    allTypes.insert("RemovePolicy", removePolicy());
-    allTypes.insert("DeviceError", deviceErrorTypes());
+    allTypes.insert("DeviceError", deviceError());
-    allTypes.insert("RuleError", ruleErrorTypes());
+    allTypes.insert("RuleError", ruleError());
     allTypes.insert("StateType", stateTypeDescription());
     allTypes.insert("StateDescriptor", stateDescriptorDescription());
     allTypes.insert("StateEvaluator", stateEvaluatorDescription());
@@ -307,7 +306,7 @@ QVariantMap JsonTypes::packStateDescriptor(const StateDescriptor &stateDescripto
     variantMap.insert("stateTypeId", stateDescriptor.stateTypeId().toString());
     variantMap.insert("deviceId", stateDescriptor.deviceId().toString());
     variantMap.insert("value", stateDescriptor.stateValue());
-    variantMap.insert("operator", valueOperatorTypes().at(stateDescriptor.operatorType()));
+    variantMap.insert("operator", valueOperator().at(stateDescriptor.operatorType()));
     return variantMap;
 }
 
@@ -337,7 +336,7 @@ QVariantMap JsonTypes::packParamDescriptor(const ParamDescriptor &paramDescripto
     QVariantMap variantMap;
     variantMap.insert("name", paramDescriptor.name());
     variantMap.insert("value", paramDescriptor.value());
-    variantMap.insert("operator", s_valueOperatorTypes.at(paramDescriptor.operatorType()));
+    variantMap.insert("operator", s_valueOperator.at(paramDescriptor.operatorType()));
     return variantMap;
 }
 
@@ -403,7 +402,7 @@ QVariantMap JsonTypes::packDeviceClass(const DeviceClass &deviceClass)
     variant.insert("eventTypes", eventTypes);
     variant.insert("actionTypes", actionTypes);
     variant.insert("createMethods", packCreateMethods(deviceClass.createMethods()));
-    variant.insert("setupMethod", s_setupMethodTypes.at(deviceClass.setupMethod()));
+    variant.insert("setupMethod", s_setupMethod.at(deviceClass.setupMethod()));
     return variant;
 }
 
@@ -525,7 +524,7 @@ EventDescriptor JsonTypes::unpackEventDescriptor(const QVariantMap &eventDescrip
 QPair<bool, QString> JsonTypes::validateMap(const QVariantMap &templateMap, const QVariantMap &map)
 {
     s_lastError.clear();
-    qDebug() << "validating Map" << templateMap << map;
+    // qDebug() << "validating Map" << templateMap << map;
 
     // Make sure all values defined in the template are around
     foreach (const QString &key, templateMap.keys()) {
@@ -541,7 +540,7 @@ QPair<bool, QString> JsonTypes::validateMap(const QVariantMap &templateMap, cons
         if (map.contains(strippedKey)) {
             QPair<bool, QString> result = validateVariant(templateMap.value(key), map.value(strippedKey));
             if (!result.first) {
-                qDebug() << "Object not matching template or object not matching" << templateMap.value(key) << map.value(strippedKey);
+                qDebug() << "Object not matching template" << templateMap.value(key) << map.value(strippedKey);
                 return result;
             }
         }
@@ -563,25 +562,25 @@ QPair<bool, QString> JsonTypes::validateMap(const QVariantMap &templateMap, cons
 
 QPair<bool, QString> JsonTypes::validateProperty(const QVariant &templateValue, const QVariant &value)
 {
-    qDebug() << "validating property. template:" << templateValue << "got:" << value;
+    //qDebug() << "validating property. template:" << templateValue << "got:" << value;
     QString strippedTemplateValue = templateValue.toString();
 
-    if (strippedTemplateValue == "variant") {
+    if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::Variant)) {
         return report(true, "");
     }
-    if (strippedTemplateValue == "uuid") {
+    if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::Uuid)) {
         QString errorString = QString("Param %1 is not a uuid.").arg(value.toString());
         return report(value.canConvert(QVariant::Uuid), errorString);
     }
-    if (strippedTemplateValue == "string") {
+    if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::String)) {
         QString errorString = QString("Param %1 is not a string.").arg(value.toString());
         return report(value.canConvert(QVariant::String), errorString);
     }
-    if (strippedTemplateValue == "bool") {
+    if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::Bool)) {
         QString errorString = QString("Param %1 is not a bool.").arg(value.toString());
         return report(value.canConvert(QVariant::Bool), errorString);
     }
-    if (strippedTemplateValue == "int") {
+    if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::Int)) {
         QString errorString = QString("Param %1 is not a int.").arg(value.toString());
         return report(value.canConvert(QVariant::Int), errorString);
     }
@@ -714,38 +713,50 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
                     qDebug() << "evendescriptor not matching";
                     return result;
                 }
-            } else if (refName == basicTypesRef()) {
+            } else if (refName == basicTypeRef()) {
                 QPair<bool, QString> result = validateBasicType(variant);
                 if (!result.first) {
-                    qDebug() << "value not allowed in" << basicTypesRef();
+                    qDebug() << "value not allowed in" << basicTypeRef();
                     return result;
                 }
-            } else if (refName == stateOperatorTypesRef()) {
+            } else if (refName == stateOperatorRef()) {
-                QPair<bool, QString> result = validateStateOperatorType(variant);
+                QPair<bool, QString> result = validateStateOperator(variant);
                 if (!result.first) {
-                    qDebug() << "value not allowed in" << stateOperatorTypesRef();
+                    qDebug() << "value not allowed in" << stateOperatorRef();
                     return result;
                 }
-            } else if (refName == createMethodTypesRef()) {
+            } else if (refName == createMethodRef()) {
-                QPair<bool, QString> result = validateCreateMethodType(variant);
+                QPair<bool, QString> result = validateCreateMethod(variant);
                 if (!result.first) {
-                    qDebug() << "value not allowed in" << createMethodTypesRef() << variant;
+                    qDebug() << "value not allowed in" << createMethodRef() << variant;
                     return result;
                 }
-            } else if (refName == setupMethodTypesRef()) {
+            } else if (refName == setupMethodRef()) {
-                QPair<bool, QString> result = validateSetupMethodType(variant);
+                QPair<bool, QString> result = validateSetupMethod(variant);
                 if (!result.first) {
-                    qDebug() << "value not allowed in" << createMethodTypesRef();
+                    qDebug() << "value not allowed in" << createMethodRef();
                     return result;
                 }
-            } else if (refName == valueOperatorTypesRef()) {
+            } else if (refName == valueOperatorRef()) {
-                QPair<bool, QString> result = validateValueOperatorType(variant);
+                QPair<bool, QString> result = validateValueOperator(variant);
                 if (!result.first) {
-                    qDebug() << QString("value %1 not allowed in %2").arg(variant.toString()).arg(valueOperatorTypesRef());
+                    qDebug() << QString("value %1 not allowed in %2").arg(variant.toString()).arg(valueOperatorRef());
+                    return result;
+                }
+            } else if (refName == deviceErrorRef()) {
+                QPair<bool, QString> result = validateDeviceError(variant);
+                if (!result.first) {
+                    qDebug() << QString("value %1 not allowed in %2").arg(variant.toString()).arg(deviceErrorRef());
+                    return result;
+                }
+            } else if (refName == ruleErrorRef()) {
+                QPair<bool, QString> result = validateRuleError(variant);
+                if (!result.first) {
+                    qDebug() << QString("value %1 not allowed in %2").arg(variant.toString()).arg(ruleErrorRef());
                     return result;
                 }
             } else {
-                qDebug() << "unhandled ref:" << refName;
+                Q_ASSERT_X(false, "JsonTypes", QString("Unhandled ref: %1").arg(refName).toLatin1().data());
                 return report(false, QString("Unhandled ref %1. Server implementation incomplete.").arg(refName));
             }
 
@@ -798,30 +809,32 @@ QPair<bool, QString> JsonTypes::validateBasicType(const QVariant &variant)
     return report(false, QString("Error validating basic type %1.").arg(variant.toString()));
 }
 
-QPair<bool, QString> JsonTypes::validateStateOperatorType(const QVariant &variant)
+QPair<bool, QString> JsonTypes::validateStateOperator(const QVariant &variant)
 {
-    return report(s_stateOperatorTypes.contains(variant.toString()), QString("Unknown state operator %1").arg(variant.toString()));
+    return report(s_stateOperator.contains(variant.toString()), QString("Unknown state operator %1").arg(variant.toString()));
 }
 
-QPair<bool, QString> JsonTypes::validateCreateMethodType(const QVariant &variant)
+QPair<bool, QString> JsonTypes::validateCreateMethod(const QVariant &variant)
 {
-    if (variant.toList().isEmpty()) {
+    return report(s_createMethod.contains(variant.toString()), QString("Unknwon createMethod type %1").arg(variant.toString()));
-        return report(false, QString("No createMethod given."));
-    }
-    foreach (const QVariant &method, variant.toList()) {
-        if (!s_createMethodTypes.contains(method.toString())) {
-            return report(false, QString("Unknwon createMethod type %1").arg(method.toString()));
-        }
-    }
-    return report(true, QString());
 }
 
-QPair<bool, QString> JsonTypes::validateSetupMethodType(const QVariant &variant)
+QPair<bool, QString> JsonTypes::validateSetupMethod(const QVariant &variant)
 {
-    return report(s_setupMethodTypes.contains(variant.toString()), QString("Unknwon setupMethod type %1").arg(variant.toString()));
+    return report(s_setupMethod.contains(variant.toString()), QString("Unknwon SetupMethod: %1").arg(variant.toString()));
 }
 
-QPair<bool, QString> JsonTypes::validateValueOperatorType(const QVariant &variant)
+QPair<bool, QString> JsonTypes::validateValueOperator(const QVariant &variant)
 {
-    return report(s_valueOperatorTypes.contains(variant.toString()), QString("Unknown value operator type %1").arg(variant.toString()));
+    return report(s_valueOperator.contains(variant.toString()), QString("Unknown ValueOperator: %1").arg(variant.toString()));
+}
+
+QPair<bool, QString> JsonTypes::validateDeviceError(const QVariant &variant)
+{
+    return report(s_deviceError.contains(variant.toString()), QString("Unknown DeviceError: %1").arg(variant.toString()));
+}
+
+QPair<bool, QString> JsonTypes::validateRuleError(const QVariant &variant)
+{
+    return report(s_ruleError.contains(variant.toString()), QString("Unknown RuleError: %1").arg(variant.toString()));
 }

server/jsonrpc/jsontypes.h

@@ -71,27 +71,29 @@ class Device;
 class JsonTypes
 {
     Q_GADGET
-    Q_ENUMS(BasicTypes)
+    Q_ENUMS(BasicType)
+    Q_ENUMS(JsonError)
 public:
-    enum BasicTypes {
+    enum BasicType {
         Uuid,
         String,
         Int,
         Double,
-        Bool
+        Bool,
+        Variant,
+        Object
     };
 
-
     static QVariantMap allTypes();
 
-    DECLARE_TYPE(basicTypes, "BasicType", JsonTypes, BasicTypes)
+    DECLARE_TYPE(basicType, "BasicType", JsonTypes, BasicType)
-    DECLARE_TYPE(stateOperatorTypes, "StateOperator", Types, StateOperator)
+    DECLARE_TYPE(stateOperator, "StateOperator", Types, StateOperator)
-    DECLARE_TYPE(valueOperatorTypes, "ValueOperator", Types, ValueOperator)
+    DECLARE_TYPE(valueOperator, "ValueOperator", Types, ValueOperator)
-    DECLARE_TYPE(createMethodTypes, "CreateMethod", DeviceClass, CreateMethod)
+    DECLARE_TYPE(createMethod, "CreateMethod", DeviceClass, CreateMethod)
-    DECLARE_TYPE(setupMethodTypes, "SetupMethod", DeviceClass, SetupMethod)
+    DECLARE_TYPE(setupMethod, "SetupMethod", DeviceClass, SetupMethod)
-    DECLARE_TYPE(deviceErrorTypes, "DeviceError", DeviceManager, DeviceError)
+    DECLARE_TYPE(deviceError, "DeviceError", DeviceManager, DeviceError)
-    DECLARE_TYPE(removePolicyTypes, "RemovePolicy", RuleEngine, RemovePolicy)
+    DECLARE_TYPE(removePolicy, "RemovePolicy", RuleEngine, RemovePolicy)
-    DECLARE_TYPE(ruleErrorTypes, "RuleError", RuleEngine, RuleError)
+    DECLARE_TYPE(ruleError, "RuleError", RuleEngine, RuleError)
     DECLARE_OBJECT(paramType, "ParamType")
     DECLARE_OBJECT(param, "Param")
     DECLARE_OBJECT(paramDescriptor, "ParamDescriptor")
@@ -141,11 +143,12 @@ public:
     static QPair<bool, QString> validateList(const QVariantList &templateList, const QVariantList &list);
     static QPair<bool, QString> validateVariant(const QVariant &templateVariant, const QVariant &variant);
     static QPair<bool, QString> validateBasicType(const QVariant &variant);
-    static QPair<bool, QString> validateStateOperatorType(const QVariant &variant);
+    static QPair<bool, QString> validateStateOperator(const QVariant &variant);
-    static QPair<bool, QString> validateCreateMethodType(const QVariant &variant);
+    static QPair<bool, QString> validateCreateMethod(const QVariant &variant);
-    static QPair<bool, QString> validateSetupMethodType(const QVariant &variant);
+    static QPair<bool, QString> validateSetupMethod(const QVariant &variant);
-    static QPair<bool, QString> validateValueOperatorType(const QVariant &variant);
+    static QPair<bool, QString> validateValueOperator(const QVariant &variant);
-
+    static QPair<bool, QString> validateDeviceError(const QVariant &variant);
+    static QPair<bool, QString> validateRuleError(const QVariant &variant);
 
 private:
     static bool s_initialized;

server/jsonrpc/ruleshandler.cpp

@@ -32,12 +32,12 @@ RulesHandler::RulesHandler(QObject *parent) :
     params.clear(); returns.clear();
     setDescription("GetRules", "Get all configured rules");
     setParams("GetRules", params);
-    returns.insert("ruleIds", QVariantList() << "uuid");
+    returns.insert("ruleIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setReturns("GetRules", returns);
 
     params.clear(); returns.clear();
     setDescription("GetRuleDetails", "Get details for the rule identified by ruleId");
-    params.insert("ruleId", "uuid");
+    params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("GetRuleDetails", params);
     returns.insert("rule", JsonTypes::ruleRef());
     setReturns("GetRuleDetails", returns);
@@ -52,22 +52,22 @@ RulesHandler::RulesHandler(QObject *parent) :
     actions.append(JsonTypes::actionRef());
     params.insert("actions", actions);
     setParams("AddRule", params);
-    returns.insert("ruleError", "int");
+    returns.insert("ruleError", JsonTypes::ruleErrorRef());
-    returns.insert("o:ruleId", "uuid");
+    returns.insert("o:ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setReturns("AddRule", returns);
 
     params.clear(); returns.clear();
     setDescription("RemoveRule", "Remove a rule");
-    params.insert("ruleId", "uuid");
+    params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("RemoveRule", params);
-    returns.insert("ruleError", "int");
+    returns.insert("ruleError", JsonTypes::ruleErrorRef());
     setReturns("RemoveRule", returns);
 
     params.clear(); returns.clear();
     setDescription("FindRules", "Find a list of rules containing any of the given parameters.");
-    params.insert("deviceId", "uuid");
+    params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setParams("FindRules", params);
-    returns.insert("ruleIds", QVariantList() << "uuid");
+    returns.insert("ruleIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid));
     setReturns("FindRules", returns);
 }
 
@@ -106,7 +106,7 @@ JsonReply* RulesHandler::AddRule(const QVariantMap &params)
     if (params.contains("eventDescriptor") && params.contains("eventDescriptorList")) {
         QVariantMap returns;
         qWarning() << "Only one of eventDesciptor or eventDescriptorList may be used.";
-        returns.insert("ruleError", RuleEngine::RuleErrorInvalidParameter);
+        returns.insert("ruleError", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorInvalidParameter));
         return createReply(returns);
     }
 
@@ -132,7 +132,7 @@ JsonReply* RulesHandler::AddRule(const QVariantMap &params)
 
     QVariantMap returns;
     if (actions.count() == 0) {
-        returns.insert("ruleErorr", RuleEngine::RuleErrorMissingParameter);
+        returns.insert("ruleErorr", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorMissingParameter));
         return createReply(returns);
     }
 
@@ -141,7 +141,7 @@ JsonReply* RulesHandler::AddRule(const QVariantMap &params)
     if (status ==  RuleEngine::RuleErrorNoError) {
         returns.insert("ruleId", newRuleId.toString());
     }
-    returns.insert("ruleError", status);
+    returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
     return createReply(returns);
 }
 
@@ -150,7 +150,7 @@ JsonReply* RulesHandler::RemoveRule(const QVariantMap &params)
     QVariantMap returns;
     RuleId ruleId(params.value("ruleId").toString());
     RuleEngine::RuleError status = GuhCore::instance()->removeRule(ruleId);
-    returns.insert("ruleError", status);
+    returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
     return createReply(returns);
 }
 

tests/auto/actions/testactions.cpp

@@ -64,8 +64,8 @@ void TestActions::executeAction_data()
     QTest::newRow("invalid actionTypeId") << m_mockDeviceId << ActionTypeId::createActionTypeId() << params << DeviceManager::DeviceErrorActionTypeNotFound;
     QTest::newRow("missing params") << m_mockDeviceId << mockActionIdWithParams << QVariantList() << DeviceManager::DeviceErrorMissingParameter;
     QTest::newRow("async action") << m_mockDeviceId << mockActionIdAsync << QVariantList() << DeviceManager::DeviceErrorNoError;
-    QTest::newRow("broken action") << m_mockDeviceId << mockActionIdFailing << QVariantList() << DeviceManager::DeviceErrorActionParameterError;
+    QTest::newRow("broken action") << m_mockDeviceId << mockActionIdFailing << QVariantList() << DeviceManager::DeviceErrorSetupFailed;
-    QTest::newRow("async broken action") << m_mockDeviceId << mockActionIdAsyncFailing << QVariantList() << DeviceManager::DeviceErrorActionParameterError;
+    QTest::newRow("async broken action") << m_mockDeviceId << mockActionIdAsyncFailing << QVariantList() << DeviceManager::DeviceErrorSetupFailed;
 }
 
 void TestActions::executeAction()
@@ -81,7 +81,7 @@ void TestActions::executeAction()
     params.insert("params", actionParams);
     QVariant response = injectAndWait("Actions.ExecuteAction", params);
     qDebug() << "executeActionresponse" << response;
-    verifyError(response, "deviceError", error);
+    verifyDeviceError(response, error);
 
     // Fetch action execution history from mock device
     QNetworkAccessManager nam;
@@ -138,7 +138,7 @@ void TestActions::getActionTypes()
     params.insert("actionTypeId", actionTypeId.toString());
     QVariant response = injectAndWait("Actions.GetActionType", params);
 
-    verifyError(response, "deviceError", error);
+    verifyDeviceError(response, error);
 
     if (error == DeviceManager::DeviceErrorNoError) {
         QVERIFY2(ActionTypeId(response.toMap().value("params").toMap().value("actionType").toMap().value("id").toString()) == actionTypeId, "Didnt get reply for same actionTypeId as requested.");

tests/auto/api.json

@@ -1,68 +1,64 @@
-5
+6
 {
     "methods": {
         "Actions.ExecuteAction": {
             "description": "Execute a single action.",
             "params": {
-                "actionTypeId": "uuid",
+                "actionTypeId": "Uuid",
-                "deviceId": "uuid",
+                "deviceId": "Uuid",
                 "o:params": [
                     "$ref:Param"
                 ]
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError"
-                "success": "bool"
             }
         },
         "Actions.GetActionType": {
             "description": "Get the ActionType for the given ActionTypeId",
             "params": {
-                "actionTypeId": "uuid"
+                "actionTypeId": "Uuid"
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError",
                 "o:actionType": {
-                    "id": "uuid",
+                    "id": "Uuid",
-                    "name": "string",
+                    "name": "Uuid",
                     "paramTypes": [
                         "$ref:ParamType"
                     ]
-                },
+                }
-                "success": "bool"
             }
         },
         "Devices.AddConfiguredDevice": {
             "description": "Add a configured device with a setupMethod of SetupMethodJustAdd. For devices with a setupMethod different than SetupMethodJustAdd, use PairDevice. Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId.",
             "params": {
-                "deviceClassId": "uuid",
+                "deviceClassId": "Uuid",
-                "o:deviceDescriptorId": "uuid",
+                "o:deviceDescriptorId": "Uuid",
                 "o:deviceParams": [
                     "$ref:Param"
                 ]
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError",
-                "o:deviceId": "uuid",
+                "o:deviceId": "Uuid"
-                "success": "bool"
             }
         },
         "Devices.ConfirmPairing": {
             "description": "Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params.",
             "params": {
-                "o:secret": "string",
+                "o:secret": "String",
-                "pairingTransactionId": "uuid"
+                "pairingTransactionId": "Uuid"
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError",
-                "o:deviceId": "uuid",
+                "o:deviceId": "Uuid"
-                "success": "bool"
             }
         },
         "Devices.GetActionTypes": {
             "description": "Get action types for a specified deviceClassId.",
             "params": {
-                "deviceClassId": "uuid"
+                "deviceClassId": "Uuid"
             },
             "returns": {
                 "actionTypes": [
@@ -83,23 +79,22 @@
         "Devices.GetDiscoveredDevices": {
             "description": "Performs a device discovery and returns the results. This function may take a while to return.",
             "params": {
-                "deviceClassId": "uuid",
+                "deviceClassId": "Uuid",
                 "o:discoveryParams": [
                     "$ref:Param"
                 ]
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError",
                 "o:deviceDescriptors": [
                     "$ref:DeviceDescriptor"
-                ],
+                ]
-                "success": "bool"
             }
         },
         "Devices.GetEventTypes": {
             "description": "Get event types for a specified deviceClassId.",
             "params": {
-                "deviceClassId": "uuid"
+                "deviceClassId": "Uuid"
             },
             "returns": {
                 "eventTypes": [
@@ -110,14 +105,13 @@
         "Devices.GetPluginConfiguration": {
             "description": "Get a plugin's params.",
             "params": {
-                "pluginId": "uuid"
+                "pluginId": "Uuid"
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError",
                 "o:configuration": [
                     "$ref:Param"
-                ],
+                ]
-                "success": "bool"
             }
         },
         "Devices.GetPlugins": {
@@ -133,7 +127,7 @@
         "Devices.GetStateTypes": {
             "description": "Get state types for a specified deviceClassId.",
             "params": {
-                "deviceClassId": "uuid"
+                "deviceClassId": "Uuid"
             },
             "returns": {
                 "stateTypes": [
@@ -144,19 +138,18 @@
         "Devices.GetStateValue": {
             "description": "Get the value of the given device and the given stateType",
             "params": {
-                "deviceId": "uuid",
+                "deviceId": "Uuid",
-                "stateTypeId": "uuid"
+                "stateTypeId": "Uuid"
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError",
-                "o:value": "variant",
+                "o:value": "Variant"
-                "success": "bool"
             }
         },
         "Devices.GetSupportedDevices": {
             "description": "Returns a list of supported Device classes, optionally filtered by vendorId.",
             "params": {
-                "o:vendorId": "uuid"
+                "o:vendorId": "Uuid"
             },
             "returns": {
                 "deviceClasses": [
@@ -177,34 +170,32 @@
         "Devices.PairDevice": {
             "description": "Pair a device. Use this for DeviceClasses with a setupMethod different than SetupMethodJustAdd.Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId. If success is true, the return values will contain a pairingTransactionId, a displayMessage and the setupMethod. Depending on the setupMethod you should either proceed with AddConfiguredDevice  or PairDevice.",
             "params": {
-                "deviceClassId": "uuid",
+                "deviceClassId": "Uuid",
-                "o:deviceDescriptorId": "uuid",
+                "o:deviceDescriptorId": "Uuid",
                 "o:deviceParams": [
                     "$ref:Param"
                 ]
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError",
-                "o:displayMessage": "string",
+                "o:displayMessage": "String",
-                "o:pairingTransactionId": "uuid",
+                "o:pairingTransactionId": "Uuid",
-                "o:setupMethod": "$ref:SetupMethodType",
+                "o:setupMethod": "$ref:SetupMethod"
-                "success": "bool"
             }
         },
         "Devices.RemoveConfiguredDevice": {
             "description": "Remove a device from the system.",
             "params": {
-                "deviceId": "uuid",
+                "deviceId": "Uuid",
                 "o:removePolicyList": [
                     {
-                        "policy": "$ref:RemovePolicyType",
+                        "policy": "$ref:RemovePolicy",
-                        "ruleId": "uuid"
+                        "ruleId": "Uuid"
                     }
                 ]
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError"
-                "success": "bool"
             }
         },
         "Devices.SetPluginConfiguration": {
@@ -213,11 +204,10 @@
                 "configuration": [
                     "$ref:Param"
                 ],
-                "pluginId": "uuid"
+                "pluginId": "Uuid"
             },
             "returns": {
-                "errorMessage": "string",
+                "deviceError": "$ref:DeviceError"
-                "success": "bool"
             }
         },
         "JSONRPC.Introspect": {
@@ -225,19 +215,17 @@
             "params": {
             },
             "returns": {
-                "methods": "object",
+                "methods": "Object",
-                "types": "object"
+                "types": "Object"
             }
         },
         "JSONRPC.SetNotificationStatus": {
             "description": "Enable/Disable notifications for this connections.",
             "params": {
-                "enabled": "bool"
+                "enabled": "Bool"
             },
             "returns": {
-                "enabled": "bool",
+                "enabled": "Bool"
-                "errorMessage": "string",
-                "success": "bool"
             }
         },
         "JSONRPC.Version": {
@@ -245,12 +233,12 @@
             "params": {
             },
             "returns": {
-                "protocol version": "string",
+                "protocol version": "String",
-                "version": "string"
+                "version": "String"
             }
         },
         "Rules.AddRule": {
-            "description": "Add a rule.",
+            "description": "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that onlyone of either eventDescriptor or eventDescriptorList may be passed at a time.",
             "params": {
                 "actions": [
                     "$ref:Action"
@@ -262,26 +250,25 @@
                 "o:stateEvaluator": "$ref:StateEvaluator"
             },
             "returns": {
-                "errorMessage": "string",
+                "o:ruleId": "Uuid",
-                "o:ruleId": "uuid",
+                "ruleError": "$ref:RuleError"
-                "success": "bool"
             }
         },
         "Rules.FindRules": {
             "description": "Find a list of rules containing any of the given parameters.",
             "params": {
-                "deviceId": "uuid"
+                "deviceId": "Uuid"
             },
             "returns": {
                 "ruleIds": [
-                    "uuid"
+                    "Uuid"
                 ]
             }
         },
         "Rules.GetRuleDetails": {
             "description": "Get details for the rule identified by ruleId",
             "params": {
-                "ruleId": "uuid"
+                "ruleId": "Uuid"
             },
             "returns": {
                 "rule": "$ref:Rule"
@@ -293,18 +280,17 @@
             },
             "returns": {
                 "ruleIds": [
-                    "uuid"
+                    "Uuid"
                 ]
             }
         },
         "Rules.RemoveRule": {
             "description": "Remove a rule",
             "params": {
-                "ruleId": "uuid"
+                "ruleId": "Uuid"
             },
             "returns": {
-                "errorMessage": "string",
+                "ruleError": "$ref:RuleError"
-                "success": "bool"
             }
         }
     },
@@ -312,9 +298,9 @@
         "Devices.StateChanged": {
             "description": "Emitted whenever a State of a device changes.",
             "params": {
-                "deviceId": "uuid",
+                "deviceId": "Uuid",
-                "stateTypeId": "uuid",
+                "stateTypeId": "Uuid",
-                "variant": "value"
+                "value": "Variant"
             }
         },
         "Events.EventTriggered": {
@@ -326,115 +312,133 @@
     },
     "types": {
         "Action": {
-            "actionTypeId": "uuid",
+            "actionTypeId": "Uuid",
-            "deviceId": "uuid",
+            "deviceId": "Uuid",
             "o:params": [
                 "$ref:Param"
             ]
         },
         "ActionType": {
-            "id": "uuid",
+            "id": "Uuid",
-            "name": "string",
+            "name": "Uuid",
             "paramTypes": [
                 "$ref:ParamType"
             ]
         },
         "BasicType": [
-            "uuid",
-            "string",
-            "integer",
-            "double",
-            "bool"
         ],
-        "CreateMethodType": [
+        "CreateMethod": [
             "CreateMethodUser",
             "CreateMethodAuto",
             "CreateMethodDiscovery"
         ],
         "Device": {
-            "deviceClassId": "uuid",
+            "deviceClassId": "Uuid",
-            "id": "uuid",
+            "id": "Uuid",
-            "name": "string",
+            "name": "String",
             "params": [
                 "$ref:Param"
             ],
-            "setupComplete": "bool"
+            "setupComplete": "Bool"
         },
         "DeviceClass": {
             "actionTypes": [
                 "$ref:ActionType"
             ],
-            "createMethods": "$ref:CreateMethodType",
+            "createMethods": [
+                "$ref:CreateMethod"
+            ],
             "discoveryParamTypes": [
                 "$ref:ParamType"
             ],
             "eventTypes": [
                 "$ref:EventType"
             ],
-            "id": "uuid",
+            "id": "Uuid",
-            "name": "string",
+            "name": "String",
             "paramTypes": [
                 "$ref:ParamType"
             ],
-            "setupMethod": "$ref:SetupMethodType",
+            "setupMethod": "$ref:SetupMethod",
             "stateTypes": [
                 "$ref:StateType"
             ],
-            "vendorId": "uuid"
+            "vendorId": "Uuid"
         },
         "DeviceDescriptor": {
-            "description": "string",
+            "description": "String",
-            "id": "uuid",
+            "id": "Uuid",
-            "title": "string"
+            "title": "String"
         },
+        "DeviceError": [
+            "DeviceErrorNoError",
+            "DeviceErrorPluginNotFound",
+            "DeviceErrorDeviceNotFound",
+            "DeviceErrorDeviceClassNotFound",
+            "DeviceErrorActionTypeNotFound",
+            "DeviceErrorStateTypeNotFound",
+            "DeviceErrorEventTypeNotFound",
+            "DeviceErrorDeviceDescriptorNotFound",
+            "DeviceErrorMissingParameter",
+            "DeviceErrorInvalidParameter",
+            "DeviceErrorSetupFailed",
+            "DeviceErrorDuplicateUuid",
+            "DeviceErrorCreationMethodNotSupported",
+            "DeviceErrorSetupMethodNotSupported",
+            "DeviceErrorHardwareNotAvailable",
+            "DeviceErrorHardwareFailure",
+            "DeviceErrorAsync",
+            "DeviceErrorDeviceInUse",
+            "DeviceErrorPairingTransactionIdNotFound"
+        ],
         "Event": {
-            "deviceId": "uuid",
+            "deviceId": "Uuid",
-            "eventTypeId": "uuid",
+            "eventTypeId": "Uuid",
             "o:params": [
                 "$ref:Param"
             ]
         },
         "EventDescriptor": {
-            "deviceId": "uuid",
+            "deviceId": "Uuid",
-            "eventTypeId": "uuid",
+            "eventTypeId": "Uuid",
             "o:paramDescriptors": [
                 "$ref:ParamDescriptor"
             ]
         },
         "EventType": {
-            "id": "uuid",
+            "id": "Uuid",
-            "name": "string",
+            "name": "String",
             "paramTypes": [
                 "$ref:ParamType"
             ]
         },
         "Param": {
-            "name": "string",
+            "name": "String",
             "value": "$ref:BasicType"
         },
         "ParamDescriptor": {
-            "name": "string",
+            "name": "String",
-            "operator": "$ref:ValueOperatorType",
+            "operator": "$ref:ValueOperator",
             "value": "$ref:BasicType"
         },
         "ParamType": {
-            "name": "string",
+            "name": "String",
             "o:allowedValues": [
-                "variant"
+                "Variant"
             ],
-            "o:defaultValue": "variant",
+            "o:defaultValue": "Variant",
-            "o:maxValue": "variant",
+            "o:maxValue": "Variant",
-            "o:minValue": "variant",
+            "o:minValue": "Variant",
             "type": "$ref:BasicType"
         },
         "Plugin": {
-            "id": "uuid",
+            "id": "Uuid",
-            "name": "string",
+            "name": "String",
             "params": [
                 "$ref:Param"
             ]
         },
-        "RemovePolicyType": [
+        "RemovePolicy": [
             "RemovePolicyCascade",
             "RemovePolicyUpdate"
         ],
@@ -445,54 +449,64 @@
             "eventDescriptors": [
                 "$ref:EventDescriptor"
             ],
-            "id": "uuid",
+            "id": "Uuid",
             "stateEvaluator": "$ref:StateEvaluator"
         },
-        "SetupMethodType": [
+        "RuleError": [
+            "RuleErrorNoError",
+            "RuleErrorInvalidRuleId",
+            "RuleErrorRuleNotFound",
+            "RuleErrorDeviceNotFound",
+            "RuleErrorEventTypeNotFound",
+            "RuleErrorActionTypeNotFound",
+            "RuleErrorInvalidParameter",
+            "RuleErrorMissingParameter"
+        ],
+        "SetupMethod": [
             "SetupMethodJustAdd",
             "SetupMethodDisplayPin",
             "SetupMethodEnterPin",
             "SetupMethodPushButton"
         ],
         "State": {
-            "deviceId": "uuid",
+            "deviceId": "Uuid",
-            "stateTypeId": "uuid",
+            "stateTypeId": "Uuid",
-            "value": "variant"
+            "value": "Variant"
         },
         "StateDescriptor": {
-            "deviceId": "uuid",
+            "deviceId": "Uuid",
-            "operator": "$ref:ValueOperatorType",
+            "operator": "$ref:ValueOperator",
-            "stateTypeId": "uuid",
+            "stateTypeId": "Uuid",
-            "value": "variant"
+            "value": "Variant"
         },
         "StateEvaluator": {
             "o:childEvaluators": [
                 "$ref:StateEvaluator"
             ],
-            "o:operator": "$ref:StateOperatorType",
+            "o:operator": "$ref:StateOperator",
             "o:stateDescriptor": "$ref:StateDescriptor"
         },
-        "StateOperatorType": [
+        "StateOperator": [
             "StateOperatorAnd",
             "StateOperatorOr"
         ],
         "StateType": {
-            "defaultValue": "variant",
+            "defaultValue": "Variant",
-            "id": "uuid",
+            "id": "Uuid",
-            "name": "string",
+            "name": "String",
             "type": "$ref:BasicType"
         },
-        "ValueOperatorType": [
+        "ValueOperator": [
-            "OperatorTypeEquals",
+            "ValueOperatorEquals",
-            "OperatorTypeNotEquals",
+            "ValueOperatorNotEquals",
-            "OperatorTypeLess",
+            "ValueOperatorLess",
-            "OperatorTypeGreater",
+            "ValueOperatorGreater",
-            "OperatorTypeLessThan",
+            "ValueOperatorLessOrEqual",
-            "OperatorTypeGreaterThan"
+            "ValueOperatorGreaterOrEqual"
         ],
         "Vendor": {
-            "id": "uuid",
+            "id": "Uuid",
-            "name": "string"
+            "name": "String"
         }
     }
 }

tests/auto/devices/testdevices.cpp

@@ -98,7 +98,7 @@ void TestDevices::getPluginConfig()
     QVariantMap params;
     params.insert("pluginId", pluginId);
     QVariant response = injectAndWait("Devices.GetPluginConfiguration", params);
-    verifyError(response, "deviceError", error);
+    verifyDeviceError(response, error);
 }
 
 void TestDevices::setPluginConfig_data()
@@ -130,13 +130,13 @@ void TestDevices::setPluginConfig()
     configuration.append(configParam);
     params.insert("configuration", configuration);
     QVariant response = injectAndWait("Devices.SetPluginConfiguration", params);
-    verifyError(response, "deviceError", error);
+    verifyDeviceError(response, error);
 
     if (error == DeviceManager::DeviceErrorNoError) {
         params.clear();
         params.insert("pluginId", pluginId);
         response = injectAndWait("Devices.GetPluginConfiguration", params);
-        verifyError(response, "deviceError");
+        verifyDeviceError(response);
         qDebug() << "222" << response.toMap().value("params").toMap().value("configuration").toList().first();
         QVERIFY2(response.toMap().value("params").toMap().value("configuration").toList().first().toMap().value("name") == "configParamInt", "Value not set correctly");
         QVERIFY2(response.toMap().value("params").toMap().value("configuration").toList().first().toMap().value("value") == value, "Value not set correctly");
@@ -199,7 +199,7 @@ void TestDevices::addConfiguredDevice_data()
 {
     QTest::addColumn<DeviceClassId>("deviceClassId");
     QTest::addColumn<QVariantList>("deviceParams");
-    QTest::addColumn<bool>("success");
+    QTest::addColumn<DeviceManager::DeviceError>("deviceError");
 
     QVariantMap httpportParam;
     httpportParam.insert("name", "httpport");
@@ -214,27 +214,27 @@ void TestDevices::addConfiguredDevice_data()
     QVariantList deviceParams;
 
     deviceParams.clear(); deviceParams << httpportParam;
-    QTest::newRow("User, JustAdd") << mockDeviceClassId << deviceParams << true;
+    QTest::newRow("User, JustAdd") << mockDeviceClassId << deviceParams << DeviceManager::DeviceErrorNoError;
     deviceParams.clear(); deviceParams << httpportParam << asyncParam;
-    QTest::newRow("User, JustAdd, Async") << mockDeviceClassId << deviceParams << true;
+    QTest::newRow("User, JustAdd, Async") << mockDeviceClassId << deviceParams << DeviceManager::DeviceErrorNoError;
-    QTest::newRow("Invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << deviceParams << false;
+    QTest::newRow("Invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << deviceParams << DeviceManager::DeviceErrorDeviceClassNotFound;
     deviceParams.clear(); deviceParams << httpportParam << brokenParam;
-    QTest::newRow("Setup failure") << mockDeviceClassId << deviceParams << false;
+    QTest::newRow("Setup failure") << mockDeviceClassId << deviceParams << DeviceManager::DeviceErrorSetupFailed;
     deviceParams.clear(); deviceParams << httpportParam << asyncParam << brokenParam;
-    QTest::newRow("Setup failure, Async") << mockDeviceClassId << deviceParams << false;
+    QTest::newRow("Setup failure, Async") << mockDeviceClassId << deviceParams << DeviceManager::DeviceErrorSetupFailed;
 
     QVariantList invalidDeviceParams;
-    QTest::newRow("User, JustAdd, missing params") << mockDeviceClassId << invalidDeviceParams << false;
+    QTest::newRow("User, JustAdd, missing params") << mockDeviceClassId << invalidDeviceParams << DeviceManager::DeviceErrorMissingParameter;
 
     QVariantMap fakeparam;
     fakeparam.insert("name", "tropptth");
     invalidDeviceParams.append(fakeparam);
-    QTest::newRow("User, JustAdd, invalid param") << mockDeviceClassId << invalidDeviceParams << false;
+    QTest::newRow("User, JustAdd, invalid param") << mockDeviceClassId << invalidDeviceParams << DeviceManager::DeviceErrorInvalidParameter;
 
     fakeparam.insert("value", "buhuu");
     invalidDeviceParams.clear();
     invalidDeviceParams.append(fakeparam);
-    QTest::newRow("User, JustAdd, wrong param") << mockDeviceClassId << invalidDeviceParams << false;
+    QTest::newRow("User, JustAdd, wrong param") << mockDeviceClassId << invalidDeviceParams << DeviceManager::DeviceErrorInvalidParameter;
 
 }
 
@@ -242,7 +242,7 @@ void TestDevices::addConfiguredDevice()
 {
     QFETCH(DeviceClassId, deviceClassId);
     QFETCH(QVariantList, deviceParams);
-    QFETCH(bool, success);
+    QFETCH(DeviceManager::DeviceError, deviceError);
 
     QVariantMap params;
     params.insert("deviceClassId", deviceClassId);
@@ -250,14 +250,14 @@ void TestDevices::addConfiguredDevice()
     QVariant response = injectAndWait("Devices.AddConfiguredDevice", params);
     qDebug() << "response is" << response;
 
-    verifyError(response, "deviceError", success);
+    verifyDeviceError(response, deviceError);
 
-    if (success) {
+    if (deviceError == DeviceManager::DeviceErrorNoError) {
         QUuid deviceId(response.toMap().value("params").toMap().value("deviceId").toString());
         params.clear();
         params.insert("deviceId", deviceId.toString());
         response = injectAndWait("Devices.RemoveConfiguredDevice", params);
-        verifyError(response, "deviceError");
+        verifyDeviceError(response);
     }
 }
 
@@ -272,20 +272,20 @@ void TestDevices::getConfiguredDevices()
 void TestDevices::removeDevice_data()
 {
     QTest::addColumn<DeviceId>("deviceId");
-    QTest::addColumn<bool>("success");
+    QTest::addColumn<DeviceManager::DeviceError>("deviceError");
 
-    QTest::newRow("Existing Device") << m_mockDeviceId << true;
+    QTest::newRow("Existing Device") << m_mockDeviceId << DeviceManager::DeviceErrorNoError;
-    QTest::newRow("Not existing Device") << DeviceId::createDeviceId() << false;
+    QTest::newRow("Not existing Device") << DeviceId::createDeviceId() << DeviceManager::DeviceErrorDeviceNotFound;
 }
 
 void TestDevices::removeDevice()
 {
     QFETCH(DeviceId, deviceId);
-    QFETCH(bool, success);
+    QFETCH(DeviceManager::DeviceError, deviceError);
 
     QSettings settings(m_deviceSettings);
     settings.beginGroup("DeviceConfig");
-    if (success) {
+    if (deviceError == DeviceManager::DeviceErrorNoError) {
         settings.beginGroup(m_mockDeviceId.toString());
         // Make sure we have some config values for this device
         QVERIFY(settings.allKeys().count() > 0);
@@ -296,9 +296,9 @@ void TestDevices::removeDevice()
 
     QVariant response = injectAndWait("Devices.RemoveConfiguredDevice", params);
 
-    verifyError(response, "deviceError", success);
+    verifyDeviceError(response, deviceError);
 
-    if (success) {
+    if (DeviceManager::DeviceErrorNoError) {
         // Make sure the device is gone from settings too
         QCOMPARE(settings.allKeys().count(), 0);
     }
@@ -323,7 +323,7 @@ void TestDevices::storedDevices()
     deviceParams.append(httpportParam);
     params.insert("deviceParams", deviceParams);
     QVariant response = injectAndWait("Devices.AddConfiguredDevice", params);
-    verifyError(response, "deviceError");
+    verifyDeviceError(response);
     DeviceId addedDeviceId = DeviceId(response.toMap().value("params").toMap().value("deviceId").toString());
     QVERIFY(!addedDeviceId.isNull());
 
@@ -334,7 +334,6 @@ void TestDevices::storedDevices()
 
     bool found = false;
     foreach (const QVariant device, response.toMap().value("params").toMap().value("devices").toList()) {
-        qDebug() << "found stored device" << device;
         if (DeviceId(device.toMap().value("id").toString()) == addedDeviceId) {
 //            foreach (const QVariant &paramVariant, device.toMap().value("params").toList()) {
 //                if ()
@@ -352,7 +351,7 @@ void TestDevices::storedDevices()
     params.clear();
     params.insert("deviceId", addedDeviceId);
     response = injectAndWait("Devices.RemoveConfiguredDevice", params);
-    verifyError(response, "deviceError");
+    verifyDeviceError(response);
 }
 
 void TestDevices::discoverDevices_data()
@@ -385,7 +384,7 @@ void TestDevices::discoverDevices()
     params.insert("discoveryParams", discoveryParams);
     QVariant response = injectAndWait("Devices.GetDiscoveredDevices", params);
 
-    verifyError(response, "deviceError", error);
+    verifyDeviceError(response, error);
     if (error == DeviceManager::DeviceErrorNoError) {
         QCOMPARE(response.toMap().value("params").toMap().value("deviceDescriptors").toList().count(), resultCount);
     }
@@ -399,13 +398,13 @@ void TestDevices::discoverDevices()
         params.insert("deviceDescriptorId", descriptorId.toString());
         response = injectAndWait("Devices.AddConfiguredDevice", params);
 
-        verifyError(response, "deviceError");
+        verifyDeviceError(response);
 
         DeviceId deviceId(response.toMap().value("params").toMap().value("deviceId").toString());
         params.clear();
         params.insert("deviceId", deviceId.toString());
         response = injectAndWait("Devices.RemoveConfiguredDevice", params);
-        verifyError(response, "deviceError");
+        verifyDeviceError(response);
     }
 }
 

tests/auto/guhtestbase.cpp

@@ -20,6 +20,7 @@
 #include "mocktcpserver.h"
 #include "guhcore.h"
 #include "devicemanager.h"
+#include "jsontypes.h"
 
 #include <QVariantMap>
 #include <QJsonDocument>
@@ -91,7 +92,7 @@ void GuhTestBase::initTestCase()
 
     QVariant response = injectAndWait("Devices.AddConfiguredDevice", params);
 
-    verifyError(response, "deviceError");
+    verifyDeviceError(response);
 
     m_mockDeviceId = DeviceId(response.toMap().value("params").toMap().value("deviceId").toString());
     QVERIFY2(!m_mockDeviceId.isNull(), "Newly created mock device must not be null.");
@@ -125,13 +126,6 @@ QVariant GuhTestBase::injectAndWait(const QString &method, const QVariantMap &pa
      return jsonDoc.toVariant();
 }
 
-void GuhTestBase::verifyError(const QVariant &response, const QString &fieldName, int error)
-{
-    QJsonDocument jsonDoc = QJsonDocument::fromVariant(response);
-    QVERIFY2(response.toMap().value("status").toString() == QString("success"), jsonDoc.toJson().data());
-    QVERIFY2(response.toMap().value("params").toMap().value(fieldName).toInt() == error, jsonDoc.toJson().data());
-}
-
 void GuhTestBase::restartServer()
 {
     // Destroy and recreate the core instance...

tests/auto/guhtestbase.h

@@ -22,6 +22,8 @@
 #include "typeutils.h"
 #include "mocktcpserver.h"
 #include "devicemanager.h"
+#include "ruleengine.h"
+#include "jsontypes.h"
 
 #include <QObject>
 #include <QUuid>
@@ -58,7 +60,27 @@ protected slots:
 
 protected:
     QVariant injectAndWait(const QString &method, const QVariantMap &params = QVariantMap());
-    void verifyError(const QVariant &response, const QString &fieldName, int error = 0);
+
+    inline void verifyError(const QVariant &response, const QString &fieldName, const QString &error)
+    {
+        QJsonDocument jsonDoc = QJsonDocument::fromVariant(response);
+        QVERIFY2(response.toMap().value("status").toString() == QString("success"), jsonDoc.toJson().data());
+        QVERIFY2(response.toMap().value("params").toMap().value(fieldName).toString() == error,
+                 QString("\nExpected: %1\nGot: %2\nFull message: %3\n")
+                 .arg(error)
+                 .arg(response.toMap().value("params").toMap().value(fieldName).toString())
+                 .arg(jsonDoc.toJson().data())
+                 .toLatin1().data());
+    }
+
+    inline void verifyRuleError(const QVariant &response, RuleEngine::RuleError error = RuleEngine::RuleErrorNoError) {
+        verifyError(response, "ruleError", JsonTypes::ruleErrorToString(error));
+    }
+
+    inline void verifyDeviceError(const QVariant &response, DeviceManager::DeviceError error = DeviceManager::DeviceErrorNoError) {
+        verifyError(response, "deviceError", JsonTypes::deviceErrorToString(error));
+    }
+
     void restartServer();
 
 protected:

tests/auto/jsonrpc/testjsonrpc.cpp

@@ -181,9 +181,7 @@ void TestJSONRPC::enableDisableNotifications()
     params.insert("enabled", enabled);
     QVariant response = injectAndWait("JSONRPC.SetNotificationStatus", params);
 
-    verifyError(response, "error");
     QCOMPARE(response.toMap().value("params").toMap().value("enabled").toString(), enabled);
-
 }
 
 void TestJSONRPC::stateChangeEmitsNotifications()
@@ -191,7 +189,7 @@ void TestJSONRPC::stateChangeEmitsNotifications()
     QVariantMap params;
     params.insert("enabled", true);
     QVariant response = injectAndWait("JSONRPC.SetNotificationStatus", params);
-    verifyError(response, "serverError");
+    QCOMPARE(response.toMap().value("params").toMap().value("enabled").toBool(), true);
 
     // Setup connection to mock client
     QNetworkAccessManager nam;
@@ -226,7 +224,7 @@ void TestJSONRPC::stateChangeEmitsNotifications()
     params.clear();
     params.insert("enabled", false);
     response = injectAndWait("JSONRPC.SetNotificationStatus", params);
-    verifyError(response, "serverError");
+    QCOMPARE(response.toMap().value("params").toMap().value("enabled").toBool(), false);
 
     // Fire the a statechange once again
     clientSpy.clear();

tests/auto/rules/testrules.cpp

@@ -65,7 +65,7 @@ void TestRules::addRemoveRules_data()
     QVariantMap stateDescriptor;
     stateDescriptor.insert("stateTypeId", mockIntStateId);
     stateDescriptor.insert("deviceId", m_mockDeviceId);
-    stateDescriptor.insert("operator", "OperatorTypeLess");
+    stateDescriptor.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorLess));
     stateDescriptor.insert("value", "20");
 
     QVariantMap validStateEvaluator;
@@ -87,7 +87,7 @@ void TestRules::addRemoveRules_data()
     QVariantMap param1;
     param1.insert("name", "mockParamInt");
     param1.insert("value", 3);
-    param1.insert("operator", "OperatorTypeEquals");
+    param1.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorEquals));
     params.append(param1);
     validEventDescriptor2.insert("paramDescriptors", params);
 
@@ -111,7 +111,7 @@ void TestRules::addRemoveRules_data()
     QTest::newRow("valid rule. 2 EventDescriptors, 1 Action") << validActionNoParams << QVariantMap() << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorNoError;
     QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << validActionNoParams << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorInvalidParameter;
     QTest::newRow("invalid action") << invalidAction << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorActionTypeNotFound;
-    QTest::newRow("invalid event descriptor") << validActionNoParams << invalidEventDescriptor << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidParameter;
+    QTest::newRow("invalid event descriptor") << validActionNoParams << invalidEventDescriptor << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorDeviceNotFound;
 //    QTest::newRow("invalid state evaluator") << validActionNoParams << invalidEventDescriptor << QVariantList() << invalidStateEvaluator << false;
 
 }
@@ -137,7 +137,7 @@ void TestRules::addRemoveRules()
     }
     params.insert("stateEvaluator", stateEvaluator);
     QVariant response = injectAndWait("Rules.AddRule", params);
-    verifyError(response, "ruleError", error);
+    verifyRuleError(response, error);
 
     RuleId newRuleId = RuleId(response.toMap().value("params").toMap().value("ruleId").toString());
 
@@ -185,7 +185,7 @@ void TestRules::addRemoveRules()
     params.clear();
     params.insert("ruleId", newRuleId);
     response = injectAndWait("Rules.RemoveRule", params);
-    verifyError(response, "ruleError");
+    verifyRuleError(response);
 
     response = injectAndWait("Rules.GetRules");
     rules = response.toMap().value("params").toMap().value("rules").toList();
@@ -197,7 +197,7 @@ void TestRules::removeInvalidRule()
     QVariantMap params;
     params.insert("ruleId", RuleId::createRuleId());
     QVariant response = injectAndWait("Rules.RemoveRule", params);
-    verifyError(response, "ruleError", RuleEngine::RuleErrorInvalidRuleId);
+    verifyRuleError(response, RuleEngine::RuleErrorRuleNotFound);
 }
 
 void TestRules::loadStoreConfig()
@@ -215,7 +215,7 @@ void TestRules::loadStoreConfig()
     QVariantMap eventParam1;
     eventParam1.insert("name", "mockParamInt");
     eventParam1.insert("value", 3);
-    eventParam1.insert("operator", "OperatorTypeEquals");
+    eventParam1.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorEquals));
     eventParamDescriptors.append(eventParam1);
     eventDescriptor2.insert("paramDescriptors", eventParamDescriptors);
 
@@ -253,7 +253,7 @@ void TestRules::loadStoreConfig()
     QVariant response = injectAndWait("Rules.AddRule", params);
 
     RuleId newRuleId = RuleId(response.toMap().value("params").toMap().value("ruleId").toString());
-    verifyError(response, "ruleError");
+    verifyRuleError(response);
 
     restartServer();
 
@@ -291,8 +291,6 @@ void TestRules::loadStoreConfig()
             if (actionVariant.toMap().value("actionTypeId") == replyActionVariant.toMap().value("actionTypeId") &&
                     actionVariant.toMap().value("deviceId") == replyActionVariant.toMap().value("deviceId")) {
                 found = true;
-                qDebug() << "AAA:" << actionVariant;
-                qDebug() << "BBB:" << replyActionVariant;
                 QVERIFY2(actionVariant == replyActionVariant, "Action doesn't match after loading from config.");
             }
         }
@@ -302,7 +300,7 @@ void TestRules::loadStoreConfig()
     params.clear();
     params.insert("ruleId", newRuleId);
     response = injectAndWait("Rules.RemoveRule", params);
-    verifyError(response, "ruleError");
+    verifyRuleError(response);
 
     restartServer();
 
@@ -329,7 +327,7 @@ void TestRules::evaluateEvent()
     actions.append(action);
     addRuleParams.insert("actions", actions);
     QVariant response = injectAndWait("Rules.AddRule", addRuleParams);
-    verifyError(response, "ruleError");
+    verifyRuleError(response);
 
     // Trigger an event
     QNetworkAccessManager nam;

tests/auto/states/teststates.cpp

@@ -36,6 +36,7 @@ class TestStates: public GuhTestBase
 private slots:
     void getStateValue_data();
     void getStateValue();
+
 };
 
 void TestStates::getStateValue_data()
@@ -50,7 +51,7 @@ void TestStates::getStateValue_data()
 
     QTest::newRow("existing state") << device->id() << mockIntStateId << DeviceManager::DeviceErrorNoError;
     QTest::newRow("invalid device") << DeviceId::createDeviceId() << mockIntStateId << DeviceManager::DeviceErrorDeviceNotFound;
-    QTest::newRow("invalid statetype") << device->id() << StateTypeId::createStateTypeId() << DeviceManager::DeviceErrorInvalidParameter;
+    QTest::newRow("invalid statetype") << device->id() << StateTypeId::createStateTypeId() << DeviceManager::DeviceErrorStateTypeNotFound;
 }
 
 void TestStates::getStateValue()
@@ -65,7 +66,7 @@ void TestStates::getStateValue()
 
     QVariant response = injectAndWait("Devices.GetStateValue", params);
 
-    verifyError(response, "deviceError", error);
+    verifyDeviceError(response, error);
 }
 
 #include "teststates.moc"