RoomList: introduces a SyncService

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

@@ -31,6 +31,8 @@ import io.element.android.libraries.matrix.api.pusher.PushersService
 import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
 import io.element.android.libraries.matrix.api.room.RoomSummaryDataSource
+import io.element.android.libraries.matrix.api.sync.SyncService
+import io.element.android.libraries.matrix.api.sync.SyncState
 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
@@ -41,7 +43,7 @@ import io.element.android.libraries.matrix.impl.pushers.RustPushersService
 import io.element.android.libraries.matrix.impl.room.RustMatrixRoom
 import io.element.android.libraries.matrix.impl.room.RustRoomSummaryDataSource
 import io.element.android.libraries.matrix.impl.room.roomOrNull
-import io.element.android.libraries.matrix.impl.room.stateFlow
+import io.element.android.libraries.matrix.impl.sync.RustSyncService
 import io.element.android.libraries.matrix.impl.usersearch.UserProfileMapper
 import io.element.android.libraries.matrix.impl.usersearch.UserSearchResultMapper
 import io.element.android.libraries.matrix.impl.verification.RustSessionVerificationService
@@ -49,7 +51,6 @@ import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.services.toolbox.api.systemclock.SystemClock
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
@@ -78,8 +79,10 @@ class RustMatrixClient constructor(
 
     override val sessionId: UserId = UserId(client.userId())
 
+    private val roomListService = client.roomList()
     private val sessionCoroutineScope = childScopeOf(appCoroutineScope, dispatchers.main, "Session-${sessionId}")
     private val verificationService = RustSessionVerificationService()
+    private val syncService = RustSyncService(roomListService, sessionCoroutineScope)
     private val pushersService = RustPushersService(
         client = client,
         dispatchers = dispatchers,
@@ -93,8 +96,6 @@ class RustMatrixClient constructor(
         }
     }
 
-    private val roomListService = client.roomList()
-
     private val rustRoomSummaryDataSource: RustRoomSummaryDataSource =
         RustRoomSummaryDataSource(
             roomListService = roomListService,
@@ -113,12 +114,13 @@ class RustMatrixClient constructor(
 
     init {
         client.setDelegate(clientDelegate)
+        syncService.syncState()
+            .onEach { syncState ->
+                if (syncState == SyncState.Syncing) {
+                    onSlidingSyncUpdate()
+                }
+            }.launchIn(sessionCoroutineScope)
         rustRoomSummaryDataSource.init()
-        roomListService.stateFlow()
-            .onEach {
-                Timber.v("onRoomList state change: $it")
-            }
-            .launchIn(sessionCoroutineScope)
     }
 
     override fun getRoom(roomId: RoomId): MatrixRoom? {
@@ -208,26 +210,15 @@ class RustMatrixClient constructor(
             }
         }
 
+    override fun syncService(): SyncService = syncService
+
     override fun sessionVerificationService(): SessionVerificationService = verificationService
 
     override fun pushersService(): PushersService = pushersService
 
     override fun notificationService(): NotificationService = notificationService
 
-    override fun startSync() {
-        if (!roomListService.isSyncing()) {
-            roomListService.sync()
-        }
-    }
-
-    override fun stopSync() {
-        if (roomListService.isSyncing()) {
-            roomListService.stopSync()
-        }
-    }
-
     override fun close() {
-        stopSync()
         sessionCoroutineScope.cancel()
         client.setDelegate(null)
         verificationService.destroy()
@@ -265,7 +256,7 @@ class RustMatrixClient constructor(
         }
     }
 
-    override fun onSlidingSyncUpdate() {
+    private fun onSlidingSyncUpdate() {
         if (!verificationService.isReady.value) {
             try {
                 verificationService.verificationController = client.getSessionVerificationController()

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

@@ -3,7 +3,6 @@ package io.element.android.libraries.matrix.impl.room
 import io.element.android.libraries.matrix.impl.util.mxCallbackFlow
 import kotlinx.coroutines.channels.trySendBlocking
 import kotlinx.coroutines.flow.Flow
-import org.matrix.rustcomponents.sdk.RoomList
 import org.matrix.rustcomponents.sdk.RoomListEntriesListener
 import org.matrix.rustcomponents.sdk.RoomListEntriesUpdate
 import org.matrix.rustcomponents.sdk.RoomListEntry
@@ -15,7 +14,7 @@ import org.matrix.rustcomponents.sdk.SlidingSyncListLoadingState
 import org.matrix.rustcomponents.sdk.SlidingSyncListStateObserver
 import timber.log.Timber
 
-fun RoomListInterface.stateFlow(): Flow<RoomListState> =
+fun RoomListInterface.roomListStateFlow(): Flow<RoomListState> =
     mxCallbackFlow {
         val listener = object : RoomListStateListener {
             override fun onUpdate(state: RoomListState) {

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

@@ -0,0 +1,30 @@
+/*
+ * 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.sync
+
+import io.element.android.libraries.matrix.api.sync.SyncState
+import org.matrix.rustcomponents.sdk.RoomListState
+
+internal fun RoomListState.toSyncState(): SyncState {
+    return when (this) {
+        RoomListState.INIT,
+        RoomListState.SETTING_UP -> SyncState.Idle
+        RoomListState.RUNNING -> SyncState.Syncing
+        RoomListState.ERROR -> SyncState.InError
+        RoomListState.TERMINATED -> SyncState.Terminated
+    }
+}

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

@@ -0,0 +1,58 @@
+/*
+ * 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.sync
+
+import io.element.android.libraries.matrix.api.sync.SyncService
+import io.element.android.libraries.matrix.api.sync.SyncState
+import io.element.android.libraries.matrix.impl.room.roomListStateFlow
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.stateIn
+import org.matrix.rustcomponents.sdk.RoomList
+import org.matrix.rustcomponents.sdk.RoomListState
+import timber.log.Timber
+
+class RustSyncService(
+    private val roomListService: RoomList,
+    private val sessionCoroutineScope: CoroutineScope
+) : SyncService {
+
+    override fun startSync() {
+        if (!roomListService.isSyncing()) {
+            roomListService.sync()
+        }
+    }
+
+    override fun stopSync() {
+        if (roomListService.isSyncing()) {
+            roomListService.stopSync()
+        }
+    }
+
+    override fun syncState(): StateFlow<SyncState> {
+        return roomListService
+            .roomListStateFlow()
+            .map(RoomListState::toSyncState)
+            .onEach { syncState ->
+                Timber.d("OnSyncState updated = $syncState")
+            }
+            .stateIn(sessionCoroutineScope, SharingStarted.Eagerly, SyncState.Idle)
+    }
+}