Make debian build work

debian/control

@@ -12,39 +12,35 @@ Standards-Version: 3.9.7
 
 Package: nymea-networkmanager
 Architecture: any
-Depends: libqt5network5,
+Depends: ${misc:Depends},
+  libqt5network5,
   libqt5bluetooth5,
-  ${shlibs:Depends},
+  libnymea-networkmanager (= ${binary:Version})
-  ${misc:Depends}
 Description: Daemon for wireless configuration using bluetooth LE.
   This daemon allows to configure a wireless network using a bluetooth
   low energy gatt server. The tool is written in Qt 5.
 
-Package: libnymea-networkmanager1
+Package: libnymea-networkmanager
 Section: libs
 Architecture: any
-Depends: ${shlibs:Depends},
+Depends: ${misc:Depends},
-  ${misc:Depends},
+  libqt5network5
-  libqt5network5,
 Description: Qt 5 based library for the network-manager DBus API.
   Qt 5 based library for the network-manager DBus API.
 
-Package: libnymea-networkmanager1-dev
+Package: libnymea-networkmanager-dev
 Section: libdevel
 Architecture: any
-Depends: libnymea-networkmanager1 (= ${binary:Version}),
+Depends: ${misc:Depends},
-  ${shlibs:Depends},
+  libnymea-networkmanager (= ${binary:Version})
-  ${misc:Depends}
 Description: Qt 5 based library for the network-manager DBus API - development files
   Development files for Qt 5 based network-manager DBus API.
 
-
+Package: libnymea-networkmanager-dbg
-Package: libnymea-networkmanager1-dbg
 Priority: extra
 Architecture: any
 Section: debug
-Depends: libnymea-networkmanager1 (= ${binary:Version}),
+Depends: ${misc:Depends},
-  ${shlibs:Depends},
+  libnymea-networkmanager (= ${binary:Version})
-  ${misc:Depends}
 Description: Qt 5 based library for the network-manager DBus API - debug symbols
   Debug Symbols for Qt 5 based network-manager DBus API.

debian/libnymea-networkmanager-dev.dirs.in

@@ -0,0 +1,2 @@
+usr/lib/@DEB_HOST_MULTIARCH@
+usr/include/nymea-networkmanager

debian/libnymea-networkmanager-dev.install.in

@@ -0,0 +1,3 @@
+usr/lib/@DEB_HOST_MULTIARCH@/libnymea-networkmanager.so
+usr/include/libnymea-networkmanager/* usr/include/libnymea-networkmanager
+

debian/libnymea-networkmanager.install.in

@@ -0,0 +1,3 @@
+usr/lib/@DEB_HOST_MULTIARCH@/libnymea-networkmanager.so.1
+usr/lib/@DEB_HOST_MULTIARCH@/libnymea-networkmanager.so.1.0
+usr/lib/@DEB_HOST_MULTIARCH@/libnymea-networkmanager.so.1.0.0

debian/libnymea-networkmanager1-dev.install.in

@@ -1,3 +0,0 @@
-usr/lib/libnymea-networkmanager1.install.in/libnymea-networkmanager1.so
-usr/include/nymea-networkmanager/* usr/include/nymea-networkmanager
-

debian/libnymea-networkmanager1.install.in

@@ -1 +0,0 @@
-usr/lib/@DEB_HOST_MULTIARCH@/

debian/rules

@@ -12,13 +12,10 @@ $(PREPROCESS_FILES:.in=): %: %.in
 	dh $@ --buildsystem=qmake --parallel
 
 override_dh_install: $(PREPROCESS_FILES:.in=)
-	dh_install --fail-missing
+	dh_install
-
-override_dh_auto_build:
-	dh_auto_build
 
 override_dh_strip:
-	dh_strip --dbg-package=libnymea-networkmanager1-dbg
+	dh_strip --dbg-package=libnymea-networkmanager-dbg
 
 override_dh_auto_clean:
 	dh_auto_clean

libnymea-networkmanager/libnymea-networkmanager.pro

@@ -1,4 +1,4 @@
-TARGET = nymea-networkmanager1
+TARGET = nymea-networkmanager
 TEMPLATE = lib
 
 target.path = /usr/lib/$$system('dpkg-architecture -q DEB_HOST_MULTIARCH')

libnymea-networkmanager/networkconnection.cpp

@@ -51,7 +51,7 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject
     m_connectionSettings = qdbus_cast<ConnectionSettings>(argument);
 }
 
-/*! Delets this \l{NetworkConnection} in the \l{NetworkManager}. */
+/*! Delete this \l{NetworkConnection} in the \l{NetworkManager}. */
 void NetworkConnection::deleteConnection()
 {
     QDBusMessage query = m_connectionInterface->call("Delete");

libnymea-networkmanager/networkconnection.h

@@ -55,10 +55,9 @@ public:
 
 private:
     QDBusObjectPath m_objectPath;
-    QDBusInterface *m_connectionInterface;
+    QDBusInterface *m_connectionInterface = nullptr;
 
     ConnectionSettings m_connectionSettings;
-
 };
 
 QDebug operator<<(QDebug debug, NetworkConnection *networkConnection);

libnymea-networkmanager/networkdevice.cpp

@@ -138,11 +138,7 @@
 /*! Constructs a new \l{NetworkDevice} with the given dbus \a objectPath and \a parent. */
 NetworkDevice::NetworkDevice(const QDBusObjectPath &objectPath, QObject *parent) :
     QObject(parent),
-    m_objectPath(objectPath),
+    m_objectPath(objectPath)
-    m_mtu(0),
-    m_metered(0),
-    m_deviceState(NetworkDeviceStateUnknown),
-    m_deviceStateReason(NetworkDeviceStateReasonUnknown)
 {
     QDBusConnection systemBus = QDBusConnection::systemBus();
     if (!systemBus.isConnected()) {

libnymea-networkmanager/networkdevice.h

@@ -177,7 +177,7 @@ public:
     static QString deviceStateReasonToString(const NetworkDeviceStateReason &deviceStateReason);
 
 private:
-    QDBusInterface *m_networkDeviceInterface;
+    QDBusInterface *m_networkDeviceInterface = nullptr;
     QDBusObjectPath m_objectPath;
 
     // Device properties
@@ -188,12 +188,12 @@ private:
     QString m_driverVersion;
     QString m_firmwareVersion;
     QString m_physicalPortId;
-    uint m_mtu;
+    uint m_mtu = 0;
-    uint m_metered;
+    uint m_metered = 0;
-    bool m_autoconnect;
+    bool m_autoconnect = false;
-    NetworkDeviceState m_deviceState;
+    NetworkDeviceState m_deviceState = NetworkDeviceStateUnknown;
-    NetworkDeviceStateReason m_deviceStateReason;
+    NetworkDeviceStateReason m_deviceStateReason = NetworkDeviceStateReasonUnknown;
-    NetworkDeviceType m_deviceType;
+    NetworkDeviceType m_deviceType = NetworkDeviceTypeUnknown;
 
     QDBusObjectPath m_activeConnection;
     QDBusObjectPath m_ip4Config;

libnymea-networkmanager/networkmanager.cpp

@@ -28,46 +28,9 @@
 
 /*! Constructs a new \l{NetworkManager} object with the given \a parent. */
 NetworkManager::NetworkManager(QObject *parent) :
-    QObject(parent),
+    QObject(parent)
-    m_networkManagerInterface(nullptr),
-    m_available(false),
-    m_state(NetworkManagerStateUnknown),
-    m_connectivityState(NetworkManagerConnectivityStateUnknown),
-    m_networkingEnabled(false),
-    m_wirelessEnabled(false)
 {
-    // Check DBus connection
-    if (!QDBusConnection::systemBus().isConnected()) {
-        qCWarning(dcNetworkManager()) << "System DBus not connected. NetworkManagre not available.";
-        return;
-    }
 
-    // Create interface
-    m_networkManagerInterface = new QDBusInterface(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), QDBusConnection::systemBus(), this);
-    if(!m_networkManagerInterface->isValid()) {
-        qCWarning(dcNetworkManager()) << "Invalid DBus network manager interface. NetworkManagre not available.";
-        return;
-    }
-
-    m_available = true;
-
-    // Read properties
-    setVersion(m_networkManagerInterface->property("Version").toString());
-    setState((NetworkManagerState)m_networkManagerInterface->property("State").toUInt());
-    setConnectivityState((NetworkManagerConnectivityState)m_networkManagerInterface->property("Connectivity").toUInt());
-    setNetworkingEnabled(m_networkManagerInterface->property("NetworkingEnabled").toBool());
-    setWirelessEnabled(m_networkManagerInterface->property("WirelessEnabled").toBool());
-
-    loadDevices();
-
-    // Connect signals
-    QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "StateChanged", this, SLOT(onStateChanged(uint)));
-    QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "DeviceAdded", this, SLOT(onDeviceAdded(QDBusObjectPath)));
-    QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "DeviceRemoved", this, SLOT(onDeviceRemoved(QDBusObjectPath)));
-    QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "PropertiesChanged", this, SLOT(onPropertiesChanged(QVariantMap)));
-
-    // Create settings
-    m_networkSettings = new NetworkSettings(this);
 }
 
 NetworkManager::~NetworkManager()
