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

[Gustavo Pichorim Boiko]

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

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

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

237. By Gustavo Pichorim Boiko on 2017-01-30

Fix method return value.

238. By Tiago Salem Herrmann on 2017-02-01

merge parent

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

merge parent branch

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

merge parent branch

Unmerged revisions

=== modified file 'Ubuntu/History/historythreadmodel.cpp'
--- Ubuntu/History/historythreadmodel.cpp	2016-06-17 01:49:46 +0000
+++ Ubuntu/History/historythreadmodel.cpp	2017-02-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -187,6 +187,7 @@
     QVariantMap properties;
     QVariantList participants;
     QStringList participantIds;
+    QString accountId = textChannel->property(History::FieldAccountId).toString();
 
     ChannelInterfaceRolesInterface *roles_interface = textChannel->optionalInterface<ChannelInterfaceRolesInterface>();
     RolesMap roles;
@@ -197,7 +198,7 @@
     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 +209,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 +220,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 +232,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 +315,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 +396,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 +433,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 +455,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;
@@ -620,6 +648,7 @@
     // 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 +670,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 +687,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 +716,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 +737,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 +747,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 +795,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;
@@ -811,12 +868,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 +900,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 +926,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 +1018,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 +1064,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 +1077,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 +1255,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 +1271,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-01 17:42:07 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Canonical, Ltd.
+ * Copyright (C) 2013-2017 Canonical, Ltd.
  *
  * Authors:
  *  Gustavo Pichorim Boiko <[e-mail]>
@@ -48,13 +48,18 @@
                                     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);
 
@@ -73,14 +78,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);

=== modified file 'daemon/historyservicedbus.cpp'
--- daemon/historyservicedbus.cpp	2016-11-24 01:56:01 +0000
+++ daemon/historyservicedbus.cpp	2017-02-01 17:42:07 +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-01 17:42:07 +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 'plugins/sqlite/sqlitehistoryplugin.cpp'
--- plugins/sqlite/sqlitehistoryplugin.cpp	2016-11-24 01:50:48 +0000
+++ plugins/sqlite/sqlitehistoryplugin.cpp	2017-02-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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-01 17:42:07 +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);