improve networkmanager api and bump version

debian/changelog

@@ -1,3 +1,9 @@
+guh (0.7.8) xenial; urgency=medium
+
+  * Add networkmanager
+
+ -- Simon Stürz <simon.stuerz@guh.io>  Thu, 6 Oct 2016 14:31:48 +0200
+
 guh (0.7.6) xenial; urgency=medium
 
   * Add translations

guh.pri

@@ -2,7 +2,7 @@
 GUH_VERSION_STRING=$$system('dpkg-parsechangelog | sed -n -e "s/^Version: //p"')
 
 # define protocol versions
-JSON_PROTOCOL_VERSION=46
+JSON_PROTOCOL_VERSION=47
 REST_API_VERSION=1
 
 DEFINES += GUH_VERSION_STRING=\\\"$${GUH_VERSION_STRING}\\\" \

server/jsonrpc/jsontypes.cpp

@@ -86,6 +86,7 @@ QVariantList JsonTypes::s_cloudError;
 QVariantList JsonTypes::s_configurationError;
 QVariantList JsonTypes::s_networkManagerError;
 QVariantList JsonTypes::s_networkManagerState;
+QVariantList JsonTypes::s_networkDeviceState;
 
 QVariantMap JsonTypes::s_paramType;
 QVariantMap JsonTypes::s_param;
@@ -140,6 +141,7 @@ void JsonTypes::init()
     s_configurationError = enumToStrings(GuhConfiguration::staticMetaObject, "ConfigurationError");
     s_networkManagerError = enumToStrings(NetworkManager::staticMetaObject, "NetworkManagerError");
     s_networkManagerState = enumToStrings(NetworkManager::staticMetaObject, "NetworkManagerState");
+    s_networkDeviceState = enumToStrings(NetworkDevice::staticMetaObject, "NetworkDeviceState");
 
     // ParamType
     s_paramType.insert("id", basicTypeToString(Uuid));
@@ -1545,6 +1547,7 @@ QPair<bool, QString> JsonTypes::validateProperty(const QVariant &templateValue,
         QString errorString = QString("Param %1 is not a time (hh:mm).").arg(value.toString());
         return report(value.canConvert(QVariant::Time), errorString);
     }
+
     qCWarning(dcJsonRpc) << QString("Unhandled property type: %1 (expected: %2)").arg(value.toString()).arg(strippedTemplateValue);
     QString errorString = QString("Unhandled property type: %1 (expected: %2)").arg(value.toString()).arg(strippedTemplateValue);
     return report(false, errorString);
@@ -1867,6 +1870,12 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
                     qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(networkManagerErrorRef());
                     return result;
                 }
+            } else if (refName == networkDeviceStateRef()) {
+                QPair<bool, QString> result = validateEnum(s_networkDeviceState, variant);
+                if (!result.first) {
+                    qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(networkDeviceStateRef());
+                    return result;
+                }
             } else {
                 Q_ASSERT_X(false, "JsonTypes", QString("Unhandled ref: %1").arg(refName).toLatin1().data());
                 return report(false, QString("Unhandled ref %1. Server implementation incomplete.").arg(refName));

server/jsonrpc/jsontypes.h

@@ -132,6 +132,7 @@ public:
     DECLARE_TYPE(configurationError, "ConfigurationError", GuhConfiguration, ConfigurationError)
     DECLARE_TYPE(networkManagerError, "NetworkManagerError", NetworkManager, NetworkManagerError)
     DECLARE_TYPE(networkManagerState, "NetworkManagerState", NetworkManager, NetworkManagerState)
+    DECLARE_TYPE(networkDeviceState, "NetworkDeviceState", NetworkDevice, NetworkDeviceState)
 
     DECLARE_OBJECT(paramType, "ParamType")
     DECLARE_OBJECT(param, "Param")

server/jsonrpc/networkmanagerhandler.cpp

@@ -30,8 +30,7 @@ namespace guhserver {
 NetworkManagerHandler::NetworkManagerHandler(QObject *parent) :
     JsonHandler(parent)
 {
-    QVariantMap params;
+    QVariantMap params; QVariantMap returns;
-    QVariantMap returns;
 
     params.clear(); returns.clear();
     setDescription("GetNetworkStatus", "Get the current network manager status.");
@@ -41,7 +40,7 @@ NetworkManagerHandler::NetworkManagerHandler(QObject *parent) :
     status.insert("wirelessNetworkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool));
     status.insert("state", JsonTypes::networkManagerStateRef());
     returns.insert("o:status", status);
-    returns.insert("o:networkManagerError", JsonTypes::networkManagerErrorRef());
+    returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
     setReturns("GetNetworkStatus", returns);
 
     params.clear(); returns.clear();
@@ -62,14 +61,14 @@ NetworkManagerHandler::NetworkManagerHandler(QObject *parent) :
     setDescription("GetWirelessAccessPoints", "Get the current list of wireless network access points.");
     setParams("GetWirelessAccessPoints", params);
     returns.insert("o:wirelessAccessPoints", QVariantList() << JsonTypes::wirelessAccessPointRef());
-    returns.insert("o:networkManagerError", JsonTypes::networkManagerErrorRef());
+    returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
     setReturns("GetWirelessAccessPoints", returns);
 
     params.clear(); returns.clear();
     setDescription("GetNetworkDevices", "Get the list of current network devices.");
     setParams("GetNetworkDevices", params);
     returns.insert("o:networkDevices",  QVariantList() << JsonTypes::networkDeviceRef());
-    returns.insert("o:networkManagerError", JsonTypes::networkManagerErrorRef());
+    returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
     setReturns("GetNetworkDevices", returns);
 
     params.clear(); returns.clear();
@@ -128,6 +127,7 @@ JsonReply *NetworkManagerHandler::GetNetworkStatus(const QVariantMap &params)
     // Pack network manager status
     QVariantMap returns;
     returns.insert("status", packNetworkManagerStatus());
+    returns.insert("networkManagerError", statusToReply(NetworkManager::NetworkManagerErrorNoError));
     return createReply(returns);
 }
 
@@ -168,12 +168,19 @@ JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap &par
     if (!GuhCore::instance()->networkManager()->wifiAvailable())
         return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNotAvailable));
 
+    if (!GuhCore::instance()->networkManager()->networkingEnabled())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkingDisabled));
+
+    if (!GuhCore::instance()->networkManager()->wirelessEnabled())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNetworkingDisabled));
+
     QVariantList wirelessAccessPoints;
     foreach (WirelessAccessPoint *wirelessAccessPoint, GuhCore::instance()->networkManager()->wirelessNetworkManager()->accessPoints())
         wirelessAccessPoints.append(JsonTypes::packWirelessAccessPoint(wirelessAccessPoint));
 
     QVariantMap returns;
     returns.insert("wirelessAccessPoints", wirelessAccessPoints);
