Timeline : remove some code from main thread

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

@@ -31,7 +31,7 @@ class MatrixTimelineItemMapper(
     private val eventTimelineItemMapper: EventTimelineItemMapper = EventTimelineItemMapper(),
 ) {
     fun map(timelineItem: TimelineItem): MatrixTimelineItem = timelineItem.use {
-        val uniqueId = timelineItem.uniqueId().toString()
+        val 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

@@ -174,23 +174,25 @@ class RustTimeline(
 
     // Use NonCancellable to avoid breaking the timeline when the coroutine is cancelled.
     override suspend fun paginate(direction: Timeline.PaginationDirection): Result<Boolean> = withContext(NonCancellable) {
-        initLatch.await()
+        withContext(dispatcher) {
-        runCatching {
+            initLatch.await()
-            if (!canPaginate(direction)) throw TimelineException.CannotPaginate
+            runCatching {
-            updatePaginationStatus(direction) { it.copy(isPaginating = true) }
+                if (!canPaginate(direction)) throw TimelineException.CannotPaginate
-            when (direction) {
+                updatePaginationStatus(direction) { it.copy(isPaginating = true) }
-                Timeline.PaginationDirection.BACKWARDS -> inner.paginateBackwards(PAGINATION_SIZE.toUShort())
+                when (direction) {
-                Timeline.PaginationDirection.FORWARDS -> inner.focusedPaginateForwards(PAGINATION_SIZE.toUShort())
+                    Timeline.PaginationDirection.BACKWARDS -> inner.paginateBackwards(PAGINATION_SIZE.toUShort())
-            }
+                    Timeline.PaginationDirection.FORWARDS -> inner.focusedPaginateForwards(PAGINATION_SIZE.toUShort())
-        }.onFailure { error ->
+                }
-            updatePaginationStatus(direction) { it.copy(isPaginating = false) }
+            }.onFailure { error ->
-            if (error is TimelineException.CannotPaginate) {
+                updatePaginationStatus(direction) { it.copy(isPaginating = false) }
-                Timber.d("Can't paginate $direction on room ${matrixRoom.roomId} with paginationStatus: ${backPaginationStatus.value}")
+                if (error is TimelineException.CannotPaginate) {
-            } else {
+                    Timber.d("Can't paginate $direction on room ${matrixRoom.roomId} with paginationStatus: ${backPaginationStatus.value}")
-                Timber.e(error, "Error paginating $direction on room ${matrixRoom.roomId}")
+                } else {
+                    Timber.e(error, "Error paginating $direction on room ${matrixRoom.roomId}")
+                }
+            }.onSuccess { hasReachedEnd ->
+                updatePaginationStatus(direction) { it.copy(isPaginating = false, hasMoreToLoad = !hasReachedEnd) }
             }
-        }.onSuccess { hasReachedEnd ->
-            updatePaginationStatus(direction) { it.copy(isPaginating = false, hasMoreToLoad = !hasReachedEnd) }
         }
     }
 
@@ -214,18 +216,20 @@ class RustTimeline(
         backPaginationStatus.map { it.hasMoreToLoad }.distinctUntilChanged(),
         forwardPaginationStatus.map { it.hasMoreToLoad }.distinctUntilChanged(),
     ) { timelineItems, hasMoreToLoadBackward, hasMoreToLoadForward ->
-        timelineItems
+        withContext(dispatcher) {
-            .let { items -> encryptedHistoryPostProcessor.process(items) }
+            timelineItems
-            .let { items ->
+                .let { items -> encryptedHistoryPostProcessor.process(items) }
-                roomBeginningPostProcessor.process(
+                .let { items ->
-                    items = items,
+                    roomBeginningPostProcessor.process(
-                    isDm = matrixRoom.isDm,
+                        items = items,
-                    hasMoreToLoadBackwards = hasMoreToLoadBackward
+                        isDm = matrixRoom.isDm,
-                )
+                        hasMoreToLoadBackwards = hasMoreToLoadBackward
-            }
+                    )
-            .let { items -> loadingIndicatorsPostProcessor.process(items, hasMoreToLoadBackward, hasMoreToLoadForward) }
+                }
-            // Keep lastForwardIndicatorsPostProcessor last
+                .let { items -> loadingIndicatorsPostProcessor.process(items, hasMoreToLoadBackward, hasMoreToLoadForward) }
-            .let { items -> lastForwardIndicatorsPostProcessor.process(items) }
+                // Keep lastForwardIndicatorsPostProcessor last
+                .let { items -> lastForwardIndicatorsPostProcessor.process(items) }
+        }
     }
 
     override fun close() {