Create ThreadView to track threads in a room

CMakeLists.txt

@@ -190,6 +190,7 @@ target_sources(${QUOTIENT_LIB_NAME} PUBLIC FILE_SET HEADERS BASE_DIRS .
         Quotient/events/keyverificationevent.h
         Quotient/keyimport.h
         Quotient/qt_connection_util.h
+        Quotient/threadview.h
     PRIVATE
         Quotient/function_traits.cpp
         Quotient/networkaccessmanager.cpp
@@ -247,6 +248,7 @@ target_sources(${QUOTIENT_LIB_NAME} PUBLIC FILE_SET HEADERS BASE_DIRS .
         Quotient/e2ee/cryptoutils.cpp
         Quotient/e2ee/sssshandler.cpp
         Quotient/keyimport.cpp
+        Quotient/threadview.cpp
         libquotientemojis.qrc
 )
 

Quotient/events/roommessageevent.cpp

@@ -318,9 +318,10 @@ QString RoomMessageEvent::threadRootEventId() const
     const auto relation = relatesTo();
     if (relation && relation.value().type == EventRelation::ThreadType) {
         return relation.value().eventId;
-    } else {
-        return unsignedPart<QJsonObject>("m.relations"_ls)[EventRelation::ThreadType].toString();
+    } else if (unsignedPart<QJsonObject>("m.relations"_L1).contains(EventRelation::ThreadType)) {
+        return id();
     }
+    return {};
 }
 
 namespace {

Quotient/events/roommessageevent.h

@@ -155,6 +155,10 @@ class QUOTIENT_API RoomMessageEvent : public RoomEvent {
     //!
     //! \note This will return the ID of the event if it is the thread root.
     //!
+    //! \note If the event is the thread root event and has not been updated with the server-side
+    //!       the function will return an empty string as we can't tell if the message
+    //!       is threaded.
+    //!
     //! \return The event ID of the thread root if threaded, an empty string otherwise.
     QString threadRootEventId()const;
 

Quotient/room.cpp

@@ -22,6 +22,7 @@
 #include "roommember.h"
 #include "roomstateview.h"
 #include "syncdata.h"
+#include "threadview.h"
 #include "user.h"
 
 #include "csapi/account-data.h"
@@ -123,6 +124,8 @@ class Q_DECL_HIDDEN Room::Private {
     // about the timeline.
     EventStats partiallyReadStats {}, unreadStats {};
 
+    ThreadView threads;
+
     // For storing a list of current member names for the purpose of disambiguation.
     QMultiHash<QString, QString> memberNameMap;
     QStringList membersInvited;
@@ -270,6 +273,8 @@ class Q_DECL_HIDDEN Room::Private {
     Timeline::size_type moveEventsToTimeline(RoomEventsRange events,
                                              EventsPlacement placement);
 
+    void updateThread(const RoomEvent* event);
+
     /**
      * Remove events from the passed container that are already in the timeline
      */
@@ -555,6 +560,8 @@ const Room::PendingEvents& Room::pendingEvents() const
     return d->unsyncedEvents;
 }
 
+const ThreadView& Room::threads() const { return d->threads; }
+
 int Room::requestedHistorySize() const
 {
     return eventsHistoryJob() != nullptr ? d->lastRequestedHistorySize : 0;
@@ -1752,12 +1759,51 @@ Room::Private::moveEventsToTimeline(RoomEventsRange events,
         if (auto n = q->checkForNotifications(ti); n.type != Notification::None)
             notifications.insert(eId, n);
         Q_ASSERT(q->findInTimeline(eId)->event()->id() == eId);
+        updateThread(ti.event());
     }
     const auto insertedSize = (index - baseIndex) * placement;
     Q_ASSERT(insertedSize == int(events.size()));
     return Timeline::size_type(insertedSize);
 }
 
+void Room::Private::updateThread(const RoomEvent* event)
+{
+    const auto rme = eventCast<const RoomMessageEvent>(event);
+    if (rme == nullptr) {
+        return;
+    }
+    if (!rme->isThreaded()) {
+        return;
+    }
+
+    if (threads.exists(rme->threadRootEventId())) {
+        auto thread = threads.getThread(rme->threadRootEventId());
+        const auto threadLatestIndex = eventsIndex.constFind(thread->latestEventId());
+        if (threadLatestIndex == eventsIndex.cend()) {
+            // Assume this is the latest event. This shouldn't happen but we can work around it.
+            thread->addEvent(rme, true, rme->senderId() == connection->userId());
+            return;
+        }
+
+        const auto eventIndexIt = eventsIndex.constFind(rme->id());
+        if (eventIndexIt == eventsIndex.cend()) {
+            qCCritical(EVENTS) << rme->id() << "not in the timeline. Update a thread after moving the event to timeline.";
+        }
+
+        thread->addEvent(rme, *eventIndexIt > *threadLatestIndex, rme->senderId() == connection->userId());
+    } else {
+        if (!event->id().isEmpty()) {
+            threads.add(std::make_unique<Thread>(rme->threadRootEventId(),
+                        // For pending events we can get the full correct details when the remote echo comes in.
+                        rme->id().isEmpty() ? rme->threadRootEventId() : rme->id(),
+                        // When we can't find the root we assume its a historical event that will load later if
+                        // we can find it we assume a new thread was just created.
+                        rme->id().isEmpty() || q->findInTimeline(rme->threadRootEventId()) == historyEdge() ? 1 : 2,
+                        rme->senderId() == connection->userId()));
+        }
+    }
+}
+
 const Avatar& Room::memberAvatarObject(const QString& memberId) const
 {
     return connection()->userAvatar(member(memberId).avatarUrl());

Quotient/room.h

@@ -43,6 +43,7 @@ struct MemberSorter;
 class LeaveRoomJob;
 class SetRoomStateWithKeyJob;
 class RedactEventJob;
+class ThreadView;
 
 /** The data structure used to expose file transfer information to views
  *
@@ -363,6 +364,9 @@ class QUOTIENT_API Room : public QObject {
     //!
     //! Same as messageEvents().crend()
     rev_iter_t historyEdge() const;
+
+    const ThreadView& threads() const;
+
     //! \brief Get an iterator for the position beyond the latest arrived event
     //!
     //! Same as messageEvents().cend()

Quotient/threadview.cpp

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: 2024 James Graham <james.h.graham@protonmail.com>
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#include "threadview.h"
+
+#include "events/roommessageevent.h"
+
+using namespace Quotient;
+
+namespace {
+inline auto checkThreadRoot(const QString& threadRootId) {
+    return [threadRootId](const std::unique_ptr<Thread>& thread) { return threadRootId == thread->threadRootId(); };
+}
+}
+
+void ThreadView::add(std::unique_ptr<Thread> thread)
+{
+    _threads.push_back(std::move(thread));
+}
+
+bool ThreadView::erase(const QString& threadRootId)
+{
+    return std::erase_if(_threads, checkThreadRoot(threadRootId)) > 0;
+}
+
+bool ThreadView::exists(const QString& threadRootId) const
+{
+    return std::ranges::any_of(_threads, checkThreadRoot(threadRootId));
+}
+
+Thread* ThreadView::getThread(const QString& threadRootId) const
+{
+    auto threadIt = std::ranges::find_if(_threads, checkThreadRoot(threadRootId));
+    if (threadIt == _threads.end()) {
+        return nullptr;
+    }
+    return threadIt->get();
+}
+
+Thread::Thread(QString threadRootId, QString latestEventId, int size, bool localUserParticipated)
+    : _threadRootId(threadRootId), _latestEventId(latestEventId), _size(size), _localUserParticipated(localUserParticipated)
+{}
+
+QString Thread::threadRootId() const
+{
+    return _threadRootId;
+}
+
+QString Thread::latestEventId() const
+{
+    return _latestEventId;
+}
+
+int Thread::size() const
+{
+    return _size;
+}
+
+bool Thread::localUserParticipated() const
+{
+    return _localUserParticipated;
+}
+
+bool Thread::addEvent(const RoomMessageEvent* event, bool isLatest, bool isLocalUser)
+{
+    if (event->threadRootEventId() != _threadRootId) {
+        return false;
+    }
+    if (isLatest) {
+        _latestEventId = event->id();
+    }
+    ++_size;
+    if (!_localUserParticipated) {
+        _localUserParticipated = isLocalUser;
+    }
+
+    return true;
+}

Quotient/threadview.h

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2024 James Graham <james.h.graham@protonmail.com>
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#pragma once
+
+#include <QString>
+#include <QJsonObject>
+
+#include "quotient_export.h"
+
+namespace Quotient {
+
+class RoomMessageEvent;
+
+class QUOTIENT_API Thread {
+public:
+    explicit Thread(QString threadRootId, QString latestEventId, int size, bool localUserParticipated);
+
+    QString threadRootId() const;
+    QString latestEventId() const;
+    int size() const;
+    bool localUserParticipated() const;
+
+    bool addEvent(const RoomMessageEvent* event, bool isLatest, bool isLocalUser);
+
+private:
+    const QString _threadRootId;
+    QString _latestEventId;
+    int _size;
+    bool _localUserParticipated;
+};
+
+class QUOTIENT_API ThreadView {
+public:
+    ThreadView() = default;
+
+    void add(std::unique_ptr<Thread> thread);
+
+    bool erase(const QString& threadRootId);
+
+    bool exists(const QString& threadRootId) const;
+
+    Thread* getThread(const QString& threadRootId) const;
+
+private:
+    std::vector<std::unique_ptr<Thread>> _threads;
+};
+
+} // namespace Quotient