Member events: try to cache (WIP)

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/session/room/timeline/ChunkEntityTest.kt

@@ -19,7 +19,11 @@ package im.vector.matrix.android.session.room.timeline
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.zhuinden.monarchy.Monarchy
 import im.vector.matrix.android.InstrumentedTest
-import im.vector.matrix.android.internal.database.helper.*
+import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.matrix.android.internal.database.helper.add
+import im.vector.matrix.android.internal.database.helper.isUnlinked
+import im.vector.matrix.android.internal.database.helper.lastStateIndex
+import im.vector.matrix.android.internal.database.helper.merge
 import im.vector.matrix.android.internal.database.model.ChunkEntity
 import im.vector.matrix.android.internal.database.model.SessionRealmModule
 import im.vector.matrix.android.internal.session.room.timeline.PaginationDirection
@@ -197,4 +201,15 @@ internal class ChunkEntityTest : InstrumentedTest {
             chunk1.nextToken shouldEqual nextToken
         }
     }
+
+    private fun ChunkEntity.addAll(roomId: String,
+                                   events: List<Event>,
+                                   direction: PaginationDirection,
+                                   stateIndexOffset: Int = 0,
+            // Set to true for Event retrieved from a Permalink (i.e. not linked to live Chunk)
+                                   isUnlinked: Boolean = false) {
+        events.forEach { event ->
+            add(roomId, event, direction, stateIndexOffset, isUnlinked)
+        }
+    }
 }

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/session/room/timeline/RoomDataHelper.kt

@@ -16,7 +16,6 @@
 
 package im.vector.matrix.android.session.room.timeline
 
-import com.zhuinden.monarchy.Monarchy
 import im.vector.matrix.android.api.session.events.model.Content
 import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.events.model.EventType
@@ -25,12 +24,6 @@ import im.vector.matrix.android.api.session.room.model.Membership
 import im.vector.matrix.android.api.session.room.model.RoomMember
 import im.vector.matrix.android.api.session.room.model.message.MessageTextContent
 import im.vector.matrix.android.api.session.room.model.message.MessageType
