From 4097b6f71f759d10ca882cbb0a033780e3bce13d Mon Sep 17 00:00:00 2001 From: Caio Carvalho Date: Tue, 15 May 2018 19:15:05 -0300 Subject: [PATCH] Including d-pointer in Device class Summary: Including d-pointer pattern in Device class. Related to this task: https://phabricator.kde.org/T6805 Reviewers: #kde_connect, nicolasfella Reviewed By: #kde_connect, nicolasfella Subscribers: nicolasfella, kdeconnect Tags: #kde_connect Differential Revision: https://phabricator.kde.org/D12863 --- core/device.cpp | 177 ++++++++++++++++++++++++++++++++---------------- core/device.h | 30 +++----- 2 files changed, 127 insertions(+), 80 deletions(-) diff --git a/core/device.cpp b/core/device.cpp index cdcbf949f..05754de76 100644 --- a/core/device.cpp +++ b/core/device.cpp @@ -21,6 +21,8 @@ #include "device.h" #include +#include +#include #include #include @@ -37,6 +39,34 @@ #include "kdeconnectconfig.h" #include "daemon.h" +class Device::DevicePrivate +{ +public: + DevicePrivate(const QString &id) + : m_deviceId(id) + { + + } + + ~DevicePrivate() + { + qDeleteAll(m_deviceLinks); + m_deviceLinks.clear(); + } + + const QString m_deviceId; + QString m_deviceName; + DeviceType m_deviceType; + int m_protocolVersion; + + QVector m_deviceLinks; + QHash m_plugins; + + QMultiMap m_pluginsByIncomingCapability; + QSet m_supportedPlugins; + QSet m_pairRequests; +}; + static void warn(const QString& info) { qWarning() << "Device pairing error" << info; @@ -44,28 +74,28 @@ static void warn(const QString& info) Device::Device(QObject* parent, const QString& id) : QObject(parent) - , m_deviceId(id) - , m_protocolVersion(NetworkPacket::s_protocolVersion) //We don't know it yet + , d(new Device::DevicePrivate(id)) { - KdeConnectConfig::DeviceInfo info = KdeConnectConfig::instance()->getTrustedDevice(id); + d->m_protocolVersion = NetworkPacket::s_protocolVersion; + KdeConnectConfig::DeviceInfo info = KdeConnectConfig::instance()->getTrustedDevice(d->m_deviceId); - m_deviceName = info.deviceName; - m_deviceType = str2type(info.deviceType); + d->m_deviceName = info.deviceName; + d->m_deviceType = str2type(info.deviceType); //Register in bus QDBusConnection::sessionBus().registerObject(dbusPath(), this, QDBusConnection::ExportScriptableContents | QDBusConnection::ExportAdaptors); //Assume every plugin is supported until addLink is called and we can get the actual list - m_supportedPlugins = PluginLoader::instance()->getPluginList().toSet(); + d->m_supportedPlugins = PluginLoader::instance()->getPluginList().toSet(); connect(this, &Device::pairingError, this, &warn); } Device::Device(QObject* parent, const NetworkPacket& identityPacket, DeviceLink* dl) : QObject(parent) - , m_deviceId(identityPacket.get(QStringLiteral("deviceId"))) - , m_deviceName(identityPacket.get(QStringLiteral("deviceName"))) + , d(new Device::DevicePrivate(identityPacket.get(QStringLiteral("deviceId")))) { + d->m_deviceName = identityPacket.get(QStringLiteral("deviceName")); addLink(identityPacket, dl); //Register in bus @@ -76,37 +106,66 @@ Device::Device(QObject* parent, const NetworkPacket& identityPacket, DeviceLink* Device::~Device() { - qDeleteAll(m_deviceLinks); - m_deviceLinks.clear(); + delete d; +} + +QString Device::id() const +{ + return d->m_deviceId; +} + +QString Device::name() const +{ + return d->m_deviceName; +} + +QString Device::type() const +{ + return type2str(d->m_deviceType); +} + +bool Device::isReachable() const +{ + return !d->m_deviceLinks.isEmpty(); +} + +int Device::protocolVersion() +{ + return d->m_protocolVersion; +} + +QStringList Device::supportedPlugins() const +{ + return d->m_supportedPlugins.toList(); } bool Device::hasPlugin(const QString& name) const { - return m_plugins.contains(name); + return d->m_plugins.contains(name); } QStringList Device::loadedPlugins() const { - return m_plugins.keys(); + return d->m_plugins.keys(); } void Device::reloadPlugins() { - QHash newPluginMap, oldPluginMap = m_plugins; + QHash newPluginMap, oldPluginMap = d->m_plugins; QMultiMap newPluginsByIncomingCapability; if (isTrusted() && isReachable()) { //Do not load any plugin for unpaired devices, nor useless loading them for unreachable devices PluginLoader* loader = PluginLoader::instance(); - for (const QString& pluginName : qAsConst(m_supportedPlugins)) { + for (const QString& pluginName : qAsConst(d->m_supportedPlugins)) { const KPluginMetaData service = loader->getPluginInfo(pluginName); const bool pluginEnabled = isPluginEnabled(pluginName); const QSet incomingCapabilities = KPluginMetaData::readStringList(service.rawData(), QStringLiteral("X-KdeConnect-SupportedPacketType")).toSet(); if (pluginEnabled) { - KdeConnectPlugin* plugin = m_plugins.take(pluginName); + KdeConnectPlugin* plugin = d->m_plugins.take(pluginName); if (!plugin) { plugin = loader->instantiatePluginForDevice(pluginName, this); @@ -126,12 +185,12 @@ void Device::reloadPlugins() //Erase all left plugins in the original map (meaning that we don't want //them anymore, otherwise they would have been moved to the newPluginMap) - qDeleteAll(m_plugins); - m_plugins = newPluginMap; - m_pluginsByIncomingCapability = newPluginsByIncomingCapability; + qDeleteAll(d->m_plugins); + d->m_plugins = newPluginMap; + d->m_pluginsByIncomingCapability = newPluginsByIncomingCapability; QDBusConnection bus = QDBusConnection::sessionBus(); - for (KdeConnectPlugin* plugin : qAsConst(m_plugins)) { + for (KdeConnectPlugin* plugin : qAsConst(d->m_plugins)) { //TODO: see how it works in Android (only done once, when created) plugin->connected(); @@ -162,14 +221,14 @@ void Device::requestPair() return; } - for (DeviceLink* dl : qAsConst(m_deviceLinks)) { + for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) { dl->userRequestsPair(); } } void Device::unpair() { - for (DeviceLink* dl : qAsConst(m_deviceLinks)) { + for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) { dl->userRequestsUnpair(); } KdeConnectConfig::instance()->removeTrustedDevice(id()); @@ -181,7 +240,7 @@ void Device::pairStatusChanged(DeviceLink::PairStatus status) if (status == DeviceLink::NotPaired) { KdeConnectConfig::instance()->removeTrustedDevice(id()); - for (DeviceLink* dl : qAsConst(m_deviceLinks)) { + for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) { if (dl != sender()) { dl->setPairStatus(DeviceLink::NotPaired); } @@ -207,20 +266,20 @@ void Device::addLink(const NetworkPacket& identityPacket, DeviceLink* link) //qCDebug(KDECONNECT_CORE) << "Adding link to" << id() << "via" << link->provider(); setName(identityPacket.get(QStringLiteral("deviceName"))); - m_deviceType = str2type(identityPacket.get(QStringLiteral("deviceType"))); + d->m_deviceType = str2type(identityPacket.get(QStringLiteral("deviceType"))); - if (m_deviceLinks.contains(link)) + if (d->m_deviceLinks.contains(link)) return; - m_protocolVersion = identityPacket.get(QStringLiteral("protocolVersion"), -1); - if (m_protocolVersion != NetworkPacket::s_protocolVersion) { - qCWarning(KDECONNECT_CORE) << m_deviceName << "- warning, device uses a different protocol version" << m_protocolVersion << "expected" << NetworkPacket::s_protocolVersion; + d->m_protocolVersion = identityPacket.get(QStringLiteral("protocolVersion"), -1); + if (d->m_protocolVersion != NetworkPacket::s_protocolVersion) { + qCWarning(KDECONNECT_CORE) << d->m_deviceName << "- warning, device uses a different protocol version" << d->m_protocolVersion << "expected" << NetworkPacket::s_protocolVersion; } connect(link, &QObject::destroyed, this, &Device::linkDestroyed); - m_deviceLinks.append(link); + d->m_deviceLinks.append(link); //Theoretically we will never add two links from the same provider (the provider should destroy //the old one before this is called), so we do not have to worry about destroying old links. @@ -229,22 +288,22 @@ void Device::addLink(const NetworkPacket& identityPacket, DeviceLink* link) connect(link, &DeviceLink::receivedPacket, this, &Device::privateReceivedPacket); - std::sort(m_deviceLinks.begin(), m_deviceLinks.end(), lessThan); + std::sort(d->m_deviceLinks.begin(), d->m_deviceLinks.end(), lessThan); const bool capabilitiesSupported = identityPacket.has(QStringLiteral("incomingCapabilities")) || identityPacket.has(QStringLiteral("outgoingCapabilities")); if (capabilitiesSupported) { const QSet outgoingCapabilities = identityPacket.get(QStringLiteral("outgoingCapabilities")).toSet() , incomingCapabilities = identityPacket.get(QStringLiteral("incomingCapabilities")).toSet(); - m_supportedPlugins = PluginLoader::instance()->pluginsForCapabilities(incomingCapabilities, outgoingCapabilities); + d->m_supportedPlugins = PluginLoader::instance()->pluginsForCapabilities(incomingCapabilities, outgoingCapabilities); //qDebug() << "new plugins for" << m_deviceName << m_supportedPlugins << incomingCapabilities << outgoingCapabilities; } else { - m_supportedPlugins = PluginLoader::instance()->getPluginList().toSet(); + d->m_supportedPlugins = PluginLoader::instance()->getPluginList().toSet(); } reloadPlugins(); - if (m_deviceLinks.size() == 1) { + if (d->m_deviceLinks.size() == 1) { Q_EMIT reachableChanged(true); } @@ -256,45 +315,45 @@ void Device::addLink(const NetworkPacket& identityPacket, DeviceLink* link) void Device::addPairingRequest(PairingHandler* handler) { - const bool wasEmpty = m_pairRequests.isEmpty(); - m_pairRequests.insert(handler); + const bool wasEmpty = d->m_pairRequests.isEmpty(); + d->m_pairRequests.insert(handler); - if (wasEmpty != m_pairRequests.isEmpty()) - Q_EMIT hasPairingRequestsChanged(!m_pairRequests.isEmpty()); + if (wasEmpty != d->m_pairRequests.isEmpty()) + Q_EMIT hasPairingRequestsChanged(!d->m_pairRequests.isEmpty()); } void Device::removePairingRequest(PairingHandler* handler) { - const bool wasEmpty = m_pairRequests.isEmpty(); - m_pairRequests.remove(handler); + const bool wasEmpty = d->m_pairRequests.isEmpty(); + d->m_pairRequests.remove(handler); - if (wasEmpty != m_pairRequests.isEmpty()) - Q_EMIT hasPairingRequestsChanged(!m_pairRequests.isEmpty()); + if (wasEmpty != d->m_pairRequests.isEmpty()) + Q_EMIT hasPairingRequestsChanged(!d->m_pairRequests.isEmpty()); } bool Device::hasPairingRequests() const { - return !m_pairRequests.isEmpty(); + return !d->m_pairRequests.isEmpty(); } void Device::acceptPairing() { - if (m_pairRequests.isEmpty()) + if (d->m_pairRequests.isEmpty()) qWarning() << "no pair requests to accept!"; //copying because the pairing handler will be removed upon accept - const auto prCopy = m_pairRequests; + const auto prCopy = d->m_pairRequests; for (auto ph: prCopy) ph->acceptPairing(); } void Device::rejectPairing() { - if (m_pairRequests.isEmpty()) + if (d->m_pairRequests.isEmpty()) qWarning() << "no pair requests to reject!"; //copying because the pairing handler will be removed upon reject - const auto prCopy = m_pairRequests; + const auto prCopy = d->m_pairRequests; for (auto ph: prCopy) ph->rejectPairing(); } @@ -306,11 +365,11 @@ void Device::linkDestroyed(QObject* o) void Device::removeLink(DeviceLink* link) { - m_deviceLinks.removeAll(link); + d->m_deviceLinks.removeAll(link); //qCDebug(KDECONNECT_CORE) << "RemoveLink" << m_deviceLinks.size() << "links remaining"; - if (m_deviceLinks.isEmpty()) { + if (d->m_deviceLinks.isEmpty()) { reloadPlugins(); Q_EMIT reachableChanged(false); } @@ -322,7 +381,7 @@ bool Device::sendPacket(NetworkPacket& np) Q_ASSERT(isTrusted()); //Maybe we could block here any packet that is not an identity or a pairing packet to prevent sending non encrypted data - for (DeviceLink* dl : qAsConst(m_deviceLinks)) { + for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) { if (dl->sendPacket(np)) return true; } @@ -333,7 +392,7 @@ void Device::privateReceivedPacket(const NetworkPacket& np) { Q_ASSERT(np.type() != PACKET_TYPE_PAIR); if (isTrusted()) { - const QList plugins = m_pluginsByIncomingCapability.values(np.type()); + const QList plugins = d->m_pluginsByIncomingCapability.values(np.type()); if (plugins.isEmpty()) { qWarning() << "discarding unsupported packet" << np.type() << "for" << name(); } @@ -355,8 +414,8 @@ bool Device::isTrusted() const QStringList Device::availableLinks() const { QStringList sl; - sl.reserve(m_deviceLinks.size()); - for (DeviceLink* dl : qAsConst(m_deviceLinks)) { + sl.reserve(d->m_deviceLinks.size()); + for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) { sl.append(dl->provider()->name()); } return sl; @@ -366,11 +425,11 @@ void Device::cleanUnneededLinks() { if (isTrusted()) { return; } - for(int i = 0; i < m_deviceLinks.size(); ) { - DeviceLink* dl = m_deviceLinks[i]; + for(int i = 0; i < d->m_deviceLinks.size(); ) { + DeviceLink* dl = d->m_deviceLinks[i]; if (!dl->linkShouldBeKeptAlive()) { dl->deleteLater(); - m_deviceLinks.remove(i); + d->m_deviceLinks.remove(i); } else { i++; } @@ -379,7 +438,7 @@ void Device::cleanUnneededLinks() { QHostAddress Device::getLocalIpAddress() const { - for (DeviceLink* dl : m_deviceLinks) { + for (DeviceLink* dl : d->m_deviceLinks) { LanDeviceLink* ldl = dynamic_cast(dl); if (ldl) { return ldl->hostAddress(); @@ -419,7 +478,7 @@ QString Device::iconName() const QString Device::iconForStatus(bool reachable, bool trusted) const { - Device::DeviceType deviceType = m_deviceType; + Device::DeviceType deviceType = d->m_deviceType; if (deviceType == Device::Unknown) { deviceType = Device::Phone; //Assume phone if we don't know the type } else if (deviceType == Device::Desktop) { @@ -434,15 +493,15 @@ QString Device::iconForStatus(bool reachable, bool trusted) const void Device::setName(const QString& name) { - if (m_deviceName != name) { - m_deviceName = name; + if (d->m_deviceName != name) { + d->m_deviceName = name; Q_EMIT nameChanged(name); } } KdeConnectPlugin* Device::plugin(const QString& pluginName) const { - return m_plugins[pluginName]; + return d->m_plugins[pluginName]; } void Device::setPluginEnabled(const QString& pluginName, bool enabled) diff --git a/core/device.h b/core/device.h index b299f0f3d..0621e2912 100644 --- a/core/device.h +++ b/core/device.h @@ -23,8 +23,6 @@ #include #include -#include -#include #include #include "networkpacket.h" @@ -74,10 +72,10 @@ public: ~Device() override; - QString id() const { return m_deviceId; } - QString name() const { return m_deviceName; } + QString id() const; + QString name() const; QString dbusPath() const { return "/modules/kdeconnect/devices/"+id(); } - QString type() const { return type2str(m_deviceType); } + QString type() const; QString iconName() const; QString statusIconName() const; Q_SCRIPTABLE QString encryptionInfo() const; @@ -89,7 +87,7 @@ public: Q_SCRIPTABLE bool isTrusted() const; Q_SCRIPTABLE QStringList availableLinks() const; - bool isReachable() const { return !m_deviceLinks.isEmpty(); } + bool isReachable() const; Q_SCRIPTABLE QStringList loadedPlugins() const; Q_SCRIPTABLE bool hasPlugin(const QString& name) const; @@ -102,8 +100,8 @@ public: void cleanUnneededLinks(); - int protocolVersion() { return m_protocolVersion; } - QStringList supportedPlugins() const { return m_supportedPlugins.toList(); } + int protocolVersion(); + QStringList supportedPlugins() const; QHostAddress getLocalIpAddress() const; @@ -145,19 +143,9 @@ private: //Methods void setName(const QString& name); QString iconForStatus(bool reachable, bool paired) const; -private: //Fields (TODO: dPointer!) - const QString m_deviceId; - QString m_deviceName; - DeviceType m_deviceType; - int m_protocolVersion; - - QVector m_deviceLinks; - QHash m_plugins; - - //Capabilities stuff - QMultiMap m_pluginsByIncomingCapability; - QSet m_supportedPlugins; - QSet m_pairRequests; +private: + class DevicePrivate; + DevicePrivate *d; }; Q_DECLARE_METATYPE(Device*)