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

[Gustavo Pichorim Boiko]

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

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

[lp:~phablet-team/telephony-service/async_send_message]

1204. By Gustavo Pichorim Boiko on 2016-05-24

Fix some problems, remove some code not needed anymore and add some debug.

1205. By Gustavo Pichorim Boiko on 2016-05-24

Remove empty spaces.

1206. By Gustavo Pichorim Boiko on 2016-05-31

Change ChatEntry to fetch channels from ChatManager and to send messages using the new asynchronous API.

1207. By Gustavo Pichorim Boiko on 2016-05-31

Merge parent branch

1208. By Gustavo Pichorim Boiko on 2016-05-31

Implement channel matching.

1209. By Gustavo Pichorim Boiko on 2016-05-31

Expose the chatentry to QML.

1210. By Gustavo Pichorim Boiko on 2016-05-31

Make it possible to set the chat type

1211. By Gustavo Pichorim Boiko on 2016-06-01

Finish implementing the message sending job and make use of it in chatentry.

1212. By Gustavo Pichorim Boiko on 2016-06-01

Watch for new channels.

1213. By Gustavo Pichorim Boiko on 2016-06-01

Do not pass the interface when registering the jobs, it is already present in
the adaptor.

1214. By Gustavo Pichorim Boiko on 2016-06-01

Start chat with accounts that might have typing notifications.

1215. By Gustavo Pichorim Boiko on 2016-06-03

Ignore message sending job adaptor.

1216. By Gustavo Pichorim Boiko on 2016-06-04

Fix ChatManager tests.

1217. By Gustavo Pichorim Boiko on 2016-06-04

Fix handler tests

1218. By Gustavo Pichorim Boiko on 2016-06-09

Set also the threadId in properties so that the channel gets
created correctly.

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

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

1222. By Gustavo Pichorim Boiko on 2016-06-15

merge parent

1223. By Gustavo Pichorim Boiko on 2016-06-15

Do not delete the interface classes. They are destroyed together with the channel itself.

1224. By Gustavo Pichorim Boiko on 2016-07-02

Update copyright headers.

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

