Update zigbee to API changes and fix custom serial port dialog

QtZeroConf

@@ -1 +1 @@
-Subproject commit cbf4f2bf7b926b9a874af013efbf0f6dde3155e9
+Subproject commit 39efbe2879d93bd483ee1f14fc94281a03b49935

libnymea-app/zigbee/zigbeeadapter.cpp

@@ -90,15 +90,15 @@ void ZigbeeAdapter::setHardwareRecognized(bool hardwareRecognized)
     emit hardwareRecognizedChanged();
 }
 
-ZigbeeAdapter::ZigbeeBackendType ZigbeeAdapter::backendType() const
+QString ZigbeeAdapter::backend() const
 {
-    return m_backendType;
+    return m_backend;
 }
 
-void ZigbeeAdapter::setBackendType(ZigbeeAdapter::ZigbeeBackendType backendType)
+void ZigbeeAdapter::setBackend(const QString &backend)
 {
-    m_backendType = backendType;
+    m_backend = backend;
-    emit backendTypeChanged();
+    emit backendChanged();
 }
 
 qint32 ZigbeeAdapter::baudRate() const
@@ -118,40 +118,16 @@ bool ZigbeeAdapter::operator==(const ZigbeeAdapter &other) const
             && m_name == other.name()
             && m_description == other.description()
             && m_hardwareRecognized == other.hardwareRecognized()
-            && m_backendType == other.backendType()
+            && m_backend == other.backend()
             && m_baudRate == other.baudRate();
 }
 
-ZigbeeAdapter::ZigbeeBackendType ZigbeeAdapter::stringToZigbeeBackendType(const QString &backendTypeString)
-{
-    if (backendTypeString == "ZigbeeBackendTypeNxp") {
-        return ZigbeeBackendTypeNxp;
-    } else if (backendTypeString == "ZigbeeBackendTypeDeconz") {
-        return ZigbeeBackendTypeDeconz;
-    } else {
-        // default if not recognized
-        return ZigbeeBackendTypeDeconz;
-    }
-}
-
-QString ZigbeeAdapter::getBackendName(ZigbeeAdapter::ZigbeeBackendType backendType)
-{
-    switch (backendType) {
-    case ZigbeeAdapter::ZigbeeBackendTypeDeconz:
-        return "deCONZ";
-    case ZigbeeAdapter::ZigbeeBackendTypeNxp:
-        return "Nxp";
-    default:
-        return tr("Unknown");
-    }
-}
-
 QDebug operator<<(QDebug debug, const ZigbeeAdapter &adapter)
 {
     debug.nospace() << "ZigbeeAdapter(" << adapter.name() << " - " << adapter.description();
     debug.nospace() << ", " << adapter.serialPort();
     if (adapter.hardwareRecognized()) {
-        debug.nospace() << " Hardware recognized: " << adapter.backendType();
+        debug.nospace() << " Hardware recognized: " << adapter.backend();
         debug.nospace() << ", " << adapter.baudRate();
     }
 

libnymea-app/zigbee/zigbeeadapter.h

@@ -42,16 +42,10 @@ class ZigbeeAdapter : public QObject
     Q_PROPERTY(QString serialPort READ serialPort WRITE setSerialPort NOTIFY serialPortChanged)
     Q_PROPERTY(QString serialNumber READ serialNumber WRITE setSerialNumber NOTIFY serialNumberChanged)
     Q_PROPERTY(bool hardwareRecognized READ hardwareRecognized WRITE setHardwareRecognized NOTIFY hardwareRecognizedChanged)
-    Q_PROPERTY(ZigbeeAdapter::ZigbeeBackendType backendType READ backendType WRITE setBackendType NOTIFY backendTypeChanged)
+    Q_PROPERTY(QString backend READ backend WRITE setBackend NOTIFY backendChanged)
     Q_PROPERTY(qint32 baudRate READ baudRate WRITE setBaudRate NOTIFY baudRateChanged)
 
 public:
-    enum ZigbeeBackendType {
-        ZigbeeBackendTypeDeconz,
-        ZigbeeBackendTypeNxp
-    };
-    Q_ENUM(ZigbeeBackendType)
-
     explicit ZigbeeAdapter(QObject *parent = nullptr);
 
     QString name() const;
@@ -69,25 +63,21 @@ public:
     bool hardwareRecognized() const;
     void setHardwareRecognized(bool hardwareRecognized);
 
-    ZigbeeAdapter::ZigbeeBackendType backendType() const;
+    QString backend() const;
-    void setBackendType(ZigbeeAdapter::ZigbeeBackendType backendType);
+    void setBackend(const QString &backend);
 
     qint32 baudRate() const;
     void setBaudRate(qint32 baudRate);
 
     bool operator==(const ZigbeeAdapter &other) const;
 
-    static ZigbeeAdapter::ZigbeeBackendType stringToZigbeeBackendType(const QString &backendTypeString);
-
-    Q_INVOKABLE static QString getBackendName(ZigbeeAdapter::ZigbeeBackendType backendType);
-
 private:
     QString m_name;
     QString m_description;
     QString m_serialPort;
     QString m_serialNumber;
     bool m_hardwareRecognized = false;
-    ZigbeeAdapter::ZigbeeBackendType m_backendType = ZigbeeAdapter::ZigbeeBackendTypeDeconz;
+    QString m_backend;
     qint32 m_baudRate = 38400;
 
 signals:
@@ -96,12 +86,10 @@ signals:
     void serialPortChanged();
     void serialNumberChanged();
     void hardwareRecognizedChanged();
-    void backendTypeChanged();
+    void backendChanged();
     void baudRateChanged();
 };
 
