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 &services, const QDBusConnection &c, QDBusServiceWatcher::WatchMode watchMode);
 
    void addService(const QString &service);
    void removeService(const QString &service);
};
 
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 &services,
                                               const QDBusConnection &c,
                                               QDBusServiceWatcher::WatchMode wm)
{
    if (connection.isConnected()) {
        // remove older rules
        for (const QString &s : std::as_const(watchedServicesData.value()))
            removeService(s);
    }
 
    connection = c;
    watchMode.setValueBypassingBindings(wm); // caller has to call notify()
    watchedServicesData.setValueBypassingBindings(services); // caller has to call notify()
 
    if (connection.isConnected()) {
        // add new rules
        for (const QString &s : std::as_const(watchedServicesData.value()))
            addService(s);
    }
}
 
void QDBusServiceWatcherPrivate::addService(const QString &service)
{
    QDBusConnectionPrivate *d = QDBusConnectionPrivate::d(connection);
    if (d && d->shouldWatchService(service))
        d->watchService(service, watchMode, q_func(), SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
}
 
void QDBusServiceWatcherPrivate::removeService(const QString &service)
{
    QDBusConnectionPrivate *d = QDBusConnectionPrivate::d(connection);
    if (d && d->shouldWatchService(service))
        d->unwatchService(service, watchMode, 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)
        return;
    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();
    if (d->watchedServicesData.value().contains(newService))
        return;
    d->addService(newService);
 
    auto templist = d->watchedServicesData.valueBypassingBindings();
    templist << newService;
    d->watchedServicesData.setValueBypassingBindings(templist);
 
    d->watchedServicesData.notify();
}
 
bool QDBusServiceWatcher::removeWatchedService(const QString &service)
{
    Q_D(QDBusServiceWatcher);
    d->watchedServicesData.removeBindingUnlessInWrapper();
    d->removeService(service);
    auto tempList = d->watchedServicesData.value();
    bool result = tempList.removeOne(service);
    if (result) {
        d->watchedServicesData.setValueBypassingBindings(tempList);
        d->watchedServicesData.notify();
        return true;
    } else {
        // nothing changed
        return false;
    }
}
 
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.value())
        return;
    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"