genericdbusinterface.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_GENERICDBUSINTERFACE_H
#define SWIFT_MISC_GENERICDBUSINTERFACE_H
 
#include <QDBusAbstractInterface>
#include <QDBusPendingCall>
#include <QDBusPendingReply>
#include <QMetaMethod>
#include <QObject>
#include <QSharedPointer>
 
#include "misc/logmessage.h"
#include "misc/promise.h"
 
#ifndef Q_MOC_RUN
#    define SWIFT_NO_RELAY
#endif
 
namespace swift::misc
{
    class SWIFT_MISC_EXPORT CGenericDBusInterface : public QDBusAbstractInterface
    {
        Q_OBJECT
 
    public:
        CGenericDBusInterface(const QString &serviceName, const QString &path, const QString &interfaceName,
                              const QDBusConnection &connection, QObject *parent = nullptr)
            : QDBusAbstractInterface(serviceName, path, interfaceName.toUtf8().constData(), connection, parent)
        {}
 
        void relayParentSignals()
        {
            const QMetaObject *metaObject = this->parent()->metaObject();
            const QMetaObject *superMetaObject = metaObject;
            while (strcmp(superMetaObject->superClass()->className(), "QObject") != 0)
            {
                superMetaObject = superMetaObject->superClass();
            }
 
            for (int i = superMetaObject->methodOffset(), count = metaObject->methodCount(); i < count; ++i)
            {
                const QMetaMethod method = metaObject->method(i);
                if (method.methodType() != QMetaMethod::Signal) { continue; }
                if (method.tag() && strcmp(method.tag(), "SWIFT_NO_RELAY") == 0) { continue; }
 
                const QByteArray signature = method.methodSignature().prepend(
                    "2"); // the reason for this "2" can be found in the definition of SIGNAL() macro
                const bool c = this->connection().connect(this->service(), this->path(), this->interface(),
                                                          method.name(), this->parent(), signature);
                if (!c) { CLogMessage(this).error(u"Cannot connect signal: %1") << QString(signature); }
            }
        }
 
        template <typename... Args>
        void callDBus(QLatin1String method, Args &&...args)
        {
            const QList<QVariant> argumentList { QVariant::fromValue(std::forward<Args>(args))... };
            this->callWithArgumentList(QDBus::NoBlock, method, argumentList);
        }
 
        template <typename Ret, typename... Args>
        Ret callDBusRet(QLatin1String method, Args &&...args)
        {
            QList<QVariant> argumentList { QVariant::fromValue(std::forward<Args>(args))... };
            QDBusPendingReply<Ret> pr = this->asyncCallWithArgumentList(method, argumentList);
            pr.waitForFinished();
            if (pr.isError())
            {
                CLogMessage(this).debug(u"CGenericDBusInterface::callDBusRet(%1) returned: %2")
                    << method << pr.error().message();
            }
            return pr;
        }
 
        template <typename Func, typename... Args>
        QDBusPendingCallWatcher *callDBusAsync(QLatin1String method, Func callback, Args &&...args)
        {
            QList<QVariant> argumentList { QVariant::fromValue(std::forward<Args>(args))... };
            QDBusPendingCall pc = this->asyncCallWithArgumentList(method, argumentList);
            auto pcw = new QDBusPendingCallWatcher(pc, this);
            connect(pcw, &QDBusPendingCallWatcher::finished, callback);
            return pcw;
        }
 
        template <typename Ret, typename... Args>
        QFuture<Ret> callDBusFuture(QLatin1String method, Args &&...args)
        {
            auto sharedPromise = QSharedPointer<CPromise<Ret>>::create();
            this->callDBusAsync(
                method, [=](auto pcw) { sharedPromise->setResult(QDBusPendingReply<Ret>(*pcw)); },
                std::forward<Args>(args)...);
            return sharedPromise->future();
        }
 
        void cancelAllPendingAsyncCalls()
        {
            auto watchers = this->findChildren<QDBusPendingCallWatcher *>(QString(), Qt::FindDirectChildrenOnly);
            for (auto w : watchers) { delete w; }
        }
    };
} // namespace swift::misc
 
#endif // SWIFT_MISC_GENERICDBUSINTERFACE_H