qdbusservicewatcher.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdbusservicewatcher.h"
#include "qdbusconnection.h"
#include "qdbusutil_p.h"
 
#include <QStringList>
 
#include <private/qproperty_p.h>
#include <private/qobject_p.h>
#include <private/qdbusconnection_p.h>
 
#ifndef QT_NO_DBUS
 
QT_BEGIN_NAMESPACE
 
class QDBusServiceWatcherPrivate: public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QDBusServiceWatcher)
public:
    QDBusServiceWatcherPrivate(const QDBusConnection &c, QDBusServiceWatcher::WatchMode wm)
        : connection(c), watchMode(wm)
    {
    }
 
    void setWatchedServicesForwardToQ(const QStringList &list)
    {
        q_func()->setWatchedServices(list);
    }
    Q_OBJECT_COMPAT_PROPERTY(QDBusServiceWatcherPrivate, QStringList, watchedServicesData,
                             &QDBusServiceWatcherPrivate::setWatchedServicesForwardToQ)
 
    QDBusConnection connection;
    void setWatchModeForwardToQ(QDBusServiceWatcher::WatchMode mode)
    {
        q_func()->setWatchMode(mode);
    }
    Q_OBJECT_COMPAT_PROPERTY(QDBusServiceWatcherPrivate, QDBusServiceWatcher::WatchMode, watchMode,
                             &QDBusServiceWatcherPrivate::setWatchModeForwardToQ)
 
    void _q_serviceOwnerChanged(const QString &, const QString &, const QString &);
    void setConnection(const QStringList &newServices, const QDBusConnection &newConnection,
                       QDBusServiceWatcher::WatchMode newMode);
 
    void addService(const QString &service, QDBusServiceWatcher::WatchMode mode);
    void removeService(const QString &service, QDBusServiceWatcher::WatchMode mode);
};
 
void QDBusServiceWatcherPrivate::_q_serviceOwnerChanged(const QString &service, const QString &oldOwner, const QString &newOwner)
{
    Q_Q(QDBusServiceWatcher);
    emit q->serviceOwnerChanged(service, oldOwner, newOwner);
    if (oldOwner.isEmpty())
        emit q->serviceRegistered(service);
    else if (newOwner.isEmpty())
        emit q->serviceUnregistered(service);
}
 
void QDBusServiceWatcherPrivate::setConnection(const QStringList &newServices,
                                               const QDBusConnection &newConnection,
                                               QDBusServiceWatcher::WatchMode newMode)
{
    const QStringList oldServices = watchedServicesData.valueBypassingBindings();
    const QDBusServiceWatcher::WatchMode oldMode = watchMode.valueBypassingBindings();
    if (connection.isConnected()) {
        // remove older rules
        for (const QString &s : oldServices)
            removeService(s, oldMode);
    }
 
    connection = newConnection;
    watchMode.setValueBypassingBindings(newMode); // caller has to call notify()
    watchedServicesData.setValueBypassingBindings(newServices); // caller has to call notify()
 
    if (connection.isConnected()) {
        // add new rules
        for (const QString &s : newServices)
            addService(s, newMode);
    }
}
 
void QDBusServiceWatcherPrivate::addService(const QString &service,
                                            QDBusServiceWatcher::WatchMode mode)
{
    QDBusConnectionPrivate *d = QDBusConnectionPrivate::d(connection);
    if (d && d->shouldWatchService(service))
        d->watchService(service, mode, q_func(), SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
}
 
void QDBusServiceWatcherPrivate::removeService(const QString &service,
                                               QDBusServiceWatcher::WatchMode mode)
{
    QDBusConnectionPrivate *d = QDBusConnectionPrivate::d(connection);
    if (d && d->shouldWatchService(service))
        d->unwatchService(service, mode, q_func(), SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
}
 
QDBusServiceWatcher::QDBusServiceWatcher(QObject *parent)
    : QObject(*new QDBusServiceWatcherPrivate(QDBusConnection(QString()), WatchForOwnerChange), parent)
{
}
 
QDBusServiceWatcher::QDBusServiceWatcher(const QString &service, const QDBusConnection &connection, WatchMode watchMode, QObject *parent)
    : QObject(*new QDBusServiceWatcherPrivate(connection, watchMode), parent)
{
    d_func()->setConnection(QStringList() << service, connection, watchMode);
}
 
QDBusServiceWatcher::~QDBusServiceWatcher()
{
}
 
QStringList QDBusServiceWatcher::watchedServices() const
{
    return d_func()->watchedServicesData;
}
 
void QDBusServiceWatcher::setWatchedServices(const QStringList &services)
{
    Q_D(QDBusServiceWatcher);
    d->watchedServicesData.removeBindingUnlessInWrapper();
    if (services == d->watchedServicesData.valueBypassingBindings())
        return;
    // trigger watchMode re-evaluation, but only once for the setter
    d->setConnection(services, d->connection, d->watchMode);
    d->watchedServicesData.notify();
}
 
QBindable<QStringList> QDBusServiceWatcher::bindableWatchedServices()
{
    Q_D(QDBusServiceWatcher);
    return &d->watchedServicesData;
}
 
void QDBusServiceWatcher::addWatchedService(const QString &newService)
{
    Q_D(QDBusServiceWatcher);
    d->watchedServicesData.removeBindingUnlessInWrapper();
    auto services = d->watchedServicesData.valueBypassingBindings();
    if (services.contains(newService))
        return;
    // re-evaluate watch mode
    d->addService(newService, d->watchMode);
 
    services << newService;
    d->watchedServicesData.setValueBypassingBindings(services);
 
    d->watchedServicesData.notify();
}
 
bool QDBusServiceWatcher::removeWatchedService(const QString &service)
{
    Q_D(QDBusServiceWatcher);
    d->watchedServicesData.removeBindingUnlessInWrapper();
    auto tempList = d->watchedServicesData.valueBypassingBindings();
    const bool result = tempList.removeOne(service);
    if (!result)
        return false; // nothing changed
 
    // re-evaluate watch mode
    d->removeService(service, d->watchMode);
    d->watchedServicesData.setValueBypassingBindings(tempList);
    d->watchedServicesData.notify();
    return true;
}
 
QDBusServiceWatcher::WatchMode QDBusServiceWatcher::watchMode() const
{
    return d_func()->watchMode;
}
 
QBindable<QDBusServiceWatcher::WatchMode> QDBusServiceWatcher::bindableWatchMode()
{
    return &d_func()->watchMode;
}
 
void QDBusServiceWatcher::setWatchMode(WatchMode mode)
{
    Q_D(QDBusServiceWatcher);
    d->watchMode.removeBindingUnlessInWrapper();
    if (mode == d->watchMode.valueBypassingBindings())
        return;
    // trigger watchedServicesData re-evaluation, but only once for the setter
    d->setConnection(d->watchedServicesData, d->connection, mode);
    d->watchMode.notify();
}
 
QDBusConnection QDBusServiceWatcher::connection() const
{
    return d_func()->connection;
}
 
void QDBusServiceWatcher::setConnection(const QDBusConnection &connection)
{
    Q_D(QDBusServiceWatcher);
    if (connection.name() == d->connection.name())
        return;
    d->setConnection(d->watchedServicesData, connection, d->watchMode);
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_DBUS
 
#include "moc_qdbusservicewatcher.cpp"