+    returns.insert("networkManagerError", statusToReply(NetworkManager::NetworkManagerErrorNoError));
     return createReply(returns);
 }
 
@@ -190,6 +197,7 @@ JsonReply *NetworkManagerHandler::GetNetworkDevices(const QVariantMap &params)
 
     QVariantMap returns;
     returns.insert("networkDevices", networkDevices);
+    returns.insert("networkManagerError", statusToReply(NetworkManager::NetworkManagerErrorNoError));
     return createReply(returns);
 }
 
@@ -203,6 +211,13 @@ JsonReply *NetworkManagerHandler::ScanWifiNetworks(const QVariantMap &params)
     if (!GuhCore::instance()->networkManager()->wifiAvailable())
         return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNotAvailable));
 
+    if (!GuhCore::instance()->networkManager()->networkingEnabled())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkingDisabled));
+
+    if (!GuhCore::instance()->networkManager()->wirelessEnabled())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNetworkingDisabled));
+
+
     GuhCore::instance()->networkManager()->wirelessNetworkManager()->scanWirelessNetworks();
     return createReply(statusToReply(NetworkManager::NetworkManagerErrorNoError));
 }
@@ -215,6 +230,13 @@ JsonReply *NetworkManagerHandler::ConnectWifiNetwork(const QVariantMap &params)
     if (!GuhCore::instance()->networkManager()->wifiAvailable())
         return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNotAvailable));
 
+    if (!GuhCore::instance()->networkManager()->networkingEnabled())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkingDisabled));
+
+    if (!GuhCore::instance()->networkManager()->wirelessEnabled())
+        return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNetworkingDisabled));
+
+
     QString ssid = params.value("ssid").toString();
     QString password = params.value("password").toString();
     NetworkManager::NetworkManagerError error = GuhCore::instance()->networkManager()->connectWifi(ssid, password);

server/networkmanager/networkdevice.cpp

@@ -54,6 +54,7 @@ NetworkDevice::NetworkDevice(const QDBusObjectPath &objectPath, QObject *parent)
     m_physicalPortId = networkDeviceInterface.property("PhysicalPortId").toString();
     m_mtu = networkDeviceInterface.property("Mtu").toUInt();
     m_metered = networkDeviceInterface.property("Metered").toUInt();
+    m_autoconnect = networkDeviceInterface.property("Autoconnect").toBool();
 
     m_deviceState = NetworkDeviceState(networkDeviceInterface.property("State").toUInt());
     m_deviceType = DeviceType(networkDeviceInterface.property("DeviceType").toUInt());
@@ -114,6 +115,11 @@ uint NetworkDevice::metered() const
     return m_metered;
 }
 