-Q_DECLARE_METATYPE(ZigbeeAdapter::ZigbeeBackendType)
-
 QDebug operator<<(QDebug debug, const ZigbeeAdapter &adapter);
 
 #endif // ZIGBEEADAPTER_H

libnymea-app/zigbee/zigbeeadapters.cpp

@@ -52,8 +52,8 @@ QVariant ZigbeeAdapters::data(const QModelIndex &index, int role) const
         return m_adapters.at(index.row())->serialPort();
     case RoleHardwareRecognized:
         return m_adapters.at(index.row())->hardwareRecognized();
-    case RoleBackendType:
+    case RoleBackend:
-        return m_adapters.at(index.row())->backendType();
+        return m_adapters.at(index.row())->backend();
     case RoleBaudRate:
         return m_adapters.at(index.row())->baudRate();
     }
@@ -67,7 +67,7 @@ QHash<int, QByteArray> ZigbeeAdapters::roleNames() const
     roles.insert(RoleDescription, "description");
     roles.insert(RoleSerialPort, "serialPort");
     roles.insert(RoleHardwareRecognized, "hardwareRecognized");
-    roles.insert(RoleBackendType, "backendType");
+    roles.insert(RoleBackend, "backend");
     roles.insert(RoleBaudRate, "baudRate");
     return roles;
 }
@@ -99,9 +99,9 @@ void ZigbeeAdapters::addAdapter(ZigbeeAdapter *adapter)
         emit dataChanged(idx, idx, {RoleHardwareRecognized});
     });
 
