[telepathy-qt4/master] ChannelDispatchOperation: Added ChannelDispatchOperation high-level class.
Andre Moreira Magalhaes (andrunko)
andre.magalhaes at collabora.co.uk
Mon Jun 1 10:43:08 PDT 2009
---
TelepathyQt4/ChannelDispatchOperation | 13 +
TelepathyQt4/ChannelDispatchOperationInterface | 13 +
TelepathyQt4/Makefile.am | 13 +
TelepathyQt4/channel-dispatch-operation.cpp | 374 ++++++++++++++++++++++++
TelepathyQt4/channel-dispatch-operation.h | 126 ++++++++
TelepathyQt4/channel-dispatch-operation.xml | 9 +
TelepathyQt4/stable-interfaces.xml | 1 +
TelepathyQt4/types.h | 2 +
8 files changed, 551 insertions(+), 0 deletions(-)
create mode 100644 TelepathyQt4/ChannelDispatchOperation
create mode 100644 TelepathyQt4/ChannelDispatchOperationInterface
create mode 100644 TelepathyQt4/channel-dispatch-operation.cpp
create mode 100644 TelepathyQt4/channel-dispatch-operation.h
create mode 100644 TelepathyQt4/channel-dispatch-operation.xml
diff --git a/TelepathyQt4/ChannelDispatchOperation b/TelepathyQt4/ChannelDispatchOperation
new file mode 100644
index 0000000..dc85b75
--- /dev/null
+++ b/TelepathyQt4/ChannelDispatchOperation
@@ -0,0 +1,13 @@
+#ifndef _TelepathyQt4_Client_ChannelDispatchOperation_HEADER_GUARD_
+#define _TelepathyQt4_Client_ChannelDispatchOperation_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_QT4_HEADER
+#define IN_TELEPATHY_QT4_HEADER
+#endif
+
+#include <TelepathyQt4/channel-dispatch-operation.h>
+
+#undef IN_TELEPATHY_QT4_HEADER
+
+#endif
+// vim:set ft=cpp:
diff --git a/TelepathyQt4/ChannelDispatchOperationInterface b/TelepathyQt4/ChannelDispatchOperationInterface
new file mode 100644
index 0000000..b45e4fc
--- /dev/null
+++ b/TelepathyQt4/ChannelDispatchOperationInterface
@@ -0,0 +1,13 @@
+#ifndef _TelepathyQt4_Client_ChannelDispatchOperationInterface_HEADER_GUARD_
+#define _TelepathyQt4_Client_ChannelDispatchOperationInterface_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_QT4_HEADER
+#define IN_TELEPATHY_QT4_HEADER
+#endif
+
+#include <TelepathyQt4/channel-dispatch-operation.h>
+
+#undef IN_TELEPATHY_QT4_HEADER
+
+#endif
+// vim:set ft=cpp:
diff --git a/TelepathyQt4/Makefile.am b/TelepathyQt4/Makefile.am
index b66ff4a..68ff0a5 100644
--- a/TelepathyQt4/Makefile.am
+++ b/TelepathyQt4/Makefile.am
@@ -18,6 +18,7 @@ EXTRA_DIST = \
account-manager.xml \
async-model.dox \
channel.xml \
+ channel-dispatch-operation.xml \
channel-request.xml \
client.xml \
connection.xml \
@@ -54,6 +55,7 @@ libtelepathy_qt4_la_SOURCES = \
channel-factory.cpp \
channel-factory.h \
channel-request.cpp \
+ channel-dispatch-operation.cpp \
client.cpp \
client-registrar.cpp \
client-registrar-internal.h \
@@ -100,6 +102,8 @@ nodist_libtelepathy_qt4_la_SOURCES = \
_gen/cli-account-manager.moc.hpp \
_gen/cli-channel-body.hpp \
_gen/cli-channel.moc.hpp \
+ _gen/cli-channel-dispatch-operation-body.hpp \
+ _gen/cli-channel-dispatch-operation.moc.hpp \
_gen/cli-channel-request-body.hpp \
_gen/cli-channel-request.moc.hpp \
_gen/cli-client-body.hpp \
@@ -121,6 +125,7 @@ nodist_libtelepathy_qt4_la_SOURCES = \
_gen/account.moc.hpp \
_gen/account-manager.moc.hpp \
_gen/channel.moc.hpp \
+ _gen/channel-dispatch-operation.moc.hpp \
_gen/channel-request.moc.hpp \
_gen/client.moc.hpp \
_gen/client-registrar.moc.hpp \
@@ -157,6 +162,7 @@ tpqt4include_HEADERS = \
Account \
AccountManager \
Channel \
+ ChannelDispatchOperation \
ChannelRequest \
Client \
ClientRegistrar \
@@ -214,6 +220,7 @@ tpqt4include_HEADERS = \
ChannelInterfaceHoldInterface \
ChannelInterfaceMediaSignallingInterface \
ChannelInterfacePasswordInterface \
+ ChannelDispatchOperationInterface \
ChannelRequestInterface \
ChannelTypeContactListInterface \
ChannelTypeRoomListInterface \
@@ -245,6 +252,7 @@ tpqt4include_HEADERS = \
account.h \
account-manager.h \
channel.h \
+ channel-dispatch-operation.h \
channel-request.h \
client.h \
client-registrar.h \
@@ -289,6 +297,7 @@ nodist_geninclude_HEADERS = \
_gen/cli-account.h \
_gen/cli-account-manager.h \
_gen/cli-channel.h \
+ _gen/cli-channel-dispatch-operation.h \
_gen/cli-channel-request.h \
_gen/cli-client.h \
_gen/cli-connection.h \
@@ -389,6 +398,10 @@ _gen/cli-%.h _gen/cli-%-body.hpp: _gen/spec-%.xml \
group='clientchannel'; \
prettyinclude='Channel'; \
mainiface='--mainiface=Tp::Client::ChannelInterface';; \
+ channel-dispatch-operation) \
+ group='clientchanneldispatchoperation'; \
+ prettyinclude='ChannelDispatchOperation'; \
+ mainiface='--mainiface=Tp::Client::ChannelDispatchOperationInterface';; \
channel-request) \
group='clientchannelrequest'; \
prettyinclude='ChannelRequest'; \
diff --git a/TelepathyQt4/channel-dispatch-operation.cpp b/TelepathyQt4/channel-dispatch-operation.cpp
new file mode 100644
index 0000000..a55ce98
--- /dev/null
+++ b/TelepathyQt4/channel-dispatch-operation.cpp
@@ -0,0 +1,374 @@
+/*
+ * This file is part of TelepathyQt4
+ *
+ * Copyright (C) 2009 Collabora Ltd. <http://www.collabora.co.uk/>
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <TelepathyQt4/ChannelDispatchOperation>
+
+#include "TelepathyQt4/_gen/cli-channel-dispatch-operation-body.hpp"
+#include "TelepathyQt4/_gen/cli-channel-dispatch-operation.moc.hpp"
+#include "TelepathyQt4/_gen/channel-dispatch-operation.moc.hpp"
+
+#include "TelepathyQt4/channel-factory.h"
+#include "TelepathyQt4/debug-internal.h"
+
+#include <TelepathyQt4/Account>
+#include <TelepathyQt4/Channel>
+#include <TelepathyQt4/Connection>
+#include <TelepathyQt4/PendingReady>
+#include <TelepathyQt4/PendingVoidMethodCall>
+
+/**
+ * \addtogroup clientsideproxies Client-side proxies
+ *
+ * Proxy objects representing remote service objects accessed via D-Bus.
+ *
+ * In addition to providing direct access to methods, signals and properties
+ * exported by the remote objects, some of these proxies offer features like
+ * automatic inspection of remote object capabilities, property tracking,
+ * backwards compatibility helpers for older services and other utilities.
+ */
+
+/**
+ * \defgroup clientchanneldispatchoperation ChannelDispatchOperation proxies
+ * \ingroup clientsideproxies
+ *
+ * Proxy objects representing remote Telepathy Channel Dispatch Operations and
+ * their optional interfaces.
+ */
+
+namespace Tp
+{
+
+struct ChannelDispatchOperation::Private
+{
+ Private(ChannelDispatchOperation *parent);
+ ~Private();
+
+ static void introspectMain(Private *self);
+
+ void extractMainProps(const QVariantMap &props,
+ bool immutableProperties);
+ void checkReady();
+
+ // Public object
+ ChannelDispatchOperation *parent;
+
+ // Instance of generated interface class
+ Client::ChannelDispatchOperationInterface *baseInterface;
+
+ // Optional interface proxies
+ Client::DBus::PropertiesInterface *properties;
+
+ ReadinessHelper *readinessHelper;
+
+ // Introspection
+ QStringList interfaces;
+ ConnectionPtr connection;
+ AccountPtr account;
+ QList<ChannelPtr> channels;
+ QStringList possibleHandlers;
+};
+
+ChannelDispatchOperation::Private::Private(ChannelDispatchOperation *parent)
+ : parent(parent),
+ baseInterface(new Client::ChannelDispatchOperationInterface(
+ parent->dbusConnection(), parent->busName(),
+ parent->objectPath(), parent)),
+ properties(0),
+ readinessHelper(parent->readinessHelper())
+{
+ debug() << "Creating new ChannelDispatchOperation:" << parent->objectPath();
+
+ ReadinessHelper::Introspectables introspectables;
+
+ // As ChannelDispatchOperation does not have predefined statuses let's simulate one (0)
+ ReadinessHelper::Introspectable introspectableCore(
+ QSet<uint>() << 0, // makesSenseForStatuses
+ Features(), // dependsOnFeatures
+ QStringList(), // dependsOnInterfaces
+ (ReadinessHelper::IntrospectFunc) &Private::introspectMain,
+ this);
+ introspectables[FeatureCore] = introspectableCore;
+
+ readinessHelper->addIntrospectables(introspectables);
+}
+
+ChannelDispatchOperation::Private::~Private()
+{
+}
+
+void ChannelDispatchOperation::Private::introspectMain(ChannelDispatchOperation::Private *self)
+{
+ if (!self->properties) {
+ self->properties = self->parent->propertiesInterface();
+ Q_ASSERT(self->properties != 0);
+ }
+
+ self->parent->connect(self->baseInterface,
+ SIGNAL(ChannelLost(const QDBusObjectPath &, const QString &, const QString &)),
+ SLOT(onChannelLost(const QDBusObjectPath &, const QString &, const QString &)));
+
+ debug() << "Calling Properties::GetAll(ChannelDispatchOperation)";
+ QDBusPendingCallWatcher *watcher =
+ new QDBusPendingCallWatcher(
+ self->properties->GetAll(TELEPATHY_INTERFACE_CHANNEL_DISPATCH_OPERATION),
+ self->parent);
+ self->parent->connect(watcher,
+ SIGNAL(finished(QDBusPendingCallWatcher*)),
+ SLOT(gotMainProperties(QDBusPendingCallWatcher*)));
+}
+
+void ChannelDispatchOperation::Private::extractMainProps(const QVariantMap &props,
+ bool immutableProperties)
+{
+ interfaces = qdbus_cast<QStringList>(props.value("Interfaces"));
+
+ if (!connection && props.contains("Connection")) {
+ QDBusObjectPath connectionObjectPath =
+ qdbus_cast<QDBusObjectPath>(props.value("Connection"));
+ QString connectionBusName =
+ connectionObjectPath.path().mid(1).replace('/', '.');
+ connection = Connection::create(
+ connectionBusName,
+ connectionObjectPath.path());
+ }
+
+ if (!account && props.contains("Account")) {
+ QDBusObjectPath accountObjectPath =
+ qdbus_cast<QDBusObjectPath>(props.value("Account"));
+ account = Account::create(
+ TELEPATHY_ACCOUNT_MANAGER_BUS_NAME,
+ accountObjectPath.path());
+ }
+
+ if (!immutableProperties) {
+ ChannelDetailsList channelDetailsList =
+ qdbus_cast<ChannelDetailsList>(props.value("ChannelDetailsList"));
+ ChannelPtr channel;
+ foreach (const ChannelDetails &channelDetails, channelDetailsList) {
+ channel = ChannelFactory::create(connection,
+ channelDetails.channel.path(),
+ channelDetails.properties);
+ channels.append(channel);
+ }
+ }
+
+ possibleHandlers = qdbus_cast<QStringList>(props.value("PossibleHandlers"));
+}
+
+void ChannelDispatchOperation::Private::checkReady()
+{
+ if (!connection->isReady() || !account->isReady()) {
+ return;
+ }
+
+ foreach (const ChannelPtr &channel, channels) {
+ if (!channel->isReady()) {
+ return;
+ }
+ }
+
+ readinessHelper->setIntrospectCompleted(FeatureCore, true);
+}
+
+/**
+ * \class ChannelDispatchOperation
+ * \ingroup clientchanneldispatchoperation
+ * \headerfile <TelepathyQt4/channel-dispatch-operation.h> <TelepathyQt4/ChannelDispatchOperation>
+ *
+ * High-level proxy object for accessing remote Telepathy
+ * ChannelDispatchOperation objects.
+ */
+
+const Feature ChannelDispatchOperation::FeatureCore = Feature(ChannelDispatchOperation::staticMetaObject.className(), 0, true);
+
+ChannelDispatchOperationPtr ChannelDispatchOperation::create(const QString &objectPath,
+ const QVariantMap &immutableProperties)
+{
+ return ChannelDispatchOperationPtr(new ChannelDispatchOperation(
+ QDBusConnection::sessionBus(), objectPath,
+ immutableProperties));
+}
+
+ChannelDispatchOperationPtr ChannelDispatchOperation::create(const QDBusConnection &bus,
+ const QString &objectPath, const QVariantMap &immutableProperties)
+{
+ return ChannelDispatchOperationPtr(new ChannelDispatchOperation(
+ bus, objectPath, immutableProperties));
+}
+
+ChannelDispatchOperation::ChannelDispatchOperation(const QDBusConnection &bus,
+ const QString &objectPath, const QVariantMap &immutableProperties)
+ : StatefulDBusProxy(bus,
+ "org.freedesktop.Telepathy.ChannelDispatcher",
+ objectPath),
+ OptionalInterfaceFactory<ChannelDispatchOperation>(this),
+ ReadyObject(this, FeatureCore),
+ mPriv(new Private(this))
+{
+ mPriv->extractMainProps(immutableProperties, true);
+}
+
+/**
+ * Class destructor.
+ */
+ChannelDispatchOperation::~ChannelDispatchOperation()
+{
+ delete mPriv;
+}
+
+QStringList ChannelDispatchOperation::interfaces() const
+{
+ return mPriv->interfaces;
+}
+
+ConnectionPtr ChannelDispatchOperation::connection() const
+{
+ return mPriv->connection;
+}
+
+AccountPtr ChannelDispatchOperation::account() const
+{
+ return mPriv->account;
+}
+
+QList<ChannelPtr> ChannelDispatchOperation::channels() const
+{
+ if (!isReady()) {
+ warning() << "ChannelDispatchOperation::channels called with channel "
+ "not ready";
+ }
+ return mPriv->channels;
+}
+
+QStringList ChannelDispatchOperation::possibleHandlers() const
+{
+ return mPriv->possibleHandlers;
+}
+
+PendingOperation *ChannelDispatchOperation::handleWith(const QString &handler)
+{
+ return new PendingVoidMethodCall(this,
+ mPriv->baseInterface->HandleWith(handler));
+}
+
+PendingOperation *ChannelDispatchOperation::claim()
+{
+ return new PendingVoidMethodCall(this,
+ mPriv->baseInterface->Claim());
+}
+
+/**
+ * Get the ChannelDispatchOperationInterface for this ChannelDispatchOperation
+ * class. This method is protected since the convenience methods provided by
+ * this class should always be used instead of the interface by users of the
+ * class.
+ *
+ * \return A pointer to the existing ChannelDispatchOperationInterface for this
+ * ChannelDispatchOperation
+ */
+Client::ChannelDispatchOperationInterface *ChannelDispatchOperation::baseInterface() const
+{
+ return mPriv->baseInterface;
+}
+
+void ChannelDispatchOperation::gotMainProperties(QDBusPendingCallWatcher *watcher)
+{
+ QDBusPendingReply<QVariantMap> reply = *watcher;
+ QVariantMap props;
+
+ if (!reply.isError()) {
+ debug() << "Got reply to Properties::GetAll(ChannelDispatchOperation)";
+ props = reply.value();
+
+ mPriv->extractMainProps(props, false);
+
+ connect(mPriv->connection->becomeReady(),
+ SIGNAL(finished(Tp::PendingOperation *)),
+ SLOT(onConnectionReady(Tp::PendingOperation *)));
+ connect(mPriv->account->becomeReady(),
+ SIGNAL(finished(Tp::PendingOperation *)),
+ SLOT(onAccountReady(Tp::PendingOperation *)));
+ foreach (const ChannelPtr &channel, mPriv->channels) {
+ connect(channel->becomeReady(),
+ SIGNAL(finished(Tp::PendingOperation *)),
+ SLOT(onChannelReady(Tp::PendingOperation *)));
+ }
+ }
+ else {
+ mPriv->readinessHelper->setIntrospectCompleted(FeatureCore,
+ false, reply.error());
+ warning().nospace() << "Properties::GetAll(ChannelDispatchOperation) failed with "
+ << reply.error().name() << ": " << reply.error().message();
+ }
+}
+
+void ChannelDispatchOperation::onConnectionReady(PendingOperation *op)
+{
+ if (op->isError()) {
+ warning() << "ChannelDispatchOperation: Unable to make connection ready";
+ mPriv->readinessHelper->setIntrospectCompleted(FeatureCore, false,
+ op->errorName(), op->errorMessage());
+ return;
+ }
+ mPriv->checkReady();
+}
+
+void ChannelDispatchOperation::onAccountReady(PendingOperation *op)
+{
+ if (op->isError()) {
+ warning() << "ChannelDispatchOperation: Unable to make account ready";
+ mPriv->readinessHelper->setIntrospectCompleted(FeatureCore, false,
+ op->errorName(), op->errorMessage());
+ return;
+ }
+ mPriv->checkReady();
+}
+
+void ChannelDispatchOperation::onChannelReady(PendingOperation *op)
+{
+ if (op->isError()) {
+ PendingReady *pr = qobject_cast<PendingReady*>(op);
+ ChannelPtr channel(qobject_cast<Channel*>(pr->object()));
+ // only fail if channel still exists (channelLost was not emitted)
+ if (mPriv->channels.contains(channel)) {
+ warning() << "ChannelDispatchOperation: Unable to make channel ready";
+ mPriv->readinessHelper->setIntrospectCompleted(FeatureCore, false,
+ op->errorName(), op->errorMessage());
+ }
+ return;
+ }
+ mPriv->checkReady();
+}
+
+void ChannelDispatchOperation::onChannelLost(
+ const QDBusObjectPath &channelObjectPath,
+ const QString &errorName, const QString &errorMessage)
+{
+ foreach (const ChannelPtr &channel, mPriv->channels) {
+ if (channel->objectPath() == channelObjectPath.path()) {
+ emit channelLost(channel, errorName, errorMessage);
+ mPriv->channels.removeOne(channel);
+ return;
+ }
+ }
+}
+
+} // Tp
diff --git a/TelepathyQt4/channel-dispatch-operation.h b/TelepathyQt4/channel-dispatch-operation.h
new file mode 100644
index 0000000..f3544ac
--- /dev/null
+++ b/TelepathyQt4/channel-dispatch-operation.h
@@ -0,0 +1,126 @@
+/*
+ * This file is part of TelepathyQt4
+ *
+ * Copyright (C) 2009 Collabora Ltd. <http://www.collabora.co.uk/>
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _TelepathyQt4_cli_channel_dispatch_operation_h_HEADER_GUARD_
+#define _TelepathyQt4_cli_channel_dispatch_operation_h_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_QT4_HEADER
+#error IN_TELEPATHY_QT4_HEADER
+#endif
+
+#include <TelepathyQt4/_gen/cli-channel-dispatch-operation.h>
+
+#include <TelepathyQt4/Constants>
+#include <TelepathyQt4/DBus>
+#include <TelepathyQt4/DBusProxy>
+#include <TelepathyQt4/Feature>
+#include <TelepathyQt4/OptionalInterfaceFactory>
+#include <TelepathyQt4/ReadinessHelper>
+#include <TelepathyQt4/ReadyObject>
+#include <TelepathyQt4/Types>
+#include <TelepathyQt4/SharedPtr>
+
+#include <QString>
+#include <QStringList>
+#include <QVariantMap>
+
+namespace Tp
+{
+
+class PendingOperation;
+
+class ChannelDispatchOperation : public StatefulDBusProxy,
+ private OptionalInterfaceFactory<ChannelDispatchOperation>,
+ public ReadyObject,
+ public RefCounted
+{
+ Q_OBJECT
+ Q_DISABLE_COPY(ChannelDispatchOperation)
+
+public:
+ static const Feature FeatureCore;
+
+ static ChannelDispatchOperationPtr create(const QString &objectPath,
+ const QVariantMap &immutableProperties);
+ static ChannelDispatchOperationPtr create(const QDBusConnection &bus,
+ const QString &objectPath, const QVariantMap &immutableProperties);
+
+ ~ChannelDispatchOperation();
+
+ QStringList interfaces() const;
+
+ ConnectionPtr connection() const;
+
+ AccountPtr account() const;
+
+ QList<ChannelPtr> channels() const;
+
+ QStringList possibleHandlers() const;
+
+ PendingOperation *handleWith(const QString &handler);
+
+ PendingOperation *claim();
+
+ template <class Interface>
+ inline Interface *optionalInterface(
+ InterfaceSupportedChecking check = CheckInterfaceSupported) const
+ {
+ // Check for the remote object supporting the interface
+ QString name(Interface::staticInterfaceName());
+ if (check == CheckInterfaceSupported && !interfaces().contains(name))
+ return 0;
+
+ // If present or forced, delegate to OptionalInterfaceFactory
+ return OptionalInterfaceFactory<ChannelDispatchOperation>::interface<Interface>();
+ }
+
+ inline Client::DBus::PropertiesInterface *propertiesInterface() const
+ {
+ return optionalInterface<Client::DBus::PropertiesInterface>(BypassInterfaceCheck);
+ }
+
+Q_SIGNALS:
+ void channelLost(const ChannelPtr &channel, const QString &errorName,
+ const QString &errorMessage);
+
+protected:
+ ChannelDispatchOperation(const QDBusConnection &bus,
+ const QString &objectPath, const QVariantMap &immutableProperties);
+
+ Client::ChannelDispatchOperationInterface *baseInterface() const;
+
+private Q_SLOTS:
+ void gotMainProperties(QDBusPendingCallWatcher *watcher);
+ void onConnectionReady(Tp::PendingOperation *op);
+ void onAccountReady(Tp::PendingOperation *op);
+ void onChannelReady(Tp::PendingOperation *op);
+ void onChannelLost(const QDBusObjectPath &channelObjectPath,
+ const QString &errorName, const QString &errorMessage);
+
+private:
+ struct Private;
+ friend struct Private;
+ Private *mPriv;
+};
+
+} // Tp
+
+#endif
diff --git a/TelepathyQt4/channel-dispatch-operation.xml b/TelepathyQt4/channel-dispatch-operation.xml
new file mode 100644
index 0000000..d7a6cdd
--- /dev/null
+++ b/TelepathyQt4/channel-dispatch-operation.xml
@@ -0,0 +1,9 @@
+<tp:spec
+ xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0"
+ xmlns:xi="http://www.w3.org/2001/XInclude">
+
+<tp:title>Channel Dispatch Operation interface</tp:title>
+
+<xi:include href="../spec/Channel_Dispatch_Operation.xml"/>
+
+</tp:spec>
diff --git a/TelepathyQt4/stable-interfaces.xml b/TelepathyQt4/stable-interfaces.xml
index 4904149..8d33042 100644
--- a/TelepathyQt4/stable-interfaces.xml
+++ b/TelepathyQt4/stable-interfaces.xml
@@ -8,6 +8,7 @@
<xi:include href="connection-manager.xml"/>
<xi:include href="connection.xml"/>
<xi:include href="channel.xml"/>
+<xi:include href="channel-dispatch-operation.xml"/>
<xi:include href="channel-request.xml"/>
<xi:include href="media-session-handler.xml"/>
<xi:include href="media-stream-handler.xml"/>
diff --git a/TelepathyQt4/types.h b/TelepathyQt4/types.h
index 1ec4a65..9657388 100644
--- a/TelepathyQt4/types.h
+++ b/TelepathyQt4/types.h
@@ -38,6 +38,7 @@ class AbstractClient;
class Account;
class AccountManager;
class Channel;
+class ChannelDispatchOperation;
class ChannelRequest;
class ClientObject;
class ClientRegistrar;
@@ -53,6 +54,7 @@ typedef SharedPtr<AbstractClient> AbstractClientPtr;
typedef SharedPtr<Account> AccountPtr;
typedef SharedPtr<AccountManager> AccountManagerPtr;
typedef SharedPtr<Channel> ChannelPtr;
+typedef SharedPtr<ChannelDispatchOperation> ChannelDispatchOperationPtr;
typedef SharedPtr<ChannelRequest> ChannelRequestPtr;
typedef SharedPtr<ClientObject> ClientObjectPtr;
typedef SharedPtr<ClientRegistrar> ClientRegistrarPtr;
--
1.5.6.5
More information about the telepathy-commits
mailing list