Commit 8658e741 authored by Lamarque Souza's avatar Lamarque Souza
Browse files

Use asynchronous DBus API in plasmoid and kded module communication.

parent 9b783b4b
/*
Copyright 2009 Dario Freddi <drf54321@gmail.com>
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
......@@ -158,6 +159,18 @@ void NetworkManagementService::finishInitialization()
// ideally this will always be deleted before the other list
d->networkInterfaceMonitor = new NetworkInterfaceMonitor(d->connectionList, d->activatableList, d->activatableList);
d->nm08Connections = new Nm08Connections(d->secretStorage, d->nmDBusConnectionProvider);
d->nm08Connections->importNextNm08Connection();
// give some time for the ActivatableAdded signal be processed before we emit the activationStateChanged
// and hasDefaultRouteChanged signals from d->nmActiveConnectionMonitor.
QTimer::singleShot(1000, this, SLOT(delayedRegisterObservers()));
}
void NetworkManagementService::delayedRegisterObservers()
{
Q_D(NetworkManagementService);
// create ActiveConnectionMonitor after construction of NMDBusSettingsConnectionProvider and observer registrations
// because, activatableList is filled in NetworkManager::DeviceMonitor and updated in registerObservers above. This is why "Auto eth0" connection created automatically by NM has
// Unknown activationState in its /org/kde/networkmanagement/Activatable interface
......@@ -166,7 +179,4 @@ void NetworkManagementService::finishInitialization()
// register after nmSettingsService and nmDBusConnectionProvider because it relies on changes they
// make to interfaceconnections
d->activatableList->registerObserver(d->nmActiveConnectionMonitor);
d->nm08Connections = new Nm08Connections(d->secretStorage, d->nmDBusConnectionProvider);
d->nm08Connections->importNextNm08Connection();
}
/*
Copyright 2009 Dario Freddi <drf54321@gmail.com>
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
......@@ -37,6 +38,7 @@ public:
virtual ~NetworkManagementService();
private Q_SLOTS:
void finishInitialization();
void delayedRegisterObservers();
private:
NetworkManagementServicePrivate * d_ptr;
};
......
/*
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -28,20 +29,16 @@ RemoteActivatablePrivate::~RemoteActivatablePrivate()
}
RemoteActivatable::RemoteActivatable(RemoteActivatablePrivate & dd, const QString &dbusPath, QObject * parent)
RemoteActivatable::RemoteActivatable(RemoteActivatablePrivate & dd, const QVariantMap &properties, QObject * parent)
: QObject(parent), d_ptr(&dd)
{
Q_D(RemoteActivatable);
d->activatableIface = new ActivatableInterface("org.kde.networkmanagement", dbusPath, QDBusConnection::sessionBus(), this);
init();
init(properties);
}
RemoteActivatable::RemoteActivatable(const QString &dbusPath, QObject * parent)
RemoteActivatable::RemoteActivatable(const QVariantMap &properties, QObject * parent)
: QObject(parent), d_ptr(new RemoteActivatablePrivate)
{
Q_D(RemoteActivatable);
d->activatableIface = new ActivatableInterface("org.kde.networkmanagement", dbusPath, QDBusConnection::sessionBus(), this);
init();
init(properties);
}
RemoteActivatable::~RemoteActivatable()
......@@ -49,28 +46,44 @@ RemoteActivatable::~RemoteActivatable()
delete d_ptr;
}
void RemoteActivatable::init()
void RemoteActivatable::init(const QVariantMap & properties)
{
Q_D(RemoteActivatable);
d->activatableIface = new ActivatableInterface("org.kde.networkmanagement", properties["path"].toString(), QDBusConnection::sessionBus(), this);
//kDebug() << "ActivatableInterface is (" << d->activatableIface << ") on" << d_ptr;
connect(d->activatableIface, SIGNAL(activated()),
this, SIGNAL(activated()));
connect(d->activatableIface, SIGNAL(changed()),
this, SIGNAL(changed()));
connect(d->activatableIface, SIGNAL(propertiesChanged(QVariantMap)), SLOT(propertiesChanged(QVariantMap)));
QDBusReply<QString> reply = d->activatableIface->deviceUni();
if (reply.isValid()) {
d->deviceUni = reply.value();
} else {
kDebug() << "deviceUni reply is invalid";
}
propertiesChanged(properties);
}
QDBusReply<uint> reply2 = d->activatableIface->activatableType();
if (reply2.isValid()) {
d->activatableType = (Knm::Activatable::ActivatableType)reply2.value();
} else {
d->activatableType = Knm::Activatable::InterfaceConnection;
kDebug() << "activatableType reply is invalid";
void RemoteActivatable::propertiesChanged(const QVariantMap &changedProperties)
{
Q_D(RemoteActivatable);
QStringList propKeys = changedProperties.keys();
QLatin1String deviceUniKey("deviceUni"),
activatableTypeKey("activatableType"),
sharedKey("shared");
QVariantMap::const_iterator it = changedProperties.find(deviceUniKey);
if (it != changedProperties.end()) {
d->deviceUni = it->toString();
propKeys.removeOne(deviceUniKey);
}
it = changedProperties.find(activatableTypeKey);
if (it != changedProperties.end()) {
d->activatableType = (Knm::Activatable::ActivatableType)it->toUInt();
propKeys.removeOne(activatableTypeKey);
}
it = changedProperties.find(sharedKey);
if (it != changedProperties.end()) {
d->shared = it->toBool();
propKeys.removeOne(sharedKey);
}
if (propKeys.count()) {
kDebug() << "Unhandled properties: " << propKeys;
}
}
......@@ -89,14 +102,7 @@ QString RemoteActivatable::deviceUni() const
bool RemoteActivatable::isShared() const
{
Q_D(const RemoteActivatable);
if (!d->activatableIface->isValid()) {
return false;
}
QDBusReply<bool> reply = d->activatableIface->isShared();
if (reply.isValid()) {
return reply.value();
}
return false;
return d->shared;
}
void RemoteActivatable::activate()
......
/*
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -51,13 +52,15 @@ public Q_SLOTS:
Q_SIGNALS:
void activated();
void changed();
protected Q_SLOTS:
void propertiesChanged(const QVariantMap &properties);
protected:
Q_DECLARE_PRIVATE(RemoteActivatable)
RemoteActivatable(const QString &dbusPath, QObject * parent);
RemoteActivatable(RemoteActivatablePrivate & dd, const QString &dbusPath, QObject * parent);
RemoteActivatable(const QVariantMap &properties, QObject * parent);
RemoteActivatable(RemoteActivatablePrivate & dd, const QVariantMap &properties, QObject * parent);
RemoteActivatablePrivate * d_ptr;
private:
void init();
void init(const QVariantMap & properties);
};
#endif // REMOTEACTIVATABLE_H
/*
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -30,6 +31,7 @@ public:
ActivatableInterface * activatableIface;
QString deviceUni;
Knm::Activatable::ActivatableType activatableType;
bool shared;
};
#endif // REMOTEACTIVATABLE_P_H
/*
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -70,27 +71,13 @@ void RemoteActivatableList::init()
{
Q_D(RemoteActivatableList);
if (d->iface->isValid()) {
connect(d->iface, SIGNAL(ActivatableAdded(QString,uint,int)),
this, SLOT(handleActivatableAdded(QString,uint,int)));
connect(d->iface, SIGNAL(ActivatableAdded(QVariantMap)),
this, SLOT(handleActivatableAdded(QVariantMap)));
connect(d->iface, SIGNAL(ActivatableRemoved(QString)),
this, SLOT(handleActivatableRemoved(QString)));
if (d->activatables.isEmpty()) {
QDBusReply<QStringList> rv = d->iface->ListActivatables();
if (rv.isValid()) {
int i = 0;
foreach (const QString &activatable, rv.value()) {
// messy, I know, but making ListActivatables return a(si) is boring
QDBusInterface iface(QLatin1String("org.kde.networkmanagement"),
activatable, "org.kde.networkmanagement.Activatable", QDBusConnection::sessionBus());
QDBusReply<uint> type = iface.call("activatableType");
if (type.isValid())
handleActivatableAdded(activatable, type.value(), i);
i++;
}
}
else
kWarning() << "ListActivatables method of KDED module is not available!";
d->iface->ReEmitActivatableList();
}
}
}
......@@ -148,8 +135,12 @@ QList<RemoteActivatable *> RemoteActivatableList::activatables() const
return d->sortedActivatables;
}
void RemoteActivatableList::handleActivatableAdded(const QString &addedPath, uint type, int index)
void RemoteActivatableList::handleActivatableAdded(const QVariantMap & properties)
{
QString addedPath = properties["path"].toString();
uint type = properties["activatableType"].toUInt();
int index = properties["activatableIndex"].toInt();
if (!addedPath.startsWith('/')) {
kDebug() << "Invalid path:" << addedPath << type;
return;
......@@ -159,27 +150,27 @@ void RemoteActivatableList::handleActivatableAdded(const QString &addedPath, uin
RemoteActivatable * newActivatable = 0;
switch (type) {
case Knm::Activatable::InterfaceConnection:
newActivatable = new RemoteInterfaceConnection(addedPath, this);
newActivatable = new RemoteInterfaceConnection(properties, this);
//kDebug() << "interfaceconnection at" << addedPath << "with type" << newActivatable->activatableType();
break;
case Knm::Activatable::WirelessInterfaceConnection:
newActivatable = new RemoteWirelessInterfaceConnection(addedPath, this);
newActivatable = new RemoteWirelessInterfaceConnection(properties, this);
//kDebug() << "wirelessconnection at" << addedPath << "with type" << newActivatable->activatableType();
break;
case Knm::Activatable::WirelessNetwork:
newActivatable = new RemoteWirelessNetwork(addedPath, this);
newActivatable = new RemoteWirelessNetwork(properties, this);
//kDebug() << "wirelessnetwork at" << addedPath << "with type" << newActivatable->activatableType();
break;
case Knm::Activatable::UnconfiguredInterface:
newActivatable = new RemoteUnconfiguredInterface(addedPath, this);
newActivatable = new RemoteUnconfiguredInterface(properties, this);
//kDebug() << "unconfiguredinterface at" << addedPath << "with type" << newActivatable->activatableType();
break;
case Knm::Activatable::VpnInterfaceConnection:
newActivatable = new RemoteVpnInterfaceConnection(addedPath, this);
newActivatable = new RemoteVpnInterfaceConnection(properties, this);
//kDebug() << "vpnconnection at" << addedPath << "with type" << newActivatable->activatableType();
break;
case Knm::Activatable::GsmInterfaceConnection:
newActivatable = new RemoteGsmInterfaceConnection(addedPath, this);
newActivatable = new RemoteGsmInterfaceConnection(properties, this);
//kDebug() << "gsminterfaceconnection at" << addedPath << "with type" << newActivatable->activatableType();
break;
}
......
/*
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -53,7 +54,7 @@ Q_SIGNALS:
void appeared();
void disappeared();
protected Q_SLOTS:
void handleActivatableAdded(const QString &, uint, int);
void handleActivatableAdded(const QVariantMap &properties);
void handleActivatableRemoved(const QString &);
void serviceRegistered();
void serviceUnregistered();
......
......@@ -22,16 +22,15 @@ License along with this library. If not, see <http://www.gnu.org/licenses/>.
#include "remotegsminterfaceconnection.h"
#include "remotegsminterfaceconnection_p.h"
#include <QDBusReply>
#include <KDebug>
RemoteGsmInterfaceConnection::RemoteGsmInterfaceConnection(const QString &dbusPath, QObject * parent)
: RemoteInterfaceConnection(*new RemoteGsmInterfaceConnectionPrivate, dbusPath, parent)
RemoteGsmInterfaceConnection::RemoteGsmInterfaceConnection(const QVariantMap &properties, QObject * parent)
: RemoteInterfaceConnection(*new RemoteGsmInterfaceConnectionPrivate, properties, parent)
{
Q_D(RemoteGsmInterfaceConnection);
d->gsmInterfaceConnectionIface = new GsmInterfaceConnectionInterface("org.kde.networkmanagement", dbusPath, QDBusConnection::sessionBus(), this);
connect(d->gsmInterfaceConnectionIface, SIGNAL(signalQualityChanged(int)), this, SIGNAL(signalQualityChanged(int)));
connect(d->gsmInterfaceConnectionIface, SIGNAL(accessTechnologyChanged(int)), this, SIGNAL(accessTechnologyChanged(int)));
d->gsmInterfaceConnectionIface = new GsmInterfaceConnectionInterface("org.kde.networkmanagement", properties["path"].toString(), QDBusConnection::sessionBus(), this);
connect(d->gsmInterfaceConnectionIface, SIGNAL(gsmPropertiesChanged(QVariantMap)), SLOT(gsmPropertiesChanged(QVariantMap)));
gsmPropertiesChanged(properties);
}
RemoteGsmInterfaceConnection::~RemoteGsmInterfaceConnection()
......@@ -39,22 +38,38 @@ RemoteGsmInterfaceConnection::~RemoteGsmInterfaceConnection()
}
void RemoteGsmInterfaceConnection::gsmPropertiesChanged(const QVariantMap &changedProperties)
{
Q_D(RemoteGsmInterfaceConnection);
QStringList propKeys = changedProperties.keys();
QLatin1String signalQualityKey("signalQuality"),
accessTechnologyKey("accessTechnology");
QVariantMap::const_iterator it = changedProperties.find(signalQualityKey);
if (it != changedProperties.end()) {
d->signalQuality = it->toInt();
emit signalQualityChanged(d->signalQuality);
propKeys.removeOne(signalQualityKey);
}
it = changedProperties.find(accessTechnologyKey);
if (it != changedProperties.end()) {
d->accessTechnology = it->toInt();
emit accessTechnologyChanged(d->accessTechnology);
propKeys.removeOne(accessTechnologyKey);
}
if (propKeys.count()) {
kDebug() << "Unhandled properties: " << propKeys;
}
}
int RemoteGsmInterfaceConnection::getAccessTechnology() const
{
Q_D(const RemoteGsmInterfaceConnection);
QDBusReply<int> reply = d->gsmInterfaceConnectionIface->getAccessTechnology();
if (reply.isValid()) {
return reply.value();
} else {
return ModemManager::ModemInterface::UnknownTechnology;
}
return d->accessTechnology;
}
int RemoteGsmInterfaceConnection::getSignalQuality() const
{
Q_D(const RemoteGsmInterfaceConnection);
return d->gsmInterfaceConnectionIface->getSignalQuality();
return d->signalQuality;
}
// vim: sw=4 sts=4 et tw=100
......@@ -45,8 +45,10 @@ public:
Q_SIGNALS:
void signalQualityChanged(int);
void accessTechnologyChanged(const int);
protected Q_SLOTS:
void gsmPropertiesChanged(const QVariantMap &properties);
protected:
RemoteGsmInterfaceConnection(const QString & dbusPath, QObject * parent);
RemoteGsmInterfaceConnection(const QVariantMap & properties, QObject * parent);
Q_DECLARE_PRIVATE(RemoteGsmInterfaceConnection)
};
......
......@@ -29,6 +29,8 @@ class RemoteGsmInterfaceConnectionPrivate : public RemoteInterfaceConnectionPriv
{
public:
GsmInterfaceConnectionInterface * gsmInterfaceConnectionIface;
int signalQuality;
int accessTechnology;
};
#endif // REMOTEGSMINTERFACECONNECTION_P_H
/*
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -21,84 +22,124 @@ License along with this library. If not, see <http://www.gnu.org/licenses/>.
#include "remoteinterfaceconnection.h"
#include "remoteinterfaceconnection_p.h"
RemoteInterfaceConnection::RemoteInterfaceConnection(RemoteInterfaceConnectionPrivate &dd, const QString &dbusPath, QObject * parent)
: RemoteActivatable(dd, dbusPath, parent)
#include <KDebug>
RemoteInterfaceConnection::RemoteInterfaceConnection(RemoteInterfaceConnectionPrivate &dd, const QVariantMap &properties, QObject * parent)
: RemoteActivatable(dd, properties, parent)
{
Q_D(RemoteInterfaceConnection);
d->interfaceConnectionIface = new InterfaceConnectionInterface("org.kde.networkmanagement", dbusPath, QDBusConnection::sessionBus(), this);
connect(d->interfaceConnectionIface, SIGNAL(activationStateChanged(uint,uint)),
this, SLOT(handleActivationStateChange(uint,uint)));
connect(d->interfaceConnectionIface, SIGNAL(hasDefaultRouteChanged(bool)),
this, SIGNAL(hasDefaultRouteChanged(bool)));
init(properties);
}
RemoteInterfaceConnection::RemoteInterfaceConnection(const QString &dbusPath, QObject * parent)
: RemoteActivatable(*new RemoteInterfaceConnectionPrivate, dbusPath, parent)
RemoteInterfaceConnection::RemoteInterfaceConnection(const QVariantMap &properties, QObject * parent)
: RemoteActivatable(*new RemoteInterfaceConnectionPrivate, properties, parent)
{
init(properties);
}
void RemoteInterfaceConnection::init(const QVariantMap &properties)
{
Q_D(RemoteInterfaceConnection);
d->interfaceConnectionIface = new InterfaceConnectionInterface("org.kde.networkmanagement", dbusPath, QDBusConnection::sessionBus(), this);
connect(d->interfaceConnectionIface, SIGNAL(activationStateChanged(uint,uint)),
this, SLOT(handleActivationStateChange(uint,uint)));
connect(d->interfaceConnectionIface, SIGNAL(hasDefaultRouteChanged(bool)),
this, SIGNAL(hasDefaultRouteChanged(bool)));
d->interfaceConnectionIface = new InterfaceConnectionInterface("org.kde.networkmanagement", properties["path"].toString(), QDBusConnection::sessionBus(), this);
connect(d->interfaceConnectionIface, SIGNAL(icPropertiesChanged(QVariantMap)), SLOT(icPropertiesChanged(QVariantMap)));
d->activationState = Knm::InterfaceConnection::Unknown;
icPropertiesChanged(properties);
}
RemoteInterfaceConnection::~RemoteInterfaceConnection()
{
}
void RemoteInterfaceConnection::icPropertiesChanged(const QVariantMap &changedProperties)
{
Q_D(RemoteInterfaceConnection);
QStringList propKeys = changedProperties.keys();
QLatin1String connectionTypeKey("connectionType"),
uuidKey("uuid"),
nameKey("name"),
iconNameKey("iconName"),
activationStateKey("activationState"),
hasDefaultRouteKey("hasDefaultRoute");
QVariantMap::const_iterator it = changedProperties.find(connectionTypeKey);
if (it != changedProperties.end()) {
d->connectionType = (Knm::Connection::Type)it->toUInt();
propKeys.removeOne(connectionTypeKey);
}
it = changedProperties.find(uuidKey);
if (it != changedProperties.end()) {
d->uuid = it->toString();
propKeys.removeOne(uuidKey);
}
it = changedProperties.find(nameKey);
if (it != changedProperties.end()) {
d->name = it->toString();
propKeys.removeOne(nameKey);
}
it = changedProperties.find(iconNameKey);
if (it != changedProperties.end()) {
d->iconName = it->toString();
propKeys.removeOne(iconNameKey);
}
it = changedProperties.find(activationStateKey);
if (it != changedProperties.end()) {
d->oldActivationState = d->activationState;
d->activationState = (Knm::InterfaceConnection::ActivationState)it->toUInt();
emit activationStateChanged(d->oldActivationState, d->activationState);
propKeys.removeOne(activationStateKey);
}
it = changedProperties.find(hasDefaultRouteKey);
if (it != changedProperties.end()) {
d->hasDefaultRoute = it->toBool();
emit hasDefaultRouteChanged(d->hasDefaultRoute);
propKeys.removeOne(hasDefaultRouteKey);
}
if (propKeys.count()) {
kDebug() << "Unhandled properties: " << propKeys;
}
}
Knm::Connection::Type RemoteInterfaceConnection::connectionType() const
{
Q_D(const RemoteInterfaceConnection);
uint cType = d->interfaceConnectionIface->connectionType();
return (Knm::Connection::Type)cType;
return d->connectionType;
}
QUuid RemoteInterfaceConnection::connectionUuid() const
{
Q_D(const RemoteInterfaceConnection);
QString uuid = d->interfaceConnectionIface->connectionUuid();
return QUuid(uuid);
return d->uuid;
}
QString RemoteInterfaceConnection::connectionName() const
{
Q_D(const RemoteInterfaceConnection);
return d->interfaceConnectionIface->connectionName();
return d->name;
}
QString RemoteInterfaceConnection::iconName() const
{
Q_D(const RemoteInterfaceConnection);
return d->interfaceConnectionIface->iconName();
return d->iconName;
}
Knm::InterfaceConnection::ActivationState RemoteInterfaceConnection::activationState() const
{
Q_D(const RemoteInterfaceConnection);
uint aState = d->interfaceConnectionIface->activationState();
return (Knm::InterfaceConnection::ActivationState)aState;
return d->activationState;
}
Knm::InterfaceConnection::ActivationState RemoteInterfaceConnection::oldActivationState() const
{
Q_D(const RemoteInterfaceConnection);
uint aState = d->interfaceConnectionIface->oldActivationState();
return (Knm::InterfaceConnection::ActivationState)aState;
return d->oldActivationState;
}
bool RemoteInterfaceConnection::hasDefaultRoute() const
{
Q_D(const RemoteInterfaceConnection);
return d->interfaceConnectionIface->hasDefaultRoute();
return d->hasDefaultRoute;
}
void RemoteInterfaceConnection::handleActivationStateChange(uint oldState, uint newState)
{
emit activationStateChanged((Knm::InterfaceConnection::ActivationState)oldState, (Knm::InterfaceConnection::ActivationState)newState);
}
void RemoteInterfaceConnection::deactivate()
{
Q_D(RemoteInterfaceConnection);
......
/*
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -67,11 +68,12 @@ Q_SIGNALS:
void activationStateChanged(Knm::InterfaceConnection::ActivationState, Knm::InterfaceConnection::ActivationState);
void hasDefaultRouteChanged(bool);
protected Q_SLOTS:
void handleActivationStateChange(uint, uint);
void icPropertiesChanged(const QVariantMap &properties);
protected:
RemoteInterfaceConnection(const QString &dbusPath, QObject * parent);
RemoteInterfaceConnection(RemoteInterfaceConnectionPrivate &dd, const QString &dbusPath, QObject * parent);
RemoteInterfaceConnection(const QVariantMap &properties, QObject * parent);
RemoteInterfaceConnection(RemoteInterfaceConnectionPrivate &dd, const QVariantMap &properties, QObject * parent);
private:
void init(const QVariantMap & properties);
Q_DECLARE_PRIVATE(RemoteInterfaceConnection)
};
......
/*
Copyright 2009 Will Stephenson <wstephenson@kde.org>
Copyright 2012 Lamarque V. Souza <lamarque@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -29,6 +30,13 @@ class RemoteInterfaceConnectionPrivate : public RemoteActivatablePrivate
{
public:
InterfaceConnectionInterface * interfaceConnectionIface;
Knm::Connection::Type connectionType;
QString uuid;
QString name;
QString iconName;
Knm::InterfaceConnection::ActivationState activationState;
Knm::InterfaceConnection::ActivationState oldActivationState;
bool hasDefaultRoute;
};