@@ -76,13 +39,13 @@ NetworkManager::~NetworkManager()
 }
 
 /*! Returns true if the network-manager is available on this system. */
-bool NetworkManager::available()
+bool NetworkManager::available() const
 {
     return m_available;
 }
 
 /*! Returns true if wifi is available on this system. */
-bool NetworkManager::wirelessAvailable()
+bool NetworkManager::wirelessAvailable() const
 {
     return !m_wirelessNetworkDevices.isEmpty();
 }
@@ -111,7 +74,7 @@ NetworkDevice *NetworkManager::getNetworkDevice(const QString &interface)
         if (device->interface() == interface)
             return device;
     }
-    return Q_NULLPTR;
+    return nullptr;
 }
 
 /*! Returns the version of the running \l{NetworkManager}. */
@@ -139,7 +102,7 @@ NetworkManager::NetworkManagerConnectivityState NetworkManager::connectivityStat
 }
 
 /*! Connect the given \a interface to a wifi network with the given \a ssid and \a password. Returns the \l{NetworkManagerError} to inform about the result. \sa NetworkManagerError, */
-NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &interface, const QString &ssid, const QString &password, const bool &hidden)
+NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &interface, const QString &ssid, const QString &password, bool hidden)
 {
     // Check interface
     if (!getNetworkDevice(interface))
@@ -226,7 +189,7 @@ bool NetworkManager::networkingEnabled() const
 }
 
 /*! Returns true if the networking of this \l{NetworkManager} could be \a enabled. */
-bool NetworkManager::enableNetworking(const bool &enabled)
+bool NetworkManager::enableNetworking(bool enabled)
 {
     if (m_networkingEnabled == enabled)
         return true;
@@ -240,11 +203,15 @@ bool NetworkManager::enableNetworking(const bool &enabled)
 }
 
 /*! Sets the networking of this \l{NetworkManager} to \a enabled. */
-void NetworkManager::setNetworkingEnabled(const bool &enabled)
+void NetworkManager::setNetworkingEnabled(bool enabled)
 {
+    if (m_networkingEnabled == enabled)
+        return;
+
     qCDebug(dcNetworkManager()) << "Networking" << (enabled ? "enabled" : "disabled");
+
     m_networkingEnabled = enabled;
-    emit networkingEnabledChanged();
+    emit networkingEnabledChanged(m_networkingEnabled);
 }
 
 /*! Returns true if the wireless networking of this \l{NetworkManager} is enabled. */
@@ -254,7 +221,7 @@ bool NetworkManager::wirelessEnabled() const
 }
 
 /*! Returns true if the wireless networking of this \l{NetworkManager} could be set to \a enabled. */
-bool NetworkManager::enableWireless(const bool &enabled)
+bool NetworkManager::enableWireless(bool enabled)
 {
     if (m_wirelessEnabled == enabled)
         return true;
@@ -262,6 +229,25 @@ bool NetworkManager::enableWireless(const bool &enabled)
     return m_networkManagerInterface->setProperty("WirelessEnabled", enabled);
 }
 
