added api for plugin configs

libhive/devicemanager.cpp

@@ -27,7 +27,17 @@ DeviceManager::DeviceManager(QObject *parent) :
     QMetaObject::invokeMethod(this, "loadConfiguredDevices", Qt::QueuedConnection);
 }
 
-QList<DeviceClass> DeviceManager::supportedDevices()
+QList<DevicePlugin *> DeviceManager::plugins() const
+{
+    return m_devicePlugins.values();
+}
+
+DevicePlugin *DeviceManager::plugin(const QUuid &id) const
+{
+    return m_devicePlugins.value(id);
+}
+
+QList<DeviceClass> DeviceManager::supportedDevices() const
 {
     return m_supportedDevices.values();
 }
@@ -78,7 +88,7 @@ QList<Device *> DeviceManager::configuredDevices() const
     return m_configuredDevices;
 }
 
-QList<Device *> DeviceManager::findConfiguredDevices(const QUuid &deviceClassId)
+QList<Device *> DeviceManager::findConfiguredDevices(const QUuid &deviceClassId) const
 {
     QList<Device*> ret;
     foreach (Device *device, m_configuredDevices) {
@@ -89,7 +99,7 @@ QList<Device *> DeviceManager::findConfiguredDevices(const QUuid &deviceClassId)
     return ret;
 }
 
-DeviceClass DeviceManager::findDeviceClassforTrigger(const QUuid &triggerTypeId)
+DeviceClass DeviceManager::findDeviceClassforTrigger(const QUuid &triggerTypeId) const
 {
     foreach (const DeviceClass &deviceClass, m_supportedDevices) {
         foreach (const TriggerType &triggerType, deviceClass.triggers()) {
@@ -101,7 +111,7 @@ DeviceClass DeviceManager::findDeviceClassforTrigger(const QUuid &triggerTypeId)
     return DeviceClass(QUuid(), QUuid());
 }
 
-DeviceClass DeviceManager::findDeviceClass(const QUuid &deviceClassId)
+DeviceClass DeviceManager::findDeviceClass(const QUuid &deviceClassId) const
 {
     foreach (const DeviceClass &deviceClass, m_supportedDevices) {
         if (deviceClass.id() == deviceClassId) {

libhive/devicemanager.h

@@ -30,15 +30,17 @@ public:
 
     explicit DeviceManager(QObject *parent = 0);
 
-    QList<DeviceClass> supportedDevices();
+    QList<DevicePlugin*> plugins() const;
+    DevicePlugin* plugin(const QUuid &id) const;
+    QList<DeviceClass> supportedDevices() const;
 
     QList<Device*> configuredDevices() const;
     DeviceError addConfiguredDevice(const QUuid &deviceClassId, const QVariantMap &params);
 
     Device* findConfiguredDevice(const QUuid &id) const;
-    QList<Device*> findConfiguredDevices(const QUuid &deviceClassId);
+    QList<Device*> findConfiguredDevices(const QUuid &deviceClassId) const;
-    DeviceClass findDeviceClassforTrigger(const QUuid &triggerTypeId);
+    DeviceClass findDeviceClassforTrigger(const QUuid &triggerTypeId) const;
-    DeviceClass findDeviceClass(const QUuid &deviceClassId);
+    DeviceClass findDeviceClass(const QUuid &deviceClassId) const;
 
 signals:
     void emitTrigger(const Trigger &trigger);

libhive/deviceplugin.cpp

@@ -21,6 +21,17 @@ void DevicePlugin::initPlugin(DeviceManager *deviceManager)
     init();
 }
 
+QVariantMap DevicePlugin::configuration() const
+{
+    return QVariantMap();
+}
+
+void DevicePlugin::setConfiguration(const QVariantMap &configuration)
+{
+    Q_UNUSED(configuration)
+    qWarning() << "Plugin" << pluginName() << pluginId() << "does not support any configuration";
+}
+
 DeviceManager *DevicePlugin::deviceManager() const
 {
     return m_deviceManager;

libhive/deviceplugin.h

@@ -31,6 +31,9 @@ public:
     // Hardware input
     virtual void receiveData(QList<int> rawData) = 0;
 
+    virtual QVariantMap configuration() const;
+    virtual void setConfiguration(const QVariantMap &configuration);
+
 public slots:
     virtual void executeAction(Device *device, const Action &action) = 0;
 

server/jsonrpcserver.cpp

@@ -4,6 +4,7 @@
 
 #include "hivecore.h"
 #include "devicemanager.h"
+#include "deviceplugin.h"
 #include "deviceclass.h"
 #include "device.h"
 #include "rule.h"
@@ -53,42 +54,7 @@ void JsonRPCServer::processData(int clientId, const QByteArray &jsonData)
     emit commandReceived(targetNamespace, method, params);
 
     if (targetNamespace == "Devices") {
-        if (method == "GetSupportedDevices") {
+        handleDevicesMessage(clientId, commandId, method, params);
-            QVariantMap params;
-            QVariantList supportedDeviceList;
-            foreach (const DeviceClass &deviceClass, HiveCore::instance()->deviceManager()->supportedDevices()) {
-                supportedDeviceList.append(packDeviceClass(deviceClass));
-            }
-            params.insert("deviceClasses", supportedDeviceList);
-            sendResponse(clientId, commandId, params);
-        } else if (method == "AddConfiguredDevice") {
-            QUuid deviceClass = params.value("deviceClass").toUuid();
-            QVariantMap deviceParams = params.value("params").toMap();
-            DeviceManager::DeviceError status = HiveCore::instance()->deviceManager()->addConfiguredDevice(deviceClass, deviceParams);
-            switch(status) {
-            case DeviceManager::DeviceErrorNoError:
-                sendResponse(clientId, commandId);
-                break;
-            case DeviceManager::DeviceErrorDeviceClassNotFound:
-                sendErrorResponse(clientId, commandId, "Error creating device. Device class not found.");
-                break;
-            case DeviceManager::DeviceErrorMissingParameter:
-                sendErrorResponse(clientId, commandId, "Error creating device. Missing parameter.");
-                break;
-            default:
-                sendErrorResponse(clientId, commandId, "Unknown error.");
-            }
-        } else if (method == "GetConfiguredDevices") {
-            QVariantMap rspParams;
-            QVariantList configuredDeviceList;
-            foreach (Device *device, HiveCore::instance()->deviceManager()->configuredDevices()) {
-                configuredDeviceList.append(packDevice(device));
-            }
-            rspParams.insert("devices", configuredDeviceList);
-            sendResponse(clientId, commandId, rspParams);
-        } else {
-            sendErrorResponse(clientId, commandId, "No such method");
-        }
     } else if (targetNamespace == "Rules") {
         handleRulesMessage(clientId, commandId, method, params);
     } else if (targetNamespace == "Actions") {
@@ -98,6 +64,63 @@ void JsonRPCServer::processData(int clientId, const QByteArray &jsonData)
     }
 }
 
+void JsonRPCServer::handleDevicesMessage(int clientId, int commandId, const QString &method, const QVariantMap &params)
+{
+    if (method == "GetSupportedDevices") {
+        QVariantMap params;
+        QVariantList supportedDeviceList;
+        foreach (const DeviceClass &deviceClass, HiveCore::instance()->deviceManager()->supportedDevices()) {
+            supportedDeviceList.append(packDeviceClass(deviceClass));
+        }
+        params.insert("deviceClasses", supportedDeviceList);
+        sendResponse(clientId, commandId, params);
+    } else if (method == "GetPlugins") {
+        QVariantMap params;
+        QVariantList plugins;
+        foreach (DevicePlugin *plugin, HiveCore::instance()->deviceManager()->plugins()) {
+            QVariantMap pluginMap;
+            pluginMap.insert("id", plugin->pluginId());
+            pluginMap.insert("name", plugin->pluginName());
+            pluginMap.insert("config", plugin->configuration());
+            plugins.append(pluginMap);
+        }
+        params.insert("plugins", plugins);
+        sendResponse(clientId, commandId, params);
+    } else if (method == "SetPluginConfig") {
+        QUuid pluginId = params.value("pluginId").toUuid();
+        QVariantMap pluginParams = params.value("params").toMap();
+        HiveCore::instance()->deviceManager()->plugin(pluginId)->setConfiguration(pluginParams);
+        sendResponse(clientId, commandId);
+    } else if (method == "AddConfiguredDevice") {
+        QUuid deviceClass = params.value("deviceClass").toUuid();
+        QVariantMap deviceParams = params.value("params").toMap();
+        DeviceManager::DeviceError status = HiveCore::instance()->deviceManager()->addConfiguredDevice(deviceClass, deviceParams);
+        switch(status) {
+        case DeviceManager::DeviceErrorNoError:
+            sendResponse(clientId, commandId);
+            break;
+        case DeviceManager::DeviceErrorDeviceClassNotFound:
+            sendErrorResponse(clientId, commandId, "Error creating device. Device class not found.");
+            break;
+        case DeviceManager::DeviceErrorMissingParameter:
+            sendErrorResponse(clientId, commandId, "Error creating device. Missing parameter.");
+            break;
+        default:
+            sendErrorResponse(clientId, commandId, "Unknown error.");
+        }
+    } else if (method == "GetConfiguredDevices") {
+        QVariantMap rspParams;
+        QVariantList configuredDeviceList;
+        foreach (Device *device, HiveCore::instance()->deviceManager()->configuredDevices()) {
+            configuredDeviceList.append(packDevice(device));
+        }
+        rspParams.insert("devices", configuredDeviceList);
+        sendResponse(clientId, commandId, rspParams);
+    } else {
+        sendErrorResponse(clientId, commandId, "No such method");
+    }
+}
+
 void JsonRPCServer::handleRulesMessage(int clientId, int commandId, const QString &method, const QVariantMap &params)
 {
     if (method == "GetRules") {

server/jsonrpcserver.h

@@ -25,6 +25,7 @@ private slots:
     void processData(int clientId, const QByteArray &jsonData);
 
 private:
+    void handleDevicesMessage(int clientId, int commandId, const QString &method, const QVariantMap &params);
     void handleRulesMessage(int clientId, int commandId, const QString &method, const QVariantMap &params);
     void handleActionMessage(int clientId, int commandId, const QString &method, const QVariantMap &params);
 

server/ruleengine.cpp

@@ -52,6 +52,8 @@ QList<Action> RuleEngine::evaluateTrigger(const Trigger &trigger)
 RuleEngine::RuleError RuleEngine::addRule(const Trigger &trigger, const Action &action)
 {
     qDebug() << "adding rule: Trigger:" << trigger.triggerTypeId() << "deviceid:" << action.deviceId();
+    DeviceClass triggerDeviceClass = HiveCore::instance()->deviceManager()->findDeviceClassforTrigger(trigger.triggerTypeId());
+
     Device *device = HiveCore::instance()->deviceManager()->findConfiguredDevice(trigger.deviceId());
     if (!device) {
         qWarning() << "Cannot create rule. No configured device for triggerTypeId" << trigger.triggerTypeId();

tests/getplugins.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+if [ -z $1 ]; then
+  echo "usage $0 host"
+else
+  (echo '{"id":1, "method":"Devices.GetPlugins"}'; sleep 1) | nc $1 1234
+fi

tests/setpluginconfig.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+if [ -z $1 ]; then
+  echo "usage $0 host"
+else
+  (echo '{"id":1, "method":"Devices.SetPluginConfig", "params":{"pluginId":"'$2'", "params":{"foo":"bar"}}}'; sleep 1) | nc $1 1234
+fi