Attachment 10290 Details for Bug 11244 – telepathy-qt test program

telepathy-qt test program

test.cpp (text/plain), 107.41 KB, created by Izico Chang on 2007-06-12 23:41:27 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Izico Chang

Created: 2007-06-12 23:41:27 UTC

Size: 107.41 KB

patch

obsolete

>/**
> * demo usage pattern of telepathy-qt API
> *
> * @author   izicochang@gmail.com
> * @since    5/23/2007
> */
>
>#include "test.h"
>
>#include <signal.h>
>
>#include <QtCore/QCoreApplication>
>#include <QtDBus/QDBusMessage>
>#include <QtCore/QFile>
>#include <QtCore/QVariant>
>#include <QtCore/QDebug>
>
>#include <QtTelepathy/Client/ConnectionManager>
>#include <QtTelepathy/Client/Connection>
>#include <QtTelepathy/Client/ConnectionAliasingInterface>
>#include <QtTelepathy/Client/ConnectionAvatarsInterface>
>#include <QtTelepathy/Client/ConnectionCapabilitiesInterface>
>#include <QtTelepathy/Client/ConnectionForwardingInterface>
>#include <QtTelepathy/Client/ConnectionPresenceInterface>
>#include <QtTelepathy/Client/ConnectionPrivacyInterface>
>#include <QtTelepathy/Client/ConnectionRenamingInterface>
>
>#include <QtTelepathy/Client/Channel>
>#include <QtTelepathy/Client/ChannelGroupInterface>
>#include <QtTelepathy/Common/ChannelGroupInterfaceTypes>
>#include <QtTelepathy/Client/ChannelContactSearch>
>#include <QtTelepathy/Client/ChannelStreamedMedia>
>#include <QtTelepathy/Client/ChannelText>
>#include <QtTelepathy/Client/ChannelChatStateInterface>
>#include <QtTelepathy/Client/ChannelDTMFInterface>
>#include <QtTelepathy/Client/ChannelPasswordInterface>
>#include <QtTelepathy/Client/ChannelTransferInterface>
>#include "QtTelepathy/Client/ChannelMediaSignallingInterface"
>#include "QtTelepathy/Client/MediaSessionHandler"
>#include "QtTelepathy/Client/MediaStreamHandler"
>#include <QtTelepathy/Client/ChannelHandler>
>#include <QtTelepathy/Client/StreamEngine>
>
>using namespace org::freedesktop::Telepathy;
>
>/**
> * all types used in DBus communication must be registered to Qt's metatype
> * object system to use Qt's covenience
> */
>static void registerTypes()
>{
>    static bool registered = false;
>    if (!registered)
>    {
>        qDBusRegisterMetaType<QVariantMap>();
>
>        qDBusRegisterMetaType<ParameterDefinition>();
>        qDBusRegisterMetaType<ParameterDefinitionList>();
>
>        qDBusRegisterMetaType<ChannelInfo>();
>        qDBusRegisterMetaType<ChannelInfoList>();
>
>        qDBusRegisterMetaType<Aliases>();
>        qDBusRegisterMetaType<AliasInfo>();
>        qDBusRegisterMetaType<AliasInfoList>();
>
>        qDBusRegisterMetaType<CapabilityInfo>();
>        qDBusRegisterMetaType<CapabilityInfoList>();
>        qDBusRegisterMetaType<LocalCapabilityInfo>();
>        qDBusRegisterMetaType<CapabilitiesChangedInfo>();
>        qDBusRegisterMetaType<CapabilitiesChangedInfoList>();
>        qDBusRegisterMetaType<LocalCapabilityInfoList>();
>
>        qDBusRegisterMetaType<PresenceState>();
>        qDBusRegisterMetaType<PresenceStateInTime>();
>        qDBusRegisterMetaType<PresenceStateInTimeMap>();
>        qDBusRegisterMetaType<PresenceStateDefinition>();
>        qDBusRegisterMetaType<PresenceStateDefinitionMap>();
>
>        qDBusRegisterMetaType<StreamInfo>();
>        qDBusRegisterMetaType<StreamInfoList>();
>
>        qDBusRegisterMetaType<TextMessageInfo>();
>        qDBusRegisterMetaType<TextMessageInfoList>();
>
>        qDBusRegisterMetaType<SessionHandlerInfo>();
>        qDBusRegisterMetaType<SessionHandlerInfoList>();
>
>        qDBusRegisterMetaType<CodecInfo>();
>        qDBusRegisterMetaType<CodecInfoList>();
>        qDBusRegisterMetaType<TransportInfo>();
>        qDBusRegisterMetaType<TransportInfoList>();
>        qDBusRegisterMetaType<CandidateInfo>();
>        qDBusRegisterMetaType<CandidateInfoList>();
>
>
>        registered = true;
>    }
>}
>
>static void signal_handler(int)
>{
>    QCoreApplication::instance()->quit();
>}
>
>/**
> * install the thread-unsafe signal handler for convenience in studying
> */
>static bool install_signal_handlers()
>{
>    if (SIG_ERR == signal(SIGINT, signal_handler))
>    {
>        qDebug() << "can't install signal handler for SIGINT.";
>        return false;
>    }
>    if (SIG_ERR == signal(SIGHUP, signal_handler))
>    {
>        qDebug() << "can't install signal handler for SIGHUP.";
>        return false;
>    }
>    if (SIG_ERR == signal(SIGQUIT, signal_handler))
>    {
>        qDebug() << "can't install signal handler for SIGQUIT.";
>        return false;
>    }
>    if (SIG_ERR == signal(SIGABRT, signal_handler))
>    {
>        qDebug() << "can't install signal handler for SIGABRT.";
>        return false;
>    }
>    if (SIG_ERR == signal(SIGTERM, signal_handler))
>    {
>        qDebug() << "can't install signal handler for SIGTERM.";
>        return false;
>    }
>
>    return true;
>}
>
>/**
> * get account information from command line
> *
> * @param argc in cmdline
> * @param argv in cmdline
> * @param protocol  out protocol for CM
> * @param cmService inout service for CM
> * @param cmObjPath inout object path for CM
> * @param accountParam  out account parameters for CM
> *
> * @return bool if valid account parameters are returned
> */
>static bool get_account_info(int argc, char* argv[],
>                             QString& protocol,
>                             QString& cmService,
>                             QDBusObjectPath& cmObjPath,
>                             QVariantMap& accountParam)
>{
>    if (argc < 4)
>    {
>        qDebug() << "Usage: test protocol user@host password [server port]";
>        return false;
>    }
>
>    protocol = argv[1];
>
>    // set account parameters
>    if ("jabber" == protocol)
>    {
>        if (QString(argv[2]).endsWith("@gmail.com") ||
>            QString(argv[2]).endsWith("@googlemail.com"))
>        {
>            accountParam["server"] = QVariant("talk.google.com");
>            accountParam["old-ssl"] = QVariant(true);
>            accountParam["ignore-ssl-errors"] = QVariant(true);
>            accountParam["port"] = QVariant((uint) 5223);
>            accountParam["stun-server"] = QVariant("stun.l.google.com");
>        }
>        else
>        {
>            if (argc < 6)
>            {
>                qDebug() << "usage: test protocol username@host password"
>                << "server port";
>                return false;
>            }
>            accountParam["server"] = QVariant(argv[4]);
>            accountParam["port"] = QVariant(QString(argv[5]).toUInt());
>        }
>
>        cmService += ".gabble";
>        cmObjPath.setPath(cmObjPath.path() + "/gabble");
>    }
>    else if ("sip" == protocol)
>    {
>        if (argc > 4)
>        {
>            accountParam["registrar"] = QVariant(argv[4]);
>        }
>        if (argc > 5)
>        {
>            accountParam["port"] = QVariant(QString(argv[5]).toUInt());
>        }
>
>        cmService += ".sofiasip";
>        cmObjPath.setPath(cmObjPath.path() + "/sofiasip");
>    }
>    else if ("msn" == protocol)
>    {
>        cmService += ".butterfly";
>        cmObjPath.setPath(cmObjPath.path() + "/butterfly");
>    }
>    else if ("irc" == protocol)
>    {
>        cmService += ".idle";
>        cmObjPath.setPath(cmObjPath.path() + "/idle");
>    }
>    else
>    {
>        qDebug() << "protocol " << protocol << " is not supported yet.";
>        return false;
>    }
>
>    accountParam["account"] = QVariant(argv[2]);
>    accountParam["password"] = QVariant(argv[3]);
>
>    return true;
>}
>
>/**
> * create the CM
> *
> * @param protocol  in
> * @param service   in
> * @param objPath   in
> * @param mf        inout
> */
>static void init_connection_manager(const QString& protocol,
>                                    const QString& service,
>                                    const QString& objPath,
>                                    MessageFilter& mf)
>{
>    mf.cm = new ConnectionManager(service, objPath, mf.bus, &mf);
>
>    // get the parameters supported on this connection manager for this protocol
>    QDBusReply<org::freedesktop::Telepathy::ParameterDefinitionList>
>    cmParams = mf.cm->GetParameters(protocol);
>    if (!cmParams.isValid())
>    {
>        qDebug() << "GetParameters() returned error:"
>        << cmParams.error().name() << cmParams.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "Supported parameters of protocol" << protocol << ":";
>
>        foreach (org::freedesktop::Telepathy::ParameterDefinition param,
>                 cmParams.value())
>        {
>            qDebug() << "\tname:" << param.name
>            << "\n\tflags:" << param.flags
>            << "\n\tD-Bus type signature:" << param.signature
>            << "\n\tdefault value:" << param.defaultValue.variant()
>            << "\n";
>        }
>    }
>
>    // list all the protocols supported by the CM
>    QDBusReply<QStringList> protocols = mf.cm->ListProtocols();
>    if (!protocols.isValid())
>    {
>        qDebug() << "ListProtocols() returned error:"
>        << protocols.error().name()
>        << protocols.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "Supported protocols of the CM:"
>        << protocols.value() << "\n";
>    }
>
>    // catch all the signals emited by CM
>    QObject::connect(mf.cm,
>                     SIGNAL(NewConnection(QString, QDBusObjectPath, QString)),
>                     &mf,
>                     SLOT(onNewConnection(QString, QDBusObjectPath, QString)));
>}
>
>/**
> * create the connection to the remote server
> *
> * @param protocol      in protocol for the connection
> * @param accountParam  in account parameters for the connection
> * @param connService   out DBus service of the connection
> * @param connObjPath   out DBus object path of the connection
> * @param mf            inout
> *
> * @return bool     if connection is created successfully
> */
>static bool init_connection(const QString& protocol,
>                            const QVariantMap accountParam,
>                            QString& connService,
>                            QDBusObjectPath& connObjPath,
>                            MessageFilter& mf)
>{
>    QDBusReply<QString> connServiceName =
>    mf.cm->RequestConnection(protocol, accountParam, connObjPath);
>    if (!connServiceName.isValid())
>    {
>        qDebug() << "RequestConnection() returned error:"
>        << connServiceName.error().name()
>        << connServiceName.error().message();
>        return false;
>    }
>    else
>    {
>        connService = connServiceName.value();
>        qDebug() << "connection is created on:"
>        << "\n\tservice:" << connService
>        << "\n\tobject path:" << connObjPath.path() << "\n";
>    }
>
>    mf.conn = new Connection(connService, connObjPath.path(), mf.bus, &mf);
>
>    // catch all the signals emited on this connection
>    QObject::connect(mf.conn,
>                     SIGNAL(StatusChanged(uint,uint)),
>                     &mf,
>                     SLOT(OnStatusChanged(uint,uint)));
>
>    QObject::connect(mf.conn,
>                     SIGNAL(NewChannel(QDBusObjectPath, QString,
>                                       uint, uint, bool)),
>                     &mf,
>                     SLOT(onNewChannel(QDBusObjectPath, QString,
>                                       uint, uint, bool)));
>
>    return true;
>}
>
>/**
> * create the aliasing interface of the connection
> *
> * @param service   in
> * @param objPath   in
> * @param mf        inout
> */
>static void init_connection_interface_aliasing(const QString& service,
>                                               const QDBusObjectPath& objPath,
>                                               MessageFilter& mf)
>{
>    mf.aliasingIface =
>    new ConnectionAliasingInterface(service, objPath.path(), mf.bus, &mf);
>
>    // catch all the signals emited on aliasing interface
>    QObject::connect(mf.aliasingIface,
>                     SIGNAL(AliasesChanged(org::freedesktop::Telepathy::
>                                           AliasInfoList)),
>                     &mf,
>                     SLOT(onAliasesChanged(org::freedesktop::Telepathy::
>                                           AliasInfoList)));
>}
>
>/**
> * create the avatars interface of the connection
> *
> * @param service   in
> * @param objPath   in
> * @param mf        inout
> */
>static void init_connection_interface_avatars(const QString& service,
>                                              const QDBusObjectPath& objPath,
>                                              MessageFilter& mf)
>{
>    mf.avatarsIface =
>    new ConnectionAvatarsInterface(service, objPath.path(), mf.bus, &mf);
>
>    // catch all signals emited on avatar interface
>    QObject::connect(mf.avatarsIface, SIGNAL(AvatarUpdated(uint, QString)),
>                     &mf, SLOT(onAvatarUpdated(uint, QString)));
>}
>
>static void init_connection_interface_capabilities(const QString& service,
>                                                   const QDBusObjectPath&
>                                                   objPath,
>                                                   MessageFilter& mf)
>{
>    mf.capabilitiesIface =
>    new ConnectionCapabilitiesInterface(service, objPath.path(), mf.bus, &mf);
>
>    // catch all the signals
>    QObject::connect(mf.capabilitiesIface,
>                     SIGNAL(CapabilitiesChanged(org::freedesktop::Telepathy::CapabilitiesChangedInfoList)),
>                     &mf,
>                     SLOT(onCapabilitiesChanged(org::freedesktop::Telepathy::CapabilitiesChangedInfoList)));
>}
>
>static void init_connection_interface_forwarding(const QString& service,
>                                                 const QDBusObjectPath& objPath,
>                                                 MessageFilter& mf)
>{
>    mf.forwardingIface =
>    new ConnectionForwardingInterface(service, objPath.path(), mf.bus, &mf);
>
>    QObject::connect(mf.forwardingIface, SIGNAL(ForwardingChanged(uint)),
>                     &mf, SLOT(onForwardingChanged(uint)));
>}
>
>static void init_connection_interface_presence(const QString& service,
>                                               const QDBusObjectPath& objPath,
>                                               MessageFilter& mf)
>{
>    mf.presenceIface =
>    new ConnectionPresenceInterface(service, objPath.path(), mf.bus, &mf);
>
>
>    QObject::connect(mf.presenceIface,
>                     SIGNAL(PresenceUpdate(org::freedesktop::Telepathy::PresenceStateInTimeMap)),
>                     &mf,
>                     SLOT(onPresenceUpdate(org::freedesktop::Telepathy::PresenceStateInTimeMap)));
>}
>
>static void init_connection_interface_privacy(const QString& service,
>                                              const QDBusObjectPath& objPath,
>                                              MessageFilter& mf)
>{
>    mf.privacyIface =
>    new ConnectionPrivacyInterface(service, objPath.path(), mf.bus, &mf);
>
>    QObject::connect(mf.privacyIface, SIGNAL(PrivacyModeChanged(QString)),
>                     &mf, SLOT(onPrivacyModeChanged(QString)));
>}
>
>static void init_connection_interface_renaming(const QString& service,
>                                               const QDBusObjectPath& objPath,
>                                               MessageFilter& mf)
>{
>    mf.renamingIface =
>    new ConnectionRenamingInterface(service, objPath.path(), mf.bus, &mf);
>
>    QObject::connect(mf.renamingIface, SIGNAL(Renamed(uint, uint)),
>                     &mf, SLOT(onRenamed(uint, uint)));
>}
>
>int main(int argc, char **argv)
>{
>    // get the account parameters from command line
>    QString protocol;
>    QString cmService("org.freedesktop.Telepathy.ConnectionManager");
>    QDBusObjectPath cmObjPath("/org/freedesktop/Telepathy/ConnectionManager");
>    QVariantMap accountParam;
>    if (!get_account_info(argc, argv, protocol, cmService, cmObjPath,
>                          accountParam))
>    {
>        return -1;
>    }
>
>    // install signal handlers for convenience in testing
>    if (!install_signal_handlers())
>    {
>        return -1;
>    }
>
>    QCoreApplication app(argc, argv);
>
>    // register types for DBus marshall/demashall, all types used in DBus
>    // communiction should be registered(method_call,signal,method_return,
>    // error), otherwise there's type signature mismatch problem
>    registerTypes();
>
>    // connect to DBus session bus
>    if (!QDBusConnection::sessionBus().isConnected())
>    {
>        qDebug() << "Cannot connect to the D-BUS session bus.\n"
>        "To start it, run:\n"
>        "\teval `dbus-launch --auto-syntax`\n";
>        return -1;
>    }
>
>    // create the message filter
>    MessageFilter mf(QDBusConnection::sessionBus(), &app);
>
>    // create the connection manager
>    init_connection_manager(protocol, cmService, cmObjPath.path(), mf);
>
>    // request a connection to the server
>    QString connService;
>    QDBusObjectPath connObjPath;
>    if (!init_connection(protocol, accountParam, connService,
>                         connObjPath, mf))
>    {
>        return -1;
>    }
>
>    // get the aliasing interface of this connection
>    init_connection_interface_aliasing(connService, connObjPath, mf);
>
>    // get the avatar interface of the connection
>    init_connection_interface_avatars(connService, connObjPath, mf);
>
>    // get the capabilities interface of the connection
>    init_connection_interface_capabilities(connService, connObjPath, mf);
>
>    // get the forwarding interface of the connection
>    init_connection_interface_forwarding(connService, connObjPath, mf);
>
>    // get the presence interface of the connection
>    init_connection_interface_presence(connService, connObjPath, mf);
>
>    // get the privacy interface of the connection
>    init_connection_interface_privacy(connService, connObjPath, mf);
>
>    // get the renaming interface of the connection
>    init_connection_interface_renaming(connService, connObjPath, mf);
>
>    // connect to the remote server to be online now
>    mf.conn->Connect();
>
>    return app.exec();
>}
>
>MessageFilter::MessageFilter(const QDBusConnection &b, QObject *parent)
>: QObject(parent), bus(b)
>{
>    cm = 0;
>    conn = 0;
>    aliasingIface = 0;
>    avatarsIface = 0;
>    capabilitiesIface = 0;
>    forwardingIface = 0;
>    presenceIface = 0;
>    privacyIface = 0;
>    renamingIface = 0;
>}
>
>MessageFilter::~MessageFilter()
>{
>    // disconnect the connection if it's still in use to release the CM
>    if (conn)
>    {
>        conn->Disconnect();
>    }
>}
>
>/**
> * A new connection is opened by the CM
> *
> * @param service
> * @param objPath
> * @param proto
> */
>void MessageFilter::onNewConnection(const QString& service,
>                                    const QDBusObjectPath& objPath,
>                                    const QString& proto)
>{
>    qDebug() << "new connection has been created on:"
>    << "\n\tservice:" << service
>    << "\n\tpath:" << objPath.path()
>    << "\n\tprotocol:" << proto << "\n";
>}
>
>/**
> * a new channel has been opened on the connection
> *
> * @param objPath
> * @param channelType
> * @param handleType
> * @param handle
> * @param suppressHandler
> */
>void MessageFilter::onNewChannel(const QDBusObjectPath& objPath,
>                                 const QString& channelType,
>                                 uint handleType,
>                                 uint handle,
>                                 bool suppressHandler)
>{
>    qDebug() << "new channel has been opened:"
>    << "\n\tobject path:" << objPath.path()
>    << "\n\tchannel type:" << channelType
>    << "\n\thandle type:" << handleType
>    << "\n\thandle:" << handle;
>    if (handle)
>    {
>        QDBusReply<QStringList> handleName =
>        conn->InspectHandles(handleType, QList<quint32>() << handle);
>        if (!handleName.isValid())
>        {
>            qDebug() << "InspectHandles() returned error:"
>            << handleName.error().name()
>            << handleName.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\thandle name:" << handleName.value();
>        }
>    }
>    qDebug() << "\tsuppress handler:" << suppressHandler << "\n";
>
>    // accept streamed media call
>    if (("org.freedesktop.Telepathy.Channel.Type.StreamedMedia" == channelType)
>        && (!suppressHandler))
>    {
>        setupStreamedMediaChannel(objPath);
>
>        // the contact is in local pending list now
>        QDBusReply<QList<uint> > localPendingMemberHandleList
>        = smChannelGroupIface->GetLocalPendingMembers();
>        if (!localPendingMemberHandleList.isValid())
>        {
>            qDebug() << "GetLocalPendingMembers() returned error:"
>            << localPendingMemberHandleList.error().name()
>            << localPendingMemberHandleList.error().message()
>            << "\n";
>            return;
>        }
>
>        if (localPendingMemberHandleList.value().isEmpty())
>        {
>            qDebug() << "GetLocalPendingMembers() should not return 0 user.\n";
>            return;
>        }
>
>        qDebug() << "local pending members:" <<
>        localPendingMemberHandleList.value()
>        << "\n";
>
>        QDBusReply<void> reply =
>        smChannelGroupIface->AddMembers(localPendingMemberHandleList.value(),
>                                        "");
>        if (!reply.isValid())
>        {
>            qDebug() << "AddMembers() returned error:"
>            << reply.error().name()
>            << reply.error().message()
>            << "\n";
>            return;
>        }
>
>        smContactHandle = 0;
>        smContactCapabilies = 0;
>#if 0
>        bool isContactCapableOfStreamedMedia = false;
>
>        /*
>        if we come here too quickly, the capability changed signal of the
>        contact has not been received, so it'll fail to find the streamed
>        media capability of the contact
>        */
>
>        // get the capabilities of the contact
>        QDBusReply<CapabilityInfoList> contactCapabilities =
>        capabilitiesIface->GetCapabilities(QList<uint>() << smContactHandle);
>        if (!contactCapabilities.isValid())
>        {
>            qDebug() << "GetCapabilities() returned error:"
>            << contactCapabilities.error().name()
>            << contactCapabilities.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "capabilities of conact" << smContactHandle << ":";
>            for (int i = 0; i < contactCapabilities.value().count(); ++i)
>            {
>                qDebug() << "\n\thandle:"
>                << contactCapabilities.value().at(i).contactHandle
>                << "\n\tchannel type:"
>                << contactCapabilities.value().at(i).channelType
>                << "\n\tgeneric flags:"
>                << contactCapabilities.value().at(i).genericFlags
>                << "\n\ttype specific flags:"
>                << contactCapabilities.value().at(i).typeSpecificFlags
>                << "\n";
>
>                if ((contactCapabilities.value().at(i).contactHandle ==
>                     smContactHandle) &&
>                    (contactCapabilities.value().at(i).channelType ==
>                     "org.freedesktop.Telepathy.Channel.Type.StreamedMedia"))
>                {
>                    isContactCapableOfStreamedMedia = true;
>                    smContactCapabilies =
>                    contactCapabilities.value().at(i).typeSpecificFlags;
>                }
>            }
>        }
>
>        // confirm that the contact is capable of streamed media
>        if (!isContactCapableOfStreamedMedia)
>        {
>            qDebug() << smContactHandle <<"is not capable of streamed media.\n";
>            return;
>        }
>#endif
>    }
>}
>
>/**
> * the status of the connection has changed
> *
> * @param status
> * @param reason
> */
>void MessageFilter::OnStatusChanged(uint status, uint reason)
>{
>    qDebug() << "connection state has changed to" << status
>    << "- reason" << reason;
>
>    if (CONNECTION_STATUS_CONNECTING == status)
>    {
>        qDebug() << "connection is in progress...\n";
>    }
>    else if (CONNECTION_STATUS_DISCONNECTED == status)
>    {
>        qDebug() << "connection has been disconnected.\n";
>    }
>    else if (CONNECTION_STATUS_CONNECTED == status)
>    {
>        qDebug() << "connection has been connected:\n";
>
>        test_connection();
>        //        test_connection_interface_aliasing();
>        //        test_connection_interface_avatars();
>        test_connection_interface_capabilities();
>        //        test_connection_interface_forwarding();
>        //        test_connection_interface_presence();
>        //        test_connection_interface_privacy();
>        //        test_connection_interface_renaming();
>
>        //        test_channel();
>        //        test_channel_type_contactlist();
>        //        test_channel_type_contactsearch();
>        test_channel_type_streamedmedia();
>        //        test_channel_type_roomlist();
>        //        test_channel_type_text();
>        //        test_channel_type_tubes();
>    }
>    else
>    {
>        qDebug() << "wrong connection status" << status
>        << "should not have occured.\n";
>    }
>}
>
>/**
> * alias of some contacts has been changed
> *
> * @param newAliases
> */
>void MessageFilter::onAliasesChanged(const org::freedesktop::Telepathy::
>                                     AliasInfoList& newAliases)
>{
>    qDebug() << "alias of some contacts has been changed:";
>
>    foreach (org::freedesktop::Telepathy::AliasInfo alias, newAliases)
>    {
>        qDebug() << "\thandle:" << alias.contactHandle;
>        QDBusReply<QStringList> handleName =
>        conn->InspectHandles(HANDLE_TYPE_CONTACT, QList<uint>()
>                             << alias.contactHandle);
>        if (!handleName.isValid())
>        {
>            qDebug() << "InspectHandles() returned error:"
>            << handleName.error().name()
>            << handleName.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\tname:" << handleName.value().at(0);
>        }
>        qDebug() << "\tnew alias:" << alias.newAlias
>        << "\n";
>    }
>}
>
>/**
> * avatar of contact has been updated
> *
> * @param contact           in contact handle
> * @param new_avatar_token  in new avatar token
> */
>void MessageFilter::onAvatarUpdated(uint contact,
>                                    const QString &new_avatar_token)
>{
>    qDebug() << "avatar for contact has been updated:\n"
>    << "\thandle:" << contact;
>    QDBusReply<QStringList> handleName =
>    conn->InspectHandles(HANDLE_TYPE_CONTACT, QList<uint>()
>                         << contact);
>    if (!handleName.isValid())
>    {
>        qDebug() << "InspectHandles() returned error:"
>        << handleName.error().name()
>        << handleName.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "\tname:" << handleName.value().at(0);
>    }
>    qDebug() << "\ttoken:" << new_avatar_token << "\n";
>}
>
>void MessageFilter::test_connection()
>{
>    // get the existing interfaces on this connection
>    QDBusReply<QStringList> interfaces = conn->GetInterfaces();
>    if (!interfaces.isValid())
>    {
>        qDebug() << "GetInterfaces() returned error:"
>        << interfaces.error().name()
>        << interfaces.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "Supported interfaces on the connection:";
>        foreach (QString iface, interfaces.value())
>        {
>            qDebug() << "\t" << iface;
>        }
>    }
>
>    // get the used protocol of this connection
>    QDBusReply<QString> protocol = conn->GetProtocol();
>    if (!protocol.isValid())
>    {
>        qDebug() << "GetProtocol() returned error:"
>        << protocol.error().name()
>        << protocol.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "protocol used in the connection:"
>        << protocol.value() << "\n";
>    }
>
>    // get the handle of the connection itself
>    QDBusReply<quint32> selfHandle = conn->GetSelfHandle();
>    if (!selfHandle.isValid())
>    {
>        qDebug() << "GetSelfHandle() returned error:"
>        << selfHandle.error().name()
>        << selfHandle.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "handle of user of the connection:"
>        << selfHandle.value() << "\n";
>    }
>
>    // get current connection status
>    QDBusReply<quint32> status = conn->GetStatus();
>    if (!status.isValid())
>    {
>        qDebug() << "GetStatus() returned error:"
>        << status.error().name()
>        << status.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "current status of the connection:"
>        << status.value() << "\n";
>    }
>
>    // hold the connection handle
>    QDBusReply<void> ret =
>    conn->HoldHandles(HANDLE_TYPE_CONTACT,
>                      QList<quint32>() << selfHandle.value());
>    if (!ret.isValid())
>    {
>        qDebug() << "HoldHandles() returned error:"
>        << ret.error().name() << ret.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "handle of the connection" << selfHandle.value()
>        << "is held\n";
>    }
>
>    // get the handle name of the connection
>    QDBusReply<QStringList> selfHandleName =
>    conn->InspectHandles(HANDLE_TYPE_CONTACT,
>                         QList<quint32>() << selfHandle.value());
>    if (!selfHandleName.isValid())
>    {
>        qDebug() << "InspectHandles() returned error:"
>        << selfHandleName.error().name()
>        << selfHandleName.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "handle of the connection" << selfHandle.value()
>        << "is" << selfHandleName.value().at(0) << "\n";
>    }
>
>    // list all the existing channels on this connection
>    QDBusReply<org::freedesktop::Telepathy::ChannelInfoList>
>    channels = conn->ListChannels();
>    if (!channels.isValid())
>    {
>        qDebug() << "ListChannels() returned error:"
>        << channels.error().name()
>        << channels.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "existing channels on the connection:";
>        for (int i = 0; i < channels.value().size(); ++i)
>        {
>            org::freedesktop::Telepathy::ChannelInfo channel =
>            channels.value().at(i);
>
>            qDebug() << "\tpath:" << channel.objectPath.path()
>            << "\n\tinterface:" << channel.interfaceName
>            << "\n\thandle type:" << channel.handleType
>            << "\n\thandle:" << channel.handle;
>
>            if (channel.handle)
>            {
>                QDBusReply<QStringList> handleName =
>                conn->InspectHandles(channel.handleType,
>                                     QList<uint>() << channel.handle);
>                if (!handleName.isValid())
>                {
>                    qDebug() << "InspectHandles() returned error:"
>                    << handleName.error().name()
>                    << handleName.error().message()
>                    << "\n";
>                }
>                else
>                {
>                    qDebug() << "\thandle name:" << handleName.value();
>                }
>            }
>
>            qDebug() << "\n";
>        }
>    }
>
>    // get some contact lists on this connection
>    QStringList contactListNameList;
>    contactListNameList << "subscribe" << "publish";
>    QDBusReply<QList<quint32> > contactListHandles =
>    conn->RequestHandles(HANDLE_TYPE_LIST, contactListNameList);
>    if (!contactListHandles.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactListHandles.error().name()
>        << contactListHandles.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "contact list of" << contactListNameList << ":";
>        QDBusReply<QStringList> contactListHandleNames =
>        conn->InspectHandles(HANDLE_TYPE_LIST, contactListHandles.value());
>
>        if (!contactListHandleNames.isValid())
>        {
>            qDebug() << "InspectHandles() returned error:"
>            << contactListHandleNames.error().name()
>            << contactListHandleNames.error().message()
>            << "\n";
>        }
>
>        for (int i = 0; i < contactListHandles.value().count(); ++i)
>        {
>            quint32 handle = contactListHandles.value().at(i);
>
>            qDebug() << "\thandle:" << contactListHandles.value().at(i);
>
>            if (contactListHandleNames.isValid())
>            {
>                qDebug() << "\tname:" << contactListHandleNames.value().at(i);
>            }
>
>            QDBusReply<QDBusObjectPath> contactListChannelPath =
>            conn->RequestChannel("org.freedesktop.Telepathy.Channel.Type."
>                                 "ContactList",
>                                 HANDLE_TYPE_LIST, handle, true);
>            if (!contactListChannelPath.isValid())
>            {
>                qDebug() << "RequestChannel() returned error:"
>                << contactListChannelPath.error().name()
>                << contactListChannelPath.error().message()
>                << "\n";
>            }
>            else
>            {
>                qDebug() << "\tobject path:"
>                << contactListChannelPath.value().path()
>                << "\n";
>            }
>        }
>
>        // release the handles not in use for the server to release them
>        // in will
>        QDBusReply<void> releaseHandlesReply =
>        conn->ReleaseHandles(HANDLE_TYPE_LIST, contactListHandles.value());
>        if (!releaseHandlesReply.isValid())
>        {
>            qDebug() << "ReleaseHandles() returned error:"
>            << releaseHandlesReply.error().name()
>            << releaseHandlesReply.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "contact list handles" << contactListHandles.value()
>            << "are all released.\n";
>        }
>    }
>}
>
>void MessageFilter::test_connection_interface_aliasing()
>{
>    // get the flags of the aliasing interface, if
>    // Connection_Alias_Flag_User_Set is set, user can set alias of contact
>    QDBusReply<uint> aliasFlags = aliasingIface->GetAliasFlags();
>    if (!aliasFlags.isValid())
>    {
>        qDebug() << "GetAliasFlags() returned error:"
>        << aliasFlags.error().name()
>        << aliasFlags.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "flags of the aliasing interface of the connection:"
>        << aliasFlags.value() << "\n";
>    }
>
>    // get the handles of some contacts of this connection
>    QDBusReply<QList<uint> > contactHandles =
>    conn->RequestHandles(HANDLE_TYPE_CONTACT, QStringList()
>                         << "izico@jabber.org"
>                         << "izicochang@gmail.com"
>                         << "izicoc@gmail.com"
>                         << "izico@msn.com");
>    if (!contactHandles.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactHandles.error().name()
>        << contactHandles.error().message()
>        << "\n";
>    }
>    else
>    {
>        // get the aliases of the contacts
>        QDBusReply<QStringList> contactAliases =
>        aliasingIface->RequestAliases(contactHandles.value());
>        if (!contactAliases.isValid())
>        {
>            qDebug() << "RequestAliases() returned error:"
>            << contactAliases.error().name()
>            << contactAliases.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "aliases for handles" << contactHandles.value();
>            QDBusReply<QStringList> handleNames =
>            conn->InspectHandles(HANDLE_TYPE_CONTACT,
>                                 contactHandles.value());
>            if (!handleNames.isValid())
>            {
>                qDebug() << "InspectHandles() returned error:"
>                << handleNames.error().name()
>                << handleNames.error().message();
>            }
>            else
>            {
>                qDebug() << "corresponding to users" <<
>                handleNames.value();
>            }
>            qDebug() << "are" << contactAliases.value() << "\n";
>        }
>
>        // set the aliases of contacts if the server support setting
>        // contact aliases by user
>        org::freedesktop::Telepathy::Aliases aliasMap;
>        QString alias1 = "Izico Chang";
>        QString alias2 = "Izico Chang";
>        aliasMap[contactHandles.value().at(0)] = alias1;
>        aliasMap[contactHandles.value().at(1)] = alias2;
>
>        QDBusReply<void> setAliasesReply
>        = aliasingIface->SetAliases(aliasMap);
>        if (!setAliasesReply.isValid())
>        {
>            qDebug() << "SetAliases() returned error:"
>            << setAliasesReply.error().name()
>            << setAliasesReply.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "set alias of handle"
>            << contactHandles.value().at(0)
>            << "to" << alias1;
>            qDebug() << "set alias of handle"
>            << contactHandles.value().at(1)
>            << "to" << alias2
>            << "\n";
>        }
>
>        // release all the contact handles for server to release in will
>        QDBusReply<void> releaseHandlesReply =
>        conn->ReleaseHandles(HANDLE_TYPE_CONTACT, contactHandles.value());
>        if (!releaseHandlesReply.isValid())
>        {
>            qDebug() << "ReleaseHandles() returned error:"
>            << releaseHandlesReply.error().name()
>            << releaseHandlesReply.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "all contact handles" << contactHandles.value()
>            << "are released.\n";
>        }
>    }
>}
>
>void MessageFilter::test_connection_interface_avatars()
>{
>    // get the required formats of the avatars on this connection
>    struct
>    {
>        QStringList formats;
>        ushort min_width;
>        ushort min_height;
>        ushort max_width;
>        ushort max_height;
>        uint max_size;
>    } avatarRequirments;
>
>    QDBusReply<QStringList> avatarRequirementsReply =
>    avatarsIface->GetAvatarRequirements(avatarRequirments.min_width,
>                                        avatarRequirments.min_height,
>                                        avatarRequirments.max_width,
>                                        avatarRequirments.max_height,
>                                        avatarRequirments.max_size);
>
>    if (!avatarRequirementsReply.isValid())
>    {
>        qDebug() << "GetAvatarRequirements() returned error:"
>        << avatarRequirementsReply.error().name()
>        << avatarRequirementsReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        avatarRequirments.formats = avatarRequirementsReply.value();
>        qDebug() << "Supported avatar formats are"
>        << avatarRequirments.formats;
>        qDebug() << "Required avatar geometry are(pixels):"
>        << "\n\tmin width:" << avatarRequirments.min_width
>        << "\n\tmin height:" << avatarRequirments.min_height
>        << "\n\tmax width:" << avatarRequirments.max_width
>        << "\n\tmax height:" << avatarRequirments.max_height
>        << "\n\tmax size:" << avatarRequirments.max_size << "bytes\n"
>        << "\n";
>    }
>
>    // get the handle for some contacts
>    QDBusReply<QList<uint> > contactHandles =
>    conn->RequestHandles(HANDLE_TYPE_CONTACT, QStringList()
>                         << "izicochang@gmail.com"
>                         << "izico@jabber.org");
>    if (!contactHandles.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactHandles.error().name()
>        << contactHandles.error().message()
>        << "\n";
>    }
>    else
>    {
>        // get the avatar tokens to check for local cache
>        QDBusReply<QStringList> contactAvatarTokens =
>        avatarsIface->GetAvatarTokens(contactHandles);
>        if (!contactAvatarTokens.isValid())
>        {
>            qDebug() << "GetAvatarTokens() returned error:"
>            << contactAvatarTokens.error().name()
>            << contactAvatarTokens.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "avatar tokens for contact handles"
>            << contactHandles.value()
>            << "are" << contactAvatarTokens.value()
>            << "\n";
>        }
>
>        // get the avatars from server
>        foreach (uint contactHandle, contactHandles.value())
>        {
>            QString contactAvatarFormat;
>            QDBusReply<QByteArray> contactAvatarData =
>            avatarsIface->RequestAvatar(contactHandle,
>                                        contactAvatarFormat);
>            if (!contactAvatarData.isValid())
>            {
>                qDebug() << "RequestAvatar() returned error:"
>                << contactAvatarData.error().name()
>                << contactAvatarData.error().message()
>                << "\n";
>            }
>            else
>            {
>                qDebug() << "avatar for contact handle" << contactHandle
>                << "of MIME type" << contactAvatarFormat
>                << "and size" << contactAvatarData.value().size();
>
>                QString fileName = "avatar"
>                                   + QString::number(contactHandle);
>                QFile file(fileName);
>                file.open(QIODevice::WriteOnly);
>                file.write(contactAvatarData.value());
>                if (QFile::NoError != file.error())
>                {
>                    qDebug() << "can't be writen to file" << fileName
>                    << "\n";
>                }
>                else
>                {
>                    qDebug() << "is written to file" << fileName
>                    << "\n";
>                }
>            }
>        }
>
>        QDBusReply<void> reply = conn->ReleaseHandles(HANDLE_TYPE_CONTACT,
>                                                      contactHandles.value());
>        if (!reply.isValid())
>        {
>            qDebug() << "ReleaseHandles() returned error:"
>            << reply.error().name()
>            << reply.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "contact handles" << contactHandles.value()
>            << "is released.\n";
>        }
>    }
>
>    // clear avatar of this connection
>    QDBusReply<void> reply = avatarsIface->call(QDBus::Block,
>                                                "ClearAvatar");
>    if (!reply.isValid())
>    {
>        qDebug() << "call(ClearAvatar) returned error:"
>        << reply.error().name() << reply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "connection avatar is cleared.\n";
>    }
>
>    // set avatar of this connection
>    QString fileName("/home/src/qtopia-opensource-4.2.2/pics/qtopia.png");
>    QFile file(fileName);
>    file.open(QIODevice::ReadOnly);
>    QByteArray myAvatarData = file.readAll();
>    if (QFile::NoError != file.error())
>    {
>        qDebug() << "can't read avatar file" << fileName << "\n";
>    }
>    else
>    {
>        QString myAvatarType = "image/png";
>        QDBusReply<QString> connAvatarToken =
>        avatarsIface->SetAvatar(myAvatarData, myAvatarType);
>        if (!connAvatarToken.isValid())
>        {
>            qDebug() << "SetAvatar() returned error:"
>            << connAvatarToken.error().name()
>            << connAvatarToken.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "new avatar for the connection"
>            << connAvatarToken.value()
>            << "is updated from file" << fileName
>            << "\n";
>        }
>    }
>}
>
>void MessageFilter::test_connection_interface_capabilities()
>{
>    // advertise streamed media capability
>    org::freedesktop::Telepathy::LocalCapabilityInfo addCapability;
>    addCapability.channelType =
>    "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
>    addCapability.typeSpecificFlags
>    = (CHANNEL_MEDIA_CAPABILITY_AUDIO |
>       CHANNEL_MEDIA_CAPABILITY_VIDEO |
>       CHANNEL_MEDIA_CAPABILITY_NAT_TRAVERSAL_GTALK_P2P |
>       CHANNEL_MEDIA_CAPABILITY_NAT_TRAVERSAL_STUN);
>
>    org::freedesktop::Telepathy::LocalCapabilityInfoList addCapabilities;
>    addCapabilities << addCapability;
>
>    // remove capabilities
>    QStringList removeCapabilities;
>
>    // advertise my capabilities
>    QDBusReply<org::freedesktop::Telepathy::LocalCapabilityInfoList>
>    connectionCapabilities =
>    capabilitiesIface->AdvertiseCapabilities(addCapabilities,
>                                             removeCapabilities);
>    if (!connectionCapabilities.isValid())
>    {
>        qDebug() << "AdvertiseCapabilities() returned error:"
>        << connectionCapabilities.error().name()
>        << connectionCapabilities.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "capabilities of the connection are:";
>        for (int i = 0; i < connectionCapabilities.value().count(); ++i)
>        {
>            qDebug() << "\tchannel type:"
>            << connectionCapabilities.value().at(i).channelType
>            << "\n\ttype specific capability flags:"
>            << connectionCapabilities.value().at(i).typeSpecificFlags
>            << "\n";
>        }
>    }
>
>    // get handles of some contacts and the connection itself
>    QDBusReply<QList<uint> > contactHandleList =
>    conn->RequestHandles(HANDLE_TYPE_CONTACT,
>                         QStringList() <<
>                         "izicochang@gmail.com"
>                         << "izico0@gmail.com");
>    if (!contactHandleList.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactHandleList.error().name()
>        << contactHandleList.error().message()
>        << "\n";
>    }
>    else
>    {
>        // get the capabilities of the contacts
>        QDBusReply<org::freedesktop::Telepathy::CapabilityInfoList>
>        contactCapabilitiesList =
>        capabilitiesIface->GetCapabilities(QList<uint>() << 0
>                                           << contactHandleList.value());
>
>        if (!contactCapabilitiesList.isValid())
>        {
>            qDebug() << "GetCapabilities() returned error:"
>            << contactCapabilitiesList.error().name()
>            << contactCapabilitiesList.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "capabilities of some contacts:\n";
>            for (int i =0; i < contactCapabilitiesList.value().count(); ++i)
>            {
>                qDebug() << "\thandle:"
>                << contactCapabilitiesList.value().at(i).contactHandle;
>                QDBusReply<QStringList> handleName =
>                conn->InspectHandles(HANDLE_TYPE_CONTACT, QList<uint>()
>                                     << contactCapabilitiesList.value().at(i).contactHandle);
>                if (!handleName.isValid())
>                {
>                    qDebug() << "InspectHandles() returned error:"
>                    << handleName.error().name()
>                    << handleName.error().message()
>                    << "\n";
>                }
>                else
>                {
>                    qDebug() << "\tname:" << handleName.value().at(0);
>                }
>
>                qDebug() << "\tchannel type:"
>                << contactCapabilitiesList.value().at(i).channelType
>                << "\n\tgeneric capability flags for the type:"
>                << contactCapabilitiesList.value().at(i).genericFlags
>                << "\n\ttype specific capability flags for the type:"
>                << contactCapabilitiesList.value().at(i).typeSpecificFlags
>                << "\n";
>            }
>        }
>    }
>}
>
>void MessageFilter::onCapabilitiesChanged(const org::freedesktop::Telepathy::CapabilitiesChangedInfoList& caps)
>{
>    qDebug() << "capabilities of" << caps.count()
>    << "contacts has been changed:";
>    for (int i = 0; i < caps.count(); ++i)
>    {
>        qDebug() << "\thandle:" << caps.at(i).contactHandle;
>        QDBusReply<QStringList> contactName =
>        conn->InspectHandles(HANDLE_TYPE_CONTACT, QList<uint>() <<
>                             caps.at(i).contactHandle);
>        if (!contactName.isValid())
>        {
>            qDebug() << "InspectHandles() returned error:"
>            << contactName.error().name()
>            << contactName.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\tname:" << contactName.value().at(0);
>        }
>
>        qDebug() << "\tchannel type:" << caps.at(i).channelType
>        << "\n\told generic capability flags:" << caps.at(i).oldGenericFlags
>        << "\n\tnew generic capability flags:" << caps.at(i).newGenericFlags
>        << "\n\told type specific capability flags:"
>        << caps.at(i).oldTypeSpecificFlags
>        << "\n\tnew type specific capability flags:"
>        << caps.at(i).newTypeSpecificFlags
>        << "\n";
>    }
>}
>
>/**
> * FIXME org.freedesktop.DBus.Error.UnknownMethod
> */
>void MessageFilter::test_connection_interface_forwarding()
>{
>    // disable forwarding
>    QDBusReply<void> reply = forwardingIface->SetForwardingHandle(0);
>    if (!reply.isValid())
>    {
>        qDebug() << "SetForwardingHandle() returned error:"
>        << reply.error().name()
>        << reply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "forwarding is disabled on the connection.\n";
>    }
>
>    QDBusReply<uint> forwardingHandle =
>    forwardingIface->GetForwardingHandle();
>
>    if (!forwardingHandle.isValid())
>    {
>        qDebug() << "GetForwardingHandle() returned error:"
>        << forwardingHandle.error().name()
>        << forwardingHandle.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "forwarding handle of the connection:"
>        << forwardingHandle.value()
>        << "\n";
>    }
>}
>
>void MessageFilter::onForwardingChanged(uint forward_to)
>{
>    if (!forward_to)
>    {
>        qDebug() << "forwarding has been disabled on the connection.\n";
>    }
>    else
>    {
>        qDebug() << "forwarding contact has been changed to handle"
>        << forward_to
>        << "on the connection.\n";
>    }
>}
>
>void MessageFilter::test_connection_interface_presence()
>{
>    // clear presence status of connection
>    QDBusReply<void> clearStatusReply = presenceIface->ClearStatus();
>    if (!clearStatusReply.isValid())
>    {
>        qDebug() << "ClearStatus() returned error:"
>        << clearStatusReply.error().name()
>        << clearStatusReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "presence status of the connection is cleared.\n";
>    }
>
>    // remove presence status of connection
>    QDBusReply<void> removeStatusReply =
>    presenceIface->RemoveStatus("available");
>    if (!removeStatusReply.isValid())
>    {
>        qDebug() << "RemoveStatus() returned error:"
>        << removeStatusReply.error().name()
>        << removeStatusReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "status \"available\" is removed from connection.\n";
>    }
>
>    org::freedesktop::Telepathy::PresenceState setStatus;
>    setStatus["xa"] = QVariantMap();
>    QDBusReply<void> setStatusReply = presenceIface->SetStatus(setStatus);
>    if (!setStatusReply.isValid())
>    {
>        qDebug() << "SetStatus() returned error:"
>        << setStatusReply.error().name()
>        << setStatusReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "presence state of connection is set to \"xa\"\n";
>    }
>
>    // FIXME "Only one status is possible at a time with this protocol"
>    // set presence status of connection
>    QString connPresenceStatus = "xa";
>    QVariantMap connPresenceParams;
>    QDBusReply<void> addStatusReply =
>    presenceIface->AddStatus(connPresenceStatus, connPresenceParams);
>    if (!addStatusReply.isValid())
>    {
>        qDebug() << "AddStatus() returned error:"
>        << addStatusReply.error().name()
>        << addStatusReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "presence status is set to"
>        << connPresenceStatus
>        << "\n";
>    }
>
>    // get handles of some contacts
>    QDBusReply<QList<uint> > contactHandles
>    = conn->RequestHandles(HANDLE_TYPE_CONTACT,
>                           QStringList() << "izicochang@gmail.com"
>                           << "izico@jabber.org");
>    if (!contactHandles.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactHandles.error().name()
>        << contactHandles.error().message()
>        << "\n";
>    }
>    else
>    {
>        // get presence of some contacts
>        QList<QVariant> argumentList;
>        argumentList << qVariantFromValue(contactHandles.value());
>        QDBusReply<org::freedesktop::Telepathy::PresenceStateInTimeMap>
>        contactsPresence =
>        presenceIface->callWithArgumentList(QDBus::Block, "GetPresence",
>                                            argumentList);
>        if (!contactsPresence.isValid())
>        {
>            qDebug() << "call(GetPresence) returned error:"
>            << contactsPresence.error().name()
>            << contactsPresence.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "presence of some contacts are:";
>            foreach (uint handle, contactsPresence.value().keys())
>            {
>                qDebug() << "\thandle:" << handle;
>
>                QDBusReply<QStringList> handleName =
>                conn->InspectHandles(HANDLE_TYPE_CONTACT, QList<uint>()
>                                     << handle);
>                if (!handleName.isValid())
>                {
>                    qDebug() << "InspectHandles() returned error:"
>                    << handleName.error().name()
>                    << handleName.error().message()
>                    << "\n";
>                }
>                else
>                {
>                    qDebug() << "\tname:" << handleName.value().at(0);
>                }
>
>                quint32 timestamp = contactsPresence.value()[handle].time;
>                qDebug() << "\ttimestamp:" << timestamp;
>
>                PresenceState state = contactsPresence.value()[handle].state;
>                foreach (QString status, state.keys())
>                {
>                    qDebug() << "\tstatus:" << status;
>
>                    QVariantMap params = state[status];
>                    qDebug() << "\tparameters:" << params
>                    << "\n";
>                }
>            }
>        }
>
>        QDBusReply<void> reply =
>        presenceIface->RequestPresence(contactHandles);
>        if (!reply.isValid())
>        {
>            qDebug() << "RequestPresence() returned error:"
>            << reply.error().name()
>            << reply.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "presence of some contacts is requested.\n";
>        }
>
>        QDBusReply<void> releaseHandlesReply =
>        conn->ReleaseHandles(HANDLE_TYPE_CONTACT, contactHandles);
>        if (!releaseHandlesReply.isValid())
>        {
>            qDebug() << "ReleaseHandles() returned error:"
>            << releaseHandlesReply.error().name()
>            << releaseHandlesReply.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "contact handles" << contactHandles.value()
>            << "are released.\n";
>        }
>    }
>
>    // FIXME unexpected reply signature org.freedesktop.DBus.Error.InvalidSignature
>    // get valid presense status of the connection from server
>    QDBusReply<org::freedesktop::Telepathy::PresenceStateDefinitionMap>
>    statuses = presenceIface->GetStatuses();
>    if (!statuses.isValid())
>    {
>        qDebug() << "GetStatuses() returned error:"
>        << statuses.error().name()
>        << statuses.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "valid presence statuses of the connection are:";
>        foreach (QString name, statuses.value().keys())
>        {
>            qDebug() << "\t" << name << ":";
>
>            org::freedesktop::Telepathy::PresenceStateDefinition
>            definition = statuses.value()[name];
>
>            qDebug() << "\type:" << definition.type
>            << "\n\tmaySetOnMyself:" << definition.maySetOnMyself
>            << "\n\tisExclusive:" << definition.isExclusive
>            << "\n\targument map {name, type} :" << definition.arguments
>            << "\n";
>        }
>    }
>
>    QDBusReply<void> setLastActivityTimeReply =
>    presenceIface->SetLastActivityTime(100);
>    if (!setLastActivityTimeReply.isValid())
>    {
>        qDebug() << "SetLastActivityTime() returned error:"
>        << setLastActivityTimeReply.error().name()
>        << setLastActivityTimeReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "last activity time has been set to 100.\n";
>    }
>}
>
>void MessageFilter::onPresenceUpdate(const org::freedesktop::Telepathy::PresenceStateInTimeMap& presence)
>{
>    qDebug() << "presence of some contacts has been updated:";
>    foreach (uint handle, presence.keys())
>    {
>        qDebug() << "\thandle:" << handle;
>
>        QDBusReply<QStringList> handleName =
>        conn->InspectHandles(HANDLE_TYPE_CONTACT, QList<uint>() << handle);
>        if (!handleName.isValid())
>        {
>            qDebug() << "InspectHandles() returned error:"
>            << handleName.error().name()
>            << handleName.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\tname:" << handleName.value().at(0);
>        }
>
>        quint32 timestamp = presence[handle].time;
>        qDebug() << "\ttimestamp:" << timestamp;
>
>        PresenceState state = presence[handle].state;
>        foreach (QString status, state.keys())
>        {
>            qDebug() << "\tstatus:" << status;
>
>            QVariantMap params = state[status];
>            qDebug() << "\tparameters:" << params
>            << "\n";
>        }
>    }
>}
>
>/**
> * FIXME org.freedesktop.DBus.Error.UnknownMethod
> */
>void MessageFilter::test_connection_interface_privacy()
>{
>    QDBusReply<QStringList> supportedPrivacyModes =
>    privacyIface->GetPrivacyModes();
>    if (!supportedPrivacyModes.isValid())
>    {
>        qDebug() << "GetPrivacyModes() returned error:"
>        << supportedPrivacyModes.error().name()
>        << supportedPrivacyModes.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "supported privacy modes of the connection:"
>        << supportedPrivacyModes.value()
>        << "\n";
>    }
>
>    QDBusReply<QString> currentPrivacyMode =
>    privacyIface->GetPrivacyMode();
>    if (!currentPrivacyMode.isValid())
>    {
>        qDebug() << "GetPrivacyMode() returned error:"
>        << currentPrivacyMode.error().name()
>        << currentPrivacyMode.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "current privacy mode of the connecition is"
>        << currentPrivacyMode.value()
>        << "\n";
>    }
>
>    QDBusReply<void> setPrivacyModeReply =
>    privacyIface->SetPrivacyMode("allow-all");
>    if (!setPrivacyModeReply.isValid())
>    {
>        qDebug() << "SetPrivacyMode() returned error:"
>        << setPrivacyModeReply.error().name()
>        << setPrivacyModeReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "privacy mode of the connection is set to"
>        << "\"allow-all\"\n";
>    }
>}
>
>void MessageFilter::onPrivacyModeChanged(const QString& mode)
>{
>    qDebug() << "privacy mode of the connection has been changed to" << mode
>    << "\n";
>}
>
>/**
> * FIXME org.freedesktop.DBus.Error.UnknownMethod
> */
>void MessageFilter::test_connection_interface_renaming()
>{
>    QString newName("izicochang@gmail.com");
>    QDBusReply<void> requestRenameReply =
>    renamingIface->RequestRename(newName);
>    if (!requestRenameReply.isValid())
>    {
>        qDebug() << "RequestRename() returned error:"
>        << requestRenameReply.error().name()
>        << requestRenameReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "user identifier of the connection is renamed to"
>        << newName << "\n";
>    }
>}
>
>void MessageFilter::onRenamed(uint old_handle, uint new_handle)
>{
>    qDebug() << "handle" << old_handle << "has been renamed to"
>    << "new handle" << new_handle << "\n";
>}
>
>void MessageFilter::test_channel()
>{
>    // create an anonymose channel
>    QString channelType =
>    "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
>    QDBusReply<QDBusObjectPath> channelPath =
>    conn->RequestChannel(channelType, 0, 0, true);
>    if (!channelPath.isValid())
>    {
>        qDebug() << "RequestChannel() returned error:"
>        << channelPath.error().name()
>        << channelPath.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "anonymouse channel is created:"
>        << "\n\tchannel type:" << channelType
>        << "\n\tpath:" << channelPath.value().path()
>        << "\n";
>
>        // get the Channel interface
>        anonymousChannel = new Channel(conn->service(),
>                                       channelPath.value().path(), bus, this);
>
>        connect(anonymousChannel, SIGNAL(Closed()), this, SLOT(onClose()));
>
>        QDBusReply<QString> gotChannelType = anonymousChannel->GetChannelType();
>        if (!gotChannelType.isValid())
>        {
>            qDebug() << "GetChannelType() returned error:"
>            << gotChannelType.error().name()
>            << gotChannelType.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "confirmed channel type:"
>            << gotChannelType.value()
>            << "\n";
>        }
>
>        uint handle;
>        QDBusReply<uint> handleType = anonymousChannel->GetHandle(handle);
>        if (!handleType.isValid())
>        {
>            qDebug() << "GetHandle() returned error:"
>            << handleType.error().name()
>            << handleType.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "the channnel is for cummunication with:"
>            << "\n\thandle type:" << handleType.value()
>            << "\n\thandle:" << handle
>            << "\n";
>        }
>
>        QDBusReply<QStringList> interfaces = anonymousChannel->GetInterfaces();
>        if (!interfaces.isValid())
>        {
>            qDebug() << "GetInterfaces() returned error:"
>            << interfaces.error().name()
>            << interfaces.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "supported interfaces on the channel:";
>            foreach (QString interface, interfaces.value())
>            {
>                qDebug() << "\t" << interface;
>            }
>            qDebug() << "\n";
>        }
>
>        // close the channel
>        QDBusReply<void> closeReply = anonymousChannel->Close();
>        if (!closeReply.isValid())
>        {
>            qDebug() << "Close() returned error:"
>            << closeReply.error().name()
>            << closeReply.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "channel" << channelPath.value().path()
>            << "is closed.\n";
>        }
>    }
>}
>
>void MessageFilter::onClose()
>{
>    qDebug() << "one channel has been closed.\n";
>}
>
>/**
> * FIXME:
> *
> * Transfer - org.freedesktop.DBus.Error.UnknownMethod
> */
>void MessageFilter::test_channel_type_contactlist()
>{
>    // get some contact list handles
>    QStringList contactListNameList;
>    // "allow" and "hide" is not valid on izico.zhang@gmail.com
>    contactListNameList << "subscribe" << "publish" << "deny" << "known";
>
>    QDBusReply<QList<uint> > contactListHandleList =
>    conn->RequestHandles(HANDLE_TYPE_LIST, contactListNameList);
>    if (!contactListHandleList.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactListHandleList.error().name()
>        << contactListHandleList.error().message()
>        << "\n";
>        return;
>    }
>
>    Q_ASSERT(contactListHandleList.value().count() == 4);
>
>    for (int i = 0; i < contactListHandleList.value().count(); ++i)
>    {
>        uint contactListHandle = contactListHandleList.value().at(i);
>        QString contactListName = contactListNameList.at(i);
>
>        QDBusReply<QDBusObjectPath> contactListPath =
>        conn->RequestChannel("org.freedesktop.Telepathy.Channel.Type.ContactList",
>                             HANDLE_TYPE_LIST, contactListHandle, true);
>        if (!contactListPath.isValid())
>        {
>            qDebug() << "RequestChannel() returned error:"
>            << contactListPath.error().name()
>            << contactListPath.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "contact list channel:"
>            << "\n\thandle:" << contactListHandle
>            << "\n\tname:" << contactListNameList.at(i)
>            << "\n\tobject path:" << contactListPath.value().path();
>        }
>
>        contactListChannel[i] =
>        new Channel(conn->service(), contactListPath.value().path(),
>                    bus, this);
>        connect(contactListChannel[i], SIGNAL(Closed()), this, SLOT(onClose()));
>
>        contactListChannelGroupIface[i] =
>        new ChannelGroupInterface(conn->service(),
>                                  contactListPath.value().path(),
>                                  bus, this);
>
>        connect(contactListChannelGroupIface[i],
>                SIGNAL(GroupFlagsChanged(uint, uint)),
>                this,
>                SLOT(onGroupFlagsChanged(uint, uint)));
>
>        connect(contactListChannelGroupIface[i],
>                SIGNAL(MembersChanged(QString, QList<uint>, QList<uint>, QList<uint>, QList<uint>, uint, uint)),
>                this,
>                SLOT(onMembersChanged(QString, QList<uint>, QList<uint>, QList<uint>, QList<uint>, uint, uint)));
>
>        // FIXME: org.freedesktop.DBus.Error.UnknownMethod
>        ChannelTransferInterface transferIface(conn->service(),
>                                               contactListPath.value().path(),
>                                               bus, this);
>        QDBusReply<void> transferReply =
>        transferIface.Transfer(1, 2);
>        if (!transferReply.isValid())
>        {
>            qDebug() << "Transfer() returned error:"
>            << transferReply.error().name()
>            << transferReply.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "channel member 1 will connect with 2 indead.\n";
>        }
>
>        // get flags of this channel
>        QDBusReply<uint> channelFlags =
>        contactListChannelGroupIface[i]->GetGroupFlags();
>        if (!channelFlags.isValid())
>        {
>            qDebug() << "GetGroupFlags() returned error:"
>            << channelFlags.error().name()
>            << channelFlags.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\tflags: 0x" << hex << channelFlags.value();
>        }
>
>        // add some members to "subscribe" contact list
>        if ((contactListName == "subscribe") &&
>            channelFlags.isValid() &&
>            (channelFlags & CHANNEL_GROUP_FLAG_CAN_ADD))
>        {
>            QStringList addMemberNameList;
>            addMemberNameList << "izico0@gmail.com"
>            << "ext+130@truphone.com";
>
>            QDBusReply<QList<uint> > addMemberList =
>            conn->RequestHandles(HANDLE_TYPE_CONTACT,
>                                 addMemberNameList);
>            if (!addMemberList.isValid())
>            {
>                qDebug() << "RequestHandles() returned error:"
>                << addMemberList.error().name()
>                << addMemberList.error().message()
>                << "\n";
>            }
>            else
>            {
>                QDBusReply<void> addMembersReply =
>                contactListChannelGroupIface[i]->AddMembers(addMemberList,
>                                                            "add members");
>                if (!addMembersReply.isValid())
>                {
>                    qDebug() << "AddMembers() returned error:"
>                    << addMembersReply.error().name()
>                    << addMembersReply.error().message()
>                    << "\n";
>                }
>                else
>                {
>                    qDebug() << "\tadded members:" << addMemberNameList;
>                }
>            }
>        }
>
>        // remove some contacts in "publish" lis
>        if ((contactListName == "publish") &&
>            channelFlags.isValid() &&
>            (channelFlags & CHANNEL_GROUP_FLAG_CAN_REMOVE))
>        {
>            QStringList removeMemberNameList;
>            removeMemberNameList << "izicochang@gmail.com";
>
>            QDBusReply<QList<uint> > removeMemberHandleList =
>            conn->RequestHandles(HANDLE_TYPE_CONTACT,
>                                 removeMemberNameList);
>            if (!removeMemberHandleList.isValid())
>            {
>                qDebug() << "RequestHandles() returned error:"
>                << removeMemberHandleList.error().name()
>                << removeMemberHandleList.error().message()
>                << "\n";
>            }
>            else
>            {
>                QDBusReply<void> removeMembersReply =
>                contactListChannelGroupIface[i]->RemoveMembers(removeMemberHandleList, "remove members");
>                if (!removeMembersReply.isValid())
>                {
>                    qDebug() << "RemoveMembers() returned error:"
>                    << removeMembersReply.error().name()
>                    << removeMembersReply.error().message()
>                    << "\n";
>                }
>                else
>                {
>                    qDebug() << "\tremoved members:"
>                    << removeMemberHandleList.value();
>                }
>            }
>        }
>
>        QList<uint> localPendingMemberHandleList;
>        QList<uint> remotePendingMemberHandleList;
>        QDBusReply<QList<uint> > currentMemberHandleList =
>        contactListChannelGroupIface[i]->GetAllMembers(localPendingMemberHandleList, remotePendingMemberHandleList);
>        if (!currentMemberHandleList.isValid())
>        {
>            qDebug() << "GetAllMembers() returned error:"
>            << currentMemberHandleList.error().name()
>            << currentMemberHandleList.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\tcurrent members:\n"
>            << "\t\thandles:" << currentMemberHandleList.value();
>            QDBusReply<QStringList> currentMemberNameList =
>            conn->InspectHandles(HANDLE_TYPE_CONTACT,
>                                 currentMemberHandleList.value());
>            if (!currentMemberNameList.isValid())
>            {
>                qDebug() << "InspectHandles() returned error:"
>                << currentMemberNameList.error().name()
>                << currentMemberNameList.error().message()
>                << "\n";
>            }
>            else
>            {
>                qDebug() << "\t\tnames:" << currentMemberNameList.value();
>            }
>
>            if (channelFlags.isValid() &&
>                (channelFlags.value() & CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES))
>            {
>                QDBusReply<QList<uint> > currentMemberHandleOwnerList =
>                contactListChannelGroupIface[i]->GetHandleOwners(currentMemberHandleList.value());
>                if (!currentMemberHandleOwnerList.isValid())
>                {
>                    qDebug() << "GetHandleOwners() returned error:"
>                    << currentMemberHandleOwnerList.error().name()
>                    << currentMemberHandleOwnerList.error().message()
>                    << "\n";
>                }
>                else
>                {
>                    qDebug() << "owner of handles of current members:"
>                    << currentMemberHandleOwnerList.value();
>                }
>            }
>
>            qDebug() << "\tlocal pending members:\n"
>            << "\t\thandles:" << localPendingMemberHandleList;
>            QDBusReply<QStringList> localPendingMemberNameList =
>            conn->InspectHandles(HANDLE_TYPE_CONTACT,
>                                 localPendingMemberHandleList);
>            if (!localPendingMemberNameList.isValid())
>            {
>                qDebug() << "InspectHandles() returned error:"
>                << localPendingMemberNameList.error().name()
>                << localPendingMemberNameList.error().message()
>                << "\n";
>            }
>            else
>            {
>                qDebug() << "\t\tnames:" <<
>                localPendingMemberNameList.value();
>            }
>
>            qDebug() << "\tremote pending members:\n"
>            << "\t\thandles:" << remotePendingMemberHandleList;
>            QDBusReply<QStringList> remotePendingMemberNameList =
>            conn->InspectHandles(HANDLE_TYPE_CONTACT,
>                                 remotePendingMemberHandleList);
>            if (!remotePendingMemberNameList.isValid())
>            {
>                qDebug() << "InspectHandles() returned error:"
>                << remotePendingMemberNameList.error().name()
>                << remotePendingMemberNameList.error().message()
>                << "\n";
>            }
>            else
>            {
>                qDebug() << "\t\tnames:" <<
>                remotePendingMemberNameList.value();
>            }
>        }
>
>        QDBusReply<QList<uint> > currentMemberHandleList2 =
>        contactListChannelGroupIface[i]->GetMembers();
>        if (!currentMemberHandleList2.isValid())
>        {
>            qDebug() << "GetMembers() returned error:"
>            << currentMemberHandleList2.error().name()
>            << currentMemberHandleList2.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\tconfirmed current member handles:"
>            << currentMemberHandleList2.value();
>        }
>
>        QDBusReply<QList<uint> > localPendingMemberHandleList2 =
>        contactListChannelGroupIface[i]->GetLocalPendingMembers();
>        if (!localPendingMemberHandleList2.isValid())
>        {
>            qDebug() << "GetLocalPendingMembers() returned error:"
>            << localPendingMemberHandleList2.error().name()
>            << localPendingMemberHandleList2.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\tconfirmed local pending member handles:"
>            << localPendingMemberHandleList2.value();
>        }
>
>        // XXX in telepathy spec,but not telepathy-qt API
>        QDBusMessage replyMessage =
>        contactListChannelGroupIface[i]->call(QDBus::Block,
>                                              "GetLocalPendingMembersWithInfo");
>        if (contactListChannelGroupIface[i]->lastError().isValid())
>        {
>            qDebug() << "call(GetLocalPendingMembersWithInfo)"
>            "returned error:"
>            << contactListChannelGroupIface[i]->lastError().name()
>            << contactListChannelGroupIface[i]->lastError().message()
>            << "\n";
>        }
>        else
>        {
>            // should write marshall/demarshall routine to get reply
>        }
>
>        QDBusReply<QList<uint> > remotePendingMemberHandleList2 =
>        contactListChannelGroupIface[i]->GetRemotePendingMembers();
>        if (!remotePendingMemberHandleList2.isValid())
>        {
>            qDebug() << "GetRemotePendingMembers() returned error:"
>            << remotePendingMemberHandleList2.error().name()
>            << remotePendingMemberHandleList2.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\tconfirmed remote pending member handles:"
>            << remotePendingMemberHandleList2.value()
>            << "\n";
>        }
>
>        QDBusReply<uint> selfHandle =
>        contactListChannelGroupIface[i]->GetSelfHandle();
>        if (!selfHandle.isValid())
>        {
>            qDebug() << "GetSelfHandle() returned error:"
>            << selfHandle.error().name()
>            << selfHandle.error().message()
>            << "\n";
>        }
>        else
>        {
>            if (selfHandle.value())
>            {
>                qDebug() << "\thandle of the channel user:"
>                << selfHandle.value();
>
>                QDBusReply<QStringList> selfHandleNameList =
>                conn->InspectHandles(HANDLE_TYPE_CONTACT, QList<uint>()
>                                     << selfHandle.value());
>                if (!selfHandleNameList.isValid())
>                {
>                    qDebug() << "InspectHandles() returned error:"
>                    << selfHandleNameList.error().name()
>                    << selfHandleNameList.error().message()
>                    << "\n";
>                }
>                else
>                {
>                    qDebug() << "\tname of the channel user:"
>                    << selfHandleNameList.value().at(0);
>                }
>            }
>        }
>    }
>
>    QDBusReply<void> releaseHandlesReply =
>    conn->ReleaseHandles(HANDLE_TYPE_LIST, contactListHandleList);
>    if (!releaseHandlesReply.isValid())
>    {
>        qDebug() << "ReleaseHandles() returned error:"
>        << releaseHandlesReply.error().name()
>        << releaseHandlesReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "all handles" << contactListHandleList.value()
>        << "are released.\n";
>    }
>}
>
>void MessageFilter::onGroupFlagsChanged(uint added, uint removed)
>{
>    qDebug() << "group flags of one channel has been changed:"
>    << "\n\tadded flags:" << hex << added
>    << "\n\tremoved flags:" << hex << removed
>    << "\n";
>}
>
>void MessageFilter::onMembersChanged(const QString &message,
>                                     const QList<uint> &added,
>                                     const QList<uint> &removed,
>                                     const QList<uint> &local_pending,
>                                     const QList<uint> &remote_pending,
>                                     uint actor,
>                                     uint reason)
>{
>    qDebug() << "members of one channel has changed:\n"
>    << "\n\tmessage:" << message
>    << "\n\tadded members:" << added
>    << "\n\tremoved members:" << removed
>    << "\n\tlocal pending members:" << local_pending
>    << "\n\tremote pending members:" << remote_pending
>    << "\n\tuser making the change:" << actor
>    << "\n\treason for the change:" << reason
>    << "\n";
>}
>
>/**
> * FIXME
> * unsupported channel type
> * "org.freedesktop.Telepathy.Channel.Type.ContactSearch"
> */
>void MessageFilter::test_channel_type_contactsearch()
>{
>    QStringList contactListNames;
>    contactListNames << "subscribe" << "publish" << "deny";
>
>    QDBusReply<QList<uint> > contactListHandles =
>    conn->RequestHandles(HANDLE_TYPE_LIST, contactListNames);
>    if (!contactListHandles.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactListHandles.error().name()
>        << contactListHandles.error().message()
>        << "\n";
>        return;
>    }
>
>    qDebug() << "contact search channel:";
>    foreach (uint contactListHandle, contactListHandles.value())
>    {
>        QDBusReply<QDBusObjectPath> searchPath =
>        conn->RequestChannel("org.freedesktop.Telepathy.Channel.Type.ContactSearch",
>                             HANDLE_TYPE_LIST, contactListHandle, true);
>        if (!searchPath.isValid())
>        {
>            qDebug() << "RequestChannel() returned error:"
>            << searchPath.error().name()
>            << searchPath.error().message()
>            << "\n";
>        }
>        else
>        {
>            qDebug() << "\thandle:" << contactListHandle
>            << "\n\tsearch path:"
>            << searchPath.value().path();
>
>            ChannelContactSearch searchChannel(conn->service(),
>                                               searchPath.value().path(),
>                                               bus);
>
>            ContactSearchTypeInfoMap searchKeys;
>            QDBusReply<QString> instructions =
>            searchChannel.GetSearchKeys(searchKeys);
>            if (!instructions.isValid())
>            {
>                qDebug() << "GetSearchKeys() returned error:"
>                << instructions.error().name()
>                << instructions.error().message()
>                << "\n";
>            }
>        }
>    }
>}
>
>/**
> * FIXME
> */
>void MessageFilter::test_channel_type_roomlist()
>{
>    /* FIXME
>       "org.freedesktop.Telepathy.Error.NotAvailable"
>       "requested room handle conference.jabber.org does not specify a
>       server, but we have not discovered any local conference servers
>       and no fallback was provided"
>
>       with null server lists will return back 0 handles
>
>       the call has succeeded once,but don't know why never succeed
>       again later
>    */
>    QStringList conferenceServerList;
>    conferenceServerList << "ubuntu";
>    QDBusReply<QList<uint> > roomListHandleList =
>    conn->RequestHandles(HANDLE_TYPE_ROOM, conferenceServerList);
>    if (!roomListHandleList.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << roomListHandleList.error().name()
>        << roomListHandleList.error().message()
>        << "\n";
>        return;
>    }
>
>    qDebug() << "There are" << roomListHandleList.value().count()
>    << "rooms on the conference server";
>
>    if (roomListHandleList.value().isEmpty())
>    {
>        return;
>    }
>
>    uint roomListHandle = roomListHandleList.value().at(0);
>
>    QDBusReply<QDBusObjectPath> roomListPath =
>    conn->RequestChannel("org.freedesktop.Telepathy.Channel.Type.RoomList",
>                         HANDLE_TYPE_ROOM, roomListHandle, true);
>    if (!roomListPath.isValid())
>    {
>        qDebug() << "RequestChannel() returned error:"
>        << roomListPath.error().name()
>        << roomListPath.error().message()
>        << "\n";
>        return;
>    }
>
>    qDebug() << "room list is created on:"
>    <<"\n\tobject path:" << roomListPath.value().path();
>}
>
>/**
> * XXX the properties is not exported in telepathy-qt API
> * XXX the chat state interface signals are not received
> */
>void MessageFilter::test_channel_type_text()
>{
>    QStringList contactNameList;
>    contactNameList << "izicochang@gmail.com";
>    //    contactNameList << "izico@jabber.org";
>    //    contactNameList << "izico.zhang@gmail.com";
>    QDBusReply<QList<uint> > contactHandleList =
>    conn->RequestHandles(HANDLE_TYPE_CONTACT, contactNameList);
>    if (!contactHandleList.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactHandleList.error().name()
>        << contactHandleList.error().message()
>        << "\n";
>        return;
>    }
>
>    if (contactHandleList.value().isEmpty())
>    {
>        return;
>    }
>
>    uint contactHandle = contactHandleList.value().at(0);
>
>    QDBusReply<QDBusObjectPath> channelPath =
>    conn->RequestChannel("org.freedesktop.Telepathy.Channel.Type.Text",
>                         HANDLE_TYPE_CONTACT, contactHandle, true);
>    if (!channelPath.isValid())
>    {
>        qDebug() << "RequestChannel() returned error:"
>        << channelPath.error().name()
>        << channelPath.error().message()
>        << "\n";
>        return;
>    }
>
>    qDebug() << "text channel is created on:"
>    << "\n\tobject path:" << channelPath.value().path()
>    << "\n";
>
>    // init the channel
>    textChannel = new Channel(conn->service(), channelPath.value().path(),
>                              bus, this);
>    connect(textChannel, SIGNAL(Closed()), this, SLOT(onClose()));
>
>    // init the channel type text
>    textChannelType = new ChannelText(conn->service(),
>                                      channelPath.value().path(),
>                                      bus, this);
>    connect(textChannelType, SIGNAL(LostMessage()),
>            this, SLOT(onLostMessage()));
>    connect(textChannelType,
>            SIGNAL(Received(uint, uint, uint, uint, uint, QString)),
>            this,
>            SLOT(onReceived(uint, uint, uint, uint, uint, QString)));
>    connect(textChannelType, SIGNAL(SendError(uint, uint, uint, QString)),
>            this, SLOT(onSendError(uint, uint, uint, QString)));
>    connect(textChannelType, SIGNAL(Sent(uint, uint, QString)),
>            this, SLOT(onSent(uint, uint, QString)));
>
>    // init the channel interface chatstate
>    textChannelChatStateIface =
>    new ChannelChatStateInterface(conn->service(),
>                                  channelPath.value().path(), bus, this);
>
>    connect(textChannelChatStateIface, SIGNAL(ChatStateChanged(uint, uint)),
>            this, SLOT(onChatStateChanged(uint, uint)));
>
>    QDBusReply<void> setChatStateReply =
>    textChannelChatStateIface->SetChatState(CHANNEL_CHAT_STATE_ACTIVE);
>    if (!setChatStateReply.isValid())
>    {
>        qDebug() << "SetChatState() returned error:"
>        << setChatStateReply.error().name()
>        << setChatStateReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "chat state is set to \"active\"\n";
>    }
>
>    QDBusReply<TextMessageTypeList> messageTypeList =
>    textChannelType->GetMessageTypes();
>    if (!messageTypeList.isValid())
>    {
>        qDebug() << "GetMessageTypes() returned error:"
>        << messageTypeList.error().name()
>        << messageTypeList.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "supported text message types:"
>        << messageTypeList.value()
>        << "\n";
>    }
>
>    QString sendString("hello,world.");
>    QDBusReply<void> sendReply =
>    textChannelType->Send(CHANNEL_TEXT_MESSAGE_TYPE_NORMAL, sendString);
>    if (!sendReply.isValid())
>    {
>        qDebug() << sendReply.error().name()
>        << sendReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "message" << sendString
>        << "is sent.\n";
>    }
>
>    QDBusReply<TextMessageInfoList> pendingMessageList =
>    textChannelType->ListPendingMessages(false);
>    if (!pendingMessageList.isValid())
>    {
>        qDebug() << "ListPendingMessages() returned error:"
>        << pendingMessageList.error().name()
>        << pendingMessageList.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "there are" << pendingMessageList.value().count()
>        << "pending messages:";
>        foreach (TextMessageInfo m, pendingMessageList.value())
>        {
>            qDebug()
>            << "\n\tid:" << m.id
>            << "\n\ttimestamp:" << m.timestamp
>            << "\n\ttype:" << m.type
>            << "\n\tcontact handle:" << m.contactHandle
>            << "\n\tflags:" << m.flags
>            << "\n\tmessage:" << m.message
>            << "\n";
>        }
>    }
>
>    setChatStateReply =
>    textChannelChatStateIface->SetChatState(CHANNEL_CHAT_STATE_INACTIVE);
>    if (!setChatStateReply.isValid())
>    {
>        qDebug() << "SetChatState() returned error:"
>        << setChatStateReply.error().name()
>        << setChatStateReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "chat state is set to \"inactive\"\n";
>    }
>}
>
>void MessageFilter::onLostMessage()
>{
>    qDebug() << "one incomming message has been lost by CM.\n";
>}
>
>void MessageFilter::onReceived(uint id, uint timestamp, uint sender, uint type,
>                               uint flags, const QString& text)
>{
>    qDebug() << "one message has been received:"
>    << "\n\tid:" << id
>    << "\n\ttimestamp:" << timestamp
>    << "\n\tsender:" << sender
>    << "\n\ttype:" << type
>    << "\n\tflags:" << flags
>    << "\n\ttext:" << text
>    << "\n";
>
>    QDBusReply<TextMessageInfoList> pendingMessageList =
>    textChannelType->ListPendingMessages(false);
>    if (!pendingMessageList.isValid())
>    {
>        qDebug() << "ListPendingMessages() returned error:"
>        << pendingMessageList.error().name()
>        << pendingMessageList.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "there are" << pendingMessageList.value().count()
>        << "pending messages before acknowledged:";
>        foreach (TextMessageInfo m, pendingMessageList.value())
>        {
>            qDebug()
>            << "\n\tid:" << m.id
>            << "\n\ttimestamp:" << m.timestamp
>            << "\n\ttype:" << m.type
>            << "\n\tcontact handle:" << m.contactHandle
>            << "\n\tflags:" << m.flags
>            << "\n\tmessage:" << m.message
>            << "\n";
>        }
>    }
>
>    QDBusReply<void> reply =
>    textChannelType->AcknowledgePendingMessages(QList<uint>() << id);
>    if (!reply.isValid())
>    {
>        qDebug() << "AcknowledgePendingMessages() returned error:"
>        << reply.error().name()
>        << reply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "message of id" << id
>        << "has been acknowledged.\n";
>    }
>
>    pendingMessageList = textChannelType->ListPendingMessages(false);
>    if (!pendingMessageList.isValid())
>    {
>        qDebug() << "ListPendingMessages() returned error:"
>        << pendingMessageList.error().name()
>        << pendingMessageList.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "there are" << pendingMessageList.value().count()
>        << "pending messages after acknowledged:";
>        foreach (TextMessageInfo m, pendingMessageList.value())
>        {
>            qDebug()
>            << "\n\tid:" << m.id
>            << "\n\ttimestamp:" << m.timestamp
>            << "\n\ttype:" << m.type
>            << "\n\tcontact handle:" << m.contactHandle
>            << "\n\tflags:" << m.flags
>            << "\n\tmessage:" << m.message
>            << "\n";
>        }
>    }
>
>    QDBusReply<void> sendReply =
>    textChannelType->Send(CHANNEL_TEXT_MESSAGE_TYPE_NORMAL, text);
>    if (!sendReply.isValid())
>    {
>        qDebug() << "Send() returned error:"
>        << sendReply.error().name()
>        << sendReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "message" << text
>        << "is echoed back to sender.\n";
>    }
>}
>
>void MessageFilter::onSendError(uint error, uint timestamp, uint type,
>                                const QString& text)
>{
>    qDebug() << "one message failed to send:"
>    << "\n\terror:" << error
>    << "\n\ttimestamp:" << timestamp
>    << "\n\ttype:" << type
>    << "\n\ttext:" << text
>    << "\n";
>}
>
>void MessageFilter::onSent(uint timestamp,uint type, const QString& text)
>{
>    qDebug() << "one message has been sent:"
>    << "\n\ttimestamp:" << timestamp
>    << "\n\ttype:" << type
>    << "\n\ttext:" << text
>    << "\n";
>}
>
>/**
> * FIXME "org.freedesktop.Telepathy.Error.NotImplemented"
> * "unsupported channel type org.freedesktop.Telepathy.Channel.Type.Tubes"
> */
>void MessageFilter::test_channel_type_tubes()
>{
>    QStringList contactNameList;
>    contactNameList << "izicochang@gmail.com";
>    QDBusReply<QList<uint> > contactHandleList =
>    conn->RequestHandles(HANDLE_TYPE_CONTACT, contactNameList);
>    if (!contactHandleList.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactHandleList.error().name()
>        << contactHandleList.error().message()
>        << "\n";
>        return;
>    }
>
>    if (contactHandleList.value().isEmpty())
>    {
>        return;
>    }
>
>    uint contactHandle = contactHandleList.value().at(0);
>
>    QDBusReply<QDBusObjectPath> channelPath =
>    conn->RequestChannel("org.freedesktop.Telepathy.Channel.Type.Tubes",
>                         HANDLE_TYPE_CONTACT, contactHandle, true);
>    if (!channelPath.isValid())
>    {
>        qDebug() << "RequestChannel() returned error:"
>        << channelPath.error().name()
>        << channelPath.error().message()
>        << "\n";
>        return;
>    }
>
>    qDebug() << "tube channel is opened on:"
>    << "\n\tobject path:" << channelPath.value().path()
>    << "\n";
>}
>
>void MessageFilter::onChatStateChanged(uint contact, uint state)
>{
>    qDebug() << "contact chat state has changed:";
>    qDebug() << "\n\tcontact handle:" << contact;
>
>    QDBusReply<QStringList> contactNameList =
>    conn->InspectHandles(HANDLE_TYPE_CONTACT, QList<uint>() << contact);
>    if (!contactNameList.isValid())
>    {
>        qDebug() << "InspectHandles() returned error:"
>        << contactNameList.error().name()
>        << contactNameList.error().message()
>        << "\n";
>    }
>    else
>    {
>        if (!contactNameList.value().isEmpty())
>        {
>            qDebug() << "\tcontact name:" << contactNameList.value().at(0);
>        }
>    }
>    qDebug() << "state:" << state
>    << "\n";
>}
>
>/*
> * FIXME
> *
> * DTMF -
> * org.freedesktop.DBus.Error.UnknownMethod
> *
> * Password -
> * org.freedesktop.DBus.Error.UnknownMethod
> */
>void MessageFilter::test_channel_type_streamedmedia()
>{
>    // create streamed media channel with this contact
>    QStringList contactNameList;
>    contactNameList << "izico0@gmail.com";
>
>    QDBusReply<QList<uint> > contactHandleList =
>    conn->RequestHandles(HANDLE_TYPE_CONTACT, contactNameList);
>    if (!contactHandleList.isValid())
>    {
>        qDebug() << "RequestHandles() returned error:"
>        << contactHandleList.error().name()
>        << contactHandleList.error().message()
>        << "\n";
>        return;
>    }
>
>    if (contactHandleList.value().isEmpty())
>    {
>        return;
>    }
>
>    smContactHandle = contactHandleList.value().at(0);
>    smContactCapabilies = 0;
>    bool isContactCapableOfStreamedMedia = false;
>
>    /*
>    if we come here too quickly, the capability changed signal of the
>    contact has not been received, so it'll fail to find the streamed
>    media capability of the contact
>    */
>
>    // get the capabilities of the contact
>    QDBusReply<CapabilityInfoList> contactCapabilities =
>    capabilitiesIface->GetCapabilities(contactHandleList.value());
>    if (!contactCapabilities.isValid())
>    {
>        qDebug() << "GetCapabilities() returned error:"
>        << contactCapabilities.error().name()
>        << contactCapabilities.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "capabilities of conact" << contactNameList.at(0) << ":";
>        for (int i = 0; i < contactCapabilities.value().count(); ++i)
>        {
>            qDebug() << "\n\thandle:"
>            << contactCapabilities.value().at(i).contactHandle
>            << "\n\tchannel type:"
>            << contactCapabilities.value().at(i).channelType
>            << "\n\tgeneric flags:"
>            << contactCapabilities.value().at(i).genericFlags
>            << "\n\ttype specific flags:"
>            << contactCapabilities.value().at(i).typeSpecificFlags
>            << "\n";
>
>            if ((contactCapabilities.value().at(i).contactHandle ==
>                 smContactHandle) &&
>                (contactCapabilities.value().at(i).channelType ==
>                 "org.freedesktop.Telepathy.Channel.Type.StreamedMedia"))
>            {
>                isContactCapableOfStreamedMedia = true;
>                smContactCapabilies =
>                contactCapabilities.value().at(i).typeSpecificFlags;
>            }
>        }
>    }
>
>    // confirm that the contact is capable of streamed media
>    if (!isContactCapableOfStreamedMedia)
>    {
>        qDebug() << contactNameList <<"is not capable of streamed media.\n";
>        return;
>    }
>
>    // create the streamed media channel
>    QDBusReply<QDBusObjectPath> channelPath =
>    conn->RequestChannel("org.freedesktop.Telepathy.Channel.Type.StreamedMedia", HANDLE_TYPE_CONTACT, smContactHandle, true);
>    if (!channelPath.isValid())
>    {
>        qDebug() << "RequestChannel() returned error:"
>        << channelPath.error().name()
>        << channelPath.error().message()
>        << "\n";
>        return;
>    }
>
>    qDebug() << "streamed media channel is opened:"
>    << "\n\tchannel path:" << channelPath.value().path()
>    << "\n\tcontact handle:" << smContactHandle
>    << "\n\tcontact name:" << contactNameList.at(0)
>    << "\n";
>
>    setupStreamedMediaChannel(channelPath.value());
>
>    // request streams on this channel
>    StreamTypeList streamTypeList;
>    if (CHANNEL_MEDIA_CAPABILITY_AUDIO &
>        smContactCapabilies)
>    {
>        streamTypeList << STREAM_TYPE_AUDIO;
>    }
>#if 0
>    if (CHANNEL_MEDIA_CAPABILITY_VIDEO &
>        smContactCapabilies)
>    {
>        streamTypeList << STREAM_TYPE_VIDEO;
>    }
>#endif
>
>    QDBusReply<StreamInfoList> streamInfoList =
>    smChannelType->RequestStreams(smContactHandle,
>                                  streamTypeList);
>    if (!streamInfoList.isValid())
>    {
>        qDebug() << "RequestStreams() returned error:"
>        << streamInfoList.error().name()
>        << streamInfoList.error().message()
>        << "\n";
>        return;
>    }
>
>    if (streamInfoList.value().isEmpty())
>    {
>        qDebug() << "RequestStreams() returned error:"
>        << "no streams created.\n";
>        return;
>    }
>
>    qDebug() << "requested streams:";
>    foreach (StreamInfo streamInfo, streamInfoList.value())
>    {
>        qDebug() << "\tidentifier:" << streamInfo.id
>        << "\n\tcontact handle:" << streamInfo.contactHandle
>        << "\n\ttype:" << streamInfo.type
>        << "\n\tstate:" << streamInfo.state
>        << "\n\tdirection:" << streamInfo.direction
>        << "\n\tpending send flags:" << streamInfo.pendingFlags
>        << "\n";
>    }
>
>    QDBusReply<void> requestDirectionReply =
>    smChannelType->RequestStreamDirection(streamInfoList.value().at(0).id, STREAM_DIRECTION_SEND);
>    if (!requestDirectionReply.isValid())
>    {
>        qDebug() << "RequestStreamDirection() returned error:"
>        << requestDirectionReply.error().name()
>        << requestDirectionReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "direction of stream is changed:"
>        << "\n\tid:" << streamInfoList.value().at(0).id
>        << "\n\tdirection:" << STREAM_DIRECTION_SEND
>        << "\n";
>    }
>
>    // list the currently active streams
>    streamInfoList = smChannelType->ListStreams();
>    if (!streamInfoList.isValid())
>    {
>        qDebug() << "ListStreams() returned error:"
>        << streamInfoList.error().name()
>        << streamInfoList.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "currently active streams:";
>        foreach (StreamInfo streamInfo, streamInfoList.value())
>        {
>            qDebug() << "\tidentifier:" << streamInfo.id
>            << "\n\tcontact handle:" << streamInfo.contactHandle
>            << "\n\ttype:" << streamInfo.type
>            << "\n\tstate:" << streamInfo.state
>            << "\n\tdirection:" << streamInfo.direction
>            << "\n\tpending send flags:" << streamInfo.pendingFlags
>            << "\n";
>        }
>    }
>}
>
>void MessageFilter::setupStreamedMediaChannel(const QDBusObjectPath&
>                                              channelPath)
>{
>    // create the streamed media channel interface
>    smChannel =
>    new Channel(conn->service(), channelPath.path(),
>                bus, this);
>
>    connect(smChannel, SIGNAL(Closed()),
>            this, SLOT(onClose()));
>
>    // create the streamed media channel type interface
>    smChannelType =
>    new ChannelStreamedMedia(conn->service(),
>                             channelPath.path(),
>                             bus, this);
>
>    connect(smChannelType,
>            SIGNAL(StreamAdded(uint, uint, uint)),
>            this,
>            SLOT(onStreamAdded(uint, uint, uint)));
>
>    connect(smChannelType,
>            SIGNAL(StreamDirectionChanged(uint, uint, uint)),
>            this,
>            SLOT(onStreamDirectionChanged(uint, uint, uint)));
>
>    connect(smChannelType,
>            SIGNAL(StreamError(uint, uint, QString)),
>            this,
>            SLOT(onStreamError(uint, uint, QString)));
>
>    connect(smChannelType, SIGNAL(StreamRemoved(uint)),
>            this, SLOT(onStreamRemoved(uint)));
>
>    connect(smChannelType,
>            SIGNAL(StreamStateChanged(uint, uint)),
>            this,
>            SLOT(onStreamStateChanged(uint, uint)));
>
>    // create the streamed media group interface
>    smChannelGroupIface =
>    new ChannelGroupInterface(conn->service(),
>                              channelPath.path(), bus, this);
>
>    connect(smChannelGroupIface,
>            SIGNAL(GroupFlagsChanged(uint, uint)),
>            this,
>            SLOT(onGroupFlagsChanged(uint, uint)));
>
>    connect(smChannelGroupIface,
>            SIGNAL(MembersChanged(QString, QList<uint>, QList<uint>, QList<uint>, QList<uint>, uint, uint)),
>            this,
>            SLOT(onMembersChanged(QString, QList<uint>, QList<uint>, QList<uint>, QList<uint>, uint, uint)));
>
>    // create the stream engine channel handler interface
>    smChannelHandler =
>    new ChannelHandler(STREAM_ENGINE_IFACE, STREAM_ENGINE_PATH, bus, this);
>
>    // create the stream engine
>    smStreamEngine =
>    new StreamEngine(STREAM_ENGINE_IFACE, STREAM_ENGINE_PATH, bus, this);
>
>    connect(smStreamEngine,
>            SIGNAL(Receiving(QDBusObjectPath, uint, bool)),
>            this,
>            SLOT(onReceiving(QDBusObjectPath, uint, bool)));
>
>    QDBusReply<void> handleChannelReply =
>    smChannelHandler->HandleChannel(conn->service(),
>                                    QDBusObjectPath(conn->path()),
>                                    "org.freedesktop.Telepathy.Channel.Type.StreamedMedia",
>                                    channelPath, 0, 0);
>    if (!handleChannelReply.isValid())
>    {
>        qDebug() << "HandleChannel() returned error:"
>        << handleChannelReply.error().name()
>        << handleChannelReply.error().message()
>        << "\n";
>    }
>    else
>    {
>        qDebug() << "streamed channel is now handled by stream engine.\n";
>    }
>
>#if 1
>    // These interfaces should be handled by stream engine, but here we connect
>    // the signals to see the work flow of stream engine
>
>    // create streamed media media signalling interface
>    smChannelMediaSignallingIface =
>    new ChannelMediaSignallingInterface(conn->service(),
>                                        channelPath.path(), bus, this);
>
>    connect(smChannelMediaSignallingIface,
>            SIGNAL(NewSessionHandler(QDBusObjectPath, QString)),
>            this,
>            SLOT(onNewSessionHandler(QDBusObjectPath, QString)));
>
>    QDBusReply<SessionHandlerInfoList> sessionHandlerList =
>    smChannelMediaSignallingIface->GetSessionHandlers();
>    if (!sessionHandlerList.isValid())
>    {
>        qDebug() << "GetSessionHandlers() returned error:"
>        << sessionHandlerList.error().name()
>        << sessionHandlerList.error().message()
>        << "\n";
>        return;
>    }
>
>    qDebug() << "currently active session handlers on this channel:";
>    foreach (SessionHandlerInfo info, sessionHandlerList.value())
>    {
>        qDebug() << "\tobject path" << info.path.path()
>        << "\n\ttype:" << info.type
>        << "\n";
>    }
>#endif
>}
>
>void MessageFilter::onStreamAdded(uint id, uint contactHandle, uint type)
>{
>    qDebug() << "new stream has been added:"
>    << "\n\tidentifier:" << id
>    << "\n\tcontact handle:" << contactHandle
>    << "\n\tmedia stream type:" << type
>    << "\n";
>}
>
>void MessageFilter::onStreamDirectionChanged(uint id, uint direction,
>                                             uint pendingFlags)
>{
>    qDebug() << "stream direction or pending flags has been changed:"
>    << "\n\tidentifier" << id
>    << "\n\tdirection:" << direction
>    << "\n\tpending flags:" << pendingFlags
>    << "\n";
>}
>
>void MessageFilter::onStreamError(uint id, uint errno, const QString& message)
>{
>    qDebug() << "stream error has occured:"
>    << "\n\tidentifier:" << id
>    << "\n\terror number:" << errno
>    << "\n\terror message:" << message
>    << "\n";
>}
>
>void MessageFilter::onStreamRemoved(uint id)
>{
>    qDebug() << "one media stream has been removed:"
>    << "\n\tidentifier:" << id
>    << "\n";
>}
>
>void MessageFilter::onStreamStateChanged(uint id, uint state)
>{
>    qDebug() << "stream state has changed:"
>    << "\n\tidentifier:" << id
>    << "\n\tstate:" << state
>    << "\n";
>}
>
>void MessageFilter::onNewSessionHandler(const QDBusObjectPath& path,
>                                        const QString& type)
>{
>    qDebug() << "new session handler object has been created by CM:"
>    << "\n\tobject path:" << path.path()
>    << "\n\ttype:" << type
>    << "\n";
>
>    // create media session handler
>    smSessionHandler
>    = new MediaSessionHandler(conn->service(), path.path(),
>                              bus, this);
>
>    connect(smSessionHandler,
>            SIGNAL(NewStreamHandler(QDBusObjectPath, uint, uint, uint)),
>            this,
>            SLOT(onNewStreamHandler(QDBusObjectPath, uint, uint, uint)));
>}
>
>void MessageFilter::onNewStreamHandler(const QDBusObjectPath& handlerPath,
>                                       uint streamId, uint mediaType,
>                                       uint streamDirection)
>{
>    qDebug() << "new stream handler has been created by CM:"
>    << "\n\tstream handler path:" << handlerPath.path()
>    << "\n\tstream id:" << streamId
>    << "\n\tmedia stream type:" << mediaType
>    << "\n\tstream direction:" << streamDirection
>    << "\n";
>
>    smStreamHandler =
>    new MediaStreamHandler(conn->service(), handlerPath.path(), bus, this);
>
>    connect(smStreamHandler,
>            SIGNAL(AddRemoteCandidate(QString, org::freedesktop::Telepathy::TransportInfoList)),
>            this,
>            SLOT(onAddRemoteCandidate(QString, org::freedesktop::Telepathy::TransportInfoList)));
>
>    connect(smStreamHandler, SIGNAL(Close()),
>            this, SLOT(onCloseStream()));
>
>    connect(smStreamHandler, SIGNAL(RemoveRemoteCandidate(QString)),
>            this, SLOT(onRemoveRemoteCandidate(QString)));
>
>    connect(smStreamHandler,
>            SIGNAL(SetActiveCandidatePair(QString, QString)),
>            this,
>            SLOT(onSetActiveCandidatePair(QString, QString)));
>
>    connect(smStreamHandler,
>            SIGNAL(SetRemoteCandidateList(org::freedesktop::Telepathy::CandidateInfoList)),
>            this,
>            SLOT(onSetRemoteCandidateList(org::freedesktop::Telepathy::CandidateInfoList)));
>
>    connect(smStreamHandler,
>            SIGNAL(SetRemoteCodecs(org::freedesktop::Telepathy::CodecInfoList)),
>            this,
>            SLOT(onSetRemoteCodecs(org::freedesktop::Telepathy::CodecInfoList)));
>
>    connect(smStreamHandler,
>            SIGNAL(SetStreamPlaying(bool)),
>            this,
>            SLOT(onSetStreamPlaying(bool)));
>
>    connect(smStreamHandler,
>            SIGNAL(SetStreamSending(bool)),
>            this,
>            SLOT(onSetStreamSending(bool)));
>
>    connect(smStreamHandler,
>            SIGNAL(StartTelephonyEvent(uchar)),
>            this,
>            SLOT(onStartTelephonyEvent(uchar)));
>
>    connect(smStreamHandler,
>            SIGNAL(StopTelephonyEvent()),
>            this,
>            SLOT(onStopTelephonyEvent()));
>}
>
>void MessageFilter::onAddRemoteCandidate(const QString& candidateId, const org::freedesktop::Telepathy::TransportInfoList& transportList)
>{
>    qDebug() << "new remote candidate has been informed:"
>    << "\n\tcandidate id:" << candidateId
>    << "\n\ttransports:";
>
>    foreach (TransportInfo t, transportList)
>    {
>        qDebug() << "\t\tcompoment number:" << t.number
>        << "\n\t\tIP address:" << t.ipAddr
>        << "\n\t\tIP port:" << t.port
>        << "\n\t\tbase protocol:" << t.baseProto
>        << "\n\t\tprotocol subtype:" << t.protoSubType
>        << "\n\t\tprotocol profile:" << t.protoProfile
>        << "\n\t\tpreference value:" << t.preference
>        << "\n\t\ttype:" << t.type
>        << "\n\t\tusername:" << t.username
>        << "\n\t\tpassword:" << t.password
>        << "\n";
>    }
>}
>
>void MessageFilter::onCloseStream()
>{
>    qDebug() << "one stream has been informed to be close by CM.\n";
>}
>
>void MessageFilter::onRemoveRemoteCandidate(const QString& candidateId)
>{
>    qDebug() << "remote candidate" << candidateId
>    << "has been removed.\n";
>}
>
>void MessageFilter::onSetActiveCandidatePair(const QString& nativeCandidateId,
>                                             const QString& remoteCandidateId)
>{
>    qDebug() << "a valid candidate pair"
>    << "(" << nativeCandidateId << ":" << remoteCandidateId << ")"
>    << "has been discovered by the remote end and streaming is in progress.\n";
>}
>
>void MessageFilter::onSetRemoteCandidateList(const org::freedesktop::Telepathy::CandidateInfoList& remoteCandidateList)
>{
>    qDebug() << "all the available remote candidates has been informed by CM:";
>    foreach (CandidateInfo c, remoteCandidateList)
>    {
>        qDebug() << "\tcandidate id:" << c.id
>        << "\n\ttransports:";
>
>        foreach (TransportInfo t, c.transportList)
>        {
>            qDebug() << "\t\tcompoment number:" << t.number
>            << "\n\t\tIP address:" << t.ipAddr
>            << "\n\t\tIP port:" << t.port
>            << "\n\t\tbase protocol:" << t.baseProto
>            << "\n\t\tprotocol subtype:" << t.protoSubType
>            << "\n\t\tprotocol profile:" << t.protoProfile
>            << "\n\t\tpreference value:" << t.preference
>            << "\n\t\ttype:" << t.type
>            << "\n\t\tusername:" << t.username
>            << "\n\t\tpassword:" << t.password
>            << "\n";
>        }
>    }
>}
>
>void MessageFilter::onSetRemoteCodecs(const org::freedesktop::Telepathy::CodecInfoList& codecList)
>{
>    qDebug() << "supported codecs by remote end has been informed by CM:";
>    foreach (CodecInfo c, codecList)
>    {
>        qDebug() << "\tid:" << c.id
>        << "\n\tname:" << c.name
>        << "\n\tmedia type:" << c.mediaType
>        << "\n\tclock rate:" << c.clockRate
>        << "\n\tnumber of supported channels:" << c.supportedChannels
>        << "\n\toptional parameters:" << c.parameters
>        << "\n";
>    }
>}
>
>void MessageFilter::onSetStreamPlaying(bool playing)
>{
>    qDebug() << "stream playing state has been informed by CM:"
>    << (playing ? "playing" : "stopped") << "\n";
>}
>
>void MessageFilter::onSetStreamSending(bool sending)
>{
>    qDebug() << "stream sending state has been informed by CM:"
>    << (sending ? "sending" : "stopped") << "\n";
>}
>
>void MessageFilter::onStartTelephonyEvent(uchar event)
>{
>    qDebug() << "CM has informed client to start telephony event"
>    << event << "\n";
>}
>
>void MessageFilter::onStopTelephonyEvent()
>{
>    qDebug() << "CM has informed client to stop telephony event.\n";
>}
>
>void MessageFilter::onReceiving(const QDBusObjectPath& channelPath,
>                                uint streamId, bool state)
>{
>    qDebug() << "stream engine has been receiving stream on:"
>    << "\n\tobject path:" << channelPath.path()
>    << "\n\tstream id:" << streamId
>    << "\n\tstream state:" << state
>    << "\n";
>}

Actions: View

Attachments on bug 11244: 10270 | 10287 | 10288 | 10289 | 10290 | 10291 | 10292

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.