+bool NetworkManager::isConnectedToLan() const
+{
+    // Check all wireless devices if one is connected
+    foreach (WirelessNetworkDevice *wirelessDevice, wirelessNetworkDevices()) {
+        if (wirelessDevice->deviceState() == NetworkDevice::NetworkDeviceStateActivated) {
+            return true;
+        }
+    }
+
+    // Check all wired devices if one is connected
+    foreach (WiredNetworkDevice *wiredDevice, wiredNetworkDevices()) {
+        if (wiredDevice->deviceState() == NetworkDevice::NetworkDeviceStateActivated) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 void NetworkManager::loadDevices()
 {
     // Get network devices
@@ -299,15 +285,31 @@ QString NetworkManager::networkManagerConnectivityStateToString(const NetworkMan
     return QString(metaEnum.valueToKey(state)).remove("NetworkManagerConnectivityState");
 }
 
-void NetworkManager::setVersion(const QString &version)
+void NetworkManager::setAvailable(bool available)
 {
-    qCDebug(dcNetworkManager()) << "Version:" << version;
+    if (m_available == available)
-    m_version = version;
+        return;
-    emit versionChanged();
+
+    qCDebug(dcNetworkManager()) << "Service is now" << (available ? "available" : "unavailable");
+    m_available = available;
+    emit availableChanged(m_available);
 }
 
-void NetworkManager::setWirelessEnabled(const bool &enabled)
+void NetworkManager::setVersion(const QString &version)
 {
+    if (m_version == version)
+        return;
+
+    qCDebug(dcNetworkManager()) << "Version:" << version;
+    m_version = version;
+    emit versionChanged(m_version);
+}
+
+void NetworkManager::setWirelessEnabled(bool enabled)
+{
+    if (m_wirelessEnabled == enabled)
+        return;
+
     qCDebug(dcNetworkManager()) << "Wireless networking" << (enabled ? "enabled" : "disabled");
     m_wirelessEnabled = enabled;
     emit wirelessEnabledChanged();
@@ -315,6 +317,9 @@ void NetworkManager::setWirelessEnabled(const bool &enabled)
 
 void NetworkManager::setConnectivityState(const NetworkManager::NetworkManagerConnectivityState &connectivityState)
 {
+    if (m_connectivityState == connectivityState)
+        return;
+
     qCDebug(dcNetworkManager()) << "Connectivity state changed:" << networkManagerConnectivityStateToString(connectivityState);
     m_connectivityState = connectivityState;
     emit connectivityStateChanged();
@@ -322,11 +327,26 @@ void NetworkManager::setConnectivityState(const NetworkManager::NetworkManagerCo
 
 void NetworkManager::setState(const NetworkManager::NetworkManagerState &state)
 {
+    if (m_state == state)
+        return;
+
     qCDebug(dcNetworkManager()) << "State changed:" << networkManagerStateToString(state);
     m_state = state;
     emit stateChanged();
 }
 
+void NetworkManager::onServiceRegistered()
+{
+    qCDebug(dcNetworkManager()) << "DBus service registered and available.";
+    // TODO: init stuff
+}
+
+void NetworkManager::onServiceUnregistered()
+{
+    qCWarning(dcNetworkManager()) << "DBus service unregistered.";
+    // TODO: deinit stuff
+}
+
 void NetworkManager::onDeviceAdded(const QDBusObjectPath &deviceObjectPath)
 {
     if (m_networkDevices.keys().contains(deviceObjectPath)) {
@@ -429,3 +449,86 @@ void NetworkManager::onWiredDeviceChanged()
     emit wiredDeviceChanged(networkDevice);
 }
 
+bool NetworkManager::start()
+{
+    // Get notification when network-manager appears/disappears on DBus
+    m_serviceWatcher = new QDBusServiceWatcher(NetworkManagerUtils::networkManagerServiceString(), QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration | QDBusServiceWatcher::WatchForUnregistration, this);
+    connect(m_serviceWatcher, &QDBusServiceWatcher::serviceRegistered, this, &NetworkManager::onServiceRegistered);
+    connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &NetworkManager::onServiceUnregistered);
+
+    // Check DBus connection
+    if (!QDBusConnection::systemBus().isConnected()) {
+        qCWarning(dcNetworkManager()) << "System DBus not connected. NetworkManagre not available.";
+        m_serviceWatcher->deleteLater();
+        m_serviceWatcher = nullptr;
+        return false;
+    }
+
+    // Create interface
+    m_networkManagerInterface = new QDBusInterface(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), QDBusConnection::systemBus(), this);
+    if(!m_networkManagerInterface->isValid()) {
+        qCWarning(dcNetworkManager()) << "Invalid DBus network manager interface. NetworkManagre not available.";
+        m_serviceWatcher->deleteLater();
+        m_serviceWatcher = nullptr;
+
+        m_networkManagerInterface->deleteLater();
+        m_networkManagerInterface = nullptr;
+        return false;
+    }
+
+    // Init properties
+    setVersion(m_networkManagerInterface->property("Version").toString());
+    setState((NetworkManagerState)m_networkManagerInterface->property("State").toUInt());
+    setConnectivityState((NetworkManagerConnectivityState)m_networkManagerInterface->property("Connectivity").toUInt());
+    setNetworkingEnabled(m_networkManagerInterface->property("NetworkingEnabled").toBool());
+    setWirelessEnabled(m_networkManagerInterface->property("WirelessEnabled").toBool());
+
+    // Load network devices
+    loadDevices();
+
+    // Create settings
+    m_networkSettings = new NetworkSettings(this);
+
+    // Connect signals
+    QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "StateChanged", this, SLOT(onStateChanged(uint)));
+    QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "DeviceAdded", this, SLOT(onDeviceAdded(QDBusObjectPath)));
+    QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "DeviceRemoved", this, SLOT(onDeviceRemoved(QDBusObjectPath)));
+    QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "PropertiesChanged", this, SLOT(onPropertiesChanged(QVariantMap)));
+
+    setAvailable(true);
+    return true;
+}
+
+void NetworkManager::stop()
+{
+    foreach (NetworkDevice *device, m_networkDevices) {
+        onDeviceRemoved(device->objectPath());
+    }
+
+    m_wiredNetworkDevices.clear();
+    m_wirelessNetworkDevices.clear();
+
+    if (m_networkSettings) {
+        delete m_networkSettings;
+        m_networkSettings  = nullptr;
+    }
+
+    if (m_networkManagerInterface) {
+        delete m_networkManagerInterface;
+        m_networkManagerInterface  = nullptr;
+    }
+
+    if (m_serviceWatcher) {
+        delete m_serviceWatcher;
+        m_serviceWatcher = nullptr;
+    }
+
+    m_version = QString();
+    m_state = NetworkManagerStateUnknown;
+    m_connectivityState = NetworkManagerConnectivityStateUnknown;
+    m_networkingEnabled = false;
+    m_wirelessEnabled = false;
+
+    setAvailable(false);
+}
+

libnymea-networkmanager/networkmanager.h

@@ -23,16 +23,17 @@
 #define NETWORKMANAGER_H
 
 #include <QObject>
-#include <QDBusConnection>
-#include <QDBusInterface>
 #include <QDBusMessage>
 #include <QDBusContext>
 #include <QDBusArgument>
+#include <QDBusInterface>
+#include <QDBusConnection>
+#include <QDBusServiceWatcher>
 
-#include "networkmanagerutils.h"
-#include "wirednetworkdevice.h"
-#include "wirelessnetworkdevice.h"
 #include "networksettings.h"
+#include "wirednetworkdevice.h"
+#include "networkmanagerutils.h"
+#include "wirelessnetworkdevice.h"
 
 // Docs: https://developer.gnome.org/NetworkManager/unstable/spec.html
 
@@ -79,8 +80,8 @@ public:
     explicit NetworkManager(QObject *parent = 0);
     ~NetworkManager();
 
-    bool available();
+    bool available() const;
-    bool wirelessAvailable();
+    bool wirelessAvailable() const;
 
     QList<NetworkDevice *> networkDevices() const;
     QList<WirelessNetworkDevice *> wirelessNetworkDevices() const;
@@ -94,48 +95,54 @@ public:
     QString stateString() const;
     NetworkManagerConnectivityState connectivityState() const;
 
-    NetworkManagerError connectWifi(const QString &interface, const QString &ssid, const QString &password, const bool &hidden = false);
+    NetworkManagerError connectWifi(const QString &interface, const QString &ssid, const QString &password, bool hidden = false);
 
     // Networking
     bool networkingEnabled() const;
-    bool enableNetworking(const bool &enabled);
+    bool enableNetworking(bool enabled);
 
     // Wireless Networking
     bool wirelessEnabled() const;
-    bool enableWireless(const bool &enabled);
+    bool enableWireless(bool enabled);
+
+    // Status methods
+    bool isConnectedToLan() const;
+    bool isOnline() const;
 
 private:
-    QDBusInterface *m_networkManagerInterface;
+    QDBusServiceWatcher *m_serviceWatcher = nullptr;
+    QDBusInterface *m_networkManagerInterface  = nullptr;
+    NetworkSettings *m_networkSettings  = nullptr;
 
     QHash<QDBusObjectPath, NetworkDevice *> m_networkDevices;
     QHash<QDBusObjectPath, WirelessNetworkDevice *> m_wirelessNetworkDevices;
     QHash<QDBusObjectPath, WiredNetworkDevice *> m_wiredNetworkDevices;
 
-    NetworkSettings *m_networkSettings;
+    bool m_available = false;
-
-    bool m_available;
 
     QString m_version;
 
-    NetworkManagerState m_state;
+    NetworkManagerState m_state = NetworkManagerStateUnknown;
-    NetworkManagerConnectivityState m_connectivityState;
+    NetworkManagerConnectivityState m_connectivityState = NetworkManagerConnectivityStateUnknown;
-    bool m_networkingEnabled;
+    bool m_networkingEnabled = false;
-    bool m_wirelessEnabled;
+    bool m_wirelessEnabled = false;
 
     void loadDevices();
 
     static QString networkManagerStateToString(const NetworkManagerState &state);
     static QString networkManagerConnectivityStateToString(const NetworkManagerConnectivityState &state);
 
+    void setAvailable(bool available);
     void setVersion(const QString &version);
-    void setNetworkingEnabled(const bool &enabled);
+    void setNetworkingEnabled(bool enabled);
-    void setWirelessEnabled(const bool &enabled);
+    void setWirelessEnabled(bool enabled);
     void setConnectivityState(const NetworkManagerConnectivityState &connectivityState);
     void setState(const NetworkManagerState &state);
 
 signals:
-    void versionChanged();
+    void availableChanged(bool available);
-    void networkingEnabledChanged();
+    void versionChanged(const QString &version);
+    void networkingEnabledChanged(bool enabled);
     void wirelessEnabledChanged();
     void wirelessAvailableChanged();
     void stateChanged();
@@ -150,12 +157,20 @@ signals:
     void wiredDeviceChanged(WiredNetworkDevice *wiredDevice);
 
 private slots:
+    void onServiceRegistered();
+    void onServiceUnregistered();
+
     void onDeviceAdded(const QDBusObjectPath &deviceObjectPath);
     void onDeviceRemoved(const QDBusObjectPath &deviceObjectPath);
     void onPropertiesChanged(const QVariantMap &properties);
 
     void onWirelessDeviceChanged();
     void onWiredDeviceChanged();
+
+public slots:
+    bool start();
+    void stop();
+
 };
 
 #endif // NETWORKMANAGER_H

libnymea-networkmanager/networksettings.cpp

@@ -25,7 +25,8 @@
 #include <QDebug>
 
 /*! Constructs a new \l{NetworkSettings} object with the given \a parent. */
