telephony-service

Merge lp:~phablet-team/telephony-service/async_send_message into lp:telephony-service

async_send_message
Merge into trunk

Proposed by Gustavo Pichorim Boiko on 2016-05-24

Status:	Superseded
Proposed branch:	lp:~phablet-team/telephony-service/async_send_message
Merge into:	lp:telephony-service
Prerequisite:	lp:~phablet-team/telephony-service/group-chat
Diff against target:	3029 lines (+1526/-851) 26 files modified .bzrignore (+2/-0) Ubuntu/Telephony/components.cpp (+1/-1) handler/CMakeLists.txt (+5/-0) handler/ChatStartingJob.xml (+31/-0) handler/Handler.xml (+2/-1) handler/MessageSendingJob.xml (+36/-0) handler/chatstartingjob.cpp (+171/-0) handler/chatstartingjob.h (+69/-0) handler/handlerdbus.cpp (+22/-2) handler/handlerdbus.h (+7/-2) handler/main.cpp (+1/-3) handler/messagejob.cpp (+96/-0) handler/messagejob.h (+75/-0) handler/messagesendingjob.cpp (+390/-0) handler/messagesendingjob.h (+90/-0) handler/texthandler.cpp (+11/-438) handler/texthandler.h (+4/-16) libtelephonyservice/chatentry.cpp (+253/-78) libtelephonyservice/chatentry.h (+51/-17) libtelephonyservice/chatmanager.cpp (+132/-198) libtelephonyservice/chatmanager.h (+9/-22) libtelephonyservice/telepathyhelper.cpp (+6/-3) libtelephonyservice/telepathyhelper.h (+2/-2) tests/handler/HandlerTest.cpp (+40/-17) tests/libtelephonyservice/ChatEntryTest.cpp (+2/-0) tests/libtelephonyservice/ChatManagerTest.cpp (+18/-51)
To merge this branch:	bzr merge lp:~phablet-team/telephony-service/async_send_message
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
system-apps-ci-bot	continuous-integration		Approve on 2016-06-15
PS Jenkins bot	continuous-integration		Pending
Ubuntu Phablet Team		2016-05-24	Pending
Review via email: mp+295529@code.launchpad.net

This proposal supersedes a proposal from 2016-05-24.

This proposal has been superseded by a proposal from 2016-10-13.

Commit message

Make it possible to send messages asynchronously and still report the results.

Description of the change

Make it possible to send messages asynchronously and still report the results.

Revision history for this message

system-apps-ci-bot (system-apps-ci-bot) wrote on 2016-06-07:

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/2/rebuild

review: Needs Fixing (continuous-integration)

lp:~phablet-team/telephony-service/async_send_message updated on 2016-06-09

1218. By Gustavo Pichorim Boiko on 2016-06-09: Set also the threadId in properties so that the channel gets
created correctly.

Revision history for this message

system-apps-ci-bot (system-apps-ci-bot) wrote on 2016-06-09:

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/9/rebuild

review: Needs Fixing (continuous-integration)

lp:~phablet-team/telephony-service/async_send_message updated on 2016-06-14

1219. By Gustavo Pichorim Boiko on 2016-06-14: If no accountId is given, match channels from all accounts.
1220. By Gustavo Pichorim Boiko on 2016-06-14: Only set the accountId in properties if we are trying to match a chatroom

Revision history for this message

system-apps-ci-bot (system-apps-ci-bot) wrote on 2016-06-14:

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/17/rebuild

review: Needs Fixing (continuous-integration)

lp:~phablet-team/telephony-service/async_send_message updated on 2016-06-14

1221. By Gustavo Pichorim Boiko on 2016-06-14: We don't need to verify accounts here, it is done in a later stage if needed

Revision history for this message

system-apps-ci-bot (system-apps-ci-bot) wrote on 2016-06-14:

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/18/rebuild

review: Needs Fixing (continuous-integration)

lp:~phablet-team/telephony-service/async_send_message updated on 2016-06-15

1222. By Gustavo Pichorim Boiko on 2016-06-15: merge parent

Revision history for this message

system-apps-ci-bot (system-apps-ci-bot) wrote on 2016-06-15:

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/22/rebuild

review: Needs Fixing (continuous-integration)

lp:~phablet-team/telephony-service/async_send_message updated on 2016-06-15

1223. By Gustavo Pichorim Boiko on 2016-06-15: Do not delete the interface classes. They are destroyed together with the channel itself.

Revision history for this message

system-apps-ci-bot (system-apps-ci-bot) wrote on 2016-06-15:

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-telephony-service-ci/25/rebuild

review: Approve (continuous-integration)

lp:~phablet-team/telephony-service/async_send_message updated on 2016-10-21

1225. By Gustavo Pichorim Boiko on 2016-07-06: Merge parent
1226. By Gustavo Pichorim Boiko on 2016-07-07: Expose chatstarting to dbus
1227. By Gustavo Pichorim Boiko on 2016-07-07: Make startChat return the job's objectPath
1228. By Gustavo Pichorim Boiko on 2016-07-08: Remove wrongly committed changelog.
1229. By Tiago Salem Herrmann on 2016-07-11: merge parent branch
1230. By Tiago Salem Herrmann on 2016-07-11: merge parent branch
1231. By Tiago Salem Herrmann on 2016-07-11: merge parent branch
1232. By Gustavo Pichorim Boiko on 2016-07-13: Handle channel invalidation.
1233. By Tiago Salem Herrmann on 2016-08-05: merge parent branch
1234. By Tiago Salem Herrmann on 2016-08-05: merge parent branch
1235. By Tiago Salem Herrmann on 2016-08-11: merge parent branch
1236. By Tiago Salem Herrmann on 2016-08-12: merge parent branch
1237. By Tiago Salem Herrmann on 2016-08-12: fix handler test
1238. By Tiago Salem Herrmann on 2016-08-16: merge parent branch
1239. By Tiago Salem Herrmann on 2016-10-06: merge parent branch
1240. By Gustavo Pichorim Boiko on 2016-10-21: Add a FIXME on a disabled test
1241. By Gustavo Pichorim Boiko on 2016-10-21: Merge parent

Unmerged revisions

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Ubuntu Phablet Team

 === modified file '.bzrignore'
 --- .bzrignore	2015-07-02 03:35:20 +0000
 +++ .bzrignore	2016-10-06 19:34:37 +0000
@@ -30,6 +30,7 @@
  approver/*.service
  approver/approveradaptor.*
  handler/handleradaptor.*
++handler/messagesendingjobadaptor.*
  indicator/*.desktop
  indicator/*.service
  indicator/NotificationsInterface.*
@@ -57,3 +58,4 @@
  tests/libtelephonyservice/GreeterContactsTestExe
  tests/libtelephonyservice/GreeterContactsTestServerExe
  tests/libtelephonyservice/*Mock
++tests/indicator/NotificationsInterface.*
 === modified file 'Ubuntu/Telephony/components.cpp'
 --- Ubuntu/Telephony/components.cpp	2015-11-19 12:59:31 +0000
 +++ Ubuntu/Telephony/components.cpp	2016-10-06 19:34:37 +0000
@@ -75,12 +75,12 @@
      // @uri Telephony
      qmlRegisterUncreatableType<TelepathyHelper>(uri, 0, 1, "TelepathyHelper", "This is a singleton helper class");
      qmlRegisterUncreatableType<CallEntry>(uri, 0, 1, "CallEntry", "Objects of this type are created in CallManager and made available to QML for usage");
--    qmlRegisterUncreatableType<ChatEntry>(uri, 0, 1, "ChatEntry", "Objects of this type are created in ChatManager and made available to QML for usage");
      qmlRegisterUncreatableType<ContactChatState>(uri, 0, 1, "ContactChatState", "Objects of this type are created in ChatEntry and made available to QML");
      qmlRegisterUncreatableType<AudioOutput>(uri, 0, 1, "AudioOutput", "Objects of this type are created in CallEntry and made available to QML for usage");
      qmlRegisterUncreatableType<AccountEntry>(uri, 0, 1, "AccountEntry", "Objects of this type are created in TelepathyHelper and made available to QML");
      qmlRegisterUncreatableType<USSDManager>(uri, 0, 1, "USSDManager", "Objects of this type are created in AccountEntry and made available to QML");
      qmlRegisterUncreatableType<Protocol>(uri, 0, 1, "ProtocolManager", "Objects of this type are created in ProtocolManager and made available to QML");
++    qmlRegisterType<ChatEntry>(uri, 0, 1, "ChatEntry");
      qmlRegisterType<ContactWatcher>(uri, 0, 1, "ContactWatcher");
      qmlRegisterType<PresenceRequest>(uri, 0, 1, "PresenceRequest");
      qmlRegisterType<PhoneUtils>(uri, 0, 1, "PhoneUtils");
 === modified file 'handler/CMakeLists.txt'
 --- handler/CMakeLists.txt	2016-03-18 19:02:50 +0000
 +++ handler/CMakeLists.txt	2016-10-06 19:34:37 +0000
@@ -1,13 +1,18 @@
  set(qt_SRCS
      callhandler.cpp
++    chatstartingjob.cpp
      handler.cpp
      handlerdbus.cpp
++    messagejob.cpp
++    messagesendingjob.cpp
      texthandler.cpp
+     )
  set(handler_SRCS main.cpp ${qt_SRCS})
  qt5_add_dbus_adaptor(handler_SRCS Handler.xml handler/handlerdbus.h HandlerDBus)
++qt5_add_dbus_adaptor(handler_SRCS ChatStartingJob.xml handler/chatstartingjob.h ChatStartingJob)
++qt5_add_dbus_adaptor(handler_SRCS MessageSendingJob.xml handler/messagesendingjob.h MessageSendingJob)
  include_directories(
      ${TP_QT5_INCLUDE_DIRS}
 === added file 'handler/ChatStartingJob.xml'
 --- handler/ChatStartingJob.xml	1970-01-01 00:00:00 +0000
 +++ handler/ChatStartingJob.xml	2016-10-06 19:34:37 +0000
@@ -0,0 +1,31 @@
++<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
++<node xmlns:dox="http://www.ayatana.org/dbus/dox.dtd">
++    <dox:d><![CDATA[
++      @mainpage
++
++      An interface to the asynchronous chat creation job
++    ]]></dox:d>
++    <interface name="com.canonical.TelephonyServiceHandler.ChatStartingJob" xmlns:dox="http://www.ayatana.org/dbus/dox.dtd">
++        <dox:d>
++          An interface to the phone handler helper application.
++        </dox:d>
++        <property name="accountId" type="s" access="read"/>
++        <property name="channelObjectPath" type="s" access="read"/>
++        <property name="objectPath" type="s" access="read"/>
++        <property name="properties" type="a{sv}" access="read">
++          <annotation name="org.qtproject.QtDBus.QtTypeName" value="QVariantMap"/>
++        </property>
++        <property name="status" type="i" access="read"/>
++        <property name="isFinished" type="b" access="read"/>
++        <signal name="channelObjectPathChanged">
++        </signal>
++        <signal name="statusChanged">
++        </signal>
++        <signal name="isFinishedChanged">
++        </signal>
++        <signal name="finished">
++        </signal>
++        <method name="startJob">
++        </method>
++   </interface>
++</node>
 === modified file 'handler/Handler.xml'
 --- handler/Handler.xml	2016-10-06 19:34:36 +0000
 +++ handler/Handler.xml	2016-10-06 19:34:37 +0000
@@ -18,10 +18,10 @@
              <arg name="accountId" type="s" direction="in"/>
              <arg name="message" type="s" direction="in"/>
              <arg name="attachments" type="a(sss)" direction="in"/>
--            <arg name="accountIdOut" type="s" direction="out"/>
              <annotation name="org.qtproject.QtDBus.QtTypeName.In2" value="AttachmentList"/>
              <arg name="properties" type="a{sv}" direction="in"/>
              <annotation name="org.qtproject.QtDBus.QtTypeName.In3" value="QVariantMap"/>
++            <arg name="objectPath" type="s" direction="out"/>
          </method>
          <method name="AcknowledgeMessages">
              <dox:d><![CDATA[
@@ -37,6 +37,7 @@
              <arg name="accountId" type="s" direction="in"/>
              <arg name="properties" type="a{sv}" direction="in"/>
              <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
++            <arg name="objectPath" type="s" direction="out"/>
          </method>
          <method name="AcknowledgeAllMessages">
              <dox:d><![CDATA[
 === added file 'handler/MessageSendingJob.xml'
 --- handler/MessageSendingJob.xml	1970-01-01 00:00:00 +0000
 +++ handler/MessageSendingJob.xml	2016-10-06 19:34:37 +0000
@@ -0,0 +1,36 @@
++<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
++<node xmlns:dox="http://www.ayatana.org/dbus/dox.dtd">
++    <dox:d><![CDATA[
++      @mainpage
++
++      An interface to the asynchronous message sending job
++    ]]></dox:d>
++    <interface name="com.canonical.TelephonyServiceHandler.MessageSendingJob" xmlns:dox="http://www.ayatana.org/dbus/dox.dtd">
++        <dox:d>
++          An interface to the phone handler helper application.
++        </dox:d>
++        <property name="accountId" type="s" access="read"/>
++        <property name="messageId" type="s" access="read"/>
++        <property name="channelObjectPath" type="s" access="read"/>
++        <property name="objectPath" type="s" access="read"/>
++        <property name="properties" type="a{sv}" access="read">
++          <annotation name="org.qtproject.QtDBus.QtTypeName" value="QVariantMap"/>
++        </property>
++        <property name="status" type="i" access="read"/>
++        <property name="isFinished" type="b" access="read"/>
++        <signal name="accountIdChanged">
++        </signal>
++        <signal name="messageIdChanged">
++        </signal>
++        <signal name="channelObjectPathChanged">
++        </signal>
++        <signal name="statusChanged">
++        </signal>
++        <signal name="isFinishedChanged">
++        </signal>
++        <signal name="finished">
++        </signal>
++        <method name="startJob">
++        </method>
++   </interface>
++</node>
 === added file 'handler/chatstartingjob.cpp'
 --- handler/chatstartingjob.cpp	1970-01-01 00:00:00 +0000
 +++ handler/chatstartingjob.cpp	2016-10-06 19:34:37 +0000
@@ -0,0 +1,171 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * Authors:
++ *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
++ *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
++ *
++ * This file is part of telephony-service.
++ *
++ * telephony-service is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * telephony-service is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "chatstartingjob.h"
++#include "chatstartingjobadaptor.h"
++#include "telepathyhelper.h"
++#include "texthandler.h"
++#include <TelepathyQt/PendingChannelRequest>
++
++ChatStartingJob::ChatStartingJob(TextHandler *textHandler, const QString &accountId, const QVariantMap &properties)
++: MessageJob(new ChatStartingJobAdaptor(this), textHandler), mTextHandler(textHandler), mAccountId(accountId), mProperties(properties)
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    connect(this, &ChatStartingJob::textChannelChanged, &ChatStartingJob::channelObjectPathChanged);
++}
++
++QString ChatStartingJob::accountId()
++{
++    return mAccountId;
++}
++
++void ChatStartingJob::startJob()
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    setStatus(Running);
++
++    // Request the contact to start chatting to
++    // FIXME: make it possible to select which account to use, for now, pick the first one
++    AccountEntry *account = TelepathyHelper::instance()->accountForId(mAccountId);
++    if (!account || !account->connected()) {
++        qCritical() << "The selected account does not have a connection. AccountId:" << mAccountId;
++        setStatus(Failed);
++        scheduleDeletion();
++        return;
++    }
++
++    switch(mProperties["chatType"].toUInt()) {
++    case Tp::HandleTypeNone:
++    case Tp::HandleTypeContact:
++        startTextChat(account->account(), mProperties);
++        break;
++    case Tp::HandleTypeRoom:
++        startTextChatRoom(account->account(), mProperties);
++        break;
++    default:
++        qCritical() << "Chat type not supported";
++    }
++}
++
++void ChatStartingJob::startTextChat(const Tp::AccountPtr &account, const QVariantMap &properties)
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    Tp::PendingChannelRequest *op = NULL;
++    QStringList participants = properties["participantIds"].toStringList();
++    switch(participants.size()) {
++    case 0:
++        qCritical() << "Error: No participant list provided";
++        break;
++    case 1:
++        op = account->ensureTextChat(participants[0], QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
++        break;
++    default:
++        op = account->createConferenceTextChat(QList<Tp::ChannelPtr>(), participants, QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
++    }
++
++    if (!op) {
++        setStatus(Failed);
++        scheduleDeletion();
++        return;
++    }
++
++    connect(op, &Tp::PendingOperation::finished,
++            this, &ChatStartingJob::onChannelRequestFinished);
++}
++
++void ChatStartingJob::startTextChatRoom(const Tp::AccountPtr &account, const QVariantMap &properties)
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    QString roomName = properties["threadId"].toString();
++
++    // these properties are still not used
++    //QString server = properties["Server"].toString();
++    //QString creator = properties["Creator"].toString();
++
++    QVariantMap request;
++    Tp::PendingChannelRequest *op = NULL;
++    if (roomName.isEmpty()) {
++        request.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"), TP_QT_IFACE_CHANNEL_TYPE_TEXT);
++        request.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType"), (uint) Tp::HandleTypeNone);
++        QStringList initialInviteeIDs = properties["participantIds"].toStringList();
++        if (!initialInviteeIDs.isEmpty()) {
++            request.insert(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeIDs"), initialInviteeIDs);
++        }
++        // the presence of RoomName indicates the returned channel must be of type Room
++        request.insert(TP_QT_IFACE_CHANNEL_INTERFACE_ROOM + QLatin1String(".RoomName"), QString());
++
++        // TODO use the instance returned by createChanne() to track when the channel creation is finished
++        op = account->createChannel(request, QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
++    } else {
++        op = account->ensureTextChatroom(roomName, QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler", request);
++    }
++
++    if (!op) {
++        setStatus(Failed);
++        scheduleDeletion();
++        return;
++    }
++    connect(op, &Tp::PendingOperation::finished,
++            this, &ChatStartingJob::onChannelRequestFinished);
++}
++
++Tp::TextChannelPtr ChatStartingJob::textChannel() const
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    return mTextChannel;
++}
++
++QString ChatStartingJob::channelObjectPath() const
++{
++    if (mTextChannel.isNull()) {
++        return QString::null;
++    }
++    return mTextChannel->objectPath();
++}
++
++void ChatStartingJob::setTextChannel(Tp::TextChannelPtr channel)
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    mTextChannel = channel;
++    Q_EMIT textChannelChanged();
++}
++
++void ChatStartingJob::onChannelRequestFinished(Tp::PendingOperation *op)
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    Status status;
++    if (op->isError()) {
++        status = Failed;
++    } else {
++        Tp::PendingChannelRequest *channelRequest = qobject_cast<Tp::PendingChannelRequest*>(op);
++        if (!channelRequest) {
++            status = Failed;
++        } else {
++            setTextChannel(Tp::TextChannelPtr::dynamicCast(channelRequest->channelRequest()->channel()));
++            status = Finished;
++        }
++    }
++
++    setStatus(status);
++    scheduleDeletion();
++}
++
 === added file 'handler/chatstartingjob.h'
 --- handler/chatstartingjob.h	1970-01-01 00:00:00 +0000
 +++ handler/chatstartingjob.h	2016-10-06 19:34:37 +0000
@@ -0,0 +1,69 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * Authors:
++ *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
++ *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
++ *
++ * This file is part of telephony-service.
++ *
++ * telephony-service is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * telephony-service is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef CHATSTARTINGJOB_H
++#define CHATSTARTINGJOB_H
++
++#include <QObject>
++#include "messagejob.h"
++#include <TelepathyQt/Types>
++#include <TelepathyQt/PendingOperation>
++
++class TextHandler;
++
++class ChatStartingJob : public MessageJob
++{
++    Q_OBJECT
++    Q_PROPERTY(QString accountId READ accountId CONSTANT)
++    Q_PROPERTY(Tp::TextChannelPtr textChannel READ textChannel NOTIFY textChannelChanged)
++    Q_PROPERTY(QString channelObjectPath READ channelObjectPath NOTIFY channelObjectPathChanged)
++public:
++    ChatStartingJob(TextHandler *textHandler, const QString &accountId, const QVariantMap &properties);
++
++    QString accountId();
++    Tp::TextChannelPtr textChannel() const;
++    QString channelObjectPath() const;
++
++public Q_SLOTS:
++    virtual void startJob();
++
++Q_SIGNALS:
++    void textChannelChanged();
++    void channelObjectPathChanged();
++
++
++protected Q_SLOTS:
++    void startTextChat(const Tp::AccountPtr &account, const QVariantMap &properties);
++    void startTextChatRoom(const Tp::AccountPtr &account, const QVariantMap &properties);
++    void setTextChannel(Tp::TextChannelPtr channel);
++
++    void onChannelRequestFinished(Tp::PendingOperation *op);
++
++private:
++    TextHandler *mTextHandler;
++    QString mAccountId;
++    QVariantMap mProperties;
++    Tp::TextChannelPtr mTextChannel;
++
++};
++
++#endif // CHATSTARTINGJOB_H
 === modified file 'handler/handlerdbus.cpp'
 --- handler/handlerdbus.cpp	2016-10-06 19:34:36 +0000
 +++ handler/handlerdbus.cpp	2016-10-06 19:34:37 +0000
@@ -81,6 +81,26 @@
      Q_EMIT CallIndicatorVisibleChanged(visible);
+ }
++QString HandlerDBus::registerObject(QObject *object, const QString &path)
++{
++    QString fullPath = QString("%1/%2").arg(DBUS_OBJECT_PATH, path);
++    if (QDBusConnection::sessionBus().registerObject(fullPath, object)) {
++        return fullPath;
++    }
++    return QString::null;
++}
++
++void HandlerDBus::unregisterObject(const QString &path)
++{
++    QDBusConnection::sessionBus().unregisterObject(path);
++}
++
++HandlerDBus *HandlerDBus::instance()
++{
++    static HandlerDBus *self = new HandlerDBus;
++    return self;
++}
++
  bool HandlerDBus::connectToBus()
+ {
      bool ok = QDBusConnection::sessionBus().registerService(DBUS_SERVICE);
@@ -103,9 +123,9 @@
      TextHandler::instance()->acknowledgeMessages(messages);
+ }
--void HandlerDBus::StartChat(const QString &accountId, const QVariantMap &properties)
++QString HandlerDBus::StartChat(const QString &accountId, const QVariantMap &properties)
+ {
--    TextHandler::instance()->startChat(accountId, properties);
++    return TextHandler::instance()->startChat(accountId, properties);
+ }
  void HandlerDBus::AcknowledgeAllMessages(const QVariantMap &properties)
 === modified file 'handler/handlerdbus.h'
 --- handler/handlerdbus.h	2016-10-06 19:34:36 +0000
 +++ handler/handlerdbus.h	2016-10-06 19:34:37 +0000
@@ -30,7 +30,7 @@
  #include "dbustypes.h"
  /**
-- * DBus interface for the phone approver
++ * DBus interface for the phone handler
   */
  class HandlerDBus : public QObject, protected QDBusContext
+ {
@@ -51,13 +51,18 @@
      bool callIndicatorVisible() const;
      void setCallIndicatorVisible(bool visible);
++    QString registerObject(QObject *object, const QString &path);
++    void unregisterObject(const QString &path);
++
++    static HandlerDBus *instance();
++
  public Q_SLOTS:
      bool connectToBus();
      // messages related
      QString SendMessage(const QString &accountId, const QString &message, const AttachmentList &attachments, const QVariantMap &properties);
      Q_NOREPLY void AcknowledgeMessages(const QVariantList &messages);
--    Q_NOREPLY void StartChat(const QString &accountId, const QVariantMap &properties);
++    QString StartChat(const QString &accountId, const QVariantMap &properties);
      Q_NOREPLY void AcknowledgeAllMessages(const QVariantMap &properties);
      // call related
 === modified file 'handler/main.cpp'
 --- handler/main.cpp	2016-03-18 19:02:50 +0000
 +++ handler/main.cpp	2016-10-06 19:34:37 +0000
@@ -54,10 +54,8 @@
      QObject::connect(handler, SIGNAL(textChannelAvailable(Tp::TextChannelPtr)),
                       TextHandler::instance(), SLOT(onTextChannelAvailable(Tp::TextChannelPtr)));
--    HandlerDBus dbus;
--
      QObject::connect(TelepathyHelper::instance(), SIGNAL(setupReady()),
--                     &dbus, SLOT(connectToBus()));
++                     HandlerDBus::instance(), SLOT(connectToBus()));
      return app.exec();
+ }
 === added file 'handler/messagejob.cpp'
 --- handler/messagejob.cpp	1970-01-01 00:00:00 +0000
 +++ handler/messagejob.cpp	2016-10-06 19:34:37 +0000
@@ -0,0 +1,96 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * Authors:
++ *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
++ *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
++ *
++ * This file is part of telephony-service.
++ *
++ * telephony-service is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * telephony-service is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "messagejob.h"
++#include "handlerdbus.h"
++#include <QCoreApplication>
++#include <QTime>
++#include <QTimer>
++#include <QDebug>
++
++MessageJob::MessageJob(QDBusAbstractAdaptor *adaptor, QObject *parent)
++: QObject(parent), mStatus(Pending), mFinished(false), mAdaptor(adaptor)
++{
++    static ulong count = 0;
++    // just to avoid overflowing
++    if (count == ULONG_MAX) {
++        count = 0;
++    }
++    mObjectPath = HandlerDBus::instance()->registerObject(this, QString("messagejob%1").arg(count++));
++}
++
++MessageJob::~MessageJob()
++{
++    HandlerDBus::instance()->unregisterObject(mObjectPath);
++}
++
++MessageJob::Status MessageJob::status() const
++{
++    return mStatus;
++}
++
++bool MessageJob::isFinished() const
++{
++    return mFinished;
++}
++
++QString MessageJob::objectPath() const
++{
++    return mObjectPath;
++}
++
++void MessageJob::waitForFinished(int timeout)
++{
++    QTime time;
++    time.start();
++    while (!mFinished && time.elapsed() < timeout) {
++        QCoreApplication::processEvents();
++    }
++}
++
++void MessageJob::startJob()
++{
++    // the default implementation just sets the status to Finished
++    setStatus(Finished);
++}
++
++void MessageJob::setStatus(MessageJob::Status status)
++{
++    mStatus = status;
++    Q_EMIT statusChanged();
++
++    // update the isFinished property too
++    bool wasFinished = mFinished;
++    mFinished = mStatus == Finished || mStatus == Failed;
++    if (wasFinished != mFinished) {
++        Q_EMIT isFinishedChanged();
++    }
++    if (mFinished) {
++        Q_EMIT finished();
++    }
++}
++
++void MessageJob::scheduleDeletion(int timeout)
++{
++    QTimer::singleShot(timeout, this, &QObject::deleteLater);
++}
++
 === added file 'handler/messagejob.h'
 --- handler/messagejob.h	1970-01-01 00:00:00 +0000
 +++ handler/messagejob.h	2016-10-06 19:34:37 +0000
@@ -0,0 +1,75 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * Authors:
++ *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
++ *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
++ *
++ * This file is part of telephony-service.
++ *
++ * telephony-service is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * telephony-service is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef MESSAGEJOB_H
++#define MESSAGEJOB_H
++
++#include <QObject>
++#include <QDBusAbstractAdaptor>
++#include <QDBusContext>
++
++class MessageJob : public QObject, protected QDBusContext
++{
++    Q_OBJECT
++    Q_PROPERTY(int status READ status NOTIFY statusChanged)
++    Q_PROPERTY(bool isFinished READ isFinished NOTIFY isFinishedChanged)
++    Q_PROPERTY(QString objectPath READ objectPath CONSTANT)
++    Q_ENUMS(Status)
++public:
++    enum Status {
++        Pending,
++        Initialising,
++        Running,
++        Finished,
++        Failed
++    };
++
++    explicit MessageJob(QDBusAbstractAdaptor *adaptor, QObject *parent = 0);
++    virtual ~MessageJob();
++
++    Status status() const;
++    bool isFinished() const;
++
++    QString objectPath() const;
++
++    void waitForFinished(int timeout = 10000);
++
++Q_SIGNALS:
++    void statusChanged();
++    void isFinishedChanged();
++    void finished();
++
++public Q_SLOTS:
++    virtual void startJob();
++
++protected:
++    void setStatus(Status status);
++    void scheduleDeletion(int timeout = 60000);
++
++private:
++    Status mStatus;
++    bool mFinished;
++    QString mObjectPath;
++    QDBusAbstractAdaptor *mAdaptor;
++};
++
++#endif // MESSAGEJOB_H
 === added file 'handler/messagesendingjob.cpp'
 --- handler/messagesendingjob.cpp	1970-01-01 00:00:00 +0000
 +++ handler/messagesendingjob.cpp	2016-10-06 19:34:37 +0000
@@ -0,0 +1,390 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * Authors:
++ *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
++ *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
++ *
++ * This file is part of telephony-service.
++ *
++ * telephony-service is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * telephony-service is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "accountentry.h"
++#include "chatstartingjob.h"
++#include "messagesendingjob.h"
++#include "messagesendingjobadaptor.h"
++#include "telepathyhelper.h"
++#include "texthandler.h"
++#include <TelepathyQt/ContactManager>
++#include <TelepathyQt/PendingContacts>
++#include <QImage>
++
++#define SMIL_TEXT_REGION "<region id=\"Text\" width=\"100%\" height=\"100%\" fit=\"scroll\" />"
++#define SMIL_IMAGE_REGION "<region id=\"Image\" width=\"100%\" height=\"100%\" fit=\"meet\" />"
++#define SMIL_VIDEO_REGION "<region id=\"Video\" width=\"100%\" height=\"100%\" fit=\"meet\" />"
++#define SMIL_AUDIO_REGION "<region id=\"Audio\" width=\"100%\" height=\"100%\" fit=\"meet\" />"
++#define SMIL_TEXT_PART "<par dur=\"3s\">\
++       <text src=\"cid:%1\" region=\"Text\" />\
++     </par>"
++#define SMIL_IMAGE_PART "<par dur=\"5000ms\">\
++       <img src=\"cid:%1\" region=\"Image\" />\
++     </par>"
++#define SMIL_VIDEO_PART "<par>\
++       <video src=\"cid:%1\" region=\"Video\" />\
++     </par>"
++#define SMIL_AUDIO_PART "<par>\
++       <audio src=\"cid:%1\" region=\"Audio\" />\
++     </par>"
++
++#define SMIL_FILE "<smil>\
++   <head>\
++     <layout>\
++         %1\
++     </layout>\
++   </head>\
++   <body>\
++       %2\
++   </body>\
++ </smil>"
++
++MessageSendingJob::MessageSendingJob(TextHandler *textHandler, PendingMessage message)
++: MessageJob(new MessageSendingJobAdaptor(this), textHandler), mTextHandler(textHandler), mMessage(message), mFinished(false)
++{
++}
++
++MessageSendingJob::~MessageSendingJob()
++{
++    qDebug() << __PRETTY_FUNCTION__;
++}
++
++QString MessageSendingJob::accountId() const
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    return mAccountId;
++}
++
++QString MessageSendingJob::messageId() const
++{
++    return mMessageId;
++}
++
++QString MessageSendingJob::channelObjectPath() const
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    return mChannelObjectPath;
++}
++
++QVariantMap MessageSendingJob::properties() const
++{
++    return mMessage.properties;
++}
++
++void MessageSendingJob::startJob()
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    qDebug() << "Getting account for id:" << mMessage.accountId;
++    AccountEntry *account = TelepathyHelper::instance()->accountForId(mMessage.accountId);
++    if (!account) {
++        setStatus(Failed);
++        scheduleDeletion();
++    }
++
++    setStatus(Running);
++
++    // check if the message should be sent via multimedia account
++    // we just use fallback to 1-1 chats
++    if (account->type() == AccountEntry::PhoneAccount) {
++        Q_FOREACH(AccountEntry *newAccount, TelepathyHelper::instance()->accounts()) {
++            // TODO: we have to find the multimedia account that matches the same phone number,
++            // but for now we just pick any multimedia connected account
++            if (newAccount->type() != AccountEntry::MultimediaAccount) {
++                continue;
++            }
++            // FIXME: the fallback implementation needs to be changed to use protocol info and create a map of
++            // accounts. Also, it needs to check connection capabilities to determine if we can send message
++            // to offline contacts.
++            bool shouldFallback = true;
++            // if the account is offline, dont fallback to this account
++            if (!newAccount->connected()) {
++                continue;
++            }
++            QList<Tp::TextChannelPtr> channels = mTextHandler->existingChannels(newAccount->accountId(), mMessage.properties);
++            // check if we have a channel for this contact already and get the contact pointer from there,
++            // this way we avoid doing the while(op->isFinished()) all the time
++            if (!channels.isEmpty()) {
++                // FIXME: we need to re-evaluate the rules to fallback
++                // if the contact is known, force fallback to this account
++                Q_FOREACH(const Tp::ContactPtr &contact, channels.first()->groupContacts(false)) {
++                    Tp::Presence presence = contact->presence();
++                    shouldFallback = (presence.type() == Tp::ConnectionPresenceTypeAvailable ||
++                                      presence.type() == Tp::ConnectionPresenceTypeOffline);
++                    if (!shouldFallback) {
++                        break;
++                    }
++                }
++            } else {
++                QStringList participantIds = mMessage.properties["participantIds"].toStringList();
++                Tp::PendingContacts *op = newAccount->account()->connection()->contactManager()->contactsForIdentifiers(participantIds);
++                while (!op->isFinished()) {
++                    qApp->processEvents();
++                }
++                Q_FOREACH(const Tp::ContactPtr &contact, op->contacts()) {
++                    Tp::Presence presence = contact->presence();
++                    shouldFallback = (presence.type() == Tp::ConnectionPresenceTypeAvailable ||
++                                      presence.type() == Tp::ConnectionPresenceTypeOffline);
++                    if (!shouldFallback) {
++                        break;
++                    }
++                }
++            }
++            if (shouldFallback) {
++                account = newAccount;
++                break;
++            }
++        }
++    }
++
++    // save the account
++    mAccount = account;
++    setAccountId(mAccount->accountId());
++
++    if (!account->connected()) {
++        connect(account, &AccountEntry::connectedChanged, [this, account]() {
++            if (account->connected()) {
++                findOrCreateChannel();
++            }
++        });
++        return;
++    }
++
++    findOrCreateChannel();
++}
++
++void MessageSendingJob::findOrCreateChannel()
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    // now that we know what account to use, find existing channels or request a new one
++    QList<Tp::TextChannelPtr> channels = mTextHandler->existingChannels(mAccount->accountId(), mMessage.properties);
++    if (channels.isEmpty()) {
++        ChatStartingJob *job = new ChatStartingJob(mTextHandler, mAccount->accountId(), mMessage.properties);
++        connect(job, &MessageJob::finished, [this, job]() {
++            if (job->status() == MessageJob::Failed) {
++                setStatus(Failed);
++                scheduleDeletion();
++                return;
++            }
++
++            mTextChannel = job->textChannel();
++            sendMessage();
++        });
++        job->startJob();
++        return;
++    }
++
++    mTextChannel = channels.last();
++    sendMessage();
++}
++
++void MessageSendingJob::sendMessage()
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    Tp::PendingSendMessage *op = mTextChannel->send(buildMessage(mMessage));
++    connect(op, &Tp::PendingOperation::finished, [this, op]() {
++        if (op->isError()) {
++            setStatus(Failed);
++            scheduleDeletion();
++            return;
++        }
++
++        setChannelObjectPath(mTextChannel->objectPath());
++        setMessageId(op->sentMessageToken());
++        setStatus(Finished);
++        scheduleDeletion();
++    });
++}
++
++void MessageSendingJob::setAccountId(const QString &accountId)
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    mAccountId = accountId;
++    Q_EMIT accountIdChanged();
++}
++
++void MessageSendingJob::setChannelObjectPath(const QString &objectPath)
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    mChannelObjectPath = objectPath;
++    Q_EMIT channelObjectPathChanged();
++}
++
++void MessageSendingJob::setMessageId(const QString &id)
++{
++    mMessageId = id;
++    Q_EMIT messageIdChanged();
++}
++
++Tp::MessagePartList MessageSendingJob::buildMessage(const PendingMessage &pendingMessage)
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    Tp::MessagePartList message;
++    Tp::MessagePart header;
++    QString smil, regions, parts;
++    bool hasImage = false, hasText = false, hasVideo = false, hasAudio = false, isMMS = false;
++
++    AccountEntry *account = TelepathyHelper::instance()->accountForId(pendingMessage.accountId);
++    if (!account) {
++        // account does not exist
++        return Tp::MessagePartList();
++    }
++
++    bool temporaryFiles = (pendingMessage.properties.contains("x-canonical-tmp-files") &&
++                           pendingMessage.properties["x-canonical-tmp-files"].toBool());
++
++    // add the remaining properties to the message header
++    QVariantMap::const_iterator it = pendingMessage.properties.begin();
++    for (; it != pendingMessage.properties.end(); ++it) {
++        header[it.key()] = QDBusVariant(it.value());
++    }
++
++    // check if this message should be sent as an MMS
++    if (account->type() == AccountEntry::PhoneAccount) {
++        isMMS = (pendingMessage.attachments.size() > 0 ||
++                 (header.contains("x-canonical-mms") && header["x-canonical-mms"].variant().toBool()) ||
++                 (pendingMessage.properties["participantIds"].toStringList().size() > 1 && TelepathyHelper::instance()->mmsGroupChat()));
++        if (isMMS) {
++            header["x-canonical-mms"] = QDBusVariant(true);
++        }
++    }
++
++    // this flag should not be in the message header, it's only useful for the handler
++    header.remove("x-canonical-tmp-files");
++    header.remove("chatType");
++    header.remove("threadId");
++    header.remove("participantIds");
++
++    header["message-type"] = QDBusVariant(0);
++    message << header;
++
++    // convert AttachmentList struct into telepathy Message parts
++    Q_FOREACH(const AttachmentStruct &attachment, pendingMessage.attachments) {
++        QByteArray fileData;
++        QString newFilePath = QString(attachment.filePath).replace("file://", "");
++        QFile attachmentFile(newFilePath);
++        if (!attachmentFile.open(QIODevice::ReadOnly)) {
++            qWarning() << "fail to load attachment" << attachmentFile.errorString() << attachment.filePath;
++            continue;
++        }
++        if (attachment.contentType.startsWith("image/")) {
++            if (isMMS) {
++                hasImage = true;
++                parts += QString(SMIL_IMAGE_PART).arg(attachment.id);
++                // check if we need to reduce de image size in case it's bigger than 300k
++                // this check is only valid for MMS
++                if (attachmentFile.size() > 307200) {
++                    QImage scaledImage(newFilePath);
++                    if (!scaledImage.isNull()) {
++                        QBuffer buffer(&fileData);
++                        buffer.open(QIODevice::WriteOnly);
++                        scaledImage.scaled(640, 640, Qt::KeepAspectRatio, Qt::SmoothTransformation).save(&buffer, "jpg");
++                    }
++                } else {
++                    fileData = attachmentFile.readAll();
++                }
++            }
++        } else if (attachment.contentType.startsWith("video/")) {
++            if (isMMS) {
++                hasVideo = true;
++                parts += QString(SMIL_VIDEO_PART).arg(attachment.id);
++            }
++        } else if (attachment.contentType.startsWith("audio/")) {
++            if (isMMS) {
++                hasAudio = true;
++                parts += QString(SMIL_AUDIO_PART).arg(attachment.id);
++            }
++        } else if (attachment.contentType.startsWith("text/plain")) {
++            if (isMMS) {
++                hasText = true;
++                parts += QString(SMIL_TEXT_PART).arg(attachment.id);
++            }
++        } else if (attachment.contentType.startsWith("text/vcard") ||
++                   attachment.contentType.startsWith("text/x-vcard")) {
++        } else if (isMMS) {
++            // for MMS we just support the contentTypes above
++            if (temporaryFiles) {
++                attachmentFile.remove();
++            }
++            continue;
++        }
++
++        if (fileData.isEmpty()) {
++            fileData = attachmentFile.readAll();
++        }
++
++        if (temporaryFiles) {
++            attachmentFile.remove();
++        }
++
++        if (hasVideo) {
++            regions += QString(SMIL_VIDEO_REGION);
++        }
++
++        if (hasAudio) {
++            regions += QString(SMIL_AUDIO_REGION);
++        }
++
++        if (hasText) {
++            regions += QString(SMIL_TEXT_REGION);
++        }
++        if (hasImage) {
++            regions += QString(SMIL_IMAGE_REGION);
++        }
++
++        Tp::MessagePart part;
++        part["content-type"] =  QDBusVariant(attachment.contentType);
++        part["identifier"] = QDBusVariant(attachment.id);
++        part["content"] = QDBusVariant(fileData);
++        part["size"] = QDBusVariant(fileData.size());
++
++        message << part;
++    }
++
++    if (!pendingMessage.message.isEmpty()) {
++        Tp::MessagePart part;
++        QString tmpTextId("text_0.txt");
++        part["content-type"] =  QDBusVariant(QString("text/plain"));
++        part["identifier"] = QDBusVariant(tmpTextId);
++        part["content"] = QDBusVariant(pendingMessage.message);
++        part["size"] = QDBusVariant(pendingMessage.message.size());
++        if (isMMS) {
++            parts += QString(SMIL_TEXT_PART).arg(tmpTextId);
++            regions += QString(SMIL_TEXT_REGION);
++        }
++        message << part;
++    }
++
++    if (isMMS) {
++        Tp::MessagePart smilPart;
++        smil = QString(SMIL_FILE).arg(regions).arg(parts);
++        smilPart["content-type"] =  QDBusVariant(QString("application/smil"));
++        smilPart["identifier"] = QDBusVariant(QString("smil.xml"));
++        smilPart["content"] = QDBusVariant(smil);
++        smilPart["size"] = QDBusVariant(smil.size());
++
++        message << smilPart;
++    }
++
++    return message;
++}
++
++
 === added file 'handler/messagesendingjob.h'
 --- handler/messagesendingjob.h	1970-01-01 00:00:00 +0000
 +++ handler/messagesendingjob.h	2016-10-06 19:34:37 +0000
@@ -0,0 +1,90 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * Authors:
++ *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
++ *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
++ *
++ * This file is part of telephony-service.
++ *
++ * telephony-service is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * telephony-service is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef MESSAGESENDINGJOB_H
++#define MESSAGESENDINGJOB_H
++
++#include <QObject>
++#include <TelepathyQt/Types>
++#include "dbustypes.h"
++#include "messagejob.h"
++
++class AccountEntry;
++class TextHandler;
++class MessageSendingJobAdaptor;
++
++struct PendingMessage {
++    QString accountId;
++    QString message;
++    AttachmentList attachments;
++    QVariantMap properties;
++};
++Q_DECLARE_METATYPE(PendingMessage)
++
++class MessageSendingJob : public MessageJob
++{
++    Q_OBJECT
++    Q_PROPERTY(QString accountId READ accountId NOTIFY accountIdChanged)
++    Q_PROPERTY(QString messageId READ messageId NOTIFY messageIdChanged)
++    Q_PROPERTY(QString channelObjectPath READ channelObjectPath NOTIFY channelObjectPathChanged)
++    Q_PROPERTY(QVariantMap properties READ properties CONSTANT)
++
++public:
++    explicit MessageSendingJob(TextHandler *textHandler, PendingMessage message);
++    ~MessageSendingJob();
++
++    QString accountId() const;
++    QString messageId() const;
++    QString channelObjectPath() const;
++    QVariantMap properties() const;
++
++Q_SIGNALS:
++    void accountIdChanged();
++    void messageIdChanged();
++    void channelObjectPathChanged();
++
++public Q_SLOTS:
++    void startJob();
++
++protected Q_SLOTS:
++    void findOrCreateChannel();
++    void sendMessage();
++
++    void setAccountId(const QString &accountId);
++    void setChannelObjectPath(const QString &objectPath);
++    void setMessageId(const QString &id);
++
++private:
++    TextHandler *mTextHandler;
++    PendingMessage mMessage;
++    QString mAccountId;
++    QString mMessageId;
++    AccountEntry *mAccount;
++    QString mChannelObjectPath;
++    Tp::TextChannelPtr mTextChannel;
++    bool mFinished;
++
++    Tp::MessagePartList buildMessage(const PendingMessage &pendingMessage);
++
++};
++
++#endif // MESSAGESENDINGJOB_H
 === modified file 'handler/texthandler.cpp'
 --- handler/texthandler.cpp	2016-10-06 19:34:36 +0000
 +++ handler/texthandler.cpp	2016-10-06 19:34:37 +0000
@@ -26,87 +26,19 @@
  #include "config.h"
  #include "dbustypes.h"
  #include "accountentry.h"
++#include "chatstartingjob.h"
  #include <QImage>
  #include <TelepathyQt/ContactManager>
  #include <TelepathyQt/PendingContacts>
  #include <TelepathyQt/PendingChannelRequest>
--#define SMIL_TEXT_REGION "<region id=\"Text\" width=\"100%\" height=\"100%\" fit=\"scroll\" />"
--#define SMIL_IMAGE_REGION "<region id=\"Image\" width=\"100%\" height=\"100%\" fit=\"meet\" />"
--#define SMIL_VIDEO_REGION "<region id=\"Video\" width=\"100%\" height=\"100%\" fit=\"meet\" />"
--#define SMIL_AUDIO_REGION "<region id=\"Audio\" width=\"100%\" height=\"100%\" fit=\"meet\" />"
--#define SMIL_TEXT_PART "<par dur=\"3s\">\
--       <text src=\"cid:%1\" region=\"Text\" />\
--     </par>"
--#define SMIL_IMAGE_PART "<par dur=\"5000ms\">\
--       <img src=\"cid:%1\" region=\"Image\" />\
--     </par>"
--#define SMIL_VIDEO_PART "<par>\
--       <video src=\"cid:%1\" region=\"Video\" />\
--     </par>"
--#define SMIL_AUDIO_PART "<par>\
--       <audio src=\"cid:%1\" region=\"Audio\" />\
--     </par>"
--
--#define SMIL_FILE "<smil>\
--   <head>\
--     <layout>\
--         %1\
--     </layout>\
--   </head>\
--   <body>\
--       %2\
--   </body>\
-- </smil>"
--
  TextHandler::TextHandler(QObject *parent)
  : QObject(parent)
+ {
      qDBusRegisterMetaType<AttachmentStruct>();
      qDBusRegisterMetaType<AttachmentList>();
      qRegisterMetaType<PendingMessage>();
--
--    // track when the account becomes available
--    connect(TelepathyHelper::instance(),
--            SIGNAL(setupReady()),
--            SLOT(onConnectedChanged()));
--}
--
--void TextHandler::onConnectedChanged()
--{
--    if (!TelepathyHelper::instance()->ready()) {
--        return;
--    }
--
--    // now check which accounts are connected
--    Q_FOREACH(AccountEntry *account, TelepathyHelper::instance()->accounts()) {
--        QString accountId = account->accountId();
--        if (!account->connected()) {
--            continue;
--        }
--
--        // create text channels to send the pending messages
--        QList<QStringList> recipientsList;
--        Q_FOREACH(const PendingMessage &pendingMessage, mPendingMessages) {
--            if (accountId != pendingMessage.accountId) {
--                continue;
--            }
--            bool found = false;
--            // avoid adding twice the same list of participants
--/*            Q_FOREACH(const QStringList &recipients, recipientsList) {
--                if (recipients == pendingMessage.recipients) {
--                    found = true;
--                    break;
--                }
--            }
--            if (!found) {
--                recipientsList << pendingMessage.recipients;
--            }*/
--            // TODO AVOID CALLING TWICE FOR SAME CHANNEL
--            startChat(accountId, pendingMessage.properties);
--        }
--    }
+ }
  TextHandler *TextHandler::instance()
@@ -115,344 +47,20 @@
      return handler;
+ }
--void TextHandler::startChat(const QString &accountId, const QVariantMap &properties)
--{
--    // Request the contact to start chatting to
--    // FIXME: make it possible to select which account to use, for now, pick the first one
--    AccountEntry *account = TelepathyHelper::instance()->accountForId(accountId);
--    if (!account || !account->connected()) {
--        qCritical() << "The selected account does not have a connection. AccountId:" << accountId;
--        return;
--    }
--
--    switch(properties["chatType"].toUInt()) {
--    case Tp::HandleTypeNone:
--    case Tp::HandleTypeContact:
--        startTextChat(account->account(), properties);
--        break;
--    case Tp::HandleTypeRoom:
--        startTextChatroom(account->account(), properties);
--        break;
--    default:
--        qCritical() << "Chat type not supported";
--    }
--}
--
--void TextHandler::startTextChat(const Tp::AccountPtr &account, const QVariantMap &properties)
--{
--    QStringList participants = properties["participantIds"].toStringList();
--    switch(participants.size()) {
--    case 0:
--        qCritical() << "Error: No participant list provided";
--        break;
--    case 1:
--        account->ensureTextChat(participants[0], QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
--        break;
--    default:
--        account->createConferenceTextChat(QList<Tp::ChannelPtr>(), participants, QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
--    }
--}
--
--Tp::TextChannelPtr TextHandler::startTextChatroom(const Tp::AccountPtr &account, const QVariantMap &properties)
--{
--    QString roomName = properties["threadId"].toString();
--
--    // these properties are still not used
--    //QString server = properties["Server"].toString();
--    //QString creator = properties["Creator"].toString();
--
--    QVariantMap request;
--    Tp::PendingChannelRequest *op = NULL;
--    if (roomName.isEmpty()) {
--        request.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType"), TP_QT_IFACE_CHANNEL_TYPE_TEXT);
--        request.insert(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType"), (uint) Tp::HandleTypeNone);
--        QStringList initialInviteeIDs = properties["participantIds"].toStringList();
--        if (!initialInviteeIDs.isEmpty()) {
--            request.insert(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeIDs"), initialInviteeIDs);
--        }
--        // the presence of RoomName indicates the returned channel must be of type Room
--        request.insert(TP_QT_IFACE_CHANNEL_INTERFACE_ROOM + QLatin1String(".RoomName"), QString());
--
--        // TODO use the instance returned by createChanne() to track when the channel creation is finished
--        op = account->createChannel(request, QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
--    } else {
--
--        op = account->ensureTextChatroom(roomName, QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler", request);
--    }
--
--    if (!op) {
--        return Tp::TextChannelPtr();
--    }
--    while (!op->isFinished()) {
--        qApp->processEvents();
--    }
--    Tp::TextChannelPtr textChannel(qobject_cast<Tp::TextChannel*>(op->channelRequest()->channel().data()));
--    return textChannel;
--}
--
--Tp::MessagePartList TextHandler::buildMessage(const PendingMessage &pendingMessage)
--{
--    Tp::MessagePartList message;
--    Tp::MessagePart header;
--    QString smil, regions, parts;
--    bool hasImage = false, hasText = false, hasVideo = false, hasAudio = false, isMMS = false;
--
--    AccountEntry *account = TelepathyHelper::instance()->accountForId(pendingMessage.accountId);
--    if (!account) {
--        // account does not exist
--        return Tp::MessagePartList();
--    }
--
--    bool temporaryFiles = (pendingMessage.properties.contains("x-canonical-tmp-files") &&
--                           pendingMessage.properties["x-canonical-tmp-files"].toBool());
--
--    // add the remaining properties to the message header
--    QVariantMap::const_iterator it = pendingMessage.properties.begin();
--    for (; it != pendingMessage.properties.end(); ++it) {
--        header[it.key()] = QDBusVariant(it.value());
--    }
--
--    // check if this message should be sent as an MMS
--    if (account->type() == AccountEntry::PhoneAccount) {
--        isMMS = (pendingMessage.attachments.size() > 0 ||
--                 (header.contains("x-canonical-mms") && header["x-canonical-mms"].variant().toBool()) ||
--                 (pendingMessage.properties["participantIds"].toStringList().size() > 1 && TelepathyHelper::instance()->mmsGroupChat()));
--        if (isMMS) {
--            header["x-canonical-mms"] = QDBusVariant(true);
--        }
--    }
--
--    // this flag should not be in the message header, it's only useful for the handler
--    header.remove("x-canonical-tmp-files");
--    header.remove("chatType");
--    header.remove("threadId");
--    header.remove("participantIds");
--
--    header["message-type"] = QDBusVariant(0);
--    message << header;
--
--    // convert AttachmentList struct into telepathy Message parts
--    Q_FOREACH(const AttachmentStruct &attachment, pendingMessage.attachments) {
--        QByteArray fileData;
--        QString newFilePath = QString(attachment.filePath).replace("file://", "");
--        QFile attachmentFile(newFilePath);
--        if (!attachmentFile.open(QIODevice::ReadOnly)) {
--            qWarning() << "fail to load attachment" << attachmentFile.errorString() << attachment.filePath;
--            continue;
--        }
--        if (attachment.contentType.startsWith("image/")) {
--            if (isMMS) {
--                hasImage = true;
--                parts += QString(SMIL_IMAGE_PART).arg(attachment.id);
--                // check if we need to reduce de image size in case it's bigger than 300k
--                // this check is only valid for MMS
--                if (attachmentFile.size() > 307200) {
--                    QImage scaledImage(newFilePath);
--                    if (!scaledImage.isNull()) {
--                        QBuffer buffer(&fileData);
--                        buffer.open(QIODevice::WriteOnly);
--                        scaledImage.scaled(640, 640, Qt::KeepAspectRatio, Qt::SmoothTransformation).save(&buffer, "jpg");
--                    }
--                } else {
--                    fileData = attachmentFile.readAll();
--                }
--            }
--        } else if (attachment.contentType.startsWith("video/")) {
--            if (isMMS) {
--                hasVideo = true;
--                parts += QString(SMIL_VIDEO_PART).arg(attachment.id);
--            }
--        } else if (attachment.contentType.startsWith("audio/")) {
--            if (isMMS) {
--                hasAudio = true;
--                parts += QString(SMIL_AUDIO_PART).arg(attachment.id);
--            }
--        } else if (attachment.contentType.startsWith("text/plain")) {
--            if (isMMS) {
--                hasText = true;
--                parts += QString(SMIL_TEXT_PART).arg(attachment.id);
--            }
--        } else if (attachment.contentType.startsWith("text/vcard") ||
--                   attachment.contentType.startsWith("text/x-vcard")) {
--        } else if (isMMS) {
--            // for MMS we just support the contentTypes above
--            if (temporaryFiles) {
--                attachmentFile.remove();
--            }
--            continue;
--        }
--
--        if (fileData.isEmpty()) {
--            fileData = attachmentFile.readAll();
--        }
--
--        if (temporaryFiles) {
--            attachmentFile.remove();
--        }
--
--        if (hasVideo) {
--            regions += QString(SMIL_VIDEO_REGION);
--        }
--
--        if (hasAudio) {
--            regions += QString(SMIL_AUDIO_REGION);
--        }
--
--        if (hasText) {
--            regions += QString(SMIL_TEXT_REGION);
--        }
--        if (hasImage) {
--            regions += QString(SMIL_IMAGE_REGION);
--        }
--
--        Tp::MessagePart part;
--        part["content-type"] =  QDBusVariant(attachment.contentType);
--        part["identifier"] = QDBusVariant(attachment.id);
--        part["content"] = QDBusVariant(fileData);
--        part["size"] = QDBusVariant(fileData.size());
--
--        message << part;
--    }
--
--    if (!pendingMessage.message.isEmpty()) {
--        Tp::MessagePart part;
--        QString tmpTextId("text_0.txt");
--        part["content-type"] =  QDBusVariant(QString("text/plain"));
--        part["identifier"] = QDBusVariant(tmpTextId);
--        part["content"] = QDBusVariant(pendingMessage.message);
--        part["size"] = QDBusVariant(pendingMessage.message.size());
--        if (isMMS) {
--            parts += QString(SMIL_TEXT_PART).arg(tmpTextId);
--            regions += QString(SMIL_TEXT_REGION);
--        }
--        message << part;
--    }
--
--    if (isMMS) {
--        Tp::MessagePart smilPart;
--        smil = QString(SMIL_FILE).arg(regions).arg(parts);
--        smilPart["content-type"] =  QDBusVariant(QString("application/smil"));
--        smilPart["identifier"] = QDBusVariant(QString("smil.xml"));
--        smilPart["content"] = QDBusVariant(smil);
--        smilPart["size"] = QDBusVariant(smil.size());
--
--        message << smilPart;
--    }
--
--    return message;
++QString TextHandler::startChat(const QString &accountId, const QVariantMap &properties)
++{
++    ChatStartingJob *job = new ChatStartingJob(this, accountId, properties);
++    job->startJob();
++    return job->objectPath();
+ }
  QString TextHandler::sendMessage(const QString &accountId, const QString &message, const AttachmentList &attachments, const QVariantMap &properties)
+ {
--    AccountEntry *account = TelepathyHelper::instance()->accountForId(accountId);
--    if (!account) {
--        // account does not exist
--        return QString();
--    }
--
--    // check if the message should be sent via multimedia account
--    // we just use fallback to 1-1 chats
--    if (account->type() == AccountEntry::PhoneAccount) {
--        Q_FOREACH(AccountEntry *newAccount, TelepathyHelper::instance()->accounts()) {
--            // TODO: we have to find the multimedia account that matches the same phone number,
--            // but for now we just pick any multimedia connected account
--            if (newAccount->type() != AccountEntry::MultimediaAccount) {
--                continue;
--            }
--            // FIXME: the fallback implementation needs to be changed to use protocol info and create a map of
--            // accounts. Also, it needs to check connection capabilities to determine if we can send message
--            // to offline contacts.
--            bool shouldFallback = true;
--            // if the account is offline, dont fallback to this account
--            if (!newAccount->connected()) {
--                continue;
--            }
--            QList<Tp::TextChannelPtr> channels = existingChannels(newAccount->accountId(), properties);
--            // check if we have a channel for this contact already and get the contact pointer from there,
--            // this way we avoid doing the while(op->isFinished()) all the time
--            if (!channels.isEmpty()) {
--                // if the contact is known, force fallback to this account
--                Q_FOREACH(const Tp::ContactPtr &contact, channels.first()->groupContacts(false)) {
--                    Tp::Presence presence = contact->presence();
--                    shouldFallback = (presence.type() == Tp::ConnectionPresenceTypeAvailable ||
--                                      presence.type() == Tp::ConnectionPresenceTypeOffline);
--                    if (!shouldFallback) {
--                        break;
--                    }
--                }
--            } else {
--                QStringList participants = properties["participantIds"].toStringList();
--                Tp::PendingOperation *op = newAccount->account()->connection()->contactManager()->contactsForIdentifiers(participants);
--                while (!op->isFinished()) {
--                    qApp->processEvents();
--                }
--                Tp::PendingContacts *pc = qobject_cast<Tp::PendingContacts*>(op);
--                if (pc) {
--                    Q_FOREACH(const Tp::ContactPtr &contact, pc->contacts()) {
--                        Tp::Presence presence = contact->presence();
--                        shouldFallback = (presence.type() == Tp::ConnectionPresenceTypeAvailable ||
--                                          presence.type() == Tp::ConnectionPresenceTypeOffline);
--                        if (!shouldFallback) {
--                            break;
--                        }
--                    }
--                }
--            }
--            if (shouldFallback) {
--                account = newAccount;
--                break;
--            }
--        }
--    }
--
--    // keep recipient list always sorted to be able to compare
--    PendingMessage pendingMessage = {account->accountId(), message, attachments, properties};
--
--    if (!account->connected()) {
--        mPendingMessages.append(pendingMessage);
--        return account->accountId();
--    }
--
--    QList<Tp::TextChannelPtr> channels = existingChannels(account->accountId(), properties);
--    if (channels.isEmpty()) {
--        // temporary
--        switch(properties["chatType"].toUInt()) {
--        case Tp::HandleTypeNone:
--        case Tp::HandleTypeContact:
--            mPendingMessages.append(pendingMessage);
--            startTextChat(account->account(), pendingMessage.properties);
--            return account->accountId();
--        case Tp::HandleTypeRoom: {
--            channels << startTextChatroom(account->account(), pendingMessage.properties);
--            qDebug() << "channel returned" << channels.last();
--
--            // multimedia fails if we send the message right away
--            QTimer *timer = new QTimer(this);
--            timer->setInterval(3000);
--            timer->setSingleShot(true);
--            QObject::connect(timer, &QTimer::timeout, [=]() {
--                qDebug() << "sending message" << channels.last();
--                connect(channels.last()->send(buildMessage(pendingMessage)),
--                        SIGNAL(finished(Tp::PendingOperation*)),
--                        SLOT(onMessageSent(Tp::PendingOperation*)));
--
--                timer->deleteLater();
--            });
--            timer->start();
--            return account->accountId();
--            break;
--        }
--        }
--
--        //startChat(account->accountId(), pendingMessage.properties);
--        //return account->accountId();
--    }
--
--    connect(channels.last()->send(buildMessage(pendingMessage)),
--            SIGNAL(finished(Tp::PendingOperation*)),
--            SLOT(onMessageSent(Tp::PendingOperation*)));
--
--    return account->accountId();
++    PendingMessage pendingMessage = {accountId, message, attachments, properties};
++    MessageSendingJob *job = new MessageSendingJob(this, pendingMessage);
++    job->startJob();
++
++    return job->objectPath();
+ }
  void TextHandler::acknowledgeMessages(const QVariantList &messages)
@@ -508,41 +116,6 @@
      QString accountId = account->accountId();
      mChannels.append(channel);
--
--    // check for pending messages for this channel
--    if (mPendingMessages.isEmpty()) {
--        return;
--    }
--
--    QList<PendingMessage>::iterator it = mPendingMessages.begin();
--    while (it != mPendingMessages.end()) {
--        bool found = false;
--        Q_FOREACH(const Tp::TextChannelPtr &existingChannel, existingChannels(it->accountId, it->properties)) {
--            if (existingChannel == channel) {
--                sendMessage(it->accountId, it->message, it->attachments, it->properties);
--                it = mPendingMessages.erase(it);
--                found = true;
--                break;
--            }
--        }
--        if (!found) {
--            ++it;
--        }
--    }
--}
--
--void TextHandler::onMessageSent(Tp::PendingOperation *op)
--{
--    Tp::PendingSendMessage *psm = qobject_cast<Tp::PendingSendMessage*>(op);
--    if(!psm) {
--        qWarning() << "The pending object was not a pending operation:" << op;
--        return;
--    }
--
--    if (psm->isError()) {
--        qWarning() << "Error sending message:" << psm->errorName() << psm->errorMessage();
--        return;
--    }
+ }
  QList<Tp::TextChannelPtr> TextHandler::existingChannels(const QString &accountId, const QVariantMap &properties)
 === modified file 'handler/texthandler.h'
 --- handler/texthandler.h	2016-10-06 19:34:36 +0000
 +++ handler/texthandler.h	2016-10-06 19:34:37 +0000
@@ -27,23 +27,16 @@
  #include <TelepathyQt/TextChannel>
  #include <TelepathyQt/ReceivedMessage>
  #include "dbustypes.h"
--
--struct PendingMessage {
--    QString accountId;
--    QString message;
--    AttachmentList attachments;
--    QVariantMap properties;
--};
--Q_DECLARE_METATYPE(PendingMessage)
++#include "messagesendingjob.h"
  class TextHandler : public QObject
+ {
      Q_OBJECT
  public:
      static TextHandler *instance();
--    void startChat(const QString &accountId, const QVariantMap &properties);
--    void startTextChat(const Tp::AccountPtr &account, const QVariantMap &properties);
--    Tp::TextChannelPtr startTextChatroom(const Tp::AccountPtr &account, const QVariantMap &properties);
++    QString startChat(const QString &accountId, const QVariantMap &properties);
++
++    friend class MessageSendingJob;
  public Q_SLOTS:
      QString sendMessage(const QString &accountId, const QString &message, const AttachmentList &attachments, const QVariantMap &properties);
@@ -53,18 +46,13 @@
  protected Q_SLOTS:
      void onTextChannelAvailable(Tp::TextChannelPtr channel);
      void onTextChannelInvalidated();
--    void onMessageSent(Tp::PendingOperation *op);
--    void onConnectedChanged();
  protected:
      QList<Tp::TextChannelPtr> existingChannels(const QString &accountId, const QVariantMap &properties);
  private:
      explicit TextHandler(QObject *parent = 0);
--    Tp::MessagePartList buildMessage(const PendingMessage &pendingMessage);
--
      QList<Tp::TextChannelPtr> mChannels;
--    QList<PendingMessage> mPendingMessages;
  };
  #endif // TEXTHANDLER_H
 === modified file 'libtelephonyservice/chatentry.cpp'
 --- libtelephonyservice/chatentry.cpp	2016-10-06 19:34:36 +0000
 +++ libtelephonyservice/chatentry.cpp	2016-10-06 19:34:37 +0000
@@ -1,8 +1,9 @@
  /*
-- * Copyright (C) 2015 Canonical, Ltd.
++ * Copyright (C) 2015-2016 Canonical, Ltd.
+  *
   * Authors:
   *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
++ *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
+  *
   * This file is part of telephony-service.
+  *
@@ -22,6 +23,10 @@
  #include "telepathyhelper.h"
  #include "accountentry.h"
  #include "chatentry.h"
++#include "chatmanager.h"
++
++// FIXME: move this class to libtelephonyservice
++#include "handler/messagejob.h"
  #include <TelepathyQt/Contact>
  #include <TelepathyQt/PendingReady>
@@ -29,51 +34,20 @@
  Q_DECLARE_METATYPE(ContactChatStates)
--ChatEntry::ChatEntry(const Tp::TextChannelPtr &channel, QObject *parent) :
++ChatEntry::ChatEntry(QObject *parent) :
      QObject(parent),
--    mChannel(channel),
++    mChatType(ChatTypeNone),
      roomInterface(NULL),
      roomConfigInterface(NULL),
      subjectInterface(NULL)
+ {
      qRegisterMetaType<ContactChatStates>();
--    mAccount = TelepathyHelper::instance()->accountForConnection(mChannel->connection());
--    Q_FOREACH (Tp::ContactPtr contact, mChannel->groupContacts(false)) {
--        ContactChatState *state = new ContactChatState(contact->id(), mChannel->chatState(contact));
--        mChatStates[contact->id()] = state;
--    }
--
--    roomInterface = channel->optionalInterface<Tp::Client::ChannelInterfaceRoomInterface>();
--    roomConfigInterface = channel->optionalInterface<Tp::Client::ChannelInterfaceRoomConfigInterface>();
--    subjectInterface = channel->optionalInterface<Tp::Client::ChannelInterfaceSubjectInterface>();
--
--    if (roomInterface) {
--        roomInterface->setMonitorProperties(true);
--        connect(roomInterface, SIGNAL(propertiesChanged(const QVariantMap &,const QStringList &)),
--                               SLOT(onRoomPropertiesChanged(const QVariantMap &,const QStringList &)));
--    }
--    if (roomConfigInterface) {
--        roomConfigInterface->setMonitorProperties(true);
--        connect(roomConfigInterface, SIGNAL(propertiesChanged(const QVariantMap &,const QStringList &)),
--                                     SLOT(onRoomPropertiesChanged(const QVariantMap &,const QStringList &)));
--    }
--    if (subjectInterface) {
--        subjectInterface->setMonitorProperties(true);
--        connect(subjectInterface, SIGNAL(propertiesChanged(const QVariantMap &,const QStringList &)),
--                                  SLOT(onRoomPropertiesChanged(const QVariantMap &,const QStringList &)));
--    }
--
--    connect(channel.data(), SIGNAL(chatStateChanged(const Tp::ContactPtr &, Tp::ChannelChatState)),
--                            this, SLOT(onChatStateChanged(const Tp::ContactPtr &,Tp::ChannelChatState)));
--    connect(channel.data(), SIGNAL(groupMembersChanged(const Tp::Contacts &, const Tp::Contacts &, const Tp::Contacts &,
--            const Tp::Contacts &, const Tp::Channel::GroupMemberChangeDetails &)), this, SIGNAL(participantsChanged()));
+ }
  void ChatEntry::onRoomPropertiesChanged(const QVariantMap &changed,const QStringList &invalidated)
+ {
      if (changed.contains("RoomName")) {
--        mRoomName = changed["RoomName"].toString();
--        Q_EMIT roomNameChanged();
++        setRoomName(changed["RoomName"].toString());
+     }
      if (changed.contains("Title")) {
          mTitle = changed["Title"].toString();
@@ -81,12 +55,52 @@
+     }
+ }
--QString ChatEntry::roomName()
++void ChatEntry::onSendingMessageFinished()
++{
++    QDBusInterface *job = qobject_cast<QDBusInterface*>(sender());
++    if (!job) {
++        return;
++    }
++
++    QString accountId = job->property("accountId").toString();
++    QString messageId = job->property("messageId").toString();
++    QString channelObjectPath = job->property("channelObjectPath").toString();
++    QVariantMap properties = job->property("properties").toMap();
++    qDebug() << accountId << messageId << channelObjectPath << properties;
++    Tp::TextChannelPtr channel = ChatManager::instance()->channelForObjectPath(channelObjectPath);
++
++    if (channel.isNull()) {
++        Q_EMIT messageSendingFailed(accountId, messageId, properties);
++        job->deleteLater();
++        return;
++    }
++
++    // even if sending the message fails, we can use the channel if available
++    addChannel(channel);
++
++    if (job->property("status").toInt() == MessageJob::Failed || channel.isNull()) {
++        Q_EMIT messageSendingFailed(accountId, messageId, properties);
++        job->deleteLater();
++        return;
++    }
++
++    Q_EMIT messageSent(accountId, messageId, properties);
++    job->deleteLater();
++}
++
++QString ChatEntry::roomName() const
+ {
      return mRoomName;
+ }
--QString ChatEntry::title()
++void ChatEntry::setRoomName(const QString &name)
++{
++    mRoomName = name;
++    Q_EMIT roomNameChanged();
++    // FIXME: we need to invalidate the existing channels & data and start fresh
++}
++
++QString ChatEntry::title() const
+ {
      return mTitle;
+ }
@@ -101,25 +115,32 @@
          it.next();
          delete it.value();
+     }
--
--    if (roomInterface) {
--        roomInterface->deleteLater();
--    }
--    if (roomConfigInterface) {
--        roomConfigInterface->deleteLater();
--    }
--    if (subjectInterface) {
--        subjectInterface->deleteLater();
--    }
--}
--
--QString ChatEntry::chatId()
--{
--    if (mChannel) {
--        return mChannel->targetId();
--    }
--    return QString();
--}
++}
++
++QString ChatEntry::chatId() const
++{
++    return mChatId;
++}
++
++void ChatEntry::setChatId(const QString &id)
++{
++    mChatId = id;
++    Q_EMIT chatIdChanged();
++    // FIXME: we need to invalidate the existing channels & data and start fresh
++}
++
++QString ChatEntry::accountId() const
++{
++    return mAccountId;
++}
++
++void ChatEntry::setAccountId(const QString &id)
++{
++    mAccountId = id;
++    Q_EMIT accountIdChanged();
++    // FIXME: we need to invalidate the existing channels & data and start fresh
++}
++
  void ChatEntry::onChatStateChanged(const Tp::ContactPtr &contact, Tp::ChannelChatState state)
+ {
@@ -133,28 +154,28 @@
      Q_EMIT chatStatesChanged();
+ }
--ChatEntry::ChatType ChatEntry::chatType()
--{
--    return (ChatType)mChannel->targetHandleType();
--}
--
--Tp::TextChannelPtr ChatEntry::channel()
--{
--    return mChannel;
--}
--
--QStringList ChatEntry::participants()
--{
--    QStringList participantList;
--    Q_FOREACH (Tp::ContactPtr contact, mChannel->groupContacts(false)) {
--        participantList << contact->id();
--    }
--    return participantList;
--}
--
--AccountEntry *ChatEntry::account()
--{
--    return mAccount;
++ChatEntry::ChatType ChatEntry::chatType() const
++{
++    return mChatType;
++}
++
++void ChatEntry::setChatType(ChatEntry::ChatType type)
++{
++    mChatType = type;
++    Q_EMIT chatTypeChanged();
++}
++
++QStringList ChatEntry::participants() const
++{
++    return mParticipants;
++}
++
++void ChatEntry::setParticipants(const QStringList &participants)
++{
++    mParticipants = participants;
++    Q_EMIT participantsChanged();
++
++    // FIXME: we need to invalidate the existing channels & data and start fresh
+ }
  QQmlListProperty<ContactChatState> ChatEntry::chatStates()
@@ -179,3 +200,157 @@
+     }
      return entry->mChatStates.values()[index];
+ }
++
++void ChatEntry::sendMessage(const QString &accountId, const QString &message, const QVariant &attachments, const QVariantMap &properties)
++{
++    QString objPath = ChatManager::instance()->sendMessage(accountId, message, attachments, properties);
++    QDBusInterface *sendingJob = new QDBusInterface(TelepathyHelper::instance()->handlerInterface()->service(), objPath,
++                                                    "com.canonical.TelephonyServiceHandler.MessageSendingJob");
++    qDebug() << sendingJob->isValid();
++    sendingJob->dumpObjectInfo();
++    connect(sendingJob, SIGNAL(finished()), SLOT(onSendingMessageFinished()));
++    QDBusReply<QString> reply = sendingJob->call("Introspect");
++    qDebug() << reply.value();
++}
++
++void ChatEntry::classBegin()
++{
++    // nothing to do here
++}
++
++void ChatEntry::componentComplete()
++{
++    QVariantMap properties = generateProperties();
++    QList<Tp::TextChannelPtr> channels = ChatManager::instance()->channelForProperties(properties);
++    QList<AccountEntry*> accounts;
++
++    if (!channels.isEmpty()) {
++        setChannels(channels);
++    }
++
++    // now filter out the Phone accounts from the accounts list
++    Q_FOREACH(AccountEntry *account, TelepathyHelper::instance()->activeAccounts(true)) {
++        if (account->type() != AccountEntry::PhoneAccount) {
++            accounts << account;
++        }
++    }
++
++    // now check that we have channels for all !Phone accounts
++    // we need channels to be able to show typing notifications
++    Q_FOREACH(const Tp::TextChannelPtr &channel, channels) {
++        AccountEntry *account = TelepathyHelper::instance()->accountForConnection(channel->connection());
++        accounts.removeAll(account);
++    }
++
++    // if there is any remaining account, request to start chatting using the account
++    Q_FOREACH(AccountEntry *account, accounts) {
++        ChatManager::instance()->startChat(account->accountId(), properties);
++    }
++
++    connect(ChatManager::instance(), &ChatManager::textChannelAvailable,
++            this, &ChatEntry::onTextChannelAvailable);
++}
++
++void ChatEntry::setChannels(const QList<Tp::TextChannelPtr> &channels)
++{
++    Q_FOREACH(const Tp::TextChannelPtr &channel, channels) {
++        addChannel(channel);
++    }
++}
++
++void ChatEntry::addChannel(const Tp::TextChannelPtr &channel)
++{
++    qDebug() << "adding channel" << channel->objectPath();
++    if (mChannels.contains(channel)) {
++        return;
++    }
++
++    roomInterface = channel->optionalInterface<Tp::Client::ChannelInterfaceRoomInterface>();
++    roomConfigInterface = channel->optionalInterface<Tp::Client::ChannelInterfaceRoomConfigInterface>();
++    subjectInterface = channel->optionalInterface<Tp::Client::ChannelInterfaceSubjectInterface>();
++
++    if (roomInterface) {
++        roomInterface->setProperty("channel", QVariant::fromValue(channel.data()));
++        roomInterface->setMonitorProperties(true);
++        connect(roomInterface, SIGNAL(propertiesChanged(const QVariantMap &,const QStringList &)),
++                               SLOT(onRoomPropertiesChanged(const QVariantMap &,const QStringList &)));
++    }
++    if (roomConfigInterface) {
++        roomConfigInterface->setProperty("channel", QVariant::fromValue(channel.data()));
++        roomConfigInterface->setMonitorProperties(true);
++        connect(roomConfigInterface, SIGNAL(propertiesChanged(const QVariantMap &,const QStringList &)),
++                                     SLOT(onRoomPropertiesChanged(const QVariantMap &,const QStringList &)));
++    }
++    if (subjectInterface) {
++        subjectInterface->setProperty("channel", QVariant::fromValue(channel.data()));
++        subjectInterface->setMonitorProperties(true);
++        connect(subjectInterface, SIGNAL(propertiesChanged(const QVariantMap &,const QStringList &)),
++                                  SLOT(onRoomPropertiesChanged(const QVariantMap &,const QStringList &)));
++    }
++
++    connect(channel.data(), SIGNAL(chatStateChanged(const Tp::ContactPtr &, Tp::ChannelChatState)),
++                            this, SLOT(onChatStateChanged(const Tp::ContactPtr &,Tp::ChannelChatState)));
++    connect(channel.data(), SIGNAL(groupMembersChanged(const Tp::Contacts &, const Tp::Contacts &, const Tp::Contacts &,
++            const Tp::Contacts &, const Tp::Channel::GroupMemberChangeDetails &)), this, SIGNAL(participantsChanged()));
++    connect(channel.data(), SIGNAL(invalidated(Tp::DBusProxy*,const QString&, const QString&)),
++            this, SLOT(onChannelInvalidated()));
++
++    Q_FOREACH (Tp::ContactPtr contact, channel->groupContacts(false)) {
++        // FIXME: we should not create new chat states for contacts already found in previous channels
++        ContactChatState *state = new ContactChatState(contact->id(), channel->chatState(contact));
++        mChatStates[contact->id()] = state;
++    }
++
++    // now fill the properties with the data from the channel
++    if (chatType() != (ChatType)channel->targetHandleType()) {
++        setChatType((ChatType)channel->targetHandleType());
++    }
++    if (chatType() == ChatTypeRoom && mChatId != channel->targetId()) {
++        setChatId(channel->targetId());
++    }
++
++    mChannels << channel;
++}
++
++QVariantMap ChatEntry::generateProperties() const
++{
++    QVariantMap properties;
++
++    properties["participantIds"] = participants();
++    properties["chatType"] = (int)chatType();
++    properties["chatId"] = chatId();
++    properties["threadId"] = chatId();
++
++    if (chatType() == ChatEntry::ChatTypeRoom) {
++        properties["accountId"] = accountId();
++    }
++
++    return properties;
++}
++
++void ChatEntry::onTextChannelAvailable(const Tp::TextChannelPtr &channel)
++{
++    if (ChatManager::channelMatchProperties(channel, generateProperties())) {
++        addChannel(channel);
++    }
++}
++
++void ChatEntry::onChannelInvalidated()
++{
++    qDebug() << __PRETTY_FUNCTION__;
++    Tp::TextChannelPtr channel(qobject_cast<Tp::TextChannel*>(sender()));
++    mChannels.removeAll(channel);
++
++    if (roomInterface && roomInterface->property("channel").value<Tp::TextChannel*>() == channel.data()) {
++        roomInterface->disconnect(this);
++        roomInterface = 0;
++    }
++    if (roomConfigInterface && roomConfigInterface->property("channel").value<Tp::TextChannel*>() == channel.data()) {
++        roomConfigInterface->disconnect(this);
++        roomConfigInterface = 0;
++    }
++    if (subjectInterface && subjectInterface->property("channel").value<Tp::TextChannel*>() == channel.data()) {
++        subjectInterface->disconnect(this);
++        subjectInterface = 0;
++    }
++}
 === modified file 'libtelephonyservice/chatentry.h'
 --- libtelephonyservice/chatentry.h	2016-10-06 19:34:36 +0000
 +++ libtelephonyservice/chatentry.h	2016-10-06 19:34:37 +0000
@@ -1,8 +1,9 @@
  /*
-- * Copyright (C) 2015 Canonical, Ltd.
++ * Copyright (C) 2015-2016 Canonical, Ltd.
+  *
   * Authors:
   *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
++ *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
+  *
   * This file is part of telephony-service.
+  *
@@ -23,6 +24,7 @@
  #define CHATENTRY_H
  #include <QObject>
++#include <QQmlParserStatus>
  #include <TelepathyQt/TextChannel>
  class AccountEntry;
@@ -42,6 +44,7 @@
+     }
  Q_SIGNALS:
      void stateChanged();
++
  private:
      QString mContactId;
      int mState;
@@ -49,14 +52,15 @@
  typedef QList<ContactChatState* > ContactChatStates;
--class ChatEntry : public QObject
++class ChatEntry : public QObject, public QQmlParserStatus
+ {
      Q_OBJECT
--    Q_PROPERTY(AccountEntry* account READ account CONSTANT)
--    Q_PROPERTY(ChatType chatType READ chatType CONSTANT)
--    Q_PROPERTY(QStringList participants READ participants NOTIFY participantsChanged)
--    Q_PROPERTY(QString roomName READ roomName NOTIFY roomNameChanged)
--    Q_PROPERTY(QString chatId READ chatId CONSTANT)
++    Q_INTERFACES(QQmlParserStatus)
++    Q_PROPERTY(ChatType chatType READ chatType WRITE setChatType NOTIFY chatTypeChanged)
++    Q_PROPERTY(QStringList participants READ participants WRITE setParticipants NOTIFY participantsChanged)
++    Q_PROPERTY(QString roomName READ roomName WRITE setRoomName NOTIFY roomNameChanged)
++    Q_PROPERTY(QString chatId READ chatId WRITE setChatId NOTIFY chatIdChanged)
++    Q_PROPERTY(QString accountId READ accountId WRITE setAccountId NOTIFY accountIdChanged)
      Q_PROPERTY(QString title READ title NOTIFY titleChanged)
      Q_PROPERTY(QQmlListProperty<ContactChatState> chatStates
                 READ chatStates
@@ -79,35 +83,65 @@
          ChannelChatStateComposing = Tp::ChannelChatStateComposing
      };
--    explicit ChatEntry(const Tp::TextChannelPtr &channel, QObject *parent = 0);
++    explicit ChatEntry(QObject *parent = 0);
      ~ChatEntry();
--    Tp::TextChannelPtr channel();
--    AccountEntry *account();
      QQmlListProperty<ContactChatState> chatStates();
--    QStringList participants();
--    ChatType chatType();
--    QString chatId();
--    QString roomName();
--    QString title();
++    QStringList participants() const;
++    void setParticipants(const QStringList &participants);
++    ChatType chatType() const;
++    void setChatType(ChatType type);
++    QString chatId() const;
++    void setChatId(const QString &id);
++    QString accountId() const;
++    void setAccountId(const QString &id);
++    QString roomName() const;
++    void setRoomName(const QString &name);
++    QString title() const;
      static int chatStatesCount(QQmlListProperty<ContactChatState> *p);
      static ContactChatState *chatStatesAt(QQmlListProperty<ContactChatState> *p, int index);
++    // QML parser status
++    void classBegin();
++    void componentComplete();
++
++public Q_SLOTS:
++    // FIXME: void or return something?
++    void sendMessage(const QString &accountId, const QString &message, const QVariant &attachments = QVariant(), const QVariantMap &properties = QVariantMap());
++
++protected:
++    void setChannels(const QList<Tp::TextChannelPtr> &channels);
++    void addChannel(const Tp::TextChannelPtr &channel);
++
++    QVariantMap generateProperties() const;
++
  private Q_SLOTS:
++    void onTextChannelAvailable(const Tp::TextChannelPtr &channel);
++    void onChannelInvalidated();
      void onChatStateChanged(const Tp::ContactPtr &contact, Tp::ChannelChatState state);
      void onRoomPropertiesChanged(const QVariantMap &changed,const QStringList &invalidated);
++    void onSendingMessageFinished();
  Q_SIGNALS:
++    void chatTypeChanged();
++    void chatIdChanged();
++    void accountIdChanged();
      void chatStatesChanged();
      void participantsChanged();
      void roomNameChanged();
      void titleChanged();
++    void messageSent(const QString &accountId, const QString &messageId, const QVariantMap &properties);
++    void messageSendingFailed(const QString &accountId, const QString &messageId, const QVariantMap &properties);
++
  private:
--    AccountEntry *mAccount;
--    Tp::TextChannelPtr mChannel;
++    QList<Tp::TextChannelPtr> mChannels;
++    QStringList mParticipants;
      QMap<QString, ContactChatState*> mChatStates;
      QString mRoomName;
      QString mTitle;
++    QString mChatId;
++    QString mAccountId;
++    ChatType mChatType;
      Tp::Client::ChannelInterfaceRoomInterface *roomInterface;
      Tp::Client::ChannelInterfaceRoomConfigInterface *roomConfigInterface;
      Tp::Client::ChannelInterfaceSubjectInterface *subjectInterface;
 === modified file 'libtelephonyservice/chatmanager.cpp'
 --- libtelephonyservice/chatmanager.cpp	2016-10-06 19:34:36 +0000
 +++ libtelephonyservice/chatmanager.cpp	2016-10-06 19:34:37 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2012-2013 Canonical, Ltd.
++ * Copyright (C) 2012-2016 Canonical, Ltd.
+  *
   * Authors:
   *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
@@ -20,6 +20,7 @@
   */
  #include "chatmanager.h"
++#include "chatentry.h"
  #include "telepathyhelper.h"
  #include "phoneutils.h"
  #include "config.h"
@@ -61,8 +62,7 @@
+ }
  ChatManager::ChatManager(QObject *parent)
--: QObject(parent),
--  mReady(TelepathyHelper::instance()->ready())
++: QObject(parent)
+ {
      qDBusRegisterMetaType<AttachmentList>();
      qDBusRegisterMetaType<AttachmentStruct>();
@@ -70,29 +70,13 @@
      mMessagesAckTimer.setInterval(25);
      mMessagesAckTimer.setSingleShot(true);
      connect(TelepathyHelper::instance(), SIGNAL(channelObserverUnregistered()), SLOT(onChannelObserverUnregistered()));
--    connect(TelepathyHelper::instance(), SIGNAL(setupReady()), SLOT(onTelepathyReady()));
      connect(&mMessagesAckTimer, SIGNAL(timeout()), SLOT(onAckTimerTriggered()));
      connect(TelepathyHelper::instance(), SIGNAL(setupReady()), SLOT(onConnectedChanged()));
+ }
--void ChatManager::onTelepathyReady()
--{
--    mReady = true;
--    Q_FOREACH(const Tp::TextChannelPtr &channel, mPendingChannels) {
--        onTextChannelAvailable(channel);
--    }
--    mPendingChannels.clear();
--}
--
  void ChatManager::onChannelObserverUnregistered()
+ {
--    QList<ChatEntry*> tmp = mChatEntries;
--    mChatEntries.clear();
--    Q_EMIT chatsChanged();
--    Q_FOREACH(ChatEntry *entry, tmp) {
--        // for some reason deleteLater is not working
--        delete entry;
--    }
++    mTextChannels.clear();
+ }
  void ChatManager::onConnectedChanged()
@@ -108,6 +92,13 @@
      return manager;
+ }
++void ChatManager::startChat(const QString &accountId, const QVariantMap &properties)
++{
++    QVariantMap propMap = convertPropertiesForDBus(properties);
++    QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
++    phoneAppHandler->asyncCall("StartChat", accountId, propMap);
++}
++
  QString ChatManager::sendMessage(const QString &accountId, const QString &message, const QVariant &attachments, const QVariantMap &properties)
+ {
      AccountEntry *account = TelepathyHelper::instance()->accountForId(accountId);
@@ -164,86 +155,138 @@
      return QString();
+ }
++QList<Tp::TextChannelPtr> ChatManager::channelForProperties(const QVariantMap &properties)
++{
++    // FIXME: remove before releasing
++    qDebug() << __PRETTY_FUNCTION__ << properties;
++    QList<Tp::TextChannelPtr> channels;
++
++
++    Q_FOREACH (Tp::TextChannelPtr channel, mTextChannels) {
++        if (channelMatchProperties(channel, properties)) {
++            channels << channel;
++        }
++    }
++
++    return channels;
++}
++
++Tp::TextChannelPtr ChatManager::channelForObjectPath(const QString &objectPath)
++{
++    Q_FOREACH(Tp::TextChannelPtr channel, mTextChannels) {
++        if (channel->objectPath() == objectPath) {
++            return channel;
++        }
++    }
++    return Tp::TextChannelPtr();
++}
++
++bool ChatManager::channelMatchProperties(const Tp::TextChannelPtr &channel, const QVariantMap &properties)
++{
++    QVariantMap propMap = properties;
++    ChatEntry::ChatType chatType = ChatEntry::ChatTypeNone;
++
++    QStringList participants;
++    // participants coming from qml are variants
++    if (properties.contains("participantIds")) {
++        participants = properties["participantIds"].toStringList();
++        if (!participants.isEmpty()) {
++            propMap["participantIds"] = participants;
++        }
++    }
++
++    if (participants.isEmpty() && propMap.contains("participants")) {
++        // try to generate list of participants from "participants"
++        Q_FOREACH(const QVariant &participantMap, propMap["participants"].toList()) {
++            if (participantMap.toMap().contains("identifier")) {
++                participants << participantMap.toMap()["identifier"].toString();
++            }
++        }
++        if (!participants.isEmpty()) {
++            propMap["participantIds"] = participants;
++        }
++    }
++
++    if (properties.contains("chatType")) {
++        chatType = (ChatEntry::ChatType)properties["chatType"].toInt();
++    } else {
++        if (participants.length() == 1) {
++            chatType = ChatEntry::ChatTypeContact;
++        }
++    }
++
++    QString accountId;
++    if (propMap.contains("accountId")) {
++        accountId = propMap["accountId"].toString();
++    }
++
++    if (participants.count() == 0 && chatType == ChatEntry::ChatTypeContact) {
++        return false;
++    }
++
++    AccountEntry *account = TelepathyHelper::instance()->accountForConnection(channel->connection());
++    if (!account) {
++        return false;
++    }
++
++    // only channels of the correct type should be returned
++    if ((ChatEntry::ChatType)channel->targetHandleType() != chatType) {
++        return false;
++    }
++
++    if (chatType == ChatEntry::ChatTypeRoom) {
++        QString chatId = propMap["threadId"].toString();
++        if (!chatId.isEmpty() && channel->targetId() == chatId) {
++            // if we are filtering by one specific accountId, make sure it matches
++            if (!accountId.isEmpty() && accountId != account->accountId()) {
++                return false;
++            }
++
++            return true;
++        }
++        return false;
++    }
++
++    Tp::Contacts contacts = channel->groupContacts(false);
++    if (participants.count() != contacts.count()) {
++        return false;
++    }
++    int participantCount = 0;
++    // iterate over participants
++    Q_FOREACH (const Tp::ContactPtr &contact, contacts) {
++        if (account->type() == AccountEntry::PhoneAccount || account->type() == AccountEntry::MultimediaAccount) {
++            Q_FOREACH(const QString &participant, participants) {
++                if (PhoneUtils::comparePhoneNumbers(participant, contact->id()) > PhoneUtils::NO_MATCH) {
++                    participantCount++;
++                    break;
++                }
++            }
++            continue;
++        }
++        if (participants.contains(contact->id())) {
++            participantCount++;
++        } else {
++            break;
++        }
++    }
++    return (participantCount == participants.count());
++}
++
  void ChatManager::onTextChannelAvailable(Tp::TextChannelPtr channel)
+ {
--    if (!mReady) {
--        mPendingChannels.append(channel);
--        return;
--    }
--    ChatEntry *chatEntry = new ChatEntry(channel, this);
--    mChatEntries.append(chatEntry);
--
--    connect(channel.data(),
--            SIGNAL(messageReceived(Tp::ReceivedMessage)),
--            SLOT(onMessageReceived(Tp::ReceivedMessage)));
--    connect(channel.data(),
--            SIGNAL(messageSent(Tp::Message,Tp::MessageSendingFlags,QString)),
--            SLOT(onMessageSent(Tp::Message,Tp::MessageSendingFlags,QString)));
++    mTextChannels << channel;
      connect(channel.data(),
              SIGNAL(invalidated(Tp::DBusProxy*,const QString&, const QString&)),
              SLOT(onChannelInvalidated()));
--    Q_FOREACH(const Tp::ReceivedMessage &message, channel->messageQueue()) {
--        onMessageReceived(message);
--    }
--
--    Q_EMIT chatsChanged();
--    Q_EMIT chatEntryCreated(chatEntry->account()->accountId(), chatEntry->participants(), chatEntry);
++    Q_EMIT textChannelAvailable(channel);
+ }
  void ChatManager::onChannelInvalidated()
+ {
      Tp::TextChannelPtr channel(qobject_cast<Tp::TextChannel*>(sender()));
--    ChatEntry *chatEntry = chatEntryForChannel(channel);
--    if (chatEntry) {
--        mChatEntries.removeAll(chatEntry);
--        // for some reason deleteLater is not working
--        delete chatEntry;
--        Q_EMIT chatsChanged();
--    }
--}
--
--ChatEntry *ChatManager::chatEntryForChannel(const Tp::TextChannelPtr &channel)
--{
--    Q_FOREACH (ChatEntry *chatEntry, mChatEntries) {
--        if (channel == chatEntry->channel()) {
--            return chatEntry;
--        }
--    }
--    return NULL;
--}
--
--void ChatManager::onMessageReceived(const Tp::ReceivedMessage &message)
--{
--    // ignore delivery reports for now
--    // FIXME: we need to handle errors on sending messages at some point
--    if (message.isDeliveryReport()) {
--        return;
--    }
--
--    if (!message.sender()) {
--        return;
--    }
--
--    Q_EMIT messageReceived(message.sender()->id(), message.text(), message.received(), message.messageToken(), true);
--}
--
--void ChatManager::onMessageSent(const Tp::Message &sentMessage, const Tp::MessageSendingFlags flags, const QString &message)
--{
--    Q_UNUSED(message)
--    Q_UNUSED(flags)
--
--    Tp::TextChannel *channel = qobject_cast<Tp::TextChannel*>(sender());
--    if (!channel) {
--        return;
--    }
--
--    QStringList recipients;
--    Q_FOREACH(const Tp::ContactPtr &contact, channel->groupContacts(false)) {
--        recipients << contact->id();
--    }
--
--    Q_EMIT messageSent(recipients, sentMessage.text());
++    mTextChannels.removeAll(channel);
++    Q_EMIT textChannelInvalidated(channel);
+ }
  void ChatManager::acknowledgeMessage(const QVariantMap &properties)
@@ -267,112 +310,3 @@
      mMessagesToAck.clear();
+ }
--
--QList<ChatEntry*> ChatManager::chatEntries() const
--{
--    return mChatEntries;
--}
--
--ChatEntry *ChatManager::chatEntryForProperties(const QString &accountId, const QVariantMap &properties, bool create)
--{
--    QVariantMap propMap = properties;
--    int chatType = 0;
--
--    QStringList participants;
--    // participants coming from qml are variants
--    if (properties.contains("participantIds")) {
--        participants = properties["participantIds"].toStringList();
--        if (!participants.isEmpty()) {
--            propMap["participantIds"] = participants;
--        }
--    }
--
--    if (participants.isEmpty() && propMap.contains("participants")) {
--        // try to generate list of participants from "participants"
--        Q_FOREACH(const QVariant &participantMap, propMap["participants"].toList()) {
--            if (participantMap.toMap().contains("identifier")) {
--                participants << participantMap.toMap()["identifier"].toString();
--            }
--        }
--        if (!participants.isEmpty()) {
--            propMap["participantIds"] = participants;
--        }
--    }
--
--    if (properties.contains("chatType")) {
--        chatType = properties["chatType"].toInt();
--    } else {
--        if (participants.length() == 1) {
--            chatType = 1;
--        }
--    }
--
--    if ((participants.count() == 0 && chatType == 1)  || accountId.isEmpty()) {
--        return NULL;
--    }
--
--    AccountEntry *account = TelepathyHelper::instance()->accountForId(accountId);
--
--    if (!account) {
--        return NULL;
--    }
--
--    Q_FOREACH (ChatEntry *chatEntry, mChatEntries) {
--        int participantCount = 0;
--
--        if (chatType == 2) {
--            QString roomId = propMap["threadId"].toString();
--            if (!roomId.isEmpty() && chatEntry->chatType() == 2 && roomId == chatEntry->chatId()) {
--                return chatEntry;
--            }
--            continue;
--        }
--
--        Tp::Contacts contacts = chatEntry->channel()->groupContacts(false);
--        if (participants.count() != contacts.count()) {
--            continue;
--        }
--        // iterate over participants
--        Q_FOREACH (const Tp::ContactPtr &contact, contacts) {
--            if (account->type() == AccountEntry::PhoneAccount || account->type() == AccountEntry::MultimediaAccount) {
--                Q_FOREACH(const QString &participant, participants) {
--                    if (PhoneUtils::comparePhoneNumbers(participant, contact->id()) > PhoneUtils::NO_MATCH) {
--                        participantCount++;
--                        break;
--                    }
--                }
--                continue;
--            }
--            if (participants.contains(contact->id())) {
--                participantCount++;
--            } else {
--                break;
--            }
--        }
--        if (participantCount == participants.count()) {
--            return chatEntry;
--        }
--    }
--
--    if (create) {
--        QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
--        phoneAppHandler->call("StartChat", accountId, propMap);
--    }
--    return NULL;
--}
--
--QQmlListProperty<ChatEntry> ChatManager::chats()
--{
--    return QQmlListProperty<ChatEntry>(this, 0, chatCount, chatAt);
--}
--
--int ChatManager::chatCount(QQmlListProperty<ChatEntry> *p)
--{
--    return ChatManager::instance()->chatEntries().count();
--}
--
--ChatEntry *ChatManager::chatAt(QQmlListProperty<ChatEntry> *p, int index)
--{
--    return ChatManager::instance()->chatEntries()[index];
--}
--
 === modified file 'libtelephonyservice/chatmanager.h'
 --- libtelephonyservice/chatmanager.h	2016-10-06 19:34:36 +0000
 +++ libtelephonyservice/chatmanager.h	2016-10-06 19:34:37 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2012 Canonical, Ltd.
++ * Copyright (C) 2012-2016 Canonical, Ltd.
+  *
   * Authors:
   *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
@@ -28,57 +28,44 @@
  #include <TelepathyQt/TextChannel>
  #include <TelepathyQt/ReceivedMessage>
  #include "dbustypes.h"
--#include "chatentry.h"
  class ChatManager : public QObject
+ {
      Q_OBJECT
--    Q_PROPERTY(QQmlListProperty<ChatEntry> chats
--                   READ chats
--                   NOTIFY chatsChanged)
  public:
      static ChatManager *instance();
--    Q_INVOKABLE QString sendMessage(const QString &accountId, const QString &message, const QVariant &attachments = QVariant(), const QVariantMap &properties = QVariantMap());
--    Q_INVOKABLE ChatEntry *chatEntryForProperties(const QString &accountId, const QVariantMap &properties, bool create = false);
++    void startChat(const QString &accountId, const QVariantMap &properties);
++    QString sendMessage(const QString &accountId, const QString &message, const QVariant &attachments = QVariant(), const QVariantMap &properties = QVariantMap());
++    QList<Tp::TextChannelPtr> channelForProperties(const QVariantMap &properties);
++    Tp::TextChannelPtr channelForObjectPath(const QString &objectPath);
--    QQmlListProperty<ChatEntry> chats();
--    static int chatCount(QQmlListProperty<ChatEntry> *p);
--    static ChatEntry* chatAt(QQmlListProperty<ChatEntry> *p, int index);
++    static bool channelMatchProperties(const Tp::TextChannelPtr &channel, const QVariantMap &properties);
  Q_SIGNALS:
--    void messageReceived(const QString &sender, const QString &message, const QDateTime &timestamp, const QString &messageId, bool unread);
--    void messageSent(const QStringList &recipients, const QString &message);
--    void chatsChanged();
--    void chatEntryCreated(QString accountId, QStringList participants, ChatEntry *chatEntry);
++    void textChannelAvailable(Tp::TextChannelPtr);
++    void textChannelInvalidated(Tp::TextChannelPtr);
  public Q_SLOTS:
      void onTextChannelAvailable(Tp::TextChannelPtr channel);
      void onChannelInvalidated();
      void onConnectedChanged();
--    void onMessageReceived(const Tp::ReceivedMessage &message);
--    void onMessageSent(const Tp::Message &sentMessage, const Tp::MessageSendingFlags flags, const QString &message);
      void acknowledgeMessage(const QVariantMap &properties);
      void acknowledgeAllMessages(const QVariantMap &properties);
  private Q_SLOTS:
      void onChannelObserverUnregistered();
--    void onTelepathyReady();
  protected Q_SLOTS:
      void onAckTimerTriggered();
  private:
      explicit ChatManager(QObject *parent = 0);
--    ChatEntry *chatEntryForChannel(const Tp::TextChannelPtr &channel);
--    QList<ChatEntry*> chatEntries() const;
--    mutable QList<ChatEntry*> mChatEntries;
      QVariantList mMessagesToAck;
--    QList<Tp::TextChannelPtr> mPendingChannels;
++    QList<Tp::TextChannelPtr> mTextChannels;
      QTimer mMessagesAckTimer;
--    bool mReady;
  };
  #endif // CHATMANAGER_H
 === modified file 'libtelephonyservice/telepathyhelper.cpp'
 --- libtelephonyservice/telepathyhelper.cpp	2016-10-06 19:34:36 +0000
 +++ libtelephonyservice/telepathyhelper.cpp	2016-10-06 19:34:37 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2012-2015 Canonical, Ltd.
++ * Copyright (C) 2012-2016 Canonical, Ltd.
+  *
   * Authors:
   *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
@@ -149,11 +149,14 @@
      return mAccounts;
+ }
--QList<AccountEntry*> TelepathyHelper::activeAccounts() const
++QList<AccountEntry*> TelepathyHelper::activeAccounts(bool includeMultimedia) const
+ {
      QList<AccountEntry*> activeAccountList;
      Q_FOREACH(AccountEntry *account, mAccounts) {
--        if (account->active() && account->type() != AccountEntry::MultimediaAccount) {
++        if (account->active()) {
++            if (account->type() == AccountEntry::MultimediaAccount && !includeMultimedia) {
++                continue;
++            }
              activeAccountList << account;
+         }
+     }
 === modified file 'libtelephonyservice/telepathyhelper.h'
 --- libtelephonyservice/telepathyhelper.h	2016-10-06 19:34:36 +0000
 +++ libtelephonyservice/telepathyhelper.h	2016-10-06 19:34:37 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2012 Canonical, Ltd.
++ * Copyright (C) 2012-2016 Canonical, Ltd.
+  *
   * Authors:
   *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
@@ -75,7 +75,7 @@
      static TelepathyHelper *instance();
      QList<AccountEntry*> accounts() const;
      QList<AccountEntry*> phoneAccounts() const;
--    QList<AccountEntry*> activeAccounts() const;
++    QList<AccountEntry*> activeAccounts(bool includeMultimedia=false) const;
      QQmlListProperty<AccountEntry> qmlAccounts();
      QQmlListProperty<AccountEntry> qmlPhoneAccounts();
      QQmlListProperty<AccountEntry> qmlActiveAccounts();
 === modified file 'tests/handler/HandlerTest.cpp'
 --- tests/handler/HandlerTest.cpp	2016-10-06 19:34:36 +0000
 +++ tests/handler/HandlerTest.cpp	2016-10-06 19:34:37 +0000
@@ -18,6 +18,7 @@
  #include <QtCore/QObject>
  #include <QtTest/QtTest>
++#include <QDBusInterface>
  #include "telepathytest.h"
  #include "chatmanager.h"
  #include "handlercontroller.h"
@@ -27,6 +28,8 @@
  #include "accountentryfactory.h"
  #include "telepathyhelper.h"
++Q_DECLARE_METATYPE(Tp::TextChannelPtr)
++
  class HandlerTest : public TelepathyTest
+ {
      Q_OBJECT
@@ -70,6 +73,8 @@
      QSignalSpy setupReadySpy(TelepathyHelper::instance(), SIGNAL(setupReady()));
      TRY_COMPARE(setupReadySpy.count(), 1);
++    qRegisterMetaType<Tp::TextChannelPtr>();
++
      registerApprover();
+ }
@@ -354,18 +359,24 @@
  void HandlerTest::testAcknowledgeMessage()
+ {
++    QString recipient("84376666");
++    QString recipient2("+554184376666");
++    QString message("Hello, world!");
++
++    QSignalSpy messageSentSpy(mMockController, SIGNAL(MessageSent(QString,QVariantList,QVariantMap)));
++    // first send a message to a certain number so the handler request one channel
++    QString objectPath = HandlerController::instance()->sendMessage(mTpAccount->uniqueIdentifier(), QStringList() << recipient, message);
++    QDBusInterface *sendingJob = new QDBusInterface(TelepathyHelper::instance()->handlerInterface()->service(), objectPath,
++                                                    "com.canonical.TelephonyServiceHandler.MessageSendingJob");
++    QSignalSpy handlerHasChannel(sendingJob, SIGNAL(finished()));
++
++    TRY_COMPARE(messageSentSpy.count(), 1);
++    TRY_COMPARE(handlerHasChannel.count(), 1);
++
      // if we register the observer before this test, other tests fail
--    TelepathyHelper::instance()->registerChannelObserver();
--    QString recipient("84376666");
--    QString recipient2("+554184376666");
--    QString message("Hello, world!");
--    QSignalSpy messageSentSpy(mMockController, SIGNAL(MessageSent(QString,QVariantList,QVariantMap)));
--
--    // first send a message to a certain number so the handler request one channel
--    HandlerController::instance()->sendMessage(mTpAccount->uniqueIdentifier(), QStringList() << recipient, message);
--    TRY_COMPARE(messageSentSpy.count(), 1);
--
--    QSignalSpy messageReceivedSpy(ChatManager::instance(), SIGNAL(messageReceived(QString,QString,QDateTime,QString,bool)));
++    TelepathyHelper::instance()->registerChannelObserver("TelephonyServiceTests");
++    TRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(TP_QT_IFACE_CLIENT + ".TelephonyServiceTests"));
++    QSignalSpy textChannelAvailableSpy(ChatManager::instance(), SIGNAL(textChannelAvailable(Tp::TextChannelPtr)));
      // now receive a message from a very similar number so CM creates another
      // channel and the handler needs to deal with both
@@ -374,8 +385,11 @@
      properties["Recipients"] = (QStringList() << recipient2);
      mMockController->PlaceIncomingMessage(message, properties);
--    TRY_COMPARE(messageReceivedSpy.count(), 1);
--    QString receivedMessageId = messageReceivedSpy.first()[3].toString();
++    TRY_COMPARE(textChannelAvailableSpy.count(), 2);
++    Tp::TextChannelPtr channel = textChannelAvailableSpy[1].first().value<Tp::TextChannelPtr>();
++    QVERIFY(!channel.isNull());
++    TRY_COMPARE(channel->messageQueue().count(), 1);
++    QString receivedMessageId = channel->messageQueue().first().messageToken();
      // then acknowledge the message that arrived in the second channel and make sure handler
      // does the right thing
@@ -404,7 +418,7 @@
      HandlerController::instance()->sendMessage(mTpAccount->uniqueIdentifier(), QStringList() << recipient, message);
      TRY_COMPARE(messageSentSpy.count(), 1);
--    QSignalSpy messageReceivedSpy(ChatManager::instance(), SIGNAL(messageReceived(QString,QString,QDateTime,QString,bool)));
++    QSignalSpy textChannelAvailableSpy(ChatManager::instance(), SIGNAL(textChannelAvailable(Tp::TextChannelPtr)));
      // now receive some messages from a very similar number so CM creates another
      // channel and the handler needs to deal with both
@@ -415,7 +429,11 @@
          mMockController->PlaceIncomingMessage(message.arg(QString::number(i)), properties);
+     }
--    TRY_COMPARE(messageReceivedSpy.count(), messageCount);
++    TRY_COMPARE(textChannelAvailableSpy.count(), 1);
++    Tp::TextChannelPtr channel = textChannelAvailableSpy.first().first().value<Tp::TextChannelPtr>();
++    QVERIFY(!channel.isNull());
++    TRY_COMPARE(channel->messageQueue().count(), messageCount);
++    QString receivedMessageId = channel->messageQueue().first().messageToken();
      // then acknowledge the messages that arrived in the second channel and make sure handler
      // does the right thing
@@ -491,8 +509,13 @@
      QSignalSpy messageSentOfonoSpy(mOfonoMockController, SIGNAL(MessageSent(QString,QVariantList,QVariantMap)));
      QSignalSpy messageSentMultimediaSpy(mMultimediaMockController, SIGNAL(MessageSent(QString,QVariantList,QVariantMap)));
--    QString accountId = HandlerController::instance()->sendMessage(mOfonoTpAccount->uniqueIdentifier(), QStringList() << recipient, message);
--    QCOMPARE(accountId, mMultimediaTpAccount->uniqueIdentifier());
++    QString jobObjectPath = HandlerController::instance()->sendMessage(mOfonoTpAccount->uniqueIdentifier(), QStringList() << recipient, message);
++
++    QDBusInterface jobInterface(TelepathyHelper::instance()->handlerInterface()->service(),
++                               jobObjectPath);
++    QSignalSpy finishedSpy(&jobInterface, SIGNAL(finished()));
++    TRY_COMPARE(finishedSpy.count(), 1);
++    QCOMPARE(jobInterface.property("accountId").toString(), mMultimediaTpAccount->uniqueIdentifier());
      TRY_COMPARE(messageSentMultimediaSpy.count(), 1);
      QCOMPARE(messageSentOfonoSpy.count(), 0);
      QString sentMessage = messageSentMultimediaSpy.first().first().toString();
 === modified file 'tests/libtelephonyservice/ChatEntryTest.cpp'
 --- tests/libtelephonyservice/ChatEntryTest.cpp	2016-10-06 19:34:36 +0000
 +++ tests/libtelephonyservice/ChatEntryTest.cpp	2016-10-06 19:34:37 +0000
@@ -93,6 +93,7 @@
      QFETCH(QString, accountId);
      QFETCH(QStringList, participants);
++    /*
      MockController *mockController = accountId.startsWith("mock/mock") ? mGenericMockController : mMultimediaMockController;
      QSignalSpy chatEntryCreatedSpy(ChatManager::instance(), SIGNAL(chatEntryCreated(QString, QStringList,ChatEntry *)));
@@ -137,6 +138,7 @@
          QTRY_COMPARE(chatStateChangedSpy2.count(), 1);
          QCOMPARE(contactChatState2->state(), (int)ChatEntry::ChannelChatStatePaused);
+     }
++    */
+ }
  QTEST_MAIN(ChatEntryTest)
 === modified file 'tests/libtelephonyservice/ChatManagerTest.cpp'
 --- tests/libtelephonyservice/ChatManagerTest.cpp	2016-10-06 19:34:36 +0000
 +++ tests/libtelephonyservice/ChatManagerTest.cpp	2016-10-06 19:34:37 +0000
@@ -24,6 +24,8 @@
  #include "telepathyhelper.h"
  #include "mockcontroller.h"
++Q_DECLARE_METATYPE(Tp::TextChannelPtr)
++
  class ChatManagerTest : public TelepathyTest
+ {
      Q_OBJECT
@@ -36,9 +38,7 @@
      void testSendMessage();
      void testSendMessageWithAttachments_data();
      void testSendMessageWithAttachments();
--    void testMessageReceived();
      void testAcknowledgeMessages();
--    void testChatEntry();
  private:
      Tp::AccountPtr mGenericTpAccount;
@@ -54,6 +54,8 @@
      TelepathyHelper::instance()->setMmsGroupChat(false);
      TelepathyHelper::instance()->registerChannelObserver();
++    qRegisterMetaType<Tp::TextChannelPtr>();
++
      // just give telepathy some time to register the observer
      QTest::qWait(1000);
+ }
@@ -102,11 +104,15 @@
      MockController *controller = accountId.startsWith("mock/mock") ? mGenericMockController : mPhoneMockController;
      QSignalSpy controllerMessageSentSpy(controller, SIGNAL(MessageSent(QString,QVariantList,QVariantMap)));
--    QSignalSpy messageSentSpy(ChatManager::instance(), SIGNAL(messageSent(QStringList,QString)));
      QVariantMap properties;
      properties["participantIds"] = recipients;
--    ChatManager::instance()->sendMessage(accountId, message, QVariantMap(), properties);
++    QString jobObjectPath = ChatManager::instance()->sendMessage(accountId, message, QVariantMap(), properties);
++
++    QDBusInterface iface(TelepathyHelper::instance()->handlerInterface()->service(),
++                         jobObjectPath);
++
++    QSignalSpy finishedSpy(&iface, SIGNAL(finished()));
      TRY_COMPARE(controllerMessageSentSpy.count(), 1);
      QString messageText = controllerMessageSentSpy.first()[0].toString();
@@ -116,34 +122,13 @@
      QCOMPARE(messageText, message);
      QCOMPARE(messageRecipients, recipients);
--    TRY_COMPARE(messageSentSpy.count(), 1);
--    messageRecipients = messageSentSpy.first()[0].toStringList();
--    qSort(messageRecipients);
--    messageText = messageSentSpy.first()[1].toString();
--    QCOMPARE(messageText, message);
--    QCOMPARE(messageRecipients, recipients);
--}
--
--void ChatManagerTest::testMessageReceived()
--{
--    QSignalSpy messageReceivedSpy(ChatManager::instance(), SIGNAL(messageReceived(QString,QString,QDateTime,QString,bool)));
--
--    QVariantMap properties;
--    properties["Sender"] = "12345";
--    properties["Recipients"] = (QStringList() << "12345");
--    QString message("Hi there");
--    mGenericMockController->PlaceIncomingMessage(message, properties);
--
--    TRY_COMPARE(messageReceivedSpy.count(), 1);
--    QString sender = messageReceivedSpy.first()[0].toString();
--    QString receivedMessage = messageReceivedSpy.first()[1].toString();
--    QCOMPARE(sender, properties["Sender"].toString());
--    QCOMPARE(receivedMessage, message);
++    // the rest of the properties are tested in the MessageSendingJob tests.
++    TRY_COMPARE(finishedSpy.count(), 1);
+ }
  void ChatManagerTest::testAcknowledgeMessages()
+ {
--    QSignalSpy messageReceivedSpy(ChatManager::instance(), SIGNAL(messageReceived(QString,QString,QDateTime,QString,bool)));
++    QSignalSpy textChannelAvailableSpy(ChatManager::instance(), SIGNAL(textChannelAvailable(Tp::TextChannelPtr)));
      QVariantMap properties;
      properties["Sender"] = "12345";
@@ -155,12 +140,14 @@
          // the wait shouldn't be needed, but just in case
          QTest::qWait(50);
+     }
--    TRY_COMPARE(messageReceivedSpy.count(), messages.count());
++    TRY_COMPARE(textChannelAvailableSpy.count(), 1);
++    Tp::TextChannelPtr channel = textChannelAvailableSpy.first().first().value<Tp::TextChannelPtr>();
++    QVERIFY(!channel.isNull());
++    TRY_COMPARE(channel->messageQueue().count(), messages.count());
      QStringList messageIds;
      for (int i = 0; i < messages.count(); ++i) {
--        QString messageId = messageReceivedSpy[i][3].toString();
--        messageIds << messageId;
++        messageIds << channel->messageQueue()[i].messageToken();
+     }
      QSignalSpy messageReadSpy(mGenericMockController, SIGNAL(MessageRead(QString)));
@@ -183,26 +170,6 @@
      QCOMPARE(receivedIds, messageIds);
+ }
--void ChatManagerTest::testChatEntry()
--{
--    QStringList recipients;
--    recipients << "user@domain.com" << "user2@domain.com";
--    QSignalSpy chatEntryCreatedSpy(ChatManager::instance(), SIGNAL(chatEntryCreated(QString, QStringList,ChatEntry *)));
--    QVariantMap properties;
--    properties["participantIds"] = recipients;
--
--    ChatEntry *entry = ChatManager::instance()->chatEntryForProperties("mock/mock/account0", properties, true);
--    QVERIFY(entry == NULL);
--    QTRY_COMPARE(chatEntryCreatedSpy.count(), 1);
--
--    entry = ChatManager::instance()->chatEntryForProperties("mock/mock/account0", properties, false);
--    QVERIFY(entry != NULL);
--    QList<QVariant> arguments = chatEntryCreatedSpy.takeFirst();
--    QCOMPARE(QString("mock/mock/account0"), arguments.at(0).toString());
--    QCOMPARE(recipients.toSet(), arguments.at(1).toStringList().toSet());
--    QCOMPARE(entry, arguments.at(2).value<ChatEntry*>());
--}
--
  void ChatManagerTest::testSendMessageWithAttachments_data()
+ {
      QTest::addColumn<QStringList>("recipients");