File indexing completed on 2023-09-24 04:02:48

 /*
     SPDX-FileCopyrightText: 2010-2016 Ivan Cukic <ivan.cukic(at)kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "info.h"
 #include "info_p.h"
 #include "manager_p.h"
 
 #include "utils/dbusfuture_p.h"
 
 #include <QFileSystemWatcher>
 
 namespace KActivities
 {
 // InfoPrivate
 
 InfoPrivate::InfoPrivate(Info *info, const QString &activity)
     : q(info)
     , cache(ActivitiesCache::self())
     , id(activity)
 {
 }
 
 // clang-format off
 // Filters out signals for only this activity
 #define IMPLEMENT_SIGNAL_HANDLER(INTERNAL)                                     \
     void InfoPrivate::INTERNAL(const QString &_id) const                       \
     {   if (id == _id) Q_EMIT q->INTERNAL(); }
 
 IMPLEMENT_SIGNAL_HANDLER(added)
 IMPLEMENT_SIGNAL_HANDLER(removed)
 IMPLEMENT_SIGNAL_HANDLER(started)
 IMPLEMENT_SIGNAL_HANDLER(stopped)
 IMPLEMENT_SIGNAL_HANDLER(infoChanged)
 
 #undef IMPLEMENT_SIGNAL_HANDLER
 
 #define IMPLEMENT_SIGNAL_HANDLER(INTERNAL)                                     \
     void InfoPrivate::INTERNAL##Changed(const QString &_id,                    \
                                         const QString &val) const              \
     {                                                                          \
         if (id == _id) {                                                       \
             Q_EMIT q->INTERNAL##Changed(val);                                    \
         }                                                                      \
     }
 
 IMPLEMENT_SIGNAL_HANDLER(name)
 IMPLEMENT_SIGNAL_HANDLER(description)
 IMPLEMENT_SIGNAL_HANDLER(icon)
 
 #undef IMPLEMENT_SIGNAL_HANDLER
 
 void InfoPrivate::activityStateChanged(const QString &idChanged,
                                        int newState) const
 {
     if (idChanged == id) {
         auto state = static_cast<Info::State>(newState);
         Q_EMIT q->stateChanged(state);
 
         if (state == KActivities::Info::Stopped) {
             Q_EMIT q->stopped();
         } else if (state == KActivities::Info::Running) {
             Q_EMIT q->started();
         }
     }
 }
 
 void InfoPrivate::setCurrentActivity(const QString &currentActivity)
 {
     if (isCurrent) {
         if (currentActivity != id) {
             // We are no longer the current activity
             isCurrent = false;
             Q_EMIT q->isCurrentChanged(false);
         }
     } else {
         if (currentActivity == id) {
             // We are the current activity
             isCurrent = true;
             Q_EMIT q->isCurrentChanged(true);
         }
     }
 }
 
 // Info
 Info::Info(const QString &activity, QObject *parent)
     : QObject(parent)
     , d(new InfoPrivate(this, activity))
 {
     // qDebug() << "Created an instance of Info: " << (void*)this;
 #define PASS_SIGNAL_HANDLER(SIGNAL_NAME,SLOT_NAME)                            \
     connect(d->cache.get(),  SIGNAL(SIGNAL_NAME(QString)),                     \
             this,            SLOT(SLOT_NAME(QString)));
 
     PASS_SIGNAL_HANDLER(activityAdded,added)
     PASS_SIGNAL_HANDLER(activityRemoved,removed)
     // PASS_SIGNAL_HANDLER(started)
     // PASS_SIGNAL_HANDLER(stopped)
     PASS_SIGNAL_HANDLER(activityChanged,infoChanged)
 #undef PASS_SIGNAL_HANDLER
 
 #define PASS_SIGNAL_HANDLER(SIGNAL_NAME,SLOT_NAME,TYPE)                      \
     connect(d->cache.get(),  SIGNAL(SIGNAL_NAME(QString,TYPE)),               \
             this,            SLOT(SLOT_NAME(QString,TYPE)));                  \
 
     PASS_SIGNAL_HANDLER(activityStateChanged,activityStateChanged,int);
     PASS_SIGNAL_HANDLER(activityNameChanged,nameChanged,QString);
     PASS_SIGNAL_HANDLER(activityDescriptionChanged,descriptionChanged,QString);
     PASS_SIGNAL_HANDLER(activityIconChanged,iconChanged,QString);
 // clang-format on
 #undef PASS_SIGNAL_HANDLER
     connect(d->cache.get(), SIGNAL(currentActivityChanged(QString)), this, SLOT(setCurrentActivity(QString)));
 
     d->isCurrent = (d->cache.get()->m_currentActivity == activity);
 }
 
 Info::~Info()
 {
     // qDebug() << "Deleted an instance of Info: " << (void*)this;
 }
 
 bool Info::isValid() const
 {
     auto currentState = state();
     return (currentState != Invalid && currentState != Unknown);
 }
 
 QString Info::uri() const
 {
     return QStringLiteral("activities://") + d->id;
 }
 
 QString Info::id() const
 {
     return d->id;
 }
 
 bool Info::isCurrent() const
 {
     return d->isCurrent;
 }
 
 Info::State Info::state() const
 {
     if (d->cache->m_status == Consumer::Unknown) {
         return Info::Unknown;
     }
 
     auto info = d->cache->getInfo(d->id);
 
     if (!info) {
         return Info::Invalid;
     }
 
     return static_cast<Info::State>(info->state);
 }
 
 void InfoPrivate::setServiceStatus(Consumer::ServiceStatus status) const
 {
     switch (status) {
     case Consumer::NotRunning:
     case Consumer::Unknown:
         activityStateChanged(id, Info::Unknown);
         break;
 
     default:
         activityStateChanged(id, q->state());
         break;
     }
 }
 
 Info::Availability Info::availability() const
 {
     Availability result = Nothing;
 
     if (!Manager::isServiceRunning()) {
         return result;
     }
 
     if (Manager::activities()->ListActivities().value().contains(d->id)) {
         result = BasicInfo;
 
         if (Manager::features()->IsFeatureOperational(QStringLiteral("resources/linking"))) {
             result = Everything;
         }
     }
 
     return result;
 }
 
 // clang-format off
 #define CREATE_GETTER(What)                                                    \
     QString Info::What() const                                                 \
     {                                                                          \
         auto info = d->cache->getInfo(d->id);                                  \
         return info ? info->What : QString();                                  \
     }
 // clang-format on
 
 CREATE_GETTER(name)
 CREATE_GETTER(description)
 CREATE_GETTER(icon)
 
 #undef CREATE_GETTER
 
 } // namespace KActivities
 
 #include "moc_info.cpp"