-NetworkSettings::NetworkSettings(QObject *parent) : QObject(parent)
+NetworkSettings::NetworkSettings(QObject *parent) :
+    QObject(parent)
 {
     m_settingsInterface = new QDBusInterface(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::settingsPathString(), NetworkManagerUtils::settingsInterfaceString(), QDBusConnection::systemBus(), this);
     if(!m_settingsInterface->isValid()) {
@@ -100,5 +101,6 @@ void NetworkSettings::connectionRemoved(const QDBusObjectPath &objectPath)
 void NetworkSettings::propertiesChanged(const QVariantMap &properties)
 {
     Q_UNUSED(properties);
+    // TODO: handle settings changes
     //qCDebug(dcNetworkManager()) << "Settins: properties changed" << properties;
 }

libnymea-networkmanager/networksettings.h

@@ -42,13 +42,11 @@ public:
     QList<NetworkConnection *> connections() const;
 
 private:
-    QDBusInterface *m_settingsInterface;
+    QDBusInterface *m_settingsInterface = nullptr;
     QHash<QDBusObjectPath, NetworkConnection *> m_connections;
 
     void loadConnections();
 
-signals:
-
 private slots:
     void connectionAdded(const QDBusObjectPath &objectPath);
     void connectionRemoved(const QDBusObjectPath &objectPath);

libnymea-networkmanager/wirednetworkdevice.h

@@ -38,11 +38,11 @@ public:
     bool pluggedIn() const;
 
 private:
-    QDBusInterface *m_wiredInterface;
+    QDBusInterface *m_wiredInterface = nullptr;
 
     QString m_macAddress;
-    int m_bitRate;
+    int m_bitRate = 0;
-    bool m_pluggedIn;
+    bool m_pluggedIn = false;
 
     void setMacAddress(const QString &macAddress);
     void setBitRate(const int &bitRate);

nymea-networkmanager.pro

@@ -1,5 +1,5 @@
 TEMPLATE=subdirs
 
-networkmanager.depends = libnymea-networkmanager
+nymea-networkmanager.depends = libnymea-networkmanager
 
 SUBDIRS += libnymea-networkmanager nymea-networkmanager

nymea-networkmanager/application.cpp

@@ -0,0 +1,81 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                                                                               *
+ * Copyright (C) 2018 Simon Stürz <simon.stuerz@guh.io>                          *
+ *                                                                               *
+ * This file is part of nymea-networkmanager.                                    *
+ *                                                                               *
+ * nymea-networkmanager is free software: you can redistribute it and/or         *
+ * modify it under the terms of the GNU General Public License as published by   *
+ * the Free Software Foundation, either version 3 of the License,                *
+ * or (at your option) any later version.                                        *
+ *                                                                               *
+ * nymea-networkmanager is distributed in the hope that it will be useful,       *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of                *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  *
+ * GNU General Public License for more details.                                  *
+ *                                                                               *
+ * You should have received a copy of the GNU General Public License along       *
+ * with nymea-networkmanager. If not, see <http://www.gnu.org/licenses/>.        *
+ *                                                                               *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include "application.h"
+#include "loggingcategories.h"
+#include "core.h"
+
+#include <signal.h>
+
+static bool s_aboutToShutdown = false;
+
+static void catchUnixSignals(const std::vector<int>& quitSignals, const std::vector<int>& ignoreSignals = std::vector<int>())
+{
+    auto handler = [](int sig) ->void {
+        switch (sig) {
+        case SIGQUIT:
+            qCDebug(dcApplication()) << "Cought SIGQUIT quit signal...";
+            break;
+        case SIGINT:
+            qCDebug(dcApplication()) << "Cought SIGINT quit signal...";
+            break;
+        case SIGTERM:
+            qCDebug(dcApplication()) << "Cought SIGTERM quit signal...";
+            break;
+        case SIGHUP:
+            qCDebug(dcApplication()) << "Cought SIGHUP quit signal...";
+            break;
+        case SIGSEGV: {
+            qCCritical(dcApplication()) << "Cought SIGSEGV signal. Segmentation fault!";
+            exit(EXIT_FAILURE);
+        }
+        default:
+            break;
+        }
+
+        if (s_aboutToShutdown) {
+            qCCritical(dcApplication()) << "Already shutting down.";
+            return;
+        }
+
+        qCDebug(dcApplication()) << "=====================================";
+        qCDebug(dcApplication()) << "Shutting down nymea-networkmanager";
+        qCDebug(dcApplication()) << "=====================================";
+        s_aboutToShutdown = true;
+
+        Core::instance()->destroy();
+        Application::quit();
+    };
+
+    // all these signals will be ignored.
+    for (int sig : ignoreSignals)
+        signal(sig, SIG_IGN);
+
+    for (int sig : quitSignals)
+        signal(sig, handler);
+
+}
+
+Application::Application(int &argc, char **argv) :
+    QCoreApplication(argc, argv)
+{
+    catchUnixSignals({SIGQUIT, SIGINT, SIGTERM, SIGHUP, SIGSEGV});
+}

nymea-networkmanager/application.h

@@ -0,0 +1,37 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                                                                               *
+ * Copyright (C) 2018 Simon Stürz <simon.stuerz@guh.io>                          *
+ *                                                                               *
+ * This file is part of nymea-networkmanager.                                    *
+ *                                                                               *
+ * nymea-networkmanager is free software: you can redistribute it and/or         *
+ * modify it under the terms of the GNU General Public License as published by   *
+ * the Free Software Foundation, either version 3 of the License,                *
+ * or (at your option) any later version.                                        *
+ *                                                                               *
+ * nymea-networkmanager is distributed in the hope that it will be useful,       *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of                *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  *
+ * GNU General Public License for more details.                                  *
+ *                                                                               *
+ * You should have received a copy of the GNU General Public License along       *
+ * with nymea-networkmanager. If not, see <http://www.gnu.org/licenses/>.        *
+ *                                                                               *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef APPLICATION_H
+#define APPLICATION_H
+
+#include <QObject>
+#include <QCoreApplication>
+
+
+class Application : public QCoreApplication
+{
+    Q_OBJECT
+public:
+    explicit Application(int &argc, char **argv);
+
+};
+
+#endif // APPLICATION_H

nymea-networkmanager/bluetooth/bluetoothserver.cpp

@@ -19,7 +19,6 @@
  *                                                                               *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-
 #include "bluetoothserver.h"
 #include "loggingcategories.h"
 #include "bluetoothuuids.h"
@@ -31,11 +30,7 @@ BluetoothServer::BluetoothServer(const QString &machineId, QObject *parent) :
     QObject(parent),
     m_machineId(machineId)
 {
-    m_advertisingTimer = new QTimer(this);
-    m_advertisingTimer->setInterval(60000);
-    m_advertisingTimer->setSingleShot(true);
 
-    connect(m_advertisingTimer, &QTimer::timeout, this, &BluetoothServer::onAdvertisingTimeout);
 }
 
 BluetoothServer::~BluetoothServer()
@@ -117,7 +112,7 @@ QLowEnergyServiceData BluetoothServer::genericAccessServiceData()
     // Device name 0x2a00
     QLowEnergyCharacteristicData nameCharData;
     nameCharData.setUuid(QBluetoothUuid::DeviceName);
-    nameCharData.setValue(QString("Loop-box").toUtf8());
+    nameCharData.setValue(QString("nymea-networkmanager").toUtf8());
     nameCharData.setProperties(QLowEnergyCharacteristic::Read);
     serviceData.addCharacteristic(nameCharData);
 
@@ -236,12 +231,10 @@ void BluetoothServer::onControllerStateChanged(const QLowEnergyController::Contr
     case QLowEnergyController::ConnectingState:
         qCDebug(dcBluetoothServer()) << "Controller state connecting...";
         setConnected(false);
-        m_advertisingTimer->stop();
         break;
     case QLowEnergyController::ConnectedState:
         qCDebug(dcBluetoothServer()) << "Controller state connected." << m_controller->remoteName() << m_controller->remoteAddress();
         setConnected(true);
-        m_advertisingTimer->stop();
         break;
     case QLowEnergyController::DiscoveringState:
         qCDebug(dcBluetoothServer()) << "Controller state discovering...";
@@ -261,12 +254,6 @@ void BluetoothServer::onControllerStateChanged(const QLowEnergyController::Contr
     }
 }
 
-void BluetoothServer::onAdvertisingTimeout()
-{
-    qCDebug(dcBluetoothServer()) << "Advertising timeout.";
-    stop();
-}
-
 void BluetoothServer::characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value)
 {
     qCDebug(dcBluetoothServer()) << "Service characteristic changed" << characteristic.uuid() << value;
@@ -325,7 +312,7 @@ void BluetoothServer::serviceError(const QLowEnergyService::ServiceError &error)
     qCWarning(dcBluetoothServer()) << "Service error:" << errorString;
 }
 
-void BluetoothServer::start()
+void BluetoothServer::start(WirelessNetworkDevice *wirelessDevice)
 {
     // Check if a user is connected
     if (connected()) {
@@ -334,27 +321,19 @@ void BluetoothServer::start()
     }
 
     if (running()) {
-        qCDebug(dcBluetoothServer()) << "Already running. Restart advertise timer." << Loopd::instance()->advertisingTimeout() << "[s].";
+        qCDebug(dcBluetoothServer()) << "Already running.";
         m_localDevice->setHostMode(QBluetoothLocalDevice::HostDiscoverable);
-        m_advertisingTimer->stop();
-        m_advertisingTimer->setSingleShot(true);
-        m_advertisingTimer->setInterval(Loopd::instance()->advertisingTimeout() * 1000);
-        m_advertisingTimer->start();
         return;
     }
 
     qCDebug(dcBluetoothServer()) << "-------------------------------------";
-    qCDebug(dcBluetoothServer()) << "Starting bluetooth server for" << Loopd::instance()->advertisingTimeout() << "[s].";
+    qCDebug(dcBluetoothServer()) << "Starting bluetooth server";
-    m_advertisingTimer->stop();
-    m_advertisingTimer->setSingleShot(true);
-    m_advertisingTimer->setInterval(Loopd::instance()->advertisingTimeout() * 1000);
     qCDebug(dcBluetoothServer()) << "-------------------------------------";
 
     // Local bluetooth device
     m_localDevice = new QBluetoothLocalDevice(this);
     if (!m_localDevice->isValid()) {
         qCCritical(dcBluetoothServer()) << "Local bluetooth device is not valid.";
-        m_advertisingTimer->stop();
         delete m_localDevice;
         m_localDevice = nullptr;
         return;
@@ -383,8 +362,7 @@ void BluetoothServer::start()
 
     // Create services
     m_networkService = new NetworkService(m_controller->addService(NetworkService::serviceData(), m_controller), m_controller);
-    m_wirelessService = new WirelessService(m_controller->addService(WirelessService::serviceData(), m_controller), m_controller);
+    m_wirelessService = new WirelessService(m_controller->addService(WirelessService::serviceData(), m_controller), wirelessDevice, m_controller);
-    m_systemService = new SystemService(m_controller->addService(SystemService::serviceData(), m_controller), m_controller);
 
     QLowEnergyAdvertisingData advertisingData;
     advertisingData.setDiscoverability(QLowEnergyAdvertisingData::DiscoverabilityGeneral);
@@ -392,17 +370,12 @@ void BluetoothServer::start()
     advertisingData.setLocalName("Loop-box");
     // TODO: set guh manufacturer SIG data
 
-
     // Note: start advertising in 100 ms interval, this makes the device better discoverable on certain phones
     QLowEnergyAdvertisingParameters advertisingParameters;
     advertisingParameters.setInterval(100,100);
 
     qCDebug(dcBluetoothServer()) << "Start advertising loopd" << m_localDevice->address().toString();
     m_controller->startAdvertising(advertisingParameters, advertisingData, advertisingData);
-
-    // Start the advertising timer
-    m_advertisingTimer->start();
-    setRunning(true);
 }
 
 void BluetoothServer::stop()
@@ -434,3 +407,27 @@ void BluetoothServer::stop()
     setRunning(false);
 }
 
+void BluetoothServer::onNetworkManagerAvailableChanged(bool available)
+{
+    if (m_networkService)
+        m_networkService->setNetworkManagerAvailable(available);
+}
+
+void BluetoothServer::onNetworkingEnabledChanged(bool enabled)
+{
+    if (m_networkService)
+        m_networkService->setNetworkingEnabled(enabled);
+}
+
+void BluetoothServer::onWirelessNetworkingEnabledChanged(bool enabled)
+{
+    if (m_networkService)
+        m_networkService->setNetworkingEnabled(enabled);
+}
+
+void BluetoothServer::onNetworkManagerStateChanged(const NetworkManager::NetworkManagerState &state)
+{
+    if (m_networkService)
+        m_networkService->setNetworkManagerState(state);
+}
+

nymea-networkmanager/bluetooth/bluetoothserver.h

@@ -64,9 +64,6 @@ private:
 
     NetworkService *m_networkService = nullptr;
     WirelessService *m_wirelessService = nullptr;
-    SystemService *m_systemService = nullptr;
-
-    QTimer *m_advertisingTimer = nullptr;
 
     bool m_running = false;
     bool m_connected = false;
@@ -94,8 +91,6 @@ private slots:
     void onDisconnected();
     void onControllerStateChanged(const QLowEnergyController::ControllerState &state);
 
-    void onAdvertisingTimeout();
-
     // Services
     void characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value);
     void characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &value);
