diff --git a/core/device.cpp b/core/device.cpp
index 32e23a89..e3fcd32a 100644
--- a/core/device.cpp
+++ b/core/device.cpp
@@ -1,564 +1,565 @@
 /**
  * Copyright 2013 Albert Vaca <albertvaka@gmail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "device.h"
 
 #include <QVector>
 #include <QSet>
 #include <QSslCertificate>
 
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 #include "core_debug.h"
 #include "kdeconnectplugin.h"
 #include "pluginloader.h"
 #include "backends/devicelink.h"
 #include "backends/lan/landevicelink.h"
 #include "backends/linkprovider.h"
 #include "networkpacket.h"
 #include "kdeconnectconfig.h"
 #include "daemon.h"
 #include "dbushelper.h"
 
 //In older Qt released, qAsConst isnt available
 #include "qtcompat_p.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<DeviceLink *> m_deviceLinks;
     QHash<QString, KdeConnectPlugin *> m_plugins;
 
     QMultiMap<QString, KdeConnectPlugin *> m_pluginsByIncomingCapability;
     QSet<QString> m_supportedPlugins;
     QSet<QString> m_allPlugins;
     QSet<PairingHandler *> m_pairRequests;
 };
 
 static void warn(const QString& info)
 {
     qWarning() << "Device pairing error" << info;
 }
 
 Device::Device(QObject* parent, const QString& id)
     : QObject(parent)
     , d(new Device::DevicePrivate(id))
 {
     d->m_protocolVersion = NetworkPacket::s_protocolVersion;
     KdeConnectConfig::DeviceInfo info = KdeConnectConfig::instance()->getTrustedDevice(d->m_deviceId);
 
     d->m_deviceName = info.deviceName;
     d->m_deviceType = str2type(info.deviceType);
 
     //Register in bus
     DbusHelper::sessionBus().registerObject(dbusPath(), this, QDBusConnection::ExportScriptableContents | QDBusConnection::ExportAdaptors);
 
     //Assume every plugin is supported until addLink is called and we can get the actual list
     d->m_allPlugins = PluginLoader::instance()->getPluginList().toSet();
     d->m_supportedPlugins = d->m_allPlugins;
 
     connect(this, &Device::pairingError, this, &warn);
 }
 
 Device::Device(QObject* parent, const NetworkPacket& identityPacket, DeviceLink* dl)
     : QObject(parent)
     , d(new Device::DevicePrivate(identityPacket.get<QString>(QStringLiteral("deviceId"))))
 {
     d->m_deviceName = identityPacket.get<QString>(QStringLiteral("deviceName"));
     d->m_allPlugins = PluginLoader::instance()->getPluginList().toSet();
 
     addLink(identityPacket, dl);
 
     //Register in bus
     DbusHelper::sessionBus().registerObject(dbusPath(), this, QDBusConnection::ExportScriptableContents | QDBusConnection::ExportAdaptors);
 
     connect(this, &Device::pairingError, this, &warn);
 }
 
 Device::~Device()
 {
     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 d->m_plugins.contains(name);
 }
 
 QStringList Device::loadedPlugins() const
 {
     return d->m_plugins.keys();
 }
 
 void Device::reloadPlugins()
 {
     QHash<QString, KdeConnectPlugin*> newPluginMap, oldPluginMap = d->m_plugins;
     QMultiMap<QString, KdeConnectPlugin*> 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(d->m_supportedPlugins)) {
             const KPluginMetaData service = loader->getPluginInfo(pluginName);
 
             const bool pluginEnabled = isPluginEnabled(pluginName);
             const QSet<QString> incomingCapabilities = KPluginMetaData::readStringList(service.rawData(), QStringLiteral("X-KdeConnect-SupportedPacketType")).toSet();
 
             if (pluginEnabled) {
                 KdeConnectPlugin* plugin = d->m_plugins.take(pluginName);
 
                 if (!plugin) {
                     plugin = loader->instantiatePluginForDevice(pluginName, this);
                 }
                 Q_ASSERT(plugin);
 
                 for (const QString& interface : incomingCapabilities) {
                     newPluginsByIncomingCapability.insert(interface, plugin);
                 }
 
                 newPluginMap[pluginName] = plugin;
             }
         }
     }
 
     const bool differentPlugins = oldPluginMap != newPluginMap;
 
     //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(d->m_plugins);
     d->m_plugins = newPluginMap;
     d->m_pluginsByIncomingCapability = newPluginsByIncomingCapability;
 
     QDBusConnection bus = DbusHelper::sessionBus();
     for (KdeConnectPlugin* plugin : qAsConst(d->m_plugins)) {
         //TODO: see how it works in Android (only done once, when created)
         plugin->connected();
 
         const QString dbusPath = plugin->dbusPath();
         if (!dbusPath.isEmpty()) {
             bus.registerObject(dbusPath, plugin, QDBusConnection::ExportAllProperties | QDBusConnection::ExportScriptableInvokables | QDBusConnection::ExportScriptableSignals | QDBusConnection::ExportScriptableSlots);
         }
     }
     if (differentPlugins) {
         Q_EMIT pluginsChanged();
     }
 }
 
 QString Device::pluginsConfigFile() const
 {
     return KdeConnectConfig::instance()->deviceConfigDir(id()).absoluteFilePath(QStringLiteral("config"));
 }
 
 void Device::requestPair()
 {
     if (isTrusted()) {
         Q_EMIT pairingError(i18n("Already paired"));
         return;
     }
 
     if (!isReachable()) {
         Q_EMIT pairingError(i18n("Device not reachable"));
         return;
     }
 
     for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) {
         dl->userRequestsPair();
     }
 }
 
 void Device::unpair()
 {
     for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) {
         dl->userRequestsUnpair();
     }
     KdeConnectConfig::instance()->removeTrustedDevice(id());
     Q_EMIT trustedChanged(false);
 }
 
 void Device::pairStatusChanged(DeviceLink::PairStatus status)
 {
     if (status == DeviceLink::NotPaired) {
         KdeConnectConfig::instance()->removeTrustedDevice(id());
 
         for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) {
             if (dl != sender()) {
                 dl->setPairStatus(DeviceLink::NotPaired);
             }
         }
     } else {
         KdeConnectConfig::instance()->addTrustedDevice(id(), name(), type());
     }
 
     reloadPlugins(); //Will load/unload plugins
 
     bool isTrusted = (status == DeviceLink::Paired);
     Q_EMIT trustedChanged(isTrusted);
     Q_ASSERT(isTrusted == this->isTrusted());
 }
 
 static bool lessThan(DeviceLink* p1, DeviceLink* p2)
 {
     return p1->provider()->priority() > p2->provider()->priority();
 }
 
 void Device::addLink(const NetworkPacket& identityPacket, DeviceLink* link)
 {
     //qCDebug(KDECONNECT_CORE) << "Adding link to" << id() << "via" << link->provider();
 
     setName(identityPacket.get<QString>(QStringLiteral("deviceName")));
     d->m_deviceType = str2type(identityPacket.get<QString>(QStringLiteral("deviceType")));
 
-    if (d->m_deviceLinks.contains(link))
+    if (d->m_deviceLinks.contains(link)) {
         return;
+    }
 
     d->m_protocolVersion = identityPacket.get<int>(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);
 
     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.
     //-- Actually, we should not destroy them or the provider will store an invalid ref!
 
     connect(link, &DeviceLink::receivedPacket,
             this, &Device::privateReceivedPacket);
 
     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<QString> outgoingCapabilities = identityPacket.get<QStringList>(QStringLiteral("outgoingCapabilities")).toSet()
                           , incomingCapabilities = identityPacket.get<QStringList>(QStringLiteral("incomingCapabilities")).toSet();
 
         d->m_supportedPlugins = PluginLoader::instance()->pluginsForCapabilities(incomingCapabilities, outgoingCapabilities);
         //qDebug() << "new plugins for" << m_deviceName << m_supportedPlugins << incomingCapabilities << outgoingCapabilities;
     } else {
         d->m_supportedPlugins = PluginLoader::instance()->getPluginList().toSet();
     }
 
     reloadPlugins();
 
     if (d->m_deviceLinks.size() == 1) {
         Q_EMIT reachableChanged(true);
     }
 
     connect(link, &DeviceLink::pairStatusChanged, this, &Device::pairStatusChanged);
     connect(link, &DeviceLink::pairingRequest, this, &Device::addPairingRequest);
     connect(link, &DeviceLink::pairingRequestExpired, this, &Device::removePairingRequest);
     connect(link, &DeviceLink::pairingError, this, &Device::pairingError);
 }
 
 void Device::addPairingRequest(PairingHandler* handler)
 {
     const bool wasEmpty = d->m_pairRequests.isEmpty();
     d->m_pairRequests.insert(handler);
 
     if (wasEmpty != d->m_pairRequests.isEmpty())
         Q_EMIT hasPairingRequestsChanged(!d->m_pairRequests.isEmpty());
 }
 
 void Device::removePairingRequest(PairingHandler* handler)
 {
     const bool wasEmpty = d->m_pairRequests.isEmpty();
     d->m_pairRequests.remove(handler);
 
     if (wasEmpty != d->m_pairRequests.isEmpty())
         Q_EMIT hasPairingRequestsChanged(!d->m_pairRequests.isEmpty());
 }
 
 bool Device::hasPairingRequests() const
 {
     return !d->m_pairRequests.isEmpty();
 }
 
 void Device::acceptPairing()
 {
     if (d->m_pairRequests.isEmpty())
         qWarning() << "no pair requests to accept!";
 
     //copying because the pairing handler will be removed upon accept
     const auto prCopy = d->m_pairRequests;
     for (auto ph: prCopy)
         ph->acceptPairing();
 }
 
 void Device::rejectPairing()
 {
     if (d->m_pairRequests.isEmpty())
         qWarning() << "no pair requests to reject!";
 
     //copying because the pairing handler will be removed upon reject
     const auto prCopy = d->m_pairRequests;
     for (auto ph: prCopy)
         ph->rejectPairing();
 }
 
 void Device::linkDestroyed(QObject* o)
 {
     removeLink(static_cast<DeviceLink*>(o));
 }
 
 void Device::removeLink(DeviceLink* link)
 {
     d->m_deviceLinks.removeAll(link);
 
     //qCDebug(KDECONNECT_CORE) << "RemoveLink" << m_deviceLinks.size() << "links remaining";
 
     if (d->m_deviceLinks.isEmpty()) {
         reloadPlugins();
         Q_EMIT reachableChanged(false);
     }
 }
 
 bool Device::sendPacket(NetworkPacket& np)
 {
     Q_ASSERT(np.type() != PACKET_TYPE_PAIR);
     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(d->m_deviceLinks)) {
         if (dl->sendPacket(np)) return true;
     }
 
     return false;
 }
 
 void Device::privateReceivedPacket(const NetworkPacket& np)
 {
     Q_ASSERT(np.type() != PACKET_TYPE_PAIR);
     if (isTrusted()) {
         const QList<KdeConnectPlugin*> plugins = d->m_pluginsByIncomingCapability.values(np.type());
         if (plugins.isEmpty()) {
             qWarning() << "discarding unsupported packet" << np.type() << "for" << name();
         }
         for (KdeConnectPlugin* plugin : plugins) {
             plugin->receivePacket(np);
         }
     } else {
         qCDebug(KDECONNECT_CORE) << "device" << name() << "not paired, ignoring packet" << np.type();
         unpair();
     }
 
 }
 
 bool Device::isTrusted() const
 {
     return KdeConnectConfig::instance()->trustedDevices().contains(id());
 }
 
 QStringList Device::availableLinks() const
 {
     QStringList sl;
     sl.reserve(d->m_deviceLinks.size());
     for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) {
         sl.append(dl->provider()->name());
     }
     return sl;
 }
 
 void Device::cleanUnneededLinks() {
     if (isTrusted()) {
         return;
     }
     for(int i = 0; i < d->m_deviceLinks.size(); ) {
         DeviceLink* dl = d->m_deviceLinks[i];
         if (!dl->linkShouldBeKeptAlive()) {
             dl->deleteLater();
             d->m_deviceLinks.remove(i);
         } else {
             i++;
         }
     }
 }
 
 QHostAddress Device::getLocalIpAddress() const
 {
     for (DeviceLink* dl : qAsConst(d->m_deviceLinks)) {
         LanDeviceLink* ldl = dynamic_cast<LanDeviceLink*>(dl);
         if (ldl) {
             return ldl->hostAddress();
         }
     }
     return QHostAddress::Null;
 }
 
 Device::DeviceType Device::str2type(const QString& deviceType) {
     if (deviceType == QLatin1String("desktop")) return Desktop;
     if (deviceType == QLatin1String("laptop")) return Laptop;
     if (deviceType == QLatin1String("smartphone") || deviceType == QLatin1String("phone")) return Phone;
     if (deviceType == QLatin1String("tablet")) return Tablet;
     if (deviceType == QLatin1String("tv")) return Tv;
     return Unknown;
 }
 
 QString Device::type2str(Device::DeviceType deviceType) {
     if (deviceType == Desktop) return QStringLiteral("desktop");
     if (deviceType == Laptop) return QStringLiteral("laptop");
     if (deviceType == Phone) return QStringLiteral("smartphone");
     if (deviceType == Tablet) return QStringLiteral("tablet");
     if (deviceType == Tv) return QStringLiteral("tv");
     return QStringLiteral("unknown");
 }
 
 QString Device::statusIconName() const
 {
     return iconForStatus(isReachable(), isTrusted());
 }
 
 QString Device::iconName() const
 {
 
     return iconForStatus(true, false);
 }
 
 QString Device::iconForStatus(bool reachable, bool trusted) const
 {
     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) {
         deviceType = Device::Device::Laptop; // We don't have desktop icon yet
     }
 
     QString status = (reachable? (trusted? QStringLiteral("connected") : QStringLiteral("disconnected")) : QStringLiteral("trusted"));
     QString type = type2str(deviceType);
 
     return type+status;
 }
 
 void Device::setName(const QString& name)
 {
     if (d->m_deviceName != name) {
         d->m_deviceName = name;
         Q_EMIT nameChanged(name);
     }
 }
 
 KdeConnectPlugin* Device::plugin(const QString& pluginName) const
 {
     return d->m_plugins[pluginName];
 }
 
 void Device::setPluginEnabled(const QString& pluginName, bool enabled)
 {
     if (!d->m_allPlugins.contains(pluginName)) {
         return;
     }
 
     KConfigGroup pluginStates = KSharedConfig::openConfig(pluginsConfigFile())->group("Plugins");
 
     const QString enabledKey = pluginName + QStringLiteral("Enabled");
     pluginStates.writeEntry(enabledKey, enabled);
     reloadPlugins();
 }
 
 bool Device::isPluginEnabled(const QString& pluginName) const
 {
     const QString enabledKey = pluginName + QStringLiteral("Enabled");
     KConfigGroup pluginStates = KSharedConfig::openConfig(pluginsConfigFile())->group("Plugins");
 
     return (pluginStates.hasKey(enabledKey) ? pluginStates.readEntry(enabledKey, false)
                                             : PluginLoader::instance()->getPluginInfo(pluginName).isEnabledByDefault());
 }
 
 QString Device::encryptionInfo() const
 {
     QString result;
     QCryptographicHash::Algorithm digestAlgorithm = QCryptographicHash::Algorithm::Sha1;
 
     QString localSha1 = QString::fromLatin1(KdeConnectConfig::instance()->certificate().digest(digestAlgorithm).toHex());
     for (int i = 2; i<localSha1.size(); i += 3) {
         localSha1.insert(i, QStringLiteral(":")); // Improve readability
     }
     result += i18n("SHA1 fingerprint of your device certificate is: %1\n", localSha1);
 
     std::string  remotePem = KdeConnectConfig::instance()->getDeviceProperty(id(), QStringLiteral("certificate")).toStdString();
     QSslCertificate remoteCertificate = QSslCertificate(QByteArray(remotePem.c_str(), (int)remotePem.size()));
     QString remoteSha1 = QString::fromLatin1(remoteCertificate.digest(digestAlgorithm).toHex());
     for (int i = 2; i < remoteSha1.size(); i += 3) {
         remoteSha1.insert(i, QStringLiteral(":")); // Improve readability
     }
     result += i18n("SHA1 fingerprint of remote device certificate is: %1\n", remoteSha1);
 
     return result;
 }
 
 QString Device::pluginIconName(const QString& pluginName)
 {
     if (hasPlugin(pluginName)) {
         return d->m_plugins[pluginName]->iconName();
     }
     return QString();
 }
diff --git a/plugins/sendnotifications/notificationslistener.cpp b/plugins/sendnotifications/notificationslistener.cpp
index 250953a4..76221535 100644
--- a/plugins/sendnotifications/notificationslistener.cpp
+++ b/plugins/sendnotifications/notificationslistener.cpp
@@ -1,278 +1,280 @@
 /**
  * Copyright 2015 Holger Kaelberer <holger.k@elberer.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 #include "notificationslistener.h"
 
 #include <QDBusInterface>
 #include <QDBusArgument>
 #include <QtDebug>
 #include <QLoggingCategory>
 #include <QStandardPaths>
 #include <QImage>
 #include <KConfig>
 #include <KConfigGroup>
 #include <kiconloader.h>
 #include <kicontheme.h>
 
 #include <core/device.h>
 #include <core/kdeconnectplugin.h>
 
 #include <dbushelper.h>
 
 #include "sendnotificationsplugin.h"
 #include "sendnotification_debug.h"
 #include "notifyingapplication.h"
 
 //In older Qt released, qAsConst isnt available
 #include "qtcompat_p.h"
 
 NotificationsListener::NotificationsListener(KdeConnectPlugin* aPlugin)
     : QDBusAbstractAdaptor(aPlugin),
       m_plugin(aPlugin)
 {
     qRegisterMetaTypeStreamOperators<NotifyingApplication>("NotifyingApplication");
 
     bool ret = DbusHelper::sessionBus()
                 .registerObject(QStringLiteral("/org/freedesktop/Notifications"),
                                 this,
                                 QDBusConnection::ExportScriptableContents);
     if (!ret)
         qCWarning(KDECONNECT_PLUGIN_SENDNOTIFICATION)
                 << "Error registering notifications listener for device"
                 << m_plugin->device()->name() << ":"
                 << DbusHelper::sessionBus().lastError();
     else
         qCDebug(KDECONNECT_PLUGIN_SENDNOTIFICATION)
                 << "Registered notifications listener for device"
                 << m_plugin->device()->name();
 
     QDBusInterface iface(QStringLiteral("org.freedesktop.DBus"), QStringLiteral("/org/freedesktop/DBus"),
                          QStringLiteral("org.freedesktop.DBus"));
     iface.call(QStringLiteral("AddMatch"),
                QStringLiteral("interface='org.freedesktop.Notifications',member='Notify',type='method_call',eavesdrop='true'"));
 
     setTranslatedAppName();
     loadApplications();
 
     connect(m_plugin->config(), &KdeConnectPluginConfig::configChanged, this, &NotificationsListener::loadApplications);
 }
 
 NotificationsListener::~NotificationsListener()
 {
     qCDebug(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Destroying NotificationsListener";
     QDBusInterface iface(QStringLiteral("org.freedesktop.DBus"), QStringLiteral("/org/freedesktop/DBus"),
                          QStringLiteral("org.freedesktop.DBus"));
     QDBusMessage res = iface.call(QStringLiteral("RemoveMatch"),
                                   QStringLiteral("interface='org.freedesktop.Notifications',member='Notify',type='method_call',eavesdrop='true'"));
     DbusHelper::sessionBus().unregisterObject(QStringLiteral("/org/freedesktop/Notifications"));
 }
 
 void NotificationsListener::setTranslatedAppName()
 {
     QString filePath = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("knotifications5/kdeconnect.notifyrc"), QStandardPaths::LocateFile);
     if (filePath.isEmpty()) {
         qCDebug(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Couldn't find kdeconnect.notifyrc to hide kdeconnect notifications on the devices. Using default name.";
         m_translatedAppName = QStringLiteral("KDE Connect");
         return;
     }
 
     KConfig config(filePath, KConfig::OpenFlag::SimpleConfig);
     KConfigGroup globalgroup(&config, QStringLiteral("Global"));
     m_translatedAppName = globalgroup.readEntry(QStringLiteral("Name"), QStringLiteral("KDE Connect"));
 }
 
 void NotificationsListener::loadApplications()
 {
     m_applications.clear();
     const QVariantList list = m_plugin->config()->getList(QStringLiteral("applications"));
     for (const auto& a : list) {
         NotifyingApplication app = a.value<NotifyingApplication>();
-        if (!m_applications.contains(app.name))
+        if (!m_applications.contains(app.name)) {
             m_applications.insert(app.name, app);
+        }
     }
     //qCDebug(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Loaded" << applications.size() << " applications";
 }
 
 bool NotificationsListener::parseImageDataArgument(const QVariant& argument,
                                                    int& width, int& height,
                                                    int& rowStride, int& bitsPerSample,
                                                    int& channels, bool& hasAlpha,
                                                    QByteArray& imageData) const
 {
     if (!argument.canConvert<QDBusArgument>())
         return false;
     const QDBusArgument dbusArg = argument.value<QDBusArgument>();
     dbusArg.beginStructure();
     dbusArg >> width >> height >> rowStride >> hasAlpha >> bitsPerSample
             >> channels  >> imageData;
     dbusArg.endStructure();
     return true;
 }
 
 QSharedPointer<QIODevice> NotificationsListener::iconForImageData(const QVariant& argument) const
 {
     int width, height, rowStride, bitsPerSample, channels;
     bool hasAlpha;
     QByteArray imageData;
 
     if (!parseImageDataArgument(argument, width, height, rowStride, bitsPerSample,
                                 channels, hasAlpha, imageData))
         return QSharedPointer<QIODevice>();
 
     if (bitsPerSample != 8) {
         qCWarning(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Unsupported image format:"
                                                       << "width=" << width
                                                       << "height=" << height
                                                       << "rowStride=" << rowStride
                                                       << "bitsPerSample=" << bitsPerSample
                                                       << "channels=" << channels
                                                       << "hasAlpha=" << hasAlpha;
         return QSharedPointer<QIODevice>();
     }
 
     QImage image(reinterpret_cast<uchar*>(imageData.data()), width, height, rowStride,
                  hasAlpha ? QImage::Format_ARGB32 : QImage::Format_RGB32);
     if (hasAlpha)
         image = image.rgbSwapped();  // RGBA --> ARGB
 
     QSharedPointer<QBuffer> buffer = QSharedPointer<QBuffer>(new QBuffer);
     if (!buffer || !buffer->open(QIODevice::WriteOnly) ||
             !image.save(buffer.data(), "PNG")) {
         qCWarning(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Could not initialize image buffer";
         return QSharedPointer<QIODevice>();
     }
 
     return buffer;
 }
 
 QSharedPointer<QIODevice> NotificationsListener::iconForIconName(const QString& iconName) const
 {
     int size = KIconLoader::SizeEnormous;  // use big size to allow for good
                                            // quality on high-DPI mobile devices
     QString iconPath = KIconLoader::global()->iconPath(iconName, -size, true);
     if (!iconPath.isEmpty()) {
         if (!iconPath.endsWith(QLatin1String(".png")) &&
                 KIconLoader::global()->theme()->name() != QLatin1String("hicolor")) {
             // try falling back to hicolor theme:
             KIconTheme hicolor(QStringLiteral("hicolor"));
             if (hicolor.isValid()) {
                 iconPath = hicolor.iconPath(iconName + QStringLiteral(".png"), size, KIconLoader::MatchBest);
                 //qCDebug(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Found non-png icon in default theme trying fallback to hicolor:" << iconPath;
             }
         }
     }
 
     if (iconPath.endsWith(QLatin1String(".png")))
         return QSharedPointer<QIODevice>(new QFile(iconPath));
     return QSharedPointer<QIODevice>();
 }
 
 uint NotificationsListener::Notify(const QString& appName, uint replacesId,
                                    const QString& appIcon,
                                    const QString& summary, const QString& body,
                                    const QStringList& actions,
                                    const QVariantMap& hints, int timeout)
 {
     static int id = 0;
     Q_UNUSED(actions);
 
     //qCDebug(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Got notification appName=" << appName << "replacesId=" << replacesId << "appIcon=" << appIcon << "summary=" << summary << "body=" << body << "actions=" << actions << "hints=" << hints << "timeout=" << timeout;
 
     // skip our own notifications
     if (appName == m_translatedAppName)
         return 0;
 
     NotifyingApplication app;
     if (!m_applications.contains(appName)) {
         // new application -> add to config
         app.name = appName;
         app.icon = appIcon;
         app.active = true;
         app.blacklistExpression = QRegularExpression();
         m_applications.insert(app.name, app);
         // update config:
         QVariantList list;
         for (const auto& a : qAsConst(m_applications))
             list << QVariant::fromValue<NotifyingApplication>(a);
         m_plugin->config()->setList(QStringLiteral("applications"), list);
         //qCDebug(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Added new application to config:" << app;
-    } else
+    } else {
         app = m_applications.value(appName);
+    }
 
     if (!app.active)
         return 0;
 
     if (timeout > 0 && m_plugin->config()->get(QStringLiteral("generalPersistent"), false))
         return 0;
 
     int urgency = -1;
     if (hints.contains(QStringLiteral("urgency"))) {
         bool ok;
         urgency = hints[QStringLiteral("urgency")].toInt(&ok);
         if (!ok)
             urgency = -1;
     }
     if (urgency > -1 && urgency < m_plugin->config()->get<int>(QStringLiteral("generalUrgency"), 0))
         return 0;
 
     QString ticker = summary;
     if (!body.isEmpty() && m_plugin->config()->get(QStringLiteral("generalIncludeBody"), true))
         ticker += QStringLiteral(": ") + body;
 
     if (app.blacklistExpression.isValid() &&
             !app.blacklistExpression.pattern().isEmpty() &&
             app.blacklistExpression.match(ticker).hasMatch())
         return 0;
 
     //qCDebug(KDECONNECT_PLUGIN_SENDNOTIFICATION) << "Sending notification from" << appName << ":" <<ticker << "; appIcon=" << appIcon;
     NetworkPacket np(PACKET_TYPE_NOTIFICATION, {
         {QStringLiteral("id"), QString::number(replacesId > 0 ? replacesId : ++id)},
         {QStringLiteral("appName"), appName},
         {QStringLiteral("ticker"), ticker},
         {QStringLiteral("isClearable"), timeout == 0}
     });                                   // KNotifications are persistent if
                                           // timeout == 0, for other notifications
                                           // clearability is pointless
 
     // sync any icon data?
     if (m_plugin->config()->get(QStringLiteral("generalSynchronizeIcons"), true)) {
         QSharedPointer<QIODevice> iconSource;
         // try different image sources according to priorities in notifications-
         // spec version 1.2:
         if (hints.contains(QStringLiteral("image-data")))
             iconSource = iconForImageData(hints[QStringLiteral("image-data")]);
         else if (hints.contains(QStringLiteral("image_data")))  // 1.1 backward compatibility
             iconSource = iconForImageData(hints[QStringLiteral("image_data")]);
         else if (hints.contains(QStringLiteral("image-path")))
             iconSource = iconForIconName(hints[QStringLiteral("image-path")].toString());
         else if (hints.contains(QStringLiteral("image_path")))  // 1.1 backward compatibility
             iconSource = iconForIconName(hints[QStringLiteral("image_path")].toString());
         else if (!appIcon.isEmpty())
             iconSource = iconForIconName(appIcon);
         else if (hints.contains(QStringLiteral("icon_data")))  // < 1.1 backward compatibility
             iconSource = iconForImageData(hints[QStringLiteral("icon_data")]);
 
         if (iconSource)
             np.setPayload(iconSource, iconSource->size());
     }
 
     m_plugin->sendPacket(np);
 
     return (replacesId > 0 ? replacesId : id);
 }