Pass nodes into the zigbee resource and implement available for resource

libnymea-core/hardware/zigbee/zigbeehardwareresourceimplementation.cpp

@@ -41,15 +41,18 @@ NYMEA_LOGGING_CATEGORY(dcZigbeeResource, "ZigbeeResource")
 
 namespace nymeaserver {
 
-ZigbeeHardwareResourceImplementation::ZigbeeHardwareResourceImplementation(QObject *parent) :
-    ZigbeeHardwareResource(parent)
+ZigbeeHardwareResourceImplementation::ZigbeeHardwareResourceImplementation(ZigbeeManager *zigbeeManager, QObject *parent) :
+    ZigbeeHardwareResource(parent),
+    m_zigbeeManager(zigbeeManager)
 {
-
+    connect(m_zigbeeManager, &ZigbeeManager::nodeAdded, this, &ZigbeeHardwareResourceImplementation::onZigbeeNodeAdded);
+    connect(m_zigbeeManager, &ZigbeeManager::nodeRemoved, this, &ZigbeeHardwareResourceImplementation::onZigbeeNodeRemoved);
+    connect(m_zigbeeManager, &ZigbeeManager::availableChanged, this, &ZigbeeHardwareResourceImplementation::onZigbeeAvailableChanged);
 }
 
 bool ZigbeeHardwareResourceImplementation::available() const
 {
-    return m_available;
+    return m_zigbeeManager->available();
 }
 
 bool ZigbeeHardwareResourceImplementation::enabled() const
@@ -57,18 +60,6 @@ bool ZigbeeHardwareResourceImplementation::enabled() const
     return m_enabled;
 }
 
-void ZigbeeHardwareResourceImplementation::setZigbeeNetwork(ZigbeeNetwork *network)
-{
-    // Clean up
-    if (m_zigbeeNetwork) {
-        disconnect(m_zigbeeNetwork, &ZigbeeNetwork::stateChanged, this, &ZigbeeHardwareResourceImplementation::onZigbeeNetworkStateChanged);
-    }
-
-    // Set new network
-    m_zigbeeNetwork = network;
-    connect(m_zigbeeNetwork, &ZigbeeNetwork::stateChanged, this, &ZigbeeHardwareResourceImplementation::onZigbeeNetworkStateChanged);
-}
-
 void ZigbeeHardwareResourceImplementation::setEnabled(bool enabled)
 {
     qCDebug(dcZigbeeResource()) << "Set" << (enabled ? "enabled" : "disabled");
@@ -93,33 +84,43 @@ void ZigbeeHardwareResourceImplementation::setEnabled(bool enabled)
     }
 }
 
-void ZigbeeHardwareResourceImplementation::onZigbeeNetworkStateChanged(ZigbeeNetwork::State state)
-{
-    qCDebug(dcZigbeeResource()) << "Network state changed" << state;
-}
-
 bool ZigbeeHardwareResourceImplementation::enable()
 {
-    qCDebug(dcZigbeeResource()) << "Enable hardware resource";
+    qCDebug(dcZigbeeResource()) << "Enable hardware resource. Not implemented yet.";
 
-    if (!m_zigbeeNetwork) {
-        qCDebug(dcZigbeeResource()) << "There is no zigbee network configured as hardware resource";
-    } else {
-        // TODO: start network
-    }
+    // TODO: enable all networks in the zigbee manager
 
     return true;
 }
 
 bool ZigbeeHardwareResourceImplementation::disable()
 {
-    qCDebug(dcZigbeeResource()) << "Disable hardware resource";
-    if (!m_zigbeeNetwork) {
-        qCDebug(dcZigbeeResource()) << "There is no zigbee network configured as hardware resource";
-    }
+    qCDebug(dcZigbeeResource()) << "Disable hardware resource. Not implemented yet.";
+
+    // TODO: disable all networks in the zigbee manager
 
-    // TODO: stop network
     return true;
 }
 
+void ZigbeeHardwareResourceImplementation::onZigbeeAvailableChanged(bool available)
+{
+    if (available) {
+        qCDebug(dcZigbeeResource()) << "Zigbee is now available";
+    } else {
+        qCWarning(dcZigbeeResource()) << "Zigbee is not available any more";
+    }
+
+    emit availableChanged(available);
+}
+
+void ZigbeeHardwareResourceImplementation::onZigbeeNodeAdded(const QUuid &networkUuid, ZigbeeNode *node)
+{
+    qCDebug(dcZigbeeResource()) << node << "joined the network" << m_zigbeeManager->zigbeeNetworks().value(networkUuid);
+}
+
+void ZigbeeHardwareResourceImplementation::onZigbeeNodeRemoved(const QUuid &networkUuid, ZigbeeNode *node)
+{
+    qCDebug(dcZigbeeResource()) << node << "left the network" << m_zigbeeManager->zigbeeNetworks().value(networkUuid);
+}
+
 }

libnymea-core/hardware/zigbee/zigbeehardwareresourceimplementation.h

