Update dependency org.matrix.rustcomponents:sdk-android to v0.1.12 (#407)

* Update dependency org.matrix.rustcomponents:sdk-android to v0.1.12

* Fix Rust SDK update issues.

* Try to handle Rust memory more gracefully.

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Jorge Martín <jorgem@element.io>

gradle/libs.versions.toml

@@ -129,7 +129,7 @@ jsoup = { module = "org.jsoup:jsoup", version.ref = "jsoup" }
 appyx_core = { module = "com.bumble.appyx:core", version.ref = "appyx" }
 molecule-runtime = { module = "app.cash.molecule:molecule-runtime", version.ref = "molecule" }
 timber = "com.jakewharton.timber:timber:5.0.1"
-matrix_sdk = "org.matrix.rustcomponents:sdk-android:0.1.11"
+matrix_sdk = "org.matrix.rustcomponents:sdk-android:0.1.12"
 sqldelight-driver-android = { module = "com.squareup.sqldelight:android-driver", version.ref = "sqldelight" }
 sqldelight-driver-jvm = { module = "com.squareup.sqldelight:sqlite-driver", version.ref = "sqldelight" }
 sqldelight-coroutines = { module = "com.squareup.sqldelight:coroutines-extensions", version.ref = "sqldelight" }

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

@@ -21,5 +21,5 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.SessionId
 
 interface NotificationService {
-    suspend fun getNotification(userId: SessionId, roomId: RoomId, eventId: EventId): Result<NotificationData?>
+    fun getNotification(userId: SessionId, roomId: RoomId, eventId: EventId): Result<NotificationData?>
 }

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

@@ -44,7 +44,9 @@ import io.element.android.libraries.matrix.impl.verification.RustSessionVerifica
 import io.element.android.libraries.sessionstorage.api.SessionStore
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.launchIn
@@ -54,7 +56,9 @@ import kotlinx.coroutines.withTimeout
 import org.matrix.rustcomponents.sdk.Client
 import org.matrix.rustcomponents.sdk.ClientDelegate
 import org.matrix.rustcomponents.sdk.RequiredState
+import org.matrix.rustcomponents.sdk.SlidingSyncList
 import org.matrix.rustcomponents.sdk.SlidingSyncListBuilder
+import org.matrix.rustcomponents.sdk.SlidingSyncListOnceBuilt
 import org.matrix.rustcomponents.sdk.SlidingSyncMode
 import org.matrix.rustcomponents.sdk.SlidingSyncRequestListFilters
 import org.matrix.rustcomponents.sdk.TaskHandle
@@ -82,7 +86,7 @@ class RustMatrixClient constructor(
         client = client,
         dispatchers = dispatchers,
     )
-    private val notificationService = RustNotificationService(baseDirectory, dispatchers)
+    private val notificationService = RustNotificationService(client)
     private var slidingSyncUpdateJob: Job? = null
 
     private val clientDelegate = object : ClientDelegate {
@@ -105,7 +109,8 @@ class RustMatrixClient constructor(
         notTags = emptyList()
     )
 
-    private val visibleRoomsSlidingSyncList = SlidingSyncListBuilder()
+    private val visibleRoomsSlidingSyncList = MutableSharedFlow<SlidingSyncList>(replay = 1)
+    private val visibleRoomsSlidingSyncListBuilder = SlidingSyncListBuilder("CurrentlyVisibleRooms")
         .timelineLimit(limit = 1u)
         .requiredState(
             requiredState = listOf(
@@ -115,16 +120,19 @@ class RustMatrixClient constructor(
             )
         )
         .filters(visibleRoomsSlidingSyncFilters)
-        .name(name = "CurrentlyVisibleRooms")
         .syncMode(mode = SlidingSyncMode.SELECTIVE)
         .addRange(0u, 20u)
-        .use {
+        .onceBuilt(object : SlidingSyncListOnceBuilt {
-            it.build()
+            override fun updateList(list: SlidingSyncList): SlidingSyncList {
-        }
+                visibleRoomsSlidingSyncList.tryEmit(list)
+                return list
+            }
+        })
 
     private val invitesSlidingSyncFilters = visibleRoomsSlidingSyncFilters.copy(isInvite = true)
 
-    private val invitesSlidingSyncList = SlidingSyncListBuilder()
+    private val invitesSlidingSyncList = MutableSharedFlow<SlidingSyncList>(replay = 1)
+    private val invitesSlidingSyncListBuilder = SlidingSyncListBuilder("CurrentInvites")
         .timelineLimit(limit = 1u)
         .requiredState(
             requiredState = listOf(
@@ -134,20 +142,22 @@ class RustMatrixClient constructor(
             )
         )
         .filters(invitesSlidingSyncFilters)
-        .name(name = "CurrentInvites")
         .syncMode(mode = SlidingSyncMode.SELECTIVE)
         .addRange(0u, 20u)
-        .use {
+        .onceBuilt(object : SlidingSyncListOnceBuilt {
-            it.build()
+            override fun updateList(list: SlidingSyncList): SlidingSyncList {
-        }
+                invitesSlidingSyncList.tryEmit(list)
+                return list
+            }
+        })
 
     private val slidingSync = client
         .slidingSync()
         .homeserver("https://slidingsync.lab.matrix.org")
         .withCommonExtensions()
         .storageKey("ElementX")
-        .addList(visibleRoomsSlidingSyncList)
+        .addList(visibleRoomsSlidingSyncListBuilder)
-        .addList(invitesSlidingSyncList)
+        .addList(invitesSlidingSyncListBuilder)
         .use {
             it.build()
         }
@@ -159,7 +169,6 @@ class RustMatrixClient constructor(
             slidingSync,
             visibleRoomsSlidingSyncList,
             dispatchers,
-            ::onRestartSync
         )
 
     override val roomSummaryDataSource: RoomSummaryDataSource
@@ -171,7 +180,6 @@ class RustMatrixClient constructor(
             slidingSync,
             invitesSlidingSyncList,
             dispatchers,
-            ::onRestartSync
         )
 
     override val invitesDataSource: RoomSummaryDataSource
@@ -194,11 +202,6 @@ class RustMatrixClient constructor(
             .launchIn(coroutineScope)
     }
 
-    private fun onRestartSync() {
-        stopSync()
-        startSync()
-    }
-
     override fun getRoom(roomId: RoomId): MatrixRoom? {
         val slidingSyncRoom = slidingSync.getRoom(roomId.value) ?: return null
         val fullRoom = slidingSyncRoom.fullRoom() ?: return null
@@ -297,6 +300,7 @@ class RustMatrixClient constructor(
         }
     }
 
+    @ExperimentalCoroutinesApi
     override fun close() {
         slidingSyncUpdateJob?.cancel()
         stopSync()
@@ -304,7 +308,10 @@ class RustMatrixClient constructor(
         rustRoomSummaryDataSource.close()
         rustInvitesDataSource.close()
         client.setDelegate(null)
-        visibleRoomsSlidingSyncList.destroy()
+        visibleRoomsSlidingSyncListBuilder.destroy()
+        invitesSlidingSyncListBuilder.destroy()
+        visibleRoomsSlidingSyncList.resetReplayCache()
+        invitesSlidingSyncList.resetReplayCache()
         slidingSync.destroy()
         verificationService.destroy()
         client.destroy()

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

@@ -17,33 +17,30 @@
 package io.element.android.libraries.matrix.impl.notification
 
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.matrix.api.MatrixClient
 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.SessionId
+import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.notification.NotificationData
 import io.element.android.libraries.matrix.api.notification.NotificationService
 import kotlinx.coroutines.withContext
+import org.matrix.rustcomponents.sdk.Client
+import org.matrix.rustcomponents.sdk.use
 import java.io.File
 
 class RustNotificationService(
-    private val baseDirectory: File,
+    private val client: Client,
-    private val dispatchers: CoroutineDispatchers,
 ) : NotificationService {
     private val notificationMapper: NotificationMapper = NotificationMapper()
 
-    override suspend fun getNotification(userId: SessionId, roomId: RoomId, eventId: EventId): Result<NotificationData?> {
+    override fun getNotification(
-        return withContext(dispatchers.io) {
+        userId: SessionId,
-            runCatching {
+        roomId: RoomId,
-                org.matrix.rustcomponents.sdk.NotificationService(
+        eventId: EventId
-                    basePath = File(baseDirectory, "sessions").absolutePath,
+    ): Result<NotificationData?> {
-                    userId = userId.value
+        return runCatching {
-                ).use {
+            client.getNotificationItem(roomId.value, eventId.value).use(notificationMapper::map)
-                    // TODO Not implemented yet, see https://github.com/matrix-org/matrix-rust-sdk/issues/1628
-                    it.getNotificationItem(roomId.value, eventId.value)?.let { notificationItem ->
-                        notificationMapper.map(notificationItem)
-                    }
-                }
-            }
         }
     }
 }

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

@@ -33,7 +33,6 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onStart
-import kotlinx.coroutines.flow.onSubscription
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.Room
 import org.matrix.rustcomponents.sdk.SlidingSyncRoom

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

@@ -27,9 +27,12 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.RoomListEntry
 import org.matrix.rustcomponents.sdk.SlidingSync
@@ -44,9 +47,8 @@ import java.util.UUID
 internal class RustRoomSummaryDataSource(
     private val slidingSyncUpdateFlow: Flow<UpdateSummary>,
     private val slidingSync: SlidingSync,
-    private val slidingSyncList: SlidingSyncList,
+    private val slidingSyncListFlow: Flow<SlidingSyncList>,
     private val coroutineDispatchers: CoroutineDispatchers,
-    private val onRestartSync: () -> Unit,
     private val roomSummaryDetailsFactory: RoomSummaryDetailsFactory = RoomSummaryDetailsFactory(),
 ) : RoomSummaryDataSource, Closeable {
 
@@ -57,34 +59,35 @@ internal class RustRoomSummaryDataSource(
 
     fun init() {
         coroutineScope.launch {
+            val slidingSyncList = slidingSyncListFlow.first()
+            val summaries = slidingSyncList.currentRoomList().map(::buildSummaryForRoomListEntry)
             updateRoomSummaries {
-                addAll(
+                addAll(summaries)
-                    slidingSyncList.currentRoomList().map(::buildSummaryForRoomListEntry)
-                )
             }
+
+            slidingSyncList.roomListDiff(this)
+                .onEach { diffs ->
+                    updateRoomSummaries {
+                        applyDiff(diffs)
+                    }
+                }
+                .launchIn(this)
+
+            slidingSyncList.state(this)
+                .onEach { slidingSyncState ->
+                    Timber.v("New sliding sync state: $slidingSyncState")
+                    state.value = slidingSyncState
+                }.launchIn(this)
         }
 
         slidingSyncUpdateFlow
             .onEach {
                 didReceiveSyncUpdate(it)
             }.launchIn(coroutineScope)
-
-        slidingSyncList.roomListDiff(coroutineScope)
-            .onEach { diffs ->
-                updateRoomSummaries {
-                    applyDiff(diffs)
-                }
-            }
-            .launchIn(coroutineScope)
-
-        slidingSyncList.state(coroutineScope)
-            .onEach { slidingSyncState ->
-                Timber.v("New sliding sync state: $slidingSyncState")
-                state.value = slidingSyncState
-            }.launchIn(coroutineScope)
     }
 
     override fun close() {
+        runBlocking { slidingSyncListFlow.firstOrNull() }?.close()
         coroutineScope.cancel()
     }
 
@@ -95,8 +98,9 @@ internal class RustRoomSummaryDataSource(
 
     override fun setSlidingSyncRange(range: IntRange) {
         Timber.v("setVisibleRange=$range")
-        slidingSyncList.setRange(range.first.toUInt(), range.last.toUInt())
+        coroutineScope.launch {
-        onRestartSync()
+            slidingSyncListFlow.first().setRange(range.first.toUInt(), range.last.toUInt())
+        }
     }
 
     private suspend fun didReceiveSyncUpdate(summary: UpdateSummary) {

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

@@ -23,7 +23,7 @@ import io.element.android.libraries.matrix.api.notification.NotificationData
 import io.element.android.libraries.matrix.api.notification.NotificationService
 
 class FakeNotificationService : NotificationService {
-    override suspend fun getNotification(userId: SessionId, roomId: RoomId, eventId: EventId): Result<NotificationData?> {
+    override fun getNotification(userId: SessionId, roomId: RoomId, eventId: EventId): Result<NotificationData?> {
         return Result.success(null)
     }
 }