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

[Tiago Salem Herrmann]

Improve the notifications of participants changing

Improve the notifications of participants changing

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

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

merge parent branch

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

only remove participants from irc rooms

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-21 15:00:24 +0000
@@ -95,7 +95,7 @@
         result = event.eventId();
         break;
     case SenderIdRole:
-        result = event.senderId();
+        result = History::ContactMatcher::normalizeId(event.senderId());
         break;
     case SenderRole:
         result = History::ContactMatcher::instance()->contactInfo(event.accountId(), event.senderId());
@@ -168,7 +168,7 @@
         break;
     case RemoteParticipantRole:
         if (!voiceEvent.isNull()) {
-            result = voiceEvent.remoteParticipant();
+            result = History::ContactMatcher::normalizeId(voiceEvent.remoteParticipant());
         }
         break;
     case SubjectAsAliasRole:

=== modified file 'Ubuntu/History/historymodel.cpp'
--- Ubuntu/History/historymodel.cpp	2016-11-24 12:22:11 +0000
+++ Ubuntu/History/historymodel.cpp	2017-02-21 15:00:24 +0000
@@ -385,7 +385,7 @@
             // FIXME: right now we might be grouping threads from different accounts, so we are not enforcing
             // the accountId to be the same as the one from the contact info, but maybe we need to do that
             // in the future?
-            if (History::Utils::compareIds(accountId, participant.identifier(), identifier)) {
+            if (History::Utils::compareIds(accountId, History::ContactMatcher::normalizeId(participant.identifier()), identifier)) {
                 changedIndexes << idx;
             }
         }

=== modified file 'Ubuntu/History/historythreadmodel.cpp'
--- Ubuntu/History/historythreadmodel.cpp	2016-06-17 01:49:46 +0000
+++ Ubuntu/History/historythreadmodel.cpp	2017-02-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +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/callchannelobserver.cpp'
--- daemon/callchannelobserver.cpp	2013-07-12 14:30:18 +0000
+++ daemon/callchannelobserver.cpp	2017-02-21 15:00:24 +0000
@@ -40,6 +40,7 @@
                 SLOT(onCallStateChanged(Tp::CallState)));
 
     mChannels.append(callChannel);
+    mCallStates[callChannel.data()] = callChannel->callState();
 }
 
 
@@ -51,11 +52,24 @@
     }
 
     switch (state) {
-    case Tp::CallStateEnded:
-        Q_EMIT callEnded(Tp::CallChannelPtr(channel));
+    case Tp::CallStateEnded: {
+        bool incoming = !channel->isRequested();
+        bool missed = incoming && channel->callStateReason().reason == Tp::CallStateChangeReasonNoAnswer;
+
+        // If the call state is not missed at this point, we need to check from which state we transitioned to ended,
+        // if from Initialised, it means it was indeed missed
+        if (incoming && !missed) {
+            missed = mCallStates[channel] == Tp::CallStateInitialised;
+        }
+        mCallStates.remove(channel);
+        mChannels.removeOne(Tp::CallChannelPtr(channel));
+        Q_EMIT callEnded(Tp::CallChannelPtr(channel), missed);
         break;
+    }
     case Tp::CallStateActive:
         channel->setProperty("activeTimestamp", QDateTime::currentDateTime());
+    default:
+        mCallStates[channel] = state;
         break;
     }
 }

=== modified file 'daemon/callchannelobserver.h'
--- daemon/callchannelobserver.h	2013-07-12 14:30:18 +0000
+++ daemon/callchannelobserver.h	2017-02-21 15:00:24 +0000
@@ -35,13 +35,14 @@
     void onCallChannelAvailable(Tp::CallChannelPtr callChannel);
 
 Q_SIGNALS:
-    void callEnded(Tp::CallChannelPtr callChannel);
+    void callEnded(Tp::CallChannelPtr callChannel, bool missed);
 
 protected Q_SLOTS:
     void onCallStateChanged(Tp::CallState state);
 
 private:
     QList<Tp::CallChannelPtr> mChannels;
+    QMap<Tp::CallChannel*,Tp::CallState> mCallStates;
 };
 
 #endif // CALLCHANNELOBSERVER_H

=== modified file 'daemon/historydaemon.cpp'
--- daemon/historydaemon.cpp	2016-11-24 02:02:32 +0000
+++ daemon/historydaemon.cpp	2017-02-21 15:00:24 +0000
@@ -131,8 +131,8 @@
     History::TelepathyHelper::instance()->registerChannelObserver();
 
     connect(&mCallObserver,
-            SIGNAL(callEnded(Tp::CallChannelPtr)),
-            SLOT(onCallEnded(Tp::CallChannelPtr)));
+            SIGNAL(callEnded(Tp::CallChannelPtr, bool)),
+            SLOT(onCallEnded(Tp::CallChannelPtr, bool)));
     connect(&mTextObserver,
             SIGNAL(messageReceived(Tp::TextChannelPtr,Tp::ReceivedMessage)),
             SLOT(onMessageReceived(Tp::TextChannelPtr,Tp::ReceivedMessage)));
