ClientHelpers.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorProtocol/ServiceConstants.h>
#include <PhosphorProtocol/phosphorprotocol_export.h>
 
#include <PhosphorDBus/Client.h>
 
#include <QDBusConnection>
#include <QDBusPendingCall>
#include <QDBusPendingCallWatcher>
#include <QDBusPendingReply>
#include <QLoggingCategory>
#include <QObject>
#include <QVariant>
 
#include <utility>
 
namespace PhosphorProtocol {
 
PHOSPHORPROTOCOL_EXPORT const QLoggingCategory& lcPhosphorProtocol();
 
inline PhosphorDBus::Client daemonClient()
{
    return PhosphorDBus::Client(QDBusConnection::sessionBus(), Service::Name, Service::ObjectPath,
                                &lcPhosphorProtocol());
}
 
namespace ClientHelpers {
 
inline void fireAndForget(QObject* parent, const QString& interface, const QString& method, const QVariantList& args,
                          const QString& logContext = {})
{
    daemonClient().fireAndForget(parent, interface, method, args, logContext);
}
 
inline void sendOneWay(const QString& interface, const QString& method, const QVariantList& args = {})
{
    daemonClient().sendOneWay(interface, method, args);
}
 
inline QDBusPendingCall asyncCall(const QString& interface, const QString& method, const QVariantList& args = {})
{
    return daemonClient().asyncCall(interface, method, args);
}
 
inline QDBusMessage syncCall(const QString& interface, const QString& method, const QVariantList& args = {})
{
    return daemonClient().syncCall(interface, method, args, Service::SyncCallTimeoutMs);
}
 
inline void reloadDaemonSettings(QObject* parent, const QString& logContext = {})
{
    fireAndForget(parent, Service::Interface::Settings, QStringLiteral("reloadSettings"), {}, logContext);
}
 
inline void reloadDaemonSettingsBlocking()
{
    syncCall(Service::Interface::Settings, QStringLiteral("reloadSettings"));
}
 
template<typename Fn>
void loadSettingAsync(QObject* parent, const QString& name, Fn&& onValue)
{
    auto* watcher = new QDBusPendingCallWatcher(
        daemonClient().asyncCall(Service::Interface::Settings, QStringLiteral("getSetting"), {name}), parent);
    QObject::connect(watcher, &QDBusPendingCallWatcher::finished, parent,
                     [name, onValue = std::forward<Fn>(onValue)](QDBusPendingCallWatcher* w) {
                         w->deleteLater();
                         QDBusPendingReply<QVariant> reply = *w;
                         if (reply.isValid()) {
                             QVariant value = reply.value();
                             if (value.canConvert<QDBusVariant>()) {
                                 value = value.value<QDBusVariant>().variant();
                             }
                             onValue(value);
                             qCDebug(lcPhosphorProtocol) << "Loaded" << name;
                         } else {
                             qCWarning(lcPhosphorProtocol)
                                 << "loadSettingAsync: failed to load" << name << ":" << reply.error().message();
                         }
                     });
}
 
} // namespace ClientHelpers
 
} // namespace PhosphorProtocol