Merge branch 'develop' into feature/fga/better_media_handling

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/MatrixClient.kt

@@ -31,9 +31,7 @@ import io.element.android.libraries.matrix.api.sync.SyncService
 import io.element.android.libraries.matrix.api.user.MatrixSearchUserResults
 import io.element.android.libraries.matrix.api.user.MatrixUser
 import io.element.android.libraries.matrix.api.verification.SessionVerificationService
-import kotlinx.coroutines.TimeoutCancellationException
 import java.io.Closeable
-import kotlin.time.Duration
 
 interface MatrixClient : Closeable {
     val sessionId: SessionId

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/MatrixClientProvider.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023 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 io.element.android.libraries.matrix.api
+
+import io.element.android.libraries.matrix.api.core.SessionId
+
+interface MatrixClientProvider {
+    /**
+     * Can be used to get or restore a MatrixClient with the given [SessionId].
+     * If a [MatrixClient] is already in memory, it'll return it. Otherwise it'll try to restore one.
+     * Most of the time you want to use injected constructor instead of retrieving a MatrixClient with this provider.
+     */
+    suspend fun getOrRestore(sessionId: SessionId): Result<MatrixClient>
+}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/core/TransactionId.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 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 io.element.android.libraries.matrix.api.core
+
+import java.io.Serializable
+
+@JvmInline
+value class TransactionId(val value: String) : Serializable {
+    override fun toString(): String = value
+}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/exception/ClientException.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023 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 io.element.android.libraries.matrix.api.exception
+
+sealed class ClientException(message: String) : Exception(message) {
+    class Generic(message: String) : ClientException(message)
+    class Other(message: String) : ClientException(message)
+}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/room/MatrixRoom.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.SessionId
+import io.element.android.libraries.matrix.api.core.TransactionId
 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
@@ -70,7 +71,7 @@ interface MatrixRoom : Closeable {
 
     suspend fun sendMessage(message: String): Result<Unit>
 
-    suspend fun editMessage(originalEventId: EventId?, transactionId: String?, message: String): Result<Unit>
+    suspend fun editMessage(originalEventId: EventId?, transactionId: TransactionId?, message: String): Result<Unit>
 
     suspend fun replyMessage(eventId: EventId, message: String): Result<Unit>
 
@@ -88,9 +89,9 @@ interface MatrixRoom : Closeable {
 
     suspend fun forwardEvent(eventId: EventId, roomIds: List<RoomId>): Result<Unit>
 
-    suspend fun retrySendMessage(transactionId: String): Result<Unit>
+    suspend fun retrySendMessage(transactionId: TransactionId): Result<Unit>
 
-    suspend fun cancelSend(transactionId: String): Result<Unit>
+    suspend fun cancelSend(transactionId: TransactionId): Result<Unit>
 
     suspend fun leave(): Result<Unit>
 

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/MatrixTimelineItem.kt

@@ -17,13 +17,14 @@
 package io.element.android.libraries.matrix.api.timeline
 
 import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.TransactionId
 import io.element.android.libraries.matrix.api.timeline.item.event.EventTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTimelineItem
 
 sealed interface MatrixTimelineItem {
     data class Event(val uniqueId: Long, val event: EventTimelineItem) : MatrixTimelineItem {
         val eventId: EventId? = event.eventId
-        val transactionId: String? = event.transactionId
+        val transactionId: TransactionId? = event.transactionId
     }
 
     data class Virtual(val uniqueId: Long, val virtual: VirtualTimelineItem) : MatrixTimelineItem

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/item/event/EventTimelineItem.kt

@@ -17,12 +17,13 @@
 package io.element.android.libraries.matrix.api.timeline.item.event
 
 import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.TransactionId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.timeline.item.TimelineItemDebugInfo
 
 data class EventTimelineItem(
     val eventId: EventId?,
-    val transactionId: String?,
+    val transactionId: TransactionId?,
     val isEditable: Boolean,
     val isLocal: Boolean,
     val isOwn: Boolean,
@@ -34,6 +35,7 @@ data class EventTimelineItem(
     val timestamp: Long,
     val content: EventContent,
     val debugInfo: TimelineItemDebugInfo,
+    val origin: TimelineItemEventOrigin?,
 ) {
     fun inReplyTo(): InReplyTo? {
         return (content as? MessageContent)?.inReplyTo

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/item/event/TimelineItemEventOrigin.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023 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 io.element.android.libraries.matrix.api.timeline.item.event
+
+enum class TimelineItemEventOrigin {
+    LOCAL, SYNC, PAGINATION;
+}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/item/virtual/VirtualTimelineItem.kt

@@ -24,4 +24,5 @@ sealed interface VirtualTimelineItem {
 
     object ReadMarker : VirtualTimelineItem
 
+    object EncryptedHistoryBanner : VirtualTimelineItem
 }

libraries/matrix/impl/build.gradle.kts

@@ -41,4 +41,8 @@ dependencies {
     implementation("net.java.dev.jna:jna:5.13.0@aar")
     implementation(libs.androidx.datastore.preferences)
     implementation(libs.serialization.json)
+
+    testImplementation(libs.test.junit)
+    testImplementation(libs.test.truth)
+    testImplementation(projects.libraries.matrix.test)
 }

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

@@ -157,6 +157,7 @@ class RustMatrixClient constructor(
             coroutineDispatchers = dispatchers,
             systemClock = clock,
             roomContentForwarder = roomContentForwarder,
+            sessionData = sessionStore.getSession(sessionId.value)!!,
         )
     }
 
@@ -164,8 +165,10 @@ class RustMatrixClient constructor(
         val cachedRoomListItem = roomListService.roomOrNull(roomId.value)
         val fullRoom = cachedRoomListItem?.fullRoom()
         if (cachedRoomListItem == null || fullRoom == null) {
+            Timber.d("No room cached for $roomId")
             null
         } else {
+            Timber.d("Found room cached for $roomId")
             Pair(cachedRoomListItem, fullRoom)
         }
     }

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

@@ -19,7 +19,7 @@ package io.element.android.libraries.matrix.impl.auth
 import io.element.android.libraries.matrix.api.auth.AuthenticationException
 import org.matrix.rustcomponents.sdk.AuthenticationException as RustAuthenticationException
 
-fun Throwable.mapAuthenticationException(): Throwable {
+fun Throwable.mapAuthenticationException(): AuthenticationException {
     return when (this) {
         is RustAuthenticationException.ClientMissing -> AuthenticationException.ClientMissing(this.message!!)
         is RustAuthenticationException.Generic -> AuthenticationException.Generic(this.message!!)
@@ -35,6 +35,6 @@ fun Throwable.mapAuthenticationException(): Throwable {
         is RustAuthenticationException.OidcNotSupported -> AuthenticationException.OidcError("OidcNotSupported", message!!)
          */
 
-        else -> this
+        else -> AuthenticationException.Generic(this.message ?: "Unknown error")
     }
 }

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

@@ -29,6 +29,7 @@ import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
 import io.element.android.libraries.matrix.api.auth.OidcDetails
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.impl.RustMatrixClient
+import io.element.android.libraries.matrix.impl.exception.mapClientException
 import io.element.android.libraries.network.useragent.UserAgentProvider
 import io.element.android.libraries.sessionstorage.api.SessionData
 import io.element.android.libraries.sessionstorage.api.SessionStore
@@ -45,6 +46,7 @@ import org.matrix.rustcomponents.sdk.ClientBuilder
 import org.matrix.rustcomponents.sdk.Session
 import org.matrix.rustcomponents.sdk.use
 import java.io.File
+import java.util.Date
 import javax.inject.Inject
 import org.matrix.rustcomponents.sdk.AuthenticationService as RustAuthenticationService
 
@@ -94,7 +96,7 @@ class RustMatrixAuthenticationService @Inject constructor(
                 throw IllegalStateException("No session to restore with id $sessionId")
             }
         }.mapFailure { failure ->
-            failure.mapAuthenticationException()
+            failure.mapClientException()
         }
     }
 
@@ -208,4 +210,5 @@ private fun Session.toSessionData() = SessionData(
     refreshToken = refreshToken,
     homeserverUrl = homeserverUrl,
     slidingSyncProxy = slidingSyncProxy,
+    loginTimestamp = Date(),
 )

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2023 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 io.element.android.libraries.matrix.impl.exception
+
+import io.element.android.libraries.matrix.api.exception.ClientException
+import org.matrix.rustcomponents.sdk.ClientException as RustClientException
+
+fun Throwable.mapClientException(): ClientException {
+    return when (this) {
+        is RustClientException.Generic -> ClientException.Generic(msg)
+        else -> ClientException.Other(message ?: "Unknown error")
+    }
+}

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

@@ -22,6 +22,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.SessionId
+import io.element.android.libraries.matrix.api.core.TransactionId
 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
@@ -41,6 +42,8 @@ import io.element.android.libraries.matrix.impl.room.location.toInner
 import io.element.android.libraries.matrix.impl.timeline.RustMatrixTimeline
 import io.element.android.libraries.matrix.impl.timeline.backPaginationStatusFlow
 import io.element.android.libraries.matrix.impl.timeline.timelineDiffFlow
+import io.element.android.libraries.sessionstorage.api.SessionData
+import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.services.toolbox.api.systemclock.SystemClock
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -72,6 +75,7 @@ class RustMatrixRoom(
     private val coroutineDispatchers: CoroutineDispatchers,
     private val systemClock: SystemClock,
     private val roomContentForwarder: RoomContentForwarder,
+    private val sessionData: SessionData,
 ) : MatrixRoom {
 
     override val roomId = RoomId(innerRoom.id())
@@ -90,7 +94,8 @@ class RustMatrixRoom(
             matrixRoom = this,
             innerRoom = innerRoom,
             roomCoroutineScope = roomCoroutineScope,
-            dispatcher = roomDispatcher
+            dispatcher = roomDispatcher,
+            lastLoginTimestamp = sessionData.loginTimestamp,
         )
     }
 
@@ -218,10 +223,10 @@ class RustMatrixRoom(
         }
     }
 
-    override suspend fun editMessage(originalEventId: EventId?, transactionId: String?, message: String): Result<Unit> = withContext(roomDispatcher) {
+    override suspend fun editMessage(originalEventId: EventId?, transactionId: TransactionId?, message: String): Result<Unit> = withContext(roomDispatcher) {
         if (originalEventId != null) {
             runCatching {
-                innerRoom.edit(/* TODO use content */ message, originalEventId.value, transactionId)
+                innerRoom.edit(/* TODO use content */ message, originalEventId.value, transactionId?.value)
             }
         } else {
             runCatching {
@@ -326,17 +331,17 @@ class RustMatrixRoom(
         }
     }
 
-    override suspend fun retrySendMessage(transactionId: String): Result<Unit> =
+    override suspend fun retrySendMessage(transactionId: TransactionId): Result<Unit> =
         withContext(roomDispatcher) {
             runCatching {
-                innerRoom.retrySend(transactionId)
+                innerRoom.retrySend(transactionId.value)
             }
         }
 
-    override suspend fun cancelSend(transactionId: String): Result<Unit> =
+    override suspend fun cancelSend(transactionId: TransactionId): Result<Unit> =
         withContext(roomDispatcher) {
             runCatching {
-                innerRoom.cancelSend(transactionId)
+                innerRoom.cancelSend(transactionId.value)
             }
         }
 

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

@@ -21,19 +21,23 @@ import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.timeline.MatrixTimeline
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.TimelineException
+import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTimelineItem
 import io.element.android.libraries.matrix.impl.timeline.item.event.EventMessageMapper
 import io.element.android.libraries.matrix.impl.timeline.item.event.EventTimelineItemMapper
 import io.element.android.libraries.matrix.impl.timeline.item.event.TimelineEventContentMapper
 import io.element.android.libraries.matrix.impl.timeline.item.virtual.VirtualTimelineItemMapper
 import kotlinx.coroutines.CompletableDeferred
+import io.element.android.libraries.matrix.impl.timeline.postprocessor.TimelineEncryptedHistoryPostProcessor
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.getAndUpdate
+import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.sample
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.BackPaginationStatus
@@ -43,6 +47,7 @@ import org.matrix.rustcomponents.sdk.TimelineDiff
 import org.matrix.rustcomponents.sdk.TimelineItem
 import timber.log.Timber
 import java.util.concurrent.atomic.AtomicBoolean
+import java.util.Date
 
 private const val INITIAL_MAX_SIZE = 50
 
@@ -51,6 +56,7 @@ class RustMatrixTimeline(
     private val matrixRoom: MatrixRoom,
     private val innerRoom: Room,
     private val dispatcher: CoroutineDispatcher,
+    private val lastLoginTimestamp: Date?,
 ) : MatrixTimeline {
 
     private val initLatch = CompletableDeferred<Unit>()
@@ -63,6 +69,12 @@ class RustMatrixTimeline(
         MatrixTimeline.PaginationState(hasMoreToLoadBackwards = true, isBackPaginating = false)
     )
 
+    private val encryptedHistoryPostProcessor = TimelineEncryptedHistoryPostProcessor(
+        lastLoginTimestamp = lastLoginTimestamp,
+        isRoomEncrypted = matrixRoom.isEncrypted,
+        paginationStateFlow = _paginationState,
+    )
+
     private val timelineItemFactory = MatrixTimelineItemMapper(
         fetchDetailsForEvent = this::fetchDetailsForEvent,
         roomCoroutineScope = roomCoroutineScope,
@@ -81,8 +93,11 @@ class RustMatrixTimeline(
 
     override val paginationState: StateFlow<MatrixTimeline.PaginationState> = _paginationState.asStateFlow()
 
-    @OptIn(FlowPreview::class)
+    @OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
     override val timelineItems: Flow<List<MatrixTimelineItem>> = _timelineItems.sample(50)
+        .mapLatest { items ->
+            encryptedHistoryPostProcessor.process(items)
+        }
 
     internal suspend fun postItems(items: List<TimelineItem>) {
         // Split the initial items in multiple list as there is no pagination in the cached data, so we can post timelineItems asap.
@@ -100,6 +115,12 @@ class RustMatrixTimeline(
 
     internal fun postPaginationStatus(status: BackPaginationStatus) {
         _paginationState.getAndUpdate { currentPaginationState ->
+            if (hasEncryptionHistoryBanner()) {
+                return@getAndUpdate currentPaginationState.copy(
+                    isBackPaginating = false,
+                    hasMoreToLoadBackwards = false,
+                )
+            }
             when (status) {
                 BackPaginationStatus.IDLE -> {
                     currentPaginationState.copy(
@@ -159,4 +180,10 @@ class RustMatrixTimeline(
     fun getItemById(eventId: EventId): MatrixTimelineItem.Event? {
         return _timelineItems.value.firstOrNull { (it as? MatrixTimelineItem.Event)?.eventId == eventId } as? MatrixTimelineItem.Event
     }
+
+    private fun hasEncryptionHistoryBanner(): Boolean {
+        val firstItem = _timelineItems.value.firstOrNull()
+        return firstItem is MatrixTimelineItem.Virtual
+            && firstItem.virtual is VirtualTimelineItem.EncryptedHistoryBanner
+    }
 }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/item/event/EventTimelineItemMapper.kt

@@ -17,13 +17,16 @@
 package io.element.android.libraries.matrix.impl.timeline.item.event
 
 import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.TransactionId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.timeline.item.TimelineItemDebugInfo
+import io.element.android.libraries.matrix.api.timeline.item.event.TimelineItemEventOrigin
 import io.element.android.libraries.matrix.api.timeline.item.event.EventReaction
 import io.element.android.libraries.matrix.api.timeline.item.event.EventTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.event.LocalEventSendState
 import io.element.android.libraries.matrix.api.timeline.item.event.ProfileTimelineDetails
 import org.matrix.rustcomponents.sdk.Reaction
+import org.matrix.rustcomponents.sdk.EventItemOrigin as RustEventItemOrigin
 import org.matrix.rustcomponents.sdk.EventSendState as RustEventSendState
 import org.matrix.rustcomponents.sdk.EventTimelineItem as RustEventTimelineItem
 import org.matrix.rustcomponents.sdk.EventTimelineItemDebugInfo as RustEventTimelineItemDebugInfo
@@ -34,7 +37,7 @@ class EventTimelineItemMapper(private val contentMapper: TimelineEventContentMap
     fun map(eventTimelineItem: RustEventTimelineItem): EventTimelineItem = eventTimelineItem.use {
         EventTimelineItem(
             eventId = it.eventId()?.let(::EventId),
-            transactionId = it.transactionId(),
+            transactionId = it.transactionId()?.let(::TransactionId),
             isEditable = it.isEditable(),
             isLocal = it.isLocal(),
             isOwn = it.isOwn(),
@@ -46,6 +49,7 @@ class EventTimelineItemMapper(private val contentMapper: TimelineEventContentMap
             timestamp = it.timestamp().toLong(),
             content = contentMapper.map(it.content()),
             debugInfo = it.debugInfo().map(),
+            origin = it.origin()?.map()
         )
     }
 }
@@ -90,3 +94,11 @@ private fun RustEventTimelineItemDebugInfo.map(): TimelineItemDebugInfo {
         latestEditedJson = latestEditJson,
     )
 }
+
+private fun RustEventItemOrigin.map(): TimelineItemEventOrigin {
+    return when (this) {
+        RustEventItemOrigin.LOCAL -> TimelineItemEventOrigin.LOCAL
+        RustEventItemOrigin.SYNC -> TimelineItemEventOrigin.SYNC
+        RustEventItemOrigin.PAGINATION -> TimelineItemEventOrigin.PAGINATION
+    }
+}

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2023 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 io.element.android.libraries.matrix.impl.timeline.postprocessor
+
+import io.element.android.libraries.matrix.api.timeline.MatrixTimeline
+import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
+import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTimelineItem
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.getAndUpdate
+import java.util.Date
+import java.util.UUID
+
+class TimelineEncryptedHistoryPostProcessor(
+    private val lastLoginTimestamp: Date?,
+    private val isRoomEncrypted: Boolean,
+    private val paginationStateFlow: MutableStateFlow<MatrixTimeline.PaginationState>,
+) {
+
+    fun process(items: List<MatrixTimelineItem>): List<MatrixTimelineItem> {
+        if (!isRoomEncrypted || lastLoginTimestamp == null) return items
+
+        val filteredItems = replaceWithEncryptionHistoryBannerIfNeeded(items)
+        // Disable back pagination
+        val wasFiltered = filteredItems !== items
+        if (wasFiltered) {
+            paginationStateFlow.getAndUpdate {
+                it.copy(
+                    isBackPaginating = false,
+                    hasMoreToLoadBackwards = false
+                )
+            }
+        }
+        return filteredItems
+    }
+
+    private fun replaceWithEncryptionHistoryBannerIfNeeded(list: List<MatrixTimelineItem>): List<MatrixTimelineItem> {
+        var lastEncryptedHistoryBannerIndex = -1
+        for ((i, item) in list.withIndex()) {
+            if (isItemEncryptionHistory(item)) {
+                lastEncryptedHistoryBannerIndex = i
+            }
+        }
+        return if (lastEncryptedHistoryBannerIndex >= 0) {
+            val sublist = list.drop(lastEncryptedHistoryBannerIndex + 1).toMutableList()
+            sublist.add(0, MatrixTimelineItem.Virtual(0L, VirtualTimelineItem.EncryptedHistoryBanner))
+            sublist
+        } else {
+            list
+        }
+    }
+
+    private fun isItemEncryptionHistory(item: MatrixTimelineItem): Boolean {
+        if ((item as? MatrixTimelineItem.Virtual)?.virtual is VirtualTimelineItem.EncryptedHistoryBanner) {
+            return true
+        }
+        val timestamp = (item as? MatrixTimelineItem.Event)?.event?.timestamp ?: return false
+        return timestamp <= lastLoginTimestamp!!.time
+    }
+
+}

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

@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2023 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 io.element.android.libraries.matrix.impl.timeline.postprocessor
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.timeline.MatrixTimeline
+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.room.anEventTimelineItem
+import kotlinx.coroutines.flow.MutableStateFlow
+import org.junit.Test
+import java.util.Date
+
+class TimelineEncryptedHistoryPostProcessorTest {
+
+    private val defaultLastLoginTimestamp = Date(1689061264L)
+
+    @Test
+    fun `given an unencrypted room, nothing is done`() {
+        val processor = createPostProcessor(isRoomEncrypted = false)
+        val items = listOf(
+            MatrixTimelineItem.Event(0L, anEventTimelineItem())
+        )
+        assertThat(processor.process(items)).isSameInstanceAs(items)
+    }
+
+    @Test
+    fun `given a null lastLoginTimestamp, nothing is done`() {
+        val processor = createPostProcessor(lastLoginTimestamp = null)
+        val items = listOf(
+            MatrixTimelineItem.Event(0L, anEventTimelineItem())
+        )
+        assertThat(processor.process(items)).isSameInstanceAs(items)
+    }
+
+    @Test
+    fun `given an empty list, nothing is done`() {
+        val processor = createPostProcessor()
+        val items = emptyList<MatrixTimelineItem>()
+        assertThat(processor.process(items)).isSameInstanceAs(items)
+    }
+
+    @Test
+    fun `given a list with no items before lastLoginTimestamp, nothing is done`() {
+        val processor = createPostProcessor()
+        val items = listOf(
+            MatrixTimelineItem.Event(0L, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1))
+        )
+        assertThat(processor.process(items)).isSameInstanceAs(items)
+    }
+
+    @Test
+    fun `given a list with an item with equal timestamp as lastLoginTimestamp, it's replaced`() {
+        val processor = createPostProcessor()
+        val items = listOf(
+            MatrixTimelineItem.Event(0L, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time))
+        )
+        assertThat(processor.process(items))
+            .isEqualTo(listOf(MatrixTimelineItem.Virtual(0L, VirtualTimelineItem.EncryptedHistoryBanner)))
+    }
+
+    @Test
+    fun `given a list with an item with a lower timestamp than lastLoginTimestamp, it's replaced`() {
+        val processor = createPostProcessor()
+        val items = listOf(
+            MatrixTimelineItem.Event(0L, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time - 1))
+        )
+        assertThat(processor.process(items)).isEqualTo(
+            listOf(MatrixTimelineItem.Virtual(0L, VirtualTimelineItem.EncryptedHistoryBanner))
+        )
+    }
+
+    @Test
+    fun `given a list with several with lower or equal timestamps than lastLoginTimestamp, they're replaced and the user can't back paginate`() {
+        val paginationStateFlow = MutableStateFlow(MatrixTimeline.PaginationState(hasMoreToLoadBackwards = true, isBackPaginating = false))
+        val processor = createPostProcessor(paginationStateFlow = paginationStateFlow)
+        val items = listOf(
+            MatrixTimelineItem.Event(0L, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time - 1)),
+            MatrixTimelineItem.Event(0L, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time)),
+            MatrixTimelineItem.Event(0L, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1)),
+        )
+        assertThat(processor.process(items)).isEqualTo(
+            listOf(
+                MatrixTimelineItem.Virtual(0L, VirtualTimelineItem.EncryptedHistoryBanner),
+                MatrixTimelineItem.Event(0L, anEventTimelineItem(timestamp = defaultLastLoginTimestamp.time + 1))
+            )
+        )
+        assertThat(paginationStateFlow.value).isEqualTo(MatrixTimeline.PaginationState(hasMoreToLoadBackwards = false, isBackPaginating = false))
+    }
+
+    private fun createPostProcessor(
+        lastLoginTimestamp: Date? = defaultLastLoginTimestamp,
+        isRoomEncrypted: Boolean = true,
+        paginationStateFlow: MutableStateFlow<MatrixTimeline.PaginationState> =
+            MutableStateFlow(MatrixTimeline.PaginationState(hasMoreToLoadBackwards = true, isBackPaginating = false))
+    ) = TimelineEncryptedHistoryPostProcessor(
+        lastLoginTimestamp = lastLoginTimestamp,
+        isRoomEncrypted = isRoomEncrypted,
+        paginationStateFlow = paginationStateFlow,
+    )
+}

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/TestData.kt

@@ -22,6 +22,7 @@ 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.SpaceId
 import io.element.android.libraries.matrix.api.core.ThreadId
+import io.element.android.libraries.matrix.api.core.TransactionId
 import io.element.android.libraries.matrix.api.core.UserId
 import java.util.UUID
 
@@ -38,7 +39,7 @@ val A_ROOM_ID_2 = RoomId("!aRoomId2:domain")
 val A_THREAD_ID = ThreadId("\$aThreadId")
 val AN_EVENT_ID = EventId("\$anEventId")
 val AN_EVENT_ID_2 = EventId("\$anEventId2")
-const val A_TRANSACTION_ID = "aTransactionId"
+val A_TRANSACTION_ID = TransactionId("aTransactionId")
 const val A_UNIQUE_ID = "aUniqueId"
 
 const val A_ROOM_NAME = "A room name"

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/room/FakeMatrixRoom.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.SessionId
+import io.element.android.libraries.matrix.api.core.TransactionId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.room.location.AssetType
 import io.element.android.libraries.matrix.api.media.AudioInfo
@@ -164,17 +165,17 @@ class FakeMatrixRoom(
         return toggleReactionResult
     }
 
-    override suspend fun retrySendMessage(transactionId: String): Result<Unit> {
+    override suspend fun retrySendMessage(transactionId: TransactionId): Result<Unit> {
         retrySendMessageCount++
         return retrySendMessageResult
     }
 
-    override suspend fun cancelSend(transactionId: String): Result<Unit> {
+    override suspend fun cancelSend(transactionId: TransactionId): Result<Unit> {
         cancelSendCount++
         return cancelSendResult
     }
 
-    override suspend fun editMessage(originalEventId: EventId?, transactionId: String?, message: String): Result<Unit> {
+    override suspend fun editMessage(originalEventId: EventId?, transactionId: TransactionId?, message: String): Result<Unit> {
         editMessageCalls += message
         return Result.success(Unit)
     }

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/room/RoomSummaryFixture.kt

@@ -18,6 +18,7 @@ package io.element.android.libraries.matrix.test.room
 
 import io.element.android.libraries.matrix.api.core.EventId
 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.UserId
 import io.element.android.libraries.matrix.api.room.RoomSummary
 import io.element.android.libraries.matrix.api.room.RoomSummaryDetails
@@ -25,14 +26,17 @@ import io.element.android.libraries.matrix.api.room.message.RoomMessage
 import io.element.android.libraries.matrix.api.timeline.item.TimelineItemDebugInfo
 import io.element.android.libraries.matrix.api.timeline.item.event.EventContent
 import io.element.android.libraries.matrix.api.timeline.item.event.EventReaction
-import io.element.android.libraries.matrix.api.timeline.item.event.LocalEventSendState
 import io.element.android.libraries.matrix.api.timeline.item.event.EventTimelineItem
+import io.element.android.libraries.matrix.api.timeline.item.event.InReplyTo
+import io.element.android.libraries.matrix.api.timeline.item.event.LocalEventSendState
+import io.element.android.libraries.matrix.api.timeline.item.event.MessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.MessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ProfileChangeContent
 import io.element.android.libraries.matrix.api.timeline.item.event.ProfileTimelineDetails
+import io.element.android.libraries.matrix.api.timeline.item.event.TextMessageType
 import io.element.android.libraries.matrix.test.AN_EVENT_ID
 import io.element.android.libraries.matrix.test.A_ROOM_ID
 import io.element.android.libraries.matrix.test.A_ROOM_NAME
-import io.element.android.libraries.matrix.test.A_UNIQUE_ID
 import io.element.android.libraries.matrix.test.A_USER_ID
 import io.element.android.libraries.matrix.test.A_USER_NAME
 
@@ -88,7 +92,7 @@ fun aRoomMessage(
 
 fun anEventTimelineItem(
     eventId: EventId = AN_EVENT_ID,
-    transactionId: String? = null,
+    transactionId: TransactionId? = null,
     isEditable: Boolean = false,
     isLocal: Boolean = false,
     isOwn: Boolean = false,
@@ -114,6 +118,7 @@ fun anEventTimelineItem(
     timestamp = timestamp,
     content = content,
     debugInfo = debugInfo,
+    origin = null,
 )
 
 fun aProfileTimelineDetails(
@@ -138,6 +143,21 @@ fun aProfileChangeMessageContent(
     prevAvatarUrl = prevAvatarUrl,
 )
 
+fun aMessageContent(
+    body: String = "body",
+    inReplyTo: InReplyTo? = null,
+    isEdited: Boolean = false,
+    messageType: MessageType = TextMessageType(
+        body = body,
+        formatted = null
+    )
+) = MessageContent(
+    body = body,
+    inReplyTo = inReplyTo,
+    isEdited = isEdited,
+    type = messageType
+)
+
 fun aTimelineItemDebugInfo(
     model: String = "Rust(Model())",
     originalJson: String? = null,
@@ -145,3 +165,4 @@ fun aTimelineItemDebugInfo(
 ) = TimelineItemDebugInfo(
     model, originalJson, latestEditedJson
 )
+

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/timeline/FakeMatrixTimeline.kt

@@ -19,6 +19,8 @@ package io.element.android.libraries.matrix.test.timeline
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimeline
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
+import io.element.android.tests.testutils.simulateLongTask
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -36,6 +38,8 @@ class FakeMatrixTimeline(
     var sendReadReceiptCount = 0
         private set
 
+    var sendReadReceiptLatch: CompletableDeferred<Unit>? = null
+
     fun updatePaginationState(update: (MatrixTimeline.PaginationState.() -> MatrixTimeline.PaginationState)) {
         _paginationState.getAndUpdate(update)
     }
@@ -62,13 +66,13 @@ class FakeMatrixTimeline(
         return Result.success(Unit)
     }
 
-
-    override suspend fun fetchDetailsForEvent(eventId: EventId): Result<Unit> {
-        return Result.success(Unit)
+    override suspend fun fetchDetailsForEvent(eventId: EventId): Result<Unit> = simulateLongTask {
+        Result.success(Unit)
     }
 
-    override suspend fun sendReadReceipt(eventId: EventId): Result<Unit> {
+    override suspend fun sendReadReceipt(eventId: EventId): Result<Unit> = simulateLongTask {
         sendReadReceiptCount++
-        return Result.success(Unit)
+        sendReadReceiptLatch?.complete(Unit)
+        Result.success(Unit)
     }
 }