=== modified file '.bzrignore'
--- .bzrignore	2015-07-02 03:35:20 +0000
+++ .bzrignore	2016-05-24 01:13:17 +0000
@@ -57,3 +57,4 @@
 tests/libtelephonyservice/GreeterContactsTestExe
 tests/libtelephonyservice/GreeterContactsTestServerExe
 tests/libtelephonyservice/*Mock
+tests/indicator/NotificationsInterface.*
 
=== modified file 'approver/TelephonyServiceApprover.client'
--- approver/TelephonyServiceApprover.client	2013-07-17 17:50:32 +0000
+++ approver/TelephonyServiceApprover.client	2016-05-24 01:13:17 +0000
@@ -8,7 +8,6 @@
 
 [org.freedesktop.Telepathy.Client.Approver.ApproverChannelFilter 1]
 org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Text
-org.freedesktop.Telepathy.Channel.TargetHandleType u=1
 
 [org.freedesktop.Telepathy.Client.Approver.Capabilities]
 org.freedesktop.Telepathy.Channel.Type.Call1/audio=true
 
=== modified file 'approver/approver.cpp'
--- approver/approver.cpp	2016-01-05 17:14:32 +0000
+++ approver/approver.cpp	2016-05-24 01:13:17 +0000
@@ -412,10 +412,12 @@
 void Approver::onRejectMessage(Tp::ChannelDispatchOperationPtr dispatchOp, const char *action)
 {
     if (mRejectActions.contains(action)) {
-        QString targetId = dispatchOp->channels().first()->targetContact()->id();
+        QVariantMap properties;
+        properties["participantIds"] = QStringList() << dispatchOp->channels().first()->targetContact()->id();
         ChatManager::instance()->sendMessage(dispatchOp->account()->uniqueIdentifier(),
-                                             QStringList() << targetId,
-                                             mRejectActions[action]);
+                                             mRejectActions[action],
+                                             QVariantMap(), // attachments
+                                             properties);
     }
 
     onRejected(dispatchOp);
 
=== modified file 'handler/CMakeLists.txt'
--- handler/CMakeLists.txt	2016-03-18 19:02:50 +0000
+++ handler/CMakeLists.txt	2016-05-24 01:13:17 +0000
@@ -1,8 +1,11 @@
 
 set(qt_SRCS
     callhandler.cpp
+    chatstartingjob.cpp
     handler.cpp
     handlerdbus.cpp
+    messagejob.cpp
+    messagesendingjob.cpp
     texthandler.cpp
     )
 
 
=== modified file 'handler/Handler.xml'
--- handler/Handler.xml	2015-12-07 16:26:20 +0000
+++ handler/Handler.xml	2016-05-24 01:13:17 +0000
@@ -16,13 +16,12 @@
                Request to send a message to one or multiple recipients
             ]]></dox:d>
             <arg name="accountId" type="s" direction="in"/>
-            <arg name="recipients" type="as" 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.In3" value="AttachmentList"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In2" value="AttachmentList"/>
             <arg name="properties" type="a{sv}" direction="in"/>
-            <annotation name="org.qtproject.QtDBus.QtTypeName.In4" value="QVariantMap"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In3" value="QVariantMap"/>
         </method>
         <method name="AcknowledgeMessages">
             <dox:d><![CDATA[
@@ -37,16 +36,8 @@
                 Start a chat with the given participants
             ]]></dox:d>
             <arg name="accountId" type="s" direction="in"/>
-            <arg name="participants" type="as" direction="in"/>
-        </method>
-        <method name="StartChatRoom">
-            <dox:d><![CDATA[
-                Start a chat room with the given properties
-            ]]></dox:d>
-            <arg name="accountId" type="s" direction="in"/>
-            <arg name="initialParticipants" type="as" direction="in"/>
             <arg name="properties" type="a{sv}" direction="in"/>
-            <annotation name="org.qtproject.QtDBus.QtTypeName.In2" value="QVariantMap"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
         </method>
         <method name="AcknowledgeAllMessages">
             <dox:d><![CDATA[
 
=== modified file 'handler/TelephonyServiceHandler.client'
--- handler/TelephonyServiceHandler.client	2014-11-19 17:39:57 +0000
+++ handler/TelephonyServiceHandler.client	2016-05-24 01:13:17 +0000
@@ -3,11 +3,6 @@
 
 [org.freedesktop.Telepathy.Client.Handler.HandlerChannelFilter 0]
 org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Text
-org.freedesktop.Telepathy.Channel.TargetHandleType u=1
-
-[org.freedesktop.Telepathy.Client.Handler.HandlerChannelFilter 1]
-org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Text
-org.freedesktop.Telepathy.Channel.TargetHandleType u=0
-
-[org.freedesktop.Telepathy.Client.Handler.HandlerChannelFilter 2]
+
+[org.freedesktop.Telepathy.Client.Handler.HandlerChannelFilter 3]
 org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Call1
 
=== added file 'handler/chatstartingjob.cpp'
--- handler/chatstartingjob.cpp	1970-01-01 00:00:00 +0000
+++ handler/chatstartingjob.cpp	2016-05-24 01:13:17 +0000
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[e-mail]>
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * 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 "telepathyhelper.h"
+#include "texthandler.h"
+#include <TelepathyQt/PendingChannelRequest>
+
+ChatStartingJob::ChatStartingJob(TextHandler *textHandler, const QString &accountId, const QVariantMap &properties)
+: MessageJob(textHandler), mAccountId(accountId), mProperties(properties)
+{
+}
+
+void ChatStartingJob::startJob()
+{
+    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)
+{
+    Tp::PendingChannelRequest *op = NULL;
+    QStringList participants = properties["participantIds"].toStringList();
+    switch(participants.size()) {
+    case 0:
+        qCritical() << "Error: No participant list provided";
+        return;
+    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)
+{
+    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
+{
+    return mTextChannel;
+}
+
+void ChatStartingJob::setTextChannel(Tp::TextChannelPtr channel)
+{
+    mTextChannel = channel;
+    Q_EMIT textChannelChanged();
+}
+
+void ChatStartingJob::onChannelRequestFinished(Tp::PendingOperation *op)
+{
+    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-05-24 01:13:17 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[e-mail]>
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * 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(Tp::TextChannelPtr textChannel READ textChannel NOTIFY textChannelChanged)
+public:
+    ChatStartingJob(TextHandler *textHandler, const QString &accountId, const QVariantMap &properties);
+
+    Tp::TextChannelPtr textChannel() const;
+
+public Q_SLOTS:
+    virtual void startJob();
+
+Q_SIGNALS:
+    void textChannelChanged();
+
+
+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	2015-12-07 16:26:20 +0000
+++ handler/handlerdbus.cpp	2016-05-24 01:13:17 +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);
@@ -93,9 +113,9 @@
     return true;
 }
 
-QString HandlerDBus::SendMessage(const QString &accountId, const QStringList &recipients, const QString &message, const AttachmentList &attachments, const QVariantMap &properties)
+QString HandlerDBus::SendMessage(const QString &accountId, const QString &message, const AttachmentList &attachments, const QVariantMap &properties)
 {
-    return TextHandler::instance()->sendMessage(accountId, recipients, message, attachments, properties);
+    return TextHandler::instance()->sendMessage(accountId, message, attachments, properties);
 }
 
 void HandlerDBus::AcknowledgeMessages(const QStringList &numbers, const QStringList &messageIds, const QString &accountId)
@@ -103,14 +123,9 @@
     TextHandler::instance()->acknowledgeMessages(numbers, messageIds, accountId);
 }
 
-void HandlerDBus::StartChat(const QString &accountId, const QStringList &participants)
-{
-    TextHandler::instance()->startChat(participants, accountId);
-}
-
-void HandlerDBus::StartChatRoom(const QString &accountId, const QStringList &initialParticipants, const QVariantMap &properties)
-{
-    TextHandler::instance()->startChatRoom(accountId, initialParticipants, properties);
+void HandlerDBus::StartChat(const QString &accountId, const QVariantMap &properties)
+{
+    TextHandler::instance()->startChat(accountId, properties);
 }
 
 void HandlerDBus::AcknowledgeAllMessages(const QStringList &numbers, const QString &accountId)
 
=== modified file 'handler/handlerdbus.h'
--- handler/handlerdbus.h	2015-12-07 16:26:20 +0000
+++ handler/handlerdbus.h	2016-05-24 01:13:17 +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,14 +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 QStringList &recipients, const QString &message, const AttachmentList &attachments, const QVariantMap &properties);
+    QString SendMessage(const QString &accountId, const QString &message, const AttachmentList &attachments, const QVariantMap &properties);
     Q_NOREPLY void AcknowledgeMessages(const QStringList &numbers, const QStringList &messageIds, const QString &accountId);
-    Q_NOREPLY void StartChat(const QString &accountId, const QStringList &participants);
-    Q_NOREPLY void StartChatRoom(const QString &accountId, const QStringList &initialParticipants, const QVariantMap &properties);
+    Q_NOREPLY void StartChat(const QString &accountId, const QVariantMap &properties);
     Q_NOREPLY void AcknowledgeAllMessages(const QStringList &numbers, const QString &accountId);
 
     // call related
 
=== modified file 'handler/main.cpp'
--- handler/main.cpp	2016-03-18 19:02:50 +0000
+++ handler/main.cpp	2016-05-24 01:13:17 +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-05-24 01:13:17 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[e-mail]>
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * 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 <QCoreApplication>
+#include <QTime>
+#include <QTimer>
+
+MessageJob::MessageJob(QObject *parent)
+: QObject(parent), mStatus(Pending), mFinished(false)
+{
+}
+
+MessageJob::~MessageJob()
+{
+}
+
+MessageJob::Status MessageJob::status() const
+{
+    return mStatus;
+}
+
+bool MessageJob::isFinished() const
+{
+    return mFinished;
+}
+
+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-05-24 01:13:17 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[e-mail]>
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * 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>
+
+class MessageJob : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(Status status READ status NOTIFY statusChanged)
+    Q_PROPERTY(bool isFinished READ isFinished NOTIFY isFinishedChanged)
+    Q_ENUMS(Status)
+public:
+    enum Status {
+        Pending,
+        Initialising,
+        Running,
+        Finished,
+        Failed
+    };
+
+    explicit MessageJob(QObject *parent = 0);
+    virtual ~MessageJob();
+
+    Status status() const;
+    bool isFinished() 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;
+};
+
+#endif // MESSAGEJOB_H
 
=== added file 'handler/messagesendingjob.cpp'
--- handler/messagesendingjob.cpp	1970-01-01 00:00:00 +0000
+++ handler/messagesendingjob.cpp	2016-05-24 01:13:17 +0000
@@ -0,0 +1,375 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[e-mail]>
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * 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 "handlerdbus.h"
+#include "messagesendingjob.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(textHandler), mMessage(message), mFinished(false)
+{
+    static ulong count = 0;
+    // just to avoid overflowing
+    if (count == ULONG_MAX) {
+        count = 0;
+    }
+    mObjectPath = HandlerDBus::instance()->registerObject(this, QString("messagesendingjob%1").arg(count++));
+}
+
+MessageSendingJob::~MessageSendingJob()
+{
+    HandlerDBus::instance()->unregisterObject(mObjectPath);
+}
+
+QString MessageSendingJob::accountId() const
+{
+    return mAccountId;
+}
+
+QString MessageSendingJob::channelObjectPath() const
+{
+    return mChannelObjectPath;
+}
+
+QString MessageSendingJob::objectPath() const
+{
+    return mObjectPath;
+}
+
+void MessageSendingJob::startJob()
+{
+    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()
+{
+    // 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();
+    }
+
+    mTextChannel = channels.last();
+    sendMessage();
+}
+
+void MessageSendingJob::sendMessage()
+{
+    Tp::PendingSendMessage *op = mTextChannel->send(buildMessage(mMessage));
+    connect(op, &Tp::PendingOperation::finished, [this, op]() {
+        if (op->isError()) {
+            setStatus(Failed);
+            scheduleDeletion();
+            return;
+        }
+
+        setChannelObjectPath(mTextChannel->objectPath());
+        setStatus(Finished);
+        scheduleDeletion();
+    });
+}
+
+void MessageSendingJob::setAccountId(const QString &accountId)
+{
+    mAccountId = accountId;
+    Q_EMIT accountIdChanged();
+}
+
+void MessageSendingJob::setChannelObjectPath(const QString &objectPath)
+{
+    mChannelObjectPath = objectPath;
+    Q_EMIT channelObjectPathChanged();
+}
+
+Tp::MessagePartList MessageSendingJob::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;
+}
+
+
 
=== added file 'handler/messagesendingjob.h'
--- handler/messagesendingjob.h	1970-01-01 00:00:00 +0000
+++ handler/messagesendingjob.h	2016-05-24 01:13:17 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * Authors:
+ *  Tiago Salem Herrmann <[e-mail]>
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * 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 <QDBusContext>
+#include <TelepathyQt/Types>
+#include "dbustypes.h"
+#include "messagejob.h"
+
+class AccountEntry;
+class TextHandler;
+
+struct PendingMessage {
+    QString accountId;
+    QString message;
+    AttachmentList attachments;
+    QVariantMap properties;
+};
+Q_DECLARE_METATYPE(PendingMessage)
+
+class MessageSendingJob : public MessageJob, protected QDBusContext
+{
+    Q_OBJECT
+    Q_PROPERTY(QString accountId READ accountId NOTIFY accountIdChanged)
+    Q_PROPERTY(QString channelObjectPath READ channelObjectPath NOTIFY channelObjectPathChanged)
+    Q_PROPERTY(QString objectPath READ objectPath CONSTANT)
+
+public:
+    explicit MessageSendingJob(TextHandler *textHandler, PendingMessage message);
+    ~MessageSendingJob();
+
+    QString accountId() const;
+    QString channelObjectPath() const;
+    QString objectPath() const;
+
+Q_SIGNALS:
+    void accountIdChanged();
+    void channelObjectPathChanged();
+    void messageStatusChanged();
+
+public Q_SLOTS:
+    void startJob();
+
+protected Q_SLOTS:
+    void findOrCreateChannel();
+    void sendMessage();
+
+    void setAccountId(const QString &accountId);
+    void setChannelObjectPath(const QString &objectPath);
+
+private:
+    TextHandler *mTextHandler;
+    PendingMessage mMessage;
+    QString mAccountId;
+    AccountEntry *mAccount;
+    QString mChannelObjectPath;
+    Tp::TextChannelPtr mTextChannel;
+    QString mObjectPath;
+    bool mFinished;
+
+    Tp::MessagePartList buildMessage(const PendingMessage &pendingMessage);
+
+};
+
+#endif // MESSAGESENDINGJOB_H
 
=== modified file 'handler/texthandler.cpp'
--- handler/texthandler.cpp	2016-03-01 18:17:57 +0000
+++ handler/texthandler.cpp	2016-05-24 01:13:17 +0000
@@ -26,38 +26,12 @@
 #include "config.h"
 #include "dbustypes.h"
 #include "accountentry.h"
+#include "chatstartingjob.h"
 
 #include <QImage>
 #include <TelepathyQt/ContactManager>
 #include <TelepathyQt/PendingContacts>
-
-#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>"
+#include <TelepathyQt/PendingChannelRequest>
 
 TextHandler::TextHandler(QObject *parent)
 : QObject(parent)
@@ -93,7 +67,7 @@
             }
             bool found = false;
             // avoid adding twice the same list of participants
-            Q_FOREACH(const QStringList &recipients, recipientsList) {
+/*            Q_FOREACH(const QStringList &recipients, recipientsList) {
                 if (recipients == pendingMessage.recipients) {
                     found = true;
                     break;
@@ -101,10 +75,9 @@
             }
             if (!found) {
                 recipientsList << pendingMessage.recipients;
-            }
-        }
-        Q_FOREACH(const QStringList& recipients, recipientsList) {
-            startChat(recipients, accountId);
+            }*/
+            // TODO AVOID CALLING TWICE FOR SAME CHANNEL
+            startChat(accountId, pendingMessage.properties);
         }
     }
 }