@@ -33,7 +33,7 @@
 
 #include <QObject>
 
-#include "zigbeenetwork.h"
+#include "zigbee/zigbeemanager.h"
 #include "hardware/zigbee/zigbeehardwarereource.h"
 
 namespace nymeaserver {
@@ -43,29 +43,28 @@ class ZigbeeHardwareResourceImplementation : public ZigbeeHardwareResource
     Q_OBJECT
 
 public:
-    explicit ZigbeeHardwareResourceImplementation(QObject *parent = nullptr);
+    explicit ZigbeeHardwareResourceImplementation(ZigbeeManager *zigbeeManager, QObject *parent = nullptr);
 
     bool available() const override;
     bool enabled() const override;
 
-    void setZigbeeNetwork(ZigbeeNetwork *network);
-
 private:
     bool m_available = false;
     bool m_enabled = false;
-
-    ZigbeeNetwork *m_zigbeeNetwork = nullptr;
+    ZigbeeManager *m_zigbeeManager = nullptr;
 
 protected:
     void setEnabled(bool enabled) override;
 
-private slots:
-    void onZigbeeNetworkStateChanged(ZigbeeNetwork::State state);
-
 public slots:
     bool enable();
     bool disable();
 
+private slots:
+    void onZigbeeAvailableChanged(bool available);
+    void onZigbeeNodeAdded(const QUuid &networkUuid, ZigbeeNode *node);
+    void onZigbeeNodeRemoved(const QUuid &networkUuid, ZigbeeNode *node);
+
 };
 
 }

libnymea-core/hardwaremanagerimplementation.cpp

