Update dependency org.matrix.rustcomponents:sdk-android to v0.2.41 (#3384)

* Introduce value class UniqueId.

* Allow reactions on non-sent Event, the SDK can now handle it.

Also the SDK will manage local echo for reactions.

* Update dependency org.matrix.rustcomponents:sdk-android to v0.2.41

* Fixes after SDK upgrade:

- Use `ClientBuilderSlidingSync` to set `SlidingSyncVersionBuilder` in `RustMatrixClientFactory`.
- `Room.toggleReaction(emoji: String, eventId: EventId)` is now `Room.toggleReaction(emoji: String, uniqueId: UniqueId)`, since reactions can now be applied to local echoes too in the SDK.

* Rename exception case

* Fix wrong error case being used in test

---------

Co-authored-by: Benoit Marty <benoit@matrix.org>
Co-authored-by: Benoit Marty <benoitm@matrix.org>
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Jorge Martín <jorgem@element.io>

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClientFactory.kt

@@ -16,6 +16,7 @@
 
 package io.element.android.libraries.matrix.impl
 
+import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.di.CacheDirectory
 import io.element.android.libraries.matrix.impl.analytics.UtdTracker
@@ -34,6 +35,8 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.ClientBuilder
 import org.matrix.rustcomponents.sdk.Session
+import org.matrix.rustcomponents.sdk.SlidingSyncVersion
+import org.matrix.rustcomponents.sdk.SlidingSyncVersionBuilder
 import org.matrix.rustcomponents.sdk.use
 import timber.log.Timber
 import java.io.File
@@ -56,11 +59,11 @@ class RustMatrixClientFactory @Inject constructor(
         val client = getBaseClientBuilder(
             sessionPaths = sessionData.getSessionPaths(),
             passphrase = sessionData.passphrase,
-            slidingSync = if (appPreferencesStore.isSimplifiedSlidingSyncEnabledFlow().first()) {
-                ClientBuilderSlidingSync.Simplified
-            } else {
-                ClientBuilderSlidingSync.Restored
-            },
+            slidingSync = when {
+                AuthenticationConfig.SLIDING_SYNC_PROXY_URL != null -> ClientBuilderSlidingSync.CustomProxy(AuthenticationConfig.SLIDING_SYNC_PROXY_URL!!)
+                appPreferencesStore.isSimplifiedSlidingSyncEnabledFlow().first() -> ClientBuilderSlidingSync.Simplified
+                else -> ClientBuilderSlidingSync.Restored
+            }
         )
             .homeserverUrl(sessionData.homeserverUrl)
             .username(sessionData.userId)
@@ -91,7 +94,6 @@ class RustMatrixClientFactory @Inject constructor(
     internal fun getBaseClientBuilder(
         sessionPaths: SessionPaths,
         passphrase: String?,
-        slidingSyncProxy: String? = null,
         slidingSync: ClientBuilderSlidingSync,
     ): ClientBuilder {
         return ClientBuilder()
@@ -100,16 +102,17 @@ class RustMatrixClientFactory @Inject constructor(
                 cachePath = sessionPaths.cacheDirectory.absolutePath,
             )
             .passphrase(passphrase)
-            .slidingSyncProxy(slidingSyncProxy)
             .userAgent(userAgentProvider.provide())
             .addRootCertificates(userCertificatesProvider.provides())
             .autoEnableBackups(true)
             .autoEnableCrossSigning(true)
             .run {
+                // Apply sliding sync version settings
                 when (slidingSync) {
                     ClientBuilderSlidingSync.Restored -> this
-                    ClientBuilderSlidingSync.Discovered -> requiresSlidingSync()
-                    ClientBuilderSlidingSync.Simplified -> simplifiedSlidingSync(true)
+                    is ClientBuilderSlidingSync.CustomProxy -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.Proxy(slidingSync.url))
+                    ClientBuilderSlidingSync.Discovered -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.DiscoverProxy)
+                    ClientBuilderSlidingSync.Simplified -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.Native)
                 }
             }
             .run {
@@ -119,15 +122,18 @@ class RustMatrixClientFactory @Inject constructor(
     }
 }
 
-enum class ClientBuilderSlidingSync {
+sealed interface ClientBuilderSlidingSync {
+    // The proxy is set by the user.
+    data class CustomProxy(val url: String) : ClientBuilderSlidingSync
+
     // The proxy will be supplied when restoring the Session.
-    Restored,
+    data object Restored : ClientBuilderSlidingSync
 
     // A proxy must be discovered whilst building the session.
-    Discovered,
+    data object Discovered : ClientBuilderSlidingSync
 
     // Use Simplified Sliding Sync (discovery isn't a thing yet).
-    Simplified,
+    data object Simplified : ClientBuilderSlidingSync
 }
 
 private fun SessionData.toSession() = Session(
@@ -136,6 +142,6 @@ private fun SessionData.toSession() = Session(
     userId = userId,
     deviceId = deviceId,
     homeserverUrl = homeserverUrl,
-    slidingSyncProxy = slidingSyncProxy,
+    slidingSyncVersion = slidingSyncProxy?.let(SlidingSyncVersion::Proxy) ?: SlidingSyncVersion.Native,
     oidcData = oidcData,
 )

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/auth/AuthenticationException.kt

@@ -24,7 +24,7 @@ fun Throwable.mapAuthenticationException(): AuthenticationException {
     return when (this) {
         is RustAuthenticationException.Generic -> AuthenticationException.Generic(message)
         is RustAuthenticationException.InvalidServerName -> AuthenticationException.InvalidServerName(message)
-        is RustAuthenticationException.SlidingSyncNotAvailable -> AuthenticationException.SlidingSyncNotAvailable(message)
+        is RustAuthenticationException.SlidingSyncVersion -> AuthenticationException.SlidingSyncVersion(message)
         else -> AuthenticationException.Generic(message)
     }
 }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/auth/RustMatrixAuthenticationService.kt

@@ -17,7 +17,6 @@
 package io.element.android.libraries.matrix.impl.auth
 
 import com.squareup.anvil.annotations.ContributesBinding
-import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.core.extensions.mapFailure
 import io.element.android.libraries.di.AppScope
@@ -223,7 +222,6 @@ class RustMatrixAuthenticationService @Inject constructor(
                 val client = rustMatrixClientFactory.getBaseClientBuilder(
                     sessionPaths = emptySessionPaths,
                     passphrase = pendingPassphrase,
-                    slidingSyncProxy = AuthenticationConfig.SLIDING_SYNC_PROXY_URL,
                     slidingSync = ClientBuilderSlidingSync.Discovered,
                 )
                     .buildWithQrCode(
@@ -267,7 +265,6 @@ class RustMatrixAuthenticationService @Inject constructor(
         .getBaseClientBuilder(
             sessionPaths = sessionPaths,
             passphrase = pendingPassphrase,
-            slidingSyncProxy = AuthenticationConfig.SLIDING_SYNC_PROXY_URL,
             slidingSync = ClientBuilderSlidingSync.Discovered,
         )
 

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/mapper/Session.kt

@@ -20,6 +20,7 @@ import io.element.android.libraries.matrix.impl.paths.SessionPaths
 import io.element.android.libraries.sessionstorage.api.LoginType
 import io.element.android.libraries.sessionstorage.api.SessionData
 import org.matrix.rustcomponents.sdk.Session
+import org.matrix.rustcomponents.sdk.SlidingSyncVersion
 import java.util.Date
 
 internal fun Session.toSessionData(
@@ -35,7 +36,7 @@ internal fun Session.toSessionData(
     refreshToken = refreshToken,
     homeserverUrl = homeserverUrl ?: this.homeserverUrl,
     oidcData = oidcData,
-    slidingSyncProxy = slidingSyncProxy,
+    slidingSyncProxy = (slidingSyncVersion as? SlidingSyncVersion.Proxy)?.url,
     loginTimestamp = Date(),
     isTokenValid = isTokenValid,
     loginType = loginType,

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/RustMatrixRoom.kt

@@ -25,6 +25,7 @@ import io.element.android.libraries.matrix.api.core.RoomAlias
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.TransactionId
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.media.AudioInfo
 import io.element.android.libraries.matrix.api.media.FileInfo
@@ -459,8 +460,8 @@ class RustMatrixRoom(
         return liveTimeline.sendFile(file, fileInfo, progressCallback)
     }
 
-    override suspend fun toggleReaction(emoji: String, eventId: EventId): Result<Unit> {
-        return liveTimeline.toggleReaction(emoji, eventId)
+    override suspend fun toggleReaction(emoji: String, uniqueId: UniqueId): Result<Unit> {
+        return liveTimeline.toggleReaction(emoji, uniqueId)
     }
 
     override suspend fun forwardEvent(eventId: EventId, roomIds: List<RoomId>): Result<Unit> {

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/MatrixTimelineItemMapper.kt

@@ -17,6 +17,7 @@
 package io.element.android.libraries.matrix.impl.timeline
 
 import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.impl.timeline.item.event.EventTimelineItemMapper
 import io.element.android.libraries.matrix.impl.timeline.item.virtual.VirtualTimelineItemMapper
@@ -31,7 +32,7 @@ class MatrixTimelineItemMapper(
     private val eventTimelineItemMapper: EventTimelineItemMapper = EventTimelineItemMapper(),
 ) {
     fun map(timelineItem: TimelineItem): MatrixTimelineItem = timelineItem.use {
-        val uniqueId = timelineItem.uniqueId()
+        val uniqueId = UniqueId(timelineItem.uniqueId())
         val asEvent = it.asEvent()
         if (asEvent != null) {
             val eventTimelineItem = eventTimelineItemMapper.map(asEvent)

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/RustTimeline.kt

@@ -20,6 +20,7 @@ import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.ProgressCallback
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.TransactionId
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.media.AudioInfo
 import io.element.android.libraries.matrix.api.media.FileInfo
 import io.element.android.libraries.matrix.api.media.ImageInfo
@@ -391,9 +392,9 @@ class RustTimeline(
         }
     }
 
-    override suspend fun toggleReaction(emoji: String, eventId: EventId): Result<Unit> = withContext(dispatcher) {
+    override suspend fun toggleReaction(emoji: String, uniqueId: UniqueId): Result<Unit> = withContext(dispatcher) {
         runCatching {
-            inner.toggleReaction(key = emoji, eventId = eventId.value)
+            inner.toggleReaction(key = emoji, uniqueId = uniqueId.value)
         }
     }
 

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/LastForwardIndicatorsPostProcessor.kt

@@ -16,6 +16,7 @@
 
 package io.element.android.libraries.matrix.impl.timeline.postprocessor
 
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTimelineItem
 
@@ -25,7 +26,7 @@ import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTime
 class LastForwardIndicatorsPostProcessor(
     private val isTimelineLive: Boolean,
 ) {
-    private val lastForwardIdentifiers = LinkedHashSet<String>()
+    private val lastForwardIdentifiers = LinkedHashSet<UniqueId>()
 
     fun process(
         items: List<MatrixTimelineItem>,
@@ -56,17 +57,17 @@ class LastForwardIndicatorsPostProcessor(
     }
 }
 
-private fun createLastForwardIndicator(identifier: String): MatrixTimelineItem {
+private fun createLastForwardIndicator(identifier: UniqueId): MatrixTimelineItem {
     return MatrixTimelineItem.Virtual(
-        uniqueId = "last_forward_indicator_$identifier",
+        uniqueId = UniqueId("last_forward_indicator_$identifier"),
         virtual = VirtualTimelineItem.LastForwardIndicator
     )
 }
 
-private fun List<MatrixTimelineItem>.latestEventIdentifier(): String {
+private fun List<MatrixTimelineItem>.latestEventIdentifier(): UniqueId {
     return findLast {
         it is MatrixTimelineItem.Event
     }?.let {
         (it as MatrixTimelineItem.Event).uniqueId
-    } ?: "fake_id"
+    } ?: UniqueId("fake_id")
 }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/LoadingIndicatorsPostProcessor.kt

@@ -16,6 +16,7 @@
 
 package io.element.android.libraries.matrix.impl.timeline.postprocessor
 
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTimelineItem
@@ -33,7 +34,7 @@ class LoadingIndicatorsPostProcessor(private val systemClock: SystemClock) {
         return buildList {
             if (shouldAddBackwardLoadingIndicator) {
                 val backwardLoadingIndicator = MatrixTimelineItem.Virtual(
-                    uniqueId = "BackwardLoadingIndicator",
+                    uniqueId = UniqueId("BackwardLoadingIndicator"),
                     virtual = VirtualTimelineItem.LoadingIndicator(
                         direction = Timeline.PaginationDirection.BACKWARDS,
                         timestamp = currentTimestamp
@@ -44,7 +45,7 @@ class LoadingIndicatorsPostProcessor(private val systemClock: SystemClock) {
             addAll(items)
             if (shouldAddForwardLoadingIndicator) {
                 val forwardLoadingIndicator = MatrixTimelineItem.Virtual(
-                    uniqueId = "ForwardLoadingIndicator",
+                    uniqueId = UniqueId("ForwardLoadingIndicator"),
                     virtual = VirtualTimelineItem.LoadingIndicator(
                         direction = Timeline.PaginationDirection.FORWARDS,
                         timestamp = currentTimestamp

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/RoomBeginningPostProcessor.kt

@@ -17,6 +17,7 @@
 package io.element.android.libraries.matrix.impl.timeline.postprocessor
 
 import androidx.annotation.VisibleForTesting
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.event.MembershipChange
 import io.element.android.libraries.matrix.api.timeline.item.event.OtherState
@@ -77,7 +78,7 @@ class RoomBeginningPostProcessor {
     @VisibleForTesting
     fun createRoomBeginningItem(): MatrixTimelineItem.Virtual {
         return MatrixTimelineItem.Virtual(
-            uniqueId = VirtualTimelineItem.RoomBeginning.toString(),
+            uniqueId = UniqueId("RoomBeginning"),
             virtual = VirtualTimelineItem.RoomBeginning
         )
     }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/TimelineEncryptedHistoryPostProcessor.kt

@@ -16,6 +16,7 @@
 
 package io.element.android.libraries.matrix.impl.timeline.postprocessor
 
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTimelineItem
 import kotlinx.coroutines.CoroutineDispatcher
@@ -23,6 +24,8 @@ import kotlinx.coroutines.withContext
 import timber.log.Timber
 import java.util.Date
 
+internal val encryptedHistoryBannerId = UniqueId("EncryptedHistoryBannerId")
+
 class TimelineEncryptedHistoryPostProcessor(
     private val dispatcher: CoroutineDispatcher,
     private val lastLoginTimestamp: Date?,
@@ -44,7 +47,7 @@ class TimelineEncryptedHistoryPostProcessor(
         }
         return if (lastEncryptedHistoryBannerIndex >= 0) {
             val sublist = list.drop(lastEncryptedHistoryBannerIndex + 1).toMutableList()
-            sublist.add(0, MatrixTimelineItem.Virtual(VirtualTimelineItem.EncryptedHistoryBanner.toString(), VirtualTimelineItem.EncryptedHistoryBanner))
+            sublist.add(0, MatrixTimelineItem.Virtual(encryptedHistoryBannerId, VirtualTimelineItem.EncryptedHistoryBanner))
             sublist
         } else {
             list

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/auth/AuthenticationExceptionMappingTest.kt

@@ -48,8 +48,8 @@ class AuthenticationExceptionMappingTest {
         assertThat(ClientBuildException.Sdk("SDK issue").mapAuthenticationException())
             .isException<AuthenticationException.Generic>("SDK issue")
 
-        assertThat(ClientBuildException.SlidingSyncNotAvailable("Sliding sync not available").mapAuthenticationException())
-            .isException<AuthenticationException.SlidingSyncNotAvailable>("Sliding sync not available")
+        assertThat(ClientBuildException.SlidingSyncVersion("Sliding sync not available").mapAuthenticationException())
+            .isException<AuthenticationException.SlidingSyncVersion>("Sliding sync not available")
     }
 
     private inline fun <reified T> ThrowableSubject.isException(message: String) {

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/RoomBeginningPostProcessorTest.kt

@@ -17,6 +17,7 @@
 package io.element.android.libraries.matrix.impl.timeline.postprocessor
 
 import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.event.MembershipChange
 import io.element.android.libraries.matrix.api.timeline.item.event.OtherState
@@ -33,8 +34,8 @@ class RoomBeginningPostProcessorTest {
     @Test
     fun `processor removes room creation event and self-join event from DM timeline`() {
         val timelineItems = listOf(
-            MatrixTimelineItem.Event("m.room.create", anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
-            MatrixTimelineItem.Event("m.room.member", anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
+            MatrixTimelineItem.Event(UniqueId("m.room.create"), anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
+            MatrixTimelineItem.Event(UniqueId("m.room.member"), anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
         )
         val processor = RoomBeginningPostProcessor()
         val processedItems = processor.process(timelineItems, isDm = true, hasMoreToLoadBackwards = false)
@@ -44,14 +45,20 @@ class RoomBeginningPostProcessorTest {
     @Test
     fun `processor removes room creation event and self-join event from DM timeline even if they're not the first items`() {
         val timelineItems = listOf(
-            MatrixTimelineItem.Event("m.room.member_other", anEventTimelineItem(content = RoomMembershipContent(A_USER_ID_2, null, MembershipChange.JOINED))),
-            MatrixTimelineItem.Event("m.room.create", anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
-            MatrixTimelineItem.Event("m.room.message", anEventTimelineItem(content = aMessageContent("hi"))),
-            MatrixTimelineItem.Event("m.room.member", anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
+            MatrixTimelineItem.Event(
+                UniqueId("m.room.member_other"),
+                anEventTimelineItem(content = RoomMembershipContent(A_USER_ID_2, null, MembershipChange.JOINED))
+            ),
+            MatrixTimelineItem.Event(UniqueId("m.room.create"), anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
+            MatrixTimelineItem.Event(UniqueId("m.room.message"), anEventTimelineItem(content = aMessageContent("hi"))),
+            MatrixTimelineItem.Event(UniqueId("m.room.member"), anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
         )
         val expected = listOf(
-            MatrixTimelineItem.Event("m.room.member_other", anEventTimelineItem(content = RoomMembershipContent(A_USER_ID_2, null, MembershipChange.JOINED))),
-            MatrixTimelineItem.Event("m.room.message", anEventTimelineItem(content = aMessageContent("hi"))),
+            MatrixTimelineItem.Event(
+                UniqueId("m.room.member_other"),
+                anEventTimelineItem(content = RoomMembershipContent(A_USER_ID_2, null, MembershipChange.JOINED))
+            ),
+            MatrixTimelineItem.Event(UniqueId("m.room.message"), anEventTimelineItem(content = aMessageContent("hi"))),
         )
         val processor = RoomBeginningPostProcessor()
         val processedItems = processor.process(timelineItems, isDm = true, hasMoreToLoadBackwards = false)
@@ -61,8 +68,8 @@ class RoomBeginningPostProcessorTest {
     @Test
     fun `processor will add beginning of room item if it's not a DM`() {
         val timelineItems = listOf(
-            MatrixTimelineItem.Event("m.room.create", anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
-            MatrixTimelineItem.Event("m.room.member", anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
+            MatrixTimelineItem.Event(UniqueId("m.room.create"), anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
+            MatrixTimelineItem.Event(UniqueId("m.room.member"), anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
         )
         val processor = RoomBeginningPostProcessor()
         val processedItems = processor.process(timelineItems, isDm = false, hasMoreToLoadBackwards = false)
@@ -74,7 +81,7 @@ class RoomBeginningPostProcessorTest {
     @Test
     fun `processor will not add beginning of room item if it's not a DM and EncryptedHistoryBanner item is found`() {
         val timelineItems = listOf(
-            MatrixTimelineItem.Virtual("EncryptedHistoryBanner", VirtualTimelineItem.EncryptedHistoryBanner),
+            MatrixTimelineItem.Virtual(UniqueId("EncryptedHistoryBanner"), VirtualTimelineItem.EncryptedHistoryBanner),
         )
         val processor = RoomBeginningPostProcessor()
         val processedItems = processor.process(timelineItems, isDm = false, hasMoreToLoadBackwards = false)
@@ -84,8 +91,8 @@ class RoomBeginningPostProcessorTest {
     @Test
     fun `processor won't remove items if it's not at the start of the timeline`() {
         val timelineItems = listOf(
-            MatrixTimelineItem.Event("m.room.create", anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
-            MatrixTimelineItem.Event("m.room.member", anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
+            MatrixTimelineItem.Event(UniqueId("m.room.create"), anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
+            MatrixTimelineItem.Event(UniqueId("m.room.member"), anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
         )
         val processor = RoomBeginningPostProcessor()
         val processedItems = processor.process(timelineItems, isDm = true, hasMoreToLoadBackwards = true)
@@ -95,7 +102,7 @@ class RoomBeginningPostProcessorTest {
     @Test
     fun `processor won't remove the first member join event if it can't find the room creation event`() {
         val timelineItems = listOf(
-            MatrixTimelineItem.Event("m.room.member", anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
+            MatrixTimelineItem.Event(UniqueId("m.room.member"), anEventTimelineItem(content = RoomMembershipContent(A_USER_ID, null, MembershipChange.JOINED))),
         )
         val processor = RoomBeginningPostProcessor()
         val processedItems = processor.process(timelineItems, isDm = true, hasMoreToLoadBackwards = true)
@@ -105,8 +112,11 @@ class RoomBeginningPostProcessorTest {
     @Test
     fun `processor won't remove the first member join event if it's not from the room creator`() {
         val timelineItems = listOf(
-            MatrixTimelineItem.Event("m.room.create", anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
-            MatrixTimelineItem.Event("m.room.member", anEventTimelineItem(content = RoomMembershipContent(A_USER_ID_2, null, MembershipChange.JOINED))),
+            MatrixTimelineItem.Event(UniqueId("m.room.create"), anEventTimelineItem(sender = A_USER_ID, content = StateContent("", OtherState.RoomCreate))),
+            MatrixTimelineItem.Event(
+                UniqueId("m.room.member"),
+                anEventTimelineItem(content = RoomMembershipContent(A_USER_ID_2, null, MembershipChange.JOINED))
+            ),
         )
         val processor = RoomBeginningPostProcessor()
         val processedItems = processor.process(timelineItems, isDm = true, hasMoreToLoadBackwards = true)

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/TimelineEncryptedHistoryPostProcessorTest.kt

@@ -19,6 +19,7 @@ package io.element.android.libraries.matrix.impl.timeline.postprocessor
 import com.google.common.truth.Truth.assertThat
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTimelineItem
+import io.element.android.libraries.matrix.test.A_UNIQUE_ID
 import io.element.android.libraries.matrix.test.timeline.anEventTimelineItem
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.TestScope
@@ -26,8 +27,6 @@ import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import java.util.Date
 
-private const val FAKE_UNIQUE_ID = "FAKE_UNIQUE_ID"
-
 class TimelineEncryptedHistoryPostProcessorTest {
     private val defaultLastLoginTimestamp = Date(1_689_061_264L)
 
@@ -35,7 +34,7 @@ class TimelineEncryptedHistoryPostProcessorTest {
     fun `given an unencrypted room, nothing is done`() = runTest {
         val processor = createPostProcessor(isRoomEncrypted = false)
         val items = listOf(
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem())
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem())
         )
         assertThat(processor.process(items)).isSameInstanceAs(items)
     }
@@ -44,7 +43,7 @@ class TimelineEncryptedHistoryPostProcessorTest {
     fun `given an encrypted room, and key backup enabled, nothing is done`() = runTest {
         val processor = createPostProcessor(isKeyBackupEnabled = true)
         val items = listOf(
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem())
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem())
         )
         assertThat(processor.process(items)).isSameInstanceAs(items)
     }
@@ -53,7 +52,7 @@ class TimelineEncryptedHistoryPostProcessorTest {
     fun `given a null lastLoginTimestamp, nothing is done`() = runTest {
         val processor = createPostProcessor(lastLoginTimestamp = null)
         val items = listOf(
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem())
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem())
         )
         assertThat(processor.process(items)).isSameInstanceAs(items)
     }
@@ -69,7 +68,7 @@ class TimelineEncryptedHistoryPostProcessorTest {
     fun `given a list with no items before lastLoginTimestamp, nothing is done`() = runTest {
         val processor = createPostProcessor()
         val items = listOf(
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1))
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1))
         )
         assertThat(processor.process(items)).isSameInstanceAs(items)
     }
@@ -78,20 +77,20 @@ class TimelineEncryptedHistoryPostProcessorTest {
     fun `given a list with an item with equal timestamp as lastLoginTimestamp, it's replaced`() = runTest {
         val processor = createPostProcessor()
         val items = listOf(
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time))
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time))
         )
         assertThat(processor.process(items))
-            .isEqualTo(listOf(MatrixTimelineItem.Virtual(VirtualTimelineItem.EncryptedHistoryBanner.toString(), VirtualTimelineItem.EncryptedHistoryBanner)))
+            .isEqualTo(listOf(MatrixTimelineItem.Virtual(encryptedHistoryBannerId, VirtualTimelineItem.EncryptedHistoryBanner)))
     }
 
     @Test
     fun `given a list with an item with a lower timestamp than lastLoginTimestamp, it's replaced`() = runTest {
         val processor = createPostProcessor()
         val items = listOf(
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time - 1))
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time - 1))
         )
         assertThat(processor.process(items)).isEqualTo(
-            listOf(MatrixTimelineItem.Virtual(VirtualTimelineItem.EncryptedHistoryBanner.toString(), VirtualTimelineItem.EncryptedHistoryBanner))
+            listOf(MatrixTimelineItem.Virtual(encryptedHistoryBannerId, VirtualTimelineItem.EncryptedHistoryBanner))
         )
     }
 
@@ -99,14 +98,14 @@ class TimelineEncryptedHistoryPostProcessorTest {
     fun `given a list with several with lower or equal timestamps than lastLoginTimestamp, then they're replaced`() = runTest {
         val processor = createPostProcessor()
         val items = listOf(
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time - 1)),
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time)),
-            MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1)),
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time - 1)),
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time)),
+            MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1)),
         )
         assertThat(processor.process(items)).isEqualTo(
             listOf(
-                MatrixTimelineItem.Virtual(VirtualTimelineItem.EncryptedHistoryBanner.toString(), VirtualTimelineItem.EncryptedHistoryBanner),
-                MatrixTimelineItem.Event(FAKE_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1))
+                MatrixTimelineItem.Virtual(encryptedHistoryBannerId, VirtualTimelineItem.EncryptedHistoryBanner),
+                MatrixTimelineItem.Event(A_UNIQUE_ID, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1))
             )
         )
     }