qdbusconnectioninterface.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 "qdbusconnectioninterface.h"
 
#include <QtCore/QByteArray>
#include <QtCore/QList>
#include <QtCore/QMap>
#include <QtCore/QMetaMethod>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QVariant>
#include <QtCore/QDebug>
 
#include "qdbusutil_p.h"          // for the DBUS_* constants
 
#ifndef QT_NO_DBUS
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
/*
 * Implementation of interface class QDBusConnectionInterface
 */
 
const char *QDBusConnectionInterface::staticInterfaceName()
{ return "org.freedesktop.DBus"; }
 
QDBusConnectionInterface::QDBusConnectionInterface(const QDBusConnection &connection,
                                                   QObject *parent)
    : QDBusAbstractInterface(QDBusUtil::dbusService(),
                             QDBusUtil::dbusPath(),
                             DBUS_INTERFACE_DBUS, connection, parent)
{
    connect(this, &QDBusConnectionInterface::NameAcquired, this, emit &QDBusConnectionInterface::serviceRegistered);
    connect(this, &QDBusConnectionInterface::NameLost, this, emit &QDBusConnectionInterface::serviceUnregistered);
    connect(this, &QDBusConnectionInterface::NameOwnerChanged,
            this, emit &QDBusConnectionInterface::serviceOwnerChanged);
}
 
QDBusConnectionInterface::~QDBusConnectionInterface()
{
}
 
QDBusReply<QString> QDBusConnectionInterface::serviceOwner(const QString &name) const
{
    return internalConstCall(QDBus::AutoDetect, "GetNameOwner"_L1, QList<QVariant>() << name);
}
 
QDBusReply<QStringList> QDBusConnectionInterface::registeredServiceNames() const
{
    return internalConstCall(QDBus::AutoDetect, "ListNames"_L1);
}
 
QDBusReply<QStringList> QDBusConnectionInterface::activatableServiceNames() const
{
    return internalConstCall(QDBus::AutoDetect, "ListActivatableNames"_L1);
}
 
QDBusReply<bool> QDBusConnectionInterface::isServiceRegistered(const QString &serviceName) const
{
    return internalConstCall(QDBus::AutoDetect, "NameHasOwner"_L1,
                             QList<QVariant>() << serviceName);
}
 
QDBusReply<uint> QDBusConnectionInterface::servicePid(const QString &serviceName) const
{
    return internalConstCall(QDBus::AutoDetect, "GetConnectionUnixProcessID"_L1,
                             QList<QVariant>() << serviceName);
}
 
QDBusReply<uint> QDBusConnectionInterface::serviceUid(const QString &serviceName) const
{
    return internalConstCall(QDBus::AutoDetect, "GetConnectionUnixUser"_L1,
                             QList<QVariant>() << serviceName);
}
 
QDBusReply<void> QDBusConnectionInterface::startService(const QString &name)
{
    return call("StartServiceByName"_L1, name, uint(0));
}
 
QDBusReply<QDBusConnectionInterface::RegisterServiceReply>
QDBusConnectionInterface::registerService(const QString &serviceName,
                                          ServiceQueueOptions qoption,
                                          ServiceReplacementOptions roption)
{
    // reconstruct the low-level flags
    uint flags = 0;
    switch (qoption) {
    case DontQueueService:
        flags = DBUS_NAME_FLAG_DO_NOT_QUEUE;
        break;
    case QueueService:
        flags = 0;
        break;
    case ReplaceExistingService:
        flags = DBUS_NAME_FLAG_DO_NOT_QUEUE | DBUS_NAME_FLAG_REPLACE_EXISTING;
        break;
    }
 
    switch (roption) {
    case DontAllowReplacement:
        break;
    case AllowReplacement:
        flags |= DBUS_NAME_FLAG_ALLOW_REPLACEMENT;
        break;
    }
 
    QDBusMessage reply = call("RequestName"_L1, serviceName, flags);
//    qDebug() << "QDBusConnectionInterface::registerService" << serviceName << "Reply:" << reply;
 
    // convert the low-level flags to something that we can use
    if (reply.type() == QDBusMessage::ReplyMessage) {
        uint code = 0;
 
        switch (reply.arguments().at(0).toUInt()) {
        case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
        case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
            code = uint(ServiceRegistered);
            break;
 
        case DBUS_REQUEST_NAME_REPLY_EXISTS:
            code = uint(ServiceNotRegistered);
            break;
 
        case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
            code = uint(ServiceQueued);
            break;
        }
 
        reply.setArguments(QVariantList() << code);
    }
 
    return reply;
}
 
QDBusReply<bool>
QDBusConnectionInterface::unregisterService(const QString &serviceName)
{
    QDBusMessage reply = call("ReleaseName"_L1, serviceName);
    if (reply.type() == QDBusMessage::ReplyMessage) {
        bool success = reply.arguments().at(0).toUInt() == DBUS_RELEASE_NAME_REPLY_RELEASED;
        reply.setArguments(QVariantList() << success);
    }
    return reply;
}
 
void QDBusConnectionInterface::connectNotify(const QMetaMethod &signal)
{
    // translate the signal names to what we really want
    // this avoids setting hooks for signals that don't exist on the bus
    static const QMetaMethod serviceRegisteredSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::serviceRegistered);
    static const QMetaMethod serviceUnregisteredSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::serviceUnregistered);
    static const QMetaMethod serviceOwnerChangedSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::serviceOwnerChanged);
    static const QMetaMethod NameAcquiredSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::NameAcquired);
    static const QMetaMethod NameLostSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::NameLost);
    static const QMetaMethod NameOwnerChangedSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::NameOwnerChanged);
    if (signal == serviceRegisteredSignal)
        QDBusAbstractInterface::connectNotify(NameAcquiredSignal);
 
    else if (signal == serviceUnregisteredSignal)
        QDBusAbstractInterface::connectNotify(NameLostSignal);
 
    else if (signal == serviceOwnerChangedSignal) {
        static bool warningPrinted = false;
        if (!warningPrinted) {
            qWarning("Connecting to deprecated signal QDBusConnectionInterface::serviceOwnerChanged(QString,QString,QString)");
            warningPrinted = true;
        }
        QDBusAbstractInterface::connectNotify(NameOwnerChangedSignal);
    }
}
 
void QDBusConnectionInterface::disconnectNotify(const QMetaMethod &signal)
{
    // translate the signal names to what we really want
    // this avoids setting hooks for signals that don't exist on the bus
    static const QMetaMethod serviceRegisteredSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::serviceRegistered);
    static const QMetaMethod serviceUnregisteredSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::serviceUnregistered);
    static const QMetaMethod serviceOwnerChangedSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::serviceOwnerChanged);
    static const QMetaMethod NameAcquiredSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::NameAcquired);
    static const QMetaMethod NameLostSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::NameLost);
    static const QMetaMethod NameOwnerChangedSignal = QMetaMethod::fromSignal(&QDBusConnectionInterface::NameOwnerChanged);
    if (signal == serviceRegisteredSignal)
        QDBusAbstractInterface::disconnectNotify(NameAcquiredSignal);
 
    else if (signal == serviceUnregisteredSignal)
        QDBusAbstractInterface::disconnectNotify(NameLostSignal);
 
    else if (signal == serviceOwnerChangedSignal)
        QDBusAbstractInterface::disconnectNotify(NameOwnerChangedSignal);
}
 
// signals
QT_END_NAMESPACE
 
#include "moc_qdbusconnectioninterface.cpp"
 
#endif // QT_NO_DBUS