diff options
Diffstat (limited to 'src/dbus/qdbuspendingcall.cpp')
| -rw-r--r-- | src/dbus/qdbuspendingcall.cpp | 472 |
1 files changed, 472 insertions, 0 deletions
diff --git a/src/dbus/qdbuspendingcall.cpp b/src/dbus/qdbuspendingcall.cpp new file mode 100644 index 0000000..9753bbe --- /dev/null +++ b/src/dbus/qdbuspendingcall.cpp @@ -0,0 +1,472 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbuspendingcall.h" +#include "qdbuspendingcall_p.h" + +#include "qdbusconnection_p.h" +#include "qdbusmetatype_p.h" +#include "qcoreapplication.h" +#include "qcoreevent.h" +#include <private/qobject_p.h> + +QT_BEGIN_NAMESPACE + +/*! + \class QDBusPendingCall + \inmodule QtDBus + \since 4.5 + + \brief The QDBusPendingCall class refers to one pending asynchronous call + + A QDBusPendingCall object is a reference to a method call that was + sent over D-Bus without waiting for a reply. QDBusPendingCall is an + opaque type, meant to be used as a handle for a pending reply. + + In most programs, the QDBusPendingCall class will not be used + directly. It can be safely replaced with the template-based + QDBusPendingReply, in order to access the contents of the reply or + wait for it to be complete. + + The QDBusPendingCallWatcher class allows one to connect to a signal + that will indicate when the reply has arrived or if the call has + timed out. It also provides the + QDBusPendingCallWatcher::waitForFinished() method which will suspend + the execution of the program until the reply has arrived. + + \note If you create a copy of a QDBusPendingCall object, all + information will be shared among the many copies. Therefore, + QDBusPendingCall is an explicitly-shared object and does not + provide a method of detaching the copies (since they refer + to the same pending call) + + \sa QDBusPendingReply, QDBusPendingCallWatcher, + QDBusAbstractInterface::asyncCall() +*/ + +/*! + \class QDBusPendingCallWatcher + \inmodule QtDBus + \since 4.5 + + \brief The QDBusPendingCallWatcher class provides a convenient way for + waiting for asynchronous replies + + The QDBusPendingCallWatcher provides the finished() signal that will be + emitted when a reply arrives. + + It is usually used like the following example: + + \snippet doc/src/snippets/code/src.qdbus.qdbuspendingcall.cpp 0 + + Note that it is not necessary to keep the original QDBusPendingCall + object around since QDBusPendingCallWatcher inherits from that class + too. + + The slot connected to by the above code could be something similar + to the following: + + \snippet doc/src/snippets/code/src.qdbus.qdbuspendingcall.cpp 1 + + Note the use of QDBusPendingReply to validate the argument types in + the reply. If the reply did not contain exactly two arguments + (one string and one QByteArray), QDBusPendingReply::isError() will + return true. + + \sa QDBusPendingReply, QDBusAbstractInterface::asyncCall() +*/ + +/*! + \fn void QDBusPendingCallWatcher::finished(QDBusPendingCallWatcher *self) + + This signal is emitted when the pending call has finished and its + reply is available. The \a self parameter is a pointer to the + object itself, passed for convenience so that the slot can access + the properties and determine the contents of the reply. +*/ + +void QDBusPendingCallWatcherHelper::add(QDBusPendingCallWatcher *watcher) +{ + connect(this, SIGNAL(finished()), watcher, SLOT(_q_finished()), Qt::QueuedConnection); +} + +QDBusPendingCallPrivate::~QDBusPendingCallPrivate() +{ + if (pending) { + q_dbus_pending_call_cancel(pending); + q_dbus_pending_call_unref(pending); + } + delete watcherHelper; +} + +bool QDBusPendingCallPrivate::setReplyCallback(QObject *target, const char *member) +{ + receiver = target; + metaTypes.clear(); + methodIdx = -1; + if (!target) + return true;; // unsetting + + if (!member || !*member) { + // would not be able to deliver a reply + qWarning("QDBusPendingCall::setReplyCallback: error: cannot deliver a reply to %s::%s (%s)", + target ? target->metaObject()->className() : "(null)", + member ? member + 1 : "(null)", + target ? qPrintable(target->objectName()) : "no name"); + return false; + } + + methodIdx = QDBusConnectionPrivate::findSlot(target, member + 1, metaTypes); + if (methodIdx == -1) { + QByteArray normalizedName = QMetaObject::normalizedSignature(member + 1); + methodIdx = QDBusConnectionPrivate::findSlot(target, normalizedName, metaTypes); + } + if (methodIdx == -1) { + // would not be able to deliver a reply + qWarning("QDBusPendingCall::setReplyCallback: error: cannot deliver a reply to %s::%s (%s)", + target->metaObject()->className(), + member + 1, qPrintable(target->objectName())); + return false; + } + + // success + // construct the expected signature + int count = metaTypes.count() - 1; + if (count == 1 && metaTypes.at(1) == QDBusMetaTypeId::message) { + // wildcard slot, can receive anything, so don't set the signature + return true; + } + + if (metaTypes.at(count) == QDBusMetaTypeId::message) + --count; + + // QList<int> is actually a vector + // kids, don't try this at home + setMetaTypes(count, count ? &metaTypes.at(1) : 0); + return true; +} + +void QDBusPendingCallPrivate::setMetaTypes(int count, const int *types) +{ + expectedReplyCount = count; + if (count == 0) { + expectedReplySignature = QLatin1String(""); // not null + return; + } + + QByteArray sig; + sig.reserve(count + count / 2); + for (int i = 0; i < count; ++i) { + const char *typeSig = QDBusMetaType::typeToSignature(types[i]); + if (!typeSig) { + qFatal("QDBusPendingReply: type %s is not registered with QtDBus", + QMetaType::typeName(types[i])); + } + sig += typeSig; + } + + expectedReplySignature = QString::fromLatin1(sig); +} + +void QDBusPendingCallPrivate::checkReceivedSignature() +{ + if (replyMessage.type() == QDBusMessage::InvalidMessage) + return; // not yet finished - no message to + // validate against + if (replyMessage.type() == QDBusMessage::ErrorMessage) + return; // we don't have to check the signature of an error reply + + if (expectedReplySignature.isNull()) + return; // no signature to validate against + + // can't use startsWith here because a null string doesn't start or end with an empty string + if (!replyMessage.signature().indexOf(expectedReplySignature) == 0) { + QString errorMsg = QLatin1String("Unexpected reply signature: got \"%1\", " + "expected \"%2\""); + replyMessage = QDBusMessage::createError( + QDBusError::InvalidSignature, + errorMsg.arg(replyMessage.signature(), expectedReplySignature)); + + } +} + +void QDBusPendingCallPrivate::waitForFinished() +{ + if (replyMessage.type() != QDBusMessage::InvalidMessage) + return; // already finished + + connection->waitForFinished(this); +} + +/*! + Creates a copy of the \a other pending asynchronous call. Note + that both objects will refer to the same pending call. +*/ +QDBusPendingCall::QDBusPendingCall(const QDBusPendingCall &other) + : d(other.d) +{ +} + +/*! + \internal +*/ +QDBusPendingCall::QDBusPendingCall(QDBusPendingCallPrivate *dd) + : d(dd) +{ +} + +/*! + Destroys this copy of the QDBusPendingCall object. If this copy is + also the last copy of a pending asynchronous call, the call will + be canceled and no further notifications will be received. There + will be no way of accessing the reply's contents when it arrives. +*/ +QDBusPendingCall::~QDBusPendingCall() +{ + // d deleted by QExplicitlySharedDataPointer +} + + +/*! + Creates a copy of the \a other pending asynchronous call and drops + the reference to the previously-referenced call. Note that both + objects will refer to the same pending call after this function. + + If this object contained the last reference of a pending + asynchronous call, the call will be canceled and no further + notifications will be received. There will be no way of accessing + the reply's contents when it arrives. +*/ +QDBusPendingCall &QDBusPendingCall::operator=(const QDBusPendingCall &other) +{ + d = other.d; + return *this; +} + +/*! + \fn bool QDBusPendingCallWatcher::isFinished() const + + Returns true if the pending call has finished processing and the + reply has been received. + + Note that this function only changes state if you call + waitForFinished() or if an external D-Bus event happens, which in + general only happens if you return to the event loop execution. + + \sa QDBusPendingReply::isFinished() +*/ +/*! + \fn bool QDBusPendingReply::isFinished() const + + Returns true if the pending call has finished processing and the + reply has been received. If this function returns true, the + isError(), error() and reply() methods should return valid + information. + + Note that this function only changes state if you call + waitForFinished() or if an external D-Bus event happens, which in + general only happens if you return to the event loop execution. + + \sa QDBusPendingCallWatcher::isFinished() +*/ + +bool QDBusPendingCall::isFinished() const +{ + return d && (d->replyMessage.type() != QDBusMessage::InvalidMessage); +} + +void QDBusPendingCall::waitForFinished() +{ + if (d) d->waitForFinished(); +} + +/*! + \fn bool QDBusPendingReply::isValid() const + + Returns true if the reply contains a normal reply message, false + if it contains anything else. + + If the pending call has not finished processing, this function + return false. +*/ +bool QDBusPendingCall::isValid() const +{ + return d ? d->replyMessage.type() == QDBusMessage::ReplyMessage : false; +} + +/*! + \fn bool QDBusPendingReply::isError() const + + Returns true if the reply contains an error message, false if it + contains a normal method reply. + + If the pending call has not finished processing, this function + also returns true. +*/ +bool QDBusPendingCall::isError() const +{ + return d ? d->replyMessage.type() == QDBusMessage::ErrorMessage : true; +} + +/*! + \fn QDBusError QDBusPendingReply::error() const + + Retrieves the error content of the reply message, if it has + finished processing. If the reply message has not finished + processing or if it contains a normal reply message (non-error), + this function returns an invalid QDBusError. +*/ +QDBusError QDBusPendingCall::error() const +{ + if (d) + return d->replyMessage; + + // not connected, return an error + QDBusError err = QDBusError(QDBusError::Disconnected, + QLatin1String("Not connected to D-Bus server")); + return err; +} + +/*! + \fn QDBusMessage QDBusPendingReply::reply() const + + Retrieves the reply message received for the asynchronous call + that was sent, if it has finished processing. If the pending call + is not finished, this function returns a QDBusMessage of type + QDBusMessage::InvalidMessage. + + After it has finished processing, the message type will either be + an error message or a normal method reply message. +*/ +QDBusMessage QDBusPendingCall::reply() const +{ + return d ? d->replyMessage : QDBusMessage::createError(error()); +} + +#if 0 +/*! + Sets the slot \a member in object \a target to be called when the + reply arrives. The slot's parameter list must match the reply + message's arguments for it to be called. + + It may, optionally, contain a QDBusMessage final parameter. If it + is present, the parameter will contain the reply message object. + + The callback will not be called if the reply is an error message. + + This function returns true if it could set the callback, false + otherwise. It is not a guarantee that the callback will be + called. + + \warning QDBusPendingCall only supports one callback per pending + asynchronous call, even if multiple QDBusPendingCall + objects are referencing the same pending call. +*/ +bool QDBusPendingCall::setReplyCallback(QObject *target, const char *member) +{ + if (!d) + return false; + + return d->setReplyCallback(target, member); +} +#endif + + +class QDBusPendingCallWatcherPrivate: public QObjectPrivate +{ +public: + void _q_finished(); + + Q_DECLARE_PUBLIC(QDBusPendingCallWatcher) +}; + +inline void QDBusPendingCallWatcherPrivate::_q_finished() +{ + Q_Q(QDBusPendingCallWatcher); + emit q->finished(q); +} + +/*! + Creates a QDBusPendingCallWatcher object to watch for replies on the + asynchronous pending call \a call and sets this object's parent + to \a parent. +*/ +QDBusPendingCallWatcher::QDBusPendingCallWatcher(const QDBusPendingCall &call, QObject *parent) + : QObject(*new QDBusPendingCallWatcherPrivate, parent), QDBusPendingCall(call) +{ + if (d) { + if (!d->watcherHelper) + d->watcherHelper = new QDBusPendingCallWatcherHelper; + d->watcherHelper->add(this); + } +} + +/*! + Destroys this object. If this QDBusPendingCallWatcher object was the + last reference to the unfinished pending call, the call will be + canceled. +*/ +QDBusPendingCallWatcher::~QDBusPendingCallWatcher() +{ +} + +/*! + \fn void QDBusPendingCallWatcher::waitForFinished() + + Suspends the execution of the calling thread until the reply is + received and processed. After this function returns, isFinished() + should return true, indicating the reply's contents are ready to + be processed. + + \sa QDBusPendingReply::waitForFinished() +*/ +void QDBusPendingCallWatcher::waitForFinished() +{ + if (d) { + d->waitForFinished(); + + // our signals were queued, so deliver them + QCoreApplication::sendPostedEvents(this, QEvent::MetaCall); + } +} +QT_END_NAMESPACE + +#include "moc_qdbuspendingcall.cpp" |