-    connect(adapter, &ZigbeeAdapter::backendTypeChanged, this, [this, adapter]() {
+    connect(adapter, &ZigbeeAdapter::backendChanged, this, [this, adapter]() {
         QModelIndex idx = index(m_adapters.indexOf(adapter), 0);
-        emit dataChanged(idx, idx, {RoleBackendType});
+        emit dataChanged(idx, idx, {RoleBackend});
     });
 
     connect(adapter, &ZigbeeAdapter::baudRateChanged, this, [this, adapter]() {

libnymea-app/zigbee/zigbeeadapters.h

@@ -47,7 +47,7 @@ public:
         RoleDescription,
         RoleSerialPort,
         RoleHardwareRecognized,
-        RoleBackendType,
+        RoleBackend,
         RoleBaudRate
     };
     Q_ENUM(Roles)

libnymea-app/zigbee/zigbeemanager.cpp

@@ -44,7 +44,6 @@ ZigbeeManager::ZigbeeManager(QObject *parent) :
     m_adapters(new ZigbeeAdapters(this)),
     m_networks(new ZigbeeNetworks(this))
 {
-    qRegisterMetaType<ZigbeeAdapter::ZigbeeBackendType>();
 
 }
 
@@ -72,6 +71,11 @@ Engine *ZigbeeManager::engine() const
     return m_engine;
 }
 
+QStringList ZigbeeManager::availableBackends() const
+{
+    return m_availableBackends;
+}
+
 ZigbeeAdapters *ZigbeeManager::adapters() const
 {
     return m_adapters;
@@ -82,13 +86,12 @@ ZigbeeNetworks *ZigbeeManager::networks() const
     return m_networks;
 }
 
-int ZigbeeManager::addNetwork(const QString &serialPort, uint baudRate, ZigbeeAdapter::ZigbeeBackendType backendType)
+int ZigbeeManager::addNetwork(const QString &serialPort, uint baudRate, const QString &backend)
 {
     QVariantMap params;
     params.insert("serialPort", serialPort);
     params.insert("baudRate", baudRate);
-    QMetaEnum metaEnum = QMetaEnum::fromType<ZigbeeAdapter::ZigbeeBackendType>();
+    params.insert("backend", backend);
-    params.insert("backendType", metaEnum.valueToKey(backendType));
 
     qDebug() << "Add zigbee network" << params;
     return m_engine->jsonRpcClient()->sendCommand("Zigbee.AddNetwork", params, this, "addNetworkResponse");
@@ -121,13 +124,25 @@ void ZigbeeManager::init()
 {
     m_adapters->clear();
     m_networks->clear();
+    m_availableBackends.clear();
 
     m_engine->jsonRpcClient()->registerNotificationHandler(this, "notificationReceived");
 
+    m_engine->jsonRpcClient()->sendCommand("Zigbee.GetAvailableBackends", this, "getAvailableBackendsResponse");
     m_engine->jsonRpcClient()->sendCommand("Zigbee.GetAdapters", this, "getAdaptersResponse");
     m_engine->jsonRpcClient()->sendCommand("Zigbee.GetNetworks", this, "getNetworksResponse");
 }
 
+void ZigbeeManager::getAvailableBackendsResponse(int commandId, const QVariantMap &params)
+{
+    qDebug() << "Zigbee get available backends response" << commandId << params;
+    m_availableBackends.clear();
+    foreach (const QVariant &backendVariant, params.value("backends").toList()) {
+        m_availableBackends << backendVariant.toString();
+    }
+    emit availableBackendsChanged();
+}
+
 void ZigbeeManager::getAdaptersResponse(int commandId, const QVariantMap &params)
 {
     qDebug() << "Zigbee get adapters response" << commandId << params;
@@ -141,7 +156,7 @@ void ZigbeeManager::getAdaptersResponse(int commandId, const QVariantMap &params
 
 //    ZigbeeAdapter *fakeAdapter = new ZigbeeAdapter();
 //    fakeAdapter->setSerialPort("/dev/fake");
-//    fakeAdapter->setBackendType(ZigbeeAdapter::ZigbeeBackendTypeDeconz);
+//    fakeAdapter->setBackend("Fake");
 //    fakeAdapter->setBaudRate(9600);
 //    fakeAdapter->setDescription("Fake adapter");
 //    fakeAdapter->setHardwareRecognized(true);
@@ -232,7 +247,7 @@ ZigbeeAdapter *ZigbeeManager::unpackAdapter(const QVariantMap &adapterMap)
     adapter->setSerialPort(adapterMap.value("serialPort").toString());
     adapter->setSerialNumber(adapterMap.value("serialNumber").toString());
     adapter->setHardwareRecognized(adapterMap.value("hardwareRecognized").toBool());
-    adapter->setBackendType(ZigbeeAdapter::stringToZigbeeBackendType(adapterMap.value("backendType").toString()));
+    adapter->setBackend(adapterMap.value("backend").toString());
     adapter->setBaudRate(adapterMap.value("baudRate").toUInt());
     return adapter;
 }
@@ -257,7 +272,7 @@ void ZigbeeManager::fillNetworkData(ZigbeeNetwork *network, const QVariantMap &n
     network->setPermitJoiningEnabled(networkMap.value("permitJoiningEnabled").toBool());
     network->setPermitJoiningDuration(networkMap.value("permitJoiningDuration").toUInt());
     network->setPermitJoiningRemaining(networkMap.value("permitJoiningRemaining").toUInt());
-    network->setBackendType(ZigbeeAdapter::stringToZigbeeBackendType(networkMap.value("backendType").toString()));
+    network->setBackend(networkMap.value("backend").toString());
     network->setNetworkState(ZigbeeNetwork::stringToZigbeeNetworkState(networkMap.value("networkState").toString()));
 }
 

libnymea-app/zigbee/zigbeemanager.h

@@ -46,6 +46,7 @@ class ZigbeeManager : public JsonHandler
     Q_OBJECT
     Q_PROPERTY(Engine* engine READ engine WRITE setEngine NOTIFY engineChanged)
 
+    Q_PROPERTY(QStringList availableBackends READ availableBackends NOTIFY availableBackendsChanged)
     Q_PROPERTY(ZigbeeAdapters *adapters READ adapters CONSTANT)
     Q_PROPERTY(ZigbeeNetworks *networks READ networks CONSTANT)
 
@@ -58,22 +59,24 @@ public:
     void setEngine(Engine *engine);
     Engine *engine() const;
 
+    QStringList availableBackends() const;
     ZigbeeAdapters *adapters() const;
     ZigbeeNetworks *networks() const;
 
-    Q_INVOKABLE int addNetwork(const QString &serialPort, uint baudRate, ZigbeeAdapter::ZigbeeBackendType backendType);
+    Q_INVOKABLE int addNetwork(const QString &serialPort, uint baudRate, const QString &backend);
     Q_INVOKABLE void removeNetwork(const QUuid &networkUuid);
     Q_INVOKABLE void setPermitJoin(const QUuid &networkUuid, uint duration = 120);
     Q_INVOKABLE void factoryResetNetwork(const QUuid &networkUuid);
 
 signals:
     void engineChanged();
-
+    void availableBackendsChanged();
     void addNetworkReply(int commandId, const QString &error, const QUuid &networkUuid);
 
 private:
     void init();
 
+    Q_INVOKABLE void getAvailableBackendsResponse(int commandId, const QVariantMap &params);
     Q_INVOKABLE void getAdaptersResponse(int commandId, const QVariantMap &params);
     Q_INVOKABLE void getNetworksResponse(int commandId, const QVariantMap &params);
 
@@ -86,6 +89,7 @@ private:
 
 private:
     Engine* m_engine = nullptr;
+    QStringList m_availableBackends;
     ZigbeeAdapters *m_adapters = nullptr;
     ZigbeeNetworks *m_networks = nullptr;
 

libnymea-app/zigbee/zigbeenetwork.cpp

@@ -219,18 +219,18 @@ void ZigbeeNetwork::setPermitJoiningRemaining(uint permitJoiningRemaining)
     }
 }
 
-ZigbeeAdapter::ZigbeeBackendType ZigbeeNetwork::backendType() const
+QString ZigbeeNetwork::backend() const
 {
-    return m_backendType;
+    return m_backend;
 }
 
-void ZigbeeNetwork::setBackendType(ZigbeeAdapter::ZigbeeBackendType backendType)
+void ZigbeeNetwork::setBackend(const QString &backend)
 {
-    if (m_backendType == backendType)
+    if (m_backend == backend)
         return;
 
-    m_backendType = backendType;
+    m_backend = backend;
-    emit backendTypeChanged();
+    emit backendChanged();
 }
 
 ZigbeeNetwork::ZigbeeNetworkState ZigbeeNetwork::networkState() const

libnymea-app/zigbee/zigbeenetwork.h

@@ -52,7 +52,7 @@ class ZigbeeNetwork : public QObject
     Q_PROPERTY(bool permitJoiningEnabled READ permitJoiningEnabled NOTIFY permitJoiningEnabledChanged)
     Q_PROPERTY(uint permitJoiningDuration READ permitJoiningDuration NOTIFY permitJoiningDurationChanged)
     Q_PROPERTY(uint permitJoiningRemaining READ permitJoiningRemaining NOTIFY permitJoiningRemainingChanged)
-    Q_PROPERTY(ZigbeeAdapter::ZigbeeBackendType backendType READ backendType NOTIFY backendTypeChanged)
+    Q_PROPERTY(QString backend READ backend NOTIFY backendChanged)
     Q_PROPERTY(ZigbeeNetworkState networkState READ networkState NOTIFY networkStateChanged)
 
     // Internal properties
@@ -105,8 +105,8 @@ public:
     uint permitJoiningRemaining() const;
     void setPermitJoiningRemaining(uint permitJoiningRemaining);
 
-    ZigbeeAdapter::ZigbeeBackendType backendType() const;
+    QString backend() const;
-    void setBackendType(ZigbeeAdapter::ZigbeeBackendType backendType);
+    void setBackend(const QString &backend);
 
     ZigbeeNetworkState networkState() const;
     void setNetworkState(ZigbeeNetworkState networkState);
@@ -126,7 +126,7 @@ signals:
     void permitJoiningEnabledChanged();
     void permitJoiningDurationChanged();
     void permitJoiningRemainingChanged();
-    void backendTypeChanged();
+    void backendChanged();
     void networkStateChanged();
 
 private:
@@ -142,7 +142,7 @@ private:
     bool m_permitJoiningEnabled;
     uint m_permitJoiningDuration;
     uint m_permitJoiningRemaining;
-    ZigbeeAdapter::ZigbeeBackendType m_backendType;
+    QString m_backend;
     ZigbeeNetworkState m_networkState;
 
     QTimer *m_permitJoinTimer = nullptr;

libnymea-app/zigbee/zigbeenetworks.cpp

@@ -66,8 +66,8 @@ QVariant ZigbeeNetworks::data(const QModelIndex &index, int role) const
         return m_networks.at(index.row())->permitJoiningDuration();
     case RolePermitJoiningRemaining:
         return m_networks.at(index.row())->permitJoiningRemaining();
-    case RoleBackendType:
+    case RoleBackend:
-        return m_networks.at(index.row())->backendType();
+        return m_networks.at(index.row())->backend();
     case RoleNetworkState:
         return m_networks.at(index.row())->networkState();
     }
@@ -89,7 +89,7 @@ QHash<int, QByteArray> ZigbeeNetworks::roleNames() const
     roles.insert(RolePermitJoiningEnabled, "permitJoiningEnabled");
     roles.insert(RolePermitJoiningDuration, "permitJoiningDuration");
     roles.insert(RolePermitJoiningRemaining, "permitJoiningRemaining");
-    roles.insert(RoleBackendType, "backendType");
+    roles.insert(RoleBackend, "backend");
     roles.insert(RoleNetworkState, "networkState");
     return roles;
 
@@ -155,9 +155,9 @@ void ZigbeeNetworks::addNetwork(ZigbeeNetwork *network)
         emit dataChanged(idx, idx, {RolePermitJoiningRemaining});
     });
 