+bool NetworkDevice::autoconnect() const
+{
+    return m_autoconnect;
+}
+
 NetworkDevice::NetworkDeviceState NetworkDevice::deviceState() const
 {
     return m_deviceState;
@@ -175,7 +181,9 @@ QString NetworkDevice::deviceStateReasonToString(const NetworkDevice::NetworkDev
 
 void NetworkDevice::onStateChanged(uint newState, uint oldState, uint reason)
 {
-    qCDebug(dcNetworkManager()) << m_interface << deviceStateToString(NetworkDeviceState(oldState)) << "-->" << deviceStateToString(NetworkDeviceState(newState)) << ":" << deviceStateReasonToString(NetworkDeviceStateReason(reason));
+    Q_UNUSED(oldState);
+
+    qCDebug(dcNetworkManager()) << m_interface << deviceStateToString(NetworkDeviceState(newState)) << ":" << deviceStateReasonToString(NetworkDeviceStateReason(reason));
 
     m_deviceState = NetworkDeviceState(newState);
     emit deviceStateChanged();
@@ -183,7 +191,7 @@ void NetworkDevice::onStateChanged(uint newState, uint oldState, uint reason)
 
 QDebug operator<<(QDebug debug, NetworkDevice *device)
 {
-    debug.nospace() << "NetworkDevice(" << device->interface() << " - " << NetworkDevice::deviceTypeToString(device->deviceType()) << ")";
+    debug.nospace() << "NetworkDevice(" << device->interface() << " - " << NetworkDevice::deviceTypeToString(device->deviceType()) << ", " << device->deviceStateString() << ")";
     return debug;
 }
 

server/networkmanager/networkdevice.h

@@ -157,9 +157,11 @@ public:
     QString physicalPortId() const;
     uint mtu() const;
     uint metered() const;
+    bool autoconnect() const;
 
     NetworkDeviceState deviceState() const;
     QString deviceStateString() const;
+
     NetworkDeviceStateReason deviceStateReason() const;
     DeviceType deviceType() const;
 
@@ -170,6 +172,7 @@ public:
     static QString deviceTypeToString(const DeviceType &deviceType);
     static QString deviceStateToString(const NetworkDeviceState &deviceState);
     static QString deviceStateReasonToString(const NetworkDeviceStateReason &deviceStateReason);
+
 private:
     QDBusObjectPath m_objectPath;
 
@@ -183,6 +186,7 @@ private:
     QString m_physicalPortId;
     uint m_mtu;
     uint m_metered;
+    bool m_autoconnect;
     NetworkDeviceState m_deviceState;
     NetworkDeviceStateReason m_deviceStateReason;
     DeviceType m_deviceType;

server/networkmanager/networkmanager.cpp

@@ -119,7 +119,7 @@ NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &s
 
     QVariantMap connectionSettings;
     connectionSettings.insert("autoconnect", true);
-    connectionSettings.insert("id", ssid +" (guhIO)");
+    connectionSettings.insert("id", ssid + " (guhIO)");
     connectionSettings.insert("type", "802-11-wireless");
 
     QVariantMap wirelessSettings;
@@ -247,6 +247,7 @@ QString NetworkManager::networkManagerConnectivityStateToString(const NetworkMan
 
 void NetworkManager::setVersion(const QString &version)
 {
+    qCDebug(dcNetworkManager()) << "Version:" << version;
     m_version = version;
     emit versionChanged();
 }

server/networkmanager/wirelessnetworkmanager.cpp

@@ -29,81 +29,7 @@
 namespace guhserver {
 
 WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &objectPath, QObject *parent) :
-    QObject(parent),
+    NetworkDevice(objectPath, parent)
-    m_objectPath(objectPath),
-    m_connected(false),
-    m_managed(false),
-    m_state(NetworkDeviceStateUnknown),
-    m_stateReason(NetworkDeviceStateReasonUnknown)
-{
-    QDBusConnection systemBus = QDBusConnection::systemBus();
-    if (!systemBus.isConnected()) {
-        qCWarning(dcNetworkManager()) << "System DBus not connected";
-        return;
-    }
-
-    QDBusConnection::systemBus().connect(serviceString, m_objectPath.path(), wirelessInterfaceString, "AccessPointAdded", this, SLOT(accessPointAdded(QDBusObjectPath)));
-    QDBusConnection::systemBus().connect(serviceString, m_objectPath.path(), wirelessInterfaceString, "AccessPointRemoved", this, SLOT(accessPointRemoved(QDBusObjectPath)));
-    QDBusConnection::systemBus().connect(serviceString, m_objectPath.path(), deviceInterfaceString, "StateChanged", this, SLOT(deviceStateChanged(quint32,quint32,quint32)));
-
-    readWirelessDeviceProperties();
-
-    qCDebug(dcNetworkManager()) << this;
-
-    readAccessPoints();
-}
-
-QDBusObjectPath WirelessNetworkManager::objectPath() const
-{
-    return m_objectPath;
-}
-
-QString WirelessNetworkManager::udi() const
-{
-    return m_udi;
-}
-
-QString WirelessNetworkManager::macAddress() const
-{
-    return m_macAddress;
-}
-
-QString WirelessNetworkManager::interfaceName() const
-{
-    return m_interfaceName;
-}
-
-QString WirelessNetworkManager::driver() const
-{
-    return m_driver;
-}
-
-QString WirelessNetworkManager::driverVersion() const
-{
-    return m_driverVersion;
-}
-
-bool WirelessNetworkManager::connected() const
-{
-    return m_connected;
-}
-
-bool WirelessNetworkManager::managed() const
-{
-    return m_managed;
-}
-
-WirelessNetworkManager::NetworkDeviceState WirelessNetworkManager::state() const
-{
-    return m_state;
-}
-
-WirelessNetworkManager::NetworkDeviceStateReason WirelessNetworkManager::stateReason() const
-{
-    return m_stateReason;
-}
-
-void WirelessNetworkManager::scanWirelessNetworks()
 {
     QDBusConnection systemBus = QDBusConnection::systemBus();
     if (!systemBus.isConnected()) {
@@ -111,20 +37,43 @@ void WirelessNetworkManager::scanWirelessNetworks()
         return;
     }
 
-    QDBusInterface wirelessInterface(serviceString, m_objectPath.path(), wirelessInterfaceString, systemBus);
+    m_wirelessInterface = new QDBusInterface(serviceString, this->objectPath().path(), wirelessInterfaceString, systemBus, this);
-    if(!wirelessInterface.isValid()) {
+    if(!m_wirelessInterface->isValid()) {
-        qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not scan wireless networks: Invalid wireless dbus interface";
+        qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Invalid wireless dbus interface";
         return;
     }
 
-    QDBusMessage query= wirelessInterface.call("RequestScan", QVariantMap());
+    QDBusConnection::systemBus().connect(serviceString, this->objectPath().path(), wirelessInterfaceString, "AccessPointAdded", this, SLOT(accessPointAdded(QDBusObjectPath)));
+    QDBusConnection::systemBus().connect(serviceString, this->objectPath().path(), wirelessInterfaceString, "AccessPointRemoved", this, SLOT(accessPointRemoved(QDBusObjectPath)));
+    QDBusConnection::systemBus().connect(serviceString, this->objectPath().path(), wirelessInterfaceString, "PropertiesChanged", this, SLOT(propertiesChanged(QVariantMap)));
+
+    m_macAddress = m_wirelessInterface->property("HwAddress").toString();
+    m_bitrate = m_wirelessInterface->property("Bitrate").toInt() / 1000;
+
+    qCDebug(dcNetworkManager()) << this;
+
+    readAccessPoints();
+}
+
+QString WirelessNetworkManager::macAddress() const
+{
+    return m_macAddress;
+}
+
+int WirelessNetworkManager::bitrate() const
+{
+    return m_bitrate;
+}
+
+void WirelessNetworkManager::scanWirelessNetworks()
+{
+    QDBusMessage query = m_wirelessInterface->call("RequestScan", QVariantMap());
     if(query.type() != QDBusMessage::ReplyMessage) {
         qCWarning(dcNetworkManager()) << "Scan error:" << query.errorName() << query.errorMessage();
         return;
     }
 }
 
-
 QList<WirelessAccessPoint *> WirelessNetworkManager::accessPoints()
 {
     return m_accessPointsTable.values();
@@ -144,31 +93,9 @@ WirelessAccessPoint *WirelessNetworkManager::getAccessPoint(const QDBusObjectPat
     return m_accessPointsTable.value(objectPath);
 }
 
-QString WirelessNetworkManager::deviceStateToString(const WirelessNetworkManager::NetworkDeviceState &state)
-{
-    QMetaObject metaObject = WirelessNetworkManager::staticMetaObject;
-    int enumIndex = metaObject.indexOfEnumerator(QString("NetworkDeviceState").toLatin1().data());
-    QMetaEnum metaEnum = metaObject.enumerator(enumIndex);
-    return QString(metaEnum.valueToKey(state)).remove("NetworkDeviceState");
-}
-
-QString WirelessNetworkManager::deviceStateReasonToString(const WirelessNetworkManager::NetworkDeviceStateReason &stateReason)
-{
-    QMetaObject metaObject = WirelessNetworkManager::staticMetaObject;
-    int enumIndex = metaObject.indexOfEnumerator(QString("NetworkDeviceStateReason").toLatin1().data());
-    QMetaEnum metaEnum = metaObject.enumerator(enumIndex);
-    return QString(metaEnum.valueToKey(stateReason)).remove("NetworkDeviceStateReason");
-}
-
 void WirelessNetworkManager::readAccessPoints()
 {
-    QDBusInterface wirelessInterface(serviceString, m_objectPath.path(), wirelessInterfaceString, QDBusConnection::systemBus());
+    QDBusMessage query = m_wirelessInterface->call("GetAccessPoints");
-    if(!wirelessInterface.isValid()) {
-        qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not read access points: Invalid wireless dbus interface";
-        return;
-    }
-
-    QDBusMessage query = wirelessInterface.call("GetAccessPoints");
     if(query.type() != QDBusMessage::ReplyMessage) {
         qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
         return;
@@ -186,72 +113,6 @@ void WirelessNetworkManager::readAccessPoints()
     argument.endArray();
 }
 
-void WirelessNetworkManager::readWirelessDeviceProperties()
-{
-    QDBusInterface wirelessInterface(serviceString, m_objectPath.path(), wirelessInterfaceString, QDBusConnection::systemBus());
-    if(!wirelessInterface.isValid()) {
-        qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not read access points: Invalid wireless dbus interface";
-        return;
-    }
-
-    QDBusInterface driverInterface(serviceString, m_objectPath.path(), deviceInterfaceString, QDBusConnection::systemBus());
-    if(!driverInterface.isValid()) {
-        qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not read driver information: Invalid driver dbus interface";
-        return;
-    }
-
-    m_udi = driverInterface.property("Udi").toString();
-    m_macAddress = wirelessInterface.property("HwAddress").toString();
-    m_interfaceName = driverInterface.property("Interface").toString();
-    m_driver = driverInterface.property("Driver").toString();
-    m_driverVersion = driverInterface.property("DriverVersion").toString();
-
-    setManaged(driverInterface.property("Managed").toBool());
-    setState(NetworkDeviceState(driverInterface.property("State").toUInt()));
-}
-
-void WirelessNetworkManager::setConnected(const bool &connected)
-{
-    if (m_connected != connected) {
-        m_connected = connected;
-        emit connectedChanged(m_connected);
-    }
-}
-
-void WirelessNetworkManager::setState(const NetworkDeviceState &state)
-{
-    m_state = state;
-    emit stateChanged(m_state);
-
-    switch (state) {
-    case NetworkDeviceStateActivated:
-        setConnected(true);
-        break;
-    default:
-        setConnected(false);
-        break;
-    }
-}
-
-void WirelessNetworkManager::setStateReason(const WirelessNetworkManager::NetworkDeviceStateReason &stateReason)
-{
-    m_stateReason = stateReason;
-}
-
-void WirelessNetworkManager::setManaged(const bool &managed)
-{
-    m_managed = managed;
-    emit managedChanged(m_managed);
-}
-
-void WirelessNetworkManager::deviceStateChanged(uint newState, uint oldState, uint reason)
-{
-    qCDebug(dcNetworkManager()) << "WirelessManager: state changed" << deviceStateToString(NetworkDeviceState(oldState)) << "-->" << deviceStateToString(NetworkDeviceState(newState)) << ":" << deviceStateReasonToString(NetworkDeviceStateReason(reason));
-
-    setState(NetworkDeviceState(newState));
-    setStateReason(NetworkDeviceStateReason(reason));
-}
-
 void WirelessNetworkManager::accessPointAdded(const QDBusObjectPath &objectPath)
 {
     QDBusInterface accessPointInterface(serviceString, objectPath.path(), accessPointInterfaceString, QDBusConnection::systemBus());
@@ -266,22 +127,20 @@ void WirelessNetworkManager::accessPointAdded(const QDBusObjectPath &objectPath)
     }
 
     WirelessAccessPoint *accessPoint = new WirelessAccessPoint(objectPath, this);
+    //qCDebug(dcNetworkManager()) << "WirelessNetworkManager: [+]" << accessPoint;
 
     // Add access point
-    qCDebug(dcNetworkManager()) << "WirelessNetworkManager: [+]" << accessPoint;
     m_accessPointsTable.insert(objectPath, accessPoint);
 }
 
 void WirelessNetworkManager::accessPointRemoved(const QDBusObjectPath &objectPath)
 {
-    if (!m_accessPointsTable.keys().contains(objectPath)) {
+    if (!m_accessPointsTable.keys().contains(objectPath))
-        qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Unknown access point removed" << objectPath.path();
         return;
-    }
 
     // Remove access point
     WirelessAccessPoint *accessPoint = m_accessPointsTable.take(objectPath);
-    qCDebug(dcNetworkManager()) << "WirelessNetworkManager: [-]" << accessPoint;
+    //qCDebug(dcNetworkManager()) << "WirelessNetworkManager: [-]" << accessPoint;
     accessPoint->deleteLater();
 }
 
@@ -292,11 +151,10 @@ void WirelessNetworkManager::propertiesChanged(const QVariantMap &properties)
 
 QDebug operator<<(QDebug debug, WirelessNetworkManager *manager)
 {
-    debug.nospace() << "WirelessManager(" << manager->interfaceName() << ", ";
+    debug.nospace() << "WirelessDevice(" << manager->interface() << ", ";
     debug.nospace() << manager->macAddress() <<  ", ";
-    debug.nospace() << manager->udi() <<  ", ";
+    debug.nospace() << manager->bitrate() <<  " [Mb/s], ";
-    debug.nospace() << manager->driver() << ": " << manager->driverVersion() <<  ", ";
+    debug.nospace() << manager->deviceStateString() <<  ") ";
-    debug.nospace() << WirelessNetworkManager::deviceStateToString(manager->state()) <<  ") ";
     return debug;
 }
 

server/networkmanager/wirelessnetworkmanager.h

@@ -29,113 +29,20 @@
 #include <QDBusContext>
 #include <QDBusArgument>
 
+#include "networkdevice.h"
 #include "wirelessaccesspoint.h"
 
 namespace guhserver {
 
-class WirelessNetworkManager : public QObject
+class WirelessNetworkManager : public NetworkDevice
 {
     Q_OBJECT
-    Q_ENUMS(NetworkDeviceState)
-    Q_ENUMS(NetworkDeviceStateReason)
-
 public:
-    enum NetworkDeviceState {
-        NetworkDeviceStateUnknown = 0,
-        NetworkDeviceStateUnmanaged = 10,
-        NetworkDeviceStateUnavailable = 20,
-        NetworkDeviceStateDisconnected = 30,
-        NetworkDeviceStatePrepare = 40,
-        NetworkDeviceStateConfig = 50,
-        NetworkDeviceStateNeedAuth = 60,
-        NetworkDeviceStateIpConfig = 70,
-        NetworkDeviceStateIpCheck = 80,
-        NetworkDeviceStateSecondaries = 90,
-        NetworkDeviceStateActivated = 100,
-        NetworkDeviceStateDeactivating = 110,
-        NetworkDeviceStateFailed = 120
-    };
-
-    enum NetworkDeviceStateReason {
-        NetworkDeviceStateReasonNone = 0,
-        NetworkDeviceStateReasonUnknown = 1,
-        NetworkDeviceStateReasonNowManaged = 2,
-        NetworkDeviceStateReasonNowUnmanaged = 3,
-        NetworkDeviceStateReasonConfigFailed = 4,
-        NetworkDeviceStateReasonIpConfigUnavailable = 5,
-        NetworkDeviceStateReasonIpConfigExpired = 6,
-        NetworkDeviceStateReasonNoSecrets = 7,
-        NetworkDeviceStateReasonSupplicantDisconnected = 8,
-        NetworkDeviceStateReasonSupplicantConfigFailed = 9,
-        NetworkDeviceStateReasonSupplicantFailed = 10,
-        NetworkDeviceStateReasonSupplicantTimeout = 11,
-        NetworkDeviceStateReasonPppStartFailed = 12,
-        NetworkDeviceStateReasonPppDisconnected = 13,
-        NetworkDeviceStateReasonPppFailed = 14,
-        NetworkDeviceStateReasonDhcpStartFailed = 15,
-        NetworkDeviceStateReasonDhcpError = 16,
-        NetworkDeviceStateReasonDhcpFailed = 17,
-        NetworkDeviceStateReasonSharedStartFailed = 18,
-        NetworkDeviceStateReasonSharedFailed = 19,
-        NetworkDeviceStateReasonAutoIpStartFailed = 20,
-        NetworkDeviceStateReasonAutoIpError = 21,
-        NetworkDeviceStateReasonAutoIpFailed = 22,
-        NetworkDeviceStateReasonModemBusy = 23,
-        NetworkDeviceStateReasonModemNoDialTone = 24,
-        NetworkDeviceStateReasonModemNoCarrier = 25,
-        NetworkDeviceStateReasonModemDialTimeout = 26,
-        NetworkDeviceStateReasonModemDialFailed = 27,
-        NetworkDeviceStateReasonModemInitFailed = 28,
-        NetworkDeviceStateReasonGsmApnFailed = 29,
-        NetworkDeviceStateReasonGsmRegistrationNotSearching = 30,
-        NetworkDeviceStateReasonGsmRegistrationDenied = 31,
-        NetworkDeviceStateReasonGsmRegistrationTimeout = 32,
-        NetworkDeviceStateReasonGsmRegistrationFailed = 33,
-        NetworkDeviceStateReasonGsmPinCheckFailed = 34,
-        NetworkDeviceStateReasonFirmwareMissing = 35,
-        NetworkDeviceStateReasonRemoved = 36,
-        NetworkDeviceStateReasonSleeping = 37,
-        NetworkDeviceStateReasonConnectionRemoved = 38,
-        NetworkDeviceStateReasonUserRequest = 39,
-        NetworkDeviceStateReasonCarrier = 40,
-        NetworkDeviceStateReasonConnectionAssumed = 41,
-        NetworkDeviceStateReasonSupplicantAvailable = 42,
-        NetworkDeviceStateReasonModemNotFound = 43,
-        NetworkDeviceStateReasonBtFailed = 44,
-        NetworkDeviceStateReasonGsmSimNotInserted = 45,
-        NetworkDeviceStateReasonGsmSimPinRequired = 46,
-        NetworkDeviceStateReasonGsmSimPukRequired = 47,
-        NetworkDeviceStateReasonGsmSimWrong = 48,
-        NetworkDeviceStateReasonInfinibandMode = 49,
-        NetworkDeviceStateReasonDependencyFailed = 50,
-        NetworkDeviceStateReasonBR2684Failed = 51,
-        NetworkDeviceStateReasonModemManagerUnavailable = 52,
-        NetworkDeviceStateReasonSsidNotFound = 53,
-        NetworkDeviceStateReasonSecondaryConnectionFailed = 54,
-        NetworkDeviceStateReasonDcbFoecFailed = 55,
-        NetworkDeviceStateReasonTeamdControlFailed = 56,
-        NetworkDeviceStateReasonModemFailed = 57,
-        NetworkDeviceStateReasonModemAvailable = 58,
-        NetworkDeviceStateReasonSimPinIncorrect = 59,
-        NetworkDeviceStateReasonNewActivision = 60,
-        NetworkDeviceStateReasonParentChanged = 61,
-        NetworkDeviceStateReasonParentManagedChanged = 62
-    };
 
     explicit WirelessNetworkManager(const QDBusObjectPath &objectPath, QObject *parent = 0);
 
-    QDBusObjectPath objectPath() const;
-
-    QString udi() const;
     QString macAddress() const;
-    QString interfaceName() const;
+    int bitrate() const;
-    QString driver() const;
-    QString driverVersion() const;
-
-    bool connected() const;
-    bool managed() const;
-    NetworkDeviceState state() const;
-    NetworkDeviceStateReason stateReason() const;
 
     void scanWirelessNetworks();
 
@@ -143,43 +50,26 @@ public:
     WirelessAccessPoint *getAccessPoint(const QString &ssid);
     WirelessAccessPoint *getAccessPoint(const QDBusObjectPath &objectPath);
 
-    static QString deviceStateToString(const NetworkDeviceState &state);
-    static QString deviceStateReasonToString(const NetworkDeviceStateReason &stateReason);
-
 private:
-    QDBusObjectPath m_objectPath;
+    QDBusInterface *m_wirelessInterface;
-
-    QString m_udi;
     QString m_macAddress;
-    QString m_interfaceName;
+    int m_bitrate;
-    QString m_driver;
-    QString m_driverVersion;
-
-    // Can change
-    bool m_connected;
-    bool m_managed;
-    NetworkDeviceState m_state;
-    NetworkDeviceStateReason m_stateReason;
 
     QHash<QDBusObjectPath, WirelessAccessPoint *> m_accessPointsTable;
 
     void readAccessPoints();
-    void readWirelessDeviceProperties();
 
     void setConnected(const bool &connected);
     void setState(const NetworkDeviceState &state);
     void setStateReason(const NetworkDeviceStateReason &stateReason);
-    void setManaged(const bool &managed);
 
 private slots:
-    void deviceStateChanged(uint newState, uint oldState, uint reason);
     void accessPointAdded(const QDBusObjectPath &objectPath);
     void accessPointRemoved(const QDBusObjectPath &objectPath);
     void propertiesChanged(const QVariantMap &properties);
 
 signals:
     void connectedChanged(const bool &connected);
-    void managedChanged(const bool &managed);
     void stateChanged(const NetworkDeviceState &state);
 };
 

tests/auto/api.json

@@ -1,4 +1,4 @@
-46
+47
 {
     "methods": {
         "Actions.ExecuteAction": {
@@ -471,6 +471,77 @@
                 ]
             }
         },
+        "NetworkManager.ConnectWifiNetwork": {
+            "description": "Connect to the wifi network with the given ssid and password.",
+            "params": {
+                "o:password": "String",
+                "ssid": "String"
+            },
+            "returns": {
+                "networkManagerError": "$ref:NetworkManagerError"
+            }
+        },
+        "NetworkManager.EnableNetworking": {
+            "description": "Enable or disable networking in the NetworkManager.",
+            "params": {
+                "enable": "Bool"
+            },
+            "returns": {
+                "networkManagerError": "$ref:NetworkManagerError"
+            }
+        },
+        "NetworkManager.EnableWirelessNetworking": {
+            "description": "Enable or disable wireless networking in the NetworkManager.",
+            "params": {
+                "enable": "Bool"
+            },
+            "returns": {
+                "networkManagerError": "$ref:NetworkManagerError"
+            }
+        },
+        "NetworkManager.GetNetworkDevices": {
+            "description": "Get the list of current network devices.",
+            "params": {
+            },
+            "returns": {
+                "networkManagerError": "$ref:NetworkManagerError",
+                "o:networkDevices": [
+                    "$ref:NetworkDevice"
+                ]
+            }
+        },
+        "NetworkManager.GetNetworkStatus": {
+            "description": "Get the current network manager status.",
+            "params": {
+            },
+            "returns": {
+                "networkManagerError": "$ref:NetworkManagerError",
+                "o:status": {
+                    "networkingEnabled": "Bool",
+                    "state": "$ref:NetworkManagerState",
+                    "wirelessNetworkingEnabled": "Bool"
+                }
+            }
+        },
+        "NetworkManager.GetWirelessAccessPoints": {
+            "description": "Get the current list of wireless network access points.",
+            "params": {
+            },
+            "returns": {
+                "networkManagerError": "$ref:NetworkManagerError",
+                "o:wirelessAccessPoints": [
+                    "$ref:WirelessAccessPoint"
+                ]
+            }
+        },
+        "NetworkManager.ScanWifiNetworks": {
+            "description": "Start a wifi scan for searching new networks.",
+            "params": {
+            },
+            "returns": {
+                "networkManagerError": "$ref:NetworkManagerError"
+            }
+        },
         "Rules.AddRule": {
             "description": "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that only one of either eventDescriptor or eventDescriptorList may be passed at a time. A rule can be created but left disabled, meaning it won't actually be executed until set to enabled. If not given, enabled defaults to true.",
             "params": {
@@ -694,6 +765,34 @@
                 "logEntry": "$ref:LogEntry"
             }
         },
+        "NetworkManager.NetworkDeviceAdded": {
+            "description": "Emitted whenever a new NetworkDevice was added.",
+            "params": {
+                "networkDevice": "$ref:NetworkDevice"
+            }
+        },
+        "NetworkManager.NetworkDeviceChanged": {
+            "description": "Emitted whenever a NetworkDevice has changed.",
+            "params": {
+                "networkDevice": "$ref:NetworkDevice"
+            }
+        },
+        "NetworkManager.NetworkDeviceRemoved": {
+            "description": "Emitted whenever a NetworkDevice was removed.",
+            "params": {
+                "networkDevice": "$ref:NetworkDevice"
+            }
+        },
+        "NetworkManager.NetworkStatusChanged": {
+            "description": "Emitted whenever a status of a NetworkManager changes.",
+            "params": {
+                "status": {
+                    "networkingEnabled": "Bool",
+                    "state": "$ref:NetworkManagerState",
+                    "wirelessNetworkingEnabled": "Bool"
+                }
+            }
+        },
         "Rules.RuleActiveChanged": {
             "description": "Emitted whenever the active state of a Rule changed.",
             "params": {
@@ -983,6 +1082,30 @@
             "LoggingSourceStates",
             "LoggingSourceRules"
         ],
+        "NetworkDevice": {
+            "name": "String",
+            "type": "String"
+        },
+        "NetworkManagerError": [
+            "NetworkManagerErrorNoError",
+            "NetworkManagerErrorUnknownError",
+            "NetworkManagerErrorWirelessNotAvailable",
+            "NetworkManagerErrorAccessPointNotFound",
+            "NetworkManagerErrorWirelessNetworkingDisabled",
+            "NetworkManagerErrorWirelessConnectionFailed",
+            "NetworkManagerErrorNetworkingDisabled",
+            "NetworkManagerErrorNetworkManagerNotAvailable"
+        ],
+        "NetworkManagerState": [
+            "NetworkManagerStateUnknown",
+            "NetworkManagerStateAsleep",
+            "NetworkManagerStateDisconnected",
+            "NetworkManagerStateDisconnecting",
+            "NetworkManagerStateConnecting",
+            "NetworkManagerStateConnectedLocal",
+            "NetworkManagerStateConnectedSite",
+            "NetworkManagerStateConnectedGlobal"
+        ],
         "Param": {
             "paramTypeId": "Uuid",
             "value": "$ref:BasicType"
@@ -1214,6 +1337,12 @@
         "Vendor": {
             "id": "Uuid",
             "name": "String"
+        },
+        "WirelessAccessPoint": {
+            "frequency": "Double",
+            "macAddress": "String",
+            "signalStrength": "Int",
+            "ssid": "String"
         }
     }
 }

tests/auto/auto.pro

@@ -17,6 +17,5 @@ SUBDIRS = versioning \
         websocketserver \
         logging \
         restlogging \
-        coap \
+        #coap \
-        timemanager \
         configurations \