Add forced logout flow when the proxy is no longer available (#3458)

* Add `MatrixClient.isSlidingSyncProxySupported` function

* Update localazy strings

* Modify `ErrorDialog` to have an `onSubmit` call, which will be used for the submit action.

Also make the title text optional and dismissing the dialog by tapping outside/going back configurable.

* Check if a forced migration to SSS is needed because the proxy is no longer available.

In that case, display the non-dismissable dialog and force the user to log out after enabling SSS.

* Enable native/simplified sliding sync by default.

* Refactor the login to make sure we:

1. Always try native/simplified sliding sync login first, if available.
2. Then, if it wasn't available or failed with an sliding sync not supported error, try with the proxy instead (either discovered proxy or forced custom one).

* Move logic to `LoggedInPresenter` and the UI to `LoggedInView`

* Update screenshots

---------

Co-authored-by: ElementBot <benoitm+elementbot@element.io>

appnav/src/test/kotlin/io/element/android/appnav/loggedin/LoggedInPresenterTest.kt

@@ -29,6 +29,8 @@ import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.test.encryption.FakeEncryptionService
 import io.element.android.libraries.matrix.test.roomlist.FakeRoomListService
 import io.element.android.libraries.matrix.test.verification.FakeSessionVerificationService
+import io.element.android.libraries.preferences.api.store.EnableNativeSlidingSyncUseCase
+import io.element.android.libraries.preferences.test.InMemoryAppPreferencesStore
 import io.element.android.libraries.push.api.PushService
 import io.element.android.libraries.push.test.FakePushService
 import io.element.android.libraries.pushproviders.api.Distributor
@@ -42,6 +44,10 @@ import io.element.android.tests.testutils.lambda.any
 import io.element.android.tests.testutils.lambda.lambdaError
 import io.element.android.tests.testutils.lambda.lambdaRecorder
 import io.element.android.tests.testutils.lambda.value
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runTest
 import org.junit.Rule
 import org.junit.Test
@@ -91,7 +97,8 @@ class LoggedInPresenterTest {
             pushService = FakePushService(),
             sessionVerificationService = verificationService,
             analyticsService = analyticsService,
-            encryptionService = encryptionService
+            encryptionService = encryptionService,
+            enableNativeSlidingSyncUseCase = EnableNativeSlidingSyncUseCase(InMemoryAppPreferencesStore(), this),
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
@@ -487,26 +494,103 @@ class LoggedInPresenterTest {
         )
     }
 
+    @Test
+    fun `present - CheckSlidingSyncProxyAvailability forces the sliding sync migration under the right circumstances`() = runTest {
+        // The migration will be forced if:
+        // - The user is not using the native sliding sync
+        // - The sliding sync proxy is no longer supported
+        // - The native sliding sync is supported
+        val matrixClient = FakeMatrixClient(
+            isUsingNativeSlidingSyncLambda = { false },
+            isSlidingSyncProxySupportedLambda = { false },
+            isNativeSlidingSyncSupportedLambda = { true },
+        )
+        val presenter = createLoggedInPresenter(matrixClient = matrixClient)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.forceNativeSlidingSyncMigration).isFalse()
+
+            initialState.eventSink(LoggedInEvents.CheckSlidingSyncProxyAvailability)
+
+            assertThat(awaitItem().forceNativeSlidingSyncMigration).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - CheckSlidingSyncProxyAvailability will not force the migration if native sliding sync is not supported too`() = runTest {
+        val matrixClient = FakeMatrixClient(
+            isUsingNativeSlidingSyncLambda = { false },
+            isSlidingSyncProxySupportedLambda = { false },
+            isNativeSlidingSyncSupportedLambda = { false },
+        )
+        val presenter = createLoggedInPresenter(matrixClient = matrixClient)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.forceNativeSlidingSyncMigration).isFalse()
+
+            initialState.eventSink(LoggedInEvents.CheckSlidingSyncProxyAvailability)
+
+            expectNoEvents()
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun `present - LogoutAndMigrateToNativeSlidingSync enables native sliding sync and logs out the user`() = runTest {
+        val logoutLambda = lambdaRecorder<Boolean, Boolean, String?> { userInitiated, ignoreSdkError ->
+            assertThat(userInitiated).isTrue()
+            assertThat(ignoreSdkError).isTrue()
+            null
+        }
+        val matrixClient = FakeMatrixClient().apply {
+            this.logoutLambda = logoutLambda
+        }
+        val appPreferencesStore = InMemoryAppPreferencesStore()
+        val enableNativeSlidingSyncUseCase = EnableNativeSlidingSyncUseCase(appPreferencesStore, this)
+        val presenter = createLoggedInPresenter(matrixClient = matrixClient, enableNativeSlidingSyncUseCase = enableNativeSlidingSyncUseCase)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+
+            assertThat(appPreferencesStore.isSimplifiedSlidingSyncEnabledFlow().first()).isFalse()
+
+            initialState.eventSink(LoggedInEvents.LogoutAndMigrateToNativeSlidingSync)
+
+            advanceUntilIdle()
+
+            assertThat(appPreferencesStore.isSimplifiedSlidingSyncEnabledFlow().first()).isTrue()
+            assertThat(logoutLambda.assertions().isCalledOnce())
+        }
+    }
+
     private suspend fun <T> ReceiveTurbine<T>.awaitFirstItem(): T {
         skipItems(1)
         return awaitItem()
     }
 
-    private fun createLoggedInPresenter(
+    private fun TestScope.createLoggedInPresenter(
         roomListService: RoomListService = FakeRoomListService(),
         networkStatus: NetworkStatus = NetworkStatus.Offline,
         analyticsService: AnalyticsService = FakeAnalyticsService(),
         sessionVerificationService: SessionVerificationService = FakeSessionVerificationService(),
         encryptionService: EncryptionService = FakeEncryptionService(),
         pushService: PushService = FakePushService(),
+        enableNativeSlidingSyncUseCase: EnableNativeSlidingSyncUseCase = EnableNativeSlidingSyncUseCase(InMemoryAppPreferencesStore(), this),
+        matrixClient: MatrixClient = FakeMatrixClient(roomListService = roomListService),
     ): LoggedInPresenter {
         return LoggedInPresenter(
-            matrixClient = FakeMatrixClient(roomListService = roomListService),
+            matrixClient = matrixClient,
             networkMonitor = FakeNetworkMonitor(networkStatus),
             pushService = pushService,
             sessionVerificationService = sessionVerificationService,
             analyticsService = analyticsService,
-            encryptionService = encryptionService
+            encryptionService = encryptionService,
+            enableNativeSlidingSyncUseCase = enableNativeSlidingSyncUseCase,
         )
     }
 }