Support for receiving m.reaction events

* struct EventRelation; class ReactionEvent; Room::relatedEvents()
* Reaction events are processed in both history and sync batches
* Redacting a reaction removes it from the list of related events
* QMCTest::sendReaction()

1 files changed, 81 insertions, 38 deletions

diff --git a/lib/room.cpp b/lib/room.cpp
index 958991b7..8b05568a 100644
--- a/lib/room.cpp
+++ b/lib/room.cpp
@@ -38,6 +38,7 @@
 #include "events/roommemberevent.h"
 #include "events/typingevent.h"
 #include "events/receiptevent.h"
+#include "events/reactionevent.h"
 #include "events/callinviteevent.h"
 #include "events/callcandidatesevent.h"
 #include "events/callanswerevent.h"
@@ -106,7 +107,10 @@ class Room::Private
         Timeline timeline;
         PendingEvents unsyncedEvents;
         QHash<QString, TimelineItem::index_t> eventsIndex;
-
+        // A map from evtId to a map of relation type to a vector of event
+        // pointers. Not using QMultiHash, because we want to quickly return
+        // a number of relations for a given event without enumerating them.
+        QHash<QPair<QString, QString>, RelatedEvents> relations;
         QString displayname;
         Avatar avatar;
         int highlightCount = 0;
@@ -724,10 +728,10 @@ Room::rev_iter_t Room::findInTimeline(const QString& evtId) const
     if (!d->timeline.empty() && d->eventsIndex.contains(evtId))
     {
         auto it = findInTimeline(d->eventsIndex.value(evtId));
-        Q_ASSERT((*it)->id() == evtId);
+        Q_ASSERT(it != historyEdge() && (*it)->id() == evtId);
         return it;
     }
-    return timelineEdge();
+    return historyEdge();
 }
 
 Room::PendingEvents::iterator Room::findPendingEvent(const QString& txnId)
@@ -743,6 +747,18 @@ Room::findPendingEvent(const QString& txnId) const
             [txnId] (const auto& item) { return item->transactionId() == txnId; });
 }
 
+const Room::RelatedEvents Room::relatedEvents(const QString& evtId,
+                                              const char* relType) const
+{
+    return d->relations.value({ evtId, relType });
+}
+
+const Room::RelatedEvents Room::relatedEvents(const RoomEvent& evt,
+                                              const char* relType) const
+{
+    return relatedEvents(evt.id(), relType);
+}
+
 void Room::Private::getAllMembers()
 {
     // If already loaded or already loading, there's nothing to do here.
@@ -2044,6 +2060,14 @@ bool Room::Private::processRedaction(const RedactionEvent& redaction)
             updateDisplayname();
         }
     }
+    if (const auto* reaction = eventCast<ReactionEvent>(oldEvent)) {
+        const auto& targetEvtId = reaction->relation().eventId;
+        const auto lookupKey = qMakePair(targetEvtId,
+                                         EventRelation::Annotation());
+        if (relations.contains(lookupKey)) {
+            relations[lookupKey].removeOne(reaction);
+        }
+    }
     q->onRedaction(*oldEvent, *ti);
     emit q->replacedEvent(ti.event(), rawPtr(oldEvent));
     return true;
@@ -2124,45 +2148,49 @@ Room::Changes Room::Private::addNewMessageEvents(RoomEvents&& events)
     if (events.empty())
         return Change::NoChange;
 
-    // Pre-process redactions so that events that get redacted in the same
-    // batch landed in the timeline already redacted.
-    // NB: We have to store redaction events to the timeline too - see #220.
-    auto it = std::find_if(events.begin(), events.end(), isEditing);
-    for(const auto& eptr: RoomEventsRange(it, events.end()))
     {
-        if (auto* r = eventCast<RedactionEvent>(eptr))
-        {
-            // Try to find the target in the timeline, then in the batch.
-            if (processRedaction(*r))
-                continue;
-            auto targetIt = std::find_if(events.begin(), it,
-                [id=r->redactedEvent()] (const RoomEventPtr& ep) {
-                    return ep->id() == id;
-                });
-            if (targetIt != it)
-                *targetIt = makeRedacted(**targetIt, *r);
-            else
-                qCDebug(MAIN) << "Redaction" << r->id()
-                              << "ignored: target event" << r->redactedEvent()
-                              << "is not found";
-            // If the target event comes later, it comes already redacted.
-        }
-        if (auto* msg = eventCast<RoomMessageEvent>(eptr)) {
-            if (!msg->replacedEvent().isEmpty()) {
-                if (processReplacement(*msg))
+        // Pre-process redactions and edits so that events that get
+        // redacted/replaced in the same batch landed in the timeline already
+        // treated.
+        // NB: We have to store redacting/replacing events to the timeline too -
+        // see #220.
+        auto it = std::find_if(events.begin(), events.end(), isEditing);
+        for (const auto& eptr : RoomEventsRange(it, events.end())) {
+            if (auto* r = eventCast<RedactionEvent>(eptr)) {
+                // Try to find the target in the timeline, then in the batch.
+                if (processRedaction(*r))
                     continue;
                 auto targetIt = std::find_if(events.begin(), it,
-                    [id=msg->replacedEvent()] (const RoomEventPtr& ep) {
-                        return ep->id() == id;
-                    });
+                                             [id = r->redactedEvent()](
+                                                 const RoomEventPtr& ep) {
+                                                 return ep->id() == id;
+                                             });
                 if (targetIt != it)
-                    *targetIt = makeReplaced(**targetIt, *msg);
-                else // FIXME: don't ignore, just show it wherever it arrived
-                    qCDebug(MAIN) << "Replacing event" << msg->id()
-                                  << "ignored: replaced event" << msg->replacedEvent()
-                                  << "is not found";
-                // Same as with redactions above, the replaced event coming
-                // later will come already with the new content.
+                    *targetIt = makeRedacted(**targetIt, *r);
+                else
+                    qCDebug(MAIN)
+                        << "Redaction" << r->id() << "ignored: target event"
+                        << r->redactedEvent() << "is not found";
+                // If the target event comes later, it comes already redacted.
+            }
+            if (auto* msg = eventCast<RoomMessageEvent>(eptr)) {
+                if (!msg->replacedEvent().isEmpty()) {
+                    if (processReplacement(*msg))
+                        continue;
+                    auto targetIt = std::find_if(events.begin(), it,
+                                                 [id = msg->replacedEvent()](
+                                                     const RoomEventPtr& ep) {
+                                                     return ep->id() == id;
+                                                 });
+                    if (targetIt != it)
+                        *targetIt = makeReplaced(**targetIt, *msg);
+                    else // FIXME: don't ignore, just show it wherever it arrived
+                        qCDebug(MAIN) << "Replacing event" << msg->id()
+                                      << "ignored: replaced event"
+                                      << msg->replacedEvent() << "is not found";
+                    // Same as with redactions above, the replaced event coming
+                    // later will come already with the new content.
+                }
             }
         }
     }
@@ -2231,6 +2259,14 @@ Room::Changes Room::Private::addNewMessageEvents(RoomEvents&& events)
 
     if (totalInserted > 0)
     {
+        for (auto it = from; it != timeline.cend(); ++it) {
+            if (const auto* reaction = it->viewAs<ReactionEvent>()) {
+                const auto& relation = reaction->relation();
+                relations[{ relation.eventId, relation.type }] << reaction;
+                emit q->updatedEvent(relation.eventId);
+            }
+        }
+
         qCDebug(MAIN)
                 << "Room" << q->objectName() << "received" << totalInserted
                 << "new events; the last event is now" << timeline.back();
@@ -2289,6 +2325,13 @@ void Room::Private::addHistoricalMessageEvents(RoomEvents&& events)
     q->onAddHistoricalTimelineEvents(from);
     emit q->addedMessages(timeline.front().index(), from->index());
 
+    for (auto it = from; it != timeline.crend(); ++it) {
+        if (const auto* reaction = it->viewAs<ReactionEvent>()) {
+            const auto& relation = reaction->relation();
+            relations[{ relation.eventId, relation.type }] << reaction;
+            emit q->updatedEvent(relation.eventId);
+        }
+    }
     if (from <= q->readMarker())
         updateUnreadCount(from, timeline.crend());