Merge lp:~tiagosh/ubuntu/trusty/telepathy-qt5/group-chat into lp:ubuntu/trusty/telepathy-qt5

[Tiago Salem Herrmann]

* debian/patches/06-conference_interfaces.patch: add conference related interfaces
* debian/patches/07-fix_ensureChannel.patch: pass request details on ensureChannel()
  and do not check for TargetHandle and TargetHandleType as managers will take care of
  them.

* debian/patches/06-conference_interfaces.patch: add conference related interfaces
* debian/patches/07-fix_ensureChannel.patch: pass request details on ensureChannel()
  and do not check for TargetHandle and TargetHandleType as managers will take care of
  them.

[Gustavo Pichorim Boiko (boiko)]

It seems 07-fix_ensureChannel.patch is missing the code to actually forward the request details to the manager implementing it.

review: Needs Fixing

[lp:~tiagosh/ubuntu/trusty/telepathy-qt5/group-chat]

7. By Tiago Salem Herrmann on 2014-02-04

apply patch 06 to the code

8. By Tiago Salem Herrmann on 2014-02-04

update patches

9. By Tiago Salem Herrmann on 2014-02-04

fix callback signature

10. By Tiago Salem Herrmann on 2014-02-05

pass the request hints to createChannel()

[Tiago Salem Herrmann (tiagosh)]

Are there any related MPs required for this MP to build/function as expected? Please list.
No.

Is your branch in sync with latest trunk (e.g. bzr pull lp:trunk -> no changes)
Yes

Did you perform an exploratory manual test run of your code change and any related functionality on device or emulator?
Yes.

Did you successfully run all tests found in your component's Test Plan (https://wiki.ubuntu.com/Process/Merges/TestPlan/telepathy-qt) on device or emulator?
Yes.

If you changed the UI, was the change specified/approved by design?
No UI changes.

If you changed the packaging (debian), did you subscribe a core-dev to this MP?
No packaging changes.

[Gustavo Pichorim Boiko (boiko)]

Did you perform an exploratory manual test run of the code change and any related functionality on device or emulator?
Yes

Did you successfully run all tests found in your component's Test Plan (https://wiki.ubuntu.com/Process/Merges/TestPlan/telepathy-qt5) on device or emulator?
Yes

Did CI run pass? If not, please explain why.
No CI.

Have you checked that submitter has accurately filled out the submitter checklist and has taken no shortcut?
Yes.

The change looks good and works as expected.

review: Approve

=== added directory '.pc/06-conference_interfaces.patch'
=== added file '.pc/06-conference_interfaces.patch/.timestamp'
=== added directory '.pc/06-conference_interfaces.patch/TelepathyQt'
=== added file '.pc/06-conference_interfaces.patch/TelepathyQt/base-channel-internal.h'
--- .pc/06-conference_interfaces.patch/TelepathyQt/base-channel-internal.h	1970-01-01 00:00:00 +0000
+++ .pc/06-conference_interfaces.patch/TelepathyQt/base-channel-internal.h	2014-02-05 14:09:56 +0000
@@ -0,0 +1,351 @@
+/**
+ * This file is part of TelepathyQt
+ *
+ * @copyright Copyright (C) 2013 Matthias Gehre <[e-mail]>
+ * @copyright Copyright 2013 Canonical Ltd.
+ * @license LGPL 2.1
+ *
+ * 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 "TelepathyQt/_gen/svc-channel.h"
+
+#include <TelepathyQt/Global>
+#include <TelepathyQt/MethodInvocationContext>
+#include <TelepathyQt/Constants>
+#include <TelepathyQt/Types>
+#include "TelepathyQt/debug-internal.h"
+
+
+namespace Tp
+{
+
+class TP_QT_NO_EXPORT BaseChannel::Adaptee : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString channelType READ channelType)
+    Q_PROPERTY(QStringList interfaces READ interfaces)
+    Q_PROPERTY(uint targetHandle READ targetHandle)
+    Q_PROPERTY(QString targetID READ targetID)
+    Q_PROPERTY(uint targetHandleType READ targetHandleType)
+    Q_PROPERTY(bool requested READ requested)
+    Q_PROPERTY(uint initiatorHandle READ initiatorHandle)
+    Q_PROPERTY(QString initiatorID READ initiatorID)
+public:
+    Adaptee(const QDBusConnection &dbusConnection, BaseChannel *cm);
+    ~Adaptee();
+
+    QString channelType() const {
+        return mChannel->channelType();
+    }
+    QStringList interfaces() const;
+    uint targetHandle() const {
+        return mChannel->targetHandle();
+    }
+    QString targetID() const {
+        return mChannel->targetID();
+    }
+    uint targetHandleType() const {
+        return mChannel->targetHandleType();
+    }
+    bool requested() const {
+        return mChannel->requested();
+    }
+    uint initiatorHandle() const {
+        return mChannel->initiatorHandle();
+    }
+    QString initiatorID() const {
+        return mChannel->initiatorID();
+    }
+
+private Q_SLOTS:
+    void close(const Tp::Service::ChannelAdaptor::CloseContextPtr &context);
+    void getChannelType(const Tp::Service::ChannelAdaptor::GetChannelTypeContextPtr &context) {
+        context->setFinished(channelType());
+    }
+
+    void getHandle(const Tp::Service::ChannelAdaptor::GetHandleContextPtr &context) {
+        context->setFinished(targetHandleType(), targetHandle());
+    }
+
+    void getInterfaces(const Tp::Service::ChannelAdaptor::GetInterfacesContextPtr &context) {
+        context->setFinished(interfaces());
+    }
+
+
+public:
+    BaseChannel *mChannel;
+    Service::ChannelAdaptor *mAdaptor;
+
+signals:
+    void closed();
+};
+
+class TP_QT_NO_EXPORT BaseChannelTextType::Adaptee : public QObject
+{
+    Q_OBJECT
+public:
+    Adaptee(BaseChannelTextType *interface);
+    ~Adaptee();
+
+public slots:
+    void acknowledgePendingMessages(const Tp::UIntList &IDs, const Tp::Service::ChannelTypeTextAdaptor::AcknowledgePendingMessagesContextPtr &context);
+//deprecated:
+    //void getMessageTypes(const Tp::Service::ChannelTypeTextAdaptor::GetMessageTypesContextPtr &context);
+    //void listPendingMessages(bool clear, const Tp::Service::ChannelTypeTextAdaptor::ListPendingMessagesContextPtr &context);
+    //void send(uint type, const QString &text, const Tp::Service::ChannelTypeTextAdaptor::SendContextPtr &context);
+signals:
+    void lostMessage();
+    void received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString &text);
+    void sendError(uint error, uint timestamp, uint type, const QString &text);
+    void sent(uint timestamp, uint type, const QString &text);
+
+public:
+    BaseChannelTextType *mInterface;
+};
+
+class TP_QT_NO_EXPORT BaseChannelMessagesInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList supportedContentTypes READ supportedContentTypes)
+    Q_PROPERTY(Tp::UIntList messageTypes READ messageTypes)
+    Q_PROPERTY(uint messagePartSupportFlags READ messagePartSupportFlags)
+    Q_PROPERTY(Tp::MessagePartListList pendingMessages READ pendingMessages)
+    Q_PROPERTY(uint deliveryReportingSupport READ deliveryReportingSupport)
+public:
+    Adaptee(BaseChannelMessagesInterface *interface);
+    ~Adaptee();
+
+    QStringList supportedContentTypes() {
+        return mInterface->supportedContentTypes();
+    }
+    Tp::UIntList messageTypes() {
+        return mInterface->messageTypes();
+    }
+    uint messagePartSupportFlags() {
+        return mInterface->messagePartSupportFlags();
+    }
+    uint deliveryReportingSupport() {
+        return mInterface->deliveryReportingSupport();
+    }
+    Tp::MessagePartListList pendingMessages() {
+        return mInterface->pendingMessages();
+    }
+
+public slots:
+    void sendMessage(const Tp::MessagePartList &message, uint flags, const Tp::Service::ChannelInterfaceMessagesAdaptor::SendMessageContextPtr &context);
+//deprecated, never implemented:
+    //void getPendingMessageContent(uint messageID, const Tp::UIntList &parts, const Tp::Service::ChannelInterfaceMessagesAdaptor::GetPendingMessageContentContextPtr &context);
+signals:
+    void messageSent(const Tp::MessagePartList &content, uint flags, const QString &messageToken);
+    void pendingMessagesRemoved(const Tp::UIntList &messageIDs);
+    void messageReceived(const Tp::MessagePartList &message);
+
+public:
+    BaseChannelMessagesInterface *mInterface;
+};
+
+class TP_QT_NO_EXPORT BaseChannelServerAuthenticationType::Adaptee : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString authenticationMethod READ authenticationMethod)
+public:
+    Adaptee(BaseChannelServerAuthenticationType *interface);
+    ~Adaptee();
+    QString authenticationMethod() const;
+public:
+    BaseChannelServerAuthenticationType *mInterface;
+};
+
+class TP_QT_NO_EXPORT BaseChannelCaptchaAuthenticationInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool canRetryCaptcha READ canRetryCaptcha)
+    Q_PROPERTY(uint captchaStatus READ captchaStatus)
+    Q_PROPERTY(QString captchaError READ captchaError)
+    Q_PROPERTY(QVariantMap captchaErrorDetails READ captchaErrorDetails)
+public:
+    Adaptee(BaseChannelCaptchaAuthenticationInterface *interface);
+    ~Adaptee();
+    bool canRetryCaptcha() const;
+    uint captchaStatus() const;
+    QString captchaError() const;
+    QVariantMap captchaErrorDetails() const;
+public slots:
+    void getCaptchas(const Tp::Service::ChannelInterfaceCaptchaAuthenticationAdaptor::GetCaptchasContextPtr &context);
+    void getCaptchaData(uint ID, const QString &mimeType, const Tp::Service::ChannelInterfaceCaptchaAuthenticationAdaptor::GetCaptchaDataContextPtr &context);
+    void answerCaptchas(const Tp::CaptchaAnswers &answers, const Tp::Service::ChannelInterfaceCaptchaAuthenticationAdaptor::AnswerCaptchasContextPtr &context);
+    void cancelCaptcha(uint reason, const QString &debugMessage, const Tp::Service::ChannelInterfaceCaptchaAuthenticationAdaptor::CancelCaptchaContextPtr &context);
+public:
+    BaseChannelCaptchaAuthenticationInterface *mInterface;
+};
+
+class TP_QT_NO_EXPORT BaseChannelHoldInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+public:
+    Adaptee(BaseChannelHoldInterface *interface);
+    ~Adaptee();
+
+public slots:
+    void getHoldState(const Tp::Service::ChannelInterfaceHoldAdaptor::GetHoldStateContextPtr &context);
+    void requestHold(bool hold, const Tp::Service::ChannelInterfaceHoldAdaptor::RequestHoldContextPtr &context);
+signals:
+    void holdStateChanged(uint holdState, uint reason);
+
+public:
+    BaseChannelHoldInterface *mInterface;
+};
+
+class TP_QT_NO_EXPORT BaseChannelGroupInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(uint groupFlags READ groupFlags)
+    Q_PROPERTY(Tp::HandleOwnerMap handleOwners READ handleOwners)
+    Q_PROPERTY(Tp::LocalPendingInfoList localPendingMembers READ localPendingMembers)
+    Q_PROPERTY(Tp::UIntList members READ members)
+    Q_PROPERTY(Tp::UIntList remotePendingMembers READ remotePendingMembers)
+    Q_PROPERTY(uint selfHandle READ selfHandle)
+    Q_PROPERTY(Tp::HandleIdentifierMap memberIdentifiers READ memberIdentifiers)
+public:
+    Adaptee(BaseChannelGroupInterface *interface);
+    ~Adaptee();
+    uint groupFlags() const;
+    Tp::HandleOwnerMap handleOwners() const;
+    Tp::LocalPendingInfoList localPendingMembers() const;
+    Tp::UIntList members() const;
+    Tp::UIntList remotePendingMembers() const;
+    uint selfHandle() const;
+    Tp::HandleIdentifierMap memberIdentifiers() const;
+public slots:
+    void addMembers(const Tp::UIntList &contacts, const QString &message, const Tp::Service::ChannelInterfaceGroupAdaptor::AddMembersContextPtr &context);
+    void getAllMembers(const Tp::Service::ChannelInterfaceGroupAdaptor::GetAllMembersContextPtr &context);
+    void getGroupFlags(const Tp::Service::ChannelInterfaceGroupAdaptor::GetGroupFlagsContextPtr &context);
+    void getHandleOwners(const Tp::UIntList &handles, const Tp::Service::ChannelInterfaceGroupAdaptor::GetHandleOwnersContextPtr &context);
+    void getLocalPendingMembers(const Tp::Service::ChannelInterfaceGroupAdaptor::GetLocalPendingMembersContextPtr &context);
+    void getLocalPendingMembersWithInfo(const Tp::Service::ChannelInterfaceGroupAdaptor::GetLocalPendingMembersWithInfoContextPtr &context);
+    void getMembers(const Tp::Service::ChannelInterfaceGroupAdaptor::GetMembersContextPtr &context);
+    void getRemotePendingMembers(const Tp::Service::ChannelInterfaceGroupAdaptor::GetRemotePendingMembersContextPtr &context);
+    void getSelfHandle(const Tp::Service::ChannelInterfaceGroupAdaptor::GetSelfHandleContextPtr &context);
+    void removeMembers(const Tp::UIntList &contacts, const QString &message, const Tp::Service::ChannelInterfaceGroupAdaptor::RemoveMembersContextPtr &context);
+    void removeMembersWithReason(const Tp::UIntList &contacts, const QString &message, uint reason, const Tp::Service::ChannelInterfaceGroupAdaptor::RemoveMembersWithReasonContextPtr &context);
+signals:
+    void handleOwnersChangedDetailed(const Tp::HandleOwnerMap &added, const Tp::UIntList &removed, const Tp::HandleIdentifierMap &identifiers);
+    void selfContactChanged(uint selfHandle, const QString &selfID);
+    void groupFlagsChanged(uint added, uint removed);
+    void membersChanged(const QString &message, const Tp::UIntList &added, const Tp::UIntList &removed, const Tp::UIntList &localPending, const Tp::UIntList &remotePending, uint actor, uint reason);
+    void membersChangedDetailed(const Tp::UIntList &added, const Tp::UIntList &removed, const Tp::UIntList &localPending, const Tp::UIntList &remotePending, const QVariantMap &details);
+    //All other signals are deprecated
+public:
+    BaseChannelGroupInterface *mInterface;
+};
+
+class TP_QT_NO_EXPORT BaseChannelCallType::Adaptee : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(Tp::ObjectPathList contents READ contents)
+    Q_PROPERTY(QVariantMap callStateDetails READ callStateDetails)
+    Q_PROPERTY(uint callState READ callState)
+    Q_PROPERTY(uint callFlags READ callFlags)
+    Q_PROPERTY(Tp::CallStateReason callStateReason READ callStateReason)
+    Q_PROPERTY(bool hardwareStreaming READ hardwareStreaming)
+    Q_PROPERTY(Tp::CallMemberMap callMembers READ callMembers)
+    Q_PROPERTY(Tp::HandleIdentifierMap memberIdentifiers READ memberIdentifiers)
+    Q_PROPERTY(uint initialTransport READ initialTransport)
+    Q_PROPERTY(bool initialAudio READ initialAudio)
+    Q_PROPERTY(bool initialVideo READ initialVideo)
+    Q_PROPERTY(QString initialVideoName READ initialVideoName)
+    Q_PROPERTY(QString initialAudioName READ initialAudioName)
+    Q_PROPERTY(bool mutableContents READ mutableContents)
+
+public:
+    Adaptee(BaseChannelCallType *interface);
+    ~Adaptee();
+
+    Tp::ObjectPathList contents() {
+        return mInterface->contents();
+    }
+
+    QVariantMap callStateDetails() {
+        return mInterface->callStateDetails();
+    }
+
+    uint callState() {
+        return mInterface->callState();
+    }
+
+    uint callFlags() {
+        return mInterface->callFlags();
+    }
+
+    Tp::CallStateReason callStateReason() {
+        return mInterface->callStateReason();
+    }
+
+    bool hardwareStreaming() {
+        return mInterface->hardwareStreaming();
+    }
+
+    Tp::CallMemberMap callMembers() {
+        return mInterface->callMembers();
+    }
+
+    Tp::HandleIdentifierMap memberIdentifiers() {
+        return mInterface->memberIdentifiers();
+    }
+
+    uint initialTransport() {
+        return mInterface->initialTransport();
+    }
+
+    bool initialAudio() {
+        return mInterface->initialAudio();
+    }
+
+    bool initialVideo() {
+        return mInterface->initialVideo();
+    }
+
+    QString initialVideoName() {
+        return mInterface->initialVideoName();
+    }
+
+    QString initialAudioName() {
+        return mInterface->initialAudioName();
+    }
+
+    bool mutableContents() {
+        return mInterface->mutableContents();
+    }
+
+public slots:
+    void setRinging(const Tp::Service::ChannelTypeCallAdaptor::SetRingingContextPtr &context);
+    void setQueued(const Tp::Service::ChannelTypeCallAdaptor::SetQueuedContextPtr &context);
+    void accept(const Tp::Service::ChannelTypeCallAdaptor::AcceptContextPtr &context);
+    void hangup(uint reason, const QString &detailedHangupReason, const QString &message, const Tp::Service::ChannelTypeCallAdaptor::HangupContextPtr &context);
+    void addContent(const QString &contentName, const Tp::MediaStreamType &contentType, const Tp::MediaStreamDirection &initialDirection, const Tp::Service::ChannelTypeCallAdaptor::AddContentContextPtr &context);
+
+signals:
+    void contentAdded(const QDBusObjectPath &content);
+    void contentRemoved(const QDBusObjectPath &content, const Tp::CallStateReason &reason);
+    void callStateChanged(uint callState, uint callFlags, const Tp::CallStateReason &stateReason, const QVariantMap &callStateDetails);
+    void callMembersChanged(const Tp::CallMemberMap &flagsChanged, const Tp::HandleIdentifierMap &identifiers, const Tp::UIntList &removed, const Tp::CallStateReason &reason);
+
+public:
+    BaseChannelCallType *mInterface;
+};
+
+}

=== added file '.pc/06-conference_interfaces.patch/TelepathyQt/base-channel.cpp'
--- .pc/06-conference_interfaces.patch/TelepathyQt/base-channel.cpp	1970-01-01 00:00:00 +0000
+++ .pc/06-conference_interfaces.patch/TelepathyQt/base-channel.cpp	2014-02-05 14:09:56 +0000
@@ -0,0 +1,1688 @@
+/**
+ * This file is part of TelepathyQt
+ *
+ * @copyright Copyright (C) 2013 Matthias Gehre <[e-mail]>
+ * @copyright Copyright 2013 Canonical Ltd.
+ * @license LGPL 2.1
+ *
+ * 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 <TelepathyQt/BaseChannel>
+#include <TelepathyQt/BaseCall>
+#include "TelepathyQt/base-channel-internal.h"
+
+#include "TelepathyQt/_gen/base-channel.moc.hpp"
+#include "TelepathyQt/_gen/base-channel-internal.moc.hpp"
+
+#include "TelepathyQt/debug-internal.h"
+
+#include <TelepathyQt/BaseConnection>
+#include <TelepathyQt/Constants>
+#include <TelepathyQt/DBusObject>
+#include <TelepathyQt/Utils>
+#include <TelepathyQt/AbstractProtocolInterface>
+#include <QString>
+#include <QVariantMap>
+
+namespace Tp
+{
+
+struct TP_QT_NO_EXPORT BaseChannel::Private {
+    Private(BaseChannel *parent, const QDBusConnection &dbusConnection, BaseConnection* connection,
+            const QString &channelType, uint targetHandle, uint targetHandleType)
+        : parent(parent),
+          connection(connection),
+          channelType(channelType),
+          targetHandle(targetHandle),
+          targetHandleType(targetHandleType),
+          adaptee(new BaseChannel::Adaptee(dbusConnection, parent)) {
+    }
+
+    BaseChannel *parent;
+    BaseConnection* connection;
+    QString channelType;
+    QHash<QString, AbstractChannelInterfacePtr> interfaces;
+    uint targetHandle;
+    QString targetID;
+    uint targetHandleType;
+    bool requested;
+    uint initiatorHandle;
+    QString initiatorID;
+    BaseChannel::Adaptee *adaptee;
+};
+
+
+BaseChannel::Adaptee::Adaptee(const QDBusConnection &dbusConnection,
+                              BaseChannel *channel)
+    : QObject(channel),
+      mChannel(channel)
+{
+    debug() << "Creating service::channelAdaptor for " << channel->dbusObject();
+    mAdaptor = new Service::ChannelAdaptor(dbusConnection, this, channel->dbusObject());
+}
+
+BaseChannel::Adaptee::~Adaptee()
+{
+}
+
+QStringList BaseChannel::Adaptee::interfaces() const
+{
+    QStringList ret;
+    foreach(const AbstractChannelInterfacePtr & iface, mChannel->interfaces()) {
+        if (iface->interfaceName().contains(QLatin1String(".Type.")))
+            continue; //Do not include "Type"
+        ret << iface->interfaceName();
+    }
+    ret << TP_QT_IFACE_PROPERTIES;
+    return ret;
+}
+
+void BaseChannel::Adaptee::close(const Tp::Service::ChannelAdaptor::CloseContextPtr &context)
+{
+    mChannel->close();
+    context->setFinished();
+}
+
+/**
+ * \class BaseChannel
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for channel implementations.
+ *
+ */
+
+BaseChannel::BaseChannel(const QDBusConnection &dbusConnection,
+                         BaseConnection* connection,
+                         const QString &channelType, uint targetHandle,
+                         uint targetHandleType)
+    : DBusService(dbusConnection),
+      mPriv(new Private(this, dbusConnection, connection,
+                        channelType, targetHandle, targetHandleType))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannel::~BaseChannel()
+{
+    delete mPriv;
+}
+
+void BaseChannel::close()
+{
+    //emit after return
+    QMetaObject::invokeMethod(mPriv->adaptee, "closed",
+                              Qt::QueuedConnection);
+    //emit after return
+    QMetaObject::invokeMethod(this, "closed",
+                              Qt::QueuedConnection);
+}
+
+/**
+ * Return a unique name for this channel.
+ *
+ * \return A unique name for this channel.
+ */
+QString BaseChannel::uniqueName() const
+{
+    return QString(QLatin1String("_%1")).arg((quintptr) this, 0, 16);
+}
+
+bool BaseChannel::registerObject(DBusError *error)
+{
+    if (isRegistered()) {
+        return true;
+    }
+
+    QString name = uniqueName();
+    QString busName = mPriv->connection->busName();
+    //QString busName = QString(QLatin1String("%1.%2"))
+    //        .arg(mPriv->connection->busName(),name);
+    QString objectPath = QString(QLatin1String("%1/%2"))
+                         .arg(mPriv->connection->objectPath(), name);
+    debug() << "Registering channel: busName: " << busName << " objectName: " << objectPath;
+    DBusError _error;
+
+    debug() << "Channel: registering interfaces  at " << dbusObject();
+    foreach(const AbstractChannelInterfacePtr & iface, mPriv->interfaces) {
+        if (!iface->registerInterface(dbusObject())) {
+            // lets not fail if an optional interface fails registering, lets warn only
+            warning() << "Unable to register interface" << iface->interfaceName();
+        }
+    }
+
+    bool ret = registerObject(busName, objectPath, &_error);
+    if (!ret && error) {
+        error->set(_error.name(), _error.message());
+    }
+    return ret;
+}
+
+/**
+ * Reimplemented from DBusService.
+ */
+bool BaseChannel::registerObject(const QString &busName,
+                                 const QString &objectPath, DBusError *error)
+{
+    return DBusService::registerObject(busName, objectPath, error);
+}
+
+QString BaseChannel::channelType() const
+{
+    return mPriv->channelType;
+}
+QList<AbstractChannelInterfacePtr> BaseChannel::interfaces() const
+{
+    return mPriv->interfaces.values();
+}
+uint BaseChannel::targetHandle() const
+{
+    return mPriv->targetHandle;
+}
+QString BaseChannel::targetID() const
+{
+    return mPriv->targetID;
+}
+uint BaseChannel::targetHandleType() const
+{
+    return mPriv->targetHandleType;
+}
+bool BaseChannel::requested() const
+{
+    return mPriv->requested;
+}
+uint BaseChannel::initiatorHandle() const
+{
+    return mPriv->initiatorHandle;
+}
+QString BaseChannel::initiatorID() const
+{
+    return mPriv->initiatorID;
+}
+
+void BaseChannel::setInitiatorHandle(uint initiatorHandle)
+{
+    mPriv->initiatorHandle = initiatorHandle;
+}
+
+void BaseChannel::setInitiatorID(const QString &initiatorID)
+{
+    mPriv->initiatorID = initiatorID;
+}
+
+void BaseChannel::setTargetID(const QString &targetID)
+{
+    mPriv->targetID = targetID;
+}
+
+void BaseChannel::setRequested(bool requested)
+{
+    mPriv->requested = requested;
+}
+
+BaseConnection* BaseChannel::baseConnection() const
+{
+    return mPriv->connection;
+}
+
+/**
+ * Return the immutable properties of this channel object.
+ *
+ * Immutable properties cannot change after the object has been registered
+ * on the bus with registerObject().
+ *
+ * \return The immutable properties of this channel object.
+ */
+QVariantMap BaseChannel::immutableProperties() const
+{
+    QVariantMap map;
+    map.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"),
+               QVariant::fromValue(mPriv->adaptee->channelType()));
+    map.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle"),
+               QVariant::fromValue(mPriv->adaptee->targetHandle()));
+    map.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".Interfaces"),
+               QVariant::fromValue(mPriv->adaptee->interfaces()));
+    map.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetID"),
+               QVariant::fromValue(mPriv->adaptee->targetID()));
+    map.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType"),
+               QVariant::fromValue(mPriv->adaptee->targetHandleType()));
+    map.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".Requested"),
+               QVariant::fromValue(mPriv->adaptee->requested()));
+    map.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".InitiatorHandle"),
+               QVariant::fromValue(mPriv->adaptee->initiatorHandle()));
+    map.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".InitiatorID"),
+               QVariant::fromValue(mPriv->adaptee->initiatorID()));
+    return map;
+}
+
+Tp::ChannelDetails BaseChannel::details() const
+{
+    Tp::ChannelDetails details;
+    details.channel = QDBusObjectPath(objectPath());
+    details.properties.unite(immutableProperties());
+
+    foreach(const AbstractChannelInterfacePtr & iface, mPriv->interfaces) {
+        details.properties.unite(iface->immutableProperties());
+    }
+
+    return details;
+}
+
+/**
+ * Return a pointer to the interface with the given name.
+ *
+ * \param interfaceName The D-Bus name of the interface,
+ * ex. TP_QT_IFACE_PROTOCOL_INTERFACE_ADDRESSING.
+ * \return A pointer to the AbstractProtocolInterface object that implements
+ * the D-Bus interface with the given name, or a null pointer if such an interface
+ * has not been plugged into this object.
+ * \sa plugInterface(), interfaces()
+ */
+AbstractChannelInterfacePtr BaseChannel::interface(const QString &interfaceName) const
+{
+    return mPriv->interfaces.value(interfaceName);
+}
+
+/**
+ * Plug a new interface into this Protocol D-Bus object.
+ *
+ * This property is immutable and cannot change after this Protocol
+ * object has been registered on the bus with registerObject().
+ *
+ * \param interface An AbstractProtocolInterface instance that implements
+ * the interface that is to be plugged.
+ * \return \c true on success or \c false otherwise
+ * \sa interfaces(), interface()
+ */
+bool BaseChannel::plugInterface(const AbstractChannelInterfacePtr &interface)
+{
+    if (isRegistered()) {
+        warning() << "Unable to plug protocol interface " << interface->interfaceName() <<
+                  "- protocol already registered";
+        return false;
+    }
+
+    if (interface->isRegistered()) {
+        warning() << "Unable to plug protocol interface" << interface->interfaceName() <<
+                  "- interface already registered";
+        return false;
+    }
+
+    if (mPriv->interfaces.contains(interface->interfaceName())) {
+        warning() << "Unable to plug protocol interface" << interface->interfaceName() <<
+                  "- another interface with same name already plugged";
+        return false;
+    }
+
+    debug() << "Interface" << interface->interfaceName() << "plugged";
+    mPriv->interfaces.insert(interface->interfaceName(), interface);
+    return true;
+}
+
+/**
+ * \class AbstractChannelInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for all the Channel object interface implementations.
+ */
+
+AbstractChannelInterface::AbstractChannelInterface(const QString &interfaceName)
+    : AbstractDBusServiceInterface(interfaceName)
+{
+}
+
+AbstractChannelInterface::~AbstractChannelInterface()
+{
+}
+
+// Chan.T.Text
+BaseChannelTextType::Adaptee::Adaptee(BaseChannelTextType *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelTextType::Adaptee::~Adaptee()
+{
+}
+
+void BaseChannelTextType::Adaptee::acknowledgePendingMessages(const Tp::UIntList &IDs,
+        const Tp::Service::ChannelTypeTextAdaptor::AcknowledgePendingMessagesContextPtr &context)
+{
+    qDebug() << "BaseConnectionContactsInterface::acknowledgePendingMessages " << IDs;
+    DBusError error;
+    mInterface->acknowledgePendingMessages(IDs, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+struct TP_QT_NO_EXPORT BaseChannelTextType::Private {
+    Private(BaseChannelTextType *parent, BaseChannel* channel)
+        : channel(channel),
+          pendingMessagesId(0),
+          adaptee(new BaseChannelTextType::Adaptee(parent)) {
+    }
+
+    BaseChannel* channel;
+    /* maps pending-message-id to message part list */
+    QMap<uint, Tp::MessagePartList> pendingMessages;
+    /* increasing unique id of pending messages */
+    uint pendingMessagesId;
+    MessageAcknowledgedCallback messageAcknowledgedCB;
+    BaseChannelTextType::Adaptee *adaptee;
+};
+
+/**
+ * \class BaseChannelTextType
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Type.Text
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelTextType::BaseChannelTextType(BaseChannel* channel)
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_TYPE_TEXT),
+      mPriv(new Private(this, channel))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelTextType::~BaseChannelTextType()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelTextType::immutableProperties() const
+{
+    return QVariantMap();
+}
+
+void BaseChannelTextType::createAdaptor()
+{
+    (void) new Service::ChannelTypeTextAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+void BaseChannelTextType::addReceivedMessage(const Tp::MessagePartList &msg)
+{
+    MessagePartList message = msg;
+    if (msg.empty()) {
+        warning() << "empty message: not sent";
+        return;
+    }
+    MessagePart &header = message.front();
+
+    if (header.count(QLatin1String("pending-message-id")))
+        warning() << "pending-message-id will be overwritten";
+
+    /* Add pending-message-id to header */
+    uint pendingMessageId = mPriv->pendingMessagesId++;
+    header[QLatin1String("pending-message-id")] = QDBusVariant(pendingMessageId);
+    mPriv->pendingMessages[pendingMessageId] = message;
+
+    uint timestamp = 0;
+    if (header.count(QLatin1String("message-received")))
+        timestamp = header[QLatin1String("message-received")].variant().toUInt();
+
+    uint handle = 0;
+    if (header.count(QLatin1String("message-sender")))
+        handle = header[QLatin1String("message-sender")].variant().toUInt();
+
+    uint type = ChannelTextMessageTypeNormal;
+    if (header.count(QLatin1String("message-type")))
+        type = header[QLatin1String("message-type")].variant().toUInt();
+
+    //FIXME: flags are not parsed
+    uint flags = 0;
+
+    QString content;
+    for (MessagePartList::Iterator i = message.begin() + 1; i != message.end(); ++i)
+        if (i->count(QLatin1String("content-type"))
+                && i->value(QLatin1String("content-type")).variant().toString() == QLatin1String("text/plain")
+                && i->count(QLatin1String("content"))) {
+            content = i->value(QLatin1String("content")).variant().toString();
+            break;
+        }
+    if (content.length() > 0)
+        QMetaObject::invokeMethod(mPriv->adaptee, "received",
+                                  Qt::QueuedConnection,
+                                  Q_ARG(uint, pendingMessageId),
+                                  Q_ARG(uint, timestamp),
+                                  Q_ARG(uint, handle),
+                                  Q_ARG(uint, type),
+                                  Q_ARG(uint, flags),
+                                  Q_ARG(QString, content));
+
+    /* Signal on ChannelMessagesInterface */
+    BaseChannelMessagesInterfacePtr messagesIface = BaseChannelMessagesInterfacePtr::dynamicCast(
+                mPriv->channel->interface(TP_QT_IFACE_CHANNEL_INTERFACE_MESSAGES));
+    if (messagesIface)
+        QMetaObject::invokeMethod(messagesIface.data(), "messageReceived",
+                                  Qt::QueuedConnection,
+                                  Q_ARG(Tp::MessagePartList, message));
+}
+
+Tp::MessagePartListList BaseChannelTextType::pendingMessages()
+{
+    return mPriv->pendingMessages.values();
+}
+
+/*
+ * Will be called with the value of the message-token field after a received message has been acknowledged,
+ * if the message-token field existed in the header.
+ */
+void BaseChannelTextType::setMessageAcknowledgedCallback(const MessageAcknowledgedCallback &cb)
+{
+    mPriv->messageAcknowledgedCB = cb;
+}
+
+void BaseChannelTextType::acknowledgePendingMessages(const Tp::UIntList &IDs, DBusError* error)
+{
+    foreach(uint id, IDs) {
+        QMap<uint, Tp::MessagePartList>::Iterator i = mPriv->pendingMessages.find(id);
+        if (i == mPriv->pendingMessages.end()) {
+            error->set(TP_QT_ERROR_INVALID_ARGUMENT, QLatin1String("id not found"));
+            return;
+        }
+
+        MessagePart &header = i->front();
+        if (header.count(QLatin1String("message-token")) && mPriv->messageAcknowledgedCB.isValid())
+            mPriv->messageAcknowledgedCB(header[QLatin1String("message-token")].variant().toString());
+
+        mPriv->pendingMessages.erase(i);
+    }
+
+    /* Signal on ChannelMessagesInterface */
+    BaseChannelMessagesInterfacePtr messagesIface = BaseChannelMessagesInterfacePtr::dynamicCast(
+                mPriv->channel->interface(TP_QT_IFACE_CHANNEL_INTERFACE_MESSAGES));
+    if (messagesIface) //emit after return
+        QMetaObject::invokeMethod(messagesIface.data(), "pendingMessagesRemoved",
+                                  Qt::QueuedConnection,
+                                  Q_ARG(Tp::UIntList, IDs));
+}
+
+
+
+void BaseChannelTextType::sent(uint timestamp, uint type, QString text)
+{
+    emit mPriv->adaptee->sent(timestamp, type, text);
+}
+
+
+// Chan.I.Messages
+BaseChannelMessagesInterface::Adaptee::Adaptee(BaseChannelMessagesInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelMessagesInterface::Adaptee::~Adaptee()
+{
+}
+
+void BaseChannelMessagesInterface::Adaptee::sendMessage(const Tp::MessagePartList &message, uint flags,
+        const Tp::Service::ChannelInterfaceMessagesAdaptor::SendMessageContextPtr &context)
+{
+    DBusError error;
+    QString token = mInterface->sendMessage(message, flags, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(token);
+}
+
+struct TP_QT_NO_EXPORT BaseChannelMessagesInterface::Private {
+    Private(BaseChannelMessagesInterface *parent,
+            BaseChannelTextType* textTypeInterface,
+            QStringList supportedContentTypes,
+            Tp::UIntList messageTypes,
+            uint messagePartSupportFlags,
+            uint deliveryReportingSupport)
+        : textTypeInterface(textTypeInterface),
+          supportedContentTypes(supportedContentTypes),
+          messageTypes(messageTypes),
+          messagePartSupportFlags(messagePartSupportFlags),
+          deliveryReportingSupport(deliveryReportingSupport),
+          adaptee(new BaseChannelMessagesInterface::Adaptee(parent)) {
+    }
+
+    BaseChannelTextType* textTypeInterface;
+    QStringList supportedContentTypes;
+    Tp::UIntList messageTypes;
+    uint messagePartSupportFlags;
+    uint deliveryReportingSupport;
+    SendMessageCallback sendMessageCB;
+    BaseChannelMessagesInterface::Adaptee *adaptee;
+};
+
+/**
+ * \class BaseChannelMessagesInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Interface.Messages
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelMessagesInterface::BaseChannelMessagesInterface(BaseChannelTextType *textType,
+        QStringList supportedContentTypes,
+        UIntList messageTypes,
+        uint messagePartSupportFlags,
+        uint deliveryReportingSupport)
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_INTERFACE_MESSAGES),
+      mPriv(new Private(this, textType, supportedContentTypes, messageTypes,
+                        messagePartSupportFlags, deliveryReportingSupport))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelMessagesInterface::~BaseChannelMessagesInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelMessagesInterface::immutableProperties() const
+{
+    QVariantMap map;
+
+    map.insert(TP_QT_IFACE_CHANNEL_INTERFACE_MESSAGES + QLatin1String(".SupportedContentTypes"),
+               QVariant::fromValue(mPriv->adaptee->supportedContentTypes()));
+    map.insert(TP_QT_IFACE_CHANNEL_INTERFACE_MESSAGES + QLatin1String(".MessageTypes"),
+               QVariant::fromValue(mPriv->adaptee->messageTypes()));
+    map.insert(TP_QT_IFACE_CHANNEL_INTERFACE_MESSAGES + QLatin1String(".MessagePartSupportFlags"),
+               QVariant::fromValue(mPriv->adaptee->messagePartSupportFlags()));
+    map.insert(TP_QT_IFACE_CHANNEL_INTERFACE_MESSAGES + QLatin1String(".DeliveryReportingSupport"),
+               QVariant::fromValue(mPriv->adaptee->deliveryReportingSupport()));
+    return map;
+}
+
+void BaseChannelMessagesInterface::createAdaptor()
+{
+    (void) new Service::ChannelInterfaceMessagesAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+QStringList BaseChannelMessagesInterface::supportedContentTypes()
+{
+    return mPriv->supportedContentTypes;
+}
+
+Tp::UIntList BaseChannelMessagesInterface::messageTypes()
+{
+    return mPriv->messageTypes;
+}
+
+uint BaseChannelMessagesInterface::messagePartSupportFlags()
+{
+    return mPriv->messagePartSupportFlags;
+}
+
+uint BaseChannelMessagesInterface::deliveryReportingSupport()
+{
+    return mPriv->deliveryReportingSupport;
+}
+
+Tp::MessagePartListList BaseChannelMessagesInterface::pendingMessages()
+{
+    return mPriv->textTypeInterface->pendingMessages();
+}
+
+void BaseChannelMessagesInterface::messageSent(const Tp::MessagePartList &content, uint flags, const QString &messageToken)
+{
+    emit mPriv->adaptee->messageSent(content, flags, messageToken);
+}
+
+void BaseChannelMessagesInterface::pendingMessagesRemoved(const Tp::UIntList &messageIDs)
+{
+    emit mPriv->adaptee->pendingMessagesRemoved(messageIDs);
+}
+
+void BaseChannelMessagesInterface::messageReceived(const Tp::MessagePartList &message)
+{
+    emit mPriv->adaptee->messageReceived(message);
+}
+
+void BaseChannelMessagesInterface::setSendMessageCallback(const SendMessageCallback &cb)
+{
+    mPriv->sendMessageCB = cb;
+}
+
+QString BaseChannelMessagesInterface::sendMessage(const Tp::MessagePartList &message, uint flags, DBusError* error)
+{
+    if (!mPriv->sendMessageCB.isValid()) {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return QString();
+    }
+    QString token = mPriv->sendMessageCB(message, flags, error);
+
+    //emit after return
+    QMetaObject::invokeMethod(mPriv->adaptee, "messageSent",
+                              Qt::QueuedConnection,
+                              Q_ARG(Tp::MessagePartList, message),
+                              Q_ARG(uint, flags),
+                              Q_ARG(QString, token));
+
+    if (message.empty()) {
+        warning() << "Sending empty message";
+        return token;
+    }
+    const MessagePart &header = message.front();
+
+    uint timestamp = 0;
+    if (header.count(QLatin1String("message-received")))
+        timestamp = header[QLatin1String("message-received")].variant().toUInt();
+
+    uint type = ChannelTextMessageTypeNormal;
+    if (header.count(QLatin1String("message-type")))
+        type = header[QLatin1String("message-type")].variant().toUInt();
+
+    QString content;
+    for (MessagePartList::const_iterator i = message.begin() + 1; i != message.end(); ++i)
+        if (i->count(QLatin1String("content-type"))
+                && i->value(QLatin1String("content-type")).variant().toString() == QLatin1String("text/plain")
+                && i->count(QLatin1String("content"))) {
+            content = i->value(QLatin1String("content")).variant().toString();
+            break;
+        }
+    //emit after return
+    QMetaObject::invokeMethod(mPriv->textTypeInterface, "sent",
+                              Qt::QueuedConnection,
+                              Q_ARG(uint, timestamp),
+                              Q_ARG(uint, type),
+                              Q_ARG(QString, content));
+    return token;
+}
+
+
+//Chan.T.ServerAuthentication
+BaseChannelServerAuthenticationType::Adaptee::Adaptee(BaseChannelServerAuthenticationType *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelServerAuthenticationType::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseChannelServerAuthenticationType::Private {
+    Private(BaseChannelServerAuthenticationType *parent, const QString& authenticationMethod)
+        : authenticationMethod(authenticationMethod),
+          adaptee(new BaseChannelServerAuthenticationType::Adaptee(parent)) {
+    }
+    QString authenticationMethod;
+    BaseChannelServerAuthenticationType::Adaptee *adaptee;
+};
+
+QString BaseChannelServerAuthenticationType::Adaptee::authenticationMethod() const
+{
+    return mInterface->mPriv->authenticationMethod;
+}
+
+/**
+ * \class BaseChannelServerAuthenticationType
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Type.ServerAuthentifcation
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelServerAuthenticationType::BaseChannelServerAuthenticationType(const QString& authenticationMethod)
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_TYPE_SERVER_AUTHENTICATION),
+      mPriv(new Private(this, authenticationMethod))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelServerAuthenticationType::~BaseChannelServerAuthenticationType()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelServerAuthenticationType::immutableProperties() const
+{
+    QVariantMap map;
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_SERVER_AUTHENTICATION + QLatin1String(".AuthenticationMethod"),
+               QVariant::fromValue(mPriv->adaptee->authenticationMethod()));
+    return map;
+}
+
+void BaseChannelServerAuthenticationType::createAdaptor()
+{
+    (void) new Service::ChannelTypeServerAuthenticationAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+//Chan.I.CaptchaAuthentication
+BaseChannelCaptchaAuthenticationInterface::Adaptee::Adaptee(BaseChannelCaptchaAuthenticationInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelCaptchaAuthenticationInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseChannelCaptchaAuthenticationInterface::Private {
+    Private(BaseChannelCaptchaAuthenticationInterface *parent, bool canRetryCaptcha)
+        : canRetryCaptcha(canRetryCaptcha),
+          captchaStatus(CaptchaStatusLocalPending),
+          adaptee(new BaseChannelCaptchaAuthenticationInterface::Adaptee(parent)) {
+    }
+    bool canRetryCaptcha;
+    bool captchaStatus;
+    QString captchaError;
+    QVariantMap captchaErrorDetails;
+    GetCaptchasCallback getCaptchasCB;
+    GetCaptchaDataCallback getCaptchaDataCB;
+    AnswerCaptchasCallback answerCaptchasCB;
+    CancelCaptchaCallback cancelCaptchaCB;
+    BaseChannelCaptchaAuthenticationInterface::Adaptee *adaptee;
+};
+
+bool BaseChannelCaptchaAuthenticationInterface::Adaptee::canRetryCaptcha() const
+{
+    return mInterface->mPriv->canRetryCaptcha;
+}
+
+uint BaseChannelCaptchaAuthenticationInterface::Adaptee::captchaStatus() const
+{
+    return mInterface->mPriv->captchaStatus;
+}
+
+QString BaseChannelCaptchaAuthenticationInterface::Adaptee::captchaError() const
+{
+    return mInterface->mPriv->captchaError;
+}
+
+QVariantMap BaseChannelCaptchaAuthenticationInterface::Adaptee::captchaErrorDetails() const
+{
+    return mInterface->mPriv->captchaErrorDetails;
+}
+
+void BaseChannelCaptchaAuthenticationInterface::Adaptee::getCaptchas(const Tp::Service::ChannelInterfaceCaptchaAuthenticationAdaptor::GetCaptchasContextPtr &context)
+{
+    qDebug() << "BaseChannelCaptchaAuthenticationInterface::Adaptee::getCaptchas";
+    DBusError error;
+    Tp::CaptchaInfoList captchaInfo;
+    uint numberRequired;
+    QString language;
+    mInterface->mPriv->getCaptchasCB(captchaInfo, numberRequired, language, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(captchaInfo, numberRequired, language);
+}
+
+void BaseChannelCaptchaAuthenticationInterface::Adaptee::getCaptchaData(uint ID, const QString& mimeType, const Tp::Service::ChannelInterfaceCaptchaAuthenticationAdaptor::GetCaptchaDataContextPtr &context)
+{
+    qDebug() << "BaseChannelCaptchaAuthenticationInterface::Adaptee::getCaptchaData " << ID << mimeType;
+    DBusError error;
+    QByteArray captchaData = mInterface->mPriv->getCaptchaDataCB(ID, mimeType, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(captchaData);
+}
+
+void BaseChannelCaptchaAuthenticationInterface::Adaptee::answerCaptchas(const Tp::CaptchaAnswers& answers, const Tp::Service::ChannelInterfaceCaptchaAuthenticationAdaptor::AnswerCaptchasContextPtr &context)
+{
+    qDebug() << "BaseChannelCaptchaAuthenticationInterface::Adaptee::answerCaptchas";
+    DBusError error;
+    mInterface->mPriv->answerCaptchasCB(answers, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseChannelCaptchaAuthenticationInterface::Adaptee::cancelCaptcha(uint reason, const QString& debugMessage, const Tp::Service::ChannelInterfaceCaptchaAuthenticationAdaptor::CancelCaptchaContextPtr &context)
+{
+    qDebug() << "BaseChannelCaptchaAuthenticationInterface::Adaptee::cancelCaptcha "
+             << reason << " " << debugMessage;
+    DBusError error;
+    mInterface->mPriv->cancelCaptchaCB(reason, debugMessage, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+/**
+ * \class BaseChannelCaptchaAuthenticationInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Interface.CaptchaAuthentication
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelCaptchaAuthenticationInterface::BaseChannelCaptchaAuthenticationInterface(bool canRetryCaptcha)
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_INTERFACE_CAPTCHA_AUTHENTICATION),
+      mPriv(new Private(this, canRetryCaptcha))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelCaptchaAuthenticationInterface::~BaseChannelCaptchaAuthenticationInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelCaptchaAuthenticationInterface::immutableProperties() const
+{
+    QVariantMap map;
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_SERVER_AUTHENTICATION + QLatin1String(".CanRetryCaptcha"),
+               QVariant::fromValue(mPriv->adaptee->canRetryCaptcha()));
+    return map;
+}
+
+void BaseChannelCaptchaAuthenticationInterface::createAdaptor()
+{
+    (void) new Service::ChannelInterfaceCaptchaAuthenticationAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+void BaseChannelCaptchaAuthenticationInterface::setGetCaptchasCallback(const GetCaptchasCallback &cb)
+{
+    mPriv->getCaptchasCB = cb;
+}
+
+void BaseChannelCaptchaAuthenticationInterface::setGetCaptchaDataCallback(const GetCaptchaDataCallback &cb)
+{
+    mPriv->getCaptchaDataCB = cb;
+}
+
+void BaseChannelCaptchaAuthenticationInterface::setAnswerCaptchasCallback(const AnswerCaptchasCallback &cb)
+{
+    mPriv->answerCaptchasCB = cb;
+}
+
+void BaseChannelCaptchaAuthenticationInterface::setCancelCaptchaCallback(const CancelCaptchaCallback &cb)
+{
+    mPriv->cancelCaptchaCB = cb;
+}
+
+void BaseChannelCaptchaAuthenticationInterface::setCaptchaStatus(uint status)
+{
+    mPriv->captchaStatus = status;
+}
+
+void BaseChannelCaptchaAuthenticationInterface::setCaptchaError(const QString& busName)
+{
+    mPriv->captchaError = busName;
+}
+
+void BaseChannelCaptchaAuthenticationInterface::setCaptchaErrorDetails(const QVariantMap& error)
+{
+    mPriv->captchaErrorDetails = error;
+}
+
+//Chan.I.Group
+BaseChannelGroupInterface::Adaptee::Adaptee(BaseChannelGroupInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelGroupInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseChannelGroupInterface::Private {
+    Private(BaseChannelGroupInterface *parent, ChannelGroupFlags initialFlags, uint selfHandle)
+        : flags(initialFlags),
+          selfHandle(selfHandle),
+          adaptee(new BaseChannelGroupInterface::Adaptee(parent)) {
+    }
+    ChannelGroupFlags flags;
+    Tp::HandleOwnerMap handleOwners;
+    Tp::LocalPendingInfoList localPendingMembers;
+    Tp::UIntList members;
+    Tp::UIntList remotePendingMembers;
+    uint selfHandle;
+    Tp::HandleIdentifierMap memberIdentifiers;
+    RemoveMembersCallback removeMembersCB;
+    AddMembersCallback addMembersCB;
+    Tp::UIntList getLocalPendingMembers() const {
+        Tp::UIntList ret;
+        foreach(const LocalPendingInfo & info, localPendingMembers)
+        ret << info.toBeAdded;
+        return ret;
+    }
+    BaseChannelGroupInterface::Adaptee *adaptee;
+};
+
+uint BaseChannelGroupInterface::Adaptee::groupFlags() const
+{
+    return mInterface->mPriv->flags;
+}
+
+Tp::HandleOwnerMap BaseChannelGroupInterface::Adaptee::handleOwners() const
+{
+    return mInterface->mPriv->handleOwners;
+}
+
+Tp::LocalPendingInfoList BaseChannelGroupInterface::Adaptee::localPendingMembers() const
+{
+    return mInterface->mPriv->localPendingMembers;
+}
+
+Tp::UIntList BaseChannelGroupInterface::Adaptee::members() const
+{
+    return mInterface->mPriv->members;
+}
+
+Tp::UIntList BaseChannelGroupInterface::Adaptee::remotePendingMembers() const
+{
+    return mInterface->mPriv->remotePendingMembers;
+}
+
+uint BaseChannelGroupInterface::Adaptee::selfHandle() const
+{
+    return mInterface->mPriv->selfHandle;
+}
+
+Tp::HandleIdentifierMap BaseChannelGroupInterface::Adaptee::memberIdentifiers() const
+{
+    return mInterface->mPriv->memberIdentifiers;
+}
+
+void BaseChannelGroupInterface::Adaptee::addMembers(const Tp::UIntList& contacts,
+        const QString& message,
+        const Tp::Service::ChannelInterfaceGroupAdaptor::AddMembersContextPtr &context)
+{
+    debug() << "BaseChannelGroupInterface::Adaptee::addMembers";
+    if (!mInterface->mPriv->addMembersCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    mInterface->mPriv->addMembersCB(contacts, message, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseChannelGroupInterface::Adaptee::removeMembers(const Tp::UIntList& contacts, const QString& message,
+        const Tp::Service::ChannelInterfaceGroupAdaptor::RemoveMembersContextPtr &context)
+{
+    debug() << "BaseChannelGroupInterface::Adaptee::removeMembers";
+    if (!mInterface->mPriv->removeMembersCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    mInterface->mPriv->removeMembersCB(contacts, message, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseChannelGroupInterface::Adaptee::removeMembersWithReason(const Tp::UIntList& contacts,
+        const QString& message,
+        uint reason,
+        const Tp::Service::ChannelInterfaceGroupAdaptor::RemoveMembersWithReasonContextPtr &context)
+{
+    debug() << "BaseChannelGroupInterface::Adaptee::removeMembersWithReason";
+    removeMembers(contacts, message, context);
+}
+
+void BaseChannelGroupInterface::Adaptee::getAllMembers(const Tp::Service::ChannelInterfaceGroupAdaptor::GetAllMembersContextPtr &context)
+{
+    context->setFinished(mInterface->mPriv->members, mInterface->mPriv->getLocalPendingMembers(), mInterface->mPriv->remotePendingMembers);
+}
+
+void BaseChannelGroupInterface::Adaptee::getGroupFlags(const Tp::Service::ChannelInterfaceGroupAdaptor::GetGroupFlagsContextPtr &context)
+{
+    context->setFinished(mInterface->mPriv->flags);
+}
+
+void BaseChannelGroupInterface::Adaptee::getHandleOwners(const Tp::UIntList& handles, const Tp::Service::ChannelInterfaceGroupAdaptor::GetHandleOwnersContextPtr &context)
+{
+    Tp::UIntList ret;
+    foreach(uint handle, handles)
+    ret.append(mInterface->mPriv->handleOwners.contains(handle) ? mInterface->mPriv->handleOwners[handle] : 0);
+    context->setFinished(ret);
+}
+
+void BaseChannelGroupInterface::Adaptee::getLocalPendingMembers(const Tp::Service::ChannelInterfaceGroupAdaptor::GetLocalPendingMembersContextPtr &context)
+{
+    context->setFinished(mInterface->mPriv->getLocalPendingMembers());
+}
+
+void BaseChannelGroupInterface::Adaptee::getLocalPendingMembersWithInfo(const Tp::Service::ChannelInterfaceGroupAdaptor::GetLocalPendingMembersWithInfoContextPtr &context)
+{
+    context->setFinished(mInterface->mPriv->localPendingMembers);
+}
+
+void BaseChannelGroupInterface::Adaptee::getMembers(const Tp::Service::ChannelInterfaceGroupAdaptor::GetMembersContextPtr &context)
+{
+    context->setFinished(mInterface->mPriv->members);
+}
+
+void BaseChannelGroupInterface::Adaptee::getRemotePendingMembers(const Tp::Service::ChannelInterfaceGroupAdaptor::GetRemotePendingMembersContextPtr &context)
+{
+    context->setFinished(mInterface->mPriv->remotePendingMembers);
+}
+
+void BaseChannelGroupInterface::Adaptee::getSelfHandle(const Tp::Service::ChannelInterfaceGroupAdaptor::GetSelfHandleContextPtr &context)
+{
+    context->setFinished(mInterface->mPriv->selfHandle);
+}
+
+/**
+ * \class BaseChannelGroupInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Interface.Group
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelGroupInterface::BaseChannelGroupInterface(ChannelGroupFlags initialFlags, uint selfHandle)
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_INTERFACE_GROUP),
+      mPriv(new Private(this, initialFlags, selfHandle))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelGroupInterface::~BaseChannelGroupInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelGroupInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseChannelGroupInterface::createAdaptor()
+{
+    (void) new Service::ChannelInterfaceGroupAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+void BaseChannelGroupInterface::setRemoveMembersCallback(const RemoveMembersCallback &cb)
+{
+    mPriv->removeMembersCB = cb;
+}
+
+void BaseChannelGroupInterface::setAddMembersCallback(const AddMembersCallback &cb)
+{
+    mPriv->addMembersCB = cb;
+}
+
+void BaseChannelGroupInterface::addMembers(const Tp::UIntList& handles, const QStringList& identifiers)
+{
+    if (handles.size() != identifiers.size()) {
+        debug() << "BaseChannelGroupInterface::addMembers: handles.size() != identifiers.size()";
+        return;
+    }
+    Tp::UIntList added;
+    for (int i = 0; i < handles.size(); ++i) {
+        uint handle = handles[i];
+        if (mPriv->members.contains(handle))
+            continue;
+
+        mPriv->memberIdentifiers[handle] = identifiers[i];
+        mPriv->members.append(handle);
+        added.append(handle);
+    }
+    if (!added.isEmpty())
+        emit mPriv->adaptee->membersChanged(QString(), added, Tp::UIntList(), Tp::UIntList(), Tp::UIntList(), 0, ChannelGroupChangeReasonNone);
+}
+
+void BaseChannelGroupInterface::removeMembers(const Tp::UIntList& handles)
+{
+    Tp::UIntList removed;
+    foreach(uint handle, handles) {
+        if (mPriv->members.contains(handle))
+            continue;
+
+        mPriv->memberIdentifiers.remove(handle);
+        mPriv->members.removeAll(handle);
+        removed.append(handle);
+    }
+    if (!removed.isEmpty())
+        emit mPriv->adaptee->membersChanged(QString(), Tp::UIntList(), removed, Tp::UIntList(), Tp::UIntList(), 0, ChannelGroupChangeReasonNone);
+}
+
+// Chan.T.Call
+BaseChannelCallType::Adaptee::Adaptee(BaseChannelCallType *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelCallType::Adaptee::~Adaptee()
+{
+}
+
+
+struct TP_QT_NO_EXPORT BaseChannelCallType::Private {
+    Private(BaseChannelCallType *parent, BaseChannel* channel, bool hardwareStreaming,
+            uint initialTransport,
+            bool initialAudio,
+            bool initialVideo,
+            QString initialAudioName,
+            QString initialVideoName,
+            bool mutableContents)
+        : hardwareStreaming(hardwareStreaming),
+          initialTransport(initialTransport),
+          initialAudio(initialAudio),
+          initialVideo(initialVideo),
+          initialAudioName(initialAudioName),
+          initialVideoName(initialVideoName),
+          mutableContents(mutableContents),
+          channel(channel),
+          adaptee(new BaseChannelCallType::Adaptee(parent)) {
+    }
+
+    Tp::ObjectPathList contents;
+    QVariantMap callStateDetails;
+    uint callState;
+    uint callFlags;
+    Tp::CallStateReason callStateReason;
+    bool hardwareStreaming;
+    Tp::CallMemberMap callMembers;
+    Tp::HandleIdentifierMap memberIdentifiers;
+    uint initialTransport;
+    bool initialAudio;
+    bool initialVideo;
+    QString initialAudioName;
+    QString initialVideoName;
+    bool mutableContents;
+
+    QList<Tp::BaseCallContentPtr> mCallContents;
+    AcceptCallback acceptCB;
+    HangupCallback hangupCB;
+    SetQueuedCallback setQueuedCB;
+    SetRingingCallback setRingingCB;
+    AddContentCallback addContentCB;
+
+    BaseChannel *channel;
+    BaseChannelCallType::Adaptee *adaptee;
+};
+
+void BaseChannelCallType::Adaptee::setRinging(const Tp::Service::ChannelTypeCallAdaptor::SetRingingContextPtr &context)
+{
+    if (!mInterface->mPriv->setRingingCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    mInterface->mPriv->setRingingCB(&error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseChannelCallType::Adaptee::setQueued(const Tp::Service::ChannelTypeCallAdaptor::SetQueuedContextPtr &context)
+{
+    if (!mInterface->mPriv->setQueuedCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    mInterface->mPriv->setQueuedCB(&error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseChannelCallType::Adaptee::accept(const Tp::Service::ChannelTypeCallAdaptor::AcceptContextPtr &context)
+{
+    if (!mInterface->mPriv->acceptCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    mInterface->mPriv->acceptCB(&error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseChannelCallType::Adaptee::hangup(uint reason, const QString &detailedHangupReason, const QString &message, const Tp::Service::ChannelTypeCallAdaptor::HangupContextPtr &context)
+{
+    if (!mInterface->mPriv->hangupCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    mInterface->mPriv->hangupCB(reason, detailedHangupReason, message, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseChannelCallType::Adaptee::addContent(const QString &contentName, const Tp::MediaStreamType &contentType, const Tp::MediaStreamDirection &initialDirection, const Tp::Service::ChannelTypeCallAdaptor::AddContentContextPtr &context)
+{
+    if (!mInterface->mPriv->addContentCB.isValid()) {
+        Tp::BaseCallContentPtr ptr = mInterface->addContent(contentName, contentType, initialDirection);
+        QDBusObjectPath objPath;
+        objPath.setPath(ptr->objectPath());
+        context->setFinished(objPath);
+        return;
+    }
+
+    DBusError error;
+    QDBusObjectPath objPath = mInterface->mPriv->addContentCB(contentName, contentType, initialDirection, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(objPath);
+}
+
+/**
+ * \class BaseChannelCallType
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Type.Call
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelCallType::BaseChannelCallType(BaseChannel* channel, bool hardwareStreaming,
+                                         uint initialTransport,
+                                         bool initialAudio,
+                                         bool initialVideo,
+                                         QString initialAudioName,
+                                         QString initialVideoName,
+                                         bool mutableContents)
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_TYPE_CALL),
+      mPriv(new Private(this, channel,
+                        hardwareStreaming,
+                        initialTransport,
+                        initialAudio,
+                        initialVideo,
+                        initialAudioName,
+                        initialVideoName,
+                        mutableContents))
+{
+}
+
+Tp::ObjectPathList BaseChannelCallType::contents() {
+    return mPriv->contents;
+}
+
+QVariantMap BaseChannelCallType::callStateDetails() {
+    return mPriv->callStateDetails;
+}
+
+uint BaseChannelCallType::callState() {
+    return mPriv->callState;
+}
+
+uint BaseChannelCallType::callFlags() {
+    return mPriv->callFlags;
+}
+
+Tp::CallStateReason BaseChannelCallType::callStateReason() {
+    return mPriv->callStateReason;
+}
+
+bool BaseChannelCallType::hardwareStreaming() {
+    return mPriv->hardwareStreaming;
+}
+
+Tp::CallMemberMap BaseChannelCallType::callMembers() {
+    return mPriv->callMembers;
+}
+
+Tp::HandleIdentifierMap BaseChannelCallType::memberIdentifiers() {
+    return mPriv->memberIdentifiers;
+}
+
+uint BaseChannelCallType::initialTransport() {
+    return mPriv->initialTransport;
+}
+
+bool BaseChannelCallType::initialAudio() {
+    return mPriv->initialAudio;
+}
+
+bool BaseChannelCallType::initialVideo() {
+    return mPriv->initialVideo;
+}
+
+QString BaseChannelCallType::initialVideoName() {
+    return mPriv->initialVideoName;
+}
+
+QString BaseChannelCallType::initialAudioName() {
+    return mPriv->initialAudioName;
+}
+
+bool BaseChannelCallType::mutableContents() {
+    return mPriv->mutableContents;
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelCallType::~BaseChannelCallType()
+{
+    delete mPriv;
+}
+
+QVariantMap BaseChannelCallType::immutableProperties() const
+{
+    QVariantMap map;
+
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_CALL + QLatin1String(".HardwareStreaming"),
+               QVariant::fromValue(mPriv->adaptee->hardwareStreaming()));
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_CALL + QLatin1String(".InitialTransport"),
+               QVariant::fromValue(mPriv->adaptee->initialTransport()));
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_CALL + QLatin1String(".InitialAudio"),
+               QVariant::fromValue(mPriv->adaptee->initialAudio()));
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_CALL + QLatin1String(".InitialVideo"),
+               QVariant::fromValue(mPriv->adaptee->initialVideo()));
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_CALL + QLatin1String(".InitialAudioName"),
+               QVariant::fromValue(mPriv->adaptee->initialAudioName()));
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_CALL + QLatin1String(".InitialVideoName"),
+               QVariant::fromValue(mPriv->adaptee->initialVideoName()));
+    map.insert(TP_QT_IFACE_CHANNEL_TYPE_CALL + QLatin1String(".MutableContents"),
+               QVariant::fromValue(mPriv->adaptee->mutableContents()));
+    return map;
+}
+
+void BaseChannelCallType::createAdaptor()
+{
+    (void) new Service::ChannelTypeCallAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+void BaseChannelCallType::setCallState(const Tp::CallState &state, uint flags, const Tp::CallStateReason &stateReason, const QVariantMap &callStateDetails)
+{
+    mPriv->callState = state;
+    mPriv->callFlags = flags;
+    mPriv->callStateReason = stateReason;
+    mPriv->callStateDetails = callStateDetails;
+    emit mPriv->adaptee->callStateChanged(state, flags, stateReason, callStateDetails);
+}
+
+void BaseChannelCallType::setAcceptCallback(const AcceptCallback &cb)
+{
+    mPriv->acceptCB = cb;
+}
+
+void BaseChannelCallType::setHangupCallback(const HangupCallback &cb)
+{
+    mPriv->hangupCB = cb;
+}
+
+void BaseChannelCallType::setSetRingingCallback(const SetRingingCallback &cb)
+{
+    mPriv->setRingingCB = cb;
+}
+
+void BaseChannelCallType::setSetQueuedCallback(const SetQueuedCallback &cb)
+{
+    mPriv->setQueuedCB = cb;
+}
+
+void BaseChannelCallType::setAddContentCallback(const AddContentCallback &cb)
+{
+    mPriv->addContentCB = cb;
+}
+
+void BaseChannelCallType::setMembersFlags(const Tp::CallMemberMap &flagsChanged, const Tp::HandleIdentifierMap &identifiers, const Tp::UIntList &removed, const Tp::CallStateReason &reason)
+{
+    mPriv->callMembers = flagsChanged;
+    mPriv->memberIdentifiers = identifiers;
+    emit mPriv->adaptee->callMembersChanged(flagsChanged, identifiers, removed, reason);
+}
+
+BaseCallContentPtr BaseChannelCallType::addContent(const QString &name, const Tp::MediaStreamType &type, const Tp::MediaStreamDirection &direction)
+{
+    BaseCallContentPtr ptr = BaseCallContent::create(mPriv->channel->dbusConnection(), mPriv->channel, name, type, direction);
+    DBusError error;
+    ptr->registerObject(&error);
+    QDBusObjectPath objpath;
+    objpath.setPath(ptr->objectPath());
+    mPriv->contents.append(objpath);
+    emit mPriv->adaptee->contentAdded(objpath);
+
+    return ptr;
+}
+
+void BaseChannelCallType::addContent(BaseCallContentPtr content)
+{
+    DBusError error;
+    content->registerObject(&error);
+    QDBusObjectPath objpath;
+    objpath.setPath(content->objectPath());
+    mPriv->contents.append(objpath);
+    emit mPriv->adaptee->contentAdded(objpath);
+}
+
+// Chan.I.Hold
+BaseChannelHoldInterface::Adaptee::Adaptee(BaseChannelHoldInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelHoldInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseChannelHoldInterface::Private {
+    Private(BaseChannelHoldInterface *parent, Tp::LocalHoldState state)
+        : state(state),
+          reason(Tp::LocalHoldStateReasonNone),
+          adaptee(new BaseChannelHoldInterface::Adaptee(parent)) {
+    }
+
+    SetHoldStateCallback setHoldStateCB;
+    Tp::LocalHoldState state;
+    Tp::LocalHoldStateReason reason;
+    BaseChannelHoldInterface::Adaptee *adaptee;
+};
+
+void BaseChannelHoldInterface::Adaptee::getHoldState(const Tp::Service::ChannelInterfaceHoldAdaptor::GetHoldStateContextPtr &context)
+{
+    context->setFinished(mInterface->getHoldState(), mInterface->getHoldReason());
+}
+
+void BaseChannelHoldInterface::Adaptee::requestHold(bool hold, const Tp::Service::ChannelInterfaceHoldAdaptor::RequestHoldContextPtr &context)
+{
+    if (!mInterface->mPriv->setHoldStateCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+
+    Tp::LocalHoldState state = hold ? Tp::LocalHoldStateHeld : Tp::LocalHoldStateUnheld;
+
+    DBusError error;
+    mInterface->mPriv->setHoldStateCB(state, Tp::LocalHoldStateReasonRequested, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+/**
+ * \class BaseChannelHoldInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Interface.Hold
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelHoldInterface::BaseChannelHoldInterface()
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_INTERFACE_HOLD),
+      mPriv(new Private(this, Tp::LocalHoldStateUnheld))
+{
+}
+
+Tp::LocalHoldState BaseChannelHoldInterface::getHoldState() const
+{
+    return mPriv->state;
+}
+
+Tp::LocalHoldStateReason BaseChannelHoldInterface::getHoldReason() const
+{
+    return mPriv->reason;
+}
+
+void BaseChannelHoldInterface::setSetHoldStateCallback(const SetHoldStateCallback &cb)
+{
+    mPriv->setHoldStateCB = cb;
+}
+
+void BaseChannelHoldInterface::setHoldState(const Tp::LocalHoldState &state, const Tp::LocalHoldStateReason &reason)
+{
+    if (mPriv->state != state) {
+        mPriv->state = state;
+        mPriv->reason = reason;
+        emit mPriv->adaptee->holdStateChanged(state, reason);
+    }
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelHoldInterface::~BaseChannelHoldInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelHoldInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseChannelHoldInterface::createAdaptor()
+{
+    (void) new Service::ChannelInterfaceHoldAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+}
+

=== added file '.pc/06-conference_interfaces.patch/TelepathyQt/base-channel.h'
--- .pc/06-conference_interfaces.patch/TelepathyQt/base-channel.h	1970-01-01 00:00:00 +0000
+++ .pc/06-conference_interfaces.patch/TelepathyQt/base-channel.h	2014-02-05 14:09:56 +0000
@@ -0,0 +1,479 @@
+/**
+ * This file is part of TelepathyQt
+ *
+ * @copyright Copyright (C) 2013 Matthias Gehre <[e-mail]>
+ * @copyright Copyright 2013 Canonical Ltd.
+ * @license LGPL 2.1
+ *
+ * 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 _TelepathyQt_base_channel_h_HEADER_GUARD_
+#define _TelepathyQt_base_channel_h_HEADER_GUARD_
+
+#ifndef IN_TP_QT_HEADER
+#error IN_TP_QT_HEADER
+#endif
+
+#include <TelepathyQt/DBusService>
+#include <TelepathyQt/Global>
+#include <TelepathyQt/Types>
+#include <TelepathyQt/Callbacks>
+#include <TelepathyQt/Constants>
+
+#include <QDBusConnection>
+
+class QString;
+
+namespace Tp
+{
+
+class TP_QT_EXPORT BaseChannel : public DBusService
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannel)
+
+public:
+    static BaseChannelPtr create(BaseConnection* connection, const QString &channelType,
+                                 uint targetHandle, uint targetHandleType) {
+        return BaseChannelPtr(new BaseChannel(QDBusConnection::sessionBus(), connection,
+                                              channelType, targetHandle, targetHandleType));
+    }
+
+    virtual ~BaseChannel();
+
+    QVariantMap immutableProperties() const;
+    bool registerObject(DBusError *error = NULL);
+    virtual QString uniqueName() const;
+
+    QString channelType() const;
+    QList<AbstractChannelInterfacePtr> interfaces() const;
+    AbstractChannelInterfacePtr interface(const QString &interfaceName) const;
+    uint targetHandle() const;
+    QString targetID() const;
+    uint targetHandleType() const;
+    bool requested() const;
+    uint initiatorHandle() const;
+    QString initiatorID() const;
+    Tp::ChannelDetails details() const;
+
+    void setInitiatorHandle(uint initiatorHandle);
+    void setInitiatorID(const QString &initiatorID);
+    void setTargetID(const QString &targetID);
+    void setRequested(bool requested);
+
+    bool plugInterface(const AbstractChannelInterfacePtr &interface);
+    BaseConnection * baseConnection() const;
+    void close();
+
+Q_SIGNALS:
+    void closed();
+protected:
+    BaseChannel(const QDBusConnection &dbusConnection, BaseConnection* connection,
+                const QString &channelType, uint targetHandle, uint targetHandleType);
+    virtual bool registerObject(const QString &busName, const QString &objectPath,
+                                DBusError *error);
+private:
+    class Adaptee;
+    friend class Adaptee;
+    class Private;
+    friend class Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT AbstractChannelInterface : public AbstractDBusServiceInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(AbstractChannelInterface)
+
+public:
+    AbstractChannelInterface(const QString &interfaceName);
+    virtual ~AbstractChannelInterface();
+
+private:
+    friend class BaseChannel;
+
+    class Private;
+    friend class Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelTextType : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelTextType)
+
+public:
+    static BaseChannelTextTypePtr create(BaseChannel* channel) {
+        return BaseChannelTextTypePtr(new BaseChannelTextType(channel));
+    }
+    template<typename BaseChannelTextTypeSubclass>
+    static SharedPtr<BaseChannelTextTypeSubclass> create(BaseChannel* channel) {
+        return SharedPtr<BaseChannelTextTypeSubclass>(
+                   new BaseChannelTextTypeSubclass(channel));
+    }
+
+    typedef Callback2<QDBusObjectPath, const QVariantMap&, DBusError*> CreateChannelCallback;
+    CreateChannelCallback createChannel;
+
+    typedef Callback2<bool, const QVariantMap&, DBusError*> EnsureChannelCallback;
+    EnsureChannelCallback ensureChannel;
+
+    virtual ~BaseChannelTextType();
+
+    QVariantMap immutableProperties() const;
+
+    Tp::RequestableChannelClassList requestableChannelClasses;
+
+    typedef Callback1<void, QString> MessageAcknowledgedCallback;
+    void setMessageAcknowledgedCallback(const MessageAcknowledgedCallback &cb);
+
+    Tp::MessagePartListList pendingMessages();
+
+    /* Convenience function */
+    void addReceivedMessage(const Tp::MessagePartList &message);
+private Q_SLOTS:
+    void sent(uint timestamp, uint type, QString text);
+protected:
+    BaseChannelTextType(BaseChannel* channel);
+    void acknowledgePendingMessages(const Tp::UIntList &IDs, DBusError* error);
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelMessagesInterface : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelMessagesInterface)
+
+public:
+    static BaseChannelMessagesInterfacePtr create(BaseChannelTextType* textTypeInterface,
+            QStringList supportedContentTypes,
+            UIntList messageTypes,
+            uint messagePartSupportFlags,
+            uint deliveryReportingSupport) {
+        return BaseChannelMessagesInterfacePtr(new BaseChannelMessagesInterface(textTypeInterface,
+                                               supportedContentTypes,
+                                               messageTypes,
+                                               messagePartSupportFlags,
+                                               deliveryReportingSupport));
+    }
+    template<typename BaseChannelMessagesInterfaceSubclass>
+    static SharedPtr<BaseChannelMessagesInterfaceSubclass> create() {
+        return SharedPtr<BaseChannelMessagesInterfaceSubclass>(
+                   new BaseChannelMessagesInterfaceSubclass());
+    }
+    virtual ~BaseChannelMessagesInterface();
+
+    QVariantMap immutableProperties() const;
+
+    QStringList supportedContentTypes();
+    Tp::UIntList messageTypes();
+    uint messagePartSupportFlags();
+    uint deliveryReportingSupport();
+    Tp::MessagePartListList pendingMessages();
+
+    void messageSent(const Tp::MessagePartList &content, uint flags, const QString &messageToken);
+
+    typedef Callback3<QString, const Tp::MessagePartList&, uint, DBusError*> SendMessageCallback;
+    void setSendMessageCallback(const SendMessageCallback &cb);
+protected:
+    QString sendMessage(const Tp::MessagePartList &message, uint flags, DBusError* error);
+private Q_SLOTS:
+    void pendingMessagesRemoved(const Tp::UIntList &messageIDs);
+    void messageReceived(const Tp::MessagePartList &message);
+private:
+    BaseChannelMessagesInterface(BaseChannelTextType* textType,
+                                 QStringList supportedContentTypes,
+                                 Tp::UIntList messageTypes,
+                                 uint messagePartSupportFlags,
+                                 uint deliveryReportingSupport);
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelServerAuthenticationType : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelServerAuthenticationType)
+
+public:
+    static BaseChannelServerAuthenticationTypePtr create(const QString &authenticationMethod) {
+        return BaseChannelServerAuthenticationTypePtr(new BaseChannelServerAuthenticationType(authenticationMethod));
+    }
+    template<typename BaseChannelServerAuthenticationTypeSubclass>
+    static SharedPtr<BaseChannelServerAuthenticationTypeSubclass> create(const QString &authenticationMethod) {
+        return SharedPtr<BaseChannelServerAuthenticationTypeSubclass>(
+                   new BaseChannelServerAuthenticationTypeSubclass(authenticationMethod));
+    }
+    virtual ~BaseChannelServerAuthenticationType();
+
+    QVariantMap immutableProperties() const;
+private Q_SLOTS:
+private:
+    BaseChannelServerAuthenticationType(const QString &authenticationMethod);
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelCaptchaAuthenticationInterface : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelCaptchaAuthenticationInterface)
+
+public:
+    static BaseChannelCaptchaAuthenticationInterfacePtr create(bool canRetryCaptcha) {
+        return BaseChannelCaptchaAuthenticationInterfacePtr(new BaseChannelCaptchaAuthenticationInterface(canRetryCaptcha));
+    }
+    template<typename BaseChannelCaptchaAuthenticationInterfaceSubclass>
+    static SharedPtr<BaseChannelCaptchaAuthenticationInterfaceSubclass> create(bool canRetryCaptcha) {
+        return SharedPtr<BaseChannelCaptchaAuthenticationInterfaceSubclass>(
+                   new BaseChannelCaptchaAuthenticationInterfaceSubclass(canRetryCaptcha));
+    }
+    virtual ~BaseChannelCaptchaAuthenticationInterface();
+
+    QVariantMap immutableProperties() const;
+
+    typedef Callback4<void, Tp::CaptchaInfoList&, uint&, QString&, DBusError*> GetCaptchasCallback;
+    void setGetCaptchasCallback(const GetCaptchasCallback &cb);
+
+    typedef Callback3<QByteArray, uint, const QString&, DBusError*> GetCaptchaDataCallback;
+    void setGetCaptchaDataCallback(const GetCaptchaDataCallback &cb);
+
+    typedef Callback2<void, const Tp::CaptchaAnswers&, DBusError*> AnswerCaptchasCallback;
+    void setAnswerCaptchasCallback(const AnswerCaptchasCallback &cb);
+
+    typedef Callback3<void, uint, const QString&, DBusError*> CancelCaptchaCallback;
+    void setCancelCaptchaCallback(const CancelCaptchaCallback &cb);
+
+    void setCaptchaStatus(uint status);
+    void setCaptchaError(const QString &busName);
+    void setCaptchaErrorDetails(const QVariantMap &error);
+private Q_SLOTS:
+private:
+    BaseChannelCaptchaAuthenticationInterface(bool canRetryCaptcha);
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelGroupInterface : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelGroupInterface)
+
+public:
+    static BaseChannelGroupInterfacePtr create(ChannelGroupFlags initialFlags, uint selfHandle) {
+        return BaseChannelGroupInterfacePtr(new BaseChannelGroupInterface(initialFlags, selfHandle));
+    }
+    template<typename BaseChannelGroupInterfaceSubclass>
+    static SharedPtr<BaseChannelGroupInterfaceSubclass> create(ChannelGroupFlags initialFlags, uint selfHandle) {
+        return SharedPtr<BaseChannelGroupInterfaceSubclass>(
+                   new BaseChannelGroupInterfaceSubclass(initialFlags, selfHandle));
+    }
+    virtual ~BaseChannelGroupInterface();
+
+    QVariantMap immutableProperties() const;
+
+    typedef Callback3<void, const Tp::UIntList&, const QString&, DBusError*> RemoveMembersCallback;
+    void setRemoveMembersCallback(const RemoveMembersCallback &cb);
+
+    typedef Callback3<void, const Tp::UIntList&, const QString&, DBusError*> AddMembersCallback;
+    void setAddMembersCallback(const AddMembersCallback &cb);
+
+    /* Adds a contact to this group. No-op if already in this group */
+    void addMembers(const Tp::UIntList &handles, const QStringList &identifiers);
+    void removeMembers(const Tp::UIntList &handles);
+
+private Q_SLOTS:
+private:
+    BaseChannelGroupInterface(ChannelGroupFlags initialFlags, uint selfHandle);
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelCallType : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelCallType)
+
+public:
+    static BaseChannelCallTypePtr create(BaseChannel* channel, bool hardwareStreaming,
+                                         uint initialTransport,
+                                         bool initialAudio,
+                                         bool initialVideo,
+                                         QString initialAudioName,
+                                         QString initialVideoName,
+                                         bool mutableContents = false) {
+        return BaseChannelCallTypePtr(new BaseChannelCallType(channel,
+                                                              hardwareStreaming,
+                                                              initialTransport,
+                                                              initialAudio,
+                                                              initialVideo,
+                                                              initialAudioName,
+                                                              initialVideoName,
+                                                              mutableContents));
+    }
+    template<typename BaseChannelCallTypeSubclass>
+    static SharedPtr<BaseChannelCallTypeSubclass> create(BaseChannel* channel, bool hardwareStreaming,
+                                                         uint initialTransport,
+                                                         bool initialAudio,
+                                                         bool initialVideo,
+                                                         QString initialAudioName,
+                                                         QString initialVideoName,
+                                                         bool mutableContents = false) {
+        return SharedPtr<BaseChannelCallTypeSubclass>(
+                   new BaseChannelCallTypeSubclass(channel,
+                                                   hardwareStreaming,
+                                                   initialTransport,
+                                                   initialAudio,
+                                                   initialVideo,
+                                                   initialAudioName,
+                                                   initialVideoName,
+                                                   mutableContents));
+    }
+
+    typedef Callback2<QDBusObjectPath, const QVariantMap&, DBusError*> CreateChannelCallback;
+    CreateChannelCallback createChannel;
+
+    typedef Callback2<bool, const QVariantMap&, DBusError*> EnsureChannelCallback;
+    EnsureChannelCallback ensureChannel;
+
+    virtual ~BaseChannelCallType();
+
+    QVariantMap immutableProperties() const;
+
+    Tp::ObjectPathList contents();
+    QVariantMap callStateDetails();
+    uint callState();
+    uint callFlags();
+    Tp::CallStateReason callStateReason();
+    bool hardwareStreaming();
+    Tp::CallMemberMap callMembers();
+    Tp::HandleIdentifierMap memberIdentifiers();
+    uint initialTransport();
+    bool initialAudio();
+    bool initialVideo();
+    QString initialAudioName();
+    QString initialVideoName();
+    bool mutableContents();
+
+    typedef Callback1<void, DBusError*> AcceptCallback;
+    void setAcceptCallback(const AcceptCallback &cb);
+
+    typedef Callback4<void, uint, const QString &, const QString &, DBusError*> HangupCallback;
+    void setHangupCallback(const HangupCallback &cb);
+
+    typedef Callback1<void, DBusError*> SetRingingCallback;
+    void setSetRingingCallback(const SetRingingCallback &cb);
+
+    typedef Callback1<void, DBusError*> SetQueuedCallback;
+    void setSetQueuedCallback(const SetQueuedCallback &cb);
+
+    typedef Callback4<QDBusObjectPath, const QString&, const Tp::MediaStreamType&, const Tp::MediaStreamDirection&, DBusError*> AddContentCallback;
+    void setAddContentCallback(const AddContentCallback &cb);
+
+    void setCallState(const Tp::CallState &state, uint flags, const Tp::CallStateReason &stateReason, const QVariantMap &callStateDetails);
+    void setMembersFlags(const Tp::CallMemberMap &flagsChanged, const Tp::HandleIdentifierMap &identifiers, const Tp::UIntList &removed, const Tp::CallStateReason &reason);
+    BaseCallContentPtr addContent(const QString &name, const Tp::MediaStreamType &type, const Tp::MediaStreamDirection &direction);
+    void addContent(BaseCallContentPtr content);
+
+    Tp::RequestableChannelClassList requestableChannelClasses;
+
+protected:
+    BaseChannelCallType(BaseChannel* channel,
+                        bool hardwareStreaming,
+                        uint initialTransport,
+                        bool initialAudio,
+                        bool initialVideo,
+                        QString initialAudioName,
+                        QString initialVideoName,
+                        bool mutableContents = false);
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelHoldInterface : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelHoldInterface)
+
+public:
+    static BaseChannelHoldInterfacePtr create() {
+        return BaseChannelHoldInterfacePtr(new BaseChannelHoldInterface());
+    }
+    template<typename BaseChannelHoldInterfaceSubclass>
+    static SharedPtr<BaseChannelHoldInterfaceSubclass> create() {
+        return SharedPtr<BaseChannelHoldInterfaceSubclass>(
+                   new BaseChannelHoldInterfaceSubclass());
+    }
+    virtual ~BaseChannelHoldInterface();
+
+    QVariantMap immutableProperties() const;
+
+    Tp::LocalHoldState getHoldState() const;
+    Tp::LocalHoldStateReason getHoldReason() const;
+    void setHoldState(const Tp::LocalHoldState &state, const Tp::LocalHoldStateReason &reason);
+
+    typedef Callback3<void, const Tp::LocalHoldState&, const Tp::LocalHoldStateReason &, DBusError*> SetHoldStateCallback;
+    void setSetHoldStateCallback(const SetHoldStateCallback &cb);
+Q_SIGNALS:
+    void holdStateChanged(const Tp::LocalHoldState &state, const Tp::LocalHoldStateReason &reason);
+private:
+    BaseChannelHoldInterface();
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+}
+#endif

=== added file '.pc/06-conference_interfaces.patch/TelepathyQt/service-types.h'
--- .pc/06-conference_interfaces.patch/TelepathyQt/service-types.h	1970-01-01 00:00:00 +0000
+++ .pc/06-conference_interfaces.patch/TelepathyQt/service-types.h	2014-02-05 14:09:56 +0000
@@ -0,0 +1,97 @@
+/**
+ * This file is part of TelepathyQt
+ *
+ * @copyright Copyright (C) 2012 Collabora Ltd. <http://www.collabora.co.uk/>
+ * @copyright Copyright (C) 2012 Nokia Corporation
+ * @license LGPL 2.1
+ *
+ * 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 _TelepathyQt_service_types_h_HEADER_GUARD_
+#define _TelepathyQt_service_types_h_HEADER_GUARD_
+
+#ifndef IN_TP_QT_HEADER
+#error IN_TP_QT_HEADER
+#endif
+
+#include <TelepathyQt/Types>
+
+namespace Tp
+{
+
+class AbstractProtocolInterface;
+class AbstractConnectionInterface;
+class AbstractChannelInterface;
+class AbstractCallContentInterface;
+class BaseConnection;
+class BaseConnectionRequestsInterface;
+class BaseConnectionContactsInterface;
+class BaseConnectionSimplePresenceInterface;
+class BaseConnectionContactListInterface;
+class BaseConnectionAddressingInterface;
+class BaseConnectionManager;
+class BaseProtocol;
+class BaseProtocolAddressingInterface;
+class BaseProtocolAvatarsInterface;
+class BaseProtocolPresenceInterface;
+class BaseChannel;
+class BaseChannelTextType;
+class BaseChannelCallType;
+class BaseCallContent;
+class BaseCallMuteInterface;
+class BaseCallContentDTMFInterface;
+class BaseChannelMessagesInterface;
+class BaseChannelServerAuthenticationType;
+class BaseChannelCaptchaAuthenticationInterface;
+class BaseChannelGroupInterface;
+class BaseChannelHoldInterface;
+class DBusService;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+typedef SharedPtr<AbstractProtocolInterface> AbstractProtocolInterfacePtr;
+typedef SharedPtr<AbstractConnectionInterface> AbstractConnectionInterfacePtr;
+typedef SharedPtr<AbstractChannelInterface> AbstractChannelInterfacePtr;
+typedef SharedPtr<AbstractCallContentInterface> AbstractCallContentInterfacePtr;
+typedef SharedPtr<BaseConnection> BaseConnectionPtr;
+typedef SharedPtr<BaseConnectionRequestsInterface> BaseConnectionRequestsInterfacePtr;
+typedef SharedPtr<BaseConnectionContactsInterface> BaseConnectionContactsInterfacePtr;
+typedef SharedPtr<BaseConnectionSimplePresenceInterface> BaseConnectionSimplePresenceInterfacePtr;
+typedef SharedPtr<BaseConnectionContactListInterface> BaseConnectionContactListInterfacePtr;
+typedef SharedPtr<BaseConnectionAddressingInterface> BaseConnectionAddressingInterfacePtr;
+typedef SharedPtr<BaseConnectionManager> BaseConnectionManagerPtr;
+typedef SharedPtr<BaseProtocol> BaseProtocolPtr;
+typedef SharedPtr<BaseProtocolAddressingInterface> BaseProtocolAddressingInterfacePtr;
+typedef SharedPtr<BaseProtocolAvatarsInterface> BaseProtocolAvatarsInterfacePtr;
+typedef SharedPtr<BaseProtocolPresenceInterface> BaseProtocolPresenceInterfacePtr;
+typedef SharedPtr<BaseChannel> BaseChannelPtr;
+typedef SharedPtr<BaseChannelTextType> BaseChannelTextTypePtr;
+typedef SharedPtr<BaseChannelCallType> BaseChannelCallTypePtr;
+typedef SharedPtr<BaseCallContent> BaseCallContentPtr;
+typedef SharedPtr<BaseCallContentDTMFInterface> BaseCallContentDTMFInterfacePtr;
+typedef SharedPtr<BaseCallMuteInterface> BaseCallMuteInterfacePtr;
+typedef SharedPtr<BaseChannelMessagesInterface> BaseChannelMessagesInterfacePtr;
+typedef SharedPtr<BaseChannelServerAuthenticationType> BaseChannelServerAuthenticationTypePtr;
+typedef SharedPtr<BaseChannelCaptchaAuthenticationInterface> BaseChannelCaptchaAuthenticationInterfacePtr;
+typedef SharedPtr<BaseChannelGroupInterface> BaseChannelGroupInterfacePtr;
+typedef SharedPtr<BaseChannelHoldInterface> BaseChannelHoldInterfacePtr;
+typedef SharedPtr<DBusService> DBusServicePtr;
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // Tp
+
+#endif

=== added file '.pc/06-conference_interfaces.patch/TelepathyQt/svc-channel.xml'
--- .pc/06-conference_interfaces.patch/TelepathyQt/svc-channel.xml	1970-01-01 00:00:00 +0000
+++ .pc/06-conference_interfaces.patch/TelepathyQt/svc-channel.xml	2014-02-05 14:09:56 +0000
@@ -0,0 +1,38 @@
+<tp:spec
+  xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0"
+  xmlns:xi="http://www.w3.org/2001/XInclude">
+
+<tp:title>Channel interfaces</tp:title>
+
+<xi:include href="../spec/Channel.xml"/>
+
+<xi:include href="../spec/Channel_Type_Call.xml"/>
+<xi:include href="../spec/Channel_Type_Contact_Search.xml"/>
+<xi:include href="../spec/Channel_Type_DBus_Tube.xml"/>
+<xi:include href="../spec/Channel_Type_File_Transfer.xml"/>
+<xi:include href="../spec/Channel_Type_Room_List.xml"/>
+<xi:include href="../spec/Channel_Type_Server_Authentication.xml"/>
+<xi:include href="../spec/Channel_Type_Server_TLS_Connection.xml"/>
+<xi:include href="../spec/Channel_Type_Streamed_Media.xml"/>
+<xi:include href="../spec/Channel_Type_Stream_Tube.xml"/>
+<xi:include href="../spec/Channel_Type_Text.xml"/>
+
+<xi:include href="../spec/Channel_Interface_Anonymity.xml"/>
+<xi:include href="../spec/Channel_Interface_Captcha_Authentication.xml"/>
+<xi:include href="../spec/Channel_Interface_Call_State.xml"/>
+<xi:include href="../spec/Channel_Interface_Chat_State.xml"/>
+<xi:include href="../spec/Channel_Interface_Conference.xml"/>
+<xi:include href="../spec/Channel_Interface_Destroyable.xml"/>
+<xi:include href="../spec/Channel_Interface_DTMF.xml"/>
+<xi:include href="../spec/Channel_Interface_File_Transfer_Metadata.xml"/>
+<xi:include href="../spec/Channel_Interface_Group.xml"/>
+<xi:include href="../spec/Channel_Interface_Hold.xml"/>
+<xi:include href="../spec/Channel_Interface_Media_Signalling.xml"/>
+<xi:include href="../spec/Channel_Interface_Messages.xml"/>
+<xi:include href="../spec/Channel_Interface_Password.xml"/>
+<xi:include href="../spec/Channel_Interface_SASL_Authentication.xml"/>
+<xi:include href="../spec/Channel_Interface_Securable.xml"/>
+<xi:include href="../spec/Channel_Interface_Service_Point.xml"/>
+<xi:include href="../spec/Channel_Interface_SMS.xml"/>
+
+</tp:spec>

=== added directory '.pc/07-fix_createChannel.patch'
=== added file '.pc/07-fix_createChannel.patch/.timestamp'
=== added directory '.pc/07-fix_createChannel.patch/TelepathyQt'
=== added file '.pc/07-fix_createChannel.patch/TelepathyQt/base-connection.cpp'
--- .pc/07-fix_createChannel.patch/TelepathyQt/base-connection.cpp	1970-01-01 00:00:00 +0000
+++ .pc/07-fix_createChannel.patch/TelepathyQt/base-connection.cpp	2014-02-05 14:09:56 +0000
@@ -0,0 +1,1356 @@
+/**
+ * This file is part of TelepathyQt
+ *
+ * @copyright Copyright (C) 2012 Collabora Ltd. <http://www.collabora.co.uk/>
+ * @copyright Copyright (C) 2012 Nokia Corporation
+ * @license LGPL 2.1
+ *
+ * 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 <TelepathyQt/BaseConnection>
+#include "TelepathyQt/base-connection-internal.h"
+
+#include "TelepathyQt/_gen/base-connection.moc.hpp"
+#include "TelepathyQt/_gen/base-connection-internal.moc.hpp"
+
+#include "TelepathyQt/debug-internal.h"
+
+#include <TelepathyQt/BaseChannel>
+#include <TelepathyQt/Constants>
+#include <TelepathyQt/DBusObject>
+#include <TelepathyQt/Utils>
+#include <TelepathyQt/AbstractProtocolInterface>
+#include <QString>
+#include <QVariantMap>
+
+namespace Tp
+{
+
+struct TP_QT_NO_EXPORT BaseConnection::Private {
+    Private(BaseConnection *parent, const QDBusConnection &dbusConnection,
+            const QString &cmName, const QString &protocolName,
+            const QVariantMap &parameters)
+        : parent(parent),
+          cmName(cmName),
+          protocolName(protocolName),
+          parameters(parameters),
+          status(Tp::ConnectionStatusDisconnected),
+          selfHandle(0),
+          adaptee(new BaseConnection::Adaptee(dbusConnection, parent)) {
+    }
+
+    BaseConnection *parent;
+    QString cmName;
+    QString protocolName;
+    QVariantMap parameters;
+    uint status;
+    QHash<QString, AbstractConnectionInterfacePtr> interfaces;
+    QSet<BaseChannelPtr> channels;
+    CreateChannelCallback createChannelCB;
+    RequestHandlesCallback requestHandlesCB;
+    ConnectCallback connectCB;
+    InspectHandlesCallback inspectHandlesCB;
+    uint selfHandle;
+    BaseConnection::Adaptee *adaptee;
+};
+
+BaseConnection::Adaptee::Adaptee(const QDBusConnection &dbusConnection,
+                                 BaseConnection *connection)
+    : QObject(connection),
+      mConnection(connection)
+{
+    mAdaptor = new Service::ConnectionAdaptor(dbusConnection, this, connection->dbusObject());
+}
+
+BaseConnection::Adaptee::~Adaptee()
+{
+}
+
+void BaseConnection::Adaptee::disconnect(const Tp::Service::ConnectionAdaptor::DisconnectContextPtr &context)
+{
+    debug() << "BaseConnection::Adaptee::disconnect";
+    /* This will remove the connection from the connection manager
+     * and destroy this object. */
+    emit mConnection->disconnected();
+    context->setFinished();
+}
+
+void BaseConnection::Adaptee::getSelfHandle(const Tp::Service::ConnectionAdaptor::GetSelfHandleContextPtr &context)
+{
+    context->setFinished(mConnection->mPriv->selfHandle);
+}
+
+uint BaseConnection::Adaptee::selfHandle() const
+{
+    return mConnection->mPriv->selfHandle;
+}
+
+void BaseConnection::Adaptee::getStatus(const Tp::Service::ConnectionAdaptor::GetStatusContextPtr &context)
+{
+    context->setFinished(mConnection->status());
+}
+
+void BaseConnection::Adaptee::connect(const Tp::Service::ConnectionAdaptor::ConnectContextPtr &context)
+{
+    if (!mConnection->mPriv->connectCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    mConnection->mPriv->connectCB(&error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+void BaseConnection::Adaptee::inspectHandles(uint handleType,
+                                             const Tp::UIntList &handles,
+                                             const Tp::Service::ConnectionAdaptor::InspectHandlesContextPtr &context)
+{
+    if (!mConnection->mPriv->inspectHandlesCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    QStringList ret = mConnection->mPriv->inspectHandlesCB(handleType, handles, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(ret);
+}
+QStringList BaseConnection::Adaptee::interfaces() const
+{
+    QStringList ret;
+    foreach(const AbstractConnectionInterfacePtr & iface, mConnection->interfaces()) {
+        ret << iface->interfaceName();
+    }
+    return ret;
+}
+
+void BaseConnection::Adaptee::requestChannel(const QString &type, uint handleType, uint handle, bool suppressHandler,
+        const Tp::Service::ConnectionAdaptor::RequestChannelContextPtr &context)
+{
+    debug() << "BaseConnection::Adaptee::requestChannel (deprecated)";
+    DBusError error;
+    bool yours;
+    BaseChannelPtr channel = mConnection->ensureChannel(type,
+                             handleType,
+                             handle,
+                             yours,
+                             selfHandle(),
+                             suppressHandler,
+                             &error);
+    if (error.isValid() || !channel) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(QDBusObjectPath(channel->objectPath()));
+}
+
+void BaseConnection::Adaptee::requestHandles(uint handleType, const QStringList &identifiers,
+        const Tp::Service::ConnectionAdaptor::RequestHandlesContextPtr &context)
+{
+    DBusError error;
+    Tp::UIntList handles = mConnection->requestHandles(handleType, identifiers, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(handles);
+}
+
+/**
+ * \class BaseConnection
+ * \ingroup serviceconn
+ * \headerfile TelepathyQt/base-connection.h <TelepathyQt/BaseConnection>
+ *
+ * \brief Base class for Connection implementations.
+ */
+
+/**
+ * Construct a BaseConnection.
+ *
+ * \param dbusConnection The D-Bus connection that will be used by this object.
+ * \param cmName The name of the connection manager associated with this connection.
+ * \param protocolName The name of the protocol associated with this connection.
+ * \param parameters The parameters of this connection.
+ */
+BaseConnection::BaseConnection(const QDBusConnection &dbusConnection,
+                               const QString &cmName, const QString &protocolName,
+                               const QVariantMap &parameters)
+    : DBusService(dbusConnection),
+      mPriv(new Private(this, dbusConnection, cmName, protocolName, parameters))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseConnection::~BaseConnection()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the name of the connection manager associated with this connection.
+ *
+ * \return The name of the connection manager associated with this connection.
+ */
+QString BaseConnection::cmName() const
+{
+    return mPriv->cmName;
+}
+
+/**
+ * Return the name of the protocol associated with this connection.
+ *
+ * \return The name of the protocol associated with this connection.
+ */
+QString BaseConnection::protocolName() const
+{
+    return mPriv->protocolName;
+}
+
+/**
+ * Return the parameters of this connection.
+ *
+ * \return The parameters of this connection.
+ */
+QVariantMap BaseConnection::parameters() const
+{
+    return mPriv->parameters;
+}
+
+/**
+ * Return the immutable properties of this connection object.
+ *
+ * Immutable properties cannot change after the object has been registered
+ * on the bus with registerObject().
+ *
+ * \return The immutable properties of this connection object.
+ */
+QVariantMap BaseConnection::immutableProperties() const
+{
+    // FIXME
+    return QVariantMap();
+}
+
+/**
+ * Return a unique name for this connection.
+ *
+ * \return A unique name for this connection.
+ */
+QString BaseConnection::uniqueName() const
+{
+    return QString(QLatin1String("_%1")).arg((quintptr) this, 0, 16);
+}
+
+uint BaseConnection::status() const
+{
+    debug() << "BaseConnection::status = " << mPriv->status << " " << this;
+    return mPriv->status;
+}
+
+void BaseConnection::setStatus(uint newStatus, uint reason)
+{
+    debug() << "BaseConnection::setStatus " << newStatus << " " << reason << " " << this;
+    bool changed = (newStatus != mPriv->status);
+    mPriv->status = newStatus;
+    if (changed)
+        emit mPriv->adaptee->statusChanged(newStatus, reason);
+}
+
+void BaseConnection::setCreateChannelCallback(const CreateChannelCallback &cb)
+{
+    mPriv->createChannelCB = cb;
+}
+
+Tp::BaseChannelPtr BaseConnection::createChannel(const QString &channelType,
+        uint targetHandleType,
+        uint targetHandle,
+        uint initiatorHandle,
+        bool suppressHandler,
+        DBusError *error)
+{
+    if (!mPriv->createChannelCB.isValid()) {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return BaseChannelPtr();
+    }
+    if (!mPriv->inspectHandlesCB.isValid()) {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return BaseChannelPtr();
+    }
+
+    BaseChannelPtr channel = mPriv->createChannelCB(channelType, targetHandleType, targetHandle, error);
+    if (error->isValid())
+        return BaseChannelPtr();
+
+    QString targetID;
+    if (targetHandle != 0) {
+        QStringList list = mPriv->inspectHandlesCB(targetHandleType,  UIntList() << targetHandle, error);
+        if (error->isValid()) {
+            debug() << "BaseConnection::createChannel: could not resolve handle " << targetHandle;
+            return BaseChannelPtr();
+        } else {
+            debug() << "BaseConnection::createChannel: found targetID " << *list.begin();
+            targetID = *list.begin();
+        }
+    }
+    QString initiatorID;
+    if (initiatorHandle != 0) {
+        QStringList list = mPriv->inspectHandlesCB(HandleTypeContact, UIntList() << initiatorHandle, error);
+        if (error->isValid()) {
+            debug() << "BaseConnection::createChannel: could not resolve handle " << initiatorHandle;
+            return BaseChannelPtr();
+        } else {
+            debug() << "BaseConnection::createChannel: found initiatorID " << *list.begin();
+            initiatorID = *list.begin();
+        }
+    }
+    channel->setInitiatorHandle(initiatorHandle);
+    channel->setInitiatorID(initiatorID);
+    channel->setTargetID(targetID);
+    channel->setRequested(initiatorHandle == mPriv->selfHandle);
+
+    channel->registerObject(error);
+    if (error->isValid())
+        return BaseChannelPtr();
+
+    mPriv->channels.insert(channel);
+
+    BaseConnectionRequestsInterfacePtr reqIface =
+        BaseConnectionRequestsInterfacePtr::dynamicCast(interface(TP_QT_IFACE_CONNECTION_INTERFACE_REQUESTS));
+
+    if (!reqIface.isNull())
+        //emit after return
+        QMetaObject::invokeMethod(reqIface.data(), "newChannels",
+                                  Qt::QueuedConnection,
+                                  Q_ARG(Tp::ChannelDetailsList, ChannelDetailsList() << channel->details()));
+
+
+    //emit after return
+    QMetaObject::invokeMethod(mPriv->adaptee, "newChannel",
+                              Qt::QueuedConnection,
+                              Q_ARG(QDBusObjectPath, QDBusObjectPath(channel->objectPath())),
+                              Q_ARG(QString, channel->channelType()),
+                              Q_ARG(uint, channel->targetHandleType()),
+                              Q_ARG(uint, channel->targetHandle()),
+                              Q_ARG(bool, suppressHandler));
+
+    QObject::connect(channel.data(),
+                     SIGNAL(closed()),
+                     SLOT(removeChannel()));
+
+    return channel;
+}
+
+void BaseConnection::setRequestHandlesCallback(const RequestHandlesCallback &cb)
+{
+    mPriv->requestHandlesCB = cb;
+}
+
+UIntList BaseConnection::requestHandles(uint handleType, const QStringList &identifiers, DBusError* error)
+{
+    if (!mPriv->requestHandlesCB.isValid()) {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return UIntList();
+    }
+    return mPriv->requestHandlesCB(handleType, identifiers, error);
+}
+
+Tp::ChannelInfoList BaseConnection::channelsInfo()
+{
+    qDebug() << "BaseConnection::channelsInfo:";
+    Tp::ChannelInfoList list;
+    foreach(const BaseChannelPtr & c, mPriv->channels) {
+        Tp::ChannelInfo info;
+        info.channel = QDBusObjectPath(c->objectPath());
+        info.channelType = c->channelType();
+        info.handle = c->targetHandle();
+        info.handleType = c->targetHandleType();
+        qDebug() << "BaseConnection::channelsInfo " << info.channel.path();
+        list << info;
+    }
+    return list;
+}
+
+Tp::ChannelDetailsList BaseConnection::channelsDetails()
+{
+    Tp::ChannelDetailsList list;
+    foreach(const BaseChannelPtr & c, mPriv->channels)
+    list << c->details();
+    return list;
+}
+
+BaseChannelPtr BaseConnection::ensureChannel(const QString &channelType, uint targetHandleType,
+        uint targetHandle, bool &yours, uint initiatorHandle,
+        bool suppressHandler,
+        DBusError* error)
+{
+    foreach(BaseChannelPtr channel, mPriv->channels) {
+        if (channel->channelType() == channelType
+                && channel->targetHandleType() == targetHandleType
+                && channel->targetHandle() == targetHandle) {
+            yours = false;
+            return channel;
+        }
+    }
+    yours = true;
+    return createChannel(channelType, targetHandleType, targetHandle, initiatorHandle, suppressHandler, error);
+}
+
+void BaseConnection::removeChannel()
+{
+    BaseChannelPtr channel = BaseChannelPtr(
+                                 qobject_cast<BaseChannel*>(sender()));
+    Q_ASSERT(channel);
+    Q_ASSERT(mPriv->channels.contains(channel));
+    mPriv->channels.remove(channel);
+}
+
+/**
+ * Return a list of interfaces that have been plugged into this Protocol
+ * D-Bus object with plugInterface().
+ *
+ * This property is immutable and cannot change after this Protocol
+ * object has been registered on the bus with registerObject().
+ *
+ * \return A list containing all the Protocol interface implementation objects.
+ * \sa plugInterface(), interface()
+ */
+QList<AbstractConnectionInterfacePtr> BaseConnection::interfaces() const
+{
+    return mPriv->interfaces.values();
+}
+
+/**
+ * Return a pointer to the interface with the given name.
+ *
+ * \param interfaceName The D-Bus name of the interface,
+ * ex. TP_QT_IFACE_CONNECTION_INTERFACE_ADDRESSING.
+ * \return A pointer to the AbstractConnectionInterface object that implements
+ * the D-Bus interface with the given name, or a null pointer if such an interface
+ * has not been plugged into this object.
+ * \sa plugInterface(), interfaces()
+ */
+AbstractConnectionInterfacePtr BaseConnection::interface(const QString &interfaceName) const
+{
+    return mPriv->interfaces.value(interfaceName);
+}
+
+/**
+ * Plug a new interface into this Connection D-Bus object.
+ *
+ * This property is immutable and cannot change after this Protocol
+ * object has been registered on the bus with registerObject().
+ *
+ * \param interface An AbstractConnectionInterface instance that implements
+ * the interface that is to be plugged.
+ * \return \c true on success or \c false otherwise
+ * \sa interfaces(), interface()
+ */
+bool BaseConnection::plugInterface(const AbstractConnectionInterfacePtr &interface)
+{
+    if (isRegistered()) {
+        warning() << "Unable to plug protocol interface " << interface->interfaceName() <<
+                  "- protocol already registered";
+        return false;
+    }
+
+    if (interface->isRegistered()) {
+        warning() << "Unable to plug protocol interface" << interface->interfaceName() <<
+                  "- interface already registered";
+        return false;
+    }
+
+    if (mPriv->interfaces.contains(interface->interfaceName())) {
+        warning() << "Unable to plug protocol interface" << interface->interfaceName() <<
+                  "- another interface with same name already plugged";
+        return false;
+    }
+
+    debug() << "Interface" << interface->interfaceName() << "plugged";
+    mPriv->interfaces.insert(interface->interfaceName(), interface);
+    return true;
+}
+
+/**
+ * Register this connection object on the bus.
+ *
+ * If \a error is passed, any D-Bus error that may occur will
+ * be stored there.
+ *
+ * \param error A pointer to an empty DBusError where any
+ * possible D-Bus error will be stored.
+ * \return \c true on success and \c false if there was an error
+ * or this connection object is already registered.
+ * \sa isRegistered()
+ */
+bool BaseConnection::registerObject(DBusError *error)
+{
+    if (isRegistered()) {
+        return true;
+    }
+
+    if (!checkValidProtocolName(mPriv->protocolName)) {
+        if (error) {
+            error->set(TP_QT_ERROR_INVALID_ARGUMENT,
+                       mPriv->protocolName + QLatin1String("is not a valid protocol name"));
+        }
+        debug() << "Unable to register connection - invalid protocol name";
+        return false;
+    }
+
+    QString escapedProtocolName = mPriv->protocolName;
+    escapedProtocolName.replace(QLatin1Char('-'), QLatin1Char('_'));
+    QString name = uniqueName();
+    debug() << "cmName: " << mPriv->cmName << " escapedProtocolName: " << escapedProtocolName << " name:" << name;
+    QString busName = QString(QLatin1String("%1%2.%3.%4"))
+                      .arg(TP_QT_CONNECTION_BUS_NAME_BASE, mPriv->cmName, escapedProtocolName, name);
+    QString objectPath = QString(QLatin1String("%1%2/%3/%4"))
+                         .arg(TP_QT_CONNECTION_OBJECT_PATH_BASE, mPriv->cmName, escapedProtocolName, name);
+    debug() << "busName: " << busName << " objectName: " << objectPath;
+    DBusError _error;
+
+    debug() << "Connection: registering interfaces  at " << dbusObject();
+    foreach(const AbstractConnectionInterfacePtr & iface, mPriv->interfaces) {
+        if (!iface->registerInterface(dbusObject())) {
+            // lets not fail if an optional interface fails registering, lets warn only
+            warning() << "Unable to register interface" << iface->interfaceName();
+        }
+    }
+
+    bool ret = registerObject(busName, objectPath, &_error);
+    if (!ret && error) {
+        error->set(_error.name(), _error.message());
+    }
+    return ret;
+}
+
+/**
+ * Reimplemented from DBusService.
+ */
+bool BaseConnection::registerObject(const QString &busName,
+                                    const QString &objectPath, DBusError *error)
+{
+    return DBusService::registerObject(busName, objectPath, error);
+}
+
+void BaseConnection::setSelfHandle(uint selfHandle)
+{
+    mPriv->selfHandle = selfHandle;
+}
+
+uint BaseConnection::selfHandle() const
+{
+    return mPriv->selfHandle;
+}
+
+void BaseConnection::setConnectCallback(const ConnectCallback &cb)
+{
+    mPriv->connectCB = cb;
+}
+
+void BaseConnection::setInspectHandlesCallback(const InspectHandlesCallback &cb)
+{
+    mPriv->inspectHandlesCB = cb;
+}
+
+/**
+ * \fn void BaseConnection::disconnected()
+ *
+ * Emitted when this connection has been disconnected.
+ */
+
+/**
+ * \class AbstractConnectionInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-connection.h <TelepathyQt/BaseConnection>
+ *
+ * \brief Base class for all the Connection object interface implementations.
+ */
+
+AbstractConnectionInterface::AbstractConnectionInterface(const QString &interfaceName)
+    : AbstractDBusServiceInterface(interfaceName)
+{
+}
+
+AbstractConnectionInterface::~AbstractConnectionInterface()
+{
+}
+
+// Conn.I.Requests
+BaseConnectionRequestsInterface::Adaptee::Adaptee(BaseConnectionRequestsInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseConnectionRequestsInterface::Adaptee::~Adaptee()
+{
+}
+
+void BaseConnectionRequestsInterface::Adaptee::ensureChannel(const QVariantMap &request,
+        const Tp::Service::ConnectionInterfaceRequestsAdaptor::EnsureChannelContextPtr &context)
+{
+    DBusError error;
+    bool yours;
+    QDBusObjectPath channel;
+    QVariantMap details;
+
+    mInterface->ensureChannel(request, yours, channel, details, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(yours, channel, details);
+}
+
+void BaseConnectionRequestsInterface::Adaptee::createChannel(const QVariantMap &request,
+        const Tp::Service::ConnectionInterfaceRequestsAdaptor::CreateChannelContextPtr &context)
+{
+    DBusError error;
+    QDBusObjectPath channel;
+    QVariantMap details;
+
+    mInterface->createChannel(request, channel, details, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(channel, details);
+}
+
+struct TP_QT_NO_EXPORT BaseConnectionRequestsInterface::Private {
+    Private(BaseConnectionRequestsInterface *parent, BaseConnection *connection_)
+        : connection(connection_), adaptee(new BaseConnectionRequestsInterface::Adaptee(parent)) {
+    }
+    BaseConnection *connection;
+    BaseConnectionRequestsInterface::Adaptee *adaptee;
+};
+
+/**
+ * \class BaseConnectionRequestsInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-connection.h <TelepathyQt/BaseConnection>
+ *
+ * \brief Base class for implementations of Connection.Interface.Requests
+ */
+
+/**
+ * Class constructor.
+ */
+BaseConnectionRequestsInterface::BaseConnectionRequestsInterface(BaseConnection *connection)
+    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_INTERFACE_REQUESTS),
+      mPriv(new Private(this, connection))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseConnectionRequestsInterface::~BaseConnectionRequestsInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseConnectionRequestsInterface::immutableProperties() const
+{
+    QVariantMap map;
+    map.insert(TP_QT_IFACE_CONNECTION_INTERFACE_REQUESTS + QLatin1String(".RequestableChannelClasses"),
+               QVariant::fromValue(mPriv->adaptee->requestableChannelClasses()));
+    return map;
+}
+
+void BaseConnectionRequestsInterface::createAdaptor()
+{
+    (void) new Service::ConnectionInterfaceRequestsAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+Tp::ChannelDetailsList BaseConnectionRequestsInterface::Adaptee::channels() const
+{
+    return mInterface->mPriv->connection->channelsDetails();
+}
+
+void BaseConnectionRequestsInterface::newChannels(const Tp::ChannelDetailsList &channels)
+{
+    mPriv->adaptee->newChannels(channels);
+}
+
+void BaseConnectionRequestsInterface::ensureChannel(const QVariantMap &request, bool &yours,
+        QDBusObjectPath &objectPath, QVariantMap &details, DBusError *error)
+{
+    if (!request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"))
+            || !request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType"))
+            || (!request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle"))
+                && !request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetID")))) {
+        error->set(TP_QT_ERROR_INVALID_ARGUMENT, QLatin1String("Missing parameters"));
+        return;
+    }
+
+    QString channelType = request[TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType")].toString();
+    uint targetHandleType = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType")].toUInt();
+    uint targetHandle;
+    if (request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle")))
+        targetHandle = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle")].toUInt();
+    else {
+        QString targetID = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetID")].toString();
+        Tp::UIntList list = mPriv->connection->requestHandles(targetHandleType, QStringList() << targetID, error);
+        if (error->isValid()) {
+            warning() << "BBaseConnectionRequestsInterface::ensureChannel: could not resolve ID " << targetID;
+            return;
+        }
+        targetHandle = *list.begin();
+    }
+
+    bool suppressHandler = true;
+    BaseChannelPtr channel = mPriv->connection->ensureChannel(channelType, targetHandleType,
+                             targetHandle, yours,
+                             mPriv->connection->selfHandle(),
+                             suppressHandler,
+                             error);
+    if (error->isValid())
+        return;
+
+    objectPath = QDBusObjectPath(channel->objectPath());
+    details = channel->details().properties;
+}
+
+void BaseConnectionRequestsInterface::createChannel(const QVariantMap &request,
+        QDBusObjectPath &objectPath,
+        QVariantMap &details, DBusError *error)
+{
+    if (!request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"))
+            || !request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"))
+            || !request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"))) {
+        error->set(TP_QT_ERROR_INVALID_ARGUMENT, QLatin1String("Missing parameters"));
+        return;
+    }
+
+    QString channelType = request[TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType")].toString();
+    uint targetHandleType = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType")].toUInt();
+    uint targetHandle;
+    if (request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle")))
+        targetHandle = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle")].toUInt();
+    else {
+        QString targetID = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetID")].toString();
+        Tp::UIntList list = mPriv->connection->requestHandles(targetHandleType, QStringList() << targetID, error);
+        if (error->isValid()) {
+            warning() << "BBaseConnectionRequestsInterface::ensureChannel: could not resolve ID " << targetID;
+            return;
+        }
+        targetHandle = *list.begin();
+    }
+
+    bool suppressHandler = true;
+    BaseChannelPtr channel = mPriv->connection->createChannel(channelType, targetHandleType,
+                             targetHandle,
+                             mPriv->connection->selfHandle(),
+                             suppressHandler,
+                             error);
+    if (error->isValid())
+        return;
+
+    objectPath = QDBusObjectPath(channel->objectPath());
+    details = channel->details().properties;
+}
+
+
+// Conn.I.Contacts
+BaseConnectionContactsInterface::Adaptee::Adaptee(BaseConnectionContactsInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseConnectionContactsInterface::Adaptee::~Adaptee()
+{
+}
+
+void BaseConnectionContactsInterface::Adaptee::getContactAttributes(const Tp::UIntList &handles,
+        const QStringList &interfaces, bool /*hold*/,
+        const Tp::Service::ConnectionInterfaceContactsAdaptor::GetContactAttributesContextPtr &context)
+{
+    DBusError error;
+    ContactAttributesMap contactAttributes = mInterface->getContactAttributes(handles, interfaces, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(contactAttributes);
+}
+
+struct TP_QT_NO_EXPORT BaseConnectionContactsInterface::Private {
+    Private(BaseConnectionContactsInterface *parent)
+        : adaptee(new BaseConnectionContactsInterface::Adaptee(parent)) {
+    }
+    QStringList contactAttributeInterfaces;
+    GetContactAttributesCallback getContactAttributesCallback;
+    BaseConnectionContactsInterface::Adaptee *adaptee;
+};
+
+QStringList BaseConnectionContactsInterface::Adaptee::contactAttributeInterfaces() const
+{
+    return mInterface->mPriv->contactAttributeInterfaces;
+}
+
+/**
+ * \class BaseConnectionContactsInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-connection.h <TelepathyQt/BaseConnection>
+ *
+ * \brief Base class for implementations of Connection.Interface.Contacts
+ */
+
+/**
+ * Class constructor.
+ */
+BaseConnectionContactsInterface::BaseConnectionContactsInterface()
+    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_INTERFACE_CONTACTS),
+      mPriv(new Private(this))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseConnectionContactsInterface::~BaseConnectionContactsInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this<interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseConnectionContactsInterface::immutableProperties() const
+{
+    QVariantMap map;
+    map.insert(TP_QT_IFACE_CONNECTION_INTERFACE_CONTACTS + QLatin1String(".ContactAttributeInterfaces"),
+               QVariant::fromValue(mPriv->adaptee->contactAttributeInterfaces()));
+    return map;
+}
+
+void BaseConnectionContactsInterface::createAdaptor()
+{
+    (void) new Service::ConnectionInterfaceContactsAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+void BaseConnectionContactsInterface::setContactAttributeInterfaces(const QStringList &contactAttributeInterfaces)
+{
+    mPriv->contactAttributeInterfaces = contactAttributeInterfaces;
+}
+
+void BaseConnectionContactsInterface::setGetContactAttributesCallback(const GetContactAttributesCallback &cb)
+{
+    mPriv->getContactAttributesCallback = cb;
+}
+
+ContactAttributesMap BaseConnectionContactsInterface::getContactAttributes(const Tp::UIntList &handles,
+        const QStringList &interfaces,
+        DBusError *error)
+{
+    if (!mPriv->getContactAttributesCallback.isValid()) {
+        error->set(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return ContactAttributesMap();
+    }
+    return mPriv->getContactAttributesCallback(handles, interfaces, error);
+}
+
+// Conn.I.SimplePresence
+BaseConnectionSimplePresenceInterface::Adaptee::Adaptee(BaseConnectionSimplePresenceInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseConnectionSimplePresenceInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseConnectionSimplePresenceInterface::Private {
+    Private(BaseConnectionSimplePresenceInterface *parent)
+        : maxmimumStatusMessageLength(0),
+          adaptee(new BaseConnectionSimplePresenceInterface::Adaptee(parent)) {
+    }
+    SetPresenceCallback setPresenceCB;
+    SimpleStatusSpecMap statuses;
+    uint maxmimumStatusMessageLength;
+    /* The current presences */
+    SimpleContactPresences presences;
+    BaseConnectionSimplePresenceInterface::Adaptee *adaptee;
+};
+
+/**
+ * \class BaseConnectionSimplePresenceInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-connection.h <TelepathyQt/BaseConnection>
+ *
+ * \brief Base class for implementations of Connection.Interface.SimplePresence
+ */
+
+/**
+ * Class constructor.
+ */
+BaseConnectionSimplePresenceInterface::BaseConnectionSimplePresenceInterface()
+    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE),
+      mPriv(new Private(this))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseConnectionSimplePresenceInterface::~BaseConnectionSimplePresenceInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this<interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseConnectionSimplePresenceInterface::immutableProperties() const
+{
+    QVariantMap map;
+    //FIXME
+    return map;
+}
+
+void BaseConnectionSimplePresenceInterface::createAdaptor()
+{
+    (void) new Service::ConnectionInterfaceSimplePresenceAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+
+
+void BaseConnectionSimplePresenceInterface::setPresences(const Tp::SimpleContactPresences &presences)
+{
+    foreach(uint handle, presences.keys()) {
+        mPriv->presences[handle] = presences[handle];
+    }
+    emit mPriv->adaptee->presencesChanged(presences);
+}
+
+void BaseConnectionSimplePresenceInterface::setSetPresenceCallback(const SetPresenceCallback &cb)
+{
+    mPriv->setPresenceCB = cb;
+}
+
+void BaseConnectionSimplePresenceInterface::setStatuses(const SimpleStatusSpecMap &statuses)
+{
+    mPriv->statuses = statuses;
+}
+
+void BaseConnectionSimplePresenceInterface::setMaxmimumStatusMessageLength(uint maxmimumStatusMessageLength)
+{
+    mPriv->maxmimumStatusMessageLength = maxmimumStatusMessageLength;
+}
+
+
+Tp::SimpleStatusSpecMap BaseConnectionSimplePresenceInterface::Adaptee::statuses() const
+{
+    return mInterface->mPriv->statuses;
+}
+
+int BaseConnectionSimplePresenceInterface::Adaptee::maximumStatusMessageLength() const
+{
+    return mInterface->mPriv->maxmimumStatusMessageLength;
+}
+
+void BaseConnectionSimplePresenceInterface::Adaptee::setPresence(const QString &status, const QString &statusMessage_,
+        const Tp::Service::ConnectionInterfaceSimplePresenceAdaptor::SetPresenceContextPtr &context)
+{
+    if (!mInterface->mPriv->setPresenceCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+
+    SimpleStatusSpecMap::Iterator i = mInterface->mPriv->statuses.find(status);
+    if (i == mInterface->mPriv->statuses.end()) {
+        warning() << "BaseConnectionSimplePresenceInterface::Adaptee::setPresence: status is not in statuses";
+        context->setFinishedWithError(TP_QT_ERROR_INVALID_ARGUMENT, QLatin1String("status not in statuses"));
+        return;
+    }
+
+    QString statusMessage = statusMessage_;
+    if ((uint)statusMessage.length() > mInterface->mPriv->maxmimumStatusMessageLength) {
+        debug() << "BaseConnectionSimplePresenceInterface::Adaptee::setPresence: "
+                << "truncating status to " << mInterface->mPriv->maxmimumStatusMessageLength;
+        statusMessage = statusMessage.left(mInterface->mPriv->maxmimumStatusMessageLength);
+    }
+
+    DBusError error;
+    uint selfHandle = mInterface->mPriv->setPresenceCB(status, statusMessage, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    Tp::SimplePresence presence;
+    presence.type = i->type;
+    presence.status = status;
+    presence.statusMessage = statusMessage;
+    mInterface->mPriv->presences[selfHandle] = presence;
+
+    /* Emit PresencesChanged */
+    SimpleContactPresences presences;
+    presences[selfHandle] = presence;
+    //emit after return
+    QMetaObject::invokeMethod(mInterface->mPriv->adaptee, "presencesChanged",
+                              Qt::QueuedConnection,
+                              Q_ARG(Tp::SimpleContactPresences, presences));
+    context->setFinished();
+}
+
+void BaseConnectionSimplePresenceInterface::Adaptee::getPresences(const Tp::UIntList &contacts,
+        const Tp::Service::ConnectionInterfaceSimplePresenceAdaptor::GetPresencesContextPtr &context)
+{
+    Tp::SimpleContactPresences presences;
+    foreach(uint handle, contacts) {
+        SimpleContactPresences::iterator i = mInterface->mPriv->presences.find(handle);
+        if (i == mInterface->mPriv->presences.end()) {
+            Tp::SimplePresence presence;
+            presence.type = ConnectionPresenceTypeUnknown;
+            presence.status = QLatin1String("unknown");
+            presences[handle] = presence;
+        } else
+            presences[handle] = *i;
+    }
+    context->setFinished(presences);
+}
+
+// Conn.I.ContactList
+BaseConnectionContactListInterface::Adaptee::Adaptee(BaseConnectionContactListInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseConnectionContactListInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseConnectionContactListInterface::Private {
+    Private(BaseConnectionContactListInterface *parent)
+        : contactListState(ContactListStateNone),
+          contactListPersists(false),
+          canChangeContactList(true),
+          requestUsesMessage(false),
+          downloadAtConnection(false),
+          adaptee(new BaseConnectionContactListInterface::Adaptee(parent)) {
+    }
+    uint contactListState;
+    bool contactListPersists;
+    bool canChangeContactList;
+    bool requestUsesMessage;
+    bool downloadAtConnection;
+    GetContactListAttributesCallback getContactListAttributesCB;
+    RequestSubscriptionCallback requestSubscriptionCB;
+    BaseConnectionContactListInterface::Adaptee *adaptee;
+};
+
+/**
+ * \class BaseConnectionContactListInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-connection.h <TelepathyQt/BaseConnection>
+ *
+ * \brief Base class for implementations of Connection.Interface.ContactList
+ */
+
+/**
+ * Class constructor.
+ */
+BaseConnectionContactListInterface::BaseConnectionContactListInterface()
+    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_INTERFACE_CONTACT_LIST),
+      mPriv(new Private(this))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseConnectionContactListInterface::~BaseConnectionContactListInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this<interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseConnectionContactListInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseConnectionContactListInterface::createAdaptor()
+{
+    (void) new Service::ConnectionInterfaceContactListAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+void BaseConnectionContactListInterface::setContactListState(uint contactListState)
+{
+    bool changed = (contactListState != mPriv->contactListState);
+    mPriv->contactListState = contactListState;
+    if (changed)
+        //emit after return
+        QMetaObject::invokeMethod(mPriv->adaptee, "contactListStateChanged",
+                                  Qt::QueuedConnection,
+                                  Q_ARG(uint, contactListState));
+
+}
+
+void BaseConnectionContactListInterface::setContactListPersists(bool contactListPersists)
+{
+    mPriv->contactListPersists = contactListPersists;
+}
+
+void BaseConnectionContactListInterface::setCanChangeContactList(bool canChangeContactList)
+{
+    mPriv->canChangeContactList = canChangeContactList;
+}
+
+void BaseConnectionContactListInterface::setRequestUsesMessage(bool requestUsesMessage)
+{
+    mPriv->requestUsesMessage = requestUsesMessage;
+}
+
+void BaseConnectionContactListInterface::setDownloadAtConnection(bool downloadAtConnection)
+{
+    mPriv->downloadAtConnection = downloadAtConnection;
+}
+
+void BaseConnectionContactListInterface::setGetContactListAttributesCallback(const GetContactListAttributesCallback &cb)
+{
+    mPriv->getContactListAttributesCB = cb;
+}
+
+void BaseConnectionContactListInterface::setRequestSubscriptionCallback(const RequestSubscriptionCallback &cb)
+{
+    mPriv->requestSubscriptionCB = cb;
+}
+
+void BaseConnectionContactListInterface::contactsChangedWithID(const Tp::ContactSubscriptionMap &changes, const Tp::HandleIdentifierMap &identifiers, const Tp::HandleIdentifierMap &removals)
+{
+    emit mPriv->adaptee->contactsChangedWithID(changes, identifiers, removals);
+}
+
+uint BaseConnectionContactListInterface::Adaptee::contactListState() const
+{
+    return mInterface->mPriv->contactListState;
+}
+
+bool BaseConnectionContactListInterface::Adaptee::contactListPersists() const
+{
+    return mInterface->mPriv->contactListPersists;
+}
+
+bool BaseConnectionContactListInterface::Adaptee::canChangeContactList() const
+{
+    return mInterface->mPriv->canChangeContactList;
+}
+
+bool BaseConnectionContactListInterface::Adaptee::requestUsesMessage() const
+{
+    return mInterface->mPriv->requestUsesMessage;
+}
+
+bool BaseConnectionContactListInterface::Adaptee::downloadAtConnection() const
+{
+    return mInterface->mPriv->downloadAtConnection;
+}
+
+void BaseConnectionContactListInterface::Adaptee::getContactListAttributes(const QStringList &interfaces,
+        bool hold, const Tp::Service::ConnectionInterfaceContactListAdaptor::GetContactListAttributesContextPtr &context)
+{
+    if (!mInterface->mPriv->getContactListAttributesCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    Tp::ContactAttributesMap contactAttributesMap = mInterface->mPriv->getContactListAttributesCB(interfaces, hold, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(contactAttributesMap);
+}
+
+void BaseConnectionContactListInterface::Adaptee::requestSubscription(const Tp::UIntList &contacts,
+        const QString &message, const Tp::Service::ConnectionInterfaceContactListAdaptor::RequestSubscriptionContextPtr &context)
+{
+    if (!mInterface->mPriv->requestSubscriptionCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    DBusError error;
+    mInterface->mPriv->requestSubscriptionCB(contacts, message, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+// Conn.I.Addressing
+BaseConnectionAddressingInterface::Adaptee::Adaptee(BaseConnectionAddressingInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseConnectionAddressingInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseConnectionAddressingInterface::Private {
+    Private(BaseConnectionAddressingInterface *parent)
+        : adaptee(new BaseConnectionAddressingInterface::Adaptee(parent)) {
+    }
+    GetContactsByVCardFieldCallback getContactsByVCardFieldCB;
+    GetContactsByURICallback getContactsByURICB;
+    BaseConnectionAddressingInterface::Adaptee *adaptee;
+};
+
+/**
+ * \class BaseProtocolPresenceInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-protocol.h <TelepathyQt/BaseProtocolPresenceInterface>
+ *
+ * \brief Base class for implementations of Protocol.Interface.Presence
+ */
+
+/**
+ * Class constructor.
+ */
+BaseConnectionAddressingInterface::BaseConnectionAddressingInterface()
+    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_INTERFACE_ADDRESSING),
+      mPriv(new Private(this))
+{
+}
+
+/**
+ * Class destructor.
+ */
+BaseConnectionAddressingInterface::~BaseConnectionAddressingInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this<interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseConnectionAddressingInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseConnectionAddressingInterface::createAdaptor()
+{
+    (void) new Service::ConnectionInterfaceAddressingAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+void BaseConnectionAddressingInterface::setGetContactsByVCardFieldCallback(const GetContactsByVCardFieldCallback &cb)
+{
+    mPriv->getContactsByVCardFieldCB = cb;
+}
+
+void BaseConnectionAddressingInterface::setGetContactsByURICallback(const GetContactsByURICallback &cb)
+{
+    mPriv->getContactsByURICB = cb;
+}
+
+void BaseConnectionAddressingInterface::Adaptee::getContactsByVCardField(const QString &field,
+        const QStringList &addresses,
+        const QStringList &interfaces,
+        const Tp::Service::ConnectionInterfaceAddressingAdaptor::GetContactsByVCardFieldContextPtr &context)
+{
+    if (!mInterface->mPriv->getContactsByVCardFieldCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    Tp::AddressingNormalizationMap addressingNormalizationMap;
+    Tp::ContactAttributesMap contactAttributesMap;
+
+    DBusError error;
+    mInterface->mPriv->getContactsByVCardFieldCB(field, addresses, interfaces,
+            addressingNormalizationMap, contactAttributesMap,
+            &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(addressingNormalizationMap, contactAttributesMap);
+}
+
+void BaseConnectionAddressingInterface::Adaptee::getContactsByURI(const QStringList &URIs,
+        const QStringList &interfaces,
+        const Tp::Service::ConnectionInterfaceAddressingAdaptor::GetContactsByURIContextPtr &context)
+{
+    if (!mInterface->mPriv->getContactsByURICB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+    Tp::AddressingNormalizationMap addressingNormalizationMap;
+    Tp::ContactAttributesMap contactAttributesMap;
+
+    DBusError error;
+    mInterface->mPriv->getContactsByURICB(URIs, interfaces,
+                                          addressingNormalizationMap, contactAttributesMap,
+                                          &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished(addressingNormalizationMap, contactAttributesMap);
+}
+
+}

=== added file '.pc/07-fix_createChannel.patch/TelepathyQt/base-connection.h'
--- .pc/07-fix_createChannel.patch/TelepathyQt/base-connection.h	1970-01-01 00:00:00 +0000
+++ .pc/07-fix_createChannel.patch/TelepathyQt/base-connection.h	2014-02-05 14:09:56 +0000
@@ -0,0 +1,364 @@
+/**
+ * This file is part of TelepathyQt
+ *
+ * @copyright Copyright (C) 2012 Collabora Ltd. <http://www.collabora.co.uk/>
+ * @copyright Copyright (C) 2012 Nokia Corporation
+ * @license LGPL 2.1
+ *
+ * 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 _TelepathyQt_base_connection_h_HEADER_GUARD_
+#define _TelepathyQt_base_connection_h_HEADER_GUARD_
+
+#ifndef IN_TP_QT_HEADER
+#error IN_TP_QT_HEADER
+#endif
+
+#include <TelepathyQt/DBusService>
+#include <TelepathyQt/Global>
+#include <TelepathyQt/Types>
+#include <TelepathyQt/Callbacks>
+
+#include <QDBusConnection>
+
+class QString;
+
+namespace Tp
+{
+
+class TP_QT_EXPORT BaseConnection : public DBusService
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseConnection)
+
+public:
+    static BaseConnectionPtr create(const QString &cmName, const QString &protocolName,
+                                    const QVariantMap &parameters) {
+        return BaseConnectionPtr(new BaseConnection(
+                                     QDBusConnection::sessionBus(), cmName, protocolName, parameters));
+    }
+    template<typename BaseConnectionSubclass>
+    static SharedPtr<BaseConnectionSubclass> create(const QString &cmName,
+            const QString &protocolName, const QVariantMap &parameters) {
+        return SharedPtr<BaseConnectionSubclass>(new BaseConnectionSubclass(
+                    QDBusConnection::sessionBus(), cmName, protocolName, parameters));
+    }
+    static BaseConnectionPtr create(const QDBusConnection &dbusConnection,
+                                    const QString &cmName, const QString &protocolName,
+                                    const QVariantMap &parameters) {
+        return BaseConnectionPtr(new BaseConnection(
+                                     dbusConnection, cmName, protocolName, parameters));
+    }
+    template<typename BaseConnectionSubclass>
+    static SharedPtr<BaseConnectionSubclass> create(const QDBusConnection &dbusConnection,
+            const QString &cmName, const QString &protocolName,
+            const QVariantMap &parameters) {
+        return SharedPtr<BaseConnectionSubclass>(new BaseConnectionSubclass(
+                    dbusConnection, cmName, protocolName, parameters));
+    }
+
+    virtual ~BaseConnection();
+
+    QString cmName() const;
+    QString protocolName() const;
+    QVariantMap parameters() const;
+    uint status() const;
+    QVariantMap immutableProperties() const;
+
+    void setStatus(uint newStatus, uint reason);
+
+    typedef Callback4<BaseChannelPtr, const QString&, uint, uint, DBusError*> CreateChannelCallback;
+    void setCreateChannelCallback(const CreateChannelCallback &cb);
+    Tp::BaseChannelPtr createChannel(const QString &channelType, uint targetHandleType, uint targetHandle, uint initiatorHandle, bool suppressHandler, DBusError *error);
+
+    typedef Callback3<UIntList, uint, const QStringList&, DBusError*> RequestHandlesCallback;
+    void setRequestHandlesCallback(const RequestHandlesCallback &cb);
+    UIntList requestHandles(uint handleType, const QStringList &identifiers, DBusError* error);
+
+    //typedef Callback3<uint, const QString&, const QString&, DBusError*> SetPresenceCallback;
+    //void setSetPresenceCallback(const SetPresenceCallback &cb);
+
+    void setSelfHandle(uint selfHandle);
+    uint selfHandle() const;
+
+    typedef Callback1<void, DBusError*> ConnectCallback;
+    void setConnectCallback(const ConnectCallback &cb);
+
+    typedef Callback3<QStringList, uint, const Tp::UIntList&, DBusError*> InspectHandlesCallback;
+    void setInspectHandlesCallback(const InspectHandlesCallback &cb);
+
+    Tp::ChannelInfoList channelsInfo();
+    Tp::ChannelDetailsList channelsDetails();
+
+    BaseChannelPtr ensureChannel(const QString &channelType, uint targetHandleType,
+                                 uint targetHandle, bool &yours, uint initiatorHandle, bool suppressHandler, DBusError *error);
+    void addChannel(BaseChannelPtr channel);
+
+    QList<AbstractConnectionInterfacePtr> interfaces() const;
+    AbstractConnectionInterfacePtr interface(const QString  &interfaceName) const;
+    bool plugInterface(const AbstractConnectionInterfacePtr &interface);
+
+    virtual QString uniqueName() const;
+    bool registerObject(DBusError *error = NULL);
+
+Q_SIGNALS:
+    void disconnected();
+
+private Q_SLOTS:
+    TP_QT_NO_EXPORT void removeChannel();
+
+protected:
+    BaseConnection(const QDBusConnection &dbusConnection,
+                   const QString &cmName, const QString &protocolName,
+                   const QVariantMap &parameters);
+
+    virtual bool registerObject(const QString &busName, const QString &objectPath,
+                                DBusError *error);
+
+private:
+    class Adaptee;
+    friend class Adaptee;
+    class Private;
+    friend class Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT AbstractConnectionInterface : public AbstractDBusServiceInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(AbstractConnectionInterface)
+
+public:
+    AbstractConnectionInterface(const QString &interfaceName);
+    virtual ~AbstractConnectionInterface();
+
+private:
+    friend class BaseConnection;
+
+    class Private;
+    friend class Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseConnectionRequestsInterface : public AbstractConnectionInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseConnectionRequestsInterface)
+
+public:
+    static BaseConnectionRequestsInterfacePtr create(BaseConnection* connection) {
+        return BaseConnectionRequestsInterfacePtr(new BaseConnectionRequestsInterface(connection));
+    }
+    template<typename BaseConnectionRequestsInterfaceSubclass>
+    static SharedPtr<BaseConnectionRequestsInterfaceSubclass> create(BaseConnection* connection) {
+        return SharedPtr<BaseConnectionRequestsInterfaceSubclass>(
+                   new BaseConnectionRequestsInterfaceSubclass(connection));
+    }
+
+    virtual ~BaseConnectionRequestsInterface();
+
+    QVariantMap immutableProperties() const;
+
+    Tp::RequestableChannelClassList requestableChannelClasses;
+    void ensureChannel(const QVariantMap &request, bool &yours,
+                       QDBusObjectPath &channel, QVariantMap &details, DBusError* error);
+    void createChannel(const QVariantMap &request, QDBusObjectPath &channel,
+                       QVariantMap &details, DBusError* error);
+public Q_SLOTS:
+    void newChannels(const Tp::ChannelDetailsList &channels);
+
+protected:
+    BaseConnectionRequestsInterface(BaseConnection* connection);
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+
+class TP_QT_EXPORT BaseConnectionContactsInterface : public AbstractConnectionInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseConnectionContactsInterface)
+
+
+public:
+    static BaseConnectionContactsInterfacePtr create() {
+        return BaseConnectionContactsInterfacePtr(new BaseConnectionContactsInterface());
+    }
+    template<typename BaseConnectionContactsInterfaceSubclass>
+    static SharedPtr<BaseConnectionContactsInterfaceSubclass> create() {
+        return SharedPtr<BaseConnectionContactsInterfaceSubclass>(
+                   new BaseConnectionContactsInterfaceSubclass());
+    }
+
+    virtual ~BaseConnectionContactsInterface();
+
+    QVariantMap immutableProperties() const;
+
+    typedef Callback3<ContactAttributesMap, const Tp::UIntList&, const QStringList&, DBusError*> GetContactAttributesCallback;
+    void setGetContactAttributesCallback(const GetContactAttributesCallback &cb);
+    ContactAttributesMap getContactAttributes(const Tp::UIntList &handles,
+            const QStringList &interfaces,
+            DBusError *error);
+    void setContactAttributeInterfaces(const QStringList &contactAttributeInterfaces);
+protected:
+    BaseConnectionContactsInterface();
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseConnectionSimplePresenceInterface : public AbstractConnectionInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseConnectionSimplePresenceInterface)
+
+public:
+    static BaseConnectionSimplePresenceInterfacePtr create() {
+        return BaseConnectionSimplePresenceInterfacePtr(new BaseConnectionSimplePresenceInterface());
+    }
+    template<typename BaseConnectionSimplePresenceInterfaceSublclass>
+    static SharedPtr<BaseConnectionSimplePresenceInterfaceSublclass> create() {
+        return SharedPtr<BaseConnectionSimplePresenceInterfaceSublclass>(
+                   new BaseConnectionSimplePresenceInterfaceSublclass());
+    }
+
+    virtual ~BaseConnectionSimplePresenceInterface();
+
+    QVariantMap immutableProperties() const;
+
+    typedef Callback3<uint, const QString&, const QString&, DBusError*> SetPresenceCallback;
+    void setSetPresenceCallback(const SetPresenceCallback &cb);
+
+    void setPresences(const Tp::SimpleContactPresences &presences);
+    void setStatuses(const SimpleStatusSpecMap &statuses);
+    void setMaxmimumStatusMessageLength(uint maxmimumStatusMessageLength);
+protected:
+    BaseConnectionSimplePresenceInterface();
+    Tp::SimpleStatusSpecMap statuses() const;
+    int maximumStatusMessageLength() const;
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseConnectionContactListInterface : public AbstractConnectionInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseConnectionContactListInterface)
+
+public:
+    static BaseConnectionContactListInterfacePtr create() {
+        return BaseConnectionContactListInterfacePtr(new BaseConnectionContactListInterface());
+    }
+    template<typename BaseConnectionContactListInterfaceSubclass>
+    static SharedPtr<BaseConnectionContactListInterfaceSubclass> create() {
+        return SharedPtr<BaseConnectionContactListInterfaceSubclass>(
+                   new BaseConnectionContactListInterfaceSubclass());
+    }
+
+    virtual ~BaseConnectionContactListInterface();
+
+    QVariantMap immutableProperties() const;
+
+    void setContactListState(uint contactListState);
+    void setContactListPersists(bool);
+    void setCanChangeContactList(bool);
+    void setRequestUsesMessage(bool);
+    void setDownloadAtConnection(bool);
+
+    typedef Callback3<Tp::ContactAttributesMap, const QStringList&, bool, DBusError*> GetContactListAttributesCallback;
+    void setGetContactListAttributesCallback(const GetContactListAttributesCallback &cb);
+
+    typedef Callback3<void, const Tp::UIntList&, const QString&, DBusError*> RequestSubscriptionCallback;
+    void setRequestSubscriptionCallback(const RequestSubscriptionCallback &cb);
+
+    void contactsChangedWithID(const Tp::ContactSubscriptionMap &changes, const Tp::HandleIdentifierMap &identifiers, const Tp::HandleIdentifierMap &removals);
+protected:
+    BaseConnectionContactListInterface();
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseConnectionAddressingInterface : public AbstractConnectionInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseConnectionAddressingInterface)
+
+public:
+    static BaseConnectionAddressingInterfacePtr create() {
+        return BaseConnectionAddressingInterfacePtr(new BaseConnectionAddressingInterface());
+    }
+    template<typename BaseConnectionAddressingInterfaceSubclass>
+    static SharedPtr<BaseConnectionAddressingInterfaceSubclass> create() {
+        return SharedPtr<BaseConnectionAddressingInterfaceSubclass>(
+                   new BaseConnectionAddressingInterfaceSubclass());
+    }
+
+    virtual ~BaseConnectionAddressingInterface();
+
+    QVariantMap immutableProperties() const;
+
+
+
+    typedef Callback6 < void, const QString&, const QStringList&, const QStringList&,
+            Tp::AddressingNormalizationMap&, Tp::ContactAttributesMap&, DBusError* > GetContactsByVCardFieldCallback;
+    void setGetContactsByVCardFieldCallback(const GetContactsByVCardFieldCallback &cb);
+
+    typedef Callback5 < void, const QStringList&, const QStringList&,
+            Tp::AddressingNormalizationMap&, Tp::ContactAttributesMap&, DBusError* > GetContactsByURICallback;
+    void setGetContactsByURICallback(const GetContactsByURICallback &cb);
+
+protected:
+    BaseConnectionAddressingInterface();
+
+private:
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+}
+
+#endif

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2014-01-17 10:22:42 +0000
+++ .pc/applied-patches	2014-02-05 14:09:56 +0000
@@ -3,3 +3,5 @@
 03-add_service_side_classes.patch
 04-force_PIC_QT5.patch
 05-fix-qt52-build.patch
+06-conference_interfaces.patch
+07-fix_createChannel.patch

=== modified file 'TelepathyQt/base-channel-internal.h'
--- TelepathyQt/base-channel-internal.h	2013-06-06 04:56:14 +0000
+++ TelepathyQt/base-channel-internal.h	2014-02-05 14:09:56 +0000
@@ -210,6 +210,73 @@
     BaseChannelHoldInterface *mInterface;
 };
 
+class TP_QT_NO_EXPORT BaseChannelConferenceInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(Tp::ObjectPathList channels READ channels)
+    Q_PROPERTY(Tp::ObjectPathList initialChannels READ initialChannels)
+    Q_PROPERTY(Tp::UIntList initialInviteeHandles READ initialInviteeHandles)
+    Q_PROPERTY(QStringList initialInviteeIDs READ initialInviteeIDs)
+    Q_PROPERTY(QString invitationMessage READ invitationMessage)
+    Q_PROPERTY(ChannelOriginatorMap originalChannels READ originalChannels)
+public:
+    Adaptee(BaseChannelConferenceInterface *interface);
+    ~Adaptee();
+    Tp::ObjectPathList channels() const {
+        return mInterface->channels();
+    }
+    Tp::ObjectPathList initialChannels() const {
+        return mInterface->initialChannels();
+    }
+    Tp::UIntList initialInviteeHandles() const {
+        return mInterface->initialInviteeHandles();
+    }
+    QStringList initialInviteeIDs() const {
+        return mInterface->initialInviteeIDs();
+    }
+    QString invitationMessage() const {
+        return mInterface->invitationMessage();
+    }
+    ChannelOriginatorMap originalChannels() const {
+        return mInterface->originalChannels();
+    }
+
+signals:
+    void channelMerged(const QDBusObjectPath &channel, uint channelHandlent, Tp::QualifiedPropertyValueMap &properties);
+    void channelRemoved(const QDBusObjectPath &channel, const QVariantMap& details);
+
+public:
+    BaseChannelConferenceInterface *mInterface;
+};
+
+class TP_QT_NO_EXPORT BaseChannelMergeableConferenceInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+public:
+    Adaptee(BaseChannelMergeableConferenceInterface *interface);
+    ~Adaptee();
+
+public slots:
+    void merge(const QDBusObjectPath &channel, const Tp::Service::ChannelInterfaceMergeableConferenceAdaptor::MergeContextPtr &context);
+
+public:
+    BaseChannelMergeableConferenceInterface *mInterface;
+};
+
+class TP_QT_NO_EXPORT BaseChannelSplittableInterface::Adaptee : public QObject
+{
+    Q_OBJECT
+public:
+    Adaptee(BaseChannelSplittableInterface *interface);
+    ~Adaptee();
+
+public slots:
+    void split(const Tp::Service::ChannelInterfaceSplittableAdaptor::SplitContextPtr &context);
+
+public:
+    BaseChannelSplittableInterface *mInterface;
+};
+
 class TP_QT_NO_EXPORT BaseChannelGroupInterface::Adaptee : public QObject
 {
     Q_OBJECT

=== modified file 'TelepathyQt/base-channel.cpp'
--- TelepathyQt/base-channel.cpp	2013-06-06 04:56:14 +0000
+++ TelepathyQt/base-channel.cpp	2014-02-05 14:09:56 +0000
@@ -26,6 +26,7 @@
 
 #include "TelepathyQt/_gen/base-channel.moc.hpp"
 #include "TelepathyQt/_gen/base-channel-internal.moc.hpp"
+#include "TelepathyQt/future-internal.h"
 
 #include "TelepathyQt/debug-internal.h"
 
@@ -1684,5 +1685,298 @@
             mPriv->adaptee, dbusObject());
 }
 
+
+// Chan.I.MergeableConference
+BaseChannelMergeableConferenceInterface::Adaptee::Adaptee(BaseChannelMergeableConferenceInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelMergeableConferenceInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseChannelMergeableConferenceInterface::Private {
+    Private(BaseChannelMergeableConferenceInterface *parent)
+        :adaptee(new BaseChannelMergeableConferenceInterface::Adaptee(parent)) {
+    }
+
+    MergeCallback mergeCB;
+    BaseChannelMergeableConferenceInterface::Adaptee *adaptee;
+};
+
+void BaseChannelMergeableConferenceInterface::Adaptee::merge(const QDBusObjectPath &channelPath, const Tp::Service::ChannelInterfaceMergeableConferenceAdaptor::MergeContextPtr &context)
+{
+    if (!mInterface->mPriv->mergeCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+
+    DBusError error;
+    mInterface->mPriv->mergeCB(channelPath, &error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+/**
+ * \class BaseChannelMergeableConferenceInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Interface.MergeableConference
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelMergeableConferenceInterface::BaseChannelMergeableConferenceInterface()
+    : AbstractChannelInterface(TP_QT_FUTURE_IFACE_CHANNEL_INTERFACE_MERGEABLE_CONFERENCE),
+      mPriv(new Private(this))
+{
+}
+
+void BaseChannelMergeableConferenceInterface::setMergeCallback(const MergeCallback &cb)
+{
+    mPriv->mergeCB = cb;
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelMergeableConferenceInterface::~BaseChannelMergeableConferenceInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelMergeableConferenceInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseChannelMergeableConferenceInterface::createAdaptor()
+{
+    (void) new Service::ChannelInterfaceMergeableConferenceAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+
+// Chan.I.Splittable
+BaseChannelSplittableInterface::Adaptee::Adaptee(BaseChannelSplittableInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelSplittableInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseChannelSplittableInterface::Private {
+    Private(BaseChannelSplittableInterface *parent)
+        :adaptee(new BaseChannelSplittableInterface::Adaptee(parent)) {
+    }
+
+    SplitCallback splitCB;
+    BaseChannelSplittableInterface::Adaptee *adaptee;
+};
+
+void BaseChannelSplittableInterface::Adaptee::split(const Tp::Service::ChannelInterfaceSplittableAdaptor::SplitContextPtr &context)
+{
+    if (!mInterface->mPriv->splitCB.isValid()) {
+        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
+        return;
+    }
+
+    DBusError error;
+    mInterface->mPriv->splitCB(&error);
+    if (error.isValid()) {
+        context->setFinishedWithError(error.name(), error.message());
+        return;
+    }
+    context->setFinished();
+}
+
+/**
+ * \class BaseChannelSplittableInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Interface.Splittable
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelSplittableInterface::BaseChannelSplittableInterface()
+    : AbstractChannelInterface(TP_QT_FUTURE_IFACE_CHANNEL_INTERFACE_SPLITTABLE),
+      mPriv(new Private(this))
+{
+}
+
+void BaseChannelSplittableInterface::setSplitCallback(const SplitCallback &cb)
+{
+    mPriv->splitCB = cb;
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelSplittableInterface::~BaseChannelSplittableInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelSplittableInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseChannelSplittableInterface::createAdaptor()
+{
+    (void) new Service::ChannelInterfaceSplittableAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
+
+// Chan.I.Conference
+BaseChannelConferenceInterface::Adaptee::Adaptee(BaseChannelConferenceInterface *interface)
+    : QObject(interface),
+      mInterface(interface)
+{
+}
+
+BaseChannelConferenceInterface::Adaptee::~Adaptee()
+{
+}
+
+struct TP_QT_NO_EXPORT BaseChannelConferenceInterface::Private {
+    Private(BaseChannelConferenceInterface *parent, 
+            Tp::ObjectPathList initialChannels,
+            Tp::UIntList initialInviteeHandles,
+            QStringList initialInviteeIDs,
+            QString invitationMessage,
+            ChannelOriginatorMap originalChannels) : 
+        channels(initialChannels),
+        initialChannels(initialChannels),
+        initialInviteeHandles(initialInviteeHandles),
+        initialInviteeIDs(initialInviteeIDs),
+        invitationMessage(invitationMessage),
+        originalChannels(originalChannels),
+        adaptee(new BaseChannelConferenceInterface::Adaptee(parent)) {
+    }
+    Tp::ObjectPathList channels;
+    Tp::ObjectPathList initialChannels;
+    Tp::UIntList initialInviteeHandles;
+    QStringList initialInviteeIDs;
+    QString invitationMessage;
+    ChannelOriginatorMap originalChannels;
+
+    BaseChannelConferenceInterface::Adaptee *adaptee;
+};
+
+/**
+ * \class BaseChannelConferenceInterface
+ * \ingroup servicecm
+ * \headerfile TelepathyQt/base-channel.h <TelepathyQt/BaseChannel>
+ *
+ * \brief Base class for implementations of Channel.Interface.Conference
+ *
+ */
+
+/**
+ * Class constructor.
+ */
+BaseChannelConferenceInterface::BaseChannelConferenceInterface(Tp::ObjectPathList initialChannels,
+    Tp::UIntList initialInviteeHandles,
+    QStringList initialInviteeIDs,
+    QString invitationMessage,
+    ChannelOriginatorMap originalChannels)
+    : AbstractChannelInterface(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE),
+      mPriv(new Private(this, initialChannels, initialInviteeHandles, initialInviteeIDs, invitationMessage, originalChannels))
+{
+}
+
+Tp::ObjectPathList BaseChannelConferenceInterface::channels() const
+{
+    return mPriv->channels;
+}
+
+Tp::ObjectPathList BaseChannelConferenceInterface::initialChannels() const
+{
+    return mPriv->initialChannels;
+}
+
+Tp::UIntList BaseChannelConferenceInterface::initialInviteeHandles() const
+{
+    return mPriv->initialInviteeHandles;
+}
+
+QStringList BaseChannelConferenceInterface::initialInviteeIDs() const
+{
+    return mPriv->initialInviteeIDs;
+}
+
+QString BaseChannelConferenceInterface::invitationMessage() const
+{
+    return mPriv->invitationMessage;
+}
+
+ChannelOriginatorMap BaseChannelConferenceInterface::originalChannels() const
+{
+    return mPriv->originalChannels;
+}
+
+/**
+ * Class destructor.
+ */
+BaseChannelConferenceInterface::~BaseChannelConferenceInterface()
+{
+    delete mPriv;
+}
+
+/**
+ * Return the immutable properties of this interface.
+ *
+ * Immutable properties cannot change after the interface has been registered
+ * on a service on the bus with registerInterface().
+ *
+ * \return The immutable properties of this interface.
+ */
+QVariantMap BaseChannelConferenceInterface::immutableProperties() const
+{
+    QVariantMap map;
+    return map;
+}
+
+void BaseChannelConferenceInterface::createAdaptor()
+{
+    (void) new Service::ChannelInterfaceConferenceAdaptor(dbusObject()->dbusConnection(),
+            mPriv->adaptee, dbusObject());
+}
+
 }
 

=== modified file 'TelepathyQt/base-channel.h'
--- TelepathyQt/base-channel.h	2013-06-06 04:56:14 +0000
+++ TelepathyQt/base-channel.h	2014-02-05 14:09:56 +0000
@@ -475,5 +475,118 @@
     Private *mPriv;
 };
 
+class TP_QT_EXPORT BaseChannelMergeableConferenceInterface : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelMergeableConferenceInterface)
+
+public:
+    static BaseChannelMergeableConferenceInterfacePtr create() {
+        return BaseChannelMergeableConferenceInterfacePtr(new BaseChannelMergeableConferenceInterface());
+    }
+    template<typename BaseChannelMergeableConferenceInterfaceSubclass>
+    static SharedPtr<BaseChannelMergeableConferenceInterfaceSubclass> create() {
+        return SharedPtr<BaseChannelMergeableConferenceInterfaceSubclass>(
+                   new BaseChannelMergeableConferenceInterfaceSubclass());
+    }
+    virtual ~BaseChannelMergeableConferenceInterface();
+
+    QVariantMap immutableProperties() const;
+
+    void merge(const QDBusObjectPath &channel);
+
+    typedef Callback2<void, const QDBusObjectPath&, DBusError*> MergeCallback;
+    void setMergeCallback(const MergeCallback &cb);
+private:
+    BaseChannelMergeableConferenceInterface();
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelSplittableInterface : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelSplittableInterface)
+
+public:
+    static BaseChannelSplittableInterfacePtr create() {
+        return BaseChannelSplittableInterfacePtr(new BaseChannelSplittableInterface());
+    }
+    template<typename BaseChannelSplittableInterfaceSubclass>
+    static SharedPtr<BaseChannelSplittableInterfaceSubclass> create() {
+        return SharedPtr<BaseChannelSplittableInterfaceSubclass>(
+                   new BaseChannelSplittableInterfaceSubclass());
+    }
+    virtual ~BaseChannelSplittableInterface();
+
+    QVariantMap immutableProperties() const;
+
+    void split();
+
+    typedef Callback1<void, DBusError*> SplitCallback;
+    void setSplitCallback(const SplitCallback &cb);
+private:
+    BaseChannelSplittableInterface();
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
+class TP_QT_EXPORT BaseChannelConferenceInterface : public AbstractChannelInterface
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(BaseChannelConferenceInterface)
+
+public:
+    static BaseChannelConferenceInterfacePtr create(Tp::ObjectPathList initialChannels = Tp::ObjectPathList(),
+            Tp::UIntList initialInviteeHandles = Tp::UIntList(),
+            QStringList initialInviteeIDs = QStringList(),
+            QString invitationMessage = QString(),
+            ChannelOriginatorMap originalChannels = ChannelOriginatorMap()) {
+        return BaseChannelConferenceInterfacePtr(new BaseChannelConferenceInterface(initialChannels, initialInviteeHandles, initialInviteeIDs, invitationMessage, originalChannels));
+    }
+    template<typename BaseChannelConferenceInterfaceSubclass>
+    static SharedPtr<BaseChannelConferenceInterfaceSubclass> create(Tp::ObjectPathList initialChannels = Tp::ObjectPathList(),
+            Tp::UIntList initialInviteeHandles = Tp::UIntList(),
+            QStringList initialInviteeIDs = QStringList(),
+            QString invitationMessage = QString(),
+            ChannelOriginatorMap originalChannels = ChannelOriginatorMap()) {
+        return SharedPtr<BaseChannelConferenceInterfaceSubclass>(
+                   new BaseChannelConferenceInterfaceSubclass(initialChannels, initialInviteeHandles, initialInviteeIDs, invitationMessage, originalChannels));
+    }
+    virtual ~BaseChannelConferenceInterface();
+
+    QVariantMap immutableProperties() const;
+    Tp::ObjectPathList channels() const;
+    Tp::ObjectPathList initialChannels() const;
+    Tp::UIntList initialInviteeHandles() const;
+    QStringList initialInviteeIDs() const;
+    QString invitationMessage() const;
+    ChannelOriginatorMap originalChannels() const;
+
+Q_SIGNALS:
+    void channelMerged(const QDBusObjectPath &channel, uint channelHandle, const Tp::QualifiedPropertyValueMap &properties);
+    void channelRemoved(const QDBusObjectPath &channel, const QVariantMap &properties);
+
+private:
+    BaseChannelConferenceInterface(Tp::ObjectPathList initialChannels, Tp::UIntList initialInviteeHandles, QStringList initialInviteeIDs, QString invitationMessage, ChannelOriginatorMap originalChannels);
+    void createAdaptor();
+
+    class Adaptee;
+    friend class Adaptee;
+    struct Private;
+    friend struct Private;
+    Private *mPriv;
+};
+
 }
 #endif

=== modified file 'TelepathyQt/base-connection.cpp'
--- TelepathyQt/base-connection.cpp	2013-06-06 04:56:14 +0000
+++ TelepathyQt/base-connection.cpp	2014-02-05 14:09:56 +0000
@@ -286,6 +286,7 @@
         uint targetHandle,
         uint initiatorHandle,
         bool suppressHandler,
+        const QVariantMap &hints,
         DBusError *error)
 {
     if (!mPriv->createChannelCB.isValid()) {
@@ -297,7 +298,7 @@
         return BaseChannelPtr();
     }
 
-    BaseChannelPtr channel = mPriv->createChannelCB(channelType, targetHandleType, targetHandle, error);
+    BaseChannelPtr channel = mPriv->createChannelCB(channelType, targetHandleType, targetHandle, hints, error);
     if (error->isValid())
         return BaseChannelPtr();
 
@@ -412,7 +413,7 @@
         }
     }
     yours = true;
-    return createChannel(channelType, targetHandleType, targetHandle, initiatorHandle, suppressHandler, error);
+    return createChannel(channelType, targetHandleType, targetHandle, initiatorHandle, suppressHandler, QVariantMap(), error);
 }
 
 void BaseConnection::removeChannel()
@@ -715,18 +716,7 @@
 
     QString channelType = request[TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType")].toString();
     uint targetHandleType = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType")].toUInt();
-    uint targetHandle;
-    if (request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle")))
-        targetHandle = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle")].toUInt();
-    else {
-        QString targetID = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetID")].toString();
-        Tp::UIntList list = mPriv->connection->requestHandles(targetHandleType, QStringList() << targetID, error);
-        if (error->isValid()) {
-            warning() << "BBaseConnectionRequestsInterface::ensureChannel: could not resolve ID " << targetID;
-            return;
-        }
-        targetHandle = *list.begin();
-    }
+    uint targetHandle = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle")].toUInt();
 
     bool suppressHandler = true;
     BaseChannelPtr channel = mPriv->connection->ensureChannel(channelType, targetHandleType,
@@ -745,33 +735,21 @@
         QDBusObjectPath &objectPath,
         QVariantMap &details, DBusError *error)
 {
-    if (!request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"))
-            || !request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"))
-            || !request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"))) {
+    if (!request.contains(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"))) {
         error->set(TP_QT_ERROR_INVALID_ARGUMENT, QLatin1String("Missing parameters"));
         return;
     }
 
     QString channelType = request[TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType")].toString();
     uint targetHandleType = request[TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType")].toUInt();
-    uint targetHandle;