Don't use flow chunk for now as it leads to errors

libraries/matrix/src/main/java/io/element/android/x/matrix/room/RoomSummaryDataSource.kt

@@ -1,7 +1,6 @@
 package io.element.android.x.matrix.room
 
 import io.element.android.x.core.coroutine.CoroutineDispatchers
-import io.element.android.x.core.data.flow.chunk
 import io.element.android.x.matrix.sync.roomListDiff
 import io.element.android.x.matrix.sync.state
 import kotlinx.coroutines.*
@@ -25,7 +24,6 @@ internal class RustRoomSummaryDataSource(
 ) : RoomSummaryDataSource, Closeable {
 
     private val singleDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
-
     private val coroutineScope = CoroutineScope(SupervisorJob() + singleDispatcher)
 
     private val roomSummaries = MutableStateFlow<List<RoomSummary>>(emptyList())
@@ -41,12 +39,9 @@ internal class RustRoomSummaryDataSource(
             }
 
             slidingSyncView.roomListDiff()
-                .chunk(30)
                 .onEach { diffs ->
                     updateRoomSummaries {
-                        diffs.forEach {
+                        applyDiff(diffs)
-                            applyDiff(it)
-                        }
                     }
                 }.collect()
 
@@ -72,7 +67,7 @@ internal class RustRoomSummaryDataSource(
     }
 
     override fun roomSummaries(): Flow<List<RoomSummary>> {
-        return roomSummaries.sample(100)
+        return roomSummaries.sample(50)
     }
 
     private fun didReceiveSyncUpdate(summary: UpdateSummary) {

libraries/matrix/src/main/java/io/element/android/x/matrix/timeline/MatrixTimeline.kt

@@ -32,7 +32,7 @@ class MatrixTimeline(
     fun timelineItems(): Flow<List<MatrixTimelineItem>> {
         return diffFlow().combine(timelineItems) { _, _ ->
             timelineItems.value
-        }
+        }.sample(50)
     }
 
     val hasMoreToLoad: Boolean
@@ -43,50 +43,56 @@ class MatrixTimeline(
 
     private fun diffFlow(): Flow<Unit> {
         return room.timelineDiff()
-            .chunk(30)
             .onEach { timelineDiffs ->
+                //Timber.v("Apply ${timelineDiffs.size} diffs on thread: ${Thread.currentThread()}")
                 updateTimelineItems {
-                    timelineDiffs.onEach {
+                    applyDiff(timelineDiffs)
-                        applyDiff(it)
-                    }
                 }
             }.map { }
+            .flowOn(coroutineDispatchers.computation)
     }
 
     private fun MutableList<MatrixTimelineItem>.applyDiff(diff: TimelineDiff) {
-        Timber.v("ApplyDiff: ${diff.change()} for list with size: $size")
         when (diff.change()) {
             TimelineChange.PUSH -> {
+                Timber.v("Apply push on list with size: $size")
                 val item = diff.push()?.asMatrixTimelineItem() ?: return
                 add(item)
             }
             TimelineChange.UPDATE_AT -> {
                 val updateAtData = diff.updateAt() ?: return
+                Timber.v("Apply $updateAtData on list with size: $size")
                 val item = updateAtData.item.asMatrixTimelineItem()
                 set(updateAtData.index.toInt(), item)
             }
             TimelineChange.INSERT_AT -> {
                 val insertAtData = diff.insertAt() ?: return
+                Timber.v("Apply $insertAtData on list with size: $size")
                 val item = insertAtData.item.asMatrixTimelineItem()
                 add(insertAtData.index.toInt(), item)
             }
             TimelineChange.MOVE -> {
                 val moveData = diff.move() ?: return
+                Timber.v("Apply $moveData on list with size: $size")
                 Collections.swap(this, moveData.oldIndex.toInt(), moveData.newIndex.toInt())
             }
             TimelineChange.REMOVE_AT -> {
                 val removeAtData = diff.removeAt() ?: return
+                Timber.v("Apply $removeAtData on list with size: $size")
                 removeAt(removeAtData.toInt())
             }
             TimelineChange.REPLACE -> {
+                Timber.v("Apply REPLACE on list with size: $size")
                 clear()
                 val items = diff.replace()?.map { it.asMatrixTimelineItem() } ?: return
                 addAll(items)
             }
             TimelineChange.POP -> {
+                Timber.v("Apply POP on list with size: $size")
                 removeLast()
             }
             TimelineChange.CLEAR -> {
+                Timber.v("Apply CLEAR on list with size: $size")
                 clear()
             }
         }