-    connect(network, &ZigbeeNetwork::backendTypeChanged, this, [this, network]() {
+    connect(network, &ZigbeeNetwork::backendChanged, this, [this, network]() {
         QModelIndex idx = index(m_networks.indexOf(network), 0);
-        emit dataChanged(idx, idx, {RoleBackendType});
+        emit dataChanged(idx, idx, {RoleBackend});
     });
 
     connect(network, &ZigbeeNetwork::networkStateChanged, this, [this, network]() {

libnymea-app/zigbee/zigbeenetworks.h

@@ -54,7 +54,7 @@ public:
         RolePermitJoiningEnabled,
         RolePermitJoiningDuration,
         RolePermitJoiningRemaining,
-        RoleBackendType,
+        RoleBackend,
         RoleNetworkState
     };
     Q_ENUM(Roles)

nymea-app/ui/system/ZigbeeAddNetworkPage.qml

@@ -47,8 +47,8 @@ SettingsPageBase {
         id: d
         property int pendingCommandId: -1
 
-        function addNetwork(serialPort, baudRate, backendType) {
+        function addNetwork(serialPort, baudRate, backend) {
-            d.pendingCommandId = root.zigbeeManager.addNetwork(serialPort, baudRate, backendType)
+            d.pendingCommandId = root.zigbeeManager.addNetwork(serialPort, baudRate, backend)
         }
     }
 
@@ -128,8 +128,8 @@ SettingsPageBase {
         delegate: NymeaListItemDelegate {
             Layout.fillWidth: true
             iconName: "../images/zigbee.svg"
-            text: model.name + " - " + model.description + " - " + model.serialPort
+            text: model.backend + " - " + model.description + " - " + model.serialPort
-            onClicked: d.addNetwork(model.serialPort, model.baudRate, model.backendType)
+            onClicked: d.addNetwork(model.serialPort, model.baudRate, model.backend)
         }
     }
 
@@ -161,7 +161,7 @@ SettingsPageBase {
             iconName: "../images/stock_usb.svg"
             text: model.description + " - " + model.serialPort
             onClicked: {
-                var dialog = serialPortOptionsDialogComponent.createObject(app, {serialPort: model.serialPort, baudRate: model.baudRate})
+                var dialog = serialPortOptionsDialogComponent.createObject(app, {serialPort: model.serialPort, baudRate: model.baudRate, backend: model.backend})
                 dialog.open()
             }
         }
@@ -174,6 +174,7 @@ SettingsPageBase {
             id: serialPortOptionsDialog
             property string serialPort
             property int baudRate
+            property string backend
 
             headerIcon: "../images/stock_usb.svg"
             title: qsTr("Serial port options")
@@ -187,12 +188,10 @@ SettingsPageBase {
                 }
                 ComboBox {
                     id: backendComboBox
-                    model: ListModel {
+                    model: root.zigbeeManager.availableBackends
-                        id: backendModel
+                    Component.onCompleted: {
-                        ListElement { displayName: "deConz"; backendValue: ZigbeeAdapter.ZigbeeBackendTypeDeconz }
+                        currentIndex = backendComboBox.find(serialPortOptionsDialog.backend)
-                        ListElement { displayName: "NXP"; backendValue: ZigbeeAdapter.ZigbeeBackendTypeNxp }
                     }
-                    textRole: "displayName"
                 }
             }
 
@@ -203,15 +202,15 @@ SettingsPageBase {
                 }
                 ComboBox {
                     id: baudRateComboBox
-                    model: [300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 38400, 57600]
+                    model: ["9600", "14400", "19200", "38400", "57600", "115200", "128000", "230400", "256000"]
                     Component.onCompleted: {
-                        currentIndex = indexOfValue(serialPortOptionsDialog.baudRate)
+                        currentIndex = baudRateComboBox.find(serialPortOptionsDialog.baudRate)
                     }
                 }
             }
 
             onAccepted: {
-                d.addNetwork(serialPortOptionsDialog.serialPort, baudRateComboBox.currentText, backendModel.get(backendComboBox.currentIndex).backendValue)
+                d.addNetwork(serialPortOptionsDialog.serialPort, baudRateComboBox.currentText, backendComboBox.currentText)
             }
         }
     }

nymea-app/ui/system/ZigbeeNetworkInfoPage.qml

@@ -79,7 +79,7 @@ SettingsPageBase {
     NymeaListItemDelegate {
         Layout.fillWidth: true
         text: qsTr("Controller backend")
-        subText: ZigbeeAdapter.getBackendName(root.network.backendType)
+        subText: root.network.backend
         progressive: false
         prominentSubText: false
     }

nymea-app/ui/system/ZigbeeSettingsPage.qml

@@ -88,7 +88,7 @@ SettingsPageBase {
             Layout.fillWidth: true
             property var network: zigbeeManager.networks.get(index)
             iconName: "../images/zigbee.svg"
-            text: model.macAddress
+            text: model.backend + " - " + model.macAddress
             subText: model.serialPort  + " - " + model.firmwareVersion
             onClicked: pageStack.push(Qt.resolvedUrl("ZigbeeNetworkPage.qml"), { zigbeeManager: zigbeeManager, network: network })
         }