diff --git a/discover/DiscoverObject.cpp b/discover/DiscoverObject.cpp
index 261553ca..5c32b06b 100644
--- a/discover/DiscoverObject.cpp
+++ b/discover/DiscoverObject.cpp
@@ -1,441 +1,446 @@
 /*
  *   Copyright (C) 2012 Aleix Pol Gonzalez <aleixpol@blue-systems.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library/Lesser General Public License
  *   version 2, or (at your option) any later version, as published by the
  *   Free Software Foundation
  *
  *   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 Library/Lesser General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "DiscoverObject.h"
 #include "PaginateModel.h"
 #include "UnityLauncher.h"
 #include "FeaturedModel.h"
 #include "CachedNetworkAccessManager.h"
 #include "DiscoverDeclarativePlugin.h"
 
 // Qt includes
 #include <QAction>
 #include <QDebug>
 #include <QDesktopServices>
 #include <QtQml/QQmlEngine>
 #include <QtQml/QQmlContext>
 #include <QtQml/QQmlApplicationEngine>
 #include <QtQuick/QQuickItem>
 #include <qqml.h>
 #include <QPointer>
 #include <QGuiApplication>
 #include <QSortFilterProxyModel>
 #include <QTimer>
 
 // KDE includes
 #include <KAboutApplicationDialog>
 #include <KAuthorized>
 #include <KBugReport>
 #include <KLocalizedString>
 #include <KLocalizedContext>
 #include <KAboutData>
 #include <KConcatenateRowsProxyModel>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KStandardAction>
 #include <KIO/AccessManager>
 // #include <KSwitchLanguageDialog>
 
 // DiscoverCommon includes
 #include <resources/AbstractResource.h>
 #include <resources/ResourcesModel.h>
 #include <resources/ResourcesProxyModel.h>
 #include <Category/Category.h>
 #include <Category/CategoryModel.h>
 
 #include <functional>
 #include <cmath>
 #include <unistd.h>
 #include <resources/StoredResultsStream.h>
 #include <utils.h>
 
 class OurSortFilterProxyModel : public QSortFilterProxyModel, public QQmlParserStatus
 {
     Q_OBJECT
     Q_INTERFACES(QQmlParserStatus)
 public:
     void classBegin() override {}
     void componentComplete() override {
         if (dynamicSortFilter())
             sort(0);
     }
 };
 
 class KIOAccessManagerFactory : public QQmlNetworkAccessManagerFactory
 {
 public:
     KIOAccessManagerFactory() = default;
     ~KIOAccessManagerFactory() = default;
     QNetworkAccessManager *create(QObject *parent) override
     {
         return new KIO::AccessManager(parent);
     }
 };
 
 DiscoverObject::DiscoverObject(CompactMode mode)
     : QObject()
     , m_engine(new QQmlApplicationEngine)
     , m_mode(mode)
     , m_networkAccessManagerFactory(new CachedNetworkAccessManagerFactory)
 {
     setObjectName(QStringLiteral("DiscoverMain"));
     m_engine->rootContext()->setContextObject(new KLocalizedContext(m_engine));
     auto factory = m_engine->networkAccessManagerFactory();
     m_engine->setNetworkAccessManagerFactory(nullptr);
     delete factory;
     m_engine->setNetworkAccessManagerFactory(new KIOAccessManagerFactory());
 
     qmlRegisterType<UnityLauncher>("org.kde.discover.app", 1, 0, "UnityLauncher");
     qmlRegisterType<PaginateModel>("org.kde.discover.app", 1, 0, "PaginateModel");
     qmlRegisterType<KConcatenateRowsProxyModel>("org.kde.discover.app", 1, 0, "KConcatenateRowsProxyModel");
     qmlRegisterType<FeaturedModel>("org.kde.discover.app", 1, 0, "FeaturedModel");
     qmlRegisterType<OurSortFilterProxyModel>("org.kde.discover.app", 1, 0, "QSortFilterProxyModel");
 
     qmlRegisterSingletonType(QUrl(QStringLiteral("qrc:/qml/DiscoverSystemPalette.qml")), "org.kde.discover.app", 1, 0, "DiscoverSystemPalette");
     qmlRegisterType<QQuickView>();
     qmlRegisterType<QActionGroup>();
     qmlRegisterType<QAction>();
     qmlRegisterUncreatableType<DiscoverObject>("org.kde.discover.app", 1, 0, "DiscoverMainWindow", QStringLiteral("don't do that"));
     setupActions();
 
     auto uri = "org.kde.discover";
     DiscoverDeclarativePlugin* plugin = new DiscoverDeclarativePlugin;
     plugin->setParent(this);
     plugin->initializeEngine(m_engine, uri);
     plugin->registerTypes(uri);
 
     //Here we set up a cache for the screenshots
     delete m_engine->networkAccessManagerFactory();
     m_engine->setNetworkAccessManagerFactory(m_networkAccessManagerFactory.data());
     m_engine->rootContext()->setContextProperty(QStringLiteral("app"), this);
 
     connect(m_engine, &QQmlApplicationEngine::objectCreated, this, &DiscoverObject::integrateObject);
     m_engine->load(QUrl(QStringLiteral("qrc:/qml/DiscoverWindow.qml")));
 
     connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, this, [this](){
         const auto objs = m_engine->rootObjects();
         for(auto o: objs)
             delete o;
     });
 }
 
 DiscoverObject::~DiscoverObject()
 {
     delete m_engine;
 }
 
 bool DiscoverObject::isRoot()
 {
     return ::getuid() == 0;
 }
 
 QStringList DiscoverObject::modes() const
 {
     QStringList ret;
     QObject* obj = rootObject();
     for(int i = obj->metaObject()->propertyOffset(); i<obj->metaObject()->propertyCount(); i++) {
         QMetaProperty p = obj->metaObject()->property(i);
         QByteArray compName = p.name();
         if(compName.startsWith("top") && compName.endsWith("Comp")) {
             ret += QString::fromLatin1(compName.mid(3, compName.length()-7));
         }
     }
     return ret;
 }
 
 void DiscoverObject::openMode(const QString& _mode)
 {
+    QObject* obj = rootObject();
+    if (!obj) {
+        qWarning() << "could not get the main object";
+        return;
+    }
+
     if(!modes().contains(_mode))
         qWarning() << "unknown mode" << _mode;
 
     QString mode = _mode;
     mode[0] = mode[0].toUpper();
 
-    QObject* obj = rootObject();
     const QByteArray propertyName = "top"+mode.toLatin1()+"Comp";
     const QVariant modeComp = obj->property(propertyName.constData());
     if (!modeComp.isValid())
         qWarning() << "couldn't open mode" << _mode;
     else
         obj->setProperty("currentTopLevel", modeComp);
 }
 
 void DiscoverObject::openMimeType(const QString& mime)
 {
     emit listMimeInternal(mime);
 }
 
 void DiscoverObject::openCategory(const QString& category)
 {
     setRootObjectProperty("defaultStartup", false);
     auto action = new OneTimeAction(
         [this, category]() {
             Category* cat = CategoryModel::global()->findCategoryByName(category);
             if (cat) {
                 emit listCategoryInternal(cat);
             } else {
                 showPassiveNotification(i18n("Could not find category '%1'", category));
                 setRootObjectProperty("defaultStartup", false);
             }
         }
         , this);
 
     if (ResourcesModel::global()->backends().isEmpty()) {
         connect(ResourcesModel::global(), &ResourcesModel::backendsChanged, action, &OneTimeAction::trigger);
     } else {
         action->trigger();
     }
 }
 
 void DiscoverObject::openLocalPackage(const QUrl& localfile)
 {
     if (!QFile::exists(localfile.toLocalFile())) {
 //         showPassiveNotification(i18n("Trying to open unexisting file '%1'", localfile.toString()));
         qWarning() << "Trying to open unexisting file" << localfile;
         return;
     }
     setRootObjectProperty("defaultStartup", false);
     auto action = new OneTimeAction(
         [this, localfile]() {
             auto res = ResourcesModel::global()->resourceForFile(localfile);
             qDebug() << "all initialized..." << res;
             if (res) {
                 emit openApplicationInternal(res);
             } else {
                 setRootObjectProperty("defaultStartup", true);
                 showPassiveNotification(i18n("Couldn't open %1", localfile.toDisplayString()));
             }
         }
         , this);
 
     if (ResourcesModel::global()->backends().isEmpty()) {
         connect(ResourcesModel::global(), &ResourcesModel::backendsChanged, action, &OneTimeAction::trigger);
     } else {
         action->trigger();
     }
 }
 
 void DiscoverObject::openApplication(const QUrl& url)
 {
     Q_ASSERT(!url.isEmpty());
     setRootObjectProperty("defaultStartup", false);
     auto action = new OneTimeAction(
         [this, url]() {
             AbstractResourcesBackend::Filters f;
             f.resourceUrl = url;
             auto stream = new StoredResultsStream({ResourcesModel::global()->search(f)});
             connect(stream, &StoredResultsStream::finished, this, [this, url, stream]() {
                 const auto res = stream->resources();
                 if (res.count() == 1) {
                     emit openApplicationInternal(res.first());
                 } else {
                     setRootObjectProperty("defaultStartup", true);
                     Q_EMIT openErrorPage(i18n("Couldn't open %1", url.toDisplayString()));
                 }
             });
         }
         , this);
 
     if (ResourcesModel::global()->backends().isEmpty()) {
         connect(ResourcesModel::global(), &ResourcesModel::backendsChanged, action, &OneTimeAction::trigger);
     } else {
         action->trigger();
     }
 }
 
 void DiscoverObject::integrateObject(QObject* object)
 {
     if (!object) {
         qWarning() << "Errors when loading the GUI";
         QTimer::singleShot(0, QCoreApplication::instance(), [](){
             QCoreApplication::instance()->exit(1);
         });
         return;
     }
 
     Q_ASSERT(object == rootObject());
 
     KConfigGroup window(KSharedConfig::openConfig(), "Window");
     if (window.hasKey("geometry"))
         rootObject()->setGeometry(window.readEntry("geometry", QRect()));
     if (window.hasKey("visibility")) {
         QWindow::Visibility visibility(QWindow::Visibility(window.readEntry<int>("visibility", QWindow::Windowed)));
         rootObject()->setVisibility(qMax(visibility, QQuickView::AutomaticVisibility));
     }
 
     object->installEventFilter(this);
     connect(object, &QObject::destroyed, qGuiApp, &QCoreApplication::quit);
 }
 
 bool DiscoverObject::eventFilter(QObject * object, QEvent * event)
 {
     if (object!=rootObject())
         return false;
 
     if (event->type() == QEvent::Close) {
         if (ResourcesModel::global()->isBusy()) {
             qWarning() << "not closing because there's still pending tasks";
             Q_EMIT preventedClose();
             return true;
         }
 
         KConfigGroup window(KSharedConfig::openConfig(), "Window");
         window.writeEntry("geometry", rootObject()->geometry());
         window.writeEntry<int>("visibility", rootObject()->visibility());
 //     } else if (event->type() == QEvent::ShortcutOverride) {
 //         qWarning() << "Action conflict" << event;
     }
     return false;
 }
 
 void DiscoverObject::setupActions()
 {
     if (KAuthorized::authorizeAction(QStringLiteral("help_report_bug")) && !KAboutData::applicationData().bugAddress().isEmpty()) {
         auto mReportBugAction = KStandardAction::reportBug(this, &DiscoverObject::reportBug, this);
         m_collection[mReportBugAction->objectName()] = mReportBugAction;
     }
 
     if (KAuthorized::authorizeAction(QStringLiteral("help_about_app"))) {
         auto mAboutAppAction = KStandardAction::aboutApp(this, &DiscoverObject::aboutApplication, this);
         m_collection[mAboutAppAction->objectName()] = mAboutAppAction;
     }
 }
 
 QAction * DiscoverObject::action(const QString& name) const
 {
     return m_collection.value(name);
 }
 
 QString DiscoverObject::iconName(const QIcon& icon)
 {
     return icon.name();
 }
 
 void DiscoverObject::aboutApplication()
 {
     static QPointer<QDialog> dialog;
     if (!dialog) {
         dialog = new KAboutApplicationDialog(KAboutData::applicationData(), nullptr);
         dialog->setAttribute(Qt::WA_DeleteOnClose);
     }
     dialog->show();
 }
 
 void DiscoverObject::reportBug()
 {
     static QPointer<QDialog> dialog;
     if (!dialog) {
         dialog = new KBugReport(KAboutData::applicationData(), nullptr);
         dialog->setAttribute(Qt::WA_DeleteOnClose);
     }
     dialog->show();
 }
 
 void DiscoverObject::switchApplicationLanguage()
 {
 //     auto langDialog = new KSwitchLanguageDialog(nullptr);
 //     connect(langDialog, SIGNAL(finished(int)), this, SLOT(dialogFinished()));
 //     langDialog->show();
 }
 
 void DiscoverObject::setCompactMode(DiscoverObject::CompactMode mode)
 {
     if (m_mode != mode) {
         m_mode = mode;
         Q_EMIT compactModeChanged(m_mode);
     }
 }
 
 class DiscoverTestExecutor : public QObject
 {
 public:
     DiscoverTestExecutor(QObject* rootObject, QQmlEngine* engine, const QUrl &url)
         : QObject(engine)
     {
         connect(engine, &QQmlEngine::quit, this, &DiscoverTestExecutor::finish, Qt::QueuedConnection);
 
         QQmlComponent* component = new QQmlComponent(engine, url, engine);
         m_testObject = component->create(engine->rootContext());
 
         if (!m_testObject) {
             qWarning() << "error loading test" << url << m_testObject << component->errors();
             Q_ASSERT(false);
         }
 
         m_testObject->setProperty("appRoot", QVariant::fromValue<QObject*>(rootObject));
         connect(engine, &QQmlEngine::warnings, this, &DiscoverTestExecutor::processWarnings);
     }
 
     void processWarnings(const QList<QQmlError> &warnings) {
         foreach(const QQmlError &warning, warnings) {
             if (warning.url().path().endsWith(QLatin1String("DiscoverTest.qml"))) {
                 qWarning() << "Test failed!" << warnings;
                 qGuiApp->exit(1);
             }
         }
         m_warnings << warnings;
     }
 
     void finish() {
         //The CI doesn't seem to have icons, remove when it's not an issue anymore
         m_warnings.erase(std::remove_if(m_warnings.begin(), m_warnings.end(), [](const QQmlError& err) -> bool {
             return err.description().contains(QLatin1String("QML Image: Failed to get image from provider: image://icon/"));
         }));
 
         if (m_warnings.isEmpty())
             qDebug() << "cool no warnings!";
         else
             qDebug() << "test finished succesfully despite" << m_warnings;
         qGuiApp->exit(m_warnings.count());
     }
 
 private:
     QObject* m_testObject;
     QList<QQmlError> m_warnings;
 };
 
 void DiscoverObject::loadTest(const QUrl& url)
 {
     new DiscoverTestExecutor(rootObject(), engine(), url);
 }
 
 QWindow* DiscoverObject::rootObject() const
 {
     return qobject_cast<QWindow*>(m_engine->rootObjects().at(0));
 }
 
 void DiscoverObject::setRootObjectProperty(const char* name, const QVariant& value)
 {
     auto ro = rootObject();
     if (!ro) {
         qWarning() << "please check your installation";
         return;
     }
 
     rootObject()->setProperty(name, value);
 }
 
 void DiscoverObject::showPassiveNotification(const QString& msg)
 {
     QTimer::singleShot(100, this, [this, msg](){
         QMetaObject::invokeMethod(rootObject(), "showPassiveNotification", Qt::QueuedConnection, Q_ARG(QVariant, msg), Q_ARG(QVariant, {}), Q_ARG(QVariant, {}), Q_ARG(QVariant, {}));
     });
 }
 
 #include "DiscoverObject.moc"
diff --git a/libdiscover/backends/FlatpakBackend/FlatpakTransactionJob.cpp b/libdiscover/backends/FlatpakBackend/FlatpakTransactionJob.cpp
index d685b63b..20816c28 100644
--- a/libdiscover/backends/FlatpakBackend/FlatpakTransactionJob.cpp
+++ b/libdiscover/backends/FlatpakBackend/FlatpakTransactionJob.cpp
@@ -1,180 +1,179 @@
 /***************************************************************************
  *   Copyright © 2017 Jan Grulich <jgrulich@redhat.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 <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "FlatpakTransactionJob.h"
 #include "FlatpakResource.h"
 
 #include <QDebug>
 
 static void flatpakInstallationProgressCallback(const gchar *stats, guint progress, gboolean estimating, gpointer userData)
 {
     Q_UNUSED(estimating);
     Q_UNUSED(stats);
 
     FlatpakTransactionJob *transactionJob = (FlatpakTransactionJob*)userData;
     if (!transactionJob) {
         return;
     }
 
     transactionJob->setProgress(progress);
-
-    Q_EMIT transactionJob->progressChanged(progress);
 }
 
 FlatpakTransactionJob::FlatpakTransactionJob(FlatpakResource *app, const QPair<QString, uint> &relatedRef, Transaction::Role role)
     : QThread()
     , m_result(false)
     , m_progress(0)
     , m_relatedRef(relatedRef.first)
     , m_relatedRefKind(relatedRef.second)
     , m_app(app)
     , m_role(role)
 {
     m_cancellable = g_cancellable_new();
 }
 
 FlatpakTransactionJob::~FlatpakTransactionJob()
 {
     g_object_unref(m_cancellable);
 }
 
 void FlatpakTransactionJob::cancel()
 {
     g_cancellable_cancel(m_cancellable);
 }
 
 void FlatpakTransactionJob::run()
 {
     g_autoptr(GError) localError = nullptr;
     g_autoptr(FlatpakInstalledRef) ref = nullptr;
 
     const QString refName = m_relatedRef.isEmpty() ? m_app->flatpakName() : m_relatedRef;
     const uint kind = m_relatedRef.isEmpty() ? (uint)m_app->type() : m_relatedRefKind;
 
     if (m_role == Transaction::Role::InstallRole) {
         bool installRelatedRef = false;
         // Before we attempt to upgrade related refs we should verify whether they are installed in first place
         if (m_app->state() == AbstractResource::Upgradeable && !m_relatedRef.isEmpty()) {
             g_autoptr(GError) installedRefError = nullptr;
             FlatpakInstalledRef *installedRef = flatpak_installation_get_installed_ref(m_app->installation(),
                                                                                        kind == FlatpakResource::DesktopApp ? FLATPAK_REF_KIND_APP : FLATPAK_REF_KIND_RUNTIME,
                                                                                        refName.toUtf8().constData(),
                                                                                        m_app->arch().toUtf8().constData(),
                                                                                        m_app->branch().toUtf8().constData(),
                                                                                        m_cancellable, &installedRefError);
             if (installedRefError) {
                 qWarning() << "Failed to check whether related ref is installed: " << installedRefError;
             }
             installRelatedRef = installedRef == nullptr;
         }
 
         if (m_app->state() == AbstractResource::Upgradeable && !installRelatedRef) {
             ref = flatpak_installation_update(m_app->installation(),
                                               FLATPAK_UPDATE_FLAGS_NONE,
                                               kind == FlatpakResource::DesktopApp ? FLATPAK_REF_KIND_APP : FLATPAK_REF_KIND_RUNTIME,
                                               refName.toUtf8().constData(),
                                               m_app->arch().toUtf8().constData(),
                                               m_app->branch().toUtf8().constData(),
                                               flatpakInstallationProgressCallback,
                                               this,
                                               m_cancellable, &localError);
         } else {
             if (m_app->flatpakFileType() == QStringLiteral("flatpak")) {
                 g_autoptr(GFile) file = g_file_new_for_path(m_app->resourceFile().toLocalFile().toUtf8().constData());
                 if (!file) {
                     qWarning() << "Failed to install bundled application" << refName;
                 }
                 ref = flatpak_installation_install_bundle(m_app->installation(), file, flatpakInstallationProgressCallback, this, m_cancellable, &localError);
             } else {
                 ref = flatpak_installation_install(m_app->installation(),
                                                    m_app->origin().toUtf8().constData(),
                                                    kind == FlatpakResource::DesktopApp ? FLATPAK_REF_KIND_APP : FLATPAK_REF_KIND_RUNTIME,
                                                    refName.toUtf8().constData(),
                                                    m_app->arch().toUtf8().constData(),
                                                    m_app->branch().toUtf8().constData(),
                                                    flatpakInstallationProgressCallback,
                                                    this,
                                                    m_cancellable, &localError);
             }
         }
 
         if (!ref) {
             m_result = false;
             m_errorMessage = QString::fromUtf8(localError->message);
             // We are done so we can set the progress to 100
-            m_progress = 100;
+            setProgress(100);
             qWarning() << "Failed to install" << refName << ':' << m_errorMessage;
             return;
         }
     } else if (m_role == Transaction::Role::RemoveRole) {
         if (!flatpak_installation_uninstall(m_app->installation(),
                                             kind == FlatpakResource::DesktopApp ? FLATPAK_REF_KIND_APP : FLATPAK_REF_KIND_RUNTIME,
                                             refName.toUtf8().constData(),
                                             m_app->arch().toUtf8().constData(),
                                             m_app->branch().toUtf8().constData(),
                                             flatpakInstallationProgressCallback,
                                             this,
                                             m_cancellable, &localError)) {
             m_result = false;
             m_errorMessage = QString::fromUtf8(localError->message);
             // We are done so we can set the progress to 100
-            m_progress = 100;
+            setProgress(100);
             qWarning() << "Failed to uninstall" << refName << ':' << m_errorMessage;
             return;
         }
     }
 
     // We are done so we can set the progress to 100
-    m_progress = 100;
     m_result = true;
-
-    Q_EMIT progressChanged(m_progress);
+    setProgress(100);
 }
 
 FlatpakResource * FlatpakTransactionJob::app() const
 {
     return m_app;
 }
 
 bool FlatpakTransactionJob::isRelated() const
 {
     return !m_relatedRef.isEmpty();
 }
 
 int FlatpakTransactionJob::progress() const
 {
     return m_progress;
 }
 
 void FlatpakTransactionJob::setProgress(int progress)
 {
-    m_progress = progress;
+    if (m_progress != progress) {
+        m_progress = progress;
+        Q_EMIT progressChanged(m_progress);
+    }
 }
 
 QString FlatpakTransactionJob::errorMessage() const
 {
     return m_errorMessage;
 }
 
 bool FlatpakTransactionJob::result() const
 {
     return m_result;
 }
 
diff --git a/libdiscover/backends/PackageKitBackend/AppPackageKitResource.cpp b/libdiscover/backends/PackageKitBackend/AppPackageKitResource.cpp
index 82bfd3bf..16db9429 100644
--- a/libdiscover/backends/PackageKitBackend/AppPackageKitResource.cpp
+++ b/libdiscover/backends/PackageKitBackend/AppPackageKitResource.cpp
@@ -1,219 +1,246 @@
 /***************************************************************************
  *   Copyright © 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.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 <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "AppPackageKitResource.h"
 #include <AppStreamQt/screenshot.h>
 #include <AppStreamQt/icon.h>
 #include <AppStreamQt/image.h>
 #include <AppStreamQt/release.h>
 #include <appstream/AppStreamUtils.h>
+#include <PackageKit/Daemon>
 #include <KLocalizedString>
 #include <KToolInvocation>
 #include <QIcon>
 #include <QProcess>
 #include <QStandardPaths>
 #include <QDebug>
 #include "config-paths.h"
+#include "utils.h"
 
 AppPackageKitResource::AppPackageKitResource(const AppStream::Component& data, const QString &packageName, PackageKitBackend* parent)
     : PackageKitResource(packageName, QString(), parent)
     , m_appdata(data)
 {
     Q_ASSERT(data.isValid());
 }
 
 QString AppPackageKitResource::name() const
 {
     QString ret;
     if (!m_appdata.extends().isEmpty()) {
         auto components = backend()->componentsById(m_appdata.extends().constFirst());
-        Q_ASSERT(!components.isEmpty());
-        ret = components.constFirst().name() + QStringLiteral(" - ") + m_appdata.name();
-    } else
+
+        if (components.isEmpty())
+            qWarning() << "couldn't find" << m_appdata.extends() << "which is supposedly extended by" << m_appdata.id();
+        else
+            ret = components.constFirst().name() + QStringLiteral(" - ") + m_appdata.name();
+    }
+
+    if (ret.isEmpty())
         ret = m_appdata.name();
     return ret;
 }
 
 QString AppPackageKitResource::longDescription()
 {
     const auto desc = m_appdata.description();
     if (!desc.isEmpty())
         return desc;
 
     return PackageKitResource::longDescription();
 }
 
 static QIcon componentIcon(const AppStream::Component &comp)
 {
     QIcon ret;
     foreach(const AppStream::Icon &icon, comp.icons()) {
         QStringList stock;
         switch(icon.kind()) {
             case AppStream::Icon::KindLocal:
                 ret.addFile(icon.url().toLocalFile(), icon.size());
                 break;
             case AppStream::Icon::KindCached:
                 ret.addFile(icon.url().toLocalFile(), icon.size());
                 break;
             case AppStream::Icon::KindStock: {
                 const auto ret = QIcon::fromTheme(icon.name());
                 if (!ret.isNull())
                     return ret;
                 break;
             }
             default:
                 break;
         }
     }
     if (ret.isNull()) {
         ret = QIcon::fromTheme(QStringLiteral("package-x-generic"));
     }
     return ret;
 }
 
 QVariant AppPackageKitResource::icon() const
 {
     return componentIcon(m_appdata);
 }
 
 QString AppPackageKitResource::license()
 {
     const auto license = m_appdata.projectLicense();
     return license.isEmpty() ? PackageKitResource::license() : license;
 }
 
 QStringList AppPackageKitResource::mimetypes() const
 {
     return m_appdata.provided(AppStream::Provided::KindMimetype).items();
 }
 
 QStringList AppPackageKitResource::categories()
 {
     auto cats = m_appdata.categories();
     if (m_appdata.kind() != AppStream::Component::KindAddon)
         cats.append(QStringLiteral("Application"));
     return cats;
 }
 
 QString AppPackageKitResource::comment()
 {
     const auto summary = m_appdata.summary();
     if (!summary.isEmpty())
         return summary;
 
     return PackageKitResource::comment();
 }
 
 QString AppPackageKitResource::appstreamId() const
 {
     return m_appdata.id();
 }
 
 QUrl AppPackageKitResource::homepage()
 {
     return m_appdata.url(AppStream::Component::UrlKindHomepage);
 }
 
 QUrl AppPackageKitResource::helpURL()
 {
     return m_appdata.url(AppStream::Component::UrlKindHelp);
 }
 
 QUrl AppPackageKitResource::bugURL()
 {
     return m_appdata.url(AppStream::Component::UrlKindBugtracker);
 }
 
 QUrl AppPackageKitResource::donationURL()
 {
     return m_appdata.url(AppStream::Component::UrlKindDonation);
 }
 
 bool AppPackageKitResource::isTechnical() const
 {
     static QString desktop = QString::fromUtf8(qgetenv("XDG_CURRENT_DESKTOP"));
     const auto desktops = m_appdata.compulsoryForDesktops();
     return (!desktops.isEmpty() && !desktops.contains(desktop)) || m_appdata.kind() == AppStream::Component::KindAddon;
 }
 
 void AppPackageKitResource::fetchScreenshots()
 {
     QList<QUrl> thumbnails, screenshots;
 
     Q_FOREACH (const AppStream::Screenshot &s, m_appdata.screenshots()) {
         const QUrl thumbnail = AppStreamUtils::imageOfKind(s.images(), AppStream::Image::KindThumbnail);
         const QUrl plain = AppStreamUtils::imageOfKind(s.images(), AppStream::Image::KindSource);
         if (plain.isEmpty())
             qWarning() << "invalid screenshot for" << name();
 
         screenshots << plain;
         thumbnails << (thumbnail.isEmpty() ? plain : thumbnail);
     }
 
     Q_EMIT screenshotsFetched(thumbnails, screenshots);
 }
 
 QStringList AppPackageKitResource::allPackageNames() const
 {
     return m_appdata.packageNames();
 }
 
 QList<PackageState> AppPackageKitResource::addonsInformation()
 {
     const PackageKitBackend* p = static_cast<PackageKitBackend*>(parent());
     const QVector<AppPackageKitResource*> res = p->extendedBy(m_appdata.id());
 
     QList<PackageState> ret;
     Q_FOREACH (AppPackageKitResource* r, res) {
         ret += PackageState(r->appstreamId(), r->name(), r->comment(), r->isInstalled());
     }
     return ret;
 }
 
 QStringList AppPackageKitResource::extends() const
 {
     return m_appdata.extends();
 }
 
 void AppPackageKitResource::fetchChangelog()
 {
     emit changelogFetched(AppStreamUtils::changelogToHtml(m_appdata));
 }
 
 void AppPackageKitResource::invokeApplication() const
 {
-    const QStringList exes = m_appdata.provided(AppStream::Provided::KindBinary).items();
-    if (exes.isEmpty()) {
-        const auto servicePath = QStandardPaths::locate(QStandardPaths::ApplicationsLocation, m_appdata.id());
-        QProcess::startDetached(QStringLiteral(CMAKE_INSTALL_FULL_LIBEXECDIR_KF5 "/discover/runservice"), {servicePath});
-    } else {
-        QProcess::startDetached(exes.constFirst());
-    }
+    auto trans = PackageKit::Daemon::getFiles({installedPackageId()});
+    connect(trans, &PackageKit::Transaction::files, this, [this](const QString &/*packageID*/, const QStringList &filenames) {
+        const auto allServices = QStandardPaths::locateAll(QStandardPaths::ApplicationsLocation, m_appdata.id());
+        if (!allServices.isEmpty()) {
+            const auto packageServices = kFilter<QStringList>(allServices, [filenames](const QString &file) { return filenames.contains(file); });
+            QProcess::startDetached(QStringLiteral(CMAKE_INSTALL_FULL_LIBEXECDIR_KF5 "/discover/runservice"), {packageServices});
+        } else {
+            const QStringList exes = m_appdata.provided(AppStream::Provided::KindBinary).items();
+            const auto packageExecutables = kFilter<QStringList>(allServices, [filenames](const QString &exe) { return filenames.contains(QLatin1Char('/') + exe); });
+            if (!packageExecutables.isEmpty()) {
+                QProcess::startDetached(exes.constFirst());
+            } else {
+                const auto locations = QStandardPaths::standardLocations(QStandardPaths::ApplicationsLocation);
+                const auto desktopFiles = kFilter<QStringList>(filenames, [locations](const QString &exe) {
+                    for (const auto &location: locations) {
+                        if (exe.startsWith(location))
+                            return exe.contains(QLatin1String(".desktop"));
+                    }
+                    return false;
+                });
+                if (!desktopFiles.isEmpty()) {
+                    QProcess::startDetached(QStringLiteral(CMAKE_INSTALL_FULL_LIBEXECDIR_KF5 "/discover/runservice"), { desktopFiles });
+                }
+            }
+            qWarning() << "Could not find any executables" << exes << filenames;
+        }
+    });
 }
 
 QDate AppPackageKitResource::releaseDate() const
 {
     if (!m_appdata.releases().isEmpty()) {
         auto release = m_appdata.releases().constFirst();
         return release.timestamp().date();
     }
 
     return {};
 }
diff --git a/libdiscover/backends/PackageKitBackend/PKTransaction.cpp b/libdiscover/backends/PackageKitBackend/PKTransaction.cpp
index acee04fb..5ceefad6 100644
--- a/libdiscover/backends/PackageKitBackend/PKTransaction.cpp
+++ b/libdiscover/backends/PackageKitBackend/PKTransaction.cpp
@@ -1,273 +1,275 @@
 /***************************************************************************
  *   Copyright © 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.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 <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "PKTransaction.h"
 #include "PackageKitBackend.h"
 #include "PackageKitResource.h"
 #include "PackageKitMessages.h"
 #include "utils.h"
 #include "LocalFilePKResource.h"
 #include <resources/AbstractResource.h>
 #include <QDebug>
 #include <QTimer>
 #include <KLocalizedString>
 #include <PackageKit/Transaction>
 #include <PackageKit/Daemon>
 #include <functional>
 
 PKTransaction::PKTransaction(const QVector<AbstractResource*>& apps, Transaction::Role role)
     : Transaction(apps.first(), apps.first(), role)
     , m_apps(apps)
 {
     Q_ASSERT(!apps.contains(nullptr));
     foreach(auto r, apps) {
         PackageKitResource* res = qobject_cast<PackageKitResource*>(r);
         m_pkgnames.unite(res->allPackageNames().toSet());
     }
 
     QTimer::singleShot(0, this, &PKTransaction::start);
 }
 
 static QStringList packageIds(const QVector<AbstractResource*>& res, std::function<QString(PackageKitResource*)> func)
 {
     QStringList ret;
     foreach(auto r, res) {
         ret += func(qobject_cast<PackageKitResource*>(r));
     }
     ret.removeDuplicates();
     return ret;
 }
 
 void PKTransaction::start()
 {
     trigger(PackageKit::Transaction::TransactionFlagSimulate);
 }
 
 void PKTransaction::trigger(PackageKit::Transaction::TransactionFlags flags)
 {
     if (m_trans)
         m_trans->deleteLater();
     m_newPackageStates.clear();
 
     if (m_apps.size() == 1 && qobject_cast<LocalFilePKResource*>(m_apps.at(0))) {
         auto app = qobject_cast<LocalFilePKResource*>(m_apps.at(0));
         m_trans = PackageKit::Daemon::installFile(QUrl(app->packageName()).toLocalFile(), flags);
         connect(m_trans.data(), &PackageKit::Transaction::finished, this, [app](PackageKit::Transaction::Exit status) {
             if (status == PackageKit::Transaction::ExitSuccess) {
                 app->markInstalled();
             }
         });
     } else switch (role()) {
         case Transaction::ChangeAddonsRole:
         case Transaction::InstallRole:
             m_trans = PackageKit::Daemon::installPackages(packageIds(m_apps, [](PackageKitResource* r){return r->availablePackageId(); }), flags);
             break;
         case Transaction::RemoveRole:
             //see bug #315063
             m_trans = PackageKit::Daemon::removePackages(packageIds(m_apps, [](PackageKitResource* r){return r->installedPackageId(); }), true /*allowDeps*/, false, flags);
             break;
     };
     Q_ASSERT(m_trans);
 
 //     connect(m_trans.data(), &PackageKit::Transaction::statusChanged, this, [this]() { qDebug() << "state..." << m_trans->status(); });
     connect(m_trans.data(), &PackageKit::Transaction::package, this, &PKTransaction::packageResolved);
     connect(m_trans.data(), &PackageKit::Transaction::finished, this, &PKTransaction::cleanup);
     connect(m_trans.data(), &PackageKit::Transaction::errorCode, this, &PKTransaction::errorFound);
     connect(m_trans.data(), &PackageKit::Transaction::mediaChangeRequired, this, &PKTransaction::mediaChange);
     connect(m_trans.data(), &PackageKit::Transaction::requireRestart, this, &PKTransaction::requireRestart);
     connect(m_trans.data(), &PackageKit::Transaction::repoSignatureRequired, this, &PKTransaction::repoSignatureRequired);
     connect(m_trans.data(), &PackageKit::Transaction::itemProgress, this, &PKTransaction::progressChanged);
     connect(m_trans.data(), &PackageKit::Transaction::eulaRequired, this, &PKTransaction::eulaRequired);
     connect(m_trans.data(), &PackageKit::Transaction::allowCancelChanged, this, &PKTransaction::cancellableChanged);
     connect(m_trans.data(), &PackageKit::Transaction::speedChanged, this, [this]() {
         setDownloadSpeed(m_trans->speed());
     });
     
     setCancellable(m_trans->allowCancel());
 }
 
 void PKTransaction::progressChanged(const QString &id, PackageKit::Transaction::Status status, uint percentage)
 {
     PackageKitResource * res = qobject_cast<PackageKitResource*>(resource());
     if (!res->allPackageNames().contains(PackageKit::Daemon::packageName(id)))
         return;
 
     setProgress(percentage);
 
     if (status == PackageKit::Transaction::StatusDownload)
         setStatus(Transaction::DownloadingStatus);
     else
         setStatus(Transaction::CommittingStatus);
 }
 
 void PKTransaction::cancellableChanged()
 {
     setCancellable(m_trans->allowCancel());
 }
 
 void PKTransaction::cancel()
 {
     if (!m_trans) {
         setStatus(CancelledStatus);
     } else if (m_trans->allowCancel()) {
         m_trans->cancel();
     } else {
         qWarning() << "trying to cancel a non-cancellable transaction: " << resource()->name();
     }
 }
 
 void PKTransaction::cleanup(PackageKit::Transaction::Exit exit, uint runtime)
 {
     Q_UNUSED(runtime)
     const bool cancel = !m_proceedFunctions.isEmpty() || exit == PackageKit::Transaction::ExitCancelled;
     const bool simulate = m_trans->transactionFlags() & PackageKit::Transaction::TransactionFlagSimulate;
 
     disconnect(m_trans, nullptr, this, nullptr);
     m_trans = nullptr;
 
     const auto backend = qobject_cast<PackageKitBackend*>(resource()->backend());
 
     if (!cancel && simulate) {
         auto packagesToRemove = m_newPackageStates.value(PackageKit::Transaction::InfoRemoving);
         QMutableListIterator<QString> i(packagesToRemove);
         QSet<AbstractResource*> removedResources;
         while (i.hasNext()) {
             const auto pkgname = PackageKit::Daemon::packageName(i.next());
             removedResources.unite(backend->resourcesByPackageName(pkgname));
 
             if (m_pkgnames.contains(pkgname)) {
                 i.remove();
             }
         }
         removedResources.subtract(m_apps.toList().toSet());
 
         if (!packagesToRemove.isEmpty() || !removedResources.isEmpty()) {
             QString msg = QStringLiteral("<ul><li>") + PackageKitResource::joinPackages(packagesToRemove, QStringLiteral("</li><li>"));
             if (!removedResources.isEmpty()) {
                 const QStringList removedResourcesStr = kTransform<QStringList>(removedResources, [](AbstractResource* a) { return a->name(); });
                 msg += QLatin1Char('\n');
                 msg += removedResourcesStr.join(QStringLiteral("</li><li>"));
             }
             msg += QStringLiteral("</li></ul>");
 
             Q_EMIT proceedRequest(i18n("Confirm package removal"), i18np("This action will also remove the following package:\n%2", "This action will also remove the following packages:\n%2", packagesToRemove.count(), msg));
         } else {
             proceed();
         }
         return;
     }
 
     this->submitResolve();
     setStatus(Transaction::CancelledStatus);
 }
 
 void PKTransaction::processProceedFunction()
 {
     auto t = m_proceedFunctions.takeFirst()();
     connect(t, &PackageKit::Transaction::finished, this, [this](PackageKit::Transaction::Exit status) {
         if (status != PackageKit::Transaction::Exit::ExitSuccess) {
             qWarning() << "transaction failed" << sender() << status;
             cancel();
             return;
         }
 
         if (!m_proceedFunctions.isEmpty()) {
             processProceedFunction();
         } else {
             start();
         }
     });
 }
 
 void PKTransaction::proceed()
 {
     if (!m_proceedFunctions.isEmpty()) {
         processProceedFunction();
     } else {
         trigger(PackageKit::Transaction::TransactionFlagOnlyTrusted);
     }
 }
 
 void PKTransaction::packageResolved(PackageKit::Transaction::Info info, const QString& packageId)
 {
     m_newPackageStates[info].append(packageId);
 }
 
 void PKTransaction::submitResolve()
 {
     QStringList needResolving;
-    const auto pkgids = m_newPackageStates.value(PackageKit::Transaction::InfoFinished);
-    foreach(const auto pkgid, pkgids) {
-        needResolving += PackageKit::Daemon::packageName(pkgid);
+    foreach(const auto &pkgids, m_newPackageStates) {
+        foreach(const auto &pkgid, pkgids) {
+            needResolving += PackageKit::Daemon::packageName(pkgid);
+        }
     }
-    const auto backend = qobject_cast<PackageKitBackend*>(resource()->backend());
 
     if (!needResolving.isEmpty()) {
+        needResolving.removeDuplicates();
+        const auto backend = qobject_cast<PackageKitBackend*>(resource()->backend());
         backend->clearPackages(needResolving);
         backend->resolvePackages(needResolving);
     }
 }
 
 PackageKit::Transaction* PKTransaction::transaction()
 {
     return m_trans;
 }
 
 void PKTransaction::eulaRequired(const QString& eulaID, const QString& packageID, const QString& vendor, const QString& licenseAgreement)
 {
     m_proceedFunctions << [eulaID](){
         return PackageKit::Daemon::acceptEula(eulaID);
     };
 
     Q_EMIT proceedRequest(i18n("Accept EULA"), i18n("The package %1 and its vendor %2 require that you accept their license:\n %3",
                                                  PackageKit::Daemon::packageName(packageID), vendor, licenseAgreement));
 }
 
 void PKTransaction::errorFound(PackageKit::Transaction::Error err, const QString& error)
 {
     if (err == PackageKit::Transaction::ErrorNoLicenseAgreement)
         return;
     qWarning() << "PackageKit error:" << err << PackageKitMessages::errorMessage(err) << error;
     Q_EMIT passiveMessage(PackageKitMessages::errorMessage(err));
 }
 
 void PKTransaction::mediaChange(PackageKit::Transaction::MediaType media, const QString& type, const QString& text)
 {
     Q_UNUSED(media)
     Q_EMIT passiveMessage(i18n("Media Change of type '%1' is requested.\n%2", type, text));
 }
 
 void PKTransaction::requireRestart(PackageKit::Transaction::Restart restart, const QString& pkgid)
 {
     Q_EMIT passiveMessage(PackageKitMessages::restartMessage(restart, pkgid));
 }
 
 void PKTransaction::repoSignatureRequired(const QString& packageID, const QString& repoName, const QString& keyUrl,
                                           const QString& keyUserid, const QString& keyId, const QString& keyFingerprint,
                                           const QString& keyTimestamp, PackageKit::Transaction::SigType type)
 {
     Q_EMIT proceedRequest(i18n("Missing signature for %1 in %2", packageID, repoName),
                           i18n("Do you trust the following key?\n\nUrl: %1\nUser: %2\nKey: %3\nFingerprint: %4\nTimestamp: %4\n",
                                keyUrl, keyUserid, keyFingerprint, keyTimestamp));
 
     m_proceedFunctions << [type, keyId, packageID](){
         return PackageKit::Daemon::installSignature(type, keyId, packageID);
     };
 }
diff --git a/libdiscover/backends/PackageKitBackend/PackageKitBackend.cpp b/libdiscover/backends/PackageKitBackend/PackageKitBackend.cpp
index 857fd252..9ec8dd13 100644
--- a/libdiscover/backends/PackageKitBackend/PackageKitBackend.cpp
+++ b/libdiscover/backends/PackageKitBackend/PackageKitBackend.cpp
@@ -1,652 +1,657 @@
 /***************************************************************************
  *   Copyright © 2012 Aleix Pol Gonzalez <aleixpol@blue-systems.com>       *
  *   Copyright © 2013 Lukas Appelhans <l.appelhans@gmx.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 <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "PackageKitBackend.h"
 #include "PackageKitSourcesBackend.h"
 #include "PackageKitResource.h"
 #include "PackageKitUpdater.h"
 #include "AppPackageKitResource.h"
 #include "PKTransaction.h"
 #include "LocalFilePKResource.h"
 #include "TransactionSet.h"
 #include <resources/AbstractResource.h>
 #include <resources/StandardBackendUpdater.h>
 #include <resources/SourcesModel.h>
 #include <appstream/OdrsReviewsBackend.h>
 #include <appstream/AppStreamIntegration.h>
 
 #include <QProcess>
 #include <QStringList>
 #include <QDebug>
 #include <QTimer>
 #include <QStandardPaths>
 #include <QFile>
 
 #include <PackageKit/Transaction>
 #include <PackageKit/Daemon>
 #include <PackageKit/Details>
 
 #include <KLocalizedString>
 #include <QAction>
 #include <QMimeDatabase>
 
 #include "utils.h"
 #include "config-paths.h"
 
 DISCOVER_BACKEND_PLUGIN(PackageKitBackend)
 
 QString PackageKitBackend::locateService(const QString &filename)
 {
     return QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("applications/")+filename);
 }
 
 PackageKitBackend::PackageKitBackend(QObject* parent)
     : AbstractResourcesBackend(parent)
     , m_updater(new PackageKitUpdater(this))
     , m_refresher(nullptr)
     , m_isFetching(0)
     , m_reviews(AppStreamIntegration::global()->reviews())
 {
     QTimer* t = new QTimer(this);
     connect(t, &QTimer::timeout, this, &PackageKitBackend::refreshDatabase);
     t->setInterval(60 * 60 * 1000);
     t->setSingleShot(false);
     t->start();
 
     m_delayedDetailsFetch.setSingleShot(true);
     m_delayedDetailsFetch.setInterval(0);
     connect(&m_delayedDetailsFetch, &QTimer::timeout, this, &PackageKitBackend::performDetailsFetch);
 
     connect(PackageKit::Daemon::global(), &PackageKit::Daemon::updatesChanged, this, &PackageKitBackend::fetchUpdates);
     connect(PackageKit::Daemon::global(), &PackageKit::Daemon::isRunningChanged, this, &PackageKitBackend::checkDaemonRunning);
     connect(m_reviews.data(), &OdrsReviewsBackend::ratingsReady, this, &AbstractResourcesBackend::emitRatingsReady);
 
     SourcesModel::global()->addSourcesBackend(new PackageKitSourcesBackend(this));
 
     QString error;
     const bool b = m_appdata.load(&error);
     reloadPackageList();
 
     if (!b && m_packages.packages.isEmpty()) {
         qWarning() << "Could not open the AppStream metadata pool" << error;
 
         QTimer::singleShot(0, this, [this]() {
             Q_EMIT passiveMessage(i18n("Please make sure that Appstream is properly set up on your system"));
         });
     }
 }
 
 PackageKitBackend::~PackageKitBackend() = default;
 
 bool PackageKitBackend::isFetching() const
 {
     return m_isFetching;
 }
 
 void PackageKitBackend::acquireFetching(bool f)
 {
     if (f)
         m_isFetching++;
     else
         m_isFetching--;
 
     if ((!f && m_isFetching==0) || (f && m_isFetching==1)) {
         emit fetchingChanged();
     }
     Q_ASSERT(m_isFetching>=0);
 }
 
 void PackageKitBackend::reloadPackageList()
 {
     acquireFetching(true);
     if (m_refresher) {
         disconnect(m_refresher.data(), &PackageKit::Transaction::finished, this, &PackageKitBackend::reloadPackageList);
     }
 
     const auto components = m_appdata.components();
     QStringList neededPackages;
     neededPackages.reserve(components.size());
     foreach(const AppStream::Component& component, components) {
         if (component.kind() == AppStream::Component::KindFirmware)
             continue;
 
         const auto pkgNames = component.packageNames();
         if (pkgNames.isEmpty()) {
             if (component.kind() == AppStream::Component::KindDesktopApp) {
                 const QString file = locateService(component.desktopId());
                 if (!file.isEmpty()) {
                     auto trans = PackageKit::Daemon::searchFiles(file);
                     connect(trans, &PackageKit::Transaction::package, this, [trans](PackageKit::Transaction::Info info, const QString &packageID){
                         if (info == PackageKit::Transaction::InfoInstalled)
                             trans->setProperty("installedPackage", packageID);
                     });
                     connect(trans, &PackageKit::Transaction::finished, this, [this, trans, component](PackageKit::Transaction::Exit status) {
                         const auto pkgidVal = trans->property("installedPackage");
                         if (status == PackageKit::Transaction::ExitSuccess && !pkgidVal.isNull()) {
                             const auto pkgid = pkgidVal.toString();
                             acquireFetching(true);
                             auto res = addComponent(component, {PackageKit::Daemon::packageName(pkgid)});
                             res->addPackageId(PackageKit::Transaction::InfoInstalled, pkgid, true);
                             acquireFetching(false);
                         }
                     });
                     continue;
                 }
             }
 
             qDebug() << "no packages for" << component.id();
             continue;
         }
         neededPackages += pkgNames;
 
         addComponent(component, pkgNames);
     }
 
     acquireFetching(false);
     neededPackages.removeDuplicates();
     resolvePackages(neededPackages);
 }
 
 AppPackageKitResource* PackageKitBackend::addComponent(const AppStream::Component& component, const QStringList& pkgNames)
 {
     Q_ASSERT(isFetching());
     Q_ASSERT(!pkgNames.isEmpty());
 
     const auto res = new AppPackageKitResource(component, pkgNames.at(0), this);
     m_packages.packages[component.id()] = res;
     foreach (const QString& pkg, pkgNames) {
         m_packages.packageToApp[pkg] += component.id();
     }
 
     foreach (const QString& pkg, component.extends()) {
         m_packages.extendedBy[pkg] += res;
     }
     return res;
 }
 
 void PackageKitBackend::clearPackages(const QStringList& packageNames)
 {
     const auto resources = resourcesByPackageNames<QVector<AbstractResource*>>(packageNames);
     for(auto res: resources) {
         qobject_cast<PackageKitResource*>(res)->clearPackageIds();
     }
 }
 
 void PackageKitBackend::resolvePackages(const QStringList &packageNames)
 {
     PackageKit::Transaction * tArch = PackageKit::Daemon::resolve(packageNames, PackageKit::Transaction::FilterArch);
     connect(tArch, &PackageKit::Transaction::package, this, &PackageKitBackend::addPackageArch);
     connect(tArch, &PackageKit::Transaction::errorCode, this, &PackageKitBackend::transactionError);
 
     PackageKit::Transaction * tNotArch = PackageKit::Daemon::resolve(packageNames, PackageKit::Transaction::FilterNotArch);
     connect(tNotArch, &PackageKit::Transaction::package, this, &PackageKitBackend::addPackageNotArch);
     connect(tNotArch, &PackageKit::Transaction::errorCode, this, &PackageKitBackend::transactionError);
 
     TransactionSet* merge = new TransactionSet({tArch, tNotArch});
     connect(merge, &TransactionSet::allFinished, this, &PackageKitBackend::getPackagesFinished);
     fetchUpdates();
 }
 
 void PackageKitBackend::fetchUpdates()
 {
     if (m_updater->isProgressing())
         return;
 
     PackageKit::Transaction * tUpdates = PackageKit::Daemon::getUpdates();
     connect(tUpdates, &PackageKit::Transaction::finished, this, &PackageKitBackend::getUpdatesFinished);
     connect(tUpdates, &PackageKit::Transaction::package, this, &PackageKitBackend::addPackageToUpdate);
     connect(tUpdates, &PackageKit::Transaction::errorCode, this, &PackageKitBackend::transactionError);
     m_updatesPackageId.clear();
     m_hasSecurityUpdates = false;
 
     m_updater->setProgressing(true);
 }
 
 void PackageKitBackend::addPackageArch(PackageKit::Transaction::Info info, const QString& packageId, const QString& summary)
 {
     addPackage(info, packageId, summary, true);
 }
 
 void PackageKitBackend::addPackageNotArch(PackageKit::Transaction::Info info, const QString& packageId, const QString& summary)
 {
     addPackage(info, packageId, summary, false);
 }
 
 void PackageKitBackend::addPackage(PackageKit::Transaction::Info info, const QString &packageId, const QString &summary, bool arch)
 {
     const QString packageName = PackageKit::Daemon::packageName(packageId);
     QSet<AbstractResource*> r = resourcesByPackageName(packageName);
     if (r.isEmpty()) {
         auto pk = new PackageKitResource(packageName, summary, this);
         r = { pk };
         m_packagesToAdd.insert(pk);
     }
     foreach(auto res, r)
         static_cast<PackageKitResource*>(res)->addPackageId(info, packageId, arch);
 }
 
 void PackageKitBackend::getPackagesFinished()
 {
     for(auto it = m_packages.packages.cbegin(); it != m_packages.packages.cend(); ++it) {
         auto pkr = qobject_cast<PackageKitResource*>(it.value());
         if (pkr->packages().isEmpty()) {
 //             qWarning() << "Failed to find package for" << it.key();
             m_packagesToDelete += pkr;
         }
     }
     includePackagesToAdd();
 }
 
 void PackageKitBackend::includePackagesToAdd()
 {
     if (m_packagesToAdd.isEmpty() && m_packagesToDelete.isEmpty())
         return;
 
     acquireFetching(true);
     foreach(PackageKitResource* res, m_packagesToAdd) {
         m_packages.packages[res->packageName()] = res;
     }
     foreach(PackageKitResource* res, m_packagesToDelete) {
         const auto pkgs = m_packages.packageToApp.value(res->packageName(), {res->packageName()});
         foreach(const auto &pkg, pkgs) {
             auto res = m_packages.packages.take(pkg);
             if (res) {
+                if (AppPackageKitResource* ares = qobject_cast<AppPackageKitResource*>(res)) {
+                    for(const auto &ext: res->extends())
+                        m_packages.extendedBy[ext].removeAll(ares);
+                }
+
                 emit resourceRemoved(res);
                 res->deleteLater();
             }
         }
     }
     m_packagesToAdd.clear();
     m_packagesToDelete.clear();
     acquireFetching(false);
 }
 
 void PackageKitBackend::transactionError(PackageKit::Transaction::Error, const QString& message)
 {
     qWarning() << "Transaction error: " << message << sender();
     Q_EMIT passiveMessage(message);
 }
 
 void PackageKitBackend::packageDetails(const PackageKit::Details& details)
 {
     const QSet<AbstractResource*> resources = resourcesByPackageName(PackageKit::Daemon::packageName(details.packageId()));
     if (resources.isEmpty())
         qWarning() << "couldn't find package for" << details.packageId();
 
     foreach(AbstractResource* res, resources) {
         qobject_cast<PackageKitResource*>(res)->setDetails(details);
     }
 }
 
 QSet<AbstractResource*> PackageKitBackend::resourcesByPackageName(const QString& name) const
 {
     return resourcesByPackageNames<QSet<AbstractResource*>>({name});
 }
 
 template <typename T>
 T PackageKitBackend::resourcesByPackageNames(const QStringList &pkgnames) const
 {
     T ret;
     ret.reserve(pkgnames.size());
     for(const QString &name : pkgnames) {
         const QStringList names = m_packages.packageToApp.value(name, QStringList(name));
         foreach(const QString& name, names) {
             AbstractResource* res = m_packages.packages.value(name);
             if (res)
                 ret += res;
         }
     }
     return ret;
 }
 
 void PackageKitBackend::checkForUpdates()
 {
     refreshDatabase();
 }
 
 void PackageKitBackend::refreshDatabase()
 {
     if (!m_refresher) {
         acquireFetching(true);
         m_refresher = PackageKit::Daemon::refreshCache(false);
         connect(m_refresher.data(), &PackageKit::Transaction::errorCode, this, &PackageKitBackend::transactionError);
         connect(m_refresher.data(), &PackageKit::Transaction::finished, this, [this]() {
             reloadPackageList();
             acquireFetching(false);
         });
     } else {
         qWarning() << "already resetting";
     }
 }
 
 QList<AppStream::Component> PackageKitBackend::componentsById(const QString& id) const
 {
     return m_appdata.componentsById(id);
 }
 
 ResultsStream* PackageKitBackend::search(const AbstractResourcesBackend::Filters& filter)
 {
     if (!filter.resourceUrl.isEmpty()) {
         return findResourceByPackageName(filter.resourceUrl);
     } else if (!filter.extends.isEmpty()) {
         const auto ext = kTransform<QVector<AbstractResource*>>(m_packages.extendedBy[filter.extends], [](AppPackageKitResource* a){ return a; });
         return new ResultsStream(QStringLiteral("PackageKitStream-extends"), ext);
     } else if (filter.search.isEmpty()) {
         return new ResultsStream(QStringLiteral("PackageKitStream-all"), kFilter<QVector<AbstractResource*>>(m_packages.packages, [](AbstractResource* res) { return !res->isTechnical(); }));
     } else {
         const QList<AppStream::Component> components = m_appdata.search(filter.search);
         const QStringList ids = kTransform<QStringList>(components, [](const AppStream::Component& comp) { return comp.id(); });
         auto stream = new ResultsStream(QStringLiteral("PackageKitStream-search"));
         if (!ids.isEmpty()) {
             const auto resources = resourcesByPackageNames<QVector<AbstractResource*>>(ids);
             QTimer::singleShot(0, this, [stream, resources] () {
                 stream->resourcesFound(resources);
             });
         }
 
         PackageKit::Transaction * tArch = PackageKit::Daemon::resolve(filter.search, PackageKit::Transaction::FilterArch);
         connect(tArch, &PackageKit::Transaction::package, this, &PackageKitBackend::addPackageArch);
         connect(tArch, &PackageKit::Transaction::package, stream, [stream](PackageKit::Transaction::Info /*info*/, const QString &packageId){
             stream->setProperty("packageId", packageId);
         });
         connect(tArch, &PackageKit::Transaction::finished, stream, [stream, ids, this](PackageKit::Transaction::Exit status) {
             getPackagesFinished();
             if (status == PackageKit::Transaction::Exit::ExitSuccess) {
                 const auto packageId = stream->property("packageId");
                 if (!packageId.isNull()) {
                     const auto res = resourcesByPackageNames<QVector<AbstractResource*>>({PackageKit::Daemon::packageName(packageId.toString())});
                     stream->resourcesFound(kFilter<QVector<AbstractResource*>>(res, [ids](AbstractResource* res){ return !ids.contains(res->appstreamId()); }));
                 }
             }
             stream->finish();
         }, Qt::QueuedConnection);
         return stream;
     }
 }
 
 ResultsStream * PackageKitBackend::findResourceByPackageName(const QUrl& url)
 {
     AbstractResource* pkg = nullptr;
     if (url.host().isEmpty())
         passiveMessage(i18n("Malformed appstream url '%1'", url.toDisplayString()));
     else if (url.scheme() == QLatin1String("appstream")) {
         static const QMap<QString, QString> deprecatedAppstreamIds = {
             { QStringLiteral("org.kde.krita.desktop"), QStringLiteral("krita.desktop") },
             { QStringLiteral("org.kde.digikam.desktop"), QStringLiteral("digikam.desktop") },
             { QStringLiteral("org.kde.ktorrent.desktop"), QStringLiteral("ktorrent.desktop") },
             { QStringLiteral("org.kde.gcompris.desktop"), QStringLiteral("gcompris.desktop") },
             { QStringLiteral("org.kde.kmymoney.desktop"), QStringLiteral("kmymoney.desktop") },
             { QStringLiteral("org.kde.kolourpaint.desktop"), QStringLiteral("kolourpaint.desktop") },
             { QStringLiteral("org.blender.blender.desktop"), QStringLiteral("blender.desktop") },
         };
         
         const auto host = url.host();
         if (host.isEmpty())
             passiveMessage(i18n("Malformed appstream url '%1'", url.toDisplayString()));
         else {
             const auto deprecatedHost = deprecatedAppstreamIds.value(url.host()); //try this as fallback
             for (auto it = m_packages.packages.constBegin(), itEnd = m_packages.packages.constEnd(); it != itEnd; ++it) {
                 if (it.key().compare(host, Qt::CaseInsensitive) == 0 || it.key().compare(deprecatedHost, Qt::CaseInsensitive) == 0) {
                     pkg = it.value();
                     break;
                 }
             }
             if (!pkg)
                 qWarning() << "could not find" << host << deprecatedHost;
         }
     }
     return new ResultsStream(QStringLiteral("PackageKitStream-url"), pkg ? QVector<AbstractResource*>{pkg} : QVector<AbstractResource*>{});
 }
 
 bool PackageKitBackend::hasSecurityUpdates() const
 {
     return m_hasSecurityUpdates;
 }
 
 int PackageKitBackend::updatesCount() const
 {
     int ret = 0;
     QSet<QString> packages;
     for(auto res: upgradeablePackages()) {
         const auto packageName = res->packageName();
         if (packages.contains(packageName)) {
             continue;
         }
         packages.insert(packageName);
         ret += 1;
     }
     return ret;
 }
 
 Transaction* PackageKitBackend::installApplication(AbstractResource* app, const AddonList& addons)
 {
     Transaction* t = nullptr;
     if(!addons.addonsToInstall().isEmpty())
     {
         QVector<AbstractResource*> appsToInstall;
 
         if(!app->isInstalled())
             appsToInstall << app;
 
         foreach(const QString& toInstall, addons.addonsToInstall()) {
             appsToInstall += m_packages.packages.value(toInstall);
             Q_ASSERT(appsToInstall.last());
         }
         t = new PKTransaction(appsToInstall, Transaction::ChangeAddonsRole);
     }
 
     if (!addons.addonsToRemove().isEmpty()) {
         QVector<AbstractResource*> appsToRemove = kTransform<QVector<AbstractResource*>>(addons.addonsToRemove(), [this](const QString& toRemove){ return m_packages.packages.value(toRemove); });
         t = new PKTransaction(appsToRemove, Transaction::RemoveRole);
     }
 
     if (!app->isInstalled())
         t = installApplication(app);
 
     return t;
 }
 
 Transaction* PackageKitBackend::installApplication(AbstractResource* app)
 {
     return new PKTransaction({app}, Transaction::InstallRole);
 }
 
 Transaction* PackageKitBackend::removeApplication(AbstractResource* app)
 {
     Q_ASSERT(!isFetching());
     return new PKTransaction({app}, Transaction::RemoveRole);
 }
 
 QSet<AbstractResource*> PackageKitBackend::upgradeablePackages() const
 {
     QSet<AbstractResource*> ret;
     ret.reserve(m_updatesPackageId.size());
     Q_FOREACH (const QString& pkgid, m_updatesPackageId) {
         const QString pkgname = PackageKit::Daemon::packageName(pkgid);
         const auto pkgs = resourcesByPackageName(pkgname);
         if (pkgs.isEmpty()) {
             qWarning() << "couldn't find resource for" << pkgid;
         }
         ret.unite(pkgs);
     }
     return ret;
 }
 
 void PackageKitBackend::addPackageToUpdate(PackageKit::Transaction::Info info, const QString& packageId, const QString& summary)
 {
     if (info == PackageKit::Transaction::InfoBlocked) {
         return;
     }
 
     if (info == PackageKit::Transaction::InfoSecurity)
         m_hasSecurityUpdates = true;
 
     m_updatesPackageId += packageId;
     addPackage(info, packageId, summary, true);
 }
 
 void PackageKitBackend::getUpdatesFinished(PackageKit::Transaction::Exit, uint)
 {
     if (!m_updatesPackageId.isEmpty()) {
         PackageKit::Transaction* transaction = PackageKit::Daemon::getDetails(m_updatesPackageId.toList());
         connect(transaction, &PackageKit::Transaction::details, this, &PackageKitBackend::packageDetails);
         connect(transaction, &PackageKit::Transaction::errorCode, this, &PackageKitBackend::transactionError);
         connect(transaction, &PackageKit::Transaction::finished, this, &PackageKitBackend::getUpdatesDetailsFinished);
     }
 
     m_updater->setProgressing(false);
 
     includePackagesToAdd();
     emit updatesCountChanged();
 }
 
 void PackageKitBackend::getUpdatesDetailsFinished(PackageKit::Transaction::Exit exit, uint)
 {
     if (exit != PackageKit::Transaction::ExitSuccess) {
         qWarning() << "Couldn't figure out the updates on PackageKit backend" << exit;
     }
 }
 
 bool PackageKitBackend::isPackageNameUpgradeable(const PackageKitResource* res) const
 {
     return !upgradeablePackageId(res).isEmpty();
 }
 
 QString PackageKitBackend::upgradeablePackageId(const PackageKitResource* res) const
 {
     QString name = res->packageName();
     foreach (const QString& pkgid, m_updatesPackageId) {
         if (PackageKit::Daemon::packageName(pkgid) == name)
             return pkgid;
     }
     return QString();
 }
 
 void PackageKitBackend::fetchDetails(const QString& pkgid)
 {
     if (!m_delayedDetailsFetch.isActive()) {
         m_delayedDetailsFetch.start();
     }
 
     m_packageNamesToFetchDetails += pkgid;
 }
 
 void PackageKitBackend::performDetailsFetch()
 {
     Q_ASSERT(!m_packageNamesToFetchDetails.isEmpty());
     const auto ids = m_packageNamesToFetchDetails.toList();
 
     PackageKit::Transaction* transaction = PackageKit::Daemon::getDetails(ids);
     connect(transaction, &PackageKit::Transaction::details, this, &PackageKitBackend::packageDetails);
     connect(transaction, &PackageKit::Transaction::errorCode, this, &PackageKitBackend::transactionError);
 
     QSharedPointer<QMap<QString, int>> packageDependencies(new QMap<QString, int>);
     auto trans = PackageKit::Daemon::dependsOn(ids);
     connect(trans, &PackageKit::Transaction::package, this, [packageDependencies](PackageKit::Transaction::Info /*info*/, const QString &packageID, const QString &/*summary*/) {
         (*packageDependencies)[packageID] += 1;
     });
     connect(trans, &PackageKit::Transaction::finished, this, [this, packageDependencies](PackageKit::Transaction::Exit /*status*/) {
         auto pkgDeps = (*packageDependencies);
 
         for (auto it = pkgDeps.constBegin(), itEnd = pkgDeps.constEnd(); it != itEnd; ++it) {
             const auto resources = resourcesByPackageName(PackageKit::Daemon::packageName(it.key()));
             for(auto resource : resources) {
                 auto pkres = qobject_cast<PackageKitResource*>(resource);
                 pkres->setDependenciesCount(it.value());
             }
         }
     });
 }
 
 void PackageKitBackend::checkDaemonRunning()
 {
     if (!PackageKit::Daemon::isRunning()) {
         qWarning() << "PackageKit stopped running!";
     }
 }
 
 AbstractBackendUpdater* PackageKitBackend::backendUpdater() const
 {
     return m_updater;
 }
 
 QVector<AppPackageKitResource*> PackageKitBackend::extendedBy(const QString& id) const
 {
     return m_packages.extendedBy[id];
 }
 
 AbstractReviewsBackend* PackageKitBackend::reviewsBackend() const
 {
     return m_reviews.data();
 }
 
 AbstractResource * PackageKitBackend::resourceForFile(const QUrl& file)
 {
     QMimeDatabase db;
     const auto mime = db.mimeTypeForUrl(file);
     if (    mime.inherits(QLatin1String("application/vnd.debian.binary-package"))
          || mime.inherits(QLatin1String("application/x-rpm"))
          || mime.inherits(QLatin1String("application/x-tar"))
          || mime.inherits(QLatin1String("application/x-xz-compressed-tar"))
     ) {
         return new LocalFilePKResource(file, this);
     }
     return nullptr;
 }
 
 static QString readDistroName()
 {
     const QStringList osreleasenames = (QStringList() << QStringLiteral("/etc/os-release")
                                                       << QStringLiteral("/usr/lib/os-release"));
     foreach (QString osrelease, osreleasenames)
     {
         QFile file(osrelease);
         if (file.open(QIODevice::ReadOnly | QIODevice::Text))
         {
             QByteArray line;
             while (!file.atEnd()) {
                 line = file.readLine().trimmed();
                 if (line.startsWith("NAME=")) {
                     auto output = line.right(line.length()-5);
                     output = output.replace('\"',"");
                     return QString::fromLocal8Bit(output);
                 }
             }
         }
     }
 
     QProcess process;
     process.setEnvironment({QStringLiteral("LC_ALL=C")});
     process.start(QStringLiteral("lsb_release"), {QStringLiteral("-sd")});
     process.waitForFinished();
     auto output = process.readAll().trimmed();
     if (output.startsWith('\"') && output.endsWith('\"'))
         output = output.mid(1, output.length()-2);
     return QString::fromLocal8Bit(output);
 }
 
 QString PackageKitBackend::displayName() const
 {
     static const QString distro = readDistroName();
     return distro;
 }
 
 #include "PackageKitBackend.moc"
diff --git a/libdiscover/backends/SnapBackend/SnapResource.cpp b/libdiscover/backends/SnapBackend/SnapResource.cpp
index df0fbe94..6272c734 100644
--- a/libdiscover/backends/SnapBackend/SnapResource.cpp
+++ b/libdiscover/backends/SnapBackend/SnapResource.cpp
@@ -1,327 +1,327 @@
 /***************************************************************************
  *   Copyright © 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.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 <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "SnapResource.h"
 #include "SnapBackend.h"
 #include <QDebug>
 #include <QProcess>
 #include <QBuffer>
 #include <QImageReader>
-#include <QQmlComponent>
 #include <QStandardItemModel>
 #include <KLocalizedString>
 #include <utils.h>
+#include <QProcess>
 
 QDebug operator<<(QDebug debug, const QSnapdPlug& plug)
 {
     QDebugStateSaver saver(debug);
     debug.nospace() << "QSnapdPlug(";
     debug.nospace() << "name:" << plug.name() << ',';
     debug.nospace() << "snap:" << plug.snap() << ',';
     debug.nospace() << "label:" << plug.label() << ',';
     debug.nospace() << "interface:" << plug.interface() << ',';
     debug.nospace() << "connectionCount:" << plug.connectionCount();
     debug.nospace() << ')';
     return debug;
 }
 
 QDebug operator<<(QDebug debug, const QSnapdSlot& slot)
 {
     QDebugStateSaver saver(debug);
     debug.nospace() << "QSnapdSlot(";
     debug.nospace() << "name:" << slot.name() << ',';
     debug.nospace() << "label:" << slot.label() << ',';
     debug.nospace() << "snap:" << slot.snap() << ',';
     debug.nospace() << "interface:" << slot.interface() << ',';
     debug.nospace() << "connectionCount:" << slot.connectionCount();
     debug.nospace() << ')';
     return debug;
 }
 
 QDebug operator<<(QDebug debug, const QSnapdPlug* plug)
 {
     QDebugStateSaver saver(debug);
     debug.nospace() << "*" << *plug;
     return debug;
 }
 
 QDebug operator<<(QDebug debug, const QSnapdSlot* slot)
 {
     QDebugStateSaver saver(debug);
     debug.nospace() << "*" << *slot;
     return debug;
 }
 
 SnapResource::SnapResource(QSharedPointer<QSnapdSnap> snap, AbstractResource::State state, SnapBackend* backend)
     : AbstractResource(backend)
     , m_state(state)
     , m_snap(snap)
     , m_objects({ QStringLiteral("qrc:/snapui/PermissionsButton.qml") })
 {
     setObjectName(snap->name());
 }
 
 QString SnapResource::availableVersion() const
 {
     return installedVersion();
 }
 
 QStringList SnapResource::categories()
 {
     return { QStringLiteral("Application") };
 }
 
 QString SnapResource::comment()
 {
     return m_snap->summary();
 }
 
 int SnapResource::size()
 {
 //     return isInstalled() ? m_snap->installedSize() : m_snap->downloadSize();
     return m_snap->downloadSize();
 }
 
 QVariant SnapResource::icon() const
 {
     if (m_icon.isNull()) {
         m_icon = [this]() -> QVariant {
             const auto iconPath = m_snap->icon();
             if (iconPath.isEmpty())
                 return QStringLiteral("package-x-generic");
 
             if (!iconPath.startsWith(QLatin1Char('/')))
                 return QUrl(iconPath);
 
             auto backend = qobject_cast<SnapBackend*>(parent());
             auto req = backend->client()->getIcon(packageName());
             connect(req, &QSnapdGetIconRequest::complete, this, &SnapResource::gotIcon);
             req->runAsync();
             return {};
         }();
     }
     return m_icon;
 }
 
 void SnapResource::gotIcon()
 {
     auto req = qobject_cast<QSnapdGetIconRequest*>(sender());
     if (req->error()) {
         qWarning() << "icon error" << req->errorString();
         return;
     }
 
     auto icon = req->icon();
 
     QBuffer buffer;
     buffer.setData(icon->data());
     QImageReader reader(&buffer);
 
     auto theIcon = QVariant::fromValue<QImage>(reader.read());
     if (theIcon != m_icon) {
         m_icon = theIcon;
         iconChanged();
     }
 }
 
 QString SnapResource::installedVersion() const
 {
     return m_snap->version();
 }
 
 QString SnapResource::license()
 {
     return m_snap->license();
 }
 
 QString SnapResource::longDescription()
 {
     return m_snap->description();
 }
 
 QString SnapResource::name() const
 {
     return m_snap->title().isEmpty() ? m_snap->name() : m_snap->title();
 }
 
 QString SnapResource::origin() const
 {
     return QStringLiteral("snappy:") + m_snap->channel();
 }
 
 QString SnapResource::packageName() const
 {
     return m_snap->name();
 }
 
 QString SnapResource::section()
 {
     return QStringLiteral("snap");
 }
 
 AbstractResource::State SnapResource::state()
 {
     return m_state;
 }
 
 void SnapResource::setState(AbstractResource::State state)
 {
     if (m_state != state) {
         m_state = state;
         Q_EMIT stateChanged();
     }
 }
 
 void SnapResource::fetchChangelog()
 {
     QString log;
     emit changelogFetched(log);
 }
 
 void SnapResource::fetchScreenshots()
 {
     QList<QUrl> screenshots;
     for(int i = 0, c = m_snap->screenshotCount(); i<c; ++i) {
         QScopedPointer<QSnapdScreenshot> screenshot(m_snap->screenshot(i));
         screenshots << QUrl(screenshot->url());
     }
     Q_EMIT screenshotsFetched(screenshots, screenshots);
 }
 
 void SnapResource::invokeApplication() const
 {
-//     QProcess::startDetached(m_snap->price());
+    QProcess::startDetached(QStringLiteral("snap"), {QStringLiteral("run"), packageName()});
 }
 
 bool SnapResource::isTechnical() const
 {
     return m_snap->snapType() != QLatin1String("app");
 }
 
 QUrl SnapResource::url() const
 {
     //FIXME interim, until it has an appstreamId
     return QUrl(QStringLiteral("snap://") + packageName());
 }
 
 void SnapResource::setSnap(const QSharedPointer<QSnapdSnap>& snap)
 {
     Q_ASSERT(snap->name() == m_snap->name());
     if (m_snap == snap)
         return;
 
     const bool newSize = m_snap->installedSize() != snap->installedSize() || m_snap->downloadSize() != snap->downloadSize();
     m_snap = snap;
     if (newSize)
         Q_EMIT sizeChanged();
 }
 
 QDate SnapResource::releaseDate() const
 {
     return {};
 }
 
 class PlugsModel : public QStandardItemModel
 {
 public:
     enum Roles {
         PlugNameRole = Qt::UserRole + 1,
         SlotSnapRole,
         SlotNameRole
     };
 
     PlugsModel(QSnapdSnap* snap, SnapBackend* backend, QObject* parent)
         : QStandardItemModel(parent)
         , m_snap(snap)
         , m_backend(backend)
     {
         setItemRoleNames(roleNames().unite(
             { {Qt::CheckStateRole, "checked"} }
         ));
 
         auto req = backend->client()->getInterfaces();
         req->runSync();
 
         QHash<QString, QVector<QSnapdSlot*>> slotsForInterface;
         for (int i = 0; i<req->slotCount(); ++i) {
             const auto slot = req->slot(i);
             slot->setParent(this);
             slotsForInterface[slot->interface()].append(slot);
 
         }
 
         for (int i = 0; i<req->plugCount(); ++i) {
             const QScopedPointer<QSnapdPlug> plug(req->plug(i));
             if (plug->snap() == m_snap->name()) {
                 for (auto slot: slotsForInterface[plug->interface()]) {
                     auto item = new QStandardItem;
                     if (plug->label().isEmpty())
                         item->setText(plug->name());
                     else
                         item->setText(i18n("%1 - %2", plug->name(), plug->label()));
 
                     item->setCheckable(true);
                     item->setCheckState(plug->connectionCount()>0 ? Qt::Checked : Qt::Unchecked);
                     item->setData(plug->name(), PlugNameRole);
                     item->setData(slot->snap(), SlotSnapRole);
                     item->setData(slot->name(), SlotNameRole);
                     appendRow(item);
                 }
             }
         }
     }
 
 private:
     bool setData(const QModelIndex & index, const QVariant & value, int role) override {
         if (role != Qt::CheckStateRole)
             return QStandardItemModel::setData(index, value, role);
 
         auto item = itemFromIndex(index);
         Q_ASSERT(item);
         const QString plugName = item->data(PlugNameRole).toString();
         const QString slotSnap = item->data(SlotSnapRole).toString();
         const QString slotName = item->data(SlotNameRole).toString();
 
         QSnapdRequest* req;
 
         if (item->checkState() == Qt::Checked) {
             req = m_backend->client()->connectInterface(m_snap->name(), plugName, slotSnap, slotName);
         } else {
             req = m_backend->client()->disconnectInterface(m_snap->name(), plugName, slotSnap, slotName);
         }
         req->runSync();
         if (req->error()) {
             qWarning() << "snapd error" << req->errorString();
         }
         return req->error() == QSnapdRequest::NoError;
     }
 
     QSnapdSnap* const m_snap;
     SnapBackend* const m_backend;
 };
 
 QAbstractItemModel* SnapResource::plugs(QObject* p)
 {
     if (!isInstalled())
         return new QStandardItemModel(p);
 
 
     return new PlugsModel(m_snap.data(), qobject_cast<SnapBackend*>(parent()), p);
 }