Merge lp:~phablet-team/history-service/sort_by_multiple_fields into lp:history-service/staging

[Renato Araujo Oliveira Filho]

[lp:~phablet-team/history-service/sort_by_multiple_fields]

258. By Renato Araujo Oliveira Filho on 2017-02-07

Create unit test for multiple fields sort query.

259. By Renato Araujo Oliveira Filho on 2017-02-07

Update comments.

260. By Renato Araujo Oliveira Filho on 2017-02-07

Keep history model sorted if multiple fields are specified.

261. By Tiago Salem Herrmann on 2017-02-15

merge parent branch

262. By Tiago Salem Herrmann on 2017-02-21

merge parent branch

263. By Renato Araujo Oliveira Filho on 2017-03-22

Code optimize.

Unmerged revisions

=== modified file 'Ubuntu/History/historyeventmodel.cpp'
--- Ubuntu/History/historyeventmodel.cpp	2016-09-16 11:59:52 +0000
+++ Ubuntu/History/historyeventmodel.cpp	2017-02-07 15:39:44 +0000
@@ -98,7 +98,14 @@
         result = 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();
@@ -173,12 +180,16 @@
         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;
     }

=== modified file 'Ubuntu/History/historythreadmodel.cpp'
--- Ubuntu/History/historythreadmodel.cpp	2016-06-17 01:49:46 +0000
+++ Ubuntu/History/historythreadmodel.cpp	2017-02-07 15:39:44 +0000
@@ -294,6 +294,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 +315,20 @@
     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);
+    }
+}
+
 void HistoryThreadModel::onThreadsAdded(const History::Threads &threads)
 {
     if (threads.isEmpty()) {

=== modified file 'Ubuntu/History/historythreadmodel.h'
--- Ubuntu/History/historythreadmodel.h	2016-06-17 01:49:46 +0000
+++ Ubuntu/History/historythreadmodel.h	2017-02-07 15:39:44 +0000
@@ -76,6 +76,7 @@
     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:
     History::Threads fetchNextPage();

=== modified file 'daemon/HistoryService.xml'
--- daemon/HistoryService.xml	2016-04-15 22:23:21 +0000
+++ daemon/HistoryService.xml	2017-02-07 15:39:44 +0000
@@ -159,5 +159,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/historydaemon.cpp'
--- daemon/historydaemon.cpp	2016-11-24 02:02:32 +0000
+++ daemon/historydaemon.cpp	2017-02-07 15:39:44 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -145,6 +145,9 @@
     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 +166,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,17 +206,20 @@
     QVariantMap properties;
     QVariantList participants;
     QStringList participantIds;
+    QString accountId = textChannel->property(History::FieldAccountId).toString();
 
     ChannelInterfaceRolesInterface *roles_interface = textChannel->optionalInterface<ChannelInterfaceRolesInterface>();
     RolesMap roles;
     if (roles_interface) {
-        roles = roles_interface->getRoles();
+        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] = textChannel->property(History::FieldAccountId).toString();
+        contactProperties[History::FieldAccountId] = accountId;
         contactProperties[History::FieldIdentifier] = contact->id();
         contactProperties[History::FieldParticipantState] = History::ParticipantStateRegular;
         contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
@@ -208,7 +230,7 @@
     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::FieldAccountId] = accountId;
         contactProperties[History::FieldIdentifier] = contact->id();
         contactProperties[History::FieldParticipantState] = History::ParticipantStateRemotePending;
         contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
@@ -219,7 +241,7 @@
     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::FieldAccountId] = accountId;
         contactProperties[History::FieldIdentifier] = contact->id();
         contactProperties[History::FieldParticipantState] = History::ParticipantStateLocalPending;
         contactProperties[History::FieldParticipantRoles] = roles[contact->handle().at(0)];
@@ -231,7 +253,7 @@
             textChannel->targetContact() == textChannel->connection()->selfContact()) {
         QVariantMap contactProperties;
         contactProperties[History::FieldAlias] = textChannel->targetContact()->alias();
-        contactProperties[History::FieldAccountId] = textChannel->property(History::FieldAccountId).toString();
+        contactProperties[History::FieldAccountId] = accountId;
         contactProperties[History::FieldIdentifier] = textChannel->targetContact()->id();
         contactProperties[History::FieldParticipantState] = History::ParticipantStateRegular;
         participantIds << textChannel->targetContact()->id();
@@ -314,6 +336,31 @@
     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;
+}
+
 QString HistoryDaemon::queryThreads(int type, const QVariantMap &sort, const QVariantMap &filter, const QVariantMap &properties)
 {
     if (!mBackend) {
@@ -370,7 +417,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 +454,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 +476,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;
@@ -615,11 +664,17 @@
     writeEvents(QList<QVariantMap>() << event, properties);
 }
 
+void HistoryDaemon::onTextChannelInvalidated(const Tp::TextChannelPtr channel)
+{
+    mRolesMap.remove(channel->objectPath());
+}
+
 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 +696,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 +713,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 +742,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 +763,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 +773,34 @@
                                                        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());
+                        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;
                     }
                 }
             }
@@ -743,25 +821,30 @@
                     }
                     writeInformationEvent(thread, type);
                     // update backend
-                    updateRoomProperties(channel, QVariantMap{{"Joined", false}});
+                    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 +855,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 +900,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 +932,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,19 +958,21 @@
     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);
+        }
     }
 }
 
@@ -955,19 +1050,20 @@
         return;
     }
 
-    QVariantMap thread = threadForProperties(textChannel->property(History::FieldAccountId).toString(),
-                                                                   History::EventTypeText,
-                                                                   properties,
-                                                                   matchFlagsForChannel(textChannel),
-                                                                   true);
+    QString accountId = textChannel->property(History::FieldAccountId).toString();
+    QString threadId = threadIdForProperties(accountId,
+                                             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 +1096,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 +1109,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");
@@ -1191,7 +1287,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 +1303,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)

=== modified file 'daemon/historydaemon.h'
--- daemon/historydaemon.h	2016-10-20 13:56:10 +0000
+++ daemon/historydaemon.h	2017-02-07 15:39:44 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -42,19 +42,24 @@
 
     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);
     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);
 
@@ -65,6 +70,7 @@
     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,14 +79,14 @@
 
 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);
@@ -93,6 +99,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-02-07 15:39:44 +0000
@@ -75,6 +75,14 @@
     Q_EMIT EventsRemoved(events);
 }
 
+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,
                                                     int type,
                                                     const QVariantMap &properties,

=== modified file 'daemon/historyservicedbus.h'
--- daemon/historyservicedbus.h	2016-06-17 01:49:46 +0000
+++ daemon/historyservicedbus.h	2017-02-07 15:39:44 +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);
@@ -70,6 +74,10 @@
     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);

=== modified file 'daemon/textchannelobserver.cpp'
--- daemon/textchannelobserver.cpp	2016-08-26 14:10:25 +0000
+++ daemon/textchannelobserver.cpp	2017-02-07 15:39:44 +0000
@@ -57,6 +57,7 @@
 {
     Tp::TextChannelPtr textChannel(qobject_cast<Tp::TextChannel*>(sender()));
     mChannels.removeAll(textChannel);
+    Q_EMIT textChannelInvalidated(textChannel);
 }
 
 void TextChannelObserver::onMessageReceived(const Tp::ReceivedMessage &message)

=== modified file 'daemon/textchannelobserver.h'
--- daemon/textchannelobserver.h	2016-08-26 14:10:25 +0000
+++ daemon/textchannelobserver.h	2017-02-07 15:39:44 +0000
@@ -37,6 +37,7 @@
 
 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);

=== modified file 'plugins/sqlite/sqlitehistoryeventview.cpp'
--- plugins/sqlite/sqlitehistoryeventview.cpp	2015-01-28 23:08:01 +0000
+++ plugins/sqlite/sqlitehistoryeventview.cpp	2017-02-07 15:39:44 +0000
@@ -42,7 +42,16 @@
     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 split by ','
+        // The idea is to implement a list of sort from the top of the API
+        Q_FOREACH(const QString& field, sort.sortField().split(",")) {
+            order += QString("%1 %2, ")
+                    .arg(field)
+                    .arg(sort.sortOrder() == Qt::AscendingOrder ? "ASC" : "DESC");
+        }
+
+        order = QString("ORDER BY %1").arg(order.lastIndexOf(","));
+        qDebug() << "ORDER" << order;
         // 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-02-07 15:39:44 +0000
@@ -315,8 +315,6 @@
         return QVariantMap();
     }
 
-    QSqlQuery query(SQLiteDatabase::instance()->database());
-
     History::ChatType chatType = (History::ChatType)properties[History::FieldChatType].toUInt();
 
     if (chatType == History::ChatTypeRoom) {
@@ -332,6 +330,24 @@
     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();
+}
+
 QVariantMap SQLiteHistoryPlugin::threadForParticipants(const QString &accountId,
                                                        History::EventType type,
                                                        const QStringList &participants,
@@ -1290,6 +1306,9 @@
                     chatRoomInfo["SelfRoles"] = query1.value(20).toInt();
 
                 thread[History::FieldChatRoomInfo] = chatRoomInfo;
+                if (!History::Utils::shouldIncludeParticipants(accountId)) {
+                    thread.remove(History::FieldParticipants);
+                }
             }
             break;
         case History::EventTypeVoice:
@@ -1317,7 +1336,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 +1373,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-02-07 15:39:44 +0000
@@ -59,6 +59,10 @@
                                       History::EventType type,
                                       const QVariantMap &properties,
                                       History::MatchFlags matchFlags = History::MatchCaseSensitive);
+    virtual QString threadIdForProperties(const QString &accountId,
+                                          History::EventType type,
+                                          const QVariantMap &properties,
+                                          History::MatchFlags matchFlags = History::MatchCaseSensitive) override;
 
     QList<QVariantMap> eventsForThread(const QVariantMap &thread);
 

=== modified file 'src/manager.cpp'
--- src/manager.cpp	2016-06-17 01:49:46 +0000
+++ src/manager.cpp	2017-02-07 15:39:44 +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(),

=== modified file 'src/manager.h'
--- src/manager.h	2016-06-17 01:49:46 +0000
+++ src/manager.h	2017-02-07 15:39:44 +0000
@@ -79,6 +79,7 @@
     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-02-07 15:39:44 +0000
@@ -50,6 +50,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",
@@ -168,6 +174,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-02-07 15:39:44 +0000
@@ -62,6 +62,10 @@
     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,6 +75,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);

=== modified file 'src/participant.cpp'
--- src/participant.cpp	2016-11-24 01:04:37 +0000
+++ src/participant.cpp	2017-02-07 15:39:44 +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-02-07 15:39:44 +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-02-07 15:39:44 +0000
@@ -65,6 +65,10 @@
                                               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> eventsForThread(const QVariantMap &thread) = 0;
 

=== modified file 'src/thread.cpp'
--- src/thread.cpp	2016-07-12 02:08:11 +0000
+++ src/thread.cpp	2017-02-07 15:39:44 +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-02-07 15:39:44 +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-02-07 15:39:44 +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-02-07 15:39:44 +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-02-07 15:39:44 +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-02-07 15:39:44 +0000
@@ -175,4 +175,11 @@
     return QVariant();
 }
 
+bool Utils::shouldIncludeParticipants(const QString &accountId)
+{
+    // FIXME
+    // this is obviously incorrect. we have to query the protocol files as a final solution
+    return protocolFromAccountId(accountId) != "irc";
+}
+
 }

=== modified file 'src/utils_p.h'
--- src/utils_p.h	2016-11-08 16:02:18 +0000
+++ src/utils_p.h	2017-02-07 15:39:44 +0000
@@ -36,6 +36,7 @@
     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 QString &accountId);
     static QString normalizeId(const QString &accountId, const QString &id);
     static QVariant getUserValue(const QString &interface, const QString &propName);