File indexing completed on 2024-04-28 16:11:13

 /*
    SPDX-FileCopyrightText: 2018-2024 Laurent Montel <montel@kde.org>
 
    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "unityservicemanager.h"
 #include "ruqola_debug.h"
 #include <QApplication>
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusMessage>
 #include <QDBusPendingCallWatcher>
 #include <QDBusPendingReply>
 #include <QDBusServiceWatcher>
 
 UnityServiceManager::UnityServiceManager(QObject *parent)
     : QObject(parent)
     , mUnityServiceWatcher(new QDBusServiceWatcher(this))
 {
     initUnity();
 }
 
 UnityServiceManager::~UnityServiceManager() = default;
 
 void UnityServiceManager::updateCount()
 {
     if (mUnityServiceAvailable) {
         const QString launcherId = qApp->desktopFileName() + QLatin1String(".desktop");
 
         const QVariantMap properties{{QStringLiteral("count-visible"), mCount > 0}, {QStringLiteral("count"), mCount}};
 
         QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/org/ruqola/UnityLauncher"),
                                                           QStringLiteral("com.canonical.Unity.LauncherEntry"),
                                                           QStringLiteral("Update"));
         message.setArguments({launcherId, properties});
         QDBusConnection::sessionBus().send(message);
     }
 }
 
 void UnityServiceManager::setCount(int count)
 {
     if (mCount != count) {
         mCount = count;
         updateCount();
     }
 }
 
 void UnityServiceManager::initUnity()
 {
     mUnityServiceWatcher->setConnection(QDBusConnection::sessionBus());
     mUnityServiceWatcher->setWatchMode(QDBusServiceWatcher::WatchForUnregistration | QDBusServiceWatcher::WatchForRegistration);
     mUnityServiceWatcher->addWatchedService(QStringLiteral("com.canonical.Unity"));
     connect(mUnityServiceWatcher, &QDBusServiceWatcher::serviceRegistered, this, [this](const QString &service) {
         Q_UNUSED(service)
         mUnityServiceAvailable = true;
         updateCount();
     });
 
     connect(mUnityServiceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, [this](const QString &service) {
         Q_UNUSED(service)
         mUnityServiceAvailable = false;
     });
 
     // QDBusConnectionInterface::isServiceRegistered blocks
     QDBusPendingCall listNamesCall = QDBusConnection::sessionBus().interface()->asyncCall(QStringLiteral("ListNames"));
     auto callWatcher = new QDBusPendingCallWatcher(listNamesCall, this);
     connect(callWatcher, &QDBusPendingCallWatcher::finished, this, [this](QDBusPendingCallWatcher *watcher) {
         QDBusPendingReply<QStringList> reply = *watcher;
         watcher->deleteLater();
 
         if (reply.isError()) {
             qCWarning(RUQOLA_LOG) << " reply" << reply.error().message();
         }
 
         const QStringList &services = reply.value();
 
         mUnityServiceAvailable = services.contains(QLatin1String("com.canonical.Unity"));
         if (mUnityServiceAvailable) {
             updateCount();
         }
     });
 }
 
 #include "moc_unityservicemanager.cpp"