Update rust sdk to 0.1.29 (new back pagination status api)

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

@@ -39,6 +39,7 @@ import io.element.android.libraries.matrix.impl.core.toProgressWatcher
 import io.element.android.libraries.matrix.impl.room.location.toInner
 import io.element.android.libraries.matrix.impl.media.map
 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.services.toolbox.api.systemclock.SystemClock
 import kotlinx.coroutines.CoroutineScope
@@ -111,6 +112,12 @@ class RustMatrixRoom(
                 _syncUpdateFlow.value = systemClock.epochMillis()
                 _timeline.postDiff(it)
             }.launchIn(this)
+
+            innerRoom.backPaginationStatusFlow()
+                .onEach {
+                    _timeline.postPaginationStatus(it)
+                }.launchIn(this)
+
             fetchMembers()
         }
         isInit.value = true

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

@@ -16,9 +16,7 @@
 
 package io.element.android.libraries.matrix.impl.timeline
 
-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.CompletableDeferred
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.sync.Mutex
@@ -28,7 +26,6 @@ import org.matrix.rustcomponents.sdk.TimelineDiff
 import org.matrix.rustcomponents.sdk.TimelineItem
 
 internal class MatrixTimelineDiffProcessor(
-    private val paginationState: MutableStateFlow<MatrixTimeline.PaginationState>,
     private val timelineItems: MutableStateFlow<List<MatrixTimelineItem>>,
     private val timelineItemFactory: MatrixTimelineItemMapper,
 ) {
@@ -40,7 +37,6 @@ internal class MatrixTimelineDiffProcessor(
         updateTimelineItems {
             val mappedItems = items.map { it.asMatrixTimelineItem() }
             addAll(mappedItems)
-            updateBackPaginationState()
         }
         initLatch.complete(Unit)
     }
@@ -50,29 +46,9 @@ internal class MatrixTimelineDiffProcessor(
         initLatch.await()
         updateTimelineItems {
             applyDiff(diff)
-            updateBackPaginationState()
         }
     }
 
-    private fun updateBackPaginationState(virtualItem: VirtualTimelineItem?) {
-        val currentPaginationState = paginationState.value
-        val newPaginationState = when (virtualItem) {
-            VirtualTimelineItem.LoadingIndicator -> currentPaginationState.copy(
-                isBackPaginating = true,
-                canBackPaginate = true
-            )
-            VirtualTimelineItem.TimelineStart -> currentPaginationState.copy(
-                isBackPaginating = false,
-                canBackPaginate = false
-            )
-            else -> currentPaginationState.copy(
-                isBackPaginating = false,
-                canBackPaginate = true
-            )
-        }
-        paginationState.value = newPaginationState
-    }
-
     private suspend fun updateTimelineItems(block: MutableList<MatrixTimelineItem>.() -> Unit) =
         mutex.withLock {
             val mutableTimelineItems = timelineItems.value.toMutableList()
@@ -125,13 +101,6 @@ internal class MatrixTimelineDiffProcessor(
         }
     }
 
-    private fun List<MatrixTimelineItem>.updateBackPaginationState() {
-        when (val firstItem = firstOrNull()) {
-            is MatrixTimelineItem.Virtual -> updateBackPaginationState(firstItem.virtual)
-            else -> updateBackPaginationState(null)
-        }
-    }
-
     private fun TimelineItem.asMatrixTimelineItem(): MatrixTimelineItem {
         return timelineItemFactory.map(this)
     }

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

@@ -21,6 +21,8 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.trySendBlocking
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.buffer
+import org.matrix.rustcomponents.sdk.BackPaginationStatus
+import org.matrix.rustcomponents.sdk.BackPaginationStatusListener
 import org.matrix.rustcomponents.sdk.Room
 import org.matrix.rustcomponents.sdk.TimelineDiff
 import org.matrix.rustcomponents.sdk.TimelineItem
@@ -37,3 +39,13 @@ internal fun Room.timelineDiffFlow(onInitialList: suspend (List<TimelineItem>) -
         onInitialList(result.items)
         result.itemsStream
     }.buffer(Channel.UNLIMITED)
+
+internal fun Room.backPaginationStatusFlow(): Flow<BackPaginationStatus> =
+    mxCallbackFlow {
+        val listener = object : BackPaginationStatusListener {
+            override fun onUpdate(status: BackPaginationStatus) {
+                trySendBlocking(status)
+            }
+        }
+        subscribeToBackPaginationStatus(listener)
+    }.buffer(Channel.UNLIMITED)

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

@@ -31,8 +31,10 @@ 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.sample
 import kotlinx.coroutines.withContext
+import org.matrix.rustcomponents.sdk.BackPaginationStatus
 import org.matrix.rustcomponents.sdk.PaginationOptions
 import org.matrix.rustcomponents.sdk.Room
 import org.matrix.rustcomponents.sdk.TimelineDiff
@@ -65,7 +67,6 @@ class RustMatrixTimeline(
     )
 
     private val timelineDiffProcessor = MatrixTimelineDiffProcessor(
-        paginationState = _paginationState,
         timelineItems = _timelineItems,
         timelineItemFactory = timelineItemFactory,
     )
@@ -83,6 +84,31 @@ class RustMatrixTimeline(
         timelineDiffProcessor.postDiff(timelineDiff)
     }
 
+    internal fun postPaginationStatus(status: BackPaginationStatus) {
+        _paginationState.getAndUpdate { currentPaginationState ->
+            when (status) {
+                BackPaginationStatus.IDLE -> {
+                    currentPaginationState.copy(
+                        isBackPaginating = false,
+                        canBackPaginate = true
+                    )
+                }
+                BackPaginationStatus.PAGINATING -> {
+                    currentPaginationState.copy(
+                        isBackPaginating = true,
+                        canBackPaginate = true
+                    )
+                }
+                BackPaginationStatus.TIMELINE_START_REACHED -> {
+                    currentPaginationState.copy(
+                        isBackPaginating = false,
+                        canBackPaginate = false
+                    )
+                }
+            }
+        }
+    }
+
     override suspend fun fetchDetailsForEvent(eventId: EventId): Result<Unit> = withContext(coroutineDispatchers.io) {
         runCatching {
             innerRoom.fetchDetailsForEvent(eventId.value)

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/item/virtual/VirtualTimelineItemMapper.kt

@@ -24,9 +24,7 @@ class VirtualTimelineItemMapper {
     fun map(virtualTimelineItem: RustVirtualTimelineItem): VirtualTimelineItem {
         return when (virtualTimelineItem) {
             is RustVirtualTimelineItem.DayDivider -> VirtualTimelineItem.DayDivider(virtualTimelineItem.ts.toLong())
-            RustVirtualTimelineItem.LoadingIndicator -> VirtualTimelineItem.LoadingIndicator
             RustVirtualTimelineItem.ReadMarker -> VirtualTimelineItem.ReadMarker
-            RustVirtualTimelineItem.TimelineStart -> VirtualTimelineItem.TimelineStart
         }
     }
 }