@@ -105,9 +100,15 @@ private slots:
     void serviceError(const QLowEnergyService::ServiceError &error);
 
 public slots:
-    void start();
+    void start(WirelessNetworkDevice *wirelessDevice);
     void stop();
 
+    // Network manager
+    void onNetworkManagerAvailableChanged(bool available);
+    void onNetworkingEnabledChanged(bool enabled);
+    void onWirelessNetworkingEnabledChanged(bool enabled);
+    void onNetworkManagerStateChanged(const NetworkManager::NetworkManagerState &state);
+
 };
 
 #endif // BLUETOOTHSERVER_H

nymea-networkmanager/bluetooth/networkservice.cpp

@@ -19,8 +19,9 @@
  *                                                                               *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-
 #include "networkservice.h"
+
+#include "core.h"
 #include "bluetoothuuids.h"
 #include "loggingcategories.h"
 
@@ -39,11 +40,6 @@ NetworkService::NetworkService(QLowEnergyService *service, QObject *parent) :
     connect(m_service, SIGNAL(characteristicWritten(QLowEnergyCharacteristic, QByteArray)), this, SLOT(characteristicWritten(QLowEnergyCharacteristic, QByteArray)));
     connect(m_service, SIGNAL(descriptorWritten(QLowEnergyDescriptor, QByteArray)), this, SLOT(descriptorWritten(QLowEnergyDescriptor, QByteArray)));
     connect(m_service, SIGNAL(error(QLowEnergyService::ServiceError)), this, SLOT(serviceError(QLowEnergyService::ServiceError)));
-
-    // NetworkManager
-    connect(Loopd::instance()->networkManager(), &NetworkManager::stateChanged, this, &NetworkService::onNetworkManagerStateChanged);
-    connect(Loopd::instance()->networkManager(), &NetworkManager::networkingEnabledChanged, this, &NetworkService::onNetworkingEnabledChanged);
-    connect(Loopd::instance()->networkManager(), &NetworkManager::wirelessEnabledChanged, this, &NetworkService::onWirelessEnabledChanged);
 }
 
 QLowEnergyService *NetworkService::service()
@@ -51,6 +47,77 @@ QLowEnergyService *NetworkService::service()
     return m_service;
 }
 
+void NetworkService::setNetworkManagerAvailable(bool available)
+{
+    m_networkManagerAvailable = available;
+}
+
+void NetworkService::setNetworkManagerState(const NetworkManager::NetworkManagerState &state)
+{
+    if (m_state == state)
+        return;
+
+    m_state = state;
+
+    if (!m_service) {
+        qCWarning(dcBluetoothServer()) << "NetworkService: Could not updatet network manager status. Service not valid";
+        return;
+    }
+
+    QLowEnergyCharacteristic characteristic = m_service->characteristic(networkStatusCharacteristicUuid);
+    if (!characteristic.isValid()) {
+        qCWarning(dcBluetoothServer()) << "NetworkService: Could not update network manager status. Characteristic not valid";
+        return;
+    }
+
+    qCDebug(dcBluetoothServer()) << "NetworkService: Notify state changed" << NetworkService::getNetworkManagerStateByteArray(m_state);
+    m_service->writeCharacteristic(characteristic, NetworkService::getNetworkManagerStateByteArray(m_state));
+}
+
+void NetworkService::setNetworkingEnabled(bool enabled)
+{
+    if (m_networkingEnabled == enabled)
+        return;
+
+    m_networkingEnabled = enabled;
+
+    if (!m_service) {
+        qCWarning(dcBluetoothServer()) << "NetworkService: Could not set networking enabled. Service not valid";
+        return;
+    }
+
+    QLowEnergyCharacteristic characteristic = m_service->characteristic(networkingEnabledCharacteristicUuid);
+    if (!characteristic.isValid()) {
+        qCWarning(dcBluetoothServer()) << "NetworkService: Could not set networking enabled. Characteristic not valid";
+        return;
+    }
+
+    qCDebug(dcBluetoothServer()) << "NetworkService: Notify networking enabled changed:" << (m_networkingEnabled ? "enabled" : "disabled");
+    m_service->writeCharacteristic(characteristic, m_networkingEnabled ? QByteArray::fromHex("01") : QByteArray::fromHex("00"));
+}
+
+void NetworkService::setWirelessNetworkingEnabled(bool enabled)
+{
+    if (m_wirelessNetworkingEnabled == enabled)
+        return;
+
+    m_wirelessNetworkingEnabled = enabled;
+
+    if (!m_service) {
+        qCWarning(dcBluetoothServer()) << "NetworkService: Could not set wireless enabled. Service not valid";
+        return;
+    }
+
+    QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessEnabledCharacteristicUuid);
+    if (!characteristic.isValid()) {
+        qCWarning(dcBluetoothServer()) << "NetworkService: Could not set wireless enabled. Characteristic not valid";
+        return;
+    }
+
+    qCDebug(dcBluetoothServer()) << "NetworkService: Notify wireless networking enabled changed:" << (m_wirelessNetworkingEnabled ? "enabled" : "disabled");
+    m_service->writeCharacteristic(characteristic, m_wirelessNetworkingEnabled ? QByteArray::fromHex("01") : QByteArray::fromHex("00"));
+}
+
 QLowEnergyServiceData NetworkService::serviceData()
 {
     QLowEnergyServiceData serviceData;
@@ -65,7 +132,7 @@ QLowEnergyServiceData NetworkService::serviceData()
     networkStatusData.setValue(QByteArray(1, 0));
     networkStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify);
     networkStatusData.addDescriptor(clientConfigDescriptorData);
-    networkStatusData.setValue(NetworkService::getNetworkManagerStateByteArray(Loopd::instance()->networkManager()->state()));
+    networkStatusData.setValue(NetworkService::getNetworkManagerStateByteArray(NetworkManager::NetworkManagerStateUnknown));
     serviceData.addCharacteristic(networkStatusData);
 
     // Network manager commander ef6d6612-b8af-49e0-9eca-ab343513641c
@@ -88,7 +155,7 @@ QLowEnergyServiceData NetworkService::serviceData()
     networkingEnabledStatusData.setUuid(networkingEnabledCharacteristicUuid);
     networkingEnabledStatusData.setValue(QByteArray(1, 0));
     networkingEnabledStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify);
-    networkingEnabledStatusData.setValue(QByteArray::number((int)Loopd::instance()->networkManager()->networkingEnabled()));
+    networkingEnabledStatusData.setValue(QByteArray::fromHex("00"));
     serviceData.addCharacteristic(networkingEnabledStatusData);
 
     // Wireless enabled ef6d6615-b8af-49e0-9eca-ab343513641c
@@ -96,7 +163,7 @@ QLowEnergyServiceData NetworkService::serviceData()
     wirelessEnabledStatusData.setUuid(wirelessEnabledCharacteristicUuid);
     wirelessEnabledStatusData.setValue(QByteArray(1, 0));
     wirelessEnabledStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify);
-    wirelessEnabledStatusData.setValue(QByteArray::number((int)Loopd::instance()->networkManager()->wirelessEnabled()));
+    wirelessEnabledStatusData.setValue(QByteArray::fromHex("00"));
     serviceData.addCharacteristic(wirelessEnabledStatusData);
 
     return serviceData;
@@ -201,7 +268,7 @@ void NetworkService::characteristicChanged(const QLowEnergyCharacteristic &chara
             return;
         }
 
