fix(deps): update dependency org.matrix.rustcomponents:sdk-android to v25 (#4273)

* fix(deps): update dependency org.matrix.rustcomponents:sdk-android to v25

* Adapt to SDK changes:

- Remove logic related to sliding sync proxy, leaving just the minimum needed to detect its usage on the current session data.
- Remove code associated with the opt-in migration to native sliding sync, since it's now mandatory.
- Remove toggle between proxy/native sliding sync.
- Some fixes to session verification API breaks.

* Update forced logout dialog message, remove `NativeSlidingSyncMigrationBanner`

* Update screenshots

* Update all strings

* Remove `SuccessfulLogoutPendingAction`

---------

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

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

@@ -129,10 +129,8 @@ class RustMatrixClientFactory @Inject constructor(
                 // Apply sliding sync version settings
                 when (slidingSyncType) {
                     ClientBuilderSlidingSync.Restored -> this
-                    is ClientBuilderSlidingSync.CustomProxy -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.Proxy(slidingSyncType.url))
-                    ClientBuilderSlidingSync.Discovered -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.DiscoverProxy)
-                    ClientBuilderSlidingSync.Simplified -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.DiscoverNative)
-                    ClientBuilderSlidingSync.ForcedSimplified -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.Native)
+                    ClientBuilderSlidingSync.Discovered -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.DISCOVER_NATIVE)
+                    ClientBuilderSlidingSync.Native -> slidingSyncVersionBuilder(SlidingSyncVersionBuilder.NATIVE)
                 }
             }
             .run {
@@ -143,21 +141,14 @@ class RustMatrixClientFactory @Inject constructor(
 }
 
 sealed interface ClientBuilderSlidingSync {
-    // The proxy is set by the user.
-    data class CustomProxy(val url: String) : ClientBuilderSlidingSync
-
     // The proxy will be supplied when restoring the Session.
     data object Restored : ClientBuilderSlidingSync
 
-    // A proxy must be discovered whilst building the session.
+    // A Native Sliding Sync instance must be discovered whilst building the session.
     data object Discovered : ClientBuilderSlidingSync
 
-    // Use Simplified Sliding Sync.
-    data object Simplified : ClientBuilderSlidingSync
-
-    // Force using Simplified Sliding Sync.
-    // TODO allow the user to select between proxy, simplified or force simplified in developer options.
-    data object ForcedSimplified : ClientBuilderSlidingSync
+    // Force using Native Sliding Sync.
+    data object Native : ClientBuilderSlidingSync
 }
 
 private fun SessionData.toSession() = Session(
@@ -166,6 +157,6 @@ private fun SessionData.toSession() = Session(
     userId = userId,
     deviceId = deviceId,
     homeserverUrl = homeserverUrl,
-    slidingSyncVersion = slidingSyncProxy?.let(SlidingSyncVersion::Proxy) ?: SlidingSyncVersion.Native,
+    slidingSyncVersion = SlidingSyncVersion.NATIVE,
     oidcData = oidcData,
 )

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

@@ -8,7 +8,6 @@
 package io.element.android.libraries.matrix.impl.auth
 
 import com.squareup.anvil.annotations.ContributesBinding
-import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.core.extensions.mapFailure
 import io.element.android.libraries.di.AppScope
@@ -32,7 +31,6 @@ import io.element.android.libraries.matrix.impl.keys.PassphraseGenerator
 import io.element.android.libraries.matrix.impl.mapper.toSessionData
 import io.element.android.libraries.matrix.impl.paths.SessionPaths
 import io.element.android.libraries.matrix.impl.paths.SessionPathsFactory
-import io.element.android.libraries.preferences.api.store.AppPreferencesStore
 import io.element.android.libraries.sessionstorage.api.LoggedInState
 import io.element.android.libraries.sessionstorage.api.LoginType
 import io.element.android.libraries.sessionstorage.api.SessionStore
@@ -40,10 +38,8 @@ import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.Client
-import org.matrix.rustcomponents.sdk.ClientBuildException
 import org.matrix.rustcomponents.sdk.ClientBuilder
 import org.matrix.rustcomponents.sdk.HumanQrLoginException
 import org.matrix.rustcomponents.sdk.OidcConfiguration
@@ -64,7 +60,6 @@ class RustMatrixAuthenticationService @Inject constructor(
     private val rustMatrixClientFactory: RustMatrixClientFactory,
     private val passphraseGenerator: PassphraseGenerator,
     private val oidcConfigurationProvider: OidcConfigurationProvider,
-    private val appPreferencesStore: AppPreferencesStore,
 ) : MatrixAuthenticationService {
     // Passphrase which will be used for new sessions. Existing sessions will use the passphrase
     // stored in the SessionData.
@@ -288,28 +283,12 @@ class RustMatrixAuthenticationService @Inject constructor(
         sessionPaths: SessionPaths,
         config: suspend ClientBuilder.() -> ClientBuilder,
     ): Client {
-        val slidingSyncType = getSlidingSyncType()
-        if (slidingSyncType is ClientBuilderSlidingSync.Simplified) {
-            Timber.d("Creating client with simplified sliding sync")
-            try {
-                return rustMatrixClientFactory
-                    .getBaseClientBuilder(
-                        sessionPaths = sessionPaths,
-                        passphrase = pendingPassphrase,
-                        slidingSyncType = slidingSyncType,
-                    )
-                    .config()
-                    .build()
-            } catch (e: ClientBuildException.SlidingSyncVersion) {
-                Timber.e(e, "Failed to create client with simplified sliding sync, trying with Proxy now")
-            }
-        }
-        Timber.d("Creating client with Proxy sliding sync")
+        Timber.d("Creating client with simplified sliding sync")
         return rustMatrixClientFactory
             .getBaseClientBuilder(
                 sessionPaths = sessionPaths,
                 passphrase = pendingPassphrase,
-                slidingSyncType = getSlidingSyncProxy(),
+                slidingSyncType = ClientBuilderSlidingSync.Discovered,
             )
             .config()
             .build()
@@ -322,43 +301,17 @@ class RustMatrixAuthenticationService @Inject constructor(
         oidcConfiguration: OidcConfiguration,
         progressListener: QrLoginProgressListener,
     ): Client {
-        val slidingSyncType = getSlidingSyncType()
-        if (slidingSyncType is ClientBuilderSlidingSync.Simplified) {
-            Timber.d("Creating client for QR Code login with simplified sliding sync")
-            try {
-                return rustMatrixClientFactory
-                    .getBaseClientBuilder(
-                        sessionPaths = sessionPaths,
-                        passphrase = pendingPassphrase,
-                        slidingSyncType = slidingSyncType,
-                    )
-                    .passphrase(passphrase)
-                    .buildWithQrCode(qrCodeData, oidcConfiguration, progressListener)
-            } catch (e: HumanQrLoginException.SlidingSyncNotAvailable) {
-                Timber.e(e, "Failed to create client with simplified sliding sync, trying with Proxy now")
-            }
-        }
-        Timber.d("Creating client for QR Code login with Proxy sliding sync")
+        Timber.d("Creating client for QR Code login with simplified sliding sync")
         return rustMatrixClientFactory
             .getBaseClientBuilder(
                 sessionPaths = sessionPaths,
                 passphrase = pendingPassphrase,
-                slidingSyncType = getSlidingSyncProxy(),
+                slidingSyncType = ClientBuilderSlidingSync.Discovered,
             )
             .passphrase(passphrase)
             .buildWithQrCode(qrCodeData, oidcConfiguration, progressListener)
     }
 
-    private suspend fun getSlidingSyncType(nativeSlidingSyncFailed: Boolean = false) = when {
-        appPreferencesStore.isSimplifiedSlidingSyncEnabledFlow().first() && !nativeSlidingSyncFailed -> ClientBuilderSlidingSync.Simplified
-        else -> getSlidingSyncProxy()
-    }
-
-    private fun getSlidingSyncProxy() = when {
-        AuthenticationConfig.SLIDING_SYNC_PROXY_URL != null -> ClientBuilderSlidingSync.CustomProxy(AuthenticationConfig.SLIDING_SYNC_PROXY_URL!!)
-        else -> ClientBuilderSlidingSync.Discovered
-    }
-
     private fun clear() {
         currentClient?.close()
         currentClient = null

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

@@ -12,7 +12,6 @@ import io.element.android.libraries.matrix.impl.paths.SessionPaths
 import io.element.android.libraries.sessionstorage.api.LoginType
 import io.element.android.libraries.sessionstorage.api.SessionData
 import org.matrix.rustcomponents.sdk.Session
-import org.matrix.rustcomponents.sdk.SlidingSyncVersion
 import java.util.Date
 
 internal fun Session.toSessionData(
@@ -28,7 +27,7 @@ internal fun Session.toSessionData(
     refreshToken = refreshToken,
     homeserverUrl = homeserverUrl ?: this.homeserverUrl,
     oidcData = oidcData,
-    slidingSyncProxy = (slidingSyncVersion as? SlidingSyncVersion.Proxy)?.url,
+    slidingSyncProxy = null,
     loginTimestamp = Date(),
     isTokenValid = isTokenValid,
     loginType = loginType,

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

@@ -12,8 +12,7 @@ import org.matrix.rustcomponents.sdk.SlidingSyncVersion as RustSlidingSyncVersio
 
 internal fun RustSlidingSyncVersion.map(): SlidingSyncVersion {
     return when (this) {
-        RustSlidingSyncVersion.None -> SlidingSyncVersion.None
-        is RustSlidingSyncVersion.Proxy -> SlidingSyncVersion.Proxy
-        RustSlidingSyncVersion.Native -> SlidingSyncVersion.Native
+        RustSlidingSyncVersion.NONE -> SlidingSyncVersion.None
+        RustSlidingSyncVersion.NATIVE -> SlidingSyncVersion.Native
     }
 }

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

@@ -113,7 +113,7 @@ class RustSessionVerificationService(
 
     override suspend fun requestVerification() = tryOrFail {
         initVerificationControllerIfNeeded()
-        verificationController.requestVerification()
+        verificationController.requestDeviceVerification()
     }
 
     override suspend fun cancelVerification() = tryOrFail {

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

@@ -14,9 +14,9 @@ import io.element.android.libraries.matrix.api.verification.SessionVerificationR
 import org.matrix.rustcomponents.sdk.SessionVerificationRequestDetails as RustSessionVerificationRequestDetails
 
 fun RustSessionVerificationRequestDetails.map() = SessionVerificationRequestDetails(
-    senderId = UserId(senderId),
+    senderId = UserId(senderProfile.userId),
     flowId = FlowId(flowId),
     deviceId = DeviceId(deviceId),
-    displayName = displayName,
+    displayName = senderProfile.displayName,
     firstSeenTimestamp = firstSeenTimestamp.toLong(),
 )