@@ -46,7 +46,7 @@
 
 namespace nymeaserver {
 
-HardwareManagerImplementation::HardwareManagerImplementation(Platform *platform, MqttBroker *mqttBroker, QObject *parent) :
+HardwareManagerImplementation::HardwareManagerImplementation(Platform *platform, MqttBroker *mqttBroker, ZigbeeManager *zigbeeManager, QObject *parent) :
     HardwareManager(parent),
     m_platform(platform)
 {
@@ -71,10 +71,7 @@ HardwareManagerImplementation::HardwareManagerImplementation(Platform *platform,
 
     m_i2cManager = new I2CManagerImplementation(this);
 
-    m_zigbeeManager = new ZigbeeHardwareResourceImplementation(this);
-
-    qCDebug(dcHardware()) << "Hardware manager initialized successfully";
-
+    m_zigbeeResource = new ZigbeeHardwareResourceImplementation(zigbeeManager, this);
 
     // Enable all the resources
     setResourceEnabled(m_pluginTimerManager, true);
@@ -93,6 +90,7 @@ HardwareManagerImplementation::HardwareManagerImplementation(Platform *platform,
         setResourceEnabled(m_bluetoothLowEnergyManager, true);
 
     m_mqttProvider = new MqttProviderImplementation(mqttBroker, this);
+    qCDebug(dcHardware()) << "Hardware manager initialized successfully";
 }
 
 HardwareManagerImplementation::~HardwareManagerImplementation()
@@ -139,9 +137,9 @@ I2CManager *HardwareManagerImplementation::i2cManager()
     return m_i2cManager;
 }
 
-ZigbeeHardwareResource *HardwareManagerImplementation::zigbeeManager()
+ZigbeeHardwareResource *HardwareManagerImplementation::zigbeeResource()
 {
-    return m_zigbeeManager;
+    return m_zigbeeResource;
 }
 
 }

libnymea-core/hardwaremanagerimplementation.h

@@ -41,13 +41,14 @@ namespace nymeaserver {
 
 class Platform;
 class MqttBroker;
+class ZigbeeManager;
 
 class HardwareManagerImplementation : public HardwareManager
 {
     Q_OBJECT
 
 public:
-    explicit HardwareManagerImplementation(Platform *platform, MqttBroker *mqttBroker, QObject *parent = nullptr);
+    explicit HardwareManagerImplementation(Platform *platform, MqttBroker *mqttBroker, ZigbeeManager *zigbeeManager, QObject *parent = nullptr);
     ~HardwareManagerImplementation() override;
 
     Radio433 *radio433() override;
@@ -58,7 +59,7 @@ public:
     BluetoothLowEnergyManager *bluetoothLowEnergyManager() override;
     MqttProvider *mqttProvider() override;
     I2CManager *i2cManager() override;
-    ZigbeeHardwareResource *zigbeeManager() override;
+    ZigbeeHardwareResource *zigbeeResource() override;
 
 private:
     QNetworkAccessManager *m_networkAccessManager = nullptr;
@@ -73,7 +74,7 @@ private:
     BluetoothLowEnergyManager *m_bluetoothLowEnergyManager = nullptr;
     MqttProvider *m_mqttProvider = nullptr;
     I2CManager *m_i2cManager = nullptr;
-    ZigbeeHardwareResource *m_zigbeeManager = nullptr;
+    ZigbeeHardwareResource *m_zigbeeResource = nullptr;
 };
 
 }

libnymea-core/nymeacore.cpp

@@ -110,7 +110,7 @@ void NymeaCore::init() {
     m_zigbeeManager = new ZigbeeManager(this);
 
     qCDebug(dcCore) << "Creating Hardware Manager";
-    m_hardwareManager = new HardwareManagerImplementation(m_platform, m_serverManager->mqttBroker(), this);
+    m_hardwareManager = new HardwareManagerImplementation(m_platform, m_serverManager->mqttBroker(), m_zigbeeManager, this);
 
     qCDebug(dcCore) << "Creating Thing Manager (locale:" << m_configuration->locale() << ")";
     m_thingManager = new ThingManagerImplementation(m_hardwareManager, m_configuration->locale(), this);

libnymea-core/zigbee/zigbeemanager.cpp

@@ -84,7 +84,7 @@ ZigbeeManager::ZigbeeManager(QObject *parent) :
 
 bool ZigbeeManager::available() const
 {
-    return !m_zigbeeNetworks.isEmpty();
+    return m_available;
 }
 
 bool ZigbeeManager::enabled() const
@@ -296,16 +296,15 @@ ZigbeeNetwork *ZigbeeManager::buildNetworkObject(const QUuid &networkId, ZigbeeA
 void ZigbeeManager::addNetwork(ZigbeeNetwork *network)
 {
     connect(network, &ZigbeeNetwork::stateChanged, this, [this, network](ZigbeeNetwork::State state){
-        qCDebug(dcZigbee()) << "Network state changed" << network->networkUuid().toString() << state;
-
-        // TODO: set state of zigbee resource depending on the state
-
+        Q_UNUSED(state)
+        qCDebug(dcZigbee()) << "Network state changed" << network;
+        evaluateZigbeeAvailable();
         emit zigbeeNetworkChanged(network);
     });
 
-    connect(network, &ZigbeeNetwork::errorOccured, this, [network](ZigbeeNetwork::Error error){
+    connect(network, &ZigbeeNetwork::errorOccured, this, [this, network](ZigbeeNetwork::Error error){
         qCWarning(dcZigbee()) << "Network error occured for" << network << error;
-
+        evaluateZigbeeAvailable();
         // TODO: handle error
     });
 
@@ -382,4 +381,24 @@ ZigbeeAdapter ZigbeeManager::convertUartAdapterToAdapter(const ZigbeeUartAdapter
     return adapter;
 }
 
+void ZigbeeManager::evaluateZigbeeAvailable()
+{
+    bool zigbeeAvailable = false;
+    if (!m_zigbeeNetworks.isEmpty()) {
+        foreach (ZigbeeNetwork *network, m_zigbeeNetworks.values()) {
+            if (network->state() == ZigbeeNetwork::StateRunning) {
+                zigbeeAvailable = true;
+                break;
+            }
+        }
+    }
+
+    if (m_available == zigbeeAvailable)
+        return;
+
+    qCDebug(dcZigbee()) << "Zigbee is" << (zigbeeAvailable ? "now available" : "not available any more.");
+    m_available = zigbeeAvailable;
+    emit availableChanged(m_available);
+}
+
 }

libnymea-core/zigbee/zigbeemanager.h

@@ -80,6 +80,7 @@ private:
     ZigbeeAdapters m_adapters;
     ZigbeeUartAdapterMonitor *m_adapterMonitor = nullptr;
     QHash<QUuid, ZigbeeNetwork *> m_zigbeeNetworks;
+    bool m_available = false;
 
     void saveNetwork(ZigbeeNetwork *network);
     void loadZigbeeNetworks();
@@ -88,8 +89,11 @@ private:
     void addNetwork(ZigbeeNetwork *network);
 
     ZigbeeAdapter convertUartAdapterToAdapter(const ZigbeeUartAdapter &uartAdapter);
+    void evaluateZigbeeAvailable();
 
 signals:
+    void availableChanged(bool available);
+
     void availableAdapterAdded(const ZigbeeAdapter &adapter);
     void availableAdapterRemoved(const ZigbeeAdapter &adapter);
 
@@ -97,6 +101,8 @@ signals:
     void zigbeeNetworkRemoved(const QUuid networkUuid);
     void zigbeeNetworkChanged(ZigbeeNetwork *zigbeeNetwork);
 
+    void nodeAdded(const QUuid &networkUuid, ZigbeeNode *node);
+    void nodeRemoved(const QUuid &networkUuid, ZigbeeNode *node);
 };
 
 }

libnymea/hardwaremanager.h

@@ -62,7 +62,7 @@ public:
     virtual BluetoothLowEnergyManager *bluetoothLowEnergyManager() = 0;
     virtual MqttProvider *mqttProvider() = 0;
     virtual I2CManager *i2cManager() = 0;
-    virtual ZigbeeHardwareResource *zigbeeManager() = 0;
+    virtual ZigbeeHardwareResource *zigbeeResource() = 0;
 
 protected:
     void setResourceEnabled(HardwareResource* resource, bool enabled);