File indexing completed on 2024-04-28 05:11:03

 /*
    SPDX-FileCopyrightText: 2018-2024 Laurent Montel <montel@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "unityservicemanager.h"
 
 #include <QApplication>
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusMessage>
 #include <QDBusPendingCallWatcher>
 #include <QDBusPendingReply>
 #include <QDBusServiceWatcher>
 
 UnityServiceManager *UnityServiceManager::mInstance = nullptr;
 
 UnityServiceManager *UnityServiceManager::instance()
 {
     if (!mInstance) {
         mInstance = new UnityServiceManager;
     }
     return mInstance;
 }
 
 UnityServiceManager::UnityServiceManager(QObject *parent)
     : QObject(parent)
     , mUnityServiceWatcher(new QDBusServiceWatcher(this))
 {
     initUnity();
 }
 
 UnityServiceManager::~UnityServiceManager() = default;
 
 void UnityServiceManager::slotSetUnread(int unread)
 {
     if (m_unread != unread) {
         m_unread = unread;
         updateCount();
     }
 }
 
 void UnityServiceManager::updateCount()
 {
     if (mUnityServiceAvailable) {
         const QString launcherId = qApp->desktopFileName() + QLatin1StringView(".desktop");
 
         const QVariantMap properties{{QStringLiteral("count-visible"), m_unread > 0}, {QStringLiteral("count"), m_unread}};
 
         QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/org/akregator/UnityLauncher"),
                                                           QStringLiteral("com.canonical.Unity.LauncherEntry"),
                                                           QStringLiteral("Update"));
         message.setArguments({launcherId, properties});
         QDBusConnection::sessionBus().send(message);
     }
 }
 
 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()) {
             return;
         }
 
         const QStringList &services = reply.value();
 
         mUnityServiceAvailable = services.contains(QLatin1StringView("com.canonical.Unity"));
         if (mUnityServiceAvailable) {
             updateCount();
         }
     });
 }
 
 #include "moc_unityservicemanager.cpp"