Merge develop into feature/fga/room_list_filters

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

@@ -113,7 +113,11 @@ class RustMatrixClient(
     private val innerRoomListService = syncService.roomListService()
     private val sessionDispatcher = dispatchers.io.limitedParallelism(64)
     private val rustSyncService = RustSyncService(syncService, sessionCoroutineScope)
-    private val verificationService = RustSessionVerificationService(rustSyncService, sessionCoroutineScope)
+    private val verificationService = RustSessionVerificationService(
+        client = client,
+        syncService = rustSyncService,
+        sessionCoroutineScope = sessionCoroutineScope,
+    ).apply { start() }
     private val pushersService = RustPushersService(
         client = client,
         dispatchers = dispatchers,

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

@@ -25,14 +25,20 @@ import io.element.android.libraries.matrix.api.encryption.EncryptionService
 import io.element.android.libraries.matrix.api.encryption.RecoveryState
 import io.element.android.libraries.matrix.api.sync.SyncState
 import io.element.android.libraries.matrix.impl.sync.RustSyncService
+import io.element.android.libraries.matrix.impl.util.cancelAndDestroy
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.BackupStateListener
 import org.matrix.rustcomponents.sdk.BackupSteadyStateListener
@@ -40,6 +46,7 @@ import org.matrix.rustcomponents.sdk.Client
 import org.matrix.rustcomponents.sdk.EnableRecoveryProgressListener
 import org.matrix.rustcomponents.sdk.Encryption
 import org.matrix.rustcomponents.sdk.RecoveryStateListener
+import org.matrix.rustcomponents.sdk.TaskHandle
 import org.matrix.rustcomponents.sdk.BackupState as RustBackupState
 import org.matrix.rustcomponents.sdk.BackupUploadState as RustBackupUploadState
 import org.matrix.rustcomponents.sdk.EnableRecoveryProgress as RustEnableRecoveryProgress
@@ -59,6 +66,8 @@ internal class RustEncryptionService(
     private val enableRecoveryProgressMapper = EnableRecoveryProgressMapper()
     private val backupUploadStateMapper = BackupUploadStateMapper()
     private val steadyStateExceptionMapper = SteadyStateExceptionMapper()
+    private var backupStateListenerTaskHandle: TaskHandle? = null
+    private var recoveryStateListenerTaskHandle: TaskHandle? = null
 
     private val backupStateFlow = MutableStateFlow(service.backupState().let(backupStateMapper::map))
 
@@ -88,14 +97,28 @@ internal class RustEncryptionService(
 
     override val enableRecoveryProgressStateFlow: MutableStateFlow<EnableRecoveryProgress> = MutableStateFlow(EnableRecoveryProgress.Starting)
 
+    /**
+     * Check if the session is the last session every 5 seconds.
+     * TODO This is a temporary workaround, when we will have a way to observe
+     * the sessions, this code will have to be updated.
+     */
+    override val isLastDevice: StateFlow<Boolean> = flow {
+        while (currentCoroutineContext().isActive) {
+            val result = isLastDevice().getOrDefault(false)
+            emit(result)
+            delay(5_000)
+        }
+    }
+        .stateIn(sessionCoroutineScope, SharingStarted.Eagerly, false)
+
     fun start() {
-        service.backupStateListener(object : BackupStateListener {
+        backupStateListenerTaskHandle = service.backupStateListener(object : BackupStateListener {
             override fun onUpdate(status: RustBackupState) {
                 backupStateFlow.value = backupStateMapper.map(status)
             }
         })
 
-        service.recoveryStateListener(object : RecoveryStateListener {
+        recoveryStateListenerTaskHandle = service.recoveryStateListener(object : RecoveryStateListener {
             override fun onUpdate(status: RustRecoveryState) {
                 recoveryStateFlow.value = recoveryStateMapper.map(status)
             }
@@ -103,7 +126,8 @@ internal class RustEncryptionService(
     }
 
     fun destroy() {
-        // No way to remove the listeners...
+        backupStateListenerTaskHandle?.cancelAndDestroy()
+        recoveryStateListenerTaskHandle?.cancelAndDestroy()
         service.destroy()
     }
 
@@ -173,7 +197,7 @@ internal class RustEncryptionService(
         }
     }
 
-    override suspend fun isLastDevice(): Result<Boolean> = withContext(dispatchers.io) {
+    private suspend fun isLastDevice(): Result<Boolean> = withContext(dispatchers.io) {
         runCatching {
             service.isLastDevice()
         }.mapFailure {

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

@@ -16,6 +16,7 @@
 
 package io.element.android.libraries.matrix.impl.verification
 
+import io.element.android.libraries.core.bool.orFalse
 import io.element.android.libraries.core.data.tryOrNull
 import io.element.android.libraries.matrix.api.sync.SyncState
 import io.element.android.libraries.matrix.api.verification.SessionVerificationData
@@ -24,22 +25,31 @@ import io.element.android.libraries.matrix.api.verification.SessionVerifiedStatu
 import io.element.android.libraries.matrix.api.verification.VerificationEmoji
 import io.element.android.libraries.matrix.api.verification.VerificationFlowState
 import io.element.android.libraries.matrix.impl.sync.RustSyncService
+import io.element.android.libraries.matrix.impl.util.cancelAndDestroy
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.launch
+import org.matrix.rustcomponents.sdk.Client
+import org.matrix.rustcomponents.sdk.Encryption
+import org.matrix.rustcomponents.sdk.RecoveryState
+import org.matrix.rustcomponents.sdk.RecoveryStateListener
 import org.matrix.rustcomponents.sdk.SessionVerificationController
 import org.matrix.rustcomponents.sdk.SessionVerificationControllerDelegate
 import org.matrix.rustcomponents.sdk.SessionVerificationControllerInterface
+import org.matrix.rustcomponents.sdk.TaskHandle
 import org.matrix.rustcomponents.sdk.use
 import org.matrix.rustcomponents.sdk.SessionVerificationData as RustSessionVerificationData
 
 class RustSessionVerificationService(
+    client: Client,
     private val syncService: RustSyncService,
     private val sessionCoroutineScope: CoroutineScope,
 ) : SessionVerificationService, SessionVerificationControllerDelegate {
+    private var recoveryStateListenerTaskHandle: TaskHandle? = null
+    private val encryptionService: Encryption = client.encryption()
     var verificationController: SessionVerificationControllerInterface? = null
         set(value) {
             field = value
@@ -64,6 +74,16 @@ class RustSessionVerificationService(
         syncState == SyncState.Running && verificationStatus == SessionVerifiedStatus.NotVerified
     }
 
+    fun start() {
+        recoveryStateListenerTaskHandle = encryptionService.recoveryStateListener(object : RecoveryStateListener {
+            override fun onUpdate(status: RecoveryState) {
+                sessionCoroutineScope.launch {
+                    updateVerificationStatus(verificationController?.isVerified().orFalse())
+                }
+            }
+        })
+    }
+
     override suspend fun requestVerification() = tryOrFail {
         verificationController?.requestVerification()
     }
@@ -125,6 +145,8 @@ class RustSessionVerificationService(
     }
 
     fun destroy() {
+        recoveryStateListenerTaskHandle?.cancelAndDestroy()
+        verificationController?.setDelegate(null)
         (verificationController as? SessionVerificationController)?.destroy()
         verificationController = null
     }