@@ -115,271 +88,33 @@
     return handler;
 }
 
-void TextHandler::startChat(const QStringList &recipients, const QString &accountId)
-{
-    // 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->connected()) {
-        qCritical() << "The selected account does not have a connection. AccountId:" << accountId;
-        return;
-    }
-
-    connect(account->account()->connection()->contactManager()->contactsForIdentifiers(recipients),
-            SIGNAL(finished(Tp::PendingOperation*)),
-            SLOT(onContactsAvailable(Tp::PendingOperation*)));
-}
-
-void TextHandler::startChatRoom(const QString &accountId, const QStringList &initialParticipants, const QVariantMap &properties)
-{
-    Q_UNUSED(accountId)
-    Q_UNUSED(initialParticipants)
-    Q_UNUSED(properties)
-    // FIXME: implement
-}
-
-void TextHandler::startChat(const Tp::AccountPtr &account, const Tp::Contacts &contacts)
-{
-    if (contacts.size() == 1) {
-        account->ensureTextChat(contacts.values()[0], QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
-    } else {
-        account->createConferenceTextChat(QList<Tp::ChannelPtr>(), contacts.toList(), QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
-    }
-    // start chatting to the contacts
-    Q_FOREACH(Tp::ContactPtr contact, contacts) {
-        // hold the ContactPtr to make sure its refcounting stays bigger than 0
-        mContacts[account->uniqueIdentifier()][contact->id()] = contact;
-    }
-}
-
-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.recipients.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["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::sendMessage(const QString &accountId, const QStringList &recipients, 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 && recipients.size() == 1) {
-        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 = false;
-            // if the account is offline, dont fallback to this account
-            if (!newAccount->connected()) {
-                continue;
-            }
-            QList<Tp::TextChannelPtr> channels = existingChannels(recipients, newAccount->accountId());
-            // 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
-                Tp::Presence presence = channels.first()->targetContact()->presence();
-                shouldFallback = (presence.type() == Tp::ConnectionPresenceTypeAvailable ||
-                    presence.type() == Tp::ConnectionPresenceTypeOffline);
-            } else {
-                Tp::PendingOperation *op = newAccount->account()->connection()->contactManager()->contactsForIdentifiers(recipients);
-                while (!op->isFinished()) {
-                    qApp->processEvents();
-                }
-                Tp::PendingContacts *pc = qobject_cast<Tp::PendingContacts*>(op);
-                if (pc) {
-                    Tp::Presence presence = pc->contacts().first()->presence();
-                    shouldFallback = (presence.type() == Tp::ConnectionPresenceTypeAvailable ||
-                        presence.type() == Tp::ConnectionPresenceTypeOffline);
-                }
-            }
-            if (shouldFallback) {
-                account = newAccount;
-                break;
-            }
-        }
-    }
-
-    // keep recipient list always sorted to be able to compare
-    QStringList sortedRecipients = recipients;
-    sortedRecipients.sort();
-    PendingMessage pendingMessage = {account->accountId(), sortedRecipients, message, attachments, properties};
-
-    if (!account->connected()) {
-        mPendingMessages.append(pendingMessage);
-        return account->accountId();
-    }
-
-    QList<Tp::TextChannelPtr> channels = existingChannels(recipients, account->accountId());
-    if (channels.isEmpty()) {
-        mPendingMessages.append(pendingMessage);
-        startChat(sortedRecipients, account->accountId());
-        return account->accountId();
-    }
-
-    connect(channels.last()->send(buildMessage(pendingMessage)),
-            SIGNAL(finished(Tp::PendingOperation*)),
-            SLOT(onMessageSent(Tp::PendingOperation*)));
-
-    return account->accountId();
+void TextHandler::startChat(const QString &accountId, const QVariantMap &properties)
+{
+    ChatStartingJob *job = new ChatStartingJob(this, accountId, properties);
+    QTimer::singleShot(0, job, &ChatStartingJob::startJob);
+    // FIXME: do we care about the result?
+}
+
+QString TextHandler::sendMessage(const QString &accountId, const QString &message, const AttachmentList &attachments, const QVariantMap &properties)
+{
+    PendingMessage pendingMessage = {accountId, message, attachments, properties};
+    MessageSendingJob *job = new MessageSendingJob(this, pendingMessage);
+    QTimer::singleShot(0, job, &MessageSendingJob::startJob);
+
+    // FIXME: just for a first stage, we synchronously wait for the job to finish and return the accountId as usual
+    while (!job->isFinished()) {
+        QCoreApplication::processEvents();
+    }
+
+    return job->accountId();
 }
 
 void TextHandler::acknowledgeMessages(const QStringList &recipients, const QStringList &messageIds, const QString &accountId)
 {
-    QList<Tp::TextChannelPtr> channels = existingChannels(recipients, accountId);
+    QVariantMap properties;
+    properties["participantIds"] = recipients;
+
+    QList<Tp::TextChannelPtr> channels = existingChannels(accountId, properties);
     if (channels.isEmpty()) {
         return;
     }
@@ -397,7 +132,9 @@
 
 void TextHandler::acknowledgeAllMessages(const QStringList &recipients, const QString &accountId)
 {
-    QList<Tp::TextChannelPtr> channels = existingChannels(recipients, accountId);
+    QVariantMap properties;
+    properties["participantIds"] = recipients;
+    QList<Tp::TextChannelPtr> channels = existingChannels(accountId, properties);
     if (channels.isEmpty()) {
         return;
     }
@@ -411,14 +148,11 @@
 {
     Tp::TextChannelPtr textChannel(qobject_cast<Tp::TextChannel*>(sender()));
     mChannels.removeAll(textChannel);
-    AccountEntry *account = TelepathyHelper::instance()->accountForConnection(textChannel->connection());
-    if (account) {
-       mContacts.remove(account->accountId());
-    }
 }
 
 void TextHandler::onTextChannelAvailable(Tp::TextChannelPtr channel)
 {
+    qDebug() << "TextHandler::onTextChannelAvailable" << channel;
     AccountEntry *account = TelepathyHelper::instance()->accountForConnection(channel->connection());
     if (!account) {
         return;
@@ -438,10 +172,9 @@
     QList<PendingMessage>::iterator it = mPendingMessages.begin();
     while (it != mPendingMessages.end()) {
         bool found = false;
-        Q_FOREACH(const Tp::TextChannelPtr &existingChannel, existingChannels(it->recipients, it->accountId)) {
+        Q_FOREACH(const Tp::TextChannelPtr &existingChannel, existingChannels(it->accountId, it->properties)) {
             if (existingChannel == channel) {
-                // FIXME: we can't trust recipients for group chats in regular IM accounts
-                sendMessage(it->accountId, it->recipients, it->message, it->attachments, it->properties);
+                sendMessage(it->accountId, it->message, it->attachments, it->properties);
                 it = mPendingMessages.erase(it);
                 found = true;
                 break;
@@ -453,23 +186,15 @@
     }
 }
 
-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 QStringList &targetIds, const QString &accountId)
+QList<Tp::TextChannelPtr> TextHandler::existingChannels(const QString &accountId, const QVariantMap &properties)
 {
     QList<Tp::TextChannelPtr> channels;
+    QStringList targetIds = properties["participantIds"].toStringList();
+    int chatType = properties["chatType"].toUInt();
+    if (chatType == 0 && targetIds.size() == 1) {
+        chatType = 1;
+    }
+    QString roomId = properties["threadId"].toString();
 
     Q_FOREACH(const Tp::TextChannelPtr &channel, mChannels) {
         int count = 0;
@@ -479,6 +204,17 @@
             continue;
         }
 
+        if (chatType != channel->targetHandleType()) {
+            continue;
+        }
+
+        if (chatType == 2) {
+            if (!roomId.isEmpty() && channel->targetHandleType() == chatType && roomId == channel->targetId()) {
+                channels.append(channel);
+            }
+            continue;
+        }
+
         // this is a special case. We have to check if we are looking for a channel open with our self contact.
         bool channelToSelfContact = channel->groupContacts(true).size() == 1 && targetIds.size() == 1 &&
                           channel->targetHandleType() == Tp::HandleTypeContact &&
@@ -507,17 +243,3 @@
     }
     return channels;
 }
-
-void TextHandler::onContactsAvailable(Tp::PendingOperation *op)
-{
-    Tp::PendingContacts *pc = qobject_cast<Tp::PendingContacts*>(op);
-
-    if (!pc) {
-        qCritical() << "The pending object is not a Tp::PendingContacts";
-        return;
-    }
-    AccountEntry *account = TelepathyHelper::instance()->accountForConnection(pc->manager()->connection());
-    startChat(account->account(), pc->contacts().toSet());
-}
-
-
 
=== modified file 'handler/texthandler.h'
--- handler/texthandler.h	2015-12-07 16:26:20 +0000
+++ handler/texthandler.h	2016-05-24 01:13:17 +0000
@@ -27,46 +27,35 @@
 #include <TelepathyQt/TextChannel>
 #include <TelepathyQt/ReceivedMessage>
 #include "dbustypes.h"
-
-struct PendingMessage {
-    QString accountId;
-    QStringList recipients;
-    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 QStringList &recipients, const QString &accountId);
-    void startChatRoom(const QString &accountId, const QStringList &initialParticipants, const QVariantMap &properties);
-    void startChat(const Tp::AccountPtr &account, const Tp::Contacts &contacts);
+    void startChat(const QString &accountId, const QVariantMap &properties);
+
+    friend class MessageSendingJob;
 
 public Q_SLOTS:
-    QString sendMessage(const QString &accountId, const QStringList &recipients, const QString &message, const AttachmentList &attachments, const QVariantMap &properties);
+    QString sendMessage(const QString &accountId, const QString &message, const AttachmentList &attachments, const QVariantMap &properties);
     void acknowledgeMessages(const QStringList &recipients, const QStringList &messageIds, const QString &accountId);
     void acknowledgeAllMessages(const QStringList &recipients, const QString &accountId);
 
 protected Q_SLOTS:
     void onTextChannelAvailable(Tp::TextChannelPtr channel);
     void onTextChannelInvalidated();
-    void onContactsAvailable(Tp::PendingOperation *op);
-    void onMessageSent(Tp::PendingOperation *op);
     void onConnectedChanged();
 
 protected:
-    QList<Tp::TextChannelPtr> existingChannels(const QStringList &targetIds, const QString &accountId);
+    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;
-    QMap<QString, QMap<QString, Tp::ContactPtr> > mContacts;
     QList<PendingMessage> mPendingMessages;
 };
 
 
=== modified file 'indicator/TelephonyServiceIndicator.client'
--- indicator/TelephonyServiceIndicator.client	2014-11-21 13:58:47 +0000
+++ indicator/TelephonyServiceIndicator.client	2016-05-24 01:13:17 +0000
@@ -8,11 +8,6 @@
 
 [org.freedesktop.Telepathy.Client.Observer.ObserverChannelFilter 1]
 org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Text
-org.freedesktop.Telepathy.Channel.TargetHandleType u=1
-
-[org.freedesktop.Telepathy.Client.Observer.ObserverChannelFilter 2]
-org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Text
-org.freedesktop.Telepathy.Channel.TargetHandleType u=0
 
 [org.freedesktop.Telepathy.Client.Observer.Capabilities]
 org.freedesktop.Telepathy.Channel.Type.Call1/audio=true
 
=== modified file 'indicator/textchannelobserver.cpp'
--- indicator/textchannelobserver.cpp	2016-03-30 13:34:38 +0000
+++ indicator/textchannelobserver.cpp	2016-05-24 01:13:17 +0000
@@ -277,7 +277,9 @@
         return;
     }
 
-    ChatManager::instance()->sendMessage(account->accountId(), recipients, text);
+    QVariantMap properties;
+    properties["participantIds"] = recipients;
+    ChatManager::instance()->sendMessage(account->accountId(), text, QVariantMap(), properties);
 }
 
 void TextChannelObserver::clearNotifications()
@@ -341,6 +343,9 @@
 void TextChannelObserver::triggerNotificationForMessage(const Tp::ReceivedMessage &message, const QString &accountId, const QStringList &participantIds)
 {
     Tp::ContactPtr contact = message.sender();
+    if (!contact) {
+        return;
+    }
 
     QByteArray token(message.messageToken().toUtf8());
     if (!mUnreadMessages.contains(token)) {
@@ -624,7 +629,7 @@
     // we do not notify messages sent by ourselves on other devices, unless we
     // are dealing with phone accounts: #1547462
     if (!account->account()->connection().isNull() && 
-            message.sender()->handle().at(0) == account->account()->connection()->selfHandle() &&
+            message.sender() && message.sender()->handle().at(0) == account->account()->connection()->selfHandle() &&
             account->type() != AccountEntry::PhoneAccount) {
         return;
     }
 
=== modified file 'libtelephonyservice/accountentry.cpp'
--- libtelephonyservice/accountentry.cpp	2015-11-23 20:01:58 +0000
+++ libtelephonyservice/accountentry.cpp	2016-05-24 01:13:17 +0000
@@ -106,6 +106,38 @@
            mAccount->connection()->status() == Tp::ConnectionStatusConnected;
 }
 
+AccountEntry::Capabilities AccountEntry::capabilities() const
+{
+    AccountEntry::Capabilities capabilities = CapabilityNone;
+
+    if (!connected()) {
+        return capabilities;
+    }
+
+    Tp::ConnectionCapabilities tpCapabilities = mAccount->capabilities();
+
+    if (tpCapabilities.textChatrooms()) {
+        capabilities |= (AccountEntry::Capabilities)AccountEntry::CapabilityTextChatrooms;
+    }
+    if (tpCapabilities.conferenceTextChats()) {
+        capabilities |= (AccountEntry::Capabilities)AccountEntry::CapabilityConferenceTextChats;
+    }
+    if (tpCapabilities.conferenceTextChatsWithInvitees()) {
+        capabilities |= (AccountEntry::Capabilities)AccountEntry::CapabilityConferenceTextChatsWithInvitees;
+    }
+    if (tpCapabilities.conferenceTextChatrooms()) {
+        capabilities |= (AccountEntry::Capabilities)AccountEntry::CapabilityConferenceTextChatrooms;
+    }
+    if (tpCapabilities.conferenceTextChatroomsWithInvitees()) {
+        capabilities |= (AccountEntry::Capabilities)AccountEntry::CapabilityConferenceTextChatroomsWithInvitees;
+    }
+    if (tpCapabilities.contactSearches()) {
+        capabilities |= (AccountEntry::Capabilities)AccountEntry::CapabilityContactSearches;
+    }
+
+    return capabilities;
+}
+
 Tp::AccountPtr AccountEntry::account() const
 {
     return mAccount;
@@ -219,6 +251,7 @@
 
     Q_EMIT connectedChanged();
     Q_EMIT selfContactIdChanged();
+    Q_EMIT capabilitiesChanged();
 }
 
 void AccountEntry::addAccountLabel(const QString &accountId, QString &text)
 
=== modified file 'libtelephonyservice/accountentry.h'
--- libtelephonyservice/accountentry.h	2015-11-23 20:01:58 +0000
+++ libtelephonyservice/accountentry.h	2016-05-24 01:13:17 +0000
@@ -45,6 +45,7 @@
     Q_PROPERTY(bool connected READ connected NOTIFY connectedChanged)
     Q_PROPERTY(QStringList addressableVCardFields READ addressableVCardFields NOTIFY addressableVCardFieldsChanged)
     Q_PROPERTY(Protocol* protocolInfo READ protocolInfo CONSTANT)
+    Q_PROPERTY(Capabilities capabilities READ capabilities NOTIFY capabilitiesChanged)
     Q_ENUMS(AccountType)
     friend class AccountEntryFactory;
 
@@ -55,6 +56,17 @@
         GenericAccount
     };
 
+    enum Capability {
+        CapabilityNone                                = 0,
+        CapabilityTextChatrooms                       = 1,
+        CapabilityConferenceTextChats                 = 2,
+        CapabilityConferenceTextChatsWithInvitees     = 4,
+        CapabilityConferenceTextChatrooms             = 8,
+        CapabilityConferenceTextChatroomsWithInvitees = 16,
+        CapabilityContactSearches                     = 32
+    };
+    Q_DECLARE_FLAGS(Capabilities, Capability);
+
     bool ready() const;
     QString accountId() const;
     QString displayName() const;
@@ -68,6 +80,7 @@
     virtual bool compareIds(const QString &first, const QString &second) const;
     virtual bool active() const;
     virtual bool connected() const;
+    Capabilities capabilities() const;
  
     Protocol *protocolInfo() const;
 
@@ -85,6 +98,7 @@
     void addressableVCardFieldsChanged();
     void removed();
     void connectionStatusChanged(Tp::ConnectionStatus status);
+    void capabilitiesChanged();
 
 protected Q_SLOTS:
     virtual void initialize();
@@ -101,4 +115,6 @@
     Protocol *mProtocol;
 };
 