-        if (!Loopd::instance()->networkManager()->available()) {
+        if (!m_networkManagerAvailable) {
             qCWarning(dcBluetoothServer()) << "NetworkService: Networkmanager not available";
             sendResponse(NetworkServiceResponseNetworkManagerNotAvailable);
             return;
@@ -274,19 +341,19 @@ void NetworkService::processCommand(const NetworkServiceCommand &command)
     switch (command) {
     case NetworkServiceCommandEnableNetworking:
         qCDebug(dcBluetoothServer()) << "NetworkService: received \"Enable networking\" command";
-        Loopd::instance()->networkManager()->enableNetworking(true);
+        Core::instance()->networkManager()->enableNetworking(true);
         break;
     case NetworkServiceCommandDisableNetworking:
         qCDebug(dcBluetoothServer()) << "NetworkService: received \"Disable networking\" command";
-        Loopd::instance()->networkManager()->enableNetworking(false);
+        Core::instance()->networkManager()->enableNetworking(false);
         break;
     case NetworkServiceCommandEnableWireless:
         qCDebug(dcBluetoothServer()) << "NetworkService: received \"Enable wireless networking\" command";
-        Loopd::instance()->networkManager()->enableWireless(true);
+        Core::instance()->networkManager()->enableWireless(true);
         break;
     case NetworkServiceCommandDisableWireless:
         qCDebug(dcBluetoothServer()) << "NetworkService: received \"Disable wireless networking\" command";
-        Loopd::instance()->networkManager()->enableWireless(false);
+        Core::instance()->networkManager()->enableWireless(false);
         break;
     default:
         qCWarning(dcBluetoothServer()) << "NetworkService: Unhandled command" << command;
@@ -294,57 +361,3 @@ void NetworkService::processCommand(const NetworkServiceCommand &command)
         break;
     }
 }
-
-bool NetworkService::onNetworkManagerStateChanged()
-{
-    if (!m_service) {
-        qCWarning(dcBluetoothServer()) << "NetworkService: Could not updatet network manager status. Service not valid";
-        return false;
-    }
-
-    QLowEnergyCharacteristic characteristic = m_service->characteristic(networkStatusCharacteristicUuid);
-    if (!characteristic.isValid()) {
-        qCWarning(dcBluetoothServer()) << "NetworkService: Could not update network manager status. Characteristic not valid";
-        return false;
-    }
-
-    qCDebug(dcBluetoothServer()) << "NetworkService: Notify state changed" << NetworkService::getNetworkManagerStateByteArray(Loopd::instance()->networkManager()->state());
-    m_service->writeCharacteristic(characteristic, NetworkService::getNetworkManagerStateByteArray(Loopd::instance()->networkManager()->state()));
-    return true;
-}
-
-bool NetworkService::onNetworkingEnabledChanged()
-{
-    if (!m_service) {
-        qCWarning(dcBluetoothServer()) << "NetworkService: Could not set networking enabled. Service not valid";
-        return false;
-    }
-
-    QLowEnergyCharacteristic characteristic = m_service->characteristic(networkingEnabledCharacteristicUuid);
-    if (!characteristic.isValid()) {
-        qCWarning(dcBluetoothServer()) << "NetworkService: Could not set networking enabled. Characteristic not valid";
-        return false;
-    }
-
-    qCDebug(dcBluetoothServer()) << "NetworkService: Notify networking enabled changed:" << (Loopd::instance()->networkManager()->networkingEnabled() ? "enabled" : "disabled");
-    m_service->writeCharacteristic(characteristic, Loopd::instance()->networkManager()->networkingEnabled() ? QByteArray::fromHex("01") : QByteArray::fromHex("00"));
-    return true;
-}
-
-bool NetworkService::onWirelessEnabledChanged()
-{
-    if (!m_service) {
-        qCWarning(dcBluetoothServer()) << "NetworkService: Could not set wireless enabled. Service not valid";
-        return false;
-    }
-
-    QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessEnabledCharacteristicUuid);
-    if (!characteristic.isValid()) {
-        qCWarning(dcBluetoothServer()) << "NetworkService: Could not set wireless enabled. Characteristic not valid";
-        return false;
-    }
-
-    qCDebug(dcBluetoothServer()) << "NetworkService: Notify wireless networking enabled changed:" << (Loopd::instance()->networkManager()->wirelessEnabled() ? "enabled" : "disabled");
-    m_service->writeCharacteristic(characteristic, Loopd::instance()->networkManager()->wirelessEnabled() ? QByteArray::fromHex("01") : QByteArray::fromHex("00"));
-    return true;
-}

nymea-networkmanager/bluetooth/networkservice.h

@@ -57,13 +57,23 @@ public:
 
     QLowEnergyService *service();
 
+    void setNetworkManagerAvailable(bool available);
+    void setNetworkManagerState(const NetworkManager::NetworkManagerState &state);
+    void setNetworkingEnabled(bool enabled);
+    void setWirelessNetworkingEnabled(bool enabled);
+
     static QLowEnergyServiceData serviceData();
     static QByteArray getNetworkManagerStateByteArray(const NetworkManager::NetworkManagerState &state);
 
 private:
-    QLowEnergyService *m_service;
+    QLowEnergyService *m_service = nullptr;
-    void sendResponse(const NetworkServiceResponse &response);
 
+    bool m_networkManagerAvailable = false;
+    NetworkManager::NetworkManagerState m_state = NetworkManager::NetworkManagerStateUnknown;
+    bool m_networkingEnabled = false;
+    bool m_wirelessNetworkingEnabled = false;
+
+    void sendResponse(const NetworkServiceResponse &response);
     NetworkServiceCommand verifyCommand(const QByteArray &commandData);
 
 private slots:
@@ -78,11 +88,6 @@ private slots:
     // Commands
     void processCommand(const NetworkServiceCommand &command);
 
-public slots:
-    bool onNetworkManagerStateChanged();
-    bool onNetworkingEnabledChanged();
-    bool onWirelessEnabledChanged();
-
 };
 
 #endif // NETWORKSERVICE_H

nymea-networkmanager/bluetooth/systemservice.h

@@ -39,7 +39,6 @@ private:
     void streamData(const QVariantMap &responseMap);
     QVariantMap createResponse(const SystemServiceCommand &command, const SystemServiceResponse &responseCode = SystemServiceResponseSuccess);
 
-
 private slots:
     // Service
     void characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value);

nymea-networkmanager/bluetooth/wirelessservice.cpp

@@ -20,6 +20,8 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include "wirelessservice.h"
+
+#include "core.h"
 #include "bluetoothuuids.h"
 #include "loggingcategories.h"
 
@@ -28,10 +30,10 @@
 #include <QLowEnergyDescriptorData>
 #include <QLowEnergyCharacteristicData>
 
-WirelessService::WirelessService(QLowEnergyService *service, QObject *parent) :
+WirelessService::WirelessService(QLowEnergyService *service, WirelessNetworkDevice *wirelessDevice, QObject *parent) :
     QObject(parent),
     m_service(service),
-    m_device(nullptr),
+    m_device(wirelessDevice),
     m_readingInputData(false)
 {    
     qCDebug(dcBluetoothServer()) << "Create WirelessService.";
@@ -43,14 +45,8 @@ WirelessService::WirelessService(QLowEnergyService *service, QObject *parent) :
     connect(m_service, SIGNAL(descriptorWritten(QLowEnergyDescriptor, QByteArray)), this, SLOT(descriptorWritten(QLowEnergyDescriptor, QByteArray)));
     connect(m_service, SIGNAL(error(QLowEnergyService::ServiceError)), this, SLOT(serviceError(QLowEnergyService::ServiceError)));
 
-    // Get the wireless network device if there is any
-    if (!Loopd::instance()->networkManager()->wirelessAvailable()) {
-        qCWarning(dcBluetoothServer()) << "WirelessService: There is no wireless network device available";
-        return;
-    }
 
-    qCDebug(dcBluetoothServer()) << "WirelessService: Using" << Loopd::instance()->networkManager()->wirelessNetworkDevices().first();
+    qCDebug(dcBluetoothServer()) << "WirelessService: Using" << m_device;
-    m_device = Loopd::instance()->networkManager()->wirelessNetworkDevices().first();
     connect(m_device, &WirelessNetworkDevice::bitRateChanged, this, &WirelessService::onWirelessDeviceBitRateChanged);
     connect(m_device, &WirelessNetworkDevice::stateChanged, this, &WirelessService::onWirelessDeviceStateChanged);
 }
@@ -89,11 +85,7 @@ QLowEnergyServiceData WirelessService::serviceData()
     wirelessStatusCharacteristicData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify);
     wirelessStatusCharacteristicData.addDescriptor(clientConfigDescriptorData);
     wirelessStatusCharacteristicData.setValueLength(1, 1);
-    if (!Loopd::instance()->networkManager()->wirelessAvailable()) {
+    wirelessStatusCharacteristicData.setValue(WirelessService::getWirelessNetworkDeviceState(NetworkDevice::NetworkDeviceStateUnknown));
-        wirelessStatusCharacteristicData.setValue(WirelessService::getWirelessNetworkDeviceState(NetworkDevice::NetworkDeviceStateUnavailable));
-    } else {
-        wirelessStatusCharacteristicData.setValue(WirelessService::getWirelessNetworkDeviceState(Loopd::instance()->networkManager()->wirelessNetworkDevices().first()->deviceState()));
-    }
     serviceData.addCharacteristic(wirelessStatusCharacteristicData);
 
     return serviceData;
@@ -103,7 +95,7 @@ QLowEnergyServiceData WirelessService::serviceData()
 WirelessService::WirelessServiceResponse WirelessService::checkWirelessErrors()
 {
     // Check possible errors
-    if (!Loopd::instance()->networkManager()->available()) {
+    if (!Core::instance()->networkManager()->available()) {
         qCWarning(dcBluetoothServer()) << "WirelessService: The networkmanager is not available.";
         return WirelessServiceResponseNetworkManagerNotAvailable;
     }
@@ -113,12 +105,12 @@ WirelessService::WirelessServiceResponse WirelessService::checkWirelessErrors()
         return WirelessServiceResponseWirelessNotAvailable;
     }
 
-    if (!Loopd::instance()->networkManager()->networkingEnabled()) {
+    if (!Core::instance()->networkManager()->networkingEnabled()) {
         qCWarning(dcBluetoothServer()) << "WirelessService: Networking not enabled";
         return WirelessServiceResponseNetworkingNotEnabled;
     }
 
-    if (!Loopd::instance()->networkManager()->wirelessEnabled()) {
+    if (!Core::instance()->networkManager()->wirelessEnabled()) {
         qCWarning(dcBluetoothServer()) << "WirelessService: Wireless not enabled";
         return WirelessServiceResponseWirelessNotEnabled;
     }
@@ -253,7 +245,7 @@ void WirelessService::commandConnect(const QVariantMap &request)
         return;
     }
 
-    Loopd::instance()->networkManager()->connectWifi(m_device->interface(), parameters.value("e").toString(), parameters.value("p").toString());
+    Core::instance()->networkManager()->connectWifi(m_device->interface(), parameters.value("e").toString(), parameters.value("p").toString());
     streamData(createResponse(WirelessServiceCommandConnect));
 }
 

nymea-networkmanager/bluetooth/wirelessservice.h

@@ -61,16 +61,17 @@ public:
     };
     Q_ENUM(WirelessServiceResponse)
 
-    explicit WirelessService(QLowEnergyService *service, QObject *parent = 0);
+    explicit WirelessService(QLowEnergyService *service, WirelessNetworkDevice *wirelessDevice, QObject *parent = 0);
+
     QLowEnergyService *service();
 
     static QLowEnergyServiceData serviceData();
 
 private:
-    QLowEnergyService *m_service;
+    QLowEnergyService *m_service = nullptr;
-    WirelessNetworkDevice *m_device;
+    WirelessNetworkDevice *m_device = nullptr;
 
-    bool m_readingInputData;
+    bool m_readingInputData = false;
     QByteArray m_inputDataStream;
 
     WirelessServiceResponse checkWirelessErrors();

nymea-networkmanager/core.cpp

@@ -20,8 +20,9 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include "core.h"
+#include "loggingcategories.h"
 
-Core* Core::s_instance = 0;
+Core* Core::s_instance = nullptr;
 
 Core *Core::instance()
 {
@@ -32,17 +33,48 @@ Core *Core::instance()
 }
 
 void Core::destroy()
-{
+{    
     if (s_instance)
         delete s_instance;
-    s_instance = 0;
+
+    s_instance = nullptr;
+}
+
+NetworkManager *Core::networkManager() const
+{
+    return m_networkManager;
 }
 
 Core::Core(QObject *parent) :
     QObject(parent)
 {
     m_networkManager = new NetworkManager(this);
+    connect(m_networkManager, &NetworkManager::availableChanged, this, &Core::onNetworkManagerAvailableChanged);
 
+    m_bluetoothServer = new BluetoothServer("nymea", this);
 
+    m_nymeaService = new NymeadService(false, this);
 
+    if (!m_networkManager->start()) {
+        qCWarning(dcApplication()) << "Could not start network manager.";
+    }
+}
+
+Core::~Core()
+{
+    delete m_networkManager;
+    m_networkManager = nullptr;
+
+    delete m_bluetoothServer;
+    m_bluetoothServer = nullptr;
+}
+
+void Core::onNetworkManagerAvailableChanged(const bool &available)
+{
+    if (!available) {
+        qCWarning(dcApplication()) << "Networkmanager is not available any more.";
+    } else {
+        qCDebug(dcApplication()) << "Networkmanager is now available.";
+
+    }
 }

nymea-networkmanager/core.h

@@ -25,6 +25,8 @@
 #include <QObject>
 
 #include "networkmanager.h"
+#include "nymeadservice.h"
+#include "bluetooth/bluetoothserver.h"
 
 class Core : public QObject
 {
@@ -33,17 +35,20 @@ public:
     static Core* instance();
     void destroy();
 
+    NetworkManager *networkManager() const;
 
 private:
     explicit Core(QObject *parent = nullptr);
+    ~Core();
+
     static Core *s_instance;
 
     NetworkManager *m_networkManager = nullptr;
+    BluetoothServer *m_bluetoothServer = nullptr;
+    NymeadService *m_nymeaService = nullptr;
 
-signals:
+private slots:
-
+    void onNetworkManagerAvailableChanged(const bool &available);
-public slots:
-
 
 };
 

nymea-networkmanager/loggingcategories.cpp

@@ -21,5 +21,6 @@
 
 #include "loggingcategories.h"
 
+Q_LOGGING_CATEGORY(dcApplication, "Application")
 Q_LOGGING_CATEGORY(dcBluetoothServer, "BluetoothServer")
 Q_LOGGING_CATEGORY(dcNymeaService, "NymeaService")

nymea-networkmanager/loggingcategories.h

@@ -25,6 +25,7 @@
 #include <QDebug>
 #include <QLoggingCategory>
 
+Q_DECLARE_LOGGING_CATEGORY(dcApplication)
 Q_DECLARE_LOGGING_CATEGORY(dcBluetoothServer)
 Q_DECLARE_LOGGING_CATEGORY(dcNymeaService)
 

nymea-networkmanager/main.cpp

@@ -20,11 +20,12 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <QCoreApplication>
-#include <QLoggingCategory>
 #include <QCommandLineParser>
 #include <QCommandLineOption>
 
 #include "core.h"
+#include "application.h"
+#include "loggingcategories.h"
 
 static const char *const normal = "\033[0m";
 static const char *const warning = "\e[33m";
@@ -72,24 +73,38 @@ static void consoleLogHandler(QtMsgType type, const QMessageLogContext& context,
 }
 
 
-
 int main(int argc, char *argv[])
 {
     qInstallMessageHandler(consoleLogHandler);
 
-    QCoreApplication application(argc, argv);
+    Application application(argc, argv);
-    application.setApplicationName("loopd");
+    application.setApplicationName("nymea-networkmanager");
-    application.setOrganizationName("guh");
+    application.setOrganizationName("nymea");
     application.setApplicationVersion("0.0.1");
 
     // Command line parser
     QCommandLineParser parser;
     parser.addHelpOption();
     parser.addVersionOption();
-    parser.setApplicationDescription(QString("\nThis daemon allows to configure a wifi network with a bluetooth low energy connection.\n\nCopyright %1 2018 Simon Stürz <simon.stuerz@guh.io>").arg(QChar(0xA9)));
+    parser.setApplicationDescription(QString("\nThis daemon allows to configure a wifi network using a bluetooth low energy connection.\n\nCopyright %1 2018 Simon Stürz <simon.stuerz@guh.io>").arg(QChar(0xA9)));
+
+    // TODO: set options
 
     parser.process(application);
 
+    // Enable debug categories
+    s_loggingFilters.insert("Application", true);
+    s_loggingFilters.insert("BluetoothServer", true);
+    s_loggingFilters.insert("NetworkManager", true);
+    s_loggingFilters.insert("NymeaService", true);
+
+    QLoggingCategory::installFilter(loggingCategoryFilter);
+
+    qCDebug(dcApplication()) << "=====================================";
+    qCDebug(dcApplication()) << "Starting nymea-networkmanager" << application.applicationVersion();
+    qCDebug(dcApplication()) << "=====================================";
+
+    // Start core
     Core::instance();
 
     return application.exec();

nymea-networkmanager/nymea-networkmanager.pro

@@ -11,23 +11,29 @@ CONFIG -= app_bundle
 TEMPLATE = app
 
 INCLUDEPATH += $$top_srcdir/libnymea-networkmanager/
-LIBS += -L$$top_builddir/libnymea-networkmanager/ -lnymea-networkmanager1
+LIBS += -L$$top_builddir/libnymea-networkmanager/ -lnymea-networkmanager
 
 HEADERS += \
+    application.h \
     core.h \
+    loggingcategories.h \
+    nymeadservice.h \
+    pushbuttonagent.h \
     bluetooth/bluetoothserver.h \
     bluetooth/networkservice.h \
     bluetooth/bluetoothuuids.h \
     bluetooth/wirelessservice.h \
-    bluetooth/loggingcategories.h
 
 SOURCES += \
     main.cpp \
+    application.cpp \
     core.cpp \
+    loggingcategories.cpp \
+    nymeadservice.cpp \
+    pushbuttonagent.cpp \
     bluetooth/bluetoothserver.cpp \
     bluetooth/networkservice.cpp \
     bluetooth/wirelessservice.cpp \
-    bluetooth/loggingcategories.cpp
 
 target.path = /usr/bin
 INSTALLS += target

nymea-networkmanager/nymeadservice.cpp

@@ -0,0 +1,121 @@
+#include "nymeadservice.h"
+#include "loggingcategories.h"
+
+NymeadService::NymeadService(bool pushbuttonEnabled, QObject *parent) :
+    QObject(parent),
+    m_pushbuttonEnabled(pushbuttonEnabled)
+{
+    // Check DBus connection
+    if (!QDBusConnection::systemBus().isConnected()) {
+        qCWarning(dcNymeaService()) << "System DBus not connected.";
+        return;
+    }
+
+    // Get notification when nymead appears/disappears on DBus
+    m_serviceWatcher = new QDBusServiceWatcher("io.guh.nymead", QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration | QDBusServiceWatcher::WatchForUnregistration, this);
+    connect(m_serviceWatcher, &QDBusServiceWatcher::serviceRegistered, this, &NymeadService::serviceRegistered);
+    connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &NymeadService::serviceUnregistered);
+
+    if (init()) {
+        qCDebug(dcNymeaService()) << "Initialized nymea D-Bus services successfully";
+    } else {
+        qCWarning(dcNymeaService()) << "Could not init nymea D-Bus services";
+        setAvailable(false);
+    }
+}
+
+bool NymeadService::available() const
+{
+    return m_available;
+}
+
+void NymeadService::enableBluetooth(const bool &enable)
+{
+    if (!m_nymeadHardwareInterface) {
+        qCCritical(dcNymeaService()) << "Could not enable/disable bluetooth hardware resource. D-Bus interface not available.";
+        return;
+    }
+
+    qCDebug(dcNymeaService()) << "Request nymea to" << (enable ? "enable" : "disable") << "bluetooth resources";
+
+    QDBusMessage query = m_nymeadHardwareInterface->call("EnableBluetooth", enable);
+    if(query.type() != QDBusMessage::ReplyMessage) {
+        qCWarning(dcNymeaService()) << "Could not enable/disable bluetooth on dbus:" << query.errorName() << query.errorMessage();
+        return;
+    }
+}
+
+void NymeadService::pushButtonPressed()
+{
+    if (!m_pushButtonAgent) {
+        qCCritical(dcNymeaService()) << "Could not press pushbutton. Pushbutton agent not available.";
+        return;
+    }
+
+    qCDebug(dcNymeaService()) << "Pushbutton pressed. Send to nymead";
+    m_pushButtonAgent->sendButtonPressed();
+}
+
+void NymeadService::setAvailable(const bool &available)
+{
+    if (m_available == available)
+        return;
+
+    if (available) {
+        qCDebug(dcNymeaService())  << "Service is now available.";
+    } else {
+        qCWarning(dcNymeaService())  << "Service is not available any more.";
+    }
+
+    m_available = available;
+    emit availableChanged(m_available);
+}
+
+bool NymeadService::init()
+{
+    if (m_pushbuttonEnabled) {
+        m_pushButtonAgent = new PushButtonAgent(this);
+        if (!m_pushButtonAgent->init()) {
+            qCWarning(dcNymeaService()) << "Could not init D-Bus push button agent.";
+            m_pushButtonAgent->deleteLater();
+            m_pushButtonAgent = nullptr;
+            return false;
+        }
+    }
+
+    m_nymeadHardwareInterface = new QDBusInterface("io.guh.nymead", "/io/guh/nymead/HardwareManager", "io.guh.nymead", QDBusConnection::systemBus(), this);
+    if (!m_nymeadHardwareInterface->isValid()) {
+        qCWarning(dcNymeaService()) << "Invalid D-Bus HardwareManager interface.";
+        m_nymeadHardwareInterface->deleteLater();
+        m_nymeadHardwareInterface = nullptr;
+        return false;
+    }
+
+    setAvailable(true);
+    return true;
+}
+
+void NymeadService::serviceRegistered(const QString &serviceName)
+{
+    qCDebug(dcNymeaService()) << "Service registered" << serviceName;
+    if (!m_available) {
+        init();
+    }
+}
+
+void NymeadService::serviceUnregistered(const QString &serviceName)
+{
+    qCDebug(dcNymeaService()) << "Service unregistered" << serviceName;
+
+    if (m_pushButtonAgent) {
+        m_pushButtonAgent->deleteLater();
+        m_pushButtonAgent = nullptr;
+    }
+
+    if (m_nymeadHardwareInterface) {
+        m_nymeadHardwareInterface->deleteLater();
+        m_nymeadHardwareInterface = nullptr;
+    }
+
+    setAvailable(false);
+}

nymea-networkmanager/nymeadservice.h

@@ -0,0 +1,43 @@
+#ifndef NYMEADSERVICE_H
+#define NYMEADSERVICE_H
+
+#include <QObject>
+#include <QDBusInterface>
+#include <QDBusConnection>
+#include <QDBusServiceWatcher>
+
+#include "pushbuttonagent.h"
+
+class NymeadService : public QObject
+{
+    Q_OBJECT
+public:
+    explicit NymeadService(bool pushbuttonEnabled, QObject *parent = nullptr);
+
+    bool available() const;
+
+    void enableBluetooth(const bool &enable);
+    void pushButtonPressed();
+
+private:
+    QDBusServiceWatcher *m_serviceWatcher = nullptr;
+    PushButtonAgent *m_pushButtonAgent = nullptr;
+    QDBusInterface *m_nymeadHardwareInterface = nullptr;
+
+    bool m_pushbuttonEnabled = false;
+    bool m_available = false;
+
+    void setAvailable(const bool &available);
+
+    bool init();
+
+signals:
+    void availableChanged(const bool &available);
+
+private slots:
+    void serviceRegistered(const QString &serviceName);
+    void serviceUnregistered(const QString &serviceName);
+
+};
+
+#endif // NYMEADSERVICE_H

nymea-networkmanager/pushbuttonagent.cpp

@@ -0,0 +1,38 @@
+#include "pushbuttonagent.h"
+#include "loggingcategories.h"
+
+#include <QDBusMessage>
+#include <QDBusObjectPath>
+
+PushButtonAgent::PushButtonAgent(QObject *parent) :
+    QObject(parent)
+{
+
+}
+
+bool PushButtonAgent::init(QDBusConnection::BusType busType)
+{
+    QDBusConnection bus = busType == QDBusConnection::SessionBus ? QDBusConnection::sessionBus() : QDBusConnection::systemBus();
+
+    bool result = bus.registerObject("/io/guh/loopd/pushbutton", this, QDBusConnection::ExportScriptableContents);
+    if (!result) {
+        qCWarning(dcNymeaService()) << "PushButtonAgent: Error registering PushButton agent on D-Bus.";
+        return false;
+    }
+
+    QDBusMessage message = QDBusMessage::createMethodCall("io.guh.nymead", "/io/guh/nymead/UserManager", QString(), "RegisterButtonAgent");
+    message << qVariantFromValue(QDBusObjectPath("/io/guh/loopd/pushbutton"));
+    QDBusMessage reply = bus.call(message);
+    if (!reply.errorName().isEmpty()) {
+        qCWarning(dcNymeaService()) << "PushButtonAgent: Error registering PushButton agent:" << reply.errorMessage();
+        return false;
+    }
+    qCDebug(dcNymeaService()) << "PushButton agent registered.";
+    return true;
+}
+
+void PushButtonAgent::sendButtonPressed()
+{
+    qCDebug(dcNymeaService()) << "PushButtonAgent: Sending button pressed event.";
+    emit PushButtonPressed();
+}

nymea-networkmanager/pushbuttonagent.h

@@ -0,0 +1,23 @@
+#ifndef PUSHBUTTONAGENT_H
+#define PUSHBUTTONAGENT_H
+
+#include <QObject>
+#include <QDBusConnection>
+
+class PushButtonAgent : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PushButtonAgent(QObject *parent = nullptr);
+
+    bool init(QDBusConnection::BusType busType = QDBusConnection::SystemBus);
+
+signals:
+    Q_SCRIPTABLE void PushButtonPressed();
+
+public slots:
+    void sendButtonPressed();
+
+};
+
+#endif // PUSHBUTTONAGENT_H