-import im.vector.matrix.android.internal.database.helper.addAll
-import im.vector.matrix.android.internal.database.helper.addOrUpdate
-import im.vector.matrix.android.internal.database.model.ChunkEntity
-import im.vector.matrix.android.internal.database.model.RoomEntity
-import im.vector.matrix.android.internal.session.room.timeline.PaginationDirection
-import io.realm.kotlin.createObject
 import kotlin.random.Random
 
 object RoomDataHelper {
@@ -73,19 +66,4 @@ object RoomDataHelper {
         val roomMember = RoomMember(Membership.JOIN, "Fake name #${Random.nextLong()}").toContent()
         return createFakeEvent(EventType.STATE_ROOM_MEMBER, roomMember)
     }
-
-    fun fakeInitialSync(monarchy: Monarchy, roomId: String) {
-        monarchy.runTransactionSync { realm ->
-            val roomEntity = realm.createObject<RoomEntity>(roomId)
-            roomEntity.membership = Membership.JOIN
-            val eventList = createFakeListOfEvents(10)
-            val chunkEntity = realm.createObject<ChunkEntity>().apply {
-                nextToken = null
-                prevToken = Random.nextLong(System.currentTimeMillis()).toString()
-                isLastForward = true
-            }
-            chunkEntity.addAll(roomId, eventList, PaginationDirection.FORWARDS)
-            roomEntity.addOrUpdate(chunkEntity)
-        }
-    }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/database/helper/ChunkEntityHelper.kt

@@ -28,6 +28,7 @@ import im.vector.matrix.android.internal.database.query.where
 import im.vector.matrix.android.internal.extensions.assertIsManaged
 import im.vector.matrix.android.internal.session.room.timeline.PaginationDirection
 import io.realm.Sort
+import io.realm.kotlin.createObject
 
 // By default if a chunk is empty we consider it unlinked
 internal fun ChunkEntity.isUnlinked(): Boolean {
@@ -65,38 +66,22 @@ internal fun ChunkEntity.merge(roomId: String,
         this.isLastBackward = chunkToMerge.isLastBackward
         eventsToMerge = chunkToMerge.timelineEvents.sort(TimelineEventEntityFields.ROOT.DISPLAY_INDEX, Sort.DESCENDING)
     }
-    val events = eventsToMerge.mapNotNull { it.root?.asDomain() }
-    val eventIds = ArrayList<String>()
-    events.forEach { event ->
-        add(roomId, event, direction, isUnlinked = isUnlinked)
-        if (event.eventId != null) {
-            eventIds.add(event.eventId)
-        }
-    }
-    updateSenderDataFor(eventIds)
+    val timelineEvents = eventsToMerge
+            .mapNotNull {
+                val event = it.root?.asDomain() ?: return@mapNotNull null
+                add(roomId, event, direction, isUnlinked = isUnlinked)
+            }
+    updateSenderDataFor(timelineEvents)
 }
 
-internal fun ChunkEntity.addAll(roomId: String,
-                                events: List<Event>,
-                                direction: PaginationDirection,
-                                stateIndexOffset: Int = 0,
-        // Set to true for Event retrieved from a Permalink (i.e. not linked to live Chunk)
-                                isUnlinked: Boolean = false) {
-    assertIsManaged()
-    val eventIds = ArrayList<String>()
-    events.forEach { event ->
-        add(roomId, event, direction, stateIndexOffset, isUnlinked)
-        if (event.eventId != null) {
-            eventIds.add(event.eventId)
-        }
-    }
-    updateSenderDataFor(eventIds)
-}
-
-internal fun ChunkEntity.updateSenderDataFor(eventIds: List<String>) {
-    for (eventId in eventIds) {
-        val timelineEventEntity = timelineEvents.find(eventId) ?: continue
-        timelineEventEntity.updateSenderData()
+internal fun ChunkEntity.updateSenderDataFor(events: List<TimelineEventEntity>) {
+    val cache = RoomMembersCache()
+    events.forEach {
+        val result = cache.get(it)
+        it.isUniqueDisplayName = result.isUniqueDisplayName
+        it.senderAvatar = result.senderAvatar
+        it.senderName = result.senderName
+        it.senderMembershipEventId = result.senderMembershipEventId
     }
 }
 
@@ -104,10 +89,10 @@ internal fun ChunkEntity.add(roomId: String,
                              event: Event,
                              direction: PaginationDirection,
                              stateIndexOffset: Int = 0,
-                             isUnlinked: Boolean = false) {
+                             isUnlinked: Boolean = false): TimelineEventEntity? {
     assertIsManaged()
     if (event.eventId != null && timelineEvents.find(event.eventId) != null) {
-        return
+        return null
     }
     var currentDisplayIndex = lastDisplayIndex(direction, 0)
     if (direction == PaginationDirection.FORWARDS) {
@@ -134,7 +119,9 @@ internal fun ChunkEntity.add(roomId: String,
     val senderId = event.senderId ?: ""
 
     val readReceiptsSummaryEntity = ReadReceiptsSummaryEntity.where(realm, eventId).findFirst()
-            ?: ReadReceiptsSummaryEntity(eventId, roomId)
+            ?: realm.createObject<ReadReceiptsSummaryEntity>(eventId).apply {
+                this.roomId = roomId
+            }
 
     // Update RR for the sender of a new message with a dummy one
 
@@ -151,13 +138,15 @@ internal fun ChunkEntity.add(roomId: String,
         }
     }
 
-    val eventEntity = TimelineEventEntity(localId).also {
-        it.root = event.toEntity(roomId).apply {
-            this.stateIndex = currentStateIndex
-            this.isUnlinked = isUnlinked
-            this.displayIndex = currentDisplayIndex
-            this.sendState = SendState.SYNCED
-        }
+    val rootEvent = event.toEntity(roomId).apply {
+        this.stateIndex = currentStateIndex
+        this.isUnlinked = isUnlinked
+        this.displayIndex = currentDisplayIndex
+        this.sendState = SendState.SYNCED
+    }
+    val eventEntity = realm.createObject<TimelineEventEntity>().also {
+        it.localId = localId
+        it.root = realm.copyToRealm(rootEvent)
         it.eventId = eventId
         it.roomId = roomId
         it.annotations = EventAnnotationsSummaryEntity.where(realm, eventId).findFirst()
@@ -165,6 +154,7 @@ internal fun ChunkEntity.add(roomId: String,
     }
     val position = if (direction == PaginationDirection.FORWARDS) 0 else this.timelineEvents.size
     timelineEvents.add(position, eventEntity)
+    return eventEntity
 }
 
 internal fun ChunkEntity.lastDisplayIndex(direction: PaginationDirection, defaultValue: Int = 0): Int {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/database/helper/RoomMembersCache.kt

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.database.helper
+
+import im.vector.matrix.android.api.session.events.model.EventType
+import im.vector.matrix.android.api.session.events.model.toModel
+import im.vector.matrix.android.api.session.room.model.RoomMemberContent
+import im.vector.matrix.android.internal.database.mapper.ContentMapper
+import im.vector.matrix.android.internal.database.model.*
+import im.vector.matrix.android.internal.database.query.next
+import im.vector.matrix.android.internal.database.query.prev
+import im.vector.matrix.android.internal.database.query.where
+import im.vector.matrix.android.internal.extensions.assertIsManaged
+import im.vector.matrix.android.internal.session.room.membership.RoomMembers
+import io.realm.RealmList
+import io.realm.RealmQuery
+import timber.log.Timber
+
+/**
+ * This is an internal cache to avoid querying all the time the room member events
+ */
+internal class RoomMembersCache {
+
+    internal data class Key(
+            val roomId: String,
+            val stateIndex: Int,
+            val senderId: String
+    )
+
+    internal class Value(
+            var senderAvatar: String? = null,
+            var senderName: String? = null,
+            var isUniqueDisplayName: Boolean = false,
+            var senderMembershipEventId: String? = null
+    )
+
+    private val values = HashMap<Key, Value>()
+
+    fun get(timelineEventEntity: TimelineEventEntity): Value {
+        val key = Key(
+                roomId = timelineEventEntity.roomId,
+                stateIndex = timelineEventEntity.root?.stateIndex ?: 0,
+                senderId = timelineEventEntity.root?.sender ?: ""
+        )
+        val result: Value
+        val start = System.currentTimeMillis()
+        result = values.getOrPut(key) {
+            doQueryAndBuildValue(timelineEventEntity)
+        }
+        val end = System.currentTimeMillis()
+        Timber.v("Get value took: ${end - start} millis")
+        return result
+    }
+
+    private fun doQueryAndBuildValue(timelineEventEntity: TimelineEventEntity): Value {
+        return timelineEventEntity.computeValue()
+    }
+
+    private fun RealmList<TimelineEventEntity>.buildQuery(sender: String, isUnlinked: Boolean): RealmQuery<TimelineEventEntity> {
+        return where()
+                .equalTo(TimelineEventEntityFields.ROOT.STATE_KEY, sender)
+                .equalTo(TimelineEventEntityFields.ROOT.TYPE, EventType.STATE_ROOM_MEMBER)
+                .equalTo(TimelineEventEntityFields.ROOT.IS_UNLINKED, isUnlinked)
+    }
+
+    private fun TimelineEventEntity.computeValue(): Value {
+        assertIsManaged()
+        val result = Value()
+
+        val roomEntity = RoomEntity.where(realm, roomId = roomId).findFirst() ?: return result
+        val stateIndex = root?.stateIndex ?: return result
+        val senderId = root?.sender ?: return result
+        val chunkEntity = chunk?.firstOrNull() ?: return result
+        val isUnlinked = chunkEntity.isUnlinked()
+        var senderMembershipEvent: EventEntity?
+        var senderRoomMemberContent: String?
+        var senderRoomMemberPrevContent: String?
+
+        if (stateIndex <= 0) {
+            senderMembershipEvent = chunkEntity.timelineEvents.buildQuery(senderId, isUnlinked).next(from = stateIndex)?.root
+            senderRoomMemberContent = senderMembershipEvent?.prevContent
+            senderRoomMemberPrevContent = senderMembershipEvent?.content
+        } else {
+            senderMembershipEvent = chunkEntity.timelineEvents.buildQuery(senderId, isUnlinked).prev(since = stateIndex)?.root
+            senderRoomMemberContent = senderMembershipEvent?.content
+            senderRoomMemberPrevContent = senderMembershipEvent?.prevContent
+        }
+
+        // We fallback to untimelinedStateEvents if we can't find membership events in timeline
+        if (senderMembershipEvent == null) {
+            senderMembershipEvent = roomEntity.untimelinedStateEvents
+                    .where()
+                    .equalTo(EventEntityFields.STATE_KEY, senderId)
+                    .equalTo(EventEntityFields.TYPE, EventType.STATE_ROOM_MEMBER)
+                    .prev(since = stateIndex)
+            senderRoomMemberContent = senderMembershipEvent?.content
+            senderRoomMemberPrevContent = senderMembershipEvent?.prevContent
+        }
+
+        ContentMapper.map(senderRoomMemberContent).toModel<RoomMemberContent>()?.also {
+            result.senderAvatar = it.avatarUrl
+            result.senderName = it.displayName
+            result.isUniqueDisplayName = RoomMembers(realm, roomId).isUniqueDisplayName(it.displayName)
+        }
+        // We try to fallback on prev content if we got a room member state events with null fields
+        if (root?.type == EventType.STATE_ROOM_MEMBER) {
+            ContentMapper.map(senderRoomMemberPrevContent).toModel<RoomMemberContent>()?.also {
+                if (result.senderAvatar == null && it.avatarUrl != null) {
+                    result.senderAvatar = it.avatarUrl
+                }
+                if (result.senderName == null && it.displayName != null) {
+                    result.senderName = it.displayName
+                    result.isUniqueDisplayName = RoomMembers(realm, roomId).isUniqueDisplayName(it.displayName)
+                }
+            }
+        }
+        result.senderMembershipEventId = senderMembershipEvent?.eventId
+        return result
+    }
+
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/database/helper/TimelineEventEntityHelper.kt

@@ -40,20 +40,18 @@ internal fun TimelineEventEntity.updateSenderData() {
     var senderMembershipEvent: EventEntity?
     var senderRoomMemberContent: String?
     var senderRoomMemberPrevContent: String?
-    when {
-        stateIndex <= 0 -> {
-            senderMembershipEvent = chunkEntity.timelineEvents.buildQuery(senderId, isUnlinked).next(from = stateIndex)?.root
-            senderRoomMemberContent = senderMembershipEvent?.prevContent
-            senderRoomMemberPrevContent = senderMembershipEvent?.content
-        }
-        else            -> {
-            senderMembershipEvent = chunkEntity.timelineEvents.buildQuery(senderId, isUnlinked).prev(since = stateIndex)?.root
-            senderRoomMemberContent = senderMembershipEvent?.content
-            senderRoomMemberPrevContent = senderMembershipEvent?.prevContent
-        }
+
+    if (stateIndex <= 0) {
+        senderMembershipEvent = chunkEntity.timelineEvents.buildQuery(senderId, isUnlinked).next(from = stateIndex)?.root
+        senderRoomMemberContent = senderMembershipEvent?.prevContent
+        senderRoomMemberPrevContent = senderMembershipEvent?.content
+    } else {
+        senderMembershipEvent = chunkEntity.timelineEvents.buildQuery(senderId, isUnlinked).prev(since = stateIndex)?.root
+        senderRoomMemberContent = senderMembershipEvent?.content
+        senderRoomMemberPrevContent = senderMembershipEvent?.prevContent
     }
 
-    // We fallback to untimelinedStateEvents if we can't find membership events in timeline
+// We fallback to untimelinedStateEvents if we can't find membership events in timeline
     if (senderMembershipEvent == null) {
         senderMembershipEvent = roomEntity.untimelinedStateEvents
                 .where()
@@ -70,7 +68,7 @@ internal fun TimelineEventEntity.updateSenderData() {
         this.isUniqueDisplayName = RoomMembers(realm, roomId).isUniqueDisplayName(it.displayName)
     }
 
-    // We try to fallback on prev content if we got a room member state events with null fields
+// We try to fallback on prev content if we got a room member state events with null fields
     if (root?.type == EventType.STATE_ROOM_MEMBER) {
         ContentMapper.map(senderRoomMemberPrevContent).toModel<RoomMemberContent>()?.also {
             if (this.senderAvatar == null && it.avatarUrl != null) {
@@ -82,7 +80,7 @@ internal fun TimelineEventEntity.updateSenderData() {
             }
         }
     }
-    this.senderMembershipEvent = senderMembershipEvent
+    this.senderMembershipEventId = senderMembershipEvent?.eventId
 }
 
 internal fun TimelineEventEntity.Companion.nextId(realm: Realm): Long {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/database/model/TimelineEventEntity.kt

@@ -29,7 +29,7 @@ internal open class TimelineEventEntity(var localId: Long = 0,
                                         var senderName: String? = null,
                                         var isUniqueDisplayName: Boolean = false,
                                         var senderAvatar: String? = null,
-                                        var senderMembershipEvent: EventEntity? = null,
+                                        var senderMembershipEventId: String? = null,
                                         var readReceipts: ReadReceiptsSummaryEntity? = null
 ) : RealmObject() {
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/database/query/TimelineEventEntityQueries.kt

@@ -54,7 +54,7 @@ internal fun TimelineEventEntity.Companion.where(realm: Realm,
 
 internal fun TimelineEventEntity.Companion.findWithSenderMembershipEvent(realm: Realm, senderMembershipEventId: String): List<TimelineEventEntity> {
     return realm.where<TimelineEventEntity>()
-            .equalTo(TimelineEventEntityFields.SENDER_MEMBERSHIP_EVENT.EVENT_ID, senderMembershipEventId)
+            .equalTo(TimelineEventEntityFields.SENDER_MEMBERSHIP_EVENT_ID, senderMembershipEventId)
             .findAll()
 }
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/room/timeline/TokenChunkEventPersistor.kt

@@ -149,10 +149,8 @@ internal class TokenChunkEventPersistor @Inject constructor(private val monarchy
                         currentChunk.isLastBackward = true
                     } else if (!shouldSkip) {
                         Timber.v("Add ${receivedChunk.events.size} events in chunk(${currentChunk.nextToken} | ${currentChunk.prevToken}")
-                        val eventIds = ArrayList<String>(receivedChunk.events.size)
-                        for (event in receivedChunk.events) {
-                            event.eventId?.also { eventIds.add(it) }
-                            currentChunk.add(roomId, event, direction, isUnlinked = currentChunk.isUnlinked())
+                        val timelineEvents = receivedChunk.events.mapNotNull {
+                            currentChunk.add(roomId, it, direction, isUnlinked = currentChunk.isUnlinked())
                         }
                         // Then we merge chunks if needed
                         if (currentChunk != prevChunk && prevChunk != null) {
@@ -172,7 +170,7 @@ internal class TokenChunkEventPersistor @Inject constructor(private val monarchy
                         for (stateEvent in receivedChunk.stateEvents) {
                             roomEntity.addStateEvent(stateEvent, isUnlinked = currentChunk.isUnlinked())
                         }
-                        currentChunk.updateSenderDataFor(eventIds)
+                        currentChunk.updateSenderDataFor(timelineEvents)
                     }
                 }
         return if (receivedChunk.events.isEmpty()) {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/RoomSyncHandler.kt

@@ -27,6 +27,7 @@ import im.vector.matrix.android.internal.database.helper.*
 import im.vector.matrix.android.internal.database.model.ChunkEntity
 import im.vector.matrix.android.internal.database.model.EventEntityFields
 import im.vector.matrix.android.internal.database.model.RoomEntity
+import im.vector.matrix.android.internal.database.model.TimelineEventEntity
 import im.vector.matrix.android.internal.database.query.find
 import im.vector.matrix.android.internal.database.query.findLastLiveChunkFromRoom
 import im.vector.matrix.android.internal.database.query.where
@@ -189,10 +190,11 @@ internal class RoomSyncHandler @Inject constructor(private val readReceiptHandle
         lastChunk?.isLastForward = false
         chunkEntity.isLastForward = true
 
-        val eventIds = ArrayList<String>(eventList.size)
+        val timelineEvents = ArrayList<TimelineEventEntity>(eventList.size)
         for (event in eventList) {
-            event.eventId?.also { eventIds.add(it) }
-            chunkEntity.add(roomEntity.roomId, event, PaginationDirection.FORWARDS, stateIndexOffset)
+            chunkEntity.add(roomEntity.roomId, event, PaginationDirection.FORWARDS, stateIndexOffset)?.also {
+                timelineEvents.add(it)
+            }
             // Give info to crypto module
             cryptoService.onLiveEvent(roomEntity.roomId, event)
             // Try to remove local echo
@@ -207,7 +209,7 @@ internal class RoomSyncHandler @Inject constructor(private val readReceiptHandle
             }
             roomMemberEventHandler.handle(realm, roomEntity.roomId, event)
         }
-        chunkEntity.updateSenderDataFor(eventIds)
+        chunkEntity.updateSenderDataFor(timelineEvents)
         return chunkEntity
     }