+Q_DECLARE_OPERATORS_FOR_FLAGS(AccountEntry::Capabilities);
+
 #endif // ACCOUNTENTRY_H
 
=== modified file 'libtelephonyservice/chatentry.cpp'
--- libtelephonyservice/chatentry.cpp	2015-08-04 19:50:53 +0000
+++ libtelephonyservice/chatentry.cpp	2016-05-24 01:13:17 +0000
@@ -31,7 +31,10 @@
 
 ChatEntry::ChatEntry(const Tp::TextChannelPtr &channel, QObject *parent) :
     QObject(parent),
-    mChannel(channel)
+    mChannel(channel),
+    roomInterface(NULL),
+    roomConfigInterface(NULL),
+    subjectInterface(NULL)
 {
     qRegisterMetaType<ContactChatStates>();
     mAccount = TelepathyHelper::instance()->accountForConnection(mChannel->connection());
@@ -40,12 +43,54 @@
         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();
+    }
+    if (changed.contains("Title")) {
+        mTitle = changed["Title"].toString();
+        Q_EMIT titleChanged();
+    }
+}
+
+QString ChatEntry::roomName()
+{
+    return mRoomName;
+}
+
+QString ChatEntry::title()
+{
+    return mTitle;
+}
+
 ChatEntry::~ChatEntry()
 {
     QMap<QString, ContactChatState*> tmp = mChatStates;
@@ -56,6 +101,24 @@
         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();
 }
 
 void ChatEntry::onChatStateChanged(const Tp::ContactPtr &contact, Tp::ChannelChatState state)
 
=== modified file 'libtelephonyservice/chatentry.h'
--- libtelephonyservice/chatentry.h	2015-03-20 19:00:21 +0000
+++ libtelephonyservice/chatentry.h	2016-05-24 01:13:17 +0000
@@ -55,6 +55,9 @@
     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_PROPERTY(QString title READ title NOTIFY titleChanged)
     Q_PROPERTY(QQmlListProperty<ContactChatState> chatStates
                READ chatStates
                NOTIFY chatStatesChanged)
@@ -83,20 +86,31 @@
     QQmlListProperty<ContactChatState> chatStates();
     QStringList participants();
     ChatType chatType();
+    QString chatId();
+    QString roomName();
+    QString title();
     static int chatStatesCount(QQmlListProperty<ContactChatState> *p);
     static ContactChatState *chatStatesAt(QQmlListProperty<ContactChatState> *p, int index);
 
 private Q_SLOTS:
     void onChatStateChanged(const Tp::ContactPtr &contact, Tp::ChannelChatState state);
+    void onRoomPropertiesChanged(const QVariantMap &changed,const QStringList &invalidated);
 
 Q_SIGNALS:
     void chatStatesChanged();
     void participantsChanged();
+    void roomNameChanged();
+    void titleChanged();
 
 private:
     AccountEntry *mAccount;
     Tp::TextChannelPtr mChannel;
     QMap<QString, ContactChatState*> mChatStates;
+    QString mRoomName;
+    QString mTitle;
+    Tp::Client::ChannelInterfaceRoomInterface *roomInterface;
+    Tp::Client::ChannelInterfaceRoomConfigInterface *roomConfigInterface;
+    Tp::Client::ChannelInterfaceSubjectInterface *subjectInterface;
 };
 
 #endif // CHATENTRY_H
 
=== modified file 'libtelephonyservice/chatmanager.cpp'
--- libtelephonyservice/chatmanager.cpp	2016-03-07 19:27:55 +0000
+++ libtelephonyservice/chatmanager.cpp	2016-05-24 01:13:17 +0000
@@ -95,7 +95,7 @@
     return manager;
 }
 
-QString ChatManager::sendMessage(const QString &accountId, const QStringList &recipients, const QString &message, const QVariant &attachments, const QVariantMap &properties)
+QString ChatManager::sendMessage(const QString &accountId, const QString &message, const QVariant &attachments, const QVariantMap &properties)
 {
     AccountEntry *account = TelepathyHelper::instance()->accountForId(accountId);
 
@@ -103,9 +103,16 @@
         return QString();
     }
 
+    QVariantMap propMap = properties;
+
     // check if files should be copied to a temporary location before passing them to handler
     bool tmpFiles = (properties.contains("x-canonical-tmp-files") && properties["x-canonical-tmp-files"].toBool());
 
+    // participants coming from qml are variants
+    if (properties.contains("participantIds")) {
+        propMap["participantIds"] = properties["participantIds"].toStringList();
+    }
+
     AttachmentList newAttachments;
     Q_FOREACH (const QVariant &attachment, attachments.toList()) {
         AttachmentStruct newAttachment;
@@ -142,7 +149,7 @@
     }
 
     QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
-    QDBusReply<QString> reply = phoneAppHandler->call("SendMessage", account->accountId(), recipients, message, QVariant::fromValue(newAttachments), properties);
+    QDBusReply<QString> reply = phoneAppHandler->call("SendMessage", account->accountId(), message, QVariant::fromValue(newAttachments), propMap);
     if (reply.isValid()) {
         return reply.value();
     }
@@ -164,7 +171,7 @@
     connect(channel.data(),
             SIGNAL(messageSent(Tp::Message,Tp::MessageSendingFlags,QString)),
             SLOT(onMessageSent(Tp::Message,Tp::MessageSendingFlags,QString)));
-     connect(channel.data(),
+    connect(channel.data(),
             SIGNAL(invalidated(Tp::DBusProxy*,const QString&, const QString&)),
             SLOT(onChannelInvalidated()));
 
@@ -206,6 +213,10 @@
         return;
     }
 
+    if (!message.sender()) {
+        return;
+    }
+
     Q_EMIT messageReceived(message.sender()->id(), message.text(), message.received(), message.messageToken(), true);
 }
 
@@ -278,9 +289,41 @@
     return mChatEntries;
 }
 
-ChatEntry *ChatManager::chatEntryForParticipants(const QString &accountId, const QStringList &participants, bool create)
+ChatEntry *ChatManager::chatEntryForProperties(const QString &accountId, const QVariantMap &properties, bool create)
 {
-    if (participants.count() == 0 || accountId.isEmpty()) {
+    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;
     }
 
@@ -292,6 +335,15 @@
 
     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;
@@ -320,19 +372,11 @@
 
     if (create) {
         QDBusInterface *phoneAppHandler = TelepathyHelper::instance()->handlerInterface();
-        phoneAppHandler->call("StartChat", accountId, participants);
+        phoneAppHandler->call("StartChat", accountId, propMap);
     }
     return NULL;
 }
 
-ChatEntry *ChatManager::chatEntryForChatRoom(const QString &accountId, const QVariantMap &properties, bool create)
-{
-    Q_UNUSED(accountId)
-    Q_UNUSED(properties)
-    Q_UNUSED(create)
-    // FIXME: implement
-}
-
 QQmlListProperty<ChatEntry> ChatManager::chats()
 {
     return QQmlListProperty<ChatEntry>(this, 0, chatCount, chatAt);
 
=== modified file 'libtelephonyservice/chatmanager.h'
--- libtelephonyservice/chatmanager.h	2015-12-07 16:26:20 +0000
+++ libtelephonyservice/chatmanager.h	2016-05-24 01:13:17 +0000
@@ -39,9 +39,8 @@
 public:
     static ChatManager *instance();
 
-    Q_INVOKABLE QString sendMessage(const QString &accountId, const QStringList &recipients, const QString &message, const QVariant &attachments = QVariant(), const QVariantMap &properties = QVariantMap());
-    Q_INVOKABLE ChatEntry *chatEntryForParticipants(const QString &accountId, const QStringList &participants, bool create = false);
-    Q_INVOKABLE ChatEntry *chatEntryForChatRoom(const QString &accountId, const QVariantMap &properties, bool create);
+    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);
 
     QQmlListProperty<ChatEntry> chats();
     static int chatCount(QQmlListProperty<ChatEntry> *p);
 
=== modified file 'libtelephonyservice/telepathyhelper.cpp'
--- libtelephonyservice/telepathyhelper.cpp	2016-03-10 21:10:11 +0000
+++ libtelephonyservice/telepathyhelper.cpp	2016-05-24 01:13:17 +0000
@@ -56,6 +56,7 @@
                            "org.freedesktop.URfkill",
                            QDBusConnection::systemBus())
 {
+    qRegisterMetaType<QList<AccountEntry*> >();
     mAccountFeatures << Tp::Account::FeatureCore
                      << Tp::Account::FeatureProtocolInfo;
     mContactFeatures << Tp::Contact::FeatureAlias
@@ -585,3 +586,14 @@
     connectivityIface.asyncCall("UnlockAllModems");
 }
 
+
+QList<AccountEntry*> TelepathyHelper::accountsForType(int type)
+{
+    QList<AccountEntry*> accounts;
+    Q_FOREACH(AccountEntry *account, mAccounts) {
+        if (account->type() == (AccountEntry::AccountType)type) {
+            accounts << account;
+        }
+    }
+    return accounts;
+}
 
=== modified file 'libtelephonyservice/telepathyhelper.h'
--- libtelephonyservice/telepathyhelper.h	2016-03-09 20:10:48 +0000
+++ libtelephonyservice/telepathyhelper.h	2016-05-24 01:13:17 +0000
@@ -31,6 +31,7 @@
 #include <TelepathyQt/ConnectionManager>
 #include <TelepathyQt/Types>
 #include "channelobserver.h"
+#include "accountentry.h"
 
 #define CANONICAL_TELEPHONY_VOICEMAIL_IFACE "com.canonical.Telephony.Voicemail"
 #define CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE "com.canonical.Telephony.AudioOutputs"
@@ -56,12 +57,19 @@
     Q_PROPERTY(bool emergencyCallsAvailable READ emergencyCallsAvailable NOTIFY emergencyCallsAvailableChanged)
     Q_PROPERTY(QVariantMap simNames READ simNames NOTIFY simNamesChanged)
     Q_ENUMS(AccountType)
+    Q_ENUMS(ChatType)
 public:
     enum AccountType {
         Call,
         Messaging
     };
 
+    enum ChatType {
+        ChatTypeNone = Tp::HandleTypeNone,
+        ChatTypeContact = Tp::HandleTypeContact,
+        ChatTypeRoom = Tp::HandleTypeRoom
+    };
+
     ~TelepathyHelper();
 
     static TelepathyHelper *instance();
@@ -87,6 +95,7 @@
     AccountEntry *accountForConnection(const Tp::ConnectionPtr &connection) const;
     Q_INVOKABLE AccountEntry *accountForId(const QString &accountId) const;
     Q_INVOKABLE void setDefaultAccount(AccountType type, AccountEntry* account);
+    Q_INVOKABLE QList<AccountEntry*> accountsForType(int type);
     bool emergencyCallsAvailable() const;
     Q_INVOKABLE void unlockSimCards() const;
     bool multiplePhoneAccounts() const;
 
=== modified file 'tests/common/mock/connection.cpp'
--- tests/common/mock/connection.cpp	2016-03-31 19:29:44 +0000
+++ tests/common/mock/connection.cpp	2016-05-24 01:13:17 +0000
@@ -362,7 +362,9 @@
 
     QStringList recipients;
     bool flash;
-    if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeHandles"))) {
+    if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeIDs"))) {
+        recipients = qdbus_cast<QStringList>(hints[TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeIDs")]);
+    } else if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeHandles"))) {
         recipients << inspectHandles(Tp::HandleTypeContact, qdbus_cast<Tp::UIntList>(hints[TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeHandles")]), error);
     } else {
         recipients << mHandles.value(targetHandle);
@@ -465,11 +467,15 @@
     const QString channelType = request.value(TP_QT_IFACE_CHANNEL + QLatin1String(".ChannelType")).toString();
     uint targetHandleType = request.value(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandleType")).toUInt();
     uint targetHandle = request.value(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetHandle")).toUInt();
+    QString targetId = request.value(TP_QT_IFACE_CHANNEL + QLatin1String(".TargetID")).toString();
     qDebug() << "MockConnection::createChannel" << targetHandle;
     if (mSelfPresence.type != Tp::ConnectionPresenceTypeAvailable) {
         error->set(TP_QT_ERROR_NETWORK_ERROR, "No network available");
         return Tp::BaseChannelPtr();
     }
+    if (!targetId.isEmpty()) {
+        targetHandle = ensureHandle(targetId);
+    }
 
     if (channelType == TP_QT_IFACE_CHANNEL_TYPE_TEXT) {
         return createTextChannel(targetHandleType, targetHandle, request, error);
 
=== modified file 'tests/handler/handlercontroller.cpp'
--- tests/handler/handlercontroller.cpp	2015-12-07 16:26:20 +0000
+++ tests/handler/handlercontroller.cpp	2016-05-24 01:13:17 +0000
@@ -75,7 +75,11 @@
 
 void HandlerController::startChat(const QString &accountId, const QStringList &recipients)
 {
-    mHandlerInterface.call("StartChat", accountId, recipients);
+    // TODO CHANGE SIGNATURE of this method
+    QVariantMap properties;
+    properties["participantIds"] = recipients;
+
+    mHandlerInterface.call("StartChat", accountId, properties);
 }
 
 void HandlerController::startCall(const QString &number, const QString &accountId)
@@ -131,7 +135,10 @@
 
 QString HandlerController::sendMessage(const QString &accountId, const QStringList &recipients, const QString &message, const AttachmentList &attachments, const QVariantMap &properties)
 {
-    QDBusReply<QString> reply = mHandlerInterface.call("SendMessage", accountId, recipients, message, QVariant::fromValue(attachments), properties);
+    // TODO CHANGE SIGNATURE of this method
+    QVariantMap props = properties;
+    props["participantIds"] = recipients;
+    QDBusReply<QString> reply = mHandlerInterface.call("SendMessage", accountId, message, QVariant::fromValue(attachments), props);
     if (reply.isValid()) {
         return reply.value();
     }
 
=== modified file 'tests/libtelephonyservice/ChatEntryTest.cpp'
--- tests/libtelephonyservice/ChatEntryTest.cpp	2015-11-17 12:41:23 +0000
+++ tests/libtelephonyservice/ChatEntryTest.cpp	2016-05-24 01:13:17 +0000
@@ -96,11 +96,13 @@
     MockController *mockController = accountId.startsWith("mock/mock") ? mGenericMockController : mMultimediaMockController;
 
     QSignalSpy chatEntryCreatedSpy(ChatManager::instance(), SIGNAL(chatEntryCreated(QString, QStringList,ChatEntry *)));
-    ChatEntry *entry = ChatManager::instance()->chatEntryForParticipants(accountId, participants, true);
+    QVariantMap properties;
+    properties["participantIds"] = participants;
+    ChatEntry *entry = ChatManager::instance()->chatEntryForProperties(accountId, properties, true);
     QVERIFY(entry == NULL);
     QTRY_COMPARE(chatEntryCreatedSpy.count(), 1);
 
-    entry = ChatManager::instance()->chatEntryForParticipants(accountId, participants, false);
+    entry = ChatManager::instance()->chatEntryForProperties(accountId, properties, false);
     QVERIFY(entry != NULL);
     QList<QVariant> arguments = chatEntryCreatedSpy.takeFirst();
     QCOMPARE(accountId, arguments.at(0).toString());
 
=== modified file 'tests/libtelephonyservice/ChatManagerTest.cpp'
--- tests/libtelephonyservice/ChatManagerTest.cpp	2016-03-10 21:10:11 +0000
+++ tests/libtelephonyservice/ChatManagerTest.cpp	2016-05-24 01:13:17 +0000
@@ -104,7 +104,9 @@
     QSignalSpy controllerMessageSentSpy(controller, SIGNAL(MessageSent(QString,QVariantList,QVariantMap)));
     QSignalSpy messageSentSpy(ChatManager::instance(), SIGNAL(messageSent(QStringList,QString)));
 
-    ChatManager::instance()->sendMessage(accountId, recipients, message);
+    QVariantMap properties;
+    properties["participantIds"] = recipients;
+    ChatManager::instance()->sendMessage(accountId, message, QVariantMap(), properties);
 
     TRY_COMPARE(controllerMessageSentSpy.count(), 1);
     QString messageText = controllerMessageSentSpy.first()[0].toString();
@@ -182,11 +184,14 @@
     QStringList recipients;
     recipients << "[e-mail]" << "[e-mail]";
     QSignalSpy chatEntryCreatedSpy(ChatManager::instance(), SIGNAL(chatEntryCreated(QString, QStringList,ChatEntry *)));
-    ChatEntry *entry = ChatManager::instance()->chatEntryForParticipants("mock/mock/account0", recipients, true);
+    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()->chatEntryForParticipants("mock/mock/account0", recipients, false);
+    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());
@@ -226,7 +231,9 @@
     attachmentList << QVariant::fromValue(attachment);
     QVariant attachments = QVariant::fromValue(attachmentList);
 
-    ChatManager::instance()->sendMessage(accountId, recipients, message, attachments);
+    QVariantMap properties;
+    properties["participantIds"] = recipients;
+    ChatManager::instance()->sendMessage(accountId, message, attachments, properties);
 
     TRY_COMPARE(controllerMessageSentSpy.count(), 1);
     QString messageText = controllerMessageSentSpy.first()[0].toString();