@@ -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();
@@ -370,7 +371,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;
@@ -427,13 +428,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;
@@ -562,7 +563,7 @@
             &mTextObserver, SLOT(onTextChannelAvailable(Tp::TextChannelPtr)));
 }
 
-void HistoryDaemon::onCallEnded(const Tp::CallChannelPtr &channel)
+void HistoryDaemon::onCallEnded(const Tp::CallChannelPtr &channel, bool missed)
 {
     QVariantMap properties = propertiesFromChannel(channel);
     QVariantList participants;
@@ -592,7 +593,6 @@
     // FIXME: check if checking for isRequested() is enough
     bool incoming = !channel->isRequested();
     int duration;
-    bool missed = incoming && channel->callStateReason().reason == Tp::CallStateChangeReasonNoAnswer;
 
     if (!missed) {
         QDateTime activeTime = channel->property("activeTimestamp").toDateTime();
@@ -620,6 +620,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 +642,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 +659,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 +688,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,
@@ -711,18 +718,33 @@
                                                        matchFlagsForChannel(channel),
                                                        false);
         if (!thread.isEmpty()) {
+            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 +765,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, true);
 }
 
-void HistoryDaemon::updateRoomParticipants(const Tp::TextChannelPtr channel)
+void HistoryDaemon::updateRoomParticipants(const Tp::TextChannelPtr channel, bool notify)
 {
     if (!channel) {
         return;
@@ -811,12 +838,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 +870,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 +896,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);
+        }
     }
 }
 
@@ -1191,7 +1224,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 +1240,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-21 15:00:24 +0000
@@ -54,13 +54,13 @@
     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);
 
 private Q_SLOTS:
     void onObserverCreated();
-    void onCallEnded(const Tp::CallChannelPtr &channel);
+    void onCallEnded(const Tp::CallChannelPtr &channel, bool missed);
     void onMessageReceived(const Tp::TextChannelPtr textChannel, const Tp::ReceivedMessage &message);
     void onMessageRead(const Tp::TextChannelPtr textChannel, const Tp::ReceivedMessage &message);
     void onMessageSent(const Tp::TextChannelPtr textChannel, const Tp::Message &message, const QString &messageToken);
@@ -73,14 +73,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-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +0000
@@ -1290,6 +1290,9 @@
                     chatRoomInfo["SelfRoles"] = query1.value(20).toInt();
 
                 thread[History::FieldChatRoomInfo] = chatRoomInfo;
+                if (!History::Utils::shouldIncludeParticipants(thread)) {
+                    thread.remove(History::FieldParticipants);
+                }
             }
             break;
         case History::EventTypeVoice:
@@ -1353,8 +1356,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 'src/contactmatcher.cpp'
--- src/contactmatcher.cpp	2016-06-17 01:49:46 +0000
+++ src/contactmatcher.cpp	2017-02-21 15:00:24 +0000
@@ -99,21 +99,24 @@
 {
     InternalContactMap &internalMap = mContactMap[accountId];
 
+
+    QString normalizedId = normalizeId(identifier);
+
     // first do a simple string match on the map
-    if (internalMap.contains(identifier)) {
-        return internalMap[identifier];
+    if (internalMap.contains(normalizedId)) {
+        return internalMap[normalizedId];
     }
     
     QVariantMap map;
-
     // and if there was no match, asynchronously request the info, and return an empty map for now
     if (History::TelepathyHelper::instance()->ready()) {
-        map = requestContactInfo(accountId, identifier, synchronous);
+        map = requestContactInfo(accountId, normalizedId, synchronous);
     } else if (!synchronous) {
-        RequestInfo info{accountId, identifier};
+        RequestInfo info{accountId, normalizedId};
         mPendingRequests.append(info);
     }
-    map[History::FieldIdentifier] = identifier;
+
+    map[History::FieldIdentifier] = normalizedId;
     map[History::FieldAccountId] = accountId;
 
     QMapIterator<QString, QVariant> i(properties);
@@ -124,7 +127,7 @@
         }
     }
 
-    mContactMap[accountId][identifier] = map;
+    mContactMap[accountId][normalizedId] = map;
     return map;
 }
 
@@ -309,6 +312,7 @@
  */
 QVariantMap ContactMatcher::requestContactInfo(const QString &accountId, const QString &identifier, bool synchronous)
 {
+    QString normalizedId = normalizeId(identifier);
     QStringList addressableVCardFields = addressableFields(accountId);
     if (addressableVCardFields.isEmpty()) {
         // FIXME: add support for generic accounts
@@ -328,7 +332,7 @@
     QContactUnionFilter topLevelFilter;
     Q_FOREACH(const QString &field, addressableVCardFields) {
         if (field == "tel") {
-            topLevelFilter.append(QContactPhoneNumber::match(identifier));
+            topLevelFilter.append(QContactPhoneNumber::match(normalizedId));
         } else {
             // FIXME: handle more fields
             // rely on a generic field filter
@@ -340,7 +344,7 @@
             QContactDetailFilter valueFilter = QContactDetailFilter();
             valueFilter.setDetailType(QContactExtendedDetail::Type, QContactExtendedDetail::FieldData);
             valueFilter.setMatchFlags(QContactFilter::MatchExactly);
-            valueFilter.setValue(identifier);
+            valueFilter.setValue(normalizedId);
 
             QContactIntersectionFilter intersectionFilter;
             intersectionFilter.append(nameFilter);
@@ -356,7 +360,7 @@
             return QVariantMap();
         }
         // for synchronous requests, return the results right away.
-        return matchAndUpdate(accountId, identifier, contacts.first());
+        return matchAndUpdate(accountId, normalizedId, contacts.first());
     } else {
         // check if there is a request already going on for the given contact
         Q_FOREACH(const RequestInfo &info, mRequests.values()) {
@@ -365,7 +369,7 @@
                 continue;
             }
 
-            if (info.identifier == identifier) {
+            if (info.identifier == normalizedId) {
                 // if so, just wait for it to finish
                 return QVariantMap();
             }
@@ -381,7 +385,7 @@
 
         RequestInfo info;
         info.accountId = accountId;
-        info.identifier = identifier;
+        info.identifier = normalizedId;
         mRequests[request] = info;
         request->start();
     }
@@ -414,7 +418,6 @@
     QStringList fields = addressableFields(accountId);
     bool match = false;
 
-    int fieldsCount = fields.count();
     Q_FOREACH(const QString &field, fields) {
         if (field == "tel") {
             QList<QContactDetail> details = contact.details(QContactDetail::TypePhoneNumber);
@@ -467,8 +470,14 @@
     QStringList fields;
     if (!account.isNull()) {
         fields = account->protocolInfo().addressableVCardFields();
-        mAddressableFields[accountId] = fields;
-    }
+    }
+
+    // fallback to phone number matching in case everything else fails
+    if (fields.isEmpty()) {
+        fields << "tel";
+    }
+
+    mAddressableFields[accountId] = fields;
 
     return fields;
 }
@@ -478,4 +487,17 @@
     return (map.contains(History::FieldContactId) && !map[History::FieldContactId].toString().isEmpty());
 }
 
+QString ContactMatcher::normalizeId(const QString &id)
+{
+    QString normalizedId = id;
+
+    // FIXME: this is a hack so that SIP URIs get converted into phone numbers for contact matching
+    if (normalizedId.startsWith("sip:")) {
+        normalizedId.remove("sip:").remove(QRegularExpression("@.*$"));
+    }
+
+    return normalizedId;
+}
+
+
 }

=== modified file 'src/contactmatcher_p.h'
--- src/contactmatcher_p.h	2016-06-17 01:49:46 +0000
+++ src/contactmatcher_p.h	2017-02-21 15:00:24 +0000
@@ -51,6 +51,8 @@
     // this will only watch for contact changes affecting the identifier, but won't fetch contact info
     void watchIdentifier(const QString &accountId, const QString &identifier, const QVariantMap &currentInfo = QVariantMap());
 
+    static QString normalizeId(const QString &id);
+
 Q_SIGNALS:
     void contactInfoChanged(const QString &acountId, const QString &identifier, const QVariantMap &contactInfo);
 

=== modified file 'src/manager.cpp'
--- src/manager.cpp	2016-06-17 01:49:46 +0000
+++ src/manager.cpp	2017-02-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +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/thread.cpp'
--- src/thread.cpp	2016-07-12 02:08:11 +0000
+++ src/thread.cpp	2017-02-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +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-21 15:00:24 +0000
@@ -50,6 +50,7 @@
     if (protocolFlags.isEmpty()) {
         protocolFlags["ofono"] = MatchPhoneNumber;
         protocolFlags["multimedia"] = MatchPhoneNumber;
+        protocolFlags["sip"] = MatchPhoneNumber;
     }
 
     QString protocol = protocolFromAccountId(accountId);
@@ -57,7 +58,7 @@
         return protocolFlags[protocol];
     }
 
-    // default to this value
+    // default to phone number matching for now
     return History::MatchCaseSensitive;
 }
 
@@ -175,4 +176,14 @@
     return QVariant();
 }
 
+bool Utils::shouldIncludeParticipants(const Thread &thread)
+{
+    // FIXME
+    // this is obviously incorrect. we have to query the protocol files as a final solution
+    if (protocolFromAccountId(thread.accountId()) == "irc") {
+        return thread.chatType() != History::ChatTypeRoom;
+    }
+    return true;
+}
+
 }

=== modified file 'src/utils_p.h'
--- src/utils_p.h	2016-11-08 16:02:18 +0000
+++ src/utils_p.h	2017-02-21 15:00:24 +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 Thread &thread);
     static QString normalizeId(const QString &accountId, const QString &id);
     static QVariant getUserValue(const QString &interface, const QString &propName);