Merge lp:history-service/staging into lp:history-service

[Gustavo Pichorim Boiko]

- Adapt to support VOIP accounts.
- Improve the notifications of participants changing
- Only start saving information events about contacts joining and leaving after the self contact is in the local list of participants.
- Improve Roles management performance by caching the retrieved data.
- Mark entire conversations as read.
- Allow pass multiple fields on sort clause.
- Reduce the dbus traffic when marking messages and threads as read.
- Use a QLockFile to ensure there will be only one instance of the daemon per user. As we now delay the registration on dbus, sometimes we ended up having two instances of the daeon running (because of dbus activation). This change makes sure that won't happen.
- Do not load the participants from threads automatically. If the client really needs it, it can use the newly added API to fetch the participants.
- Make it possible to debug sqlite commands.

- Adapt to support VOIP accounts.
- Improve the notifications of participants changing
- Only start saving information events about contacts joining and leaving after the self contact is in the local list of participants.
- Improve Roles management performance by caching the retrieved data.
- Mark entire conversations as read.
- Allow pass multiple fields on sort clause.
- Reduce the dbus traffic when marking messages and threads as read.
- Use a QLockFile to ensure there will be only one instance of the daemon per user. As we now delay the registration on dbus, sometimes we ended up having two instances of the daeon running (because of dbus activation). This change makes sure that won't happen.
- Do not load the participants from threads automatically. If the client really needs it, it can use the newly added API to fetch the participants.
- Make it possible to debug sqlite commands.

[system-apps-ci-bot (system-apps-ci-bot)]

PASSED: Continuous integration, rev:264
https://jenkins.canonical.com/system-apps/job/lp-history-service-ci/2/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build/2344
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-0-fetch/2344
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2162
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2162/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=zesty/2162
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=zesty/2162/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2162
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2162/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=zesty/2162
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=zesty/2162/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/2162
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/2162/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=zesty/2162
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=zesty/2162/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:history-service/staging]

265. By Gustavo Pichorim Boiko on 2017-03-23

Fix return value of a function that is now asynchronous

[system-apps-ci-bot (system-apps-ci-bot)]

PASSED: Continuous integration, rev:265
https://jenkins.canonical.com/system-apps/job/lp-history-service-ci/3/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build/2349
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-0-fetch/2349
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2167
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2167/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=zesty/2167
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=zesty/2167/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2167
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2167/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=zesty/2167
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=zesty/2167/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/2167
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial+overlay/2167/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=zesty/2167
        deb: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=zesty/2167/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Gustavo Pichorim Boiko (boiko)]

The changes were reviewed individually and tested from this branch, so approving.

review: Approve

Unmerged revisions

265. By Gustavo Pichorim Boiko on 2017-03-23

Fix return value of a function that is now asynchronous

264. By Gustavo Pichorim Boiko on 2017-03-22

Make it possible to debug sqlite commands.

263. By Gustavo Pichorim Boiko on 2017-03-22

Do not load the participants from threads automatically. If the client really needs it, it can use the newly added API to fetch the participants.

262. By Gustavo Pichorim Boiko on 2017-03-22

Use a QLockFile to ensure there will be only one instance of the daemon per user.
As we now delay the registration on dbus, sometimes we ended up having two instances of the daeon running (because of dbus activation). This change makes sure that won't happen.

261. By Gustavo Pichorim Boiko on 2017-03-22

Reduce the dbus traffic when marking messages and threads as read.

260. By Gustavo Pichorim Boiko on 2017-03-22

Allow pass multiple fields on sort clause.

259. By Gustavo Pichorim Boiko on 2017-03-22

Mark entire conversations as read.

258. By Gustavo Pichorim Boiko on 2017-03-22

Improve Roles management performance by caching the retrieved data.

257. By Gustavo Pichorim Boiko on 2017-03-22

Only start saving information events about contacts joining and leaving after the self contact is in the local list of participants.

256. By Gustavo Pichorim Boiko on 2017-03-22

Improve the notifications of participants changing

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-08-16 21:06:10 +0000
+++ CMakeLists.txt	2017-03-23 01:25:43 +0000
@@ -50,6 +50,11 @@
 
 find_program(DBUS_RUNNER dbus-test-runner)
 
+option(TRACE_SQLITE "Print Sqlite commants to the log." off)
+if (${TRACE_SQLITE})
+    add_definitions(-DTRACE_SQLITE)
+endif()
+
 add_definitions(-DQT_NO_KEYWORDS)
 
 include_directories(
 
=== modified file 'Ubuntu/History/historyeventmodel.cpp'
--- Ubuntu/History/historyeventmodel.cpp	2016-09-16 11:59:52 +0000
+++ Ubuntu/History/historyeventmodel.cpp	2017-03-23 01:25:43 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2015 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -29,7 +29,7 @@
 #include <QTimerEvent>
 
 HistoryEventModel::HistoryEventModel(QObject *parent) :
-    HistoryModel(parent), mCanFetchMore(true), mEventWritingTimer(0)
+    HistoryModel(parent), mCanFetchMore(true)
 {
     // configure the roles
     mRoles = HistoryModel::roleNames();
@@ -95,10 +95,17 @@
         result = event.eventId();
         break;
     case SenderIdRole:
-        result = event.senderId();
+        result = History::ContactMatcher::normalizeId(event.senderId());
         break;
     case SenderRole:
-        result = History::ContactMatcher::instance()->contactInfo(event.accountId(), event.senderId());
+        if (mMatchContacts) {
+            result = History::ContactMatcher::instance()->contactInfo(event.accountId(), event.senderId());
+        } else {
+            QVariantMap map;
+            map[History::FieldIdentifier] = event.senderId();
+            map[History::FieldAccountId] = event.accountId();
+            result = map;
+        }
         break;
     case TimestampRole:
         result = event.timestamp();
@@ -168,17 +175,21 @@
         break;
     case RemoteParticipantRole:
         if (!voiceEvent.isNull()) {
-            result = voiceEvent.remoteParticipant();
+            result = History::ContactMatcher::normalizeId(voiceEvent.remoteParticipant());
         }
         break;
     case SubjectAsAliasRole:
         if (!textEvent.isNull()) {
-            QVariantMap contactInfo = History::ContactMatcher::instance()->contactInfo(event.accountId(), textEvent.subject());
-            QString returnValue = contactInfo[History::FieldAlias].toString();
-            if (returnValue.isEmpty()) {
-                returnValue = contactInfo[History::FieldIdentifier].toString();
+            if (mMatchContacts) {
+                QVariantMap contactInfo = History::ContactMatcher::instance()->contactInfo(event.accountId(), textEvent.subject());
+                QString returnValue = contactInfo[History::FieldAlias].toString();
+                if (returnValue.isEmpty()) {
+                    returnValue = contactInfo[History::FieldIdentifier].toString();
+                }
+                return returnValue;
+
             }
-            return returnValue;
+            return textEvent.subject();
         }
         break;
     }
@@ -307,23 +318,6 @@
     return History::Manager::instance()->writeEvents(History::Events() << textEvent);
 }
 
-bool HistoryEventModel::markEventAsRead(const QString &accountId, const QString &threadId, const QString &eventId, int eventType)
-{
-    History::Event event = History::Manager::instance()->getSingleEvent((History::EventType)eventType, accountId, threadId, eventId);
-    event.setNewEvent(false);
-    if (event.type() == History::EventTypeText) {
-        History::TextEvent textEvent = event;
-        textEvent.setReadTimestamp(QDateTime::currentDateTime());
-        event = textEvent;
-    }
-    mEventWritingQueue << event;
-    if (mEventWritingTimer != 0) {
-        killTimer(mEventWritingTimer);
-    }
-    mEventWritingTimer  = startTimer(500);
-    return true;
-}
-
 void HistoryEventModel::updateQuery()
 {
     // remove all events from the model
@@ -341,7 +335,7 @@
         mView->disconnect(this);
     }
 
-    if (mFilter) {
+    if (mFilter && mFilter->filter().isValid()) {
         queryFilter = mFilter->filter();
     } else {
         // we should not return anything if there is no filter
@@ -363,6 +357,9 @@
             SIGNAL(eventsRemoved(History::Events)),
             SLOT(onEventsRemoved(History::Events)));
     connect(mView.data(),
+            SIGNAL(threadsRemoved(History::Threads)),
+            SLOT(onThreadsRemoved(History::Threads)));
+    connect(mView.data(),
             SIGNAL(invalidated()),
             SLOT(triggerQueryUpdate()));
 
@@ -439,21 +436,21 @@
     // should be handle internally in History::EventView?
 }
 
-void HistoryEventModel::timerEvent(QTimerEvent *event)
+void HistoryEventModel::onThreadsRemoved(const History::Threads &threads)
 {
-    HistoryModel::timerEvent(event);
-    if (event->timerId() == mEventWritingTimer) {
-        killTimer(mEventWritingTimer);
-        mEventWritingTimer = 0;
-
-        if (mEventWritingQueue.isEmpty()) {
-            return;
-        }
-
-        qDebug() << "Goint to update" << mEventWritingQueue.count() << "events.";
-        if (History::Manager::instance()->writeEvents(mEventWritingQueue)) {
-            qDebug() << "... succeeded!";
-            mEventWritingQueue.clear();
+    // When a thread is removed we don't get event removed signals,
+    // so we compare and find if we have an event matching that thread.
+    // in case we find it, we invalidate the whole view as there might be
+    // out of date cached data on the daemon side
+    int count = rowCount();
+    Q_FOREACH(const History::Thread &thread, threads) {
+        for (int i = 0; i < count; ++i) {
+            QModelIndex idx = index(i);
+            if (idx.data(AccountIdRole).toString() == thread.accountId() &&
+                idx.data(ThreadIdRole).toString() == thread.threadId()) {
+                triggerQueryUpdate();
+                return;
+            }
         }
     }
 }
 
=== modified file 'Ubuntu/History/historyeventmodel.h'
--- Ubuntu/History/historyeventmodel.h	2016-09-16 12:32:37 +0000
+++ Ubuntu/History/historyeventmodel.h	2017-03-23 01:25:43 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2015 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -66,7 +66,6 @@
 
     Q_INVOKABLE bool removeEvents(const QVariantList &eventsProperties);
     Q_INVOKABLE bool writeEvents(const QVariantList &eventsProperties);
-    Q_INVOKABLE bool markEventAsRead(const QString &accountId, const QString &threadId, const QString &eventId, int eventType);
     Q_INVOKABLE bool removeEventAttachment(const QString &accountId, const QString &threadId, const QString &eventId, int eventType, const QString &attachmentId);
 
 protected Q_SLOTS:
@@ -74,9 +73,9 @@
     virtual void onEventsAdded(const History::Events &events);
     virtual void onEventsModified(const History::Events &events);
     virtual void onEventsRemoved(const History::Events &events);
+    virtual void onThreadsRemoved(const History::Threads &threads);
 
 protected:
-    void timerEvent(QTimerEvent *event);
     History::Events fetchNextPage();
 
 private:
@@ -85,8 +84,6 @@
     bool mCanFetchMore;
     QHash<int, QByteArray> mRoles;
     mutable QMap<History::TextEvent, QList<QVariant> > mAttachmentCache;
-    History::Events mEventWritingQueue;
-    int mEventWritingTimer;
 };
 
 #endif // HISTORYEVENTMODEL_H
 
=== modified file 'Ubuntu/History/historygroupedthreadsmodel.cpp'
--- Ubuntu/History/historygroupedthreadsmodel.cpp	2015-10-08 19:35:40 +0000
+++ Ubuntu/History/historygroupedthreadsmodel.cpp	2017-03-23 01:25:43 +0000
@@ -199,6 +199,21 @@
     }
 }
 
+History::Threads HistoryGroupedThreadsModel::restoreParticipants(const History::Threads &oldThreads, const History::Threads &newThreads)
+{
+    History::Threads updated = newThreads;
+    for(History::Thread &thread : updated) {
+        if (!thread.participants().isEmpty()) {
+            continue;
+        }
+        int i = oldThreads.indexOf(thread);
+        if (i >=0) {
+            thread.addParticipants(oldThreads[i].participants());
+        }
+    }
+    return updated;
+}
+
 void HistoryGroupedThreadsModel::updateQuery()
 {
     // remove all entries and call the query update
@@ -217,6 +232,7 @@
         processThreadGrouping(thread);
     }
 
+    fetchParticipantsIfNeeded(threads);
     notifyDataChanged();
 }
 
@@ -225,7 +241,7 @@
     Q_FOREACH(const History::Thread &thread, threads) {
         processThreadGrouping(thread);
     }
-
+    fetchParticipantsIfNeeded(threads);
     notifyDataChanged();
 }
 
@@ -238,6 +254,42 @@
     notifyDataChanged();
 }
 
+void HistoryGroupedThreadsModel::onThreadParticipantsChanged(const History::Thread &thread, const History::Participants &added, const History::Participants &removed, const History::Participants &modified)
+{
+    int pos = existingPositionForEntry(thread);
+    if (pos >= 0) {
+        HistoryThreadGroup &group = mGroups[pos];
+        if (group.displayedThread == thread) {
+            group.displayedThread.removeParticipants(removed);
+            group.displayedThread.removeParticipants(modified);
+            group.displayedThread.addParticipants(added);
+            group.displayedThread.addParticipants(modified);
+        }
+
+        Q_FOREACH(const History::Thread &existingThread, group.threads) {
+            if (existingThread == thread) {
+                History::Thread modifiedThread = existingThread;
+                group.threads.removeOne(existingThread);
+                modifiedThread.removeParticipants(removed);
+                modifiedThread.removeParticipants(modified);
+                modifiedThread.addParticipants(added);
+                modifiedThread.addParticipants(modified);
+                group.threads.append(modifiedThread);
+            }
+        }
+        QModelIndex idx = index(pos);
+        Q_EMIT dataChanged(idx, idx);
+    }
+
+    // watch the contact info for the received participants
+    Q_FOREACH(const History::Participant &participant, added) {
+        watchContactInfo(thread.accountId(), participant.identifier(), participant.properties());
+    }
+    Q_FOREACH(const History::Participant &participant, modified) {
+        watchContactInfo(thread.accountId(), participant.identifier(), participant.properties());
+    }
+}
+
 void HistoryGroupedThreadsModel::processThreadGrouping(const History::Thread &thread)
 {
     QVariantMap queryProperties;
@@ -262,7 +314,7 @@
     }
 
     HistoryThreadGroup &group = mGroups[pos];
-    group.threads = groupedThread.groupedThreads();
+    group.threads = restoreParticipants(group.threads, groupedThread.groupedThreads());
 
     updateDisplayedThread(group);
     markGroupAsChanged(group);
 
=== modified file 'Ubuntu/History/historygroupedthreadsmodel.h'
--- Ubuntu/History/historygroupedthreadsmodel.h	2015-09-29 20:34:22 +0000
+++ Ubuntu/History/historygroupedthreadsmodel.h	2017-03-23 01:25:43 +0000
@@ -67,12 +67,17 @@
     int existingPositionForEntry(const History::Thread &thread) const;
     void removeGroup(const HistoryThreadGroup &group);
     void updateDisplayedThread(HistoryThreadGroup &group);
+    History::Threads restoreParticipants(const History::Threads &oldThreads, const History::Threads &newThreads);
 
 protected Q_SLOTS:
     virtual void updateQuery();
     virtual void onThreadsAdded(const History::Threads &threads);
     virtual void onThreadsModified(const History::Threads &threads);
     virtual void onThreadsRemoved(const History::Threads &threads);
+    void onThreadParticipantsChanged(const History::Thread &thread,
+                                     const History::Participants &added,
+                                     const History::Participants &removed,
+                                     const History::Participants &modified) override;
 
 private Q_SLOTS:
     void processThreadGrouping(const History::Thread &thread);
 
=== modified file 'Ubuntu/History/historymodel.cpp'
--- Ubuntu/History/historymodel.cpp	2016-11-24 12:22:11 +0000
+++ Ubuntu/History/historymodel.cpp	2017-03-23 01:25:43 +0000
@@ -28,13 +28,14 @@
 #include "textevent.h"
 #include "manager.h"
 #include "utils_p.h"
+#include "voiceevent.h"
 #include <QTimerEvent>
 #include <QCryptographicHash>
 #include <QDebug>
 
 HistoryModel::HistoryModel(QObject *parent) :
     QAbstractListModel(parent), mFilter(0), mSort(new HistoryQmlSort(this)),
-    mType(EventTypeText), mMatchContacts(false), mUpdateTimer(0), mWaitingForQml(false)
+    mType(EventTypeText), mMatchContacts(false), mUpdateTimer(0), mEventWritingTimer(0), mThreadWritingTimer(0), mWaitingForQml(false)
 {
     // configure the roles
     mRoles[AccountIdRole] = "accountId";
@@ -341,6 +342,20 @@
     return QString::null;
 }
 
+void HistoryModel::requestThreadParticipants(const QVariantList &threads)
+{
+    History::Threads theThreads;
+    Q_FOREACH(const QVariant &threadVariant, threads) {
+        History::Thread theThread = History::Thread::fromProperties(threadVariant.toMap());
+        // if the given thread already has the list of participants, there is no point
+        // in fetching it again
+        if (theThread.participants().isEmpty()) {
+            theThreads << theThread;
+        }
+    }
+    History::Manager::instance()->requestThreadParticipants(theThreads);
+}
+
 bool HistoryModel::writeTextInformationEvent(const QString &accountId, const QString &threadId, const QStringList &participants, const QString &message, int informationType, const QString &subject)
 {
     if (participants.isEmpty() || threadId.isEmpty() || accountId.isEmpty()) {
@@ -385,7 +400,7 @@
             // FIXME: right now we might be grouping threads from different accounts, so we are not enforcing
             // the accountId to be the same as the one from the contact info, but maybe we need to do that
             // in the future?
-            if (History::Utils::compareIds(accountId, participant.identifier(), identifier)) {
+            if (History::Utils::compareIds(accountId, History::ContactMatcher::normalizeId(participant.identifier()), identifier)) {
                 changedIndexes << idx;
             }
         }
@@ -406,19 +421,50 @@
 
 void HistoryModel::timerEvent(QTimerEvent *event)
 {
-    if (event->timerId() == mUpdateTimer && !mWaitingForQml) {
-        killTimer(mUpdateTimer);
-        mUpdateTimer = 0;
-        updateQuery();
+    if (event->timerId() == mUpdateTimer) {
+        if (!mWaitingForQml) {
+            killTimer(mUpdateTimer);
+            mUpdateTimer = 0;
+            updateQuery();
+        }
+    } else if (event->timerId() == mEventWritingTimer) {
+        killTimer(mEventWritingTimer);
+        mEventWritingTimer = 0;
+
+        if (mEventWritingQueue.isEmpty()) {
+            return;
+        }
+
+        if (History::Manager::instance()->writeEvents(mEventWritingQueue)) {
+            mEventWritingQueue.clear();
+        }
+    } else if (event->timerId() == mThreadWritingTimer) {
+        killTimer(mThreadWritingTimer);
+        mThreadWritingTimer = 0;
+
+        if (mThreadWritingQueue.isEmpty()) {
+            return;
+        }
+
+        History::Manager::instance()->markThreadsAsRead(mThreadWritingQueue);
+        mThreadWritingQueue.clear();
     }
 }
 
 bool HistoryModel::lessThan(const QVariantMap &left, const QVariantMap &right) const
 {
-    QVariant leftValue = left[sort()->sortField()];
-    QVariant rightValue = right[sort()->sortField()];
-
-    return leftValue < rightValue;
+    QStringList sortFields = sort()->sortField().split(",");
+
+    while(!sortFields.isEmpty()) {
+        QString sortField = sortFields.takeFirst().trimmed();
+        QVariant leftValue = left.value(sortField, QVariant());
+        QVariant rightValue = right.value(sortField, QVariant());
+
+        if (leftValue != rightValue) {
+            return leftValue < rightValue;
+        }
+    }
+    return false;
 }
 
 int HistoryModel::positionForItem(const QVariantMap &item) const
@@ -470,6 +516,56 @@
     return data;
 }
 
+bool HistoryModel::markEventAsRead(const QVariantMap &eventProperties)
+{
+    History::Event event;
+    History::EventType type = (History::EventType) eventProperties[History::FieldType].toInt();
+    switch (type) {
+    case History::EventTypeText:
+        event = History::TextEvent::fromProperties(eventProperties);
+        break;
+    case History::EventTypeVoice:
+        event = History::VoiceEvent::fromProperties(eventProperties);
+        break;
+    }
+
+    event.setNewEvent(false);
+    if (event.type() == History::EventTypeText) {
+        History::TextEvent textEvent = event;
+        textEvent.setReadTimestamp(QDateTime::currentDateTime());
+        event = textEvent;
+    }
+    // for repeated events, keep the last called one only
+    if (mEventWritingQueue.contains(event)) {
+        mEventWritingQueue.removeOne(event);
+    }
+    mEventWritingQueue << event;
+    if (mEventWritingTimer != 0) {
+        killTimer(mEventWritingTimer);
+    }
+    mEventWritingTimer = startTimer(500);
+    return true;
+}
+
+void HistoryModel::markThreadsAsRead(const QVariantList &threadsProperties)
+{
+    Q_FOREACH(const QVariant &entry, threadsProperties) {
+        QVariantMap threadProperties = entry.toMap();
+        History::Thread thread = History::Thread::fromProperties(threadProperties);
+        if (!thread.isNull()) {
+            if (mThreadWritingQueue.contains(thread)) {
+                continue;
+            }
+            mThreadWritingQueue << thread;
+        }
+    }
+
+    if (mThreadWritingTimer != 0) {
+        killTimer(mThreadWritingTimer);
+    }
+    mThreadWritingTimer = startTimer(2000);
+}
+
 void HistoryModel::classBegin()
 {
     mWaitingForQml = true;
 
=== modified file 'Ubuntu/History/historymodel.h'
--- Ubuntu/History/historymodel.h	2016-11-09 17:42:27 +0000
+++ Ubuntu/History/historymodel.h	2017-03-23 01:25:43 +0000
@@ -23,6 +23,8 @@
 #define HISTORYMODEL_H
 
 #include "types.h"
+#include "event.h"
+#include "thread.h"
 #include "historyqmlfilter.h"
 #include "historyqmlsort.h"
 #include <QAbstractListModel>
@@ -166,6 +168,7 @@
                                                 const QStringList &participants,
                                                 int matchFlags = (int)History::MatchCaseSensitive,
                                                 bool create = false);
+    Q_INVOKABLE void requestThreadParticipants(const QVariantList &threads);
     Q_INVOKABLE bool writeTextInformationEvent(const QString &accountId,
                                    const QString &threadId,
                                    const QStringList &participants,
@@ -175,6 +178,10 @@
 
     Q_INVOKABLE virtual QVariant get(int row) const;
 
+    // Marking events and threads as read
+    Q_INVOKABLE bool markEventAsRead(const QVariantMap &eventProperties);
+    Q_INVOKABLE void markThreadsAsRead(const QVariantList &threadsProperties);
+
     // QML parser status things
     void classBegin();
     void componentComplete();
@@ -206,6 +213,10 @@
 
 private:
     QHash<int, QByteArray> mRoles;
+    History::Events mEventWritingQueue;
+    int mEventWritingTimer;
+    History::Threads mThreadWritingQueue;
+    int mThreadWritingTimer;
     int mUpdateTimer;
     bool mWaitingForQml;
 };
 
=== modified file 'Ubuntu/History/historythreadmodel.cpp'
--- Ubuntu/History/historythreadmodel.cpp	2016-06-17 01:49:46 +0000
+++ Ubuntu/History/historythreadmodel.cpp	2017-03-23 01:25:43 +0000
@@ -26,6 +26,8 @@
 #include "voiceevent.h"
 #include <QDBusMetaType>
 
+#include <QDebug>
+
 Q_DECLARE_METATYPE(History::TextEventAttachments)
 Q_DECLARE_METATYPE(QList<QVariantMap>)
 
@@ -190,7 +192,6 @@
         }
         break;
     }
-
     return result;
 }
 
@@ -214,13 +215,6 @@
         mCanFetchMore = false;
         Q_EMIT canFetchMoreChanged();
     } else {
-        Q_FOREACH(const History::Thread &thread, threads) {
-            // insert the identifiers in the contact map
-            Q_FOREACH(const History::Participant &participant, thread.participants()) {
-                watchContactInfo(thread.accountId(), participant.identifier(), participant.properties());
-            }
-        }
-
         beginInsertRows(QModelIndex(), mThreads.count(), mThreads.count() + threads.count() - 1);
         mThreads << threads;
         endInsertRows();
@@ -294,6 +288,10 @@
             SIGNAL(threadsRemoved(History::Threads)),
             SLOT(onThreadsRemoved(History::Threads)));
     connect(mThreadView.data(),
+            SIGNAL(threadParticipantsChanged(History::Thread, History::Participants, History::Participants, History::Participants)),
+            SLOT(onThreadParticipantsChanged(History::Thread, History::Participants, History::Participants, History::Participants)));
+
+    connect(mThreadView.data(),
             SIGNAL(invalidated()),
             SLOT(triggerQueryUpdate()));
 
@@ -311,6 +309,43 @@
     fetchMore(QModelIndex());
 }
 
+
+void HistoryThreadModel::onThreadParticipantsChanged(const History::Thread &thread, const History::Participants &added, const History::Participants &removed, const History::Participants &modified)
+{
+    int pos = mThreads.indexOf(thread);
+    if (pos >= 0) {
+        mThreads[pos].removeParticipants(removed);
+        mThreads[pos].removeParticipants(modified);
+        mThreads[pos].addParticipants(added);
+        mThreads[pos].addParticipants(modified);
+        QModelIndex idx = index(pos);
+        Q_EMIT dataChanged(idx, idx);
+    }
+
+    // watch the contact info for the received participants
+    Q_FOREACH(const History::Participant &participant, added) {
+        watchContactInfo(thread.accountId(), participant.identifier(), participant.properties());
+    }
+    Q_FOREACH(const History::Participant &participant, modified) {
+        watchContactInfo(thread.accountId(), participant.identifier(), participant.properties());
+    }
+}
+
+void HistoryThreadModel::fetchParticipantsIfNeeded(const History::Threads &threads)
+{
+    History::Threads filtered;
+    Q_FOREACH(const History::Thread &thread, threads) {
+        if (thread.type() == History::EventTypeText && thread.participants().isEmpty() &&
+            (thread.chatType() != History::ChatTypeRoom || thread.accountId().startsWith("ofono"))) {
+            filtered << thread;
+        }
+    }
+    if (filtered.isEmpty()) {
+        return;
+    }
+    History::Manager::instance()->requestThreadParticipants(filtered);
+}
+
 void HistoryThreadModel::onThreadsAdded(const History::Threads &threads)
 {
     if (threads.isEmpty()) {
@@ -328,6 +363,7 @@
         mThreads.insert(pos, thread);
         endInsertRows();
     }
+    fetchParticipantsIfNeeded(threads);
 }
 
 void HistoryThreadModel::onThreadsModified(const History::Threads &threads)
@@ -349,6 +385,7 @@
     if (!newThreads.isEmpty()) {
         onThreadsAdded(newThreads);
     }
+    fetchParticipantsIfNeeded(threads);
 }
 
 void HistoryThreadModel::onThreadsRemoved(const History::Threads &threads)
@@ -369,5 +406,7 @@
 
 History::Threads HistoryThreadModel::fetchNextPage()
 {
-    return mThreadView->nextPage();
+    History::Threads threads = mThreadView->nextPage();
+    fetchParticipantsIfNeeded(threads);
+    return threads;
 }
 
=== modified file 'Ubuntu/History/historythreadmodel.h'
--- Ubuntu/History/historythreadmodel.h	2016-06-17 01:49:46 +0000
+++ Ubuntu/History/historythreadmodel.h	2017-03-23 01:25:43 +0000
@@ -76,8 +76,10 @@
     virtual void onThreadsAdded(const History::Threads &threads);
     virtual void onThreadsModified(const History::Threads &threads);
     virtual void onThreadsRemoved(const History::Threads &threads);
+    virtual void onThreadParticipantsChanged(const History::Thread &thread, const History::Participants &added, const History::Participants &removed, const History::Participants &modified);
 
 protected:
+    void fetchParticipantsIfNeeded(const History::Threads &threads);
     History::Threads fetchNextPage();
     bool mCanFetchMore;
     bool mGroupThreads;
 
=== modified file 'cmake/modules/GenerateTest.cmake'
--- cmake/modules/GenerateTest.cmake	2015-09-28 14:26:09 +0000
+++ cmake/modules/GenerateTest.cmake	2017-03-23 01:25:43 +0000
@@ -79,6 +79,7 @@
                 set(ARG_ENVIRONMENT HOME=${TMPDIR}
                                     HISTORY_PLUGIN_PATH=${CMAKE_BINARY_DIR}/plugins/sqlite
                                     HISTORY_SQLITE_DBPATH=:memory:
+                                    HISTORY_LOCK_FILE=${TMPDIR}/history-service.lock
                                     MC_ACCOUNT_DIR=${TMPDIR}
                                     MC_MANAGER_DIR=${TMPDIR})
             endif ()
 
=== modified file 'daemon/HistoryService.xml'
--- daemon/HistoryService.xml	2016-04-15 22:23:21 +0000
+++ daemon/HistoryService.xml	2017-03-23 01:25:43 +0000
@@ -35,6 +35,15 @@
             <arg type="a{sv}" direction="out"/>
             <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantMap"/>
         </method>
+        <method name="ParticipantsForThreads">
+            <dox:d><![CDATA[
+                Return the participants for the given threads
+            ]]></dox:d>
+            <arg name="threadIds" type="a(a{sv})" direction="in"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QList &lt; QVariantMap &gt;"/>
+            <arg name="participants" type="a(a{sv})" direction="out"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList &lt; QVariantMap &gt;"/>
+        </method>
         <method name="WriteEvents">
             <dox:d><![CDATA[
                 Write the given events to the storage.
@@ -62,6 +71,13 @@
             <arg type="b" direction="out"/>
             <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QList &lt; QVariantMap &gt;"/>
         </method>
+        <method name="MarkThreadsAsRead">
+            <dox:d><![CDATA[
+                Mark an entire thread as read
+            ]]></dox:d>
+            <arg name="threads" type="a(a{sv})" direction="in"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QList &lt; QVariantMap &gt;"/>
+        </method>
         <method name="QueryThreads">
             <dox:d><![CDATA[
                 Creates a threads view with the given filter and sort order.
@@ -159,5 +175,18 @@
             <arg name="events" type="a(a{sv})"/>
             <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QList &lt; QVariantMap &gt;"/>
         </signal>
+        <signal name="ThreadParticipantsChanged">
+            <dox:d><![CDATA[
+                Participants changed in a certain thread changed.
+            ]]></dox:d>
+            <arg name="thread" type="a{sv}"/>
+            <arg name="added" type="a(a{sv})"/>
+            <arg name="removed" type="a(a{sv})"/>
+            <arg name="modified" type="a(a{sv})"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QVariantMap"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QList &lt; QVariantMap &gt;"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In2" value="QList &lt; QVariantMap &gt;"/>
+            <annotation name="org.qtproject.QtDBus.QtTypeName.In3" value="QList &lt; QVariantMap &gt;"/>
+        </signal>
     </interface>
 </node>
 
=== modified file 'daemon/callchannelobserver.cpp'
--- daemon/callchannelobserver.cpp	2013-07-12 14:30:18 +0000
+++ daemon/callchannelobserver.cpp	2017-03-23 01:25:43 +0000
@@ -40,6 +40,7 @@
                 SLOT(onCallStateChanged(Tp::CallState)));
 
     mChannels.append(callChannel);
+    mCallStates[callChannel.data()] = callChannel->callState();
 }
 
 
@@ -51,11 +52,24 @@
     }
 
     switch (state) {
-    case Tp::CallStateEnded:
-        Q_EMIT callEnded(Tp::CallChannelPtr(channel));
+    case Tp::CallStateEnded: {
+        bool incoming = !channel->isRequested();
+        bool missed = incoming && channel->callStateReason().reason == Tp::CallStateChangeReasonNoAnswer;
+
+        // If the call state is not missed at this point, we need to check from which state we transitioned to ended,
+        // if from Initialised, it means it was indeed missed
+        if (incoming && !missed) {
+            missed = mCallStates[channel] == Tp::CallStateInitialised;
+        }
+        mCallStates.remove(channel);
+        mChannels.removeOne(Tp::CallChannelPtr(channel));
+        Q_EMIT callEnded(Tp::CallChannelPtr(channel), missed);
         break;
+    }
     case Tp::CallStateActive:
         channel->setProperty("activeTimestamp", QDateTime::currentDateTime());
+    default:
+        mCallStates[channel] = state;
         break;
     }
 }
 
=== modified file 'daemon/callchannelobserver.h'
--- daemon/callchannelobserver.h	2013-07-12 14:30:18 +0000
+++ daemon/callchannelobserver.h	2017-03-23 01:25:43 +0000
@@ -35,13 +35,14 @@
     void onCallChannelAvailable(Tp::CallChannelPtr callChannel);
 
 Q_SIGNALS:
-    void callEnded(Tp::CallChannelPtr callChannel);
+    void callEnded(Tp::CallChannelPtr callChannel, bool missed);
 
 protected Q_SLOTS:
     void onCallStateChanged(Tp::CallState state);
 
 private:
     QList<Tp::CallChannelPtr> mChannels;
+    QMap<Tp::CallChannel*,Tp::CallState> mCallStates;
 };
 
 #endif // CALLCHANNELOBSERVER_H
 
=== modified file 'daemon/historydaemon.cpp'
--- daemon/historydaemon.cpp	2016-11-24 02:02:32 +0000
+++ daemon/historydaemon.cpp	2017-03-23 01:25:43 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -85,10 +85,11 @@
 {
     Q_FOREACH (QVariant participant, thread[History::FieldParticipants].toList()) {
         // found if same identifier and as member into thread info
+        QVariantMap participantMap = participant.toMap();
         if (History::Utils::compareIds(thread[History::FieldAccountId].toString(),
                                        contact->id(),
-                                       participant.toMap()[History::FieldIdentifier].toString()) &&
-                participant.toMap()[History::FieldParticipantState].toUInt() == History::ParticipantStateRegular)
+                                       participantMap[History::FieldIdentifier].toString()) &&
+                participantMap[History::FieldParticipantState].toUInt() == History::ParticipantStateRegular)
         {
             return true;
         }
@@ -131,8 +132,8 @@
     History::TelepathyHelper::instance()->registerChannelObserver();
 
     connect(&mCallObserver,
-            SIGNAL(callEnded(Tp::CallChannelPtr)),
-            SLOT(onCallEnded(Tp::CallChannelPtr)));
+            SIGNAL(callEnded(Tp::CallChannelPtr, bool)),
+            SLOT(onCallEnded(Tp::CallChannelPtr, bool)));
     connect(&mTextObserver,
             SIGNAL(messageReceived(Tp::TextChannelPtr,Tp::ReceivedMessage)),
             SLOT(onMessageReceived(Tp::TextChannelPtr,Tp::ReceivedMessage)));
@@ -140,11 +141,11 @@
             SIGNAL(messageSent(Tp::TextChannelPtr,Tp::Message,QString)),
             SLOT(onMessageSent(Tp::TextChannelPtr,Tp::Message,QString)));
     connect(&mTextObserver,
-            SIGNAL(messageRead(Tp::TextChannelPtr,Tp::ReceivedMessage)),
-            SLOT(onMessageRead(Tp::TextChannelPtr,Tp::ReceivedMessage)));
-    connect(&mTextObserver,
             SIGNAL(channelAvailable(Tp::TextChannelPtr)),
             SLOT(onTextChannelAvailable(Tp::TextChannelPtr)));
+    connect(&mTextObserver,
+            SIGNAL(textChannelInvalidated(Tp::TextChannelPtr)),
+            SLOT(onTextChannelInvalidated(Tp::TextChannelPtr)));
 
     // FIXME: we need to do this in a better way, but for now this should do
     mProtocolFlags["ofono"] = History::MatchPhoneNumber;
@@ -163,23 +164,39 @@
 
 void HistoryDaemon::onRolesChanged(const HandleRolesMap &added, const HandleRolesMap &removed)
 {
-    Q_UNUSED(added);
-    Q_UNUSED(removed);
-
     ChannelInterfaceRolesInterface *roles_interface = qobject_cast<ChannelInterfaceRolesInterface*>(sender());
-    RolesMap roles = roles_interface->getRoles();
-
     Tp::TextChannelPtr channel(qobject_cast<Tp::TextChannel*>(sender()->parent()));
+    RolesMap rolesMap;
+    if (!mRolesMap.contains(channel->objectPath())) {
+        rolesMap = roles_interface->getRoles();
+    } else {
+        rolesMap = mRolesMap[channel->objectPath()];
+    }
+
+    QMapIterator<uint, uint> it(removed);
+    while (it.hasNext()) {
+        it.next();
+        rolesMap.remove(it.key());
+    }
+
+    QMapIterator<uint, uint> it2(added);
+    while (it2.hasNext()) {
+        it2.next();
+        rolesMap[it2.key()] = it2.value();
+    }
+        
+    mRolesMap[channel->objectPath()] = rolesMap;
+
     QVariantMap properties = propertiesFromChannel(channel);
     QVariantMap thread = threadForProperties(channel->property(History::FieldAccountId).toString(),
                                              History::EventTypeText,
                                              properties,
                                              matchFlagsForChannel(channel),
                                              false);
-
-    writeRolesInformationEvents(thread, channel, roles);
-
-    updateRoomRoles(channel, roles);
+    if (!thread.isEmpty()) {
+        writeRolesInformationEvents(thread, channel, rolesMap);
+        updateRoomRoles(channel, rolesMap);
+    }
 }
 
 QVariantMap HistoryDaemon::propertiesFromChannel(const Tp::ChannelPtr &textChannel)
@@ -187,55 +204,60 @@
     QVariantMap properties;
     QVariantList participants;
     QStringList participantIds;
-
-    ChannelInterfaceRolesInterface *roles_interface = textChannel->optionalInterface<ChannelInterfaceRolesInterface>();
-    RolesMap roles;
-    if (roles_interface) {
-        roles = roles_interface->getRoles();
-    }
-
-    Q_FOREACH(const Tp::ContactPtr contact, textChannel->groupContacts(false)) {
-        QVariantMap contactProperties;
-        contactProperties[History::FieldAlias] = contact->alias();
-        contactProperties[History::FieldAccountId] = textChannel->property(History::FieldAccountId).toString();
-        contactProperties[History::FieldIdentifier] = contact->id();
-        contactProperties[History::FieldParticipantState] = History::ParticipantStateRegular;
-        contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
-        participantIds << contact->id();
-        participants << contactProperties;
-    }
-
-    Q_FOREACH(const Tp::ContactPtr contact, textChannel->groupRemotePendingContacts(false)) {
-        QVariantMap contactProperties;
-        contactProperties[History::FieldAlias] = contact->alias();
-        contactProperties[History::FieldAccountId] = textChannel->property(History::FieldAccountId).toString();
-        contactProperties[History::FieldIdentifier] = contact->id();
-        contactProperties[History::FieldParticipantState] = History::ParticipantStateRemotePending;
-        contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
-        participantIds << contact->id();
-        participants << contactProperties;
-    }
-
-    Q_FOREACH(const Tp::ContactPtr contact, textChannel->groupLocalPendingContacts(false)) {
-        QVariantMap contactProperties;
-        contactProperties[History::FieldAlias] = contact->alias();
-        contactProperties[History::FieldAccountId] = textChannel->property(History::FieldAccountId).toString();
-        contactProperties[History::FieldIdentifier] = contact->id();
-        contactProperties[History::FieldParticipantState] = History::ParticipantStateLocalPending;
-        contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
-        participantIds << contact->id();
-        participants << contactProperties;
-    }
-
-    if (participants.isEmpty() && textChannel->targetHandleType() == Tp::HandleTypeContact &&
-            textChannel->targetContact() == textChannel->connection()->selfContact()) {
-        QVariantMap contactProperties;
-        contactProperties[History::FieldAlias] = textChannel->targetContact()->alias();
-        contactProperties[History::FieldAccountId] = textChannel->property(History::FieldAccountId).toString();
-        contactProperties[History::FieldIdentifier] = textChannel->targetContact()->id();
-        contactProperties[History::FieldParticipantState] = History::ParticipantStateRegular;
-        participantIds << textChannel->targetContact()->id();
-        participants << contactProperties;
+    QString accountId = textChannel->property(History::FieldAccountId).toString();
+
+    if (History::Utils::shouldIncludeParticipants(accountId, fromTelepathyHandleType(textChannel->targetHandleType()))) {
+        ChannelInterfaceRolesInterface *roles_interface = textChannel->optionalInterface<ChannelInterfaceRolesInterface>();
+        RolesMap roles;
+        if (roles_interface) {
+            if (mRolesMap.contains(textChannel->objectPath())) {
+                roles = mRolesMap[textChannel->objectPath()];
+            }
+        }
+
+        Q_FOREACH(const Tp::ContactPtr contact, textChannel->groupContacts(false)) {
+            QVariantMap contactProperties;
+            contactProperties[History::FieldAlias] = contact->alias();
+            contactProperties[History::FieldAccountId] = accountId;
+            contactProperties[History::FieldIdentifier] = contact->id();
+            contactProperties[History::FieldParticipantState] = History::ParticipantStateRegular;
+            contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
+            participantIds << contact->id();
+            participants << contactProperties;
+        }
+
+        Q_FOREACH(const Tp::ContactPtr contact, textChannel->groupRemotePendingContacts(false)) {
+            QVariantMap contactProperties;
+            contactProperties[History::FieldAlias] = contact->alias();
+            contactProperties[History::FieldAccountId] = accountId;
+            contactProperties[History::FieldIdentifier] = contact->id();
+            contactProperties[History::FieldParticipantState] = History::ParticipantStateRemotePending;
+            contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
+            participantIds << contact->id();
+            participants << contactProperties;
+        }
+
+        Q_FOREACH(const Tp::ContactPtr contact, textChannel->groupLocalPendingContacts(false)) {
+            QVariantMap contactProperties;
+            contactProperties[History::FieldAlias] = contact->alias();
+            contactProperties[History::FieldAccountId] = accountId;
+            contactProperties[History::FieldIdentifier] = contact->id();
+            contactProperties[History::FieldParticipantState] = History::ParticipantStateLocalPending;
+            contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
+            participantIds << contact->id();
+            participants << contactProperties;
+        }
+
+        if (participants.isEmpty() && textChannel->targetHandleType() == Tp::HandleTypeContact &&
+                textChannel->targetContact() == textChannel->connection()->selfContact()) {
+            QVariantMap contactProperties;
+            contactProperties[History::FieldAlias] = textChannel->targetContact()->alias();
+            contactProperties[History::FieldAccountId] = accountId;
+            contactProperties[History::FieldIdentifier] = textChannel->targetContact()->id();
+            contactProperties[History::FieldParticipantState] = History::ParticipantStateRegular;
+            participantIds << textChannel->targetContact()->id();
+            participants << contactProperties;
+        }
     }
 
     // We map chatType directly from telepathy targetHandleType: None, Contact, Room
@@ -314,6 +336,39 @@
     return thread;
 }
 
+QString HistoryDaemon::threadIdForProperties(const QString &accountId, History::EventType type, const QVariantMap &properties, History::MatchFlags matchFlags, bool create)
+{
+    if (!mBackend) {
+        return QString::null;
+    }
+
+    QString threadId = mBackend->threadIdForProperties(accountId,
+                                                       type,
+                                                       properties,
+                                                       matchFlags);
+    if (threadId.isEmpty() && create) {
+        QVariantMap thread = mBackend->createThreadForProperties(accountId, type, properties);
+        if (!thread.isEmpty()) {
+            if (properties.contains("Requested") && properties[History::FieldChatType].toInt() == History::ChatTypeRoom) {
+                QVariantMap map = thread[History::FieldChatRoomInfo].toMap();
+                map["Requested"] = properties["Requested"];
+                thread[History::FieldChatRoomInfo] = map;
+            }
+            mDBus.notifyThreadsAdded(QList<QVariantMap>() << thread);
+            threadId = thread[History::FieldThreadId].toString();
+        }
+    }
+    return threadId;
+}
+
+QList<QVariantMap> HistoryDaemon::participantsForThreads(const QList<QVariantMap> &threadIds)
+{
+    if (!mBackend) {
+        return QList<QVariantMap>();
+    }
+    return mBackend->participantsForThreads(threadIds);
+}
+
 QString HistoryDaemon::queryThreads(int type, const QVariantMap &sort, const QVariantMap &filter, const QVariantMap &properties)
 {
     if (!mBackend) {
@@ -370,7 +425,7 @@
     return mBackend->getSingleEvent((History::EventType)type, accountId, threadId, eventId);
 }
 
-bool HistoryDaemon::writeEvents(const QList<QVariantMap> &events, const QVariantMap &properties)
+bool HistoryDaemon::writeEvents(const QList<QVariantMap> &events, const QVariantMap &properties, bool notify)
 {
     if (!mBackend) {
         return false;
@@ -407,7 +462,9 @@
         threads[hash] = thread;
 
         // set the participants field in the event
-        savedEvent[History::FieldParticipants] = thread[History::FieldParticipants];
+        if (type == History::EventTypeVoice) {
+            savedEvent[History::FieldParticipants] = thread[History::FieldParticipants];
+        }
 
 
         // check if the event was a new one or a modification to an existing one
@@ -427,13 +484,13 @@
     mBackend->endBatchOperation();
 
     // and last but not least, notify the results
-    if (!newEvents.isEmpty()) {
+    if (!newEvents.isEmpty() && notify) {
         mDBus.notifyEventsAdded(newEvents);
     }
-    if (!modifiedEvents.isEmpty()) {
+    if (!modifiedEvents.isEmpty() && notify) {
         mDBus.notifyEventsModified(modifiedEvents);
     }
-    if (!threads.isEmpty()) {
+    if (!threads.isEmpty() && notify) {
         mDBus.notifyThreadsModified(threads.values());
     }
     return true;
@@ -512,44 +569,46 @@
     return true;
 }
 
+void HistoryDaemon::markThreadsAsRead(const QList<QVariantMap> &threads)
+{
+    if (!mBackend) {
+        return;
+    }
+
+    QList<QVariantMap> modifiedThreads;
+   
+    Q_FOREACH(const QVariantMap &thread, threads) {
+        mBackend->beginBatchOperation();
+        QVariantMap newThread = mBackend->markThreadAsRead(thread);
+        if (!newThread.isEmpty()) {
+            modifiedThreads << newThread;
+        }
+
+        mBackend->endBatchOperation();
+    }
+
+    if (!modifiedThreads.isEmpty()) {
+        mDBus.notifyThreadsModified(modifiedThreads);
+    }
+}
+
 bool HistoryDaemon::removeThreads(const QList<QVariantMap> &threads)
 {
     if (!mBackend) {
         return false;
     }
 
-    // In order to remove a thread all we have to do is to remove all its items
-    // then it is going to be removed by removeEvents() once it detects the thread is
-    // empty.
-    QList<QVariantMap> events;
-    QMap<QString, QVariantMap> removedEmptyThreads;
+    // If the thread has events
+    mBackend->beginBatchOperation();
     Q_FOREACH(const QVariantMap &thread, threads) {
-        QList<QVariantMap> thisEvents = mBackend->eventsForThread(thread);
-        if (thisEvents.isEmpty()) {
-            mBackend->beginBatchOperation();
-            if (!mBackend->removeThread(thread)) {
-                mBackend->rollbackBatchOperation();
-                return false;
-            }
-            mBackend->endBatchOperation();
-            QString hash = hashThread(thread);
-            removedEmptyThreads[hash] = thread;
-            continue;
-        }
-        events += thisEvents;
-    }
-
-    if (!removedEmptyThreads.isEmpty()) {
-        mDBus.notifyThreadsRemoved(removedEmptyThreads.values());
-    }
-
-    if (events.size() > 0) {
-        if(removeEvents(events)) {
-            return true;
-        }
-    }
-
-    return false;
+        if (!mBackend->removeThread(thread)) {
+            mBackend->rollbackBatchOperation();
+            return false;
+        }
+    }
+    mBackend->endBatchOperation();
+    mDBus.notifyThreadsRemoved(threads);
+    return true;
 }
 
 void HistoryDaemon::onObserverCreated()
@@ -562,7 +621,7 @@
             &mTextObserver, SLOT(onTextChannelAvailable(Tp::TextChannelPtr)));
 }
 
-void HistoryDaemon::onCallEnded(const Tp::CallChannelPtr &channel)
+void HistoryDaemon::onCallEnded(const Tp::CallChannelPtr &channel, bool missed)
 {
     QVariantMap properties = propertiesFromChannel(channel);
     QVariantList participants;
@@ -592,7 +651,6 @@
     // FIXME: check if checking for isRequested() is enough
     bool incoming = !channel->isRequested();
     int duration;
-    bool missed = incoming && channel->callStateReason().reason == Tp::CallStateChangeReasonNoAnswer;
 
     if (!missed) {
         QDateTime activeTime = channel->property("activeTimestamp").toDateTime();
@@ -615,11 +673,35 @@
     writeEvents(QList<QVariantMap>() << event, properties);
 }
 
+void HistoryDaemon::onTextChannelInvalidated(const Tp::TextChannelPtr channel)
+{
+    mRolesMap.remove(channel->objectPath());
+    QString accountId = channel->property(History::FieldAccountId).toString();
+    QVariantMap properties = propertiesFromChannel(channel);
+
+    // first try to fetch the existing thread to see if there is any.
+    QVariantMap thread = threadForProperties(accountId,
+                                             History::EventTypeText,
+                                             properties,
+                                             matchFlagsForChannel(channel),
+                                             false);
+
+    QVariantMap roomInfo = thread[History::FieldChatRoomInfo].toMap();
+    if ((roomInfo.contains("Persistent") && !roomInfo["Persistent"].toBool()) && History::TelepathyHelper::instance()->accountForId(accountId)->protocolName() != "ofono") {
+        writeInformationEvent(thread, History::InformationTypeSelfLeaving);
+        // update backend
+        updateRoomProperties(channel, QVariantMap{{"Joined", false}});
+    }
+
+    channel->disconnect(this);
+}
+
 void HistoryDaemon::onTextChannelAvailable(const Tp::TextChannelPtr channel)
 {
     // for Rooms we need to explicitly create the thread to allow users to send messages to groups even
     // before they receive any message.
     // for other types, we can wait until messages are received
+    bool notify = false;
     if (channel->targetHandleType() == Tp::HandleTypeRoom) {
         QString accountId = channel->property(History::FieldAccountId).toString();
         QVariantMap properties = propertiesFromChannel(channel);
@@ -641,12 +723,13 @@
 
             // write information event including all initial invitees
             Q_FOREACH(const Tp::ContactPtr contact, channel->groupRemotePendingContacts(false)) {
-                writeInformationEvent(thread, History::InformationTypeInvitationSent, contact->alias());
+                writeInformationEvent(thread, History::InformationTypeInvitationSent, contact->alias(), QString(), QString(), false);
             }
 
             // update participants only if the thread is not available previously. Otherwise we'll wait for membersChanged event
             // for reflect in conversation information events for modified participants.
-            updateRoomParticipants(channel);
+            updateRoomParticipants(channel, false);
+            notify = true;
         }
 
         // write an entry saying you joined the group if 'joined' flag in thread is false and modify that flag.
@@ -657,7 +740,8 @@
                 writeInformationEvent(thread, History::InformationTypeSelfJoined);
             }
             // update backend
-            updateRoomProperties(channel, QVariantMap{{"Joined", true}});
+            updateRoomProperties(channel, QVariantMap{{"Joined", true}}, false);
+            notify = true;
         }
 
         Tp::AbstractInterface *room_interface = channel->optionalInterface<Tp::Client::ChannelInterfaceRoomInterface>();
@@ -685,6 +769,10 @@
 
         connect(roles_interface, SIGNAL(RolesChanged(const HandleRolesMap&, const HandleRolesMap&)), SLOT(onRolesChanged(const HandleRolesMap&, const HandleRolesMap&)));
     }
+
+    if (notify) {
+        updateRoomParticipants(channel, true);
+    }
 }
 
 void HistoryDaemon::onGroupMembersChanged(const Tp::Contacts &groupMembersAdded,
@@ -702,6 +790,8 @@
     bool hasRemotePendingMembersAdded = groupRemotePendingMembersAdded.size() > 0;
     bool hasMembersAdded = groupMembersAdded.size() > 0;
     bool hasMembersRemoved = groupMembersRemoved.size() > 0;
+    Tp::ContactPtr selfContact = channel->connection()->selfContact();
+    bool selfContactIsPending = channel->groupRemotePendingContacts(true).contains(selfContact);
 
     if (hasRemotePendingMembersAdded || hasMembersAdded || hasMembersRemoved) {
         properties = propertiesFromChannel(channel);
@@ -710,19 +800,35 @@
                                                        properties,
                                                        matchFlagsForChannel(channel),
                                                        false);
-        if (!thread.isEmpty()) {
+        if (!thread.isEmpty() && !selfContactIsPending) {
+            QList<QVariantMap> added;
+            QList<QVariantMap> removed;
+            QList<QVariantMap> modified;
             if (hasRemotePendingMembersAdded) {
                 Q_FOREACH (const Tp::ContactPtr& contact, groupRemotePendingMembersAdded) {
                     if (!foundInThread(contact, thread)) {
-                        writeInformationEvent(thread, History::InformationTypeInvitationSent, contact->alias());
+                        writeInformationEvent(thread, History::InformationTypeInvitationSent, contact->alias(), QString(), QString(), true);
+                        QVariantMap participant;
+                        participant[History::FieldIdentifier] = contact->id();
+                        participant[History::FieldAlias] = contact->alias();
+                        participant[History::FieldParticipantState] = History::ParticipantStateRemotePending;
+                        added << participant;
                     }
                 }
+
             }
             if (hasMembersAdded) {
                 Q_FOREACH (const Tp::ContactPtr& contact, groupMembersAdded) {
                     // if this member was not previously regular member in thread, notify about his join
-                    if (!foundAsMemberInThread(contact, thread)) {
-                        writeInformationEvent(thread, History::InformationTypeJoined, contact->alias());
+                    if (!foundAsMemberInThread(contact, thread) && contact->id() != channel->groupSelfContact()->id()) {
+
+                        writeInformationEvent(thread, History::InformationTypeJoined, contact->alias(), QString(), QString(), true);
+
+                        QVariantMap participant;
+                        participant[History::FieldIdentifier] = contact->id();
+                        participant[History::FieldAlias] = contact->alias();
+                        participant[History::FieldParticipantState] = History::ParticipantStateRegular;
+                        added << participant;
                     }
                 }
             }
@@ -741,27 +847,34 @@
                             break;
                         }
                     }
-                    writeInformationEvent(thread, type);
-                    // update backend
-                    updateRoomProperties(channel, QVariantMap{{"Joined", false}});
+                    if (thread[History::FieldChatRoomInfo].toMap()["Joined"].toBool()) {
+                        writeInformationEvent(thread, type);
+                        // update backend
+                        updateRoomProperties(channel, QVariantMap{{"Joined", false}}, true);
+                    }
                 }
                 else // don't notify any other group member removal if we are leaving the group
                 {
                     Q_FOREACH (const Tp::ContactPtr& contact, groupMembersRemoved) {
                         // inform about removed members other than us
                         if (contact->id() != channel->groupSelfContact()->id()) {
-                            writeInformationEvent(thread, History::InformationTypeLeaving, contact->alias());
+                            writeInformationEvent(thread, History::InformationTypeLeaving, contact->alias(), QString(), QString(), true);
                         }
+                        QVariantMap participant;
+                        participant[History::FieldIdentifier] = contact->id();
+                        participant[History::FieldAlias] = contact->alias();
+                        removed << participant;
                     }
                 }
             }
+            mDBus.notifyThreadParticipantsChanged(thread, added, removed, QList<QVariantMap>());
         }
     }
 
-    updateRoomParticipants(channel);
+    updateRoomParticipants(channel, !selfContactIsPending);
 }
 
-void HistoryDaemon::updateRoomParticipants(const Tp::TextChannelPtr channel)
+void HistoryDaemon::updateRoomParticipants(const Tp::TextChannelPtr channel, bool notify)
 {
     if (!channel) {
         return;
@@ -772,8 +885,14 @@
 
     ChannelInterfaceRolesInterface *roles_interface = channel->optionalInterface<ChannelInterfaceRolesInterface>();
     RolesMap roles;
+
     if (roles_interface) {
-        roles = roles_interface->getRoles();
+        if (!mRolesMap.contains(channel->objectPath())) {
+            roles = roles_interface->getRoles();
+            mRolesMap[channel->objectPath()] = roles;
+        } else {
+            roles = mRolesMap[channel->objectPath()];
+        }
     }
 
     Q_FOREACH(const Tp::ContactPtr contact, channel->groupRemotePendingContacts(false)) {
@@ -811,12 +930,14 @@
     QString accountId = channel->property(History::FieldAccountId).toString();
     QString threadId = channel->targetId();
     if (mBackend->updateRoomParticipants(accountId, threadId, History::EventTypeText, participants)) {
-        QVariantMap updatedThread = getSingleThread(History::EventTypeText, accountId, threadId, QVariantMap());
-        mDBus.notifyThreadsModified(QList<QVariantMap>() << updatedThread);
+        if (notify) {
+            QVariantMap updatedThread = getSingleThread(History::EventTypeText, accountId, threadId, QVariantMap());
+            mDBus.notifyThreadsModified(QList<QVariantMap>() << updatedThread);
+        }
     }
 }
 
-void HistoryDaemon::updateRoomRoles(const Tp::TextChannelPtr &channel, const RolesMap &rolesMap)
+void HistoryDaemon::updateRoomRoles(const Tp::TextChannelPtr &channel, const RolesMap &rolesMap, bool notify)
 {
     if (!channel) {
         return;
@@ -841,8 +962,10 @@
     QString accountId = channel->property(History::FieldAccountId).toString();
     QString threadId = channel->targetId();
     if (mBackend->updateRoomParticipantsRoles(accountId, threadId, History::EventTypeText, participantsRoles)) {
-        QVariantMap updatedThread = getSingleThread(History::EventTypeText, accountId, threadId, QVariantMap());
-        mDBus.notifyThreadsModified(QList<QVariantMap>() << updatedThread);
+        if (notify) {
+            QVariantMap updatedThread = getSingleThread(History::EventTypeText, accountId, threadId, QVariantMap());
+            mDBus.notifyThreadsModified(QList<QVariantMap>() << updatedThread);
+        }
     }
 
     // update self roles in room properties
@@ -865,28 +988,41 @@
     updateRoomProperties(accountId, threadId, type, properties, invalidated);
 }
 
-void HistoryDaemon::updateRoomProperties(const Tp::TextChannelPtr &channel, const QVariantMap &properties)
+void HistoryDaemon::updateRoomProperties(const Tp::TextChannelPtr &channel, const QVariantMap &properties, bool notify)
 {
     QString accountId = channel->property(History::FieldAccountId).toString();
     QString threadId = channel->targetId();
     History::EventType type = History::EventTypeText;
-    updateRoomProperties(accountId, threadId, type, properties, QStringList());
+    updateRoomProperties(accountId, threadId, type, properties, QStringList(), notify);
 }
 
-void HistoryDaemon::updateRoomProperties(const QString &accountId, const QString &threadId, History::EventType type, const QVariantMap &properties, const QStringList &invalidated)
+void HistoryDaemon::updateRoomProperties(const QString &accountId, const QString &threadId, History::EventType type, const QVariantMap &properties, const QStringList &invalidated, bool notify)
 {
     if (mBackend->updateRoomInfo(accountId, threadId, type, properties, invalidated)) {
-        QVariantMap thread = getSingleThread(type, accountId, threadId, QVariantMap());
-        mDBus.notifyThreadsModified(QList<QVariantMap>() << thread);
+        if (notify) {
+            QVariantMap thread = getSingleThread(type, accountId, threadId, QVariantMap());
+            mDBus.notifyThreadsModified(QList<QVariantMap>() << thread);
+        }
     }
 }
 
 void HistoryDaemon::onMessageReceived(const Tp::TextChannelPtr textChannel, const Tp::ReceivedMessage &message)
 {
     QString eventId;
-    Tp::MessagePart header = message.header();
     QString senderId;
+
+    QString accountId = textChannel->property(History::FieldAccountId).toString();
+    QString threadId = textChannel->property(History::FieldThreadId).toString();
     QVariantMap properties = propertiesFromChannel(textChannel);
+
+    if (threadId.isNull()) {
+        threadId = threadIdForProperties(accountId,
+                                         History::EventTypeText,
+                                         properties,
+                                         matchFlagsForChannel(textChannel),
+                                         true);
+    }
+
     History::MessageStatus status = History::MessageStatusUnknown;
     if (!message.sender() || message.sender()->handle().at(0) == textChannel->connection()->selfHandle()) {
         senderId = "self";
@@ -909,7 +1045,7 @@
     if (message.isDeliveryReport() && message.deliveryDetails().hasOriginalToken()) {
         // at this point we assume the delivery report is for a message that was already
         // sent and properly saved at our database, so we can safely get it here to update
-        QVariantMap textEvent = getSingleEventFromTextChannel(textChannel, message.deliveryDetails().originalToken());
+        QVariantMap textEvent = getSingleEvent(History::EventTypeText, accountId, threadId, message.deliveryDetails().originalToken());
         if (textEvent.isEmpty()) {
             qWarning() << "Cound not find the original event to update with delivery details.";
             return;
@@ -922,52 +1058,21 @@
             return;
         }
 
-        History::MessageStatus status;
-        switch (message.deliveryDetails().status()) {
-        case Tp::DeliveryStatusAccepted:
-            status = History::MessageStatusAccepted;
-            break;
-        case Tp::DeliveryStatusDeleted:
-            status = History::MessageStatusDeleted;
-            break;
-        case Tp::DeliveryStatusDelivered:
-            status = History::MessageStatusDelivered;
-            break;
-        case Tp::DeliveryStatusPermanentlyFailed:
-            status = History::MessageStatusPermanentlyFailed;
-            break;
-        case Tp::DeliveryStatusRead:
-            status = History::MessageStatusRead;
-            break;
-        case Tp::DeliveryStatusTemporarilyFailed:
-            status = History::MessageStatusTemporarilyFailed;
-            break;
-        case Tp::DeliveryStatusUnknown:
-            status = History::MessageStatusUnknown;
-            break;
-        }
-
-        textEvent[History::FieldMessageStatus] = (int) status;
+        textEvent[History::FieldMessageStatus] = (int) fromTelepathyDeliveryStatus(message.deliveryDetails().status());
         if (!writeEvents(QList<QVariantMap>() << textEvent, properties)) {
             qWarning() << "Failed to save the new message status!";
         }
 
         return;
     }
-
-    QVariantMap thread = threadForProperties(textChannel->property(History::FieldAccountId).toString(),
-                                                                   History::EventTypeText,
-                                                                   properties,
-                                                                   matchFlagsForChannel(textChannel),
-                                                                   true);
     int count = 1;
     QList<QVariantMap> attachments;
     History::MessageType type = History::MessageTypeText;
     QString subject;
 
     if (message.hasNonTextContent()) {
-        QString normalizedAccountId = QString(QCryptographicHash::hash(thread[History::FieldAccountId].toString().toLatin1(), QCryptographicHash::Md5).toHex());
-        QString normalizedThreadId = QString(QCryptographicHash::hash(thread[History::FieldThreadId].toString().toLatin1(), QCryptographicHash::Md5).toHex());
+        QString normalizedAccountId = QString(QCryptographicHash::hash(accountId.toLatin1(), QCryptographicHash::Md5).toHex());
+        QString normalizedThreadId = QString(QCryptographicHash::hash(threadId.toLatin1(), QCryptographicHash::Md5).toHex());
         QString normalizedEventId = QString(QCryptographicHash::hash(eventId.toLatin1(), QCryptographicHash::Md5).toHex());
         QString mmsStoragePath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
 
@@ -1000,8 +1105,8 @@
             file.close();
 
             QVariantMap attachment;
-            attachment[History::FieldAccountId] = thread[History::FieldAccountId];
-            attachment[History::FieldThreadId] = thread[History::FieldThreadId];
+            attachment[History::FieldAccountId] = accountId;
+            attachment[History::FieldThreadId] = threadId;
             attachment[History::FieldEventId] = eventId;
             attachment[History::FieldAttachmentId] = part["identifier"].variant();
             attachment[History::FieldContentType] = part["content-type"].variant();
@@ -1013,8 +1118,8 @@
 
     QVariantMap event;
     event[History::FieldType] = History::EventTypeText;
-    event[History::FieldAccountId] = thread[History::FieldAccountId];
-    event[History::FieldThreadId] = thread[History::FieldThreadId];
+    event[History::FieldAccountId] = accountId;
+    event[History::FieldThreadId] = threadId;
     event[History::FieldEventId] = eventId;
     event[History::FieldSenderId] = senderId;
     event[History::FieldTimestamp] = message.received().toString("yyyy-MM-ddTHH:mm:ss.zzz");
@@ -1058,22 +1163,6 @@
 
 }
 
-void HistoryDaemon::onMessageRead(const Tp::TextChannelPtr textChannel, const Tp::ReceivedMessage &message)
-{
-    QVariantMap textEvent = getSingleEventFromTextChannel(textChannel, message.messageToken());
-    QVariantMap properties = propertiesFromChannel(textChannel);
-
-    if (textEvent.isEmpty()) {
-        qWarning() << "Cound not find the original event to update with newEvent = false.";
-        return;
-    }
-
-    textEvent[History::FieldNewEvent] = false;
-    if (!writeEvents(QList<QVariantMap>() << textEvent, properties)) {
-        qWarning() << "Failed to save the new message status!";
-    }
-}
-
 void HistoryDaemon::onMessageSent(const Tp::TextChannelPtr textChannel, const Tp::Message &message, const QString &messageToken)
 {
     QVariantMap properties = propertiesFromChannel(textChannel);
@@ -1191,7 +1280,7 @@
     return reply.value();
 }
 
-void HistoryDaemon::writeInformationEvent(const QVariantMap &thread, History::InformationType type, const QString &subject, const QString &sender, const QString &text)
+void HistoryDaemon::writeInformationEvent(const QVariantMap &thread, History::InformationType type, const QString &subject, const QString &sender, const QString &text, bool notify)
 {
     History::TextEvent historyEvent = History::TextEvent(thread[History::FieldAccountId].toString(),
                                                          thread[History::FieldThreadId].toString(),
@@ -1207,7 +1296,7 @@
                                                          QDateTime::currentDateTime(),
                                                          subject,
                                                          type);
-    writeEvents(QList<QVariantMap>() << historyEvent.properties(), thread);
+    writeEvents(QList<QVariantMap>() << historyEvent.properties(), thread, notify);
 }
 
 void HistoryDaemon::writeRoomChangesInformationEvents(const QVariantMap &thread, const QVariantMap &interfaceProperties)
@@ -1265,3 +1354,51 @@
         }
     }
 }
+
+History::MessageStatus HistoryDaemon::fromTelepathyDeliveryStatus(Tp::DeliveryStatus deliveryStatus)
+{
+    History::MessageStatus status;
+    switch (deliveryStatus) {
+    case Tp::DeliveryStatusAccepted:
+        status = History::MessageStatusAccepted;
+        break;
+    case Tp::DeliveryStatusDeleted:
+        status = History::MessageStatusDeleted;
+        break;
+    case Tp::DeliveryStatusDelivered:
+        status = History::MessageStatusDelivered;
+        break;
+    case Tp::DeliveryStatusPermanentlyFailed:
+        status = History::MessageStatusPermanentlyFailed;
+        break;
+    case Tp::DeliveryStatusRead:
+        status = History::MessageStatusRead;
+        break;
+    case Tp::DeliveryStatusTemporarilyFailed:
+        status = History::MessageStatusTemporarilyFailed;
+        break;
+    case Tp::DeliveryStatusUnknown:
+        status = History::MessageStatusUnknown;
+        break;
+    }
+
+    return status;
+}
+
+History::ChatType HistoryDaemon::fromTelepathyHandleType(const Tp::HandleType &type)
+{
+    History::ChatType chatType;
+    switch(type) {
+    case Tp::HandleTypeContact:
+        chatType = History::ChatTypeContact;
+        break;
+    case Tp::HandleTypeNone:
+        chatType = History::ChatTypeNone;
+        break;
+    case Tp::HandleTypeRoom:
+        chatType = History::ChatTypeRoom;
+        break;
+    }
+
+    return chatType;
+}
 
=== modified file 'daemon/historydaemon.h'
--- daemon/historydaemon.h	2016-10-20 13:56:10 +0000
+++ daemon/historydaemon.h	2017-03-23 01:25:43 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -42,29 +42,36 @@
 
     static HistoryDaemon *instance();
 
-    static QVariantMap propertiesFromChannel(const Tp::ChannelPtr &textChannel);
+    QVariantMap propertiesFromChannel(const Tp::ChannelPtr &textChannel);
     QVariantMap threadForProperties(const QString &accountId,
                                     History::EventType type,
                                     const QVariantMap &properties,
                                     History::MatchFlags matchFlags = History::MatchCaseSensitive,
                                     bool create = true);
+    QString threadIdForProperties(const QString &accountId,
+                                      History::EventType type,
+                                      const QVariantMap &properties,
+                                      History::MatchFlags matchFlags = History::MatchCaseSensitive,
+                                      bool create = true);
+    QList<QVariantMap> participantsForThreads(const QList<QVariantMap> &threadIds);
     QString queryThreads(int type, const QVariantMap &sort, const QVariantMap &filter, const QVariantMap &properties);
     QString queryEvents(int type, const QVariantMap &sort, const QVariantMap &filter);
     QVariantMap getSingleThread(int type, const QString &accountId, const QString &threadId, const QVariantMap &properties);
     QVariantMap getSingleEvent(int type, const QString &accountId, const QString &threadId, const QString &eventId);
     QVariantMap getSingleEventFromTextChannel(const Tp::TextChannelPtr textChannel, const QString &messageId);
 
-    bool writeEvents(const QList<QVariantMap> &events, const QVariantMap &properties);
+    bool writeEvents(const QList<QVariantMap> &events, const QVariantMap &properties, bool notify = true);
     bool removeEvents(const QList<QVariantMap> &events);
     bool removeThreads(const QList<QVariantMap> &threads);
+    void markThreadsAsRead(const QList<QVariantMap> &threads);
 
 private Q_SLOTS:
     void onObserverCreated();
-    void onCallEnded(const Tp::CallChannelPtr &channel);
+    void onCallEnded(const Tp::CallChannelPtr &channel, bool missed);
     void onMessageReceived(const Tp::TextChannelPtr textChannel, const Tp::ReceivedMessage &message);
-    void onMessageRead(const Tp::TextChannelPtr textChannel, const Tp::ReceivedMessage &message);
     void onMessageSent(const Tp::TextChannelPtr textChannel, const Tp::Message &message, const QString &messageToken);
     void onTextChannelAvailable(const Tp::TextChannelPtr channel);
+    void onTextChannelInvalidated(const Tp::TextChannelPtr channel);
     void onRoomPropertiesChanged(const QVariantMap &properties,const QStringList &invalidated);
     void onGroupMembersChanged(const Tp::Contacts &groupMembersAdded, const Tp::Contacts &groupLocalPendingMembersAdded,
                                const Tp::Contacts &groupRemotePendingMembersAdded, const Tp::Contacts &groupMembersRemoved,
@@ -73,18 +80,21 @@
 
 protected:
     History::MatchFlags matchFlagsForChannel(const Tp::ChannelPtr &channel);
-    void updateRoomParticipants(const Tp::TextChannelPtr channel);
-    void updateRoomRoles(const Tp::TextChannelPtr &channel, const RolesMap &rolesMap);
+    void updateRoomParticipants(const Tp::TextChannelPtr channel, bool notify = true);
+    void updateRoomRoles(const Tp::TextChannelPtr &channel, const RolesMap &rolesMap, bool notify = true);
     QString hashThread(const QVariantMap &thread);
     static QVariantMap getInterfaceProperties(const Tp::AbstractInterface *interface);
-    void updateRoomProperties(const Tp::TextChannelPtr &channel, const QVariantMap &properties);
-    void updateRoomProperties(const QString &accountId, const QString &threadId, History::EventType type, const QVariantMap &properties, const QStringList &invalidated);
+    void updateRoomProperties(const Tp::TextChannelPtr &channel, const QVariantMap &properties, bool notify = true);
+    void updateRoomProperties(const QString &accountId, const QString &threadId, History::EventType type, const QVariantMap &properties, const QStringList &invalidated, bool notify = true);
 
-    void writeInformationEvent(const QVariantMap &thread, History::InformationType type, const QString &subject = QString(), const QString &sender = QString("self"), const QString &text = QString());
+    void writeInformationEvent(const QVariantMap &thread, History::InformationType type, const QString &subject = QString(), const QString &sender = QString("self"), const QString &text = QString(), bool notify = true);
 
     void writeRoomChangesInformationEvents(const QVariantMap &thread, const QVariantMap &interfaceProperties);
     void writeRolesInformationEvents(const QVariantMap &thread, const Tp::ChannelPtr &channel, const RolesMap &rolesMap);
     void writeRolesChangesInformationEvents(const QVariantMap &thread, const Tp::ChannelPtr &channel, const RolesMap &rolesMap);
+
+    static History::MessageStatus fromTelepathyDeliveryStatus(Tp::DeliveryStatus deliveryStatus);
+    static History::ChatType fromTelepathyHandleType(const Tp::HandleType &type);
 private:
     HistoryDaemon(QObject *parent = 0);
 
@@ -93,6 +103,7 @@
     QMap<QString, History::MatchFlags> mProtocolFlags;
     History::PluginPtr mBackend;
     HistoryServiceDBus mDBus;
+    QMap<QString, RolesMap> mRolesMap;
 };
 
 #endif
 
=== modified file 'daemon/historyservicedbus.cpp'
--- daemon/historyservicedbus.cpp	2016-11-24 01:56:01 +0000
+++ daemon/historyservicedbus.cpp	2017-03-23 01:25:43 +0000
@@ -27,7 +27,7 @@
 Q_DECLARE_METATYPE(QList< QVariantMap >)
 
 HistoryServiceDBus::HistoryServiceDBus(QObject *parent) :
-    QObject(parent), mAdaptor(0)
+    QObject(parent), mAdaptor(0), mSignalsTimer(-1)
 {
     qDBusRegisterMetaType<QList<QVariantMap> >();
 }
@@ -47,32 +47,46 @@
 
 void HistoryServiceDBus::notifyThreadsAdded(const QList<QVariantMap> &threads)
 {
-    Q_EMIT ThreadsAdded(threads);
+    mThreadsAdded << threads;
+    triggerSignals();
 }
 
 void HistoryServiceDBus::notifyThreadsModified(const QList<QVariantMap> &threads)
 {
-    Q_EMIT ThreadsModified(threads);
+    mThreadsModified << threads;
+    triggerSignals();
 }
 
 void HistoryServiceDBus::notifyThreadsRemoved(const QList<QVariantMap> &threads)
 {
-    Q_EMIT ThreadsRemoved(threads);
+    mThreadsRemoved << threads;
+    triggerSignals();
 }
 
 void HistoryServiceDBus::notifyEventsAdded(const QList<QVariantMap> &events)
 {
-    Q_EMIT EventsAdded(events);
+    mEventsAdded << events;
+    triggerSignals();
 }
 
 void HistoryServiceDBus::notifyEventsModified(const QList<QVariantMap> &events)
 {
-    Q_EMIT EventsModified(events);
+    mEventsModified << events;
+    triggerSignals();
 }
 
 void HistoryServiceDBus::notifyEventsRemoved(const QList<QVariantMap> &events)
 {
-    Q_EMIT EventsRemoved(events);
+    mEventsRemoved << events;
+    triggerSignals();
+}
+
+void HistoryServiceDBus::notifyThreadParticipantsChanged(const QVariantMap &thread,
+                                                   const QList<QVariantMap> &added,
+                                                   const QList<QVariantMap> &removed,
+                                                   const QList<QVariantMap> &modified)
+{
+    Q_EMIT ThreadParticipantsChanged(thread, added, removed, modified);
 }
 
 QVariantMap HistoryServiceDBus::ThreadForProperties(const QString &accountId,
@@ -85,7 +99,12 @@
                                                             (History::EventType) type,
                                                             properties,
                                                             (History::MatchFlags) matchFlags,
-                                                            create);
+                                                          create);
+}
+
+QList<QVariantMap> HistoryServiceDBus::ParticipantsForThreads(const QList<QVariantMap> &threadIds)
+{
+    return HistoryDaemon::instance()->participantsForThreads(threadIds);
 }
 
 QVariantMap HistoryServiceDBus::ThreadForParticipants(const QString &accountId,
@@ -114,6 +133,11 @@
     return HistoryDaemon::instance()->removeThreads(threads);
 }
 
+void HistoryServiceDBus::MarkThreadsAsRead(const QList<QVariantMap> &threads)
+{
+    return HistoryDaemon::instance()->markThreadsAsRead(threads);
+}
+
 bool HistoryServiceDBus::RemoveEvents(const QList<QVariantMap> &events)
 {
     return HistoryDaemon::instance()->removeEvents(events);
@@ -139,3 +163,73 @@
     return HistoryDaemon::instance()->getSingleEvent(type, accountId, threadId, eventId);
 }
 
+void HistoryServiceDBus::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == mSignalsTimer) {
+        killTimer(mSignalsTimer);
+        mSignalsTimer = -1;
+        processSignals();
+    }
+}
+
+void HistoryServiceDBus::filterDuplicatesAndAdd(QList<QVariantMap> &targetList, const QList<QVariantMap> newItems, const QStringList &propertiesToCompare)
+{
+    Q_FOREACH (const QVariantMap &item, newItems) {
+        Q_FOREACH(const QVariantMap &existing, targetList) {
+            bool found = true;
+            Q_FOREACH(const QString &prop, propertiesToCompare) {
+                if (item[prop] != existing[prop]) {
+                    found = false;
+                    break;
+                }
+            }
+
+            if (!found) {
+                targetList << item;
+            }
+        }
+    }
+}
+
+void HistoryServiceDBus::triggerSignals()
+{
+    if (mSignalsTimer >= 0) {
+        killTimer(mSignalsTimer);
+    }
+
+    mSignalsTimer = startTimer(100);
+}
+
+void HistoryServiceDBus::processSignals()
+{
+    if (!mThreadsAdded.isEmpty()) {
+        Q_EMIT ThreadsAdded(mThreadsAdded);
+        mThreadsAdded.clear();
+    }
+
+    if (!mThreadsModified.isEmpty()) {
+        Q_EMIT ThreadsModified(mThreadsModified);
+        mThreadsModified.clear();
+    }
+
+    if (!mThreadsRemoved.isEmpty()) {
+        Q_EMIT ThreadsRemoved(mThreadsRemoved);
+        mThreadsRemoved.clear();
+    }
+
+    if (!mEventsAdded.isEmpty()) {
+        Q_EMIT EventsAdded(mEventsAdded);
+        mEventsAdded.clear();
+    }
+
+    if (!mEventsModified.isEmpty()) {
+        Q_EMIT EventsModified(mEventsModified);
+        mEventsModified.clear();
+    }
+
+    if (!mEventsRemoved.isEmpty()) {
+        Q_EMIT EventsRemoved(mEventsRemoved);
+        mEventsRemoved.clear();
+    }
+}
+
 
=== modified file 'daemon/historyservicedbus.h'
--- daemon/historyservicedbus.h	2016-06-17 01:49:46 +0000
+++ daemon/historyservicedbus.h	2017-03-23 01:25:43 +0000
@@ -39,6 +39,10 @@
     void notifyThreadsAdded(const QList<QVariantMap> &threads);
     void notifyThreadsModified(const QList<QVariantMap> &threads);
     void notifyThreadsRemoved(const QList<QVariantMap> &threads);
+    void notifyThreadParticipantsChanged(const QVariantMap &thread,
+                                   const QList<QVariantMap> &added,
+                                   const QList<QVariantMap> &removed,
+                                   const QList<QVariantMap> &modified);
 
     void notifyEventsAdded(const QList<QVariantMap> &events);
     void notifyEventsModified(const QList<QVariantMap> &events);
@@ -55,9 +59,11 @@
                                     const QVariantMap &properties,
                                     int matchFlags,
                                     bool create);
+    QList<QVariantMap> ParticipantsForThreads(const QList<QVariantMap> &threadIds);
     bool WriteEvents(const QList <QVariantMap> &events);
     bool RemoveThreads(const QList <QVariantMap> &threads);
     bool RemoveEvents(const QList <QVariantMap> &events);
+    void MarkThreadsAsRead(const QList <QVariantMap> &threads);
 
     // views
     QString QueryThreads(int type, const QVariantMap &sort, const QVariantMap &filter, const QVariantMap &properties);
@@ -70,13 +76,32 @@
     void ThreadsAdded(const QList<QVariantMap> &threads);
     void ThreadsModified(const QList<QVariantMap> &threads);
     void ThreadsRemoved(const QList<QVariantMap> &threads);
+    void ThreadParticipantsChanged(const QVariantMap &thread,
+                             const QList<QVariantMap> &added,
+                             const QList<QVariantMap> &removed,
+                             const QList<QVariantMap> &modified);
 
     void EventsAdded(const QList<QVariantMap> &events);
     void EventsModified(const QList<QVariantMap> &events);
     void EventsRemoved(const QList<QVariantMap> &events);
 
+protected:
+    void timerEvent(QTimerEvent *event) override;
+
+protected Q_SLOTS:
+    void filterDuplicatesAndAdd(QList<QVariantMap> &targetList, const QList<QVariantMap> newItems, const QStringList &propertiesToCompare);
+    void triggerSignals();
+    void processSignals();
+
 private:
     HistoryServiceAdaptor *mAdaptor;
+    QList<QVariantMap> mThreadsAdded;
+    QList<QVariantMap> mThreadsModified;
+    QList<QVariantMap> mThreadsRemoved;
+    QList<QVariantMap> mEventsAdded;
+    QList<QVariantMap> mEventsModified;
+    QList<QVariantMap> mEventsRemoved;
+    int mSignalsTimer;
 };
 
 #endif // HISTORYSERVICEDBUS_H
 
=== modified file 'daemon/main.cpp'
--- daemon/main.cpp	2016-03-30 14:03:29 +0000
+++ daemon/main.cpp	2017-03-23 01:25:43 +0000
@@ -20,16 +20,26 @@
  */
 
 #include "historydaemon.h"
+#include <QLockFile>
+#include <QDir>
 
 bool checkApplicationRunning()
 {
-    bool result = false;
-    QDBusReply<bool> reply = QDBusConnection::sessionBus().interface()->isServiceRegistered(History::DBusService);
-    if (reply.isValid()) {
-        result = reply.value();
+    QString lockPath = qgetenv("HISTORY_LOCK_FILE");
+    if (lockPath.isEmpty()) {
+        lockPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
+        QDir dir(lockPath);
+        if (!dir.exists("history-service") && !dir.mkpath("history-service")) {
+            qCritical() << "Failed to create dir";
+            // in case we fail to create the lock, better not even start the application
+            return true;
+        }
+        dir.cd("history-service");
+        lockPath = dir.absoluteFilePath("history-daemon.lock");
     }
 
-    return result;
+    static QLockFile *lockFile = new QLockFile(lockPath);
+    return !lockFile->tryLock();
 }
 int main(int argc, char **argv)
 {
 
=== modified file 'daemon/textchannelobserver.cpp'
--- daemon/textchannelobserver.cpp	2016-08-26 14:10:25 +0000
+++ daemon/textchannelobserver.cpp	2017-03-23 01:25:43 +0000
@@ -39,10 +39,6 @@
     connect(textChannel.data(),
             SIGNAL(messageSent(Tp::Message,Tp::MessageSendingFlags,QString)),
             SLOT(onMessageSent(Tp::Message,Tp::MessageSendingFlags,QString)));
-    connect(textChannel.data(),
-            SIGNAL(pendingMessageRemoved(const Tp::ReceivedMessage&)),
-            SLOT(onPendingMessageRemoved(const Tp::ReceivedMessage&)));
-
     Q_EMIT channelAvailable(textChannel);
 
     // process the messages that are already pending in the channel
@@ -57,6 +53,7 @@
 {
     Tp::TextChannelPtr textChannel(qobject_cast<Tp::TextChannel*>(sender()));
     mChannels.removeAll(textChannel);
+    Q_EMIT textChannelInvalidated(textChannel);
 }
 
 void TextChannelObserver::onMessageReceived(const Tp::ReceivedMessage &message)
@@ -82,13 +79,3 @@
  
     Q_EMIT messageSent(textChannel, message, sentMessageToken);
 }
-
-void TextChannelObserver::onPendingMessageRemoved(const Tp::ReceivedMessage &message)
-{
-    Tp::TextChannelPtr textChannel(qobject_cast<Tp::TextChannel*>(sender()));
-    if (textChannel.isNull()) {
-        return;
-    }
-
-    Q_EMIT messageRead(textChannel, message);
-}
 
=== modified file 'daemon/textchannelobserver.h'
--- daemon/textchannelobserver.h	2016-08-26 14:10:25 +0000
+++ daemon/textchannelobserver.h	2017-03-23 01:25:43 +0000
@@ -37,8 +37,8 @@
 
 Q_SIGNALS:
     void channelAvailable(const Tp::TextChannelPtr textChannel);
+    void textChannelInvalidated(const Tp::TextChannelPtr textChannel);
     void messageReceived(const Tp::TextChannelPtr textChannel, const Tp::ReceivedMessage &message);
-    void messageRead(const Tp::TextChannelPtr textChannel, const Tp::ReceivedMessage &message);
     void messageSent(const Tp::TextChannelPtr textChannel, const Tp::Message &message, const QString &messageToken);
 
 protected:
@@ -49,7 +49,6 @@
     void onTextChannelInvalidated();
     void onMessageReceived(const Tp::ReceivedMessage &message);
     void onMessageSent(const Tp::Message &message, Tp::MessageSendingFlags flags, const QString &sentMessageToken);
-    void onPendingMessageRemoved(const Tp::ReceivedMessage &message);
 
 private:
     QList<Tp::TextChannelPtr> mChannels;
 
=== added file 'plugins/sqlite/schema/v18.sql'
--- plugins/sqlite/schema/v18.sql	1970-01-01 00:00:00 +0000
+++ plugins/sqlite/schema/v18.sql	2017-03-23 01:25:43 +0000
@@ -0,0 +1,14 @@
+CREATE TRIGGER text_threads_delete_trigger AFTER DELETE ON threads
+FOR EACH ROW WHEN old.type=0
+BEGIN
+    DELETE FROM text_events WHERE
+        accountId=old.accountId AND
+        threadId=old.threadId;
+END;
+CREATE TRIGGER voice_threads_delete_trigger AFTER DELETE ON threads
+FOR EACH ROW WHEN old.type=1
+BEGIN
+    DELETE FROM voice_events WHERE
+        accountId=old.accountId AND
+        threadId=old.threadId;
+END;
 
=== modified file 'plugins/sqlite/sqlitedatabase.cpp'
--- plugins/sqlite/sqlitedatabase.cpp	2016-11-08 19:43:53 +0000
+++ plugins/sqlite/sqlitedatabase.cpp	2017-03-23 01:25:43 +0000
@@ -183,6 +183,12 @@
     return true;
 }
 
+
+void trace(void *something, const char *query)
+{
+    qDebug() << "SQLITE TRACE:" << query;
+}
+
 bool SQLiteDatabase::createOrUpdateDatabase()
 {
     bool create = !QFile(mDatabasePath).exists();
@@ -199,6 +205,10 @@
     // and also create the normalizeId function
     sqlite3_create_function(handle, "normalizeId", 2, SQLITE_ANY, NULL, &normalizeId, NULL, NULL);
 
+#ifdef TRACE_SQLITE
+    sqlite3_trace(handle, &trace, NULL);
+#endif
+
     parseVersionInfo();
 
     QSqlQuery query(mDatabase);
 
=== modified file 'plugins/sqlite/sqlitehistoryeventview.cpp'
--- plugins/sqlite/sqlitehistoryeventview.cpp	2015-01-28 23:08:01 +0000
+++ plugins/sqlite/sqlitehistoryeventview.cpp	2017-03-23 01:25:43 +0000
@@ -42,7 +42,14 @@
     QString condition = mPlugin->filterToString(filter, filterValues);
     QString order;
     if (!sort.sortField().isNull()) {
-        order = QString("ORDER BY %1 %2").arg(sort.sortField(), sort.sortOrder() == Qt::AscendingOrder ? "ASC" : "DESC");
+        // WORKAROUND: Supports multiple fields by split it using ','
+        Q_FOREACH(const QString& field, sort.sortField().split(",")) {
+            order += QString("%1 %2, ")
+                    .arg(field.trimmed())
+                    .arg(sort.sortOrder() == Qt::AscendingOrder ? "ASC" : "DESC");
+        }
+
+        order = QString("ORDER BY %1").arg(order.mid(0, order.lastIndexOf(",")));
         // FIXME: check case sensitiviy
     }
 
 
=== modified file 'plugins/sqlite/sqlitehistoryplugin.cpp'
--- plugins/sqlite/sqlitehistoryplugin.cpp	2016-11-24 01:50:48 +0000
+++ plugins/sqlite/sqlitehistoryplugin.cpp	2017-03-23 01:25:43 +0000
@@ -306,6 +306,54 @@
     return new SQLiteHistoryEventView(this, type, sort, filter);
 }
 
+QVariantMap SQLiteHistoryPlugin::markThreadAsRead(const QVariantMap &thread)
+{
+    QSqlQuery query(SQLiteDatabase::instance()->database());
+
+    if (thread[History::FieldAccountId].toString().isEmpty() ||
+           thread[History::FieldThreadId].toString().isEmpty()) {
+        return QVariantMap();
+    }
+
+    // first check if the thread actually has anything to change
+    query.prepare("SELECT unreadCount from threads WHERE accountId=:accountId AND threadId=:threadId AND type=:type");
+    query.bindValue(":accountId", thread[History::FieldAccountId].toString());
+    query.bindValue(":threadId", thread[History::FieldThreadId].toString());
+    query.bindValue(":type", (uint)History::EventTypeText);
+    if (!query.exec() || !query.next()) {
+        qCritical() << "Failed to verify the unread messages of the thread. Error:" << query.lastError();
+        return QVariantMap();
+    }
+
+
+    int unreadCount = query.value(0).toUInt();
+    if (unreadCount == 0) {
+        // no messages to ack, so no need to update anything
+        return QVariantMap();
+    }
+
+    query.prepare("UPDATE text_events SET newEvent=:newEvent WHERE accountId=:accountId AND threadId=:threadId AND newEvent=1");
+    query.bindValue(":accountId", thread[History::FieldAccountId].toString());
+    query.bindValue(":threadId", thread[History::FieldThreadId].toString());
+    query.bindValue(":newEvent", false);
+
+    if (!query.exec()) {
+        qCritical() << "Failed to mark thread as read: Error:" << query.lastError();
+        return QVariantMap();
+    }
+
+    QVariantMap existingThread = getSingleThread((History::EventType) thread[History::FieldType].toInt(),
+                                                 thread[History::FieldAccountId].toString(),
+                                                 thread[History::FieldThreadId].toString(),
+                                                 QVariantMap());
+    if (!existingThread.isEmpty()) {
+        addThreadsToCache(QList<QVariantMap>() << existingThread);
+        return existingThread;
+    }
+
+    return QVariantMap();
+}
+
 QVariantMap SQLiteHistoryPlugin::threadForProperties(const QString &accountId,
                                                        History::EventType type,
                                                        const QVariantMap &properties,
@@ -315,8 +363,6 @@
         return QVariantMap();
     }
 
-    QSqlQuery query(SQLiteDatabase::instance()->database());
-
     History::ChatType chatType = (History::ChatType)properties[History::FieldChatType].toUInt();
 
     if (chatType == History::ChatTypeRoom) {
@@ -332,6 +378,62 @@
     return threadForParticipants(accountId, type, participants.identifiers(), matchFlags);
 }
 
+QString SQLiteHistoryPlugin::threadIdForProperties(const QString &accountId, History::EventType type, const QVariantMap &properties, History::MatchFlags matchFlags)
+{
+    if (properties.isEmpty()) {
+        return QString::null;
+    }
+
+    // if chat type is room, just get the threadId directly
+    History::ChatType chatType = (History::ChatType)properties[History::FieldChatType].toUInt();
+    if (chatType == History::ChatTypeRoom) {
+          QString threadId = properties[History::FieldThreadId].toString();
+          return threadId;
+    }
+
+    // if chat type is anything else, fallback to returning the threadId from the participants list
+    History::Participants participants = History::Participants::fromVariant(properties[History::FieldParticipantIds]);
+    return threadForParticipants(accountId, type, participants.identifiers(), matchFlags)[History::FieldThreadId].toString();
+}
+
+QList<QVariantMap> SQLiteHistoryPlugin::participantsForThreads(const QList<QVariantMap> &threadIds)
+{
+    QList<QVariantMap> results;
+    Q_FOREACH(const QVariantMap &thread, threadIds) {
+        QString accountId = thread[History::FieldAccountId].toString();
+        QString threadId = thread[History::FieldThreadId].toString();
+        History::EventType type = (History::EventType)thread[History::FieldType].toUInt();
+        QVariantMap result = thread;
+
+        QSqlQuery query;
+        query.prepare("SELECT normalizedId, alias, state, roles FROM thread_participants "
+                      "WHERE accountId=:accountId AND threadId=:threadId AND type=:type");
+        query.bindValue(":accountId", accountId);
+        query.bindValue(":threadId", threadId);
+        query.bindValue(":type", type);
+        QVariantList participants;
+        if (!query.exec()) {
+            qWarning() << "Failed to retrieve participants. Error:" << query.lastError().text() << query.lastQuery();
+            results << result;
+            continue;
+        }
+
+        while (query.next()) {
+            QVariantMap participant;
+            QString identifier = query.value(0).toString();
+            participant[History::FieldIdentifier] = identifier;
+            participant[History::FieldAlias] = query.value(1);
+            participant[History::FieldParticipantState] = query.value(2);
+            participant[History::FieldParticipantRoles] = query.value(3);
+            participants << History::ContactMatcher::instance()->contactInfo(accountId, identifier, true, participant);
+        }
+
+        result[History::FieldParticipants] = participants;
+        results << result;
+    }
+    return results;
+}
+
 QVariantMap SQLiteHistoryPlugin::threadForParticipants(const QString &accountId,
                                                        History::EventType type,
                                                        const QStringList &participants,
@@ -1093,22 +1195,6 @@
            << "threads.unreadCount"
            << "threads.lastEventTimestamp";
 
-    // get the participants in the query already
-    fields << "(SELECT group_concat(thread_participants.participantId,  \"|,|\") "
-              "FROM thread_participants WHERE thread_participants.accountId=threads.accountId "
-              "AND thread_participants.threadId=threads.threadId "
-              "AND thread_participants.type=threads.type GROUP BY accountId,threadId,type) as participants";
-
-    fields << "(SELECT group_concat(thread_participants.state,  \"|,|\") "
-              "FROM thread_participants WHERE thread_participants.accountId=threads.accountId "
-              "AND thread_participants.threadId=threads.threadId "
-              "AND thread_participants.type=threads.type GROUP BY accountId,threadId,type) as state";
-
-    fields << "(SELECT group_concat(thread_participants.roles,  \"|,|\") "
-              "FROM thread_participants WHERE thread_participants.accountId=threads.accountId "
-              "AND thread_participants.threadId=threads.threadId "
-              "AND thread_participants.type=threads.type GROUP BY accountId,threadId,type) as roles";
-
     QStringList extraFields;
     QString table;
 
@@ -1136,6 +1222,7 @@
 QList<QVariantMap> SQLiteHistoryPlugin::parseThreadResults(History::EventType type, QSqlQuery &query, const QVariantMap &properties)
 {
     QList<QVariantMap> threads;
+    QList<QVariantMap> threadsWithoutParticipants;
     QSqlQuery attachmentsQuery(SQLiteDatabase::instance()->database());
     QList<QVariantMap> attachments;
     bool grouped = false;
@@ -1170,31 +1257,11 @@
         thread[History::FieldEventId] = query.value(2);
         thread[History::FieldCount] = query.value(3);
         thread[History::FieldUnreadCount] = query.value(4);
-        QStringList participants = query.value(6).toString().split("|,|", QString::SkipEmptyParts);
-        QList<int> participantStatus;
-        QStringList participantStatusString = query.value(7).toString().split("|,|", QString::SkipEmptyParts);
-        Q_FOREACH(const QString &statusString, participantStatusString) {
-            participantStatus << statusString.toUInt();
-        }
-        QStringList participantRolesString = query.value(8).toString().split("|,|", QString::SkipEmptyParts);
-        QList<int> participantRoles;
-        Q_FOREACH(const QString &rolesString, participantRolesString) {
-            participantRoles << rolesString.toUInt();
-        }
-        QVariantList contactList;
-        QVariantList contactInfo = History::ContactMatcher::instance()->contactInfo(accountId, participants, true);
-        for (int i = 0; i < contactInfo.count(); ++i) {
-            QVariantMap map = contactInfo[i].toMap();
-            map["state"] = participantStatus[i];
-            map["roles"] = participantRoles[i];
-            contactList << map;
-        }
-        thread[History::FieldParticipants] = contactList;
 
         // the generic event fields
-        thread[History::FieldSenderId] = query.value(9);
+        thread[History::FieldSenderId] = query.value(6);
         thread[History::FieldTimestamp] = toLocalTimeString(query.value(5).toDateTime());
-        thread[History::FieldNewEvent] = query.value(10).toBool();
+        thread[History::FieldNewEvent] = query.value(7).toBool();
 
         // the next step is to get the last event
         switch (type) {
@@ -1225,13 +1292,13 @@
                 thread[History::FieldAttachments] = QVariant::fromValue(attachments);
                 attachments.clear();
             }
-            thread[History::FieldMessage] = query.value(11);
-            thread[History::FieldMessageType] = query.value(12);
-            thread[History::FieldMessageStatus] = query.value(13);
-            thread[History::FieldReadTimestamp] = toLocalTimeString(query.value(14).toDateTime());
-            thread[History::FieldChatType] = query.value(15).toUInt();
+            thread[History::FieldMessage] = query.value(8);
+            thread[History::FieldMessageType] = query.value(9);
+            thread[History::FieldMessageStatus] = query.value(10);
+            thread[History::FieldReadTimestamp] = toLocalTimeString(query.value(11).toDateTime());
+            thread[History::FieldChatType] = query.value(12).toUInt();
 
-            if (thread[History::FieldChatType].toInt() == 2) {
+            if (thread[History::FieldChatType].toInt() == History::ChatTypeRoom) {
                 QVariantMap chatRoomInfo;
                 QSqlQuery query1(SQLiteDatabase::instance()->database());
 
@@ -1291,15 +1358,28 @@
 
                 thread[History::FieldChatRoomInfo] = chatRoomInfo;
             }
+            if (!History::Utils::shouldIncludeParticipants(History::Thread::fromProperties(thread))) {
+                thread.remove(History::FieldParticipants);
+                threadsWithoutParticipants << thread;
+            } else {
+                threads << thread;
+            }
             break;
         case History::EventTypeVoice:
-            thread[History::FieldMissed] = query.value(12);
-            thread[History::FieldDuration] = query.value(11);
-            thread[History::FieldRemoteParticipant] = History::ContactMatcher::instance()->contactInfo(accountId, query.value(13).toString(), true);
+            thread[History::FieldMissed] = query.value(9);
+            thread[History::FieldDuration] = query.value(8);
+            thread[History::FieldRemoteParticipant] = History::ContactMatcher::instance()->contactInfo(accountId, query.value(10).toString(), true);
+            threads << thread;
             break;
         }
-        threads << thread;
     }
+
+    // get the participants
+    threads = participantsForThreads(threads);
+
+    // and append the threads with no participants
+    threads << threadsWithoutParticipants;
+
     return threads;
 }
 
@@ -1317,7 +1397,8 @@
     QString queryText;
     switch (type) {
     case History::EventTypeText:
-        participantsField = participantsField.arg("text_events", QString::number(type));
+        // for text events we don't need the participants at all
+        participantsField = "\"\" as participants";
         queryText = QString("SELECT accountId, threadId, eventId, senderId, timestamp, newEvent, %1, "
                             "message, messageType, messageStatus, readTimestamp, subject, informationType FROM text_events %2 %3").arg(participantsField, modifiedCondition, order);
         break;
@@ -1353,8 +1434,10 @@
         event[History::FieldSenderId] = query.value(3);
         event[History::FieldTimestamp] = toLocalTimeString(query.value(4).toDateTime());
         event[History::FieldNewEvent] = query.value(5).toBool();
-        QStringList participants = query.value(6).toString().split("|,|");
-        event[History::FieldParticipants] = History::ContactMatcher::instance()->contactInfo(accountId, participants, true);
+        if (type != History::EventTypeText) {
+            QStringList participants = query.value(6).toString().split("|,|");
+            event[History::FieldParticipants] = History::ContactMatcher::instance()->contactInfo(accountId, participants, true);
+        }
 
         switch (type) {
         case History::EventTypeText:
 
=== modified file 'plugins/sqlite/sqlitehistoryplugin.h'
--- plugins/sqlite/sqlitehistoryplugin.h	2016-09-21 17:44:39 +0000
+++ plugins/sqlite/sqlitehistoryplugin.h	2017-03-23 01:25:43 +0000
@@ -59,7 +59,11 @@
                                       History::EventType type,
                                       const QVariantMap &properties,
                                       History::MatchFlags matchFlags = History::MatchCaseSensitive);
-
+    QString threadIdForProperties(const QString &accountId,
+                                  History::EventType type,
+                                  const QVariantMap &properties,
+                                  History::MatchFlags matchFlags = History::MatchCaseSensitive) override;
+    QList<QVariantMap> participantsForThreads(const QList<QVariantMap> &threadIds) override;
     QList<QVariantMap> eventsForThread(const QVariantMap &thread);
 
     QVariantMap getSingleThread(History::EventType type, const QString &accountId, const QString &threadId, const QVariantMap &properties = QVariantMap());
@@ -73,6 +77,7 @@
     bool updateRoomParticipantsRoles(const QString &accountId, const QString &threadId, History::EventType type, const QVariantMap &participantsRoles);
     bool updateRoomInfo(const QString &accountId, const QString &threadId, History::EventType type, const QVariantMap &properties, const QStringList &invalidated = QStringList());
     bool removeThread(const QVariantMap &thread);
+    QVariantMap markThreadAsRead(const QVariantMap &thread);
 
     History::EventWriteResult writeTextEvent(const QVariantMap &event);
     bool removeTextEvent(const QVariantMap &event);
 
=== modified file 'plugins/sqlite/sqlitehistorythreadview.cpp'
--- plugins/sqlite/sqlitehistorythreadview.cpp	2016-11-24 01:56:01 +0000
+++ plugins/sqlite/sqlitehistorythreadview.cpp	2017-03-23 01:25:43 +0000
@@ -43,7 +43,14 @@
     QString condition = mPlugin->filterToString(filter, filterValues);
     QString order;
     if (!sort.sortField().isNull()) {
-        order = QString("ORDER BY %1 %2").arg(sort.sortField(), sort.sortOrder() == Qt::AscendingOrder ? "ASC" : "DESC");
+        // WORKAROUND: Supports multiple fields by split it using ','
+        Q_FOREACH(const QString& field, sort.sortField().split(",")) {
+            order += QString("%1 %2, ")
+                    .arg(field.trimmed())
+                    .arg(sort.sortOrder() == Qt::AscendingOrder ? "ASC" : "DESC");
+        }
+
+        order = QString("ORDER BY %1").arg(order.mid(0, order.lastIndexOf(",")));
         // FIXME: check case sensitiviy
     }
 
 
=== modified file 'src/contactmatcher.cpp'
--- src/contactmatcher.cpp	2016-06-17 01:49:46 +0000
+++ src/contactmatcher.cpp	2017-03-23 01:25:43 +0000
@@ -99,21 +99,22 @@
 {
     InternalContactMap &internalMap = mContactMap[accountId];
 
+
+    QString normalizedId = normalizeId(identifier);
+
+    QVariantMap map;
     // first do a simple string match on the map
-    if (internalMap.contains(identifier)) {
-        return internalMap[identifier];
-    }
-    
-    QVariantMap map;
-
-    // and if there was no match, asynchronously request the info, and return an empty map for now
-    if (History::TelepathyHelper::instance()->ready()) {
-        map = requestContactInfo(accountId, identifier, synchronous);
+    if (internalMap.contains(normalizedId)) {
+        map = internalMap[normalizedId];
+    } else if (History::TelepathyHelper::instance()->ready()) {
+        // and if there was no match, asynchronously request the info, and return an empty map for now
+        map = requestContactInfo(accountId, normalizedId, synchronous);
     } else if (!synchronous) {
-        RequestInfo info{accountId, identifier};
+        RequestInfo info{accountId, normalizedId};
         mPendingRequests.append(info);
     }
-    map[History::FieldIdentifier] = identifier;
+
+    map[History::FieldIdentifier] = normalizedId;
     map[History::FieldAccountId] = accountId;
 
     QMapIterator<QString, QVariant> i(properties);
@@ -124,7 +125,7 @@
         }
     }
 
-    mContactMap[accountId][identifier] = map;
+    mContactMap[accountId][normalizedId] = map;
     return map;
 }
 
@@ -309,10 +310,17 @@
  */
 QVariantMap ContactMatcher::requestContactInfo(const QString &accountId, const QString &identifier, bool synchronous)
 {
+    QString normalizedId = normalizeId(identifier);
     QStringList addressableVCardFields = addressableFields(accountId);
+
+    QVariantMap contactInfo;
+    contactInfo[History::FieldIdentifier] = identifier;
+    contactInfo[History::FieldAccountId] = accountId;
+
     if (addressableVCardFields.isEmpty()) {
+        mContactMap[accountId][identifier] = contactInfo;
         // FIXME: add support for generic accounts
-        return QVariantMap();
+        return contactInfo;
     }
 
     bool phoneCompare = addressableVCardFields.contains("tel");
@@ -328,7 +336,7 @@
     QContactUnionFilter topLevelFilter;
     Q_FOREACH(const QString &field, addressableVCardFields) {
         if (field == "tel") {
-            topLevelFilter.append(QContactPhoneNumber::match(identifier));
+            topLevelFilter.append(QContactPhoneNumber::match(normalizedId));
         } else {
             // FIXME: handle more fields
             // rely on a generic field filter
@@ -340,7 +348,7 @@
             QContactDetailFilter valueFilter = QContactDetailFilter();
             valueFilter.setDetailType(QContactExtendedDetail::Type, QContactExtendedDetail::FieldData);
             valueFilter.setMatchFlags(QContactFilter::MatchExactly);
-            valueFilter.setValue(identifier);
+            valueFilter.setValue(normalizedId);
 
             QContactIntersectionFilter intersectionFilter;
             intersectionFilter.append(nameFilter);
@@ -353,10 +361,11 @@
     if (synchronous) {
         QList<QContact> contacts = mManager->contacts(topLevelFilter, QList<QContactSortOrder>(), hint);
         if (contacts.isEmpty()) {
-            return QVariantMap();
+            mContactMap[accountId][identifier] = contactInfo;
+            return contactInfo;
         }
         // for synchronous requests, return the results right away.
-        return matchAndUpdate(accountId, identifier, contacts.first());
+        return matchAndUpdate(accountId, normalizedId, contacts.first());
     } else {
         // check if there is a request already going on for the given contact
         Q_FOREACH(const RequestInfo &info, mRequests.values()) {
@@ -365,7 +374,7 @@
                 continue;
             }
 
-            if (info.identifier == identifier) {
+            if (info.identifier == normalizedId) {
                 // if so, just wait for it to finish
                 return QVariantMap();
             }
@@ -381,7 +390,7 @@
 
         RequestInfo info;
         info.accountId = accountId;
-        info.identifier = identifier;
+        info.identifier = normalizedId;
         mRequests[request] = info;
         request->start();
     }
@@ -414,7 +423,6 @@
     QStringList fields = addressableFields(accountId);
     bool match = false;
 
-    int fieldsCount = fields.count();
     Q_FOREACH(const QString &field, fields) {
         if (field == "tel") {
             QList<QContactDetail> details = contact.details(QContactDetail::TypePhoneNumber);
@@ -463,12 +471,26 @@
         return mAddressableFields[accountId];
     }
 
+    // FIXME: hardcoding account IDs here is not a good idea, we have to fix addressable fields on
+    // the protocols themselves
+    if (accountId.startsWith("irc/irc")) {
+        QStringList empty;
+        mAddressableFields[accountId] = empty;
+        return empty;
+    }
+
     Tp::AccountPtr account = History::TelepathyHelper::instance()->accountForId(accountId);
     QStringList fields;
     if (!account.isNull()) {
         fields = account->protocolInfo().addressableVCardFields();
-        mAddressableFields[accountId] = fields;
-    }
+    }
+
+    // fallback to phone number matching in case everything else fails
+    if (fields.isEmpty()) {
+        fields << "tel";
+    }
+
+    mAddressableFields[accountId] = fields;
 
     return fields;
 }
@@ -478,4 +500,17 @@
     return (map.contains(History::FieldContactId) && !map[History::FieldContactId].toString().isEmpty());
 }
 
+QString ContactMatcher::normalizeId(const QString &id)
+{
+    QString normalizedId = id;
+
+    // FIXME: this is a hack so that SIP URIs get converted into phone numbers for contact matching
+    if (normalizedId.startsWith("sip:")) {
+        normalizedId.remove("sip:").remove(QRegularExpression("@.*$"));
+    }
+
+    return normalizedId;
+}
+
+
 }
 
=== modified file 'src/contactmatcher_p.h'
--- src/contactmatcher_p.h	2016-06-17 01:49:46 +0000
+++ src/contactmatcher_p.h	2017-03-23 01:25:43 +0000
@@ -51,6 +51,8 @@
     // this will only watch for contact changes affecting the identifier, but won't fetch contact info
     void watchIdentifier(const QString &accountId, const QString &identifier, const QVariantMap &currentInfo = QVariantMap());
 
+    static QString normalizeId(const QString &id);
+
 Q_SIGNALS:
     void contactInfoChanged(const QString &acountId, const QString &identifier, const QVariantMap &contactInfo);
 
 
=== modified file 'src/eventview.cpp'
--- src/eventview.cpp	2015-10-01 19:44:45 +0000
+++ src/eventview.cpp	2017-03-23 01:25:43 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -53,7 +53,7 @@
         }
 
         if (filterNull || filter.match(event.properties())) {
-            filtered << events;
+            filtered << event;
         }
     }
 
@@ -128,6 +128,10 @@
     connect(Manager::instance(),
             SIGNAL(eventsRemoved(History::Events)),
             SLOT(_d_eventsRemoved(History::Events)));
+    // we don't filter thread signals
+    connect(Manager::instance(),
+            SIGNAL(threadsRemoved(History::Threads)),
+            SIGNAL(threadsRemoved(History::Threads)));
 }
 
 EventView::~EventView()
 
=== modified file 'src/eventview.h'
--- src/eventview.h	2013-09-17 23:05:35 +0000
+++ src/eventview.h	2017-03-23 01:25:43 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -24,6 +24,7 @@
 
 #include "types.h"
 #include "event.h"
+#include "thread.h"
 #include "filter.h"
 #include "sort.h"
 #include <QObject>
@@ -50,6 +51,7 @@
     void eventsAdded(const History::Events &events);
     void eventsModified(const History::Events &events);
     void eventsRemoved(const History::Events &events);
+    void threadsRemoved(const History::Threads &threads);
     void invalidated();
 
 private:
 
=== modified file 'src/manager.cpp'
--- src/manager.cpp	2016-06-17 01:49:46 +0000
+++ src/manager.cpp	2017-03-23 01:25:43 +0000
@@ -65,6 +65,9 @@
             SIGNAL(threadsRemoved(History::Threads)),
             SIGNAL(threadsRemoved(History::Threads)));
     connect(d->dbus.data(),
+            SIGNAL(threadParticipantsChanged(History::Thread, History::Participants, History::Participants, History::Participants)),
+            SIGNAL(threadParticipantsChanged(History::Thread, History::Participants, History::Participants, History::Participants)));
+    connect(d->dbus.data(),
             SIGNAL(eventsAdded(History::Events)),
             SIGNAL(eventsAdded(History::Events)));
     connect(d->dbus.data(),
@@ -104,6 +107,13 @@
     return self;
 }
 
+void Manager::markThreadsAsRead(const History::Threads &threads)
+{
+    Q_D(Manager);
+
+    d->dbus->markThreadsAsRead(threads);
+}
+
 ThreadViewPtr Manager::queryThreads(EventType type,
                                     const Sort &sort,
                                     const Filter &filter,
@@ -154,6 +164,20 @@
     return d->dbus->threadForProperties(accountId, type, properties, matchFlags, create);
 }
 
+/**
+ * @brief Request the list of participants of the given threads to the service
+ * @param threads The threads to be filled
+ *
+ * This is an asychronous request. When finished, the signal @ref threadParticipantsChanged
+ * will be emitted for the given threads.
+ */
+void Manager::requestThreadParticipants(const Threads &threads)
+{
+    Q_D(Manager);
+
+    d->dbus->requestThreadParticipants(threads);
+}
+
 Thread Manager::getSingleThread(EventType type, const QString &accountId, const QString &threadId, const QVariantMap &properties)
 {
     Q_D(Manager);
 
=== modified file 'src/manager.h'
--- src/manager.h	2016-06-17 01:49:46 +0000
+++ src/manager.h	2017-03-23 01:25:43 +0000
@@ -66,19 +66,22 @@
                                const QVariantMap &properties,
                                History::MatchFlags matchFlags = History::MatchCaseSensitive,
                                bool create = false);
-
+    void requestThreadParticipants(const History::Threads &threads);
     Thread getSingleThread(EventType type, const QString &accountId, const QString &threadId, const QVariantMap &properties = QVariantMap());
 
     bool writeEvents(const History::Events &events);
     bool removeThreads(const Threads &threads);
     bool removeEvents(const Events &events);
 
+    void markThreadsAsRead(const History::Threads &thread);
+
     bool isServiceRunning() const;
 
 Q_SIGNALS:
     void threadsAdded(const History::Threads &threads);
     void threadsModified(const History::Threads &threads);
     void threadsRemoved(const History::Threads &threads);
+    void threadParticipantsChanged(const History::Thread &thread, const History::Participants &added, const History::Participants &removed, const History::Participants &modified);
 
     void eventsAdded(const History::Events &events);
     void eventsModified(const History::Events &events);
 
=== modified file 'src/managerdbus.cpp'
--- src/managerdbus.cpp	2016-06-17 01:49:46 +0000
+++ src/managerdbus.cpp	2017-03-23 01:25:43 +0000
@@ -28,6 +28,8 @@
 #include <QDBusReply>
 #include <QDBusMetaType>
 
+#include <QDebug>
+
 Q_DECLARE_METATYPE(QList< QVariantMap >)
 
 namespace History
@@ -50,6 +52,12 @@
     connection.connect(DBusService, DBusObjectPath, DBusInterface, "ThreadsRemoved",
                        this, SLOT(onThreadsRemoved(QList<QVariantMap>)));
 
+    connection.connect(DBusService, DBusObjectPath, DBusInterface, "ThreadParticipantsChanged",
+                       this, SLOT(onThreadParticipantsChanged(QVariantMap,
+                                                        QList<QVariantMap>,
+                                                        QList<QVariantMap>,
+                                                        QList<QVariantMap>)));
+
     connection.connect(DBusService, DBusObjectPath, DBusInterface, "EventsAdded",
                        this, SLOT(onEventsAdded(QList<QVariantMap>)));
     connection.connect(DBusService, DBusObjectPath, DBusInterface, "EventsModified",
@@ -70,6 +78,16 @@
     return threadForProperties(accountId, type, properties, matchFlags, create);
 }
 
+void ManagerDBus::markThreadsAsRead(const History::Threads &threads)
+{
+    QList<QVariantMap> threadMap = threadsToProperties(threads);
+    if (threadMap.isEmpty()) {
+        return;
+    }
+
+    mInterface.asyncCall("MarkThreadsAsRead", QVariant::fromValue(threadMap));
+}
+
 Thread ManagerDBus::threadForProperties(const QString &accountId,
                                         EventType type,
                                         const QVariantMap &properties,
@@ -87,6 +105,29 @@
     return thread;
 }
 
+void ManagerDBus::requestThreadParticipants(const Threads &threads)
+{
+    QList<QVariantMap> ids;
+    Q_FOREACH(const Thread &thread, threads) {
+        QVariantMap id;
+        id[History::FieldAccountId] = thread.accountId();
+        id[History::FieldThreadId] = thread.threadId();
+        id[History::FieldType] = thread.type();
+        ids << id;
+    }
+
+    QDBusPendingCall call = mInterface.asyncCall("ParticipantsForThreads", QVariant::fromValue(ids));
+    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(call, this);
+    connect(watcher, &QDBusPendingCallWatcher::finished, [this, threads](QDBusPendingCallWatcher *watcher) {
+        QDBusPendingReply<QList<QVariantMap> > reply = *watcher;
+        Q_FOREACH(const QVariantMap &map, reply.value()) {
+            History::Thread thread = History::Thread::fromProperties(map);
+            Q_EMIT threadParticipantsChanged(thread, History::Participants(), History::Participants(), thread.participants());
+            watcher->deleteLater();
+        }
+    });
+}
+
 bool ManagerDBus::writeEvents(const Events &events)
 {
     QList<QVariantMap> eventMap = eventsToProperties(events);
@@ -108,11 +149,8 @@
         return false;
     }
 
-    QDBusReply<bool> reply = mInterface.call("RemoveThreads", QVariant::fromValue(threadMap));
-    if (!reply.isValid()) {
-        return false;
-    }
-    return reply.value();
+    mInterface.asyncCall("RemoveThreads", QVariant::fromValue(threadMap));
+    return true;
 }
 
 bool ManagerDBus::removeEvents(const Events &events)
@@ -122,11 +160,8 @@
         return false;
     }
 
-    QDBusReply<bool> reply = mInterface.call("RemoveEvents", QVariant::fromValue(eventMap));
-    if (!reply.isValid()) {
-        return false;
-    }
-    return reply.value();
+    mInterface.asyncCall("RemoveEvents", QVariant::fromValue(eventMap));
+    return true;
 }
 
 Thread ManagerDBus::getSingleThread(EventType type, const QString &accountId, const QString &threadId, const QVariantMap &properties)
@@ -168,6 +203,17 @@
     Q_EMIT threadsRemoved(threadsFromProperties(threads));
 }
 
+void ManagerDBus::onThreadParticipantsChanged(const QVariantMap &thread,
+                                        const QList<QVariantMap> &added,
+                                        const QList<QVariantMap> &removed,
+                                        const QList<QVariantMap> &modified)
+{
+    Q_EMIT threadParticipantsChanged(threadsFromProperties(QList<QVariantMap>() << thread).first(),
+                               Participants::fromVariantMapList(added),
+                               Participants::fromVariantMapList(removed),
+                               Participants::fromVariantMapList(modified));
+}
+
 void ManagerDBus::onEventsAdded(const QList<QVariantMap> &events)
 {
     Q_EMIT eventsAdded(eventsFromProperties(events));
 
=== modified file 'src/managerdbus_p.h'
--- src/managerdbus_p.h	2016-06-17 01:49:46 +0000
+++ src/managerdbus_p.h	2017-03-23 01:25:43 +0000
@@ -50,18 +50,23 @@
                                const QVariantMap &properties,
                                History::MatchFlags matchFlags,
                                bool create);
-
+    void requestThreadParticipants(const History::Threads &threads);
     bool writeEvents(const History::Events &events);
     bool removeThreads(const Threads &threads);
     bool removeEvents(const Events &events);
     Thread getSingleThread(EventType type, const QString &accountId, const QString &threadId, const QVariantMap &properties = QVariantMap());
     Event getSingleEvent(EventType type, const QString &accountId, const QString &threadId, const QString &eventId);
+    void markThreadsAsRead(const History::Threads &threads);
 
 Q_SIGNALS:
     // signals that will be triggered after processing bus signals
     void threadsAdded(const History::Threads &threads);
     void threadsModified(const History::Threads &threads);
     void threadsRemoved(const History::Threads &threads);
+    void threadParticipantsChanged(const History::Thread &thread,
+                             const History::Participants &added,
+                             const History::Participants &removed,
+                             const History::Participants &modified);
 
     void eventsAdded(const History::Events &events);
     void eventsModified(const History::Events &events);
@@ -71,7 +76,10 @@
     void onThreadsAdded(const QList<QVariantMap> &threads);
     void onThreadsModified(const QList<QVariantMap> &threads);
     void onThreadsRemoved(const QList<QVariantMap> &threads);
-
+    void onThreadParticipantsChanged(const QVariantMap &thread,
+                               const QList<QVariantMap> &added,
+                               const QList<QVariantMap> &removed,
+                               const QList<QVariantMap> &modified);
     void onEventsAdded(const QList<QVariantMap> &events);
     void onEventsModified(const QList<QVariantMap> &events);
     void onEventsRemoved(const QList<QVariantMap> &events);
 
=== modified file 'src/participant.cpp'
--- src/participant.cpp	2016-11-24 01:04:37 +0000
+++ src/participant.cpp	2017-03-23 01:25:43 +0000
@@ -233,6 +233,15 @@
     return participants;
 }
 
+Participants Participants::fromVariantMapList(const QList<QVariantMap> &list)
+{
+    Participants participants;
+    Q_FOREACH(const QVariantMap& entry, list) {
+        participants << Participant::fromProperties(entry);
+    }
+    return participants;
+}
+
 QVariantList Participants::toVariantList() const
 {
     QVariantList list;
 
=== modified file 'src/participant.h'
--- src/participant.h	2016-11-24 01:04:37 +0000
+++ src/participant.h	2017-03-23 01:25:43 +0000
@@ -79,6 +79,7 @@
     QStringList identifiers() const;
     static Participants fromVariant(const QVariant &variant);
     static Participants fromVariantList(const QVariantList &list);
+    static Participants fromVariantMapList(const QList<QVariantMap> &list);
     static Participants fromStringList(const QStringList &list);
     QVariantList toVariantList() const;
     History::Participants filterByState(uint state) const;
 
=== modified file 'src/plugin.h'
--- src/plugin.h	2016-09-21 17:44:39 +0000
+++ src/plugin.h	2017-03-23 01:25:43 +0000
@@ -65,6 +65,11 @@
                                               EventType type,
                                               const QVariantMap &properties,
                                               History::MatchFlags matchFlags = History::MatchCaseSensitive) = 0;
+    virtual QString threadIdForProperties(const QString &accountId,
+                                          EventType type,
+                                          const QVariantMap &properties,
+                                          History::MatchFlags matchFlags = History::MatchCaseSensitive) = 0;
+    virtual QList<QVariantMap> participantsForThreads(const QList<QVariantMap> &threadIds) = 0;
 
     virtual QList<QVariantMap> eventsForThread(const QVariantMap &thread) = 0;
 
@@ -75,6 +80,7 @@
     virtual bool updateRoomParticipantsRoles(const QString &accountId, const QString &threadId, History::EventType type, const QVariantMap &participantsRoles) { return false; };
     virtual bool updateRoomInfo(const QString &accountId, const QString &threadId, EventType type, const QVariantMap &properties, const QStringList &invalidated = QStringList()) { return false; };
     virtual bool removeThread(const QVariantMap &thread) { return false; }
+    virtual QVariantMap markThreadAsRead(const QVariantMap &thread) { return QVariantMap(); }
 
     virtual EventWriteResult writeTextEvent(const QVariantMap &event) { return EventWriteError; }
     virtual bool removeTextEvent(const QVariantMap &event) { return false; }
 
=== modified file 'src/thread.cpp'
--- src/thread.cpp	2016-07-12 02:08:11 +0000
+++ src/thread.cpp	2017-03-23 01:25:43 +0000
@@ -192,6 +192,22 @@
     return selfData < otherData;
 }
 
+void Thread::removeParticipants(const Participants &participants)
+{
+    Q_D(Thread);
+    Q_FOREACH(const Participant &participant, participants) {
+        d->participants.removeAll(participant);
+    }
+}
+
+void Thread::addParticipants(const Participants &participants)
+{
+    Q_D(Thread);
+    Q_FOREACH(const Participant &participant, participants) {
+        d->participants.append(participant);
+    }
+}
+
 QVariantMap Thread::properties() const
 {
     Q_D(const Thread);
 
=== modified file 'src/thread.h'
--- src/thread.h	2016-07-12 01:59:06 +0000
+++ src/thread.h	2017-03-23 01:25:43 +0000
@@ -73,6 +73,8 @@
     ChatType chatType() const;
     Threads groupedThreads() const;
     QVariantMap chatRoomInfo() const;
+    void addParticipants(const History::Participants &participants);
+    void removeParticipants(const History::Participants &participants);
 
     bool isNull() const;
     bool operator==(const Thread &other) const;
 
=== modified file 'src/threadview.cpp'
--- src/threadview.cpp	2015-10-01 19:44:45 +0000
+++ src/threadview.cpp	2017-03-23 01:25:43 +0000
@@ -89,6 +89,18 @@
     }
 }
 
+void ThreadViewPrivate::_d_threadParticipantsChanged(const History::Thread &thread,
+                                   const History::Participants &added,
+                                   const History::Participants &removed,
+                                   const History::Participants &modified)
+{
+    Q_Q(ThreadView);
+    Threads filtered = filteredThreads(History::Threads() << thread);
+    if (!filtered.isEmpty()) {
+        Q_EMIT q->threadParticipantsChanged(filtered.first(), added, removed, modified);
+    }
+}
+
 // ------------- ThreadView -------------------------------------------------------
 
 ThreadView::ThreadView(History::EventType type,
@@ -132,6 +144,9 @@
     connect(Manager::instance(),
             SIGNAL(threadsRemoved(History::Threads)),
             SLOT(_d_threadsRemoved(History::Threads)));
+    connect(Manager::instance(),
+            SIGNAL(threadParticipantsChanged(History::Thread, History::Participants, History::Participants, History::Participants)),
+            SLOT(_d_threadParticipantsChanged(History::Thread, History::Participants, History::Participants, History::Participants)));
 }
 
 ThreadView::~ThreadView()
 
=== modified file 'src/threadview.h'
--- src/threadview.h	2015-09-21 20:05:06 +0000
+++ src/threadview.h	2017-03-23 01:25:43 +0000
@@ -52,12 +52,20 @@
     void threadsAdded(const History::Threads &threads);
     void threadsModified(const History::Threads &threads);
     void threadsRemoved(const History::Threads &threads);
+    void threadParticipantsChanged(const History::Thread &thread,
+                                   const History::Participants &added,
+                                   const History::Participants &removed,
+                                   const History::Participants &modified);
     void invalidated();
 
 private:
     Q_PRIVATE_SLOT(d_func(), void _d_threadsAdded(const History::Threads &threads))
     Q_PRIVATE_SLOT(d_func(), void _d_threadsModified(const History::Threads &threads))
     Q_PRIVATE_SLOT(d_func(), void _d_threadsRemoved(const History::Threads &threads))
+    Q_PRIVATE_SLOT(d_func(), void _d_threadParticipantsChanged(const History::Thread &thread,
+                                   const History::Participants &added,
+                                   const History::Participants &removed,
+                                   const History::Participants &modified))
     QScopedPointer<ThreadViewPrivate> d_ptr;
 
 };
 
=== modified file 'src/threadview_p.h'
--- src/threadview_p.h	2013-09-17 21:33:34 +0000
+++ src/threadview_p.h	2017-03-23 01:25:43 +0000
@@ -50,6 +50,10 @@
         void _d_threadsAdded(const History::Threads &threads);
         void _d_threadsModified(const History::Threads &threads);
         void _d_threadsRemoved(const History::Threads &threads);
+        void _d_threadParticipantsChanged(const History::Thread &thread,
+                                   const History::Participants &added,
+                                   const History::Participants &removed,
+                                   const History::Participants &modified);
 
         ThreadView *q_ptr;
     };
 
=== modified file 'src/utils.cpp'
--- src/utils.cpp	2016-11-08 16:02:18 +0000
+++ src/utils.cpp	2017-03-23 01:25:43 +0000
@@ -50,6 +50,7 @@
     if (protocolFlags.isEmpty()) {
         protocolFlags["ofono"] = MatchPhoneNumber;
         protocolFlags["multimedia"] = MatchPhoneNumber;
+        protocolFlags["sip"] = MatchPhoneNumber;
     }
 
     QString protocol = protocolFromAccountId(accountId);
@@ -57,7 +58,7 @@
         return protocolFlags[protocol];
     }
 
-    // default to this value
+    // default to phone number matching for now
     return History::MatchCaseSensitive;
 }
 
@@ -175,4 +176,18 @@
     return QVariant();
 }
 
+bool Utils::shouldIncludeParticipants(const Thread &thread)
+{
+    return shouldIncludeParticipants(thread.accountId(), thread.chatType());
+}
+
+bool Utils::shouldIncludeParticipants(const QString &accountId, const ChatType &type)
+{
+    // FIXME: this is obviously incorrect. we have to query the protocol files as a final solution
+    if (protocolFromAccountId(accountId) == "irc") {
+        return type != ChatTypeRoom;
+    }
+    return true;
+}
+
 }
 
=== modified file 'src/utils_p.h'
--- src/utils_p.h	2016-11-08 16:02:18 +0000
+++ src/utils_p.h	2017-03-23 01:25:43 +0000
@@ -36,6 +36,8 @@
     static bool compareParticipants(const QStringList &participants1, const QStringList &participants2, MatchFlags flags);
     static bool compareNormalizedParticipants(const QStringList &participants1, const QStringList &participants2, MatchFlags flags);
     static bool shouldGroupThread(const Thread &thread);
+    static bool shouldIncludeParticipants(const Thread &thread);
+    static bool shouldIncludeParticipants(const QString &accountId, const History::ChatType &type);
     static QString normalizeId(const QString &accountId, const QString &id);
     static QVariant getUserValue(const QString &interface, const QString &propName);
 
 
=== modified file 'tests/Ubuntu.History/HistoryEventModelTest.cpp'
--- tests/Ubuntu.History/HistoryEventModelTest.cpp	2016-09-09 20:00:09 +0000
+++ tests/Ubuntu.History/HistoryEventModelTest.cpp	2017-03-23 01:25:43 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2016 Canonical, Ltd.
+ * Copyright (C) 2016-2017 Canonical, Ltd.
  *
  * This file is part of history-service.
  *
 
=== modified file 'tests/daemon/DaemonTest.cpp'
--- tests/daemon/DaemonTest.cpp	2016-11-03 13:20:17 +0000
+++ tests/daemon/DaemonTest.cpp	2017-03-23 01:25:43 +0000
@@ -141,8 +141,6 @@
     History::Threads threads = threadsAddedSpy.first().first().value<History::Threads>();
     QCOMPARE(threads.count(), 1);
     History::Thread thread = threads.first();
-    QCOMPARE(thread.participants().count(), 1);
-    QCOMPARE(thread.participants().first().identifier(), sender);
 
     QTRY_COMPARE(threadsModifiedSpy.count(), 1);
     threads = threadsModifiedSpy.first().first().value<History::Threads>();
@@ -252,8 +250,6 @@
     History::Threads threads = threadsAddedSpy.first().first().value<History::Threads>();
     QCOMPARE(threads.count(), 1);
     History::Thread thread = threads.first();
-    QCOMPARE(thread.participants().count(), 1);
-    QCOMPARE(thread.participants().first().identifier(), recipient);
 
     QTRY_COMPARE(threadsModifiedSpy.count(), 1);
     threads = threadsModifiedSpy.first().first().value<History::Threads>();
@@ -296,8 +292,6 @@
     History::Threads threads = threadsAddedSpy.first().first().value<History::Threads>();
     QCOMPARE(threads.count(), 1);
     History::Thread thread = threads.first();
-    QCOMPARE(thread.participants().count(), 1);
-    QCOMPARE(thread.participants().first().identifier(), callerId);
 
     QTRY_COMPARE(threadsModifiedSpy.count(), 1);
     threads = threadsModifiedSpy.first().first().value<History::Threads>();
@@ -357,8 +351,6 @@
     History::Threads threads = threadsAddedSpy.first().first().value<History::Threads>();
     QCOMPARE(threads.count(), 1);
     History::Thread thread = threads.first();
-    QCOMPARE(thread.participants().count(), 1);
-    QCOMPARE(thread.participants().first().identifier(), phoneNumber);
 
     QTRY_COMPARE(threadsModifiedSpy.count(), 1);
     threads = threadsModifiedSpy.first().first().value<History::Threads>();
 
=== modified file 'tests/libhistoryservice/ManagerTest.cpp'
--- tests/libhistoryservice/ManagerTest.cpp	2015-09-23 21:52:48 +0000
+++ tests/libhistoryservice/ManagerTest.cpp	2017-03-23 01:25:43 +0000
@@ -96,7 +96,6 @@
 
     QCOMPARE(thread.accountId(), accountId);
     QCOMPARE(thread.type(), type);
-    QCOMPARE(thread.participants().identifiers(), participants);
 
     // now try to get the thread again to see if it is returned correctly
     History::Thread sameThread = mManager->threadForParticipants(accountId, type, participantsToMatch, matchFlags, false);
@@ -137,14 +136,16 @@
 
 void ManagerTest::testWriteEvents()
 {
+    QString textParticipant("textParticipant");
+    QString voiceParticipant("voiceParticipant");
     // create two threads, one for voice and one for text
     History::Thread textThread = mManager->threadForParticipants("textAccountId",
                                                                  History::EventTypeText,
-                                                                 QStringList()<< "textParticipant",
+                                                                 QStringList()<< textParticipant,
                                                                  History::MatchCaseSensitive, true);
     History::Thread voiceThread = mManager->threadForParticipants("voiceAccountId",
                                                                   History::EventTypeVoice,
-                                                                  QStringList()<< "voiceParticipant",
+                                                                  QStringList()<< voiceParticipant,
                                                                   History::MatchCaseSensitive, true);
     // insert some text and voice events
     History::Events events;
@@ -152,7 +153,7 @@
         History::TextEvent textEvent(textThread.accountId(),
                                      textThread.threadId(),
                                      QString("eventId%1").arg(i),
-                                     textThread.participants().first().identifier(),
+                                     textParticipant,
                                      QDateTime::currentDateTime(),
                                      true,
                                      QString("Hello world %1").arg(i),
@@ -163,7 +164,7 @@
         History::VoiceEvent voiceEvent(voiceThread.accountId(),
                                        voiceThread.threadId(),
                                        QString("eventId%1").arg(i),
-                                       voiceThread.participants().first().identifier(),
+                                       voiceParticipant,
                                        QDateTime::currentDateTime(),
                                        true,
                                        true);
@@ -214,14 +215,16 @@
 
 void ManagerTest::testRemoveEvents()
 {
+    QString textParticipant("textParticipant");
+    QString voiceParticipant("voiceParticipant");
     // create two threads, one for voice and one for text
     History::Thread textThread = mManager->threadForParticipants("textRemovableAccount",
                                                                  History::EventTypeText,
-                                                                 QStringList()<< "textParticipant",
+                                                                 QStringList()<< textParticipant,
                                                                  History::MatchCaseSensitive, true);
     History::Thread voiceThread = mManager->threadForParticipants("voiceRemovableAccount",
                                                                   History::EventTypeVoice,
-                                                                  QStringList()<< "voiceParticipant",
+                                                                  QStringList()<< voiceParticipant,
                                                                   History::MatchCaseSensitive, true);
     // insert some text and voice events
     History::Events events;
@@ -229,7 +232,7 @@
         History::TextEvent textEvent(textThread.accountId(),
                                      textThread.threadId(),
                                      QString("eventToBeRemoved%1").arg(i),
-                                     textThread.participants().first().identifier(),
+                                     textParticipant,
                                      QDateTime::currentDateTime(),
                                      true,
                                      QString("Hello world %1").arg(i),
@@ -239,7 +242,7 @@
         History::VoiceEvent voiceEvent(voiceThread.accountId(),
                                        voiceThread.threadId(),
                                        QString("eventToBeRemoved%1").arg(i),
-                                       voiceThread.participants().first().identifier(),
+                                       voiceParticipant,
                                        QDateTime::currentDateTime(),
                                        true,
                                        true);
@@ -280,14 +283,16 @@
 
 void ManagerTest::testGetSingleEvent()
 {
+    QString textParticipant("textSingleParticipant");
+    QString voiceParticipant("voiceSingleParticipant");
     // create two threads, one for voice and one for text
     History::Thread textThread = mManager->threadForParticipants("textSingleAccount",
                                                                  History::EventTypeText,
-                                                                 QStringList()<< "textSingleParticipant",
+                                                                 QStringList()<< textParticipant,
                                                                  History::MatchCaseSensitive, true);
     History::Thread voiceThread = mManager->threadForParticipants("voiceSingleAccount",
                                                                   History::EventTypeVoice,
-                                                                  QStringList()<< "voiceSingleParticipant",
+                                                                  QStringList()<< voiceParticipant,
                                                                   History::MatchCaseSensitive, true);
 
     // now add two events
@@ -348,43 +353,11 @@
     History::Threads threads;
     threads << textThread << voiceThread;
 
-    // insert some text and voice events
-    History::Events events;
-    for (int i = 0; i < 50; ++i) {
-        History::TextEvent textEvent(textThread.accountId(),
-                                     textThread.threadId(),
-                                     QString("eventToBeRemoved%1").arg(i),
-                                     textThread.participants().first().identifier(),
-                                     QDateTime::currentDateTime(),
-                                     true,
-                                     QString("Hello world %1").arg(i),
-                                     History::MessageTypeText);
-        events.append(textEvent);
-
-        History::VoiceEvent voiceEvent(voiceThread.accountId(),
-                                       voiceThread.threadId(),
-                                       QString("eventToBeRemoved%1").arg(i),
-                                       voiceThread.participants().first().identifier(),
-                                       QDateTime::currentDateTime(),
-                                       true,
-                                       true);
-        events.append(voiceEvent);
-    }
-
-    QVERIFY(mManager->writeEvents(events));
-
-    QSignalSpy eventsRemovedSpy(mManager, SIGNAL(eventsRemoved(History::Events)));
     QSignalSpy threadsRemovedSpy(mManager, SIGNAL(threadsRemoved(History::Threads)));
 
     QVERIFY(mManager->removeThreads(threads));
-    QTRY_COMPARE(eventsRemovedSpy.count(), 1);
     QTRY_COMPARE(threadsRemovedSpy.count(), 1);
 
-    History::Events removedEvents = eventsRemovedSpy.first().first().value<History::Events>();
-    qSort(removedEvents);
-    qSort(events);
-    QCOMPARE(removedEvents, events);
-
     History::Threads removedThreads = threadsRemovedSpy.first().first().value<History::Threads>();
     qSort(removedThreads);
     qSort(threads);
 
=== modified file 'tests/plugins/sqlite/SqliteEventViewTest.cpp'
--- tests/plugins/sqlite/SqliteEventViewTest.cpp	2013-12-09 21:18:14 +0000
+++ tests/plugins/sqlite/SqliteEventViewTest.cpp	2017-03-23 01:25:43 +0000
@@ -39,6 +39,7 @@
     void testNextPage();
     void testFilter();
     void testSort();
+    void testSortWithMultipleFields();
 
 private:
     SQLiteHistoryPlugin *mPlugin;
@@ -128,7 +129,26 @@
     QCOMPARE(allEvents.first()[History::FieldEventId].toString(), QString("event%1").arg(EVENT_COUNT-1));
     QCOMPARE(allEvents.last()[History::FieldEventId].toString(), QString("event00"));
     delete view;
-
+}
+
+void SqliteEventViewTest::testSortWithMultipleFields()
+{
+    History::Sort ascendingSort(QString("%1, %2").arg(History::FieldAccountId).arg(History::FieldEventId), Qt::AscendingOrder);
+    //History::Sort ascendingSort(QString("%1").arg(History::FieldEventId), Qt::AscendingOrder);
+    History::PluginEventView *view = mPlugin->queryEvents(History::EventTypeText, ascendingSort);
+    QVERIFY(view->IsValid());
+    QList<QVariantMap> allEvents;
+    QList<QVariantMap> events = view->NextPage();
+    while (!events.isEmpty()) {
+        allEvents << events;
+        events = view->NextPage();
+    }
+
+    QCOMPARE(allEvents[0][History::FieldEventId].toString(), QString("event00"));
+    QCOMPARE(allEvents[0][History::FieldAccountId].toString(), QString("account0"));
+    QCOMPARE(allEvents[1][History::FieldEventId].toString(), QString("event01"));
+    QCOMPARE(allEvents[1][History::FieldAccountId].toString(), QString("account0"));
+    delete view;
 }
 
 void SqliteEventViewTest::populateDatabase()
@@ -136,7 +156,7 @@
     mPlugin->beginBatchOperation();
 
     // create two threads of each type
-    for (int i = 0; i < 2; ++i) {
+    for (int i = 1; i >= 0; --i) {
         QVariantMap voiceThread = mPlugin->createThreadForParticipants(QString("account%1").arg(i),
                                                                        History::EventTypeVoice,
                                                                        QStringList() << QString("participant%1").arg(i));
 
=== modified file 'tests/plugins/sqlite/SqlitePluginTest.cpp'
--- tests/plugins/sqlite/SqlitePluginTest.cpp	2016-09-09 20:00:09 +0000
+++ tests/plugins/sqlite/SqlitePluginTest.cpp	2017-03-23 01:25:43 +0000
@@ -189,7 +189,6 @@
     QCOMPARE(retrievedThread[History::FieldType], thread[History::FieldType]);
     QCOMPARE(retrievedThread[History::FieldCount], thread[History::FieldCount]);
     QCOMPARE(retrievedThread[History::FieldUnreadCount], thread[History::FieldUnreadCount]);
-    QCOMPARE(retrievedThread[History::FieldParticipants], thread[History::FieldParticipants]);
 }
 
 void SqlitePluginTest::testEmptyThreadForParticipants()
@@ -219,7 +218,6 @@
     QCOMPARE(retrievedThread[History::FieldType], thread[History::FieldType]);
     QCOMPARE(retrievedThread[History::FieldCount], thread[History::FieldCount]);
     QCOMPARE(retrievedThread[History::FieldUnreadCount], thread[History::FieldUnreadCount]);
-    QCOMPARE(retrievedThread[History::FieldParticipants], thread[History::FieldParticipants]);
 
     // FIXME: check that the last event data is also present
 }