ETM-Schurig/powersync-core
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wifi connection working

Browse Source
This commit is contained in:
Simon Stürz 2016-10-03 21:27:44 +02:00 committed by Michael Zanetti
parent 22d5dc1bf6
commit 00121d66c3
15 changed files with 318 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
server/guhcore.cpp
View File

@ -461,7 +461,11 @@ GuhCore::GuhCore(QObject *parent) :
m_webServer = new WebServer(m_configuration->webServerAddress(), m_configuration->webServerPort(), m_configuration->webServerPublicFolder(), this);
m_serverManager->restServer()->registerWebserver(m_webServer);
m_networkManager = new NetworkManager(this);
if (!NetworkManager::available()) {
m_networkManager = 0;
} else {
m_networkManager = new NetworkManager(this);
}
// Connect the configuration changes
connect(m_configuration, &GuhConfiguration::cloudEnabledChanged, m_cloudManager, &CloudManager::onCloudEnabledChanged);

33
server/jsonrpc/jsontypes.cpp
View File

@ -84,6 +84,7 @@ QVariantList JsonTypes::s_loggingEventType;
QVariantList JsonTypes::s_repeatingMode;
QVariantList JsonTypes::s_cloudError;
QVariantList JsonTypes::s_configurationError;
QVariantList JsonTypes::s_networkManagerState;
QVariantMap JsonTypes::s_paramType;
QVariantMap JsonTypes::s_param;
@ -112,10 +113,11 @@ QVariantMap JsonTypes::s_calendarItem;
QVariantMap JsonTypes::s_timeEventItem;
QVariantMap JsonTypes::s_repeatingOption;
QVariantMap JsonTypes::s_wirelessAccessPoint;
QVariantMap JsonTypes::s_networkDevice;
void JsonTypes::init()
{
// BasicTypes
// Enums
s_basicType = enumToStrings(JsonTypes::staticMetaObject, "BasicType");
s_stateOperator = enumToStrings(Types::staticMetaObject, "StateOperator");
s_valueOperator = enumToStrings(Types::staticMetaObject, "ValueOperator");
@ -135,6 +137,7 @@ void JsonTypes::init()
s_repeatingMode = enumToStrings(RepeatingOption::staticMetaObject, "RepeatingMode");
s_cloudError = enumToStrings(Cloud::staticMetaObject, "CloudError");
s_configurationError = enumToStrings(GuhConfiguration::staticMetaObject, "ConfigurationError");
s_networkManagerState = enumToStrings(NetworkManager::staticMetaObject, "NetworkManagerState");
// ParamType
s_paramType.insert("id", basicTypeToString(Uuid));
@ -321,11 +324,16 @@ void JsonTypes::init()
s_repeatingOption.insert("o:weekDays", QVariantList() << basicTypeToString(Int));
s_repeatingOption.insert("o:monthDays", QVariantList() << basicTypeToString(Int));
// WirelessAccessPoint
s_wirelessAccessPoint.insert("ssid", basicTypeToString(QVariant::String));
s_wirelessAccessPoint.insert("macAddress", basicTypeToString(QVariant::String));
s_wirelessAccessPoint.insert("frequency", basicTypeToString(QVariant::Double));
s_wirelessAccessPoint.insert("signalStrength", basicTypeToString(QVariant::Int));
// NetworkDevice
s_networkDevice.insert("name", basicTypeToString(QVariant::String));
s_networkDevice.insert("type", basicTypeToString(QVariant::String));
s_initialized = true;
}
@ -371,6 +379,7 @@ QVariantMap JsonTypes::allTypes()
allTypes.insert("RepeatingMode", repeatingMode());
allTypes.insert("CloudError", cloudError());
allTypes.insert("ConfigurationError", configurationError());
allTypes.insert("NetworkManagerState", networkManagerState());
allTypes.insert("StateType", stateTypeDescription());
allTypes.insert("StateDescriptor", stateDescriptorDescription());
@ -398,6 +407,7 @@ QVariantMap JsonTypes::allTypes()
allTypes.insert("TimeEventItem", timeEventItemDescription());
allTypes.insert("RepeatingOption", repeatingOptionDescription());
allTypes.insert("WirelessAccessPoint", wirelessAccessPointDescription());
allTypes.insert("NetworkDevice", networkDeviceDescription());
return allTypes;
}
@ -962,6 +972,14 @@ QVariantMap JsonTypes::packWirelessAccessPoint(WirelessAccessPoint *wirelessAcce
return wirelessAccessPointVariant;
}
QVariantMap JsonTypes::packNetworkDevice(NetworkDevice *networkDevice)
{
QVariantMap networkDeviceVariant;
networkDeviceVariant.insert("name", networkDevice->interface());
networkDeviceVariant.insert("type", NetworkDevice::deviceTypeToString(networkDevice->deviceType()));
return networkDeviceVariant;
}
/*! Returns a variant list of the supported vendors. */
QVariantList JsonTypes::packSupportedVendors()
{
@ -1726,6 +1744,12 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
qCWarning(dcJsonRpc) << "WirelessAccessPoint not matching";
return result;
}
} else if (refName == networkDeviceRef()) {
QPair<bool, QString> result = validateMap(networkDeviceDescription(), variant.toMap());
if (!result.first) {
qCWarning(dcJsonRpc) << "NetworkDevice not matching";
return result;
}
} else if (refName == basicTypeRef()) {
QPair<bool, QString> result = validateBasicType(variant);
if (!result.first) {
@ -1834,6 +1858,12 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(configurationErrorRef());
return result;
}
} else if (refName == networkManagerStateRef()) {
QPair<bool, QString> result = validateEnum(s_networkManagerState, variant);
if (!result.first) {
qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(networkManagerStateRef());
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));
@ -1896,6 +1926,7 @@ QPair<bool, QString> JsonTypes::validateBasicType(const QVariant &variant)
if (variant.canConvert(QVariant::Time) && QVariant(variant).convert(QVariant::Time)) {
return report(true, "");
}
return report(false, QString("Error validating basic type %1.").arg(variant.toString()));
}

5
server/jsonrpc/jsontypes.h
View File

@ -47,6 +47,8 @@
#include "cloud/cloudconnection.h"
#include "networkmanager/networkmanager.h"
#include "networkmanager/networkdevice.h"
#include "networkmanager/wirelessaccesspoint.h"
#include <QObject>
@ -129,6 +131,7 @@ public:
DECLARE_TYPE(repeatingMode, "RepeatingMode", RepeatingOption, RepeatingMode)
DECLARE_TYPE(cloudError, "CloudError", Cloud, CloudError)
DECLARE_TYPE(configurationError, "ConfigurationError", GuhConfiguration, ConfigurationError)
DECLARE_TYPE(networkManagerState, "NetworkManagerState", NetworkManager, NetworkManagerState)
DECLARE_OBJECT(paramType, "ParamType")
DECLARE_OBJECT(param, "Param")
@ -157,6 +160,7 @@ public:
DECLARE_OBJECT(timeEventItem, "TimeEventItem")
DECLARE_OBJECT(repeatingOption, "RepeatingOption")
DECLARE_OBJECT(wirelessAccessPoint, "WirelessAccessPoint")
DECLARE_OBJECT(networkDevice, "NetworkDevice")
// pack types
static QVariantMap packEventType(const EventType &eventType);
@ -186,6 +190,7 @@ public:
static QVariantMap packTimeEventItem(const TimeEventItem &timeEventItem);
static QVariantMap packTimeDescriptor(const TimeDescriptor &timeDescriptor);
static QVariantMap packWirelessAccessPoint(WirelessAccessPoint *wirelessAccessPoint);
static QVariantMap packNetworkDevice(NetworkDevice *networkDevice);
// pack resources
static QVariantList packRules(const QList<Rule> rules);

90
server/jsonrpc/networkmanagerhandler.cpp
View File

@ -36,7 +36,35 @@ NetworkManagerHandler::NetworkManagerHandler(QObject *parent) :
setDescription("GetWirelessAccessPoints", "Get the current list of wireless network access points.");
setParams("GetWirelessAccessPoints", params);
returns.insert("wirelessAccessPoints", QVariantList() << JsonTypes::wirelessAccessPointRef());
returns.insert("o:networkError", QVariantList() << JsonTypes::wirelessAccessPointRef());
setReturns("GetWirelessAccessPoints", returns);
params.clear(); returns.clear();
setDescription("GetNetworkStatus", "Get the current network manager status.");
setParams("GetNetworkStatus", params);
returns.insert("networkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool));
returns.insert("wirelessNetworkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool));
returns.insert("state", JsonTypes::networkManagerStateRef());
setReturns("GetNetworkStatus", returns);
params.clear(); returns.clear();
setDescription("GetNetworkDevices", "Get the list of current network devices.");
setParams("GetNetworkDevices", params);
returns.insert("networkDevices", QVariantList() << JsonTypes::networkDeviceRef());
setReturns("GetNetworkDevices", returns);
params.clear(); returns.clear();
setDescription("ScanWifiNetworks", "Start a wifi scan for searching new networks.");
setParams("ScanWifiNetworks", params);
setReturns("ScanWifiNetworks", returns);
params.clear(); returns.clear();
setDescription("ConnectWifiNetwork", "Connect to the wifi network with the given ssid and password.");
params.insert("ssid", JsonTypes::basicTypeToString(QVariant::String));
params.insert("o:password", JsonTypes::basicTypeToString(QVariant::String));
setParams("ConnectWifiNetwork", params);
//returns.insert("networkDevices", QVariantList() << JsonTypes::networkDeviceRef());
setReturns("ConnectWifiNetwork", returns);
}
QString NetworkManagerHandler::name() const
@ -44,11 +72,29 @@ QString NetworkManagerHandler::name() const
return "NetworkManager";
}
JsonReply *NetworkManagerHandler::GetNetworkStatus(const QVariantMap &params)
{
Q_UNUSED(params);
// TODO: check available
// TODO: returns (networkManager error)
QVariantMap returns;
returns.insert("networkingEnabled", GuhCore::instance()->networkManager()->networkingEnabled());
returns.insert("wirelessNetworkingEnabled", GuhCore::instance()->networkManager()->wirelessEnabled());
returns.insert("state", JsonTypes::networkManagerStateToString(GuhCore::instance()->networkManager()->state()));
return createReply(returns);
}
JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap &params)
{
Q_UNUSED(params);
QVariantList wirelessAccessPoints;
// TODO: check available
// TODO: returns (networkManager error)
foreach (WirelessAccessPoint *wirelessAccessPoint, GuhCore::instance()->networkManager()->wirelessNetworkManager()->accessPoints())
wirelessAccessPoints.append(JsonTypes::packWirelessAccessPoint(wirelessAccessPoint));
@ -57,4 +103,48 @@ JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap &par
return createReply(returns);
}
JsonReply *NetworkManagerHandler::GetNetworkDevices(const QVariantMap &params)
{
Q_UNUSED(params);
QVariantList networkDevices;
// TODO: check available
// TODO: returns (networkManager error)
foreach (NetworkDevice *networkDevice, GuhCore::instance()->networkManager()->networkDevices())
networkDevices.append(JsonTypes::packNetworkDevice(networkDevice));
QVariantMap returns;
returns.insert("networkDevices", networkDevices);
return createReply(returns);
}
JsonReply *NetworkManagerHandler::ScanWifiNetworks(const QVariantMap &params)
{
Q_UNUSED(params);
// TODO: check available
// TODO: returns (networkManager error)
GuhCore::instance()->networkManager()->wirelessNetworkManager()->scanWirelessNetworks();
QVariantMap returns;
return createReply(returns);
}
JsonReply *NetworkManagerHandler::ConnectWifiNetwork(const QVariantMap &params)
{
QString ssid = params.value("ssid").toString();
QString password = params.value("password").toString();
// TODO: check available
// TODO: returns (networkManager error)
GuhCore::instance()->networkManager()->connectWifi(ssid, password);
QVariantMap returns;
return createReply(returns);
}
}

4
server/jsonrpc/networkmanagerhandler.h
View File

@ -35,7 +35,11 @@ public:
QString name() const;
Q_INVOKABLE JsonReply *GetNetworkStatus(const QVariantMap &params);
Q_INVOKABLE JsonReply *GetWirelessAccessPoints(const QVariantMap &params);
Q_INVOKABLE JsonReply *GetNetworkDevices(const QVariantMap &params);
Q_INVOKABLE JsonReply *ScanWifiNetworks(const QVariantMap &params);
Q_INVOKABLE JsonReply *ConnectWifiNetwork(const QVariantMap &params);
signals:

51
server/networkmanager/networkconnection.cpp
View File

@ -48,11 +48,7 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject
return;
const QDBusArgument &argument = query.arguments().at(0).value<QDBusArgument>();
ConnectionSettings settingsMap = qdbus_cast<ConnectionSettings>(argument);
foreach (const QString &category, settingsMap.keys())
if (category == "connection")
qCDebug(dcNetworkManager()) << " --> " << category << qUtf8Printable(QJsonDocument::fromVariant(settingsMap.value(category)).toJson(QJsonDocument::Indented));
m_connectionSettings = qdbus_cast<ConnectionSettings>(argument);
}
@ -61,4 +57,49 @@ QDBusObjectPath NetworkConnection::objectPath() const
return m_objectPath;
}
QString NetworkConnection::id() const
{
return m_connectionSettings.value("connection").value("id").toString();
}
QString NetworkConnection::name() const
{
return m_connectionSettings.value("connection").value("name").toString();
}
QString NetworkConnection::type() const
{
return m_connectionSettings.value("connection").value("type").toString();
}
QUuid NetworkConnection::uuid() const
{
return m_connectionSettings.value("connection").value("uuid").toUuid();
}
QString NetworkConnection::interfaceName() const
{
return m_connectionSettings.value("connection").value("interface-name").toString();
}
bool NetworkConnection::autoconnect() const
{
return m_connectionSettings.value("connection").value("autoconnect").toBool();
}
QDateTime NetworkConnection::timeStamp() const
{
return QDateTime::fromTime_t(m_connectionSettings.value("connection").value("timestamp").toUInt());
}
QDebug operator<<(QDebug debug, NetworkConnection *networkConnection)
{
debug.nospace() << "NetworkConnection(" << networkConnection->id() << ", ";
debug.nospace() << networkConnection->uuid().toString() << ", ";
debug.nospace() << networkConnection->interfaceName() << ", ";
debug.nospace() << networkConnection->type() << ", ";
debug.nospace() << networkConnection->timeStamp().toString("dd.MM.yyyy hh:mm") << ") ";
return debug;
}
}

16
server/networkmanager/networkconnection.h
View File

@ -21,8 +21,10 @@
#ifndef NETWORKCONNECTION_H
#define NETWORKCONNECTION_H
#include <QUuid>
#include <QDebug>
#include <QObject>
#include <QDateTime>
#include <QDBusMetaType>
#include <QDBusObjectPath>
#include <QDBusConnection>
@ -41,15 +43,29 @@ public:
QDBusObjectPath objectPath() const;
ConnectionSettings connectionSettings() const;
QString id() const;
QString name() const;
QString type() const;
QUuid uuid() const;
QString interfaceName() const;
bool autoconnect() const;
QDateTime timeStamp() const;
private:
QDBusObjectPath m_objectPath;
ConnectionSettings m_connectionSettings;
signals:
public slots:
};
QDebug operator<<(QDebug debug, NetworkConnection *networkConnection);
}
Q_DECLARE_METATYPE(guhserver::ConnectionSettings)

1
server/networkmanager/networkdevice.cpp
View File

@ -33,7 +33,6 @@ NetworkDevice::NetworkDevice(const QDBusObjectPath &objectPath, QObject *parent)
m_deviceState(DeviceStateUnknown),
m_deviceStateReason(DeviceStateReasonUnknown)
{
QDBusConnection systemBus = QDBusConnection::systemBus();
if (!systemBus.isConnected()) {
qCWarning(dcNetworkManager()) << "NetworkDevice: System DBus not connected";

1
server/networkmanager/networkdevice.h
View File

@ -169,7 +169,6 @@ public:
static QString deviceStateToString(const DeviceState &deviceState);
static QString deviceStateReasonToString(const DeviceStateReason &deviceStateReason);
private:
QDBusObjectPath m_objectPath;

67
server/networkmanager/networkmanager.cpp
View File

@ -21,13 +21,21 @@
#include "networkmanager.h"
#include "loggingcategories.h"
#include "networkconnection.h"
#include <QMetaEnum>
#include <QUuid>
namespace guhserver {
NetworkManager::NetworkManager(QObject *parent) :
QObject(parent),
m_wirelessNetworkManager(0)
m_networkManagerInterface(0),
m_wirelessNetworkManager(0),
m_state(NetworkManagerStateUnknown),
m_connectivityState(NetworkManagerConnectivityStateUnknown),
m_networkingEnabled(false),
m_wirelessEnabled(false)
{
// Create interface
m_networkManagerInterface = new QDBusInterface(serviceString, pathString, serviceString, QDBusConnection::systemBus(), this);
@ -115,6 +123,63 @@ NetworkManager::NetworkManagerConnectivityState NetworkManager::connectivityStat
return m_connectivityState;
}
NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &ssid, const QString &password)
{
// https://developer.gnome.org/NetworkManager/stable/ref-settings.html
QVariantMap connectionSettings;
connectionSettings.insert("autoconnect", true);
connectionSettings.insert("id", ssid +" (guhIO)");
connectionSettings.insert("type", "802-11-wireless");
QVariantMap wirelessSettings;
wirelessSettings.insert("ssid", ssid.toUtf8());
wirelessSettings.insert("security", "802-11-wireless-security");
wirelessSettings.insert("mode", "infrastructure");
QVariantMap wirelessSecuritySettings;
wirelessSecuritySettings.insert("auth-alg", "open");
wirelessSecuritySettings.insert("key-mgmt", "wpa-psk");
wirelessSecuritySettings.insert("psk", password);
QVariantMap ipv4Settings;
ipv4Settings.insert("method", "auto");
QVariantMap ipv6Settings;
ipv6Settings.insert("method", "auto");
// Build connection object
ConnectionSettings settings;
settings.insert("connection", connectionSettings);
settings.insert("802-11-wireless", wirelessSettings);
settings.insert("802-11-wireless-security", wirelessSecuritySettings);
settings.insert("ipv4", ipv4Settings);
settings.insert("ipv6", ipv6Settings);
// Get the access point object path
WirelessAccessPoint *accessPoint = m_wirelessNetworkManager->getAccessPoint(ssid);
if (!accessPoint) {
qCWarning(dcNetworkManager()) << "Could not find access point with ssid:" << ssid;
return NetworkManagerErrorAccessPointNotFound;
}
// Add connection
QDBusObjectPath connectionObjectPath = m_networkSettings->addConnection(settings);
if (connectionObjectPath.path().isEmpty())
return NetworkManagerErrorWirelessConnectionFailed;
// Activate connection
QDBusMessage query = m_networkManagerInterface->call("ActivateConnection", QVariant::fromValue(connectionObjectPath),
QVariant::fromValue(m_wirelessNetworkManager->objectPath()),
QVariant::fromValue(accessPoint->objectPath()));
if(query.type() != QDBusMessage::ReplyMessage) {
qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
return NetworkManagerErrorWirelessConnectionFailed;
}
return NetworkManagerErrorNoError;
}
bool NetworkManager::networkingEnabled() const
{
return m_networkingEnabled;

16
server/networkmanager/networkmanager.h
View File

@ -42,6 +42,7 @@ class NetworkManager : public QObject
Q_OBJECT
Q_ENUMS(NetworkManagerState)
Q_ENUMS(NetworkManagerConnectivityState)
Q_ENUMS(NetworkManagerError)
public:
enum NetworkManagerState {
@ -63,6 +64,16 @@ public:
NetworkManagerConnectivityStateFull = 5
};
enum NetworkManagerError {
NetworkManagerErrorNoError,
NetworkManagerErrorWirelessNotAvailable,
NetworkManagerErrorAccessPointNotFound,
NetworkManagerErrorWirelessNetworkingDisabled,
NetworkManagerErrorWirelessConnectionFailed,
NetworkManagerErrorNetworkingDisabled,
NetworkManagerErrorNetworkManagerNotAvailable
};
explicit NetworkManager(QObject *parent = 0);
static bool available();
@ -73,11 +84,16 @@ public:
WirelessNetworkManager *wirelessNetworkManager() const;
QString stateToTranslatedString() const;
// Properties
QString version() const;
NetworkManagerState state() const;
NetworkManagerConnectivityState connectivityState() const;
NetworkManagerError connectWifi(const QString &ssid, const QString &password);
// Networking
bool networkingEnabled() const;
bool enableNetworking();

19
server/networkmanager/networksettings.cpp
View File

@ -21,7 +21,6 @@
#include "networksettings.h"
#include "dbus-interfaces.h"
#include "loggingcategories.h"
#include "networkconnection.h"
namespace guhserver {
@ -38,12 +37,24 @@ NetworkSettings::NetworkSettings(QObject *parent) : QObject(parent)
QDBusConnection::systemBus().connect(serviceString, settingsPathString, settingsInterfaceString, "NewConnection", this, SLOT(connectionAdded(QDBusObjectPath)));
QDBusConnection::systemBus().connect(serviceString, settingsPathString, settingsInterfaceString, "ConnectionRemoved", this, SLOT(connectionRemoved(QDBusObjectPath)));
QDBusConnection::systemBus().connect(serviceString, settingsPathString, settingsInterfaceString, "PropertiesChanged", this, SLOT(propertiesChanged(QVariantMap)));
}
QDBusObjectPath NetworkSettings::addConnection(const ConnectionSettings &settings)
{
QDBusMessage query = m_settingsInterface->call("AddConnection", QVariant::fromValue(settings));
if(query.type() != QDBusMessage::ReplyMessage) {
qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
return QDBusObjectPath();
}
if (query.arguments().isEmpty())
return QDBusObjectPath();
return query.arguments().at(0).value<QDBusObjectPath>();
}
void NetworkSettings::loadConnections()
{
// Get
QDBusMessage query = m_settingsInterface->call("ListConnections");
if(query.type() != QDBusMessage::ReplyMessage) {
qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
@ -65,12 +76,10 @@ void NetworkSettings::loadConnections()
void NetworkSettings::connectionAdded(const QDBusObjectPath &objectPath)
{
NetworkConnection *connection = new NetworkConnection(objectPath, this);
m_connections.insert(objectPath, connection);
qCDebug(dcNetworkManager()) << "Settings: [+]" << objectPath.path();
qCDebug(dcNetworkManager()) << "Settings: [+]" << connection;
}
void NetworkSettings::connectionRemoved(const QDBusObjectPath &objectPath)

4
server/networkmanager/networksettings.h
View File

@ -27,6 +27,8 @@
#include <QDBusInterface>
#include <QDBusArgument>
#include "networkconnection.h"
namespace guhserver {
class NetworkConnection;
@ -37,6 +39,8 @@ class NetworkSettings : public QObject
public:
explicit NetworkSettings(QObject *parent = 0);
QDBusObjectPath addConnection(const ConnectionSettings &settings);
private:
QDBusInterface *m_settingsInterface;
QHash<QDBusObjectPath, NetworkConnection *> m_connections;

25
server/networkmanager/wirelessnetworkmanager.cpp
View File

@ -24,12 +24,13 @@
#include "loggingcategories.h"
#include <QMetaEnum>
#include <QUuid>
namespace guhserver {
WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &devicePath, QObject *parent) :
WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &objectPath, QObject *parent) :
QObject(parent),
m_path(devicePath.path()),
m_objectPath(objectPath),
m_connected(false),
m_managed(false),
m_state(DeviceStateUnknown),
@ -41,9 +42,9 @@ WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &devicePath
return;
}
QDBusConnection::systemBus().connect(serviceString, m_path, wirelessInterfaceString, "AccessPointAdded", this, SLOT(accessPointAdded(QDBusObjectPath)));
QDBusConnection::systemBus().connect(serviceString, m_path, wirelessInterfaceString, "AccessPointRemoved", this, SLOT(accessPointRemoved(QDBusObjectPath)));
QDBusConnection::systemBus().connect(serviceString, m_path, deviceInterfaceString, "StateChanged", this, SLOT(deviceStateChanged(quint32,quint32,quint32)));
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();
@ -52,6 +53,11 @@ WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &devicePath
readAccessPoints();
}
QDBusObjectPath WirelessNetworkManager::objectPath() const
{
return m_objectPath;
}
QString WirelessNetworkManager::udi() const
{
return m_udi;
@ -105,7 +111,7 @@ void WirelessNetworkManager::scanWirelessNetworks()
return;
}
QDBusInterface wirelessInterface(serviceString, m_path, wirelessInterfaceString, systemBus);
QDBusInterface wirelessInterface(serviceString, m_objectPath.path(), wirelessInterfaceString, systemBus);
if(!wirelessInterface.isValid()) {
qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not scan wireless networks: Invalid wireless dbus interface";
return;
@ -118,6 +124,7 @@ void WirelessNetworkManager::scanWirelessNetworks()
}
}
QList<WirelessAccessPoint *> WirelessNetworkManager::accessPoints()
{
return m_accessPointsTable.values();
@ -155,7 +162,7 @@ QString WirelessNetworkManager::deviceStateReasonToString(const WirelessNetworkM
void WirelessNetworkManager::readAccessPoints()
{
QDBusInterface wirelessInterface(serviceString, m_path, wirelessInterfaceString, QDBusConnection::systemBus());
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;
@ -181,13 +188,13 @@ void WirelessNetworkManager::readAccessPoints()
void WirelessNetworkManager::readWirelessDeviceProperties()
{
QDBusInterface wirelessInterface(serviceString, m_path, wirelessInterfaceString, QDBusConnection::systemBus());
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_path, deviceInterfaceString, QDBusConnection::systemBus());
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;

6
server/networkmanager/wirelessnetworkmanager.h
View File

@ -122,7 +122,9 @@ public:
DeviceStateReasonParentManagedChanged = 62
};
explicit WirelessNetworkManager(const QDBusObjectPath &devicePath, QObject *parent = 0);
explicit WirelessNetworkManager(const QDBusObjectPath &objectPath, QObject *parent = 0);
QDBusObjectPath objectPath() const;
QString udi() const;
QString macAddress() const;
@ -145,7 +147,7 @@ public:
static QString deviceStateReasonToString(const DeviceStateReason &stateReason);
private:
QString m_path;
QDBusObjectPath m_objectPath;
QString m_udi;
QString m_macAddress;