Update to the latest nymea-networkmanager status

libnymea-networkmanager/networkconnection.cpp

@@ -30,8 +30,6 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject
     QObject(parent),
     m_objectPath(objectPath)
 {
-    qDBusRegisterMetaType<ConnectionSettings>();
-
     m_connectionInterface = new QDBusInterface(NetworkManagerUtils::networkManagerServiceString(), m_objectPath.path(), NetworkManagerUtils::connectionsInterfaceString(), QDBusConnection::systemBus(), this);
     if(!m_connectionInterface->isValid()) {
         qCWarning(dcNetworkManager()) << "Invalid connection dbus interface";
@@ -49,6 +47,10 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject
 
     const QDBusArgument &argument = query.arguments().at(0).value<QDBusArgument>();
     m_connectionSettings = qdbus_cast<ConnectionSettings>(argument);
+
+//    foreach (const QVariant &connectionVariant, m_connectionSettings.values()) {
+//        qCDebug(dcNetworkManager()) << connectionVariant;
+//    }
 }
 
 /*! Delete this \l{NetworkConnection} in the \l{NetworkManager}. */
@@ -60,6 +62,12 @@ void NetworkConnection::deleteConnection()
 
 }
 
+void NetworkConnection::registerTypes()
+{
+    qRegisterMetaType<ConnectionSettings>("ConnectionSettings");
+    qDBusRegisterMetaType<ConnectionSettings>();
+}
+
 /*! Returns the dbus object path of this \l{NetworkConnection}. */
 QDBusObjectPath NetworkConnection::objectPath() const
 {

libnymea-networkmanager/networkconnection.h

@@ -38,10 +38,12 @@ class NetworkConnection : public QObject
 {
     Q_OBJECT
 public:
-    explicit NetworkConnection(const QDBusObjectPath &objectPath, QObject *parent = 0);
+    explicit NetworkConnection(const QDBusObjectPath &objectPath, QObject *parent = nullptr);
 
     void deleteConnection();
 
+    static void registerTypes();
+
     QDBusObjectPath objectPath() const;
     ConnectionSettings connectionSettings() const;
 
@@ -60,6 +62,7 @@ private:
     ConnectionSettings m_connectionSettings;
 };
 
+Q_DECLARE_METATYPE(ConnectionSettings)
 QDebug operator<<(QDebug debug, NetworkConnection *networkConnection);
 
 #endif // NETWORKCONNECTION_H

libnymea-networkmanager/networkdevice.h

@@ -147,7 +147,7 @@ public:
     };
     Q_ENUM(NetworkDeviceType)
 
-    explicit NetworkDevice(const QDBusObjectPath &objectPath, QObject *parent = 0);
+    explicit NetworkDevice(const QDBusObjectPath &objectPath, QObject *parent = nullptr);
 
     QDBusObjectPath objectPath() const;
 

libnymea-networkmanager/networkmanager.cpp

@@ -30,7 +30,12 @@
 NetworkManager::NetworkManager(QObject *parent) :
     QObject(parent)
 {
+    NetworkConnection::registerTypes();
 
+    // 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);
 }
 
 NetworkManager::~NetworkManager()
@@ -67,7 +72,13 @@ QList<WiredNetworkDevice *> NetworkManager::wiredNetworkDevices() const
     return m_wiredNetworkDevices.values();
 }
 
-/*! Returns the \l{NetworkDevice} with the given \a interface from this \l{NetworkManager}. If there is no such \a interface returns Q_NULLPTR. */
+/*! Returns the \l{NetworkSettings} from this \l{NetworkManager}. */
+NetworkSettings *NetworkManager::networkSettings() const
+{
+    return m_networkSettings;
+}
+
+/*! Returns the \l{NetworkDevice} with the given \a interface from this \l{NetworkManager}. If there is no such \a interface returns nullptr. */
 NetworkDevice *NetworkManager::getNetworkDevice(const QString &interface)
 {
     foreach (NetworkDevice *device, m_networkDevices.values()) {
@@ -109,10 +120,11 @@ NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &i
         return NetworkManagerErrorNetworkInterfaceNotFound;
 
     // Get wirelessNetworkDevice
-    WirelessNetworkDevice *wirelessNetworkDevice = 0;
+    WirelessNetworkDevice *wirelessNetworkDevice = nullptr;
     foreach (WirelessNetworkDevice *networkDevice, wirelessNetworkDevices()) {
-        if (networkDevice->interface() == interface)
+        if (networkDevice->interface() == interface) {
             wirelessNetworkDevice = networkDevice;
+        }
     }
 
     if (!wirelessNetworkDevice)
@@ -125,6 +137,7 @@ NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &i
 
     // Note: https://developer.gnome.org/NetworkManager/stable/ref-settings.html
 
+    // Create network settings for this wifi
     QVariantMap connectionSettings;
     connectionSettings.insert("autoconnect", true);
     connectionSettings.insert("id", ssid);
@@ -174,7 +187,92 @@ NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &i
 
     // Activate connection
     QDBusMessage query = m_networkManagerInterface->call("ActivateConnection", QVariant::fromValue(connectionObjectPath), QVariant::fromValue(wirelessNetworkDevice->objectPath()), QVariant::fromValue(accessPoint->objectPath()));
-    if(query.type() != QDBusMessage::ReplyMessage) {
+    if (query.type() != QDBusMessage::ReplyMessage) {
+        qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
+        return NetworkManagerErrorWirelessConnectionFailed;
+    }
+
+    return NetworkManagerErrorNoError;
+}
+
+NetworkManager::NetworkManagerError NetworkManager::startAccessPoint(const QString &interface, const QString &ssid, const QString &password)
+{
+    qCDebug(dcNetworkManager()) << "Start an access point for" << interface << "SSID:" <<  ssid << "password:" << password;
+
+    // Check interface
+    if (!getNetworkDevice(interface))
+        return NetworkManagerErrorNetworkInterfaceNotFound;
+
+    // Get wirelessNetworkDevice
+    WirelessNetworkDevice *wirelessNetworkDevice = nullptr;
+    foreach (WirelessNetworkDevice *networkDevice, wirelessNetworkDevices()) {
+        if (networkDevice->interface() == interface) {
+            wirelessNetworkDevice = networkDevice;
+        }
+    }
+
+    if (!wirelessNetworkDevice)
+        return NetworkManagerErrorInvalidNetworkDeviceType;
+
+
+    // Note: https://developer.gnome.org/NetworkManager/stable/ref-settings.html
+
+    // Create network settings for access point
+    QVariantMap connectionSettings;
+    connectionSettings.insert("id", ssid);
+    connectionSettings.insert("autoconnect", false);
+    connectionSettings.insert("uuid", QUuid::createUuid().toString().remove("{").remove("}"));
+    connectionSettings.insert("type", "802-11-wireless");
+
+    QVariantMap wirelessSettings;
+    wirelessSettings.insert("band", "bg");
+    wirelessSettings.insert("mode", "ap");
+    wirelessSettings.insert("ssid", ssid.toUtf8());
+    wirelessSettings.insert("security", "802-11-wireless-security");
+    // Note: disable power save mode
+    wirelessSettings.insert("powersave", 2);
+
+    QVariantMap wirelessSecuritySettings;
+    wirelessSecuritySettings.insert("key-mgmt", "wpa-psk");
+    wirelessSecuritySettings.insert("psk", password);
+
+    QVariantMap ipv4Settings;
+    ipv4Settings.insert("method", "shared");
+
+    QVariantMap ipv6Settings;
+    ipv6Settings.insert("method", "auto");
+
+    // Build connection object
+    ConnectionSettings settings;
+    settings.insert("connection", connectionSettings);
+    settings.insert("802-11-wireless", wirelessSettings);
+    settings.insert("ipv4", ipv4Settings);
+    settings.insert("ipv6", ipv6Settings);
+    settings.insert("802-11-wireless-security", wirelessSecuritySettings);
+
+    // Remove old configuration (if there is any)
+    foreach (NetworkConnection *connection, m_networkSettings->connections()) {
+        if (connection->id() == connectionSettings.value("id")) {
+            connection->deleteConnection();
+        }
+    }
+
+    // Add connection
+    QDBusObjectPath connectionObjectPath = m_networkSettings->addConnection(settings);
+    if (connectionObjectPath.path().isEmpty())
+        return NetworkManagerErrorWirelessConnectionFailed;
+
+
+    qCDebug(dcNetworkManager()) << "Connection added" << connectionObjectPath.path();
+
+    //
+
+    // Activate connection
+    QDBusMessage query = m_networkManagerInterface->call("ActivateConnection",
+                                                         QVariant::fromValue(connectionObjectPath),
+                                                         QVariant::fromValue(wirelessNetworkDevice->objectPath()),
+                                                         QVariant::fromValue(QDBusObjectPath("/")));
+    if (query.type() != QDBusMessage::ReplyMessage) {
         qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
         return NetworkManagerErrorWirelessConnectionFailed;
     }
@@ -229,6 +327,83 @@ bool NetworkManager::enableWireless(bool enabled)
     return m_networkManagerInterface->setProperty("WirelessEnabled", enabled);
 }
 
+bool NetworkManager::init()
+{
+    if (!m_enabled)
+        return false;
+
+    qCDebug(dcNetworkManager()) << "Initialize network manager";
+    // Check DBus connection
+    if (!QDBusConnection::systemBus().isConnected()) {
+        qCWarning(dcNetworkManager()) << "System DBus not connected. NetworkManagre not available.";
+        setAvailable(false);
+        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_networkManagerInterface->deleteLater();
+        m_networkManagerInterface = nullptr;
+        setAvailable(false);
+        return false;
+    }
+
+    // Init properties
+    setVersion(m_networkManagerInterface->property("Version").toString());
+    setState(static_cast<NetworkManagerState>(m_networkManagerInterface->property("State").toUInt()));
+    setConnectivityState(static_cast<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);
+    qCDebug(dcNetworkManager()) << "Network manager initialized successfully.";
+
+    return true;
+}
+
+void NetworkManager::deinit()
+{
+    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;
+    }
+
+    setVersion(QString());
+    setState(NetworkManagerStateUnknown);
+    setConnectivityState(NetworkManagerConnectivityStateUnknown);
+    setNetworkingEnabled(false);
+    setWirelessEnabled(false);
+    setAvailable(false);
+
+    qCDebug(dcNetworkManager()) << "Netowkmanager deinitialized successfully.";
+}
+
 void NetworkManager::loadDevices()
 {
     // Get network devices
@@ -271,7 +446,7 @@ void NetworkManager::setAvailable(bool available)
     if (m_available == available)
         return;
 
-    qCDebug(dcNetworkManager()) << "Service is now" << (available ? "available" : "unavailable");
+    qCDebug(dcNetworkManager()) << "The network manager is now" << (available ? "available" : "unavailable");
     m_available = available;
     emit availableChanged(m_available);
 }
@@ -319,13 +494,13 @@ void NetworkManager::setState(const NetworkManager::NetworkManagerState &state)
 void NetworkManager::onServiceRegistered()
 {
     qCDebug(dcNetworkManager()) << "DBus service registered and available.";
-    // TODO: init stuff
+    init();
 }
 
 void NetworkManager::onServiceUnregistered()
 {
     qCWarning(dcNetworkManager()) << "DBus service unregistered.";
-    // TODO: deinit stuff
+    deinit();
 }
 
 void NetworkManager::onDeviceAdded(const QDBusObjectPath &deviceObjectPath)
@@ -405,7 +580,7 @@ void NetworkManager::onPropertiesChanged(const QVariantMap &properties)
         setVersion(properties.value("Version").toString());
 
     if (properties.contains("State"))
-        setState((NetworkManagerState)properties.value("State").toUInt());
+        setState(static_cast<NetworkManagerState>(properties.value("State").toUInt()));
 
     if (properties.contains("Connectivity"))
         setConnectivityState(NetworkManagerConnectivityState(properties.value("Connectivity").toUInt()));
@@ -432,84 +607,29 @@ void NetworkManager::onWiredDeviceChanged()
 
 bool NetworkManager::start()
 {
-    // Get notification when network-manager appears/disappears on DBus
+    // We want the networkmanager to run, so enable it
-    m_serviceWatcher = new QDBusServiceWatcher(NetworkManagerUtils::networkManagerServiceString(), QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration | QDBusServiceWatcher::WatchForUnregistration, this);
+    m_enabled = true;
-    connect(m_serviceWatcher, &QDBusServiceWatcher::serviceRegistered, this, &NetworkManager::onServiceRegistered);
-    connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &NetworkManager::onServiceUnregistered);
 
-    // Check DBus connection
+    qCDebug(dcNetworkManager()) << "Start the network manager.";
-    if (!QDBusConnection::systemBus().isConnected()) {
+    if (m_available) {
-        qCWarning(dcNetworkManager()) << "System DBus not connected. NetworkManagre not available.";
+        qCDebug(dcNetworkManager()) << "Networkmanager already running.";
-        m_serviceWatcher->deleteLater();
+        return true;
-        m_serviceWatcher = nullptr;
-        return false;
     }
 
-    // Create interface
+    return init();
-    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) {
+    // We want the networkmanager to stop, so disable it
-        onDeviceRemoved(device->objectPath());
+    m_enabled = false;
+
+    qCDebug(dcNetworkManager()) << "Stop the network manager.";
+    if (!m_available) {
+        qCDebug(dcNetworkManager()) << "Networkmanager already stopped.";
+        return;
     }
 
-    m_wiredNetworkDevices.clear();
+    deinit();
-    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

@@ -41,8 +41,8 @@ class NetworkManager : public QObject
 {
     Q_OBJECT
     Q_ENUMS(NetworkManagerState)
-    Q_ENUMS(NetworkManagerConnectivityState)
     Q_ENUMS(NetworkManagerError)
+    Q_ENUMS(NetworkManagerConnectivityState)
 
 public:
     enum NetworkManagerState {
@@ -80,7 +80,7 @@ public:
     };
     Q_ENUM(NetworkManagerError)
 
-    explicit NetworkManager(QObject *parent = 0);
+    explicit NetworkManager(QObject *parent = nullptr);
     ~NetworkManager();
 
     bool available() const;
@@ -90,6 +90,7 @@ public:
     QList<WirelessNetworkDevice *> wirelessNetworkDevices() const;
     QList<WiredNetworkDevice *> wiredNetworkDevices() const;
 
+    NetworkSettings *networkSettings() const;
     NetworkDevice *getNetworkDevice(const QString &interface);
 
     // Properties
@@ -99,6 +100,7 @@ public:
     NetworkManagerConnectivityState connectivityState() const;
 
     NetworkManagerError connectWifi(const QString &interface, const QString &ssid, const QString &password, bool hidden = false);
+    NetworkManagerError startAccessPoint(const QString &interface, const QString &ssid, const QString &password);
 
     // Networking
     bool networkingEnabled() const;
@@ -118,12 +120,17 @@ private:
     QHash<QDBusObjectPath, WiredNetworkDevice *> m_wiredNetworkDevices;
 
     bool m_available = false;
+    bool m_enabled = false;
+
     QString m_version;
     NetworkManagerState m_state = NetworkManagerStateUnknown;
     NetworkManagerConnectivityState m_connectivityState = NetworkManagerConnectivityStateUnknown;
     bool m_networkingEnabled = false;
     bool m_wirelessEnabled = false;
 
+    bool init();
+    void deinit();
+
     void loadDevices();
 
     static QString networkManagerStateToString(const NetworkManagerState &state);

libnymea-networkmanager/networksettings.h

@@ -36,7 +36,7 @@ class NetworkSettings : public QObject
 {
     Q_OBJECT
 public:
-    explicit NetworkSettings(QObject *parent = 0);
+    explicit NetworkSettings(QObject *parent = nullptr);
 
     QDBusObjectPath addConnection(const ConnectionSettings &settings);
     QList<NetworkConnection *> connections() const;

libnymea-networkmanager/wirednetworkdevice.h

@@ -31,7 +31,7 @@ class WiredNetworkDevice : public NetworkDevice
 {
     Q_OBJECT
 public:
-    explicit WiredNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent = 0);
+    explicit WiredNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent = nullptr);
 
     QString macAddress() const;
     int bitRate() const;

libnymea-networkmanager/wirelessaccesspoint.cpp

@@ -43,8 +43,7 @@
 /*! Constructs a new \l{WirelessAccessPoint} with the given dbus \a objectPath and \a parent. */
 WirelessAccessPoint::WirelessAccessPoint(const QDBusObjectPath &objectPath, QObject *parent) :
     QObject(parent),
-    m_objectPath(objectPath),
+    m_objectPath(objectPath)
-    m_securityFlags(0)
 {
     QDBusInterface accessPointInterface(NetworkManagerUtils::networkManagerServiceString(), m_objectPath.path(), NetworkManagerUtils::accessPointInterfaceString(), QDBusConnection::systemBus());
     if(!accessPointInterface.isValid()) {
@@ -56,9 +55,9 @@ WirelessAccessPoint::WirelessAccessPoint(const QDBusObjectPath &objectPath, QObj
     setSsid(accessPointInterface.property("Ssid").toString());
     setMacAddress(accessPointInterface.property("HwAddress").toString());
     setFrequency(accessPointInterface.property("Frequency").toDouble() / 1000);
-    setSignalStrength(accessPointInterface.property("Strength").toUInt());
+    setSignalStrength(accessPointInterface.property("Strength").toInt());
     setSecurityFlags(WirelessAccessPoint::ApSecurityModes(accessPointInterface.property("WpaFlags").toUInt()));
-    setIsProtected((bool)accessPointInterface.property("Flags").toUInt());
+    setIsProtected(static_cast<bool>(accessPointInterface.property("Flags").toUInt()));
 
     QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), objectPath.path(), NetworkManagerUtils::accessPointInterfaceString(), "PropertiesChanged", this, SLOT(onPropertiesChanged(QVariantMap)));
 }
@@ -139,7 +138,7 @@ void WirelessAccessPoint::setSecurityFlags(const WirelessAccessPoint::ApSecurity
 void WirelessAccessPoint::onPropertiesChanged(const QVariantMap &properties)
 {
     if (properties.contains("Strength"))
-        setSignalStrength(properties.value("Strength").toUInt());
+        setSignalStrength(properties.value("Strength").toInt());
 
 }
 

libnymea-networkmanager/wirelessaccesspoint.h

@@ -51,7 +51,7 @@ public:
     };
     Q_DECLARE_FLAGS(ApSecurityModes, ApSecurityMode)
 
-    explicit WirelessAccessPoint(const QDBusObjectPath &objectPath, QObject *parent = 0);
+    explicit WirelessAccessPoint(const QDBusObjectPath &objectPath, QObject *parent = nullptr);
 
     QDBusObjectPath objectPath() const;
 
@@ -68,9 +68,9 @@ private:
     QString m_ssid;
     QString m_macAddress;
     double m_frequency;
-    int m_signalStrength;
+    int m_signalStrength = 0;
-    bool m_isProtected;
+    bool m_isProtected = false;
-    WirelessAccessPoint::ApSecurityModes m_securityFlags;
+    WirelessAccessPoint::ApSecurityModes m_securityFlags = ApSecurityModeNone;
 
     void setSsid(const QString &ssid);
     void setMacAddress(const QString &macAddress);

libnymea-networkmanager/wirelessnetworkdevice.cpp

@@ -40,7 +40,7 @@
 /*! Constructs a new \l{WirelessNetworkDevice} with the given dbus \a objectPath and \a parent. */
 WirelessNetworkDevice::WirelessNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent) :
     NetworkDevice(objectPath, parent),
-    m_activeAccessPoint(Q_NULLPTR)
+    m_activeAccessPoint(nullptr)
 {
     QDBusConnection systemBus = QDBusConnection::systemBus();
     if (!systemBus.isConnected()) {
@@ -61,6 +61,7 @@ WirelessNetworkDevice::WirelessNetworkDevice(const QDBusObjectPath &objectPath,
     readAccessPoints();
 
     setMacAddress(m_wirelessInterface->property("HwAddress").toString());
+    setMode(static_cast<Mode>(m_wirelessInterface->property("Mode").toUInt()));
     setBitrate(m_wirelessInterface->property("Bitrate").toInt());
     setActiveAccessPoint(qdbus_cast<QDBusObjectPath>(m_wirelessInterface->property("ActiveAccessPoint")));
 }
@@ -77,6 +78,11 @@ int WirelessNetworkDevice::bitRate() const
     return m_bitRate;
 }
 
+WirelessNetworkDevice::Mode WirelessNetworkDevice::mode() const
+{
+    return m_mode;
+}
+
 /*! Returns the current active \l{WirelessAccessPoint} of this \l{WirelessNetworkDevice}. */
 WirelessAccessPoint *WirelessNetworkDevice::activeAccessPoint()
 {
@@ -100,17 +106,17 @@ QList<WirelessAccessPoint *> WirelessNetworkDevice::accessPoints()
     return m_accessPointsTable.values();
 }
 
-/*! Returns the \l{WirelessAccessPoint} with the given \a ssid. If the \l{WirelessAccessPoint} could not be found, return Q_NULLPTR. */
+/*! Returns the \l{WirelessAccessPoint} with the given \a ssid. If the \l{WirelessAccessPoint} could not be found, return nullptr. */
 WirelessAccessPoint *WirelessNetworkDevice::getAccessPoint(const QString &ssid)
 {
     foreach (WirelessAccessPoint *accessPoint, m_accessPointsTable.values()) {
         if (accessPoint->ssid() == ssid)
             return accessPoint;
     }
-    return Q_NULLPTR;
+    return nullptr;
 }
 
-/*! Returns the \l{WirelessAccessPoint} with the given \a objectPath. If the \l{WirelessAccessPoint} could not be found, return Q_NULLPTR. */
+/*! Returns the \l{WirelessAccessPoint} with the given \a objectPath. If the \l{WirelessAccessPoint} could not be found, return nullptr. */
 WirelessAccessPoint *WirelessNetworkDevice::getAccessPoint(const QDBusObjectPath &objectPath)
 {
     return m_accessPointsTable.value(objectPath);
@@ -141,10 +147,20 @@ void WirelessNetworkDevice::setMacAddress(const QString &macAddress)
     m_macAddress = macAddress;
 }
 
-void WirelessNetworkDevice::setBitrate(const int &bitRate)
+void WirelessNetworkDevice::setMode(WirelessNetworkDevice::Mode mode)
+{
+    if (m_mode == mode)
+        return;
+
+    m_mode = mode;
+    emit modeChanged(m_mode);
+}
+
+void WirelessNetworkDevice::setBitrate(int bitRate)
 {
     if (m_bitRate != bitRate / 1000) {
         m_bitRate = bitRate / 1000;
+        emit bitRateChanged(m_bitRate);
         emit deviceChanged();
     }
 }
@@ -162,7 +178,7 @@ void WirelessNetworkDevice::setActiveAccessPoint(const QDBusObjectPath &activeAc
             // Update the device when the signalstrength changed
             connect(m_activeAccessPoint, &WirelessAccessPoint::signalStrengthChanged, this, &WirelessNetworkDevice::deviceChanged);
         } else {
-            m_activeAccessPoint = Q_NULLPTR;
+            m_activeAccessPoint = nullptr;
         }
         emit deviceChanged();
     }
@@ -193,7 +209,7 @@ void WirelessNetworkDevice::accessPointRemoved(const QDBusObjectPath &objectPath
 
     WirelessAccessPoint *accessPoint = m_accessPointsTable.take(objectPath);
     if (accessPoint == m_activeAccessPoint)
-        m_activeAccessPoint = Q_NULLPTR;
+        m_activeAccessPoint = nullptr;
 
     //qCDebug(dcNetworkManager()) << "WirelessNetworkDevice: [-]" << accessPoint;
     accessPoint->deleteLater();
@@ -208,6 +224,10 @@ void WirelessNetworkDevice::propertiesChanged(const QVariantMap &properties)
 
     if (properties.contains("ActiveAccessPoint"))
         setActiveAccessPoint(qdbus_cast<QDBusObjectPath>(properties.value("ActiveAccessPoint")));
+
+    if (properties.contains("Mode"))
+        setMode(static_cast<Mode>(m_wirelessInterface->property("Mode").toUInt()));
+
 }
 
 /*! Writes the given \a device to the given to \a debug. \sa WirelessNetworkDevice, */
@@ -215,6 +235,7 @@ QDebug operator<<(QDebug debug, WirelessNetworkDevice *device)
 {
     debug.nospace() << "WirelessNetworkDevice(" << device->interface() << ", ";
     debug.nospace() << device->macAddress() <<  ", ";
+    debug.nospace() << device->mode() <<  ", ";
     debug.nospace() << device->bitRate() <<  " [Mb/s], ";
     debug.nospace() << device->deviceStateString() <<  ") ";
     return debug;

libnymea-networkmanager/wirelessnetworkdevice.h

@@ -37,12 +37,20 @@ class WirelessNetworkDevice : public NetworkDevice
 {
     Q_OBJECT
 public:
+    enum Mode {
+        ModeUnknown          = 0,
+        ModeAdhoc            = 1,
+        ModeInfrastructure   = 2,
+        ModeAccessPoint      = 3
+    };
+    Q_ENUM(Mode)
 
-    explicit WirelessNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent = 0);
+    explicit WirelessNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent = nullptr);
 
     // Properties
     QString macAddress() const;
     int bitRate() const;
+    Mode mode() const;
     WirelessAccessPoint *activeAccessPoint();
 
     // Accesspoints
@@ -54,11 +62,12 @@ public:
     void scanWirelessNetworks();
 
 private:
-    QDBusInterface *m_wirelessInterface;
+    QDBusInterface *m_wirelessInterface = nullptr;
+    WirelessAccessPoint *m_activeAccessPoint = nullptr;
 
-    QString m_macAddress;
     int m_bitRate;
-    WirelessAccessPoint *m_activeAccessPoint;
+    QString m_macAddress;
+    Mode m_mode = ModeUnknown;
     QDBusObjectPath m_activeAccessPointObjectPath;
 
     QHash<QDBusObjectPath, WirelessAccessPoint *> m_accessPointsTable;
@@ -66,7 +75,8 @@ private:
     void readAccessPoints();
 
     void setMacAddress(const QString &macAddress);
-    void setBitrate(const int &bitRate);
+    void setMode(Mode mode);
+    void setBitrate(int bitRate);
     void setActiveAccessPoint(const QDBusObjectPath &activeAccessPointObjectPath);
 
 private slots:
@@ -75,7 +85,8 @@ private slots:
     void propertiesChanged(const QVariantMap &properties);
 
 signals:
-    void bitRateChanged(const int &bitRate);
+    void bitRateChanged(int bitRate);
+    void modeChanged(Mode mode);
 
 };