Pre-compute roomMembersById

  once per timeline batch

Author: jennaharris7

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/TimelineItemsFactory.kt

@@ -19,6 +19,7 @@ import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.libraries.androidutils.diff.DiffCacheUpdater
 import io.element.android.libraries.androidutils.diff.MutableListDiffCache
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import kotlinx.collections.immutable.ImmutableList
@@ -75,19 +76,22 @@ class TimelineItemsFactory(
         timelineItems: List<MatrixTimelineItem>,
         roomMembers: List<RoomMember>,
     ) {
+        // Index the member list once per batch so per-item sender / receipt lookups are O(1)
+        // rather than O(N) — N can reach tens of thousands in large public rooms.
+        val roomMembersById = roomMembers.associateBy { it.userId }
         val newTimelineItemStates = ArrayList<TimelineItem>()
         for (index in diffCache.indices().reversed()) {
             val cacheItem = diffCache.get(index)
             if (cacheItem == null) {
-                buildAndCacheItem(timelineItems, index, roomMembers)?.also { timelineItemState ->
+                buildAndCacheItem(timelineItems, index, roomMembersById)?.also { timelineItemState ->
                     newTimelineItemStates.add(timelineItemState)
                 }
             } else {
-                val updatedItem = if (cacheItem is TimelineItem.Event && roomMembers.isNotEmpty()) {
+                val updatedItem = if (cacheItem is TimelineItem.Event && roomMembersById.isNotEmpty()) {
                     eventItemFactory.update(
                         timelineItem = cacheItem,
                         receivedMatrixTimelineItem = timelineItems[index] as MatrixTimelineItem.Event,
-                        roomMembers = roomMembers
+                        roomMembersById = roomMembersById,
                     )
                 } else {
                     cacheItem
@@ -102,11 +106,11 @@ class TimelineItemsFactory(
     private suspend fun buildAndCacheItem(
         timelineItems: List<MatrixTimelineItem>,
         index: Int,
-        roomMembers: List<RoomMember>,
+        roomMembersById: Map<UserId, RoomMember>,
     ): TimelineItem? {
         val timelineItem =
             when (val currentTimelineItem = timelineItems[index]) {
-                is MatrixTimelineItem.Event -> eventItemFactory.create(currentTimelineItem, index, timelineItems, roomMembers)
+                is MatrixTimelineItem.Event -> eventItemFactory.create(currentTimelineItem, index, timelineItems, roomMembersById)
                 is MatrixTimelineItem.Virtual -> virtualItemFactory.create(currentTimelineItem)
                 MatrixTimelineItem.Other -> null
             }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemEventFactory.kt

@@ -59,15 +59,15 @@ class TimelineItemEventFactory(
         currentTimelineItem: MatrixTimelineItem.Event,
         index: Int,
         timelineItems: List<MatrixTimelineItem>,
-        roomMembers: List<RoomMember>,
+        roomMembersById: Map<UserId, RoomMember>,
     ): TimelineItem.Event {
         val currentSender = currentTimelineItem.event.sender
         val groupPosition =
             computeGroupPosition(currentTimelineItem, timelineItems, index)
         val (senderProfile, senderAvatarData) = resolveSender(
             sender = currentSender,
             eventSenderProfile = currentTimelineItem.event.senderProfile,
-            roomMembers = roomMembers,
+            roomMembersById = roomMembersById,
         )
         val sentTime = dateFormatter.format(
             timestamp = currentTimelineItem.event.timestamp,
@@ -117,7 +117,7 @@ class TimelineItemEventFactory(
             sentDate = sentDate,
             groupPosition = groupPosition,
             reactionsState = currentTimelineItem.computeReactionsState(),
-            readReceiptState = currentTimelineItem.computeReadReceiptState(roomMembers),
+            readReceiptState = currentTimelineItem.computeReadReceiptState(roomMembersById),
             localSendState = currentTimelineItem.event.localSendState,
             inReplyTo = currentTimelineItem.event.inReplyTo()?.map(permalinkParser = permalinkParser),
             threadInfo = mappedThreadInfo,
@@ -133,19 +133,19 @@ class TimelineItemEventFactory(
     fun update(
         timelineItem: TimelineItem.Event,
         receivedMatrixTimelineItem: MatrixTimelineItem.Event,
-        roomMembers: List<RoomMember>,
+        roomMembersById: Map<UserId, RoomMember>,
     ): TimelineItem.Event {
         // Recompute the sender profile so that avatar / display name updates propagate to rows
         // already in the diff cache. The avatar is also rebuilt because it derives from senderProfile.
         val (senderProfile, senderAvatarData) = resolveSender(
             sender = timelineItem.senderId,
             eventSenderProfile = receivedMatrixTimelineItem.event.senderProfile,
-            roomMembers = roomMembers,
+            roomMembersById = roomMembersById,
         )
         return timelineItem.copy(
             senderProfile = senderProfile,
             senderAvatar = senderAvatarData,
-            readReceiptState = receivedMatrixTimelineItem.computeReadReceiptState(roomMembers),
+            readReceiptState = receivedMatrixTimelineItem.computeReadReceiptState(roomMembersById),
         )
     }
 
@@ -158,10 +158,10 @@ class TimelineItemEventFactory(
     private fun resolveSender(
         sender: UserId,
         eventSenderProfile: ProfileDetails,
-        roomMembers: List<RoomMember>,
+        roomMembersById: Map<UserId, RoomMember>,
     ): Pair<ProfileDetails, AvatarData> {
         val senderProfile = eventSenderProfile.withLiveMemberOverride(
-            roomMembers.find { it.userId == sender }
+            roomMembersById[sender]
         )
         val avatarData = AvatarData(
             id = sender.value,
@@ -212,15 +212,15 @@ class TimelineItemEventFactory(
     }
 
     private fun MatrixTimelineItem.Event.computeReadReceiptState(
-        roomMembers: List<RoomMember>,
+        roomMembersById: Map<UserId, RoomMember>,
     ): TimelineItemReadReceipts {
         if (!config.computeReadReceipts) {
             return TimelineItemReadReceipts(receipts = persistentListOf())
         }
         return TimelineItemReadReceipts(
             receipts = event.receipts
                 .map { receipt ->
-                    val roomMember = roomMembers.find { it.userId == receipt.userId }
+                    val roomMember = roomMembersById[receipt.userId]
                     ReadReceiptData(
                         avatarData = AvatarData(
                             id = receipt.userId.value,