Merge pull request #3222 from element-hq/feature/jme/add-simplified-sliding-sync-toggle

Add simplified sliding sync toggle to developer options

features/lockscreen/impl/build.gradle.kts

@@ -41,6 +41,7 @@ dependencies {
     implementation(projects.libraries.featureflag.api)
     implementation(projects.libraries.cryptography.api)
     implementation(projects.libraries.preferences.api)
+    implementation(projects.features.logout.api)
     implementation(projects.libraries.uiStrings)
     implementation(projects.libraries.sessionStorage.api)
     implementation(projects.services.appnavstate.api)
@@ -59,4 +60,5 @@ dependencies {
     testImplementation(projects.libraries.featureflag.test)
     testImplementation(projects.libraries.sessionStorage.test)
     testImplementation(projects.services.appnavstate.test)
+    testImplementation(projects.features.logout.test)
 }

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/unlock/PinUnlockPresenter.kt

@@ -29,7 +29,7 @@ import io.element.android.features.lockscreen.impl.biometric.BiometricUnlockMana
 import io.element.android.features.lockscreen.impl.pin.PinCodeManager
 import io.element.android.features.lockscreen.impl.pin.model.PinEntry
 import io.element.android.features.lockscreen.impl.unlock.keypad.PinKeypadModel
-import io.element.android.features.lockscreen.impl.unlock.signout.SignOut
+import io.element.android.features.logout.api.LogoutUseCase
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.architecture.runCatchingUpdatingState
@@ -41,7 +41,7 @@ import javax.inject.Inject
 class PinUnlockPresenter @Inject constructor(
     private val pinCodeManager: PinCodeManager,
     private val biometricUnlockManager: BiometricUnlockManager,
-    private val signOut: SignOut,
+    private val logoutUseCase: LogoutUseCase,
     private val coroutineScope: CoroutineScope,
     private val pinUnlockHelper: PinUnlockHelper,
 ) : Presenter<PinUnlockState> {
@@ -179,7 +179,7 @@ class PinUnlockPresenter @Inject constructor(
 
     private fun CoroutineScope.signOut(signOutAction: MutableState<AsyncData<String?>>) = launch {
         suspend {
-            signOut()
+            logoutUseCase.logout(ignoreSdkError = true)
         }.runCatchingUpdatingState(signOutAction)
     }
 }

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/unlock/di/PinUnlockBindings.kt

@@ -18,9 +18,9 @@ package io.element.android.features.lockscreen.impl.unlock.di
 
 import com.squareup.anvil.annotations.ContributesTo
 import io.element.android.features.lockscreen.impl.unlock.activity.PinUnlockActivity
-import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.SessionScope
 
-@ContributesTo(AppScope::class)
+@ContributesTo(SessionScope::class)
 interface PinUnlockBindings {
     fun inject(activity: PinUnlockActivity)
 }

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/unlock/signout/DefaultSignOut.kt

@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2024 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.features.lockscreen.impl.unlock.signout
-
-import com.squareup.anvil.annotations.ContributesBinding
-import io.element.android.libraries.di.AppScope
-import io.element.android.libraries.matrix.api.MatrixClientProvider
-import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
-import javax.inject.Inject
-
-@ContributesBinding(AppScope::class)
-class DefaultSignOut @Inject constructor(
-    private val authenticationService: MatrixAuthenticationService,
-    private val matrixClientProvider: MatrixClientProvider,
-) : SignOut {
-    override suspend fun invoke(): String? {
-        val currentSession = authenticationService.getLatestSessionId()
-        return if (currentSession != null) {
-            matrixClientProvider.getOrRestore(currentSession)
-                .getOrThrow()
-                .logout(ignoreSdkError = true)
-        } else {
-            error("No session to sign out")
-        }
-    }
-}

features/lockscreen/impl/src/test/kotlin/io/element/android/features/lockscreen/impl/unlock/DefaultSignOutTest.kt

@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2024 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.features.lockscreen.impl.unlock
-
-import com.google.common.truth.Truth.assertThat
-import io.element.android.features.lockscreen.impl.unlock.signout.DefaultSignOut
-import io.element.android.libraries.matrix.test.FakeMatrixClient
-import io.element.android.libraries.matrix.test.FakeMatrixClientProvider
-import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService
-import io.element.android.tests.testutils.lambda.assert
-import io.element.android.tests.testutils.lambda.lambdaRecorder
-import kotlinx.coroutines.test.runTest
-import org.junit.Test
-
-class DefaultSignOutTest {
-    private val matrixClient = FakeMatrixClient()
-    private val authenticationService = FakeMatrixAuthenticationService()
-    private val matrixClientProvider = FakeMatrixClientProvider(getClient = { Result.success(matrixClient) })
-    private val sut = DefaultSignOut(authenticationService, matrixClientProvider)
-
-    @Test
-    fun `when no active session then it throws`() = runTest {
-        authenticationService.getLatestSessionIdLambda = { null }
-        val result = runCatching { sut.invoke() }
-        assertThat(result.isFailure).isTrue()
-    }
-
-    @Test
-    fun `with one active session and successful logout on client`() = runTest {
-        val logoutLambda = lambdaRecorder<Boolean, String?> { _: Boolean -> null }
-        authenticationService.getLatestSessionIdLambda = { matrixClient.sessionId }
-        matrixClient.logoutLambda = logoutLambda
-        val result = runCatching { sut.invoke() }
-        assertThat(result.isSuccess).isTrue()
-        assert(logoutLambda).isCalledOnce()
-    }
-
-    @Test
-    fun `with one active session and and failed logout on client`() = runTest {
-        val logoutLambda = lambdaRecorder<Boolean, String?> { _: Boolean -> error("Failed to logout") }
-        authenticationService.getLatestSessionIdLambda = { matrixClient.sessionId }
-        matrixClient.logoutLambda = logoutLambda
-        val result = runCatching { sut.invoke() }
-        assertThat(result.isFailure).isTrue()
-        assert(logoutLambda).isCalledOnce()
-    }
-}

features/lockscreen/impl/src/test/kotlin/io/element/android/features/lockscreen/impl/unlock/PinUnlockPresenterTest.kt

@@ -28,7 +28,7 @@ import io.element.android.features.lockscreen.impl.pin.PinCodeManager
 import io.element.android.features.lockscreen.impl.pin.model.PinEntry
 import io.element.android.features.lockscreen.impl.pin.model.assertText
 import io.element.android.features.lockscreen.impl.unlock.keypad.PinKeypadModel
-import io.element.android.features.lockscreen.impl.unlock.signout.SignOut
+import io.element.android.features.logout.test.FakeLogoutUseCase
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.tests.testutils.lambda.assert
 import io.element.android.tests.testutils.lambda.lambdaRecorder
@@ -106,9 +106,9 @@ class PinUnlockPresenterTest {
 
     @Test
     fun `present - forgot pin flow`() = runTest {
-        val signOutLambda = lambdaRecorder<String?> { null }
-        val signOut = FakeSignOut(signOutLambda)
-        val presenter = createPinUnlockPresenter(this, signOut = signOut)
+        val signOutLambda = lambdaRecorder<Boolean, String> { "" }
+        val signOut = FakeLogoutUseCase(signOutLambda)
+        val presenter = createPinUnlockPresenter(this, logoutUseCase = signOut)
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -135,7 +135,7 @@ class PinUnlockPresenterTest {
             awaitItem().also { state ->
                 assertThat(state.signOutAction).isInstanceOf(AsyncData.Success::class.java)
             }
-            assert(signOutLambda).isCalledOnce().withNoParameter()
+            assert(signOutLambda).isCalledOnce()
         }
     }
 
@@ -147,7 +147,7 @@ class PinUnlockPresenterTest {
         scope: CoroutineScope,
         biometricUnlockManager: BiometricUnlockManager = FakeBiometricUnlockManager(),
         callback: PinCodeManager.Callback = DefaultPinCodeManagerCallback(),
-        signOut: SignOut = FakeSignOut(),
+        logoutUseCase: FakeLogoutUseCase = FakeLogoutUseCase(logoutLambda = { "" }),
     ): PinUnlockPresenter {
         val pinCodeManager = aPinCodeManager().apply {
             addCallback(callback)
@@ -156,7 +156,7 @@ class PinUnlockPresenterTest {
         return PinUnlockPresenter(
             pinCodeManager = pinCodeManager,
             biometricUnlockManager = biometricUnlockManager,
-            signOut = signOut,
+            logoutUseCase = logoutUseCase,
             coroutineScope = scope,
             pinUnlockHelper = PinUnlockHelper(biometricUnlockManager, pinCodeManager),
         )

features/logout/api/src/main/kotlin/io/element/android/features/logout/api/LogoutUseCase.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2024 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
+ *
+ *     https://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.features.logout.api
+
+/**
+ * Used to trigger a log out of the current user from any part of the app.
+ */
+interface LogoutUseCase {
+    /**
+     * Log out the current user and then perform any needed cleanup tasks.
+     * @param ignoreSdkError if true, the SDK error will be ignored and the user will be logged out anyway.
+     * @return the session id of the logged out user.
+     */
+    suspend fun logout(ignoreSdkError: Boolean): String
+
+    interface Factory {
+        fun create(sessionId: String): LogoutUseCase
+    }
+}

features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/DefaultLogoutUseCase.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 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
+ *
+ *     https://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.features.logout.impl
+
+import com.squareup.anvil.annotations.ContributesBinding
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import io.element.android.features.logout.api.LogoutUseCase
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.api.MatrixClientProvider
+import io.element.android.libraries.matrix.api.core.SessionId
+
+class DefaultLogoutUseCase @AssistedInject constructor(
+    @Assisted private val sessionId: String,
+    private val matrixClientProvider: MatrixClientProvider,
+) : LogoutUseCase {
+    @ContributesBinding(AppScope::class)
+    @AssistedFactory
+    interface Factory : LogoutUseCase.Factory {
+        override fun create(sessionId: String): DefaultLogoutUseCase
+    }
+
+    override suspend fun logout(ignoreSdkError: Boolean): String {
+        val matrixClient = matrixClientProvider.getOrRestore(SessionId(sessionId)).getOrThrow()
+        matrixClient.logout(ignoreSdkError = ignoreSdkError)
+        return sessionId
+    }
+}

features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/SessionLogoutModule.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2024 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
+ *
+ *     https://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.features.logout.impl
+
+import com.squareup.anvil.annotations.ContributesTo
+import dagger.Module
+import dagger.Provides
+import io.element.android.features.logout.api.LogoutUseCase
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.user.CurrentSessionIdHolder
+
+@Module
+@ContributesTo(SessionScope::class)
+object SessionLogoutModule {
+     @Provides
+     fun provideLogoutUseCase(
+         currentSessionIdHolder: CurrentSessionIdHolder,
+         factory: DefaultLogoutUseCase.Factory,
+     ): LogoutUseCase {
+         return factory.create(currentSessionIdHolder.current.value)
+     }
+}

features/logout/test/build.gradle.kts

@@ -5,7 +5,7 @@
  * 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
+ *     https://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,
@@ -14,8 +14,16 @@
  * limitations under the License.
  */
 
-package io.element.android.features.lockscreen.impl.unlock.signout
-
-interface SignOut {
-    suspend operator fun invoke(): String?
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.features.logout.test"
+}
+
+dependencies {
+    implementation(libs.coroutines.core)
+    implementation(projects.tests.testutils)
+    api(projects.features.logout.api)
 }

features/logout/test/src/main/kotlin/io/element/android/features/logout/test/FakeLogoutUseCase.kt

@@ -5,7 +5,7 @@
  * 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
+ *     https://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,
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package io.element.android.features.lockscreen.impl.unlock
+package io.element.android.features.logout.test
 
-import io.element.android.features.lockscreen.impl.unlock.signout.SignOut
-import io.element.android.tests.testutils.simulateLongTask
+import io.element.android.features.logout.api.LogoutUseCase
+import io.element.android.tests.testutils.lambda.lambdaError
 
-class FakeSignOut(
-    var lambda: () -> String? = { null }
-) : SignOut {
-    override suspend fun invoke(): String? = simulateLongTask {
-        lambda()
+class FakeLogoutUseCase(
+    var logoutLambda: (Boolean) -> String = lambdaError()
+) : LogoutUseCase {
+    override suspend fun logout(ignoreSdkError: Boolean): String {
+        return logoutLambda(ignoreSdkError)
     }
 }

features/preferences/impl/build.gradle.kts

@@ -90,6 +90,7 @@ dependencies {
     testImplementation(projects.features.ftue.test)
     testImplementation(projects.features.rageshake.test)
     testImplementation(projects.features.rageshake.impl)
+    testImplementation(projects.features.logout.test)
     testImplementation(projects.features.roomlist.test)
     testImplementation(projects.libraries.indicator.impl)
     testImplementation(projects.libraries.pushproviders.test)

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/developer/DeveloperSettingsEvents.kt

@@ -21,5 +21,6 @@ import io.element.android.libraries.featureflag.ui.model.FeatureUiModel
 sealed interface DeveloperSettingsEvents {
     data class UpdateEnabledFeature(val feature: FeatureUiModel, val isEnabled: Boolean) : DeveloperSettingsEvents
     data class SetCustomElementCallBaseUrl(val baseUrl: String?) : DeveloperSettingsEvents
+    data class SetSimplifiedSlidingSyncEnabled(val isEnabled: Boolean) : DeveloperSettingsEvents
     data object ClearCache : DeveloperSettingsEvents
 }

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/developer/DeveloperSettingsPresenter.kt

@@ -28,6 +28,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.snapshots.SnapshotStateMap
 import io.element.android.appconfig.ElementCallConfig
+import io.element.android.features.logout.api.LogoutUseCase
 import io.element.android.features.preferences.impl.tasks.ClearCacheUseCase
 import io.element.android.features.preferences.impl.tasks.ComputeCacheSizeUseCase
 import io.element.android.features.rageshake.api.preferences.RageshakePreferencesPresenter
@@ -55,6 +56,7 @@ class DeveloperSettingsPresenter @Inject constructor(
     private val rageshakePresenter: RageshakePreferencesPresenter,
     private val appPreferencesStore: AppPreferencesStore,
     private val buildMeta: BuildMeta,
+    private val logoutUseCase: LogoutUseCase,
 ) : Presenter<DeveloperSettingsState> {
     @Composable
     override fun present(): DeveloperSettingsState {
@@ -75,6 +77,9 @@ class DeveloperSettingsPresenter @Inject constructor(
         val customElementCallBaseUrl by appPreferencesStore
             .getCustomElementCallBaseUrlFlow()
             .collectAsState(initial = null)
+        val isSimplifiedSlidingSyncEnabled by appPreferencesStore
+            .isSimplifiedSlidingSyncEnabledFlow()
+            .collectAsState(initial = false)
 
         LaunchedEffect(Unit) {
             FeatureFlags.entries
@@ -114,6 +119,10 @@ class DeveloperSettingsPresenter @Inject constructor(
                     appPreferencesStore.setCustomElementCallBaseUrl(urlToSave)
                 }
                 DeveloperSettingsEvents.ClearCache -> coroutineScope.clearCache(clearCacheAction)
+                is DeveloperSettingsEvents.SetSimplifiedSlidingSyncEnabled -> coroutineScope.launch {
+                    appPreferencesStore.setSimplifiedSlidingSyncEnabled(event.isEnabled)
+                    logoutUseCase.logout(ignoreSdkError = true)
+                }
             }
         }
 
@@ -127,6 +136,7 @@ class DeveloperSettingsPresenter @Inject constructor(
                 defaultUrl = ElementCallConfig.DEFAULT_BASE_URL,
                 validator = ::customElementCallUrlValidator,
             ),
+            isSimpleSlidingSyncEnabled = isSimplifiedSlidingSyncEnabled,
             eventSink = ::handleEvents
         )
     }

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/developer/DeveloperSettingsState.kt

@@ -27,6 +27,7 @@ data class DeveloperSettingsState(
     val rageshakeState: RageshakePreferencesState,
     val clearCacheAction: AsyncData<Unit>,
     val customElementCallBaseUrlState: CustomElementCallBaseUrlState,
+    val isSimpleSlidingSyncEnabled: Boolean,
     val eventSink: (DeveloperSettingsEvents) -> Unit
 )
 

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/developer/DeveloperSettingsStateProvider.kt

@@ -39,6 +39,7 @@ open class DeveloperSettingsStateProvider : PreviewParameterProvider<DeveloperSe
 fun aDeveloperSettingsState(
     clearCacheAction: AsyncData<Unit> = AsyncData.Uninitialized,
     customElementCallBaseUrlState: CustomElementCallBaseUrlState = aCustomElementCallBaseUrlState(),
+    isSimplifiedSlidingSyncEnabled: Boolean = false,
     eventSink: (DeveloperSettingsEvents) -> Unit = {},
 ) = DeveloperSettingsState(
     features = aFeatureUiModelList(),
@@ -46,6 +47,7 @@ fun aDeveloperSettingsState(
     cacheSize = AsyncData.Success("1.2 MB"),
     clearCacheAction = clearCacheAction,
     customElementCallBaseUrlState = customElementCallBaseUrlState,
+    isSimpleSlidingSyncEnabled = isSimplifiedSlidingSyncEnabled,
     eventSink = eventSink,
 )
 

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/developer/DeveloperSettingsView.kt

@@ -26,6 +26,7 @@ import io.element.android.features.preferences.impl.R
 import io.element.android.features.rageshake.api.preferences.RageshakePreferencesView
 import io.element.android.libraries.designsystem.components.preferences.PreferenceCategory
 import io.element.android.libraries.designsystem.components.preferences.PreferencePage
+import io.element.android.libraries.designsystem.components.preferences.PreferenceSwitch
 import io.element.android.libraries.designsystem.components.preferences.PreferenceText
 import io.element.android.libraries.designsystem.components.preferences.PreferenceTextField
 import io.element.android.libraries.designsystem.preview.ElementPreview
@@ -60,6 +61,14 @@ fun DeveloperSettingsView(
                 title = "Configure tracing",
                 onClick = onOpenConfigureTracing,
             )
+            PreferenceSwitch(
+                title = "Enable Simplified Sliding Sync",
+                subtitle = "When toggled you'll be logged out of the app and will need to log in again.",
+                isChecked = state.isSimpleSlidingSyncEnabled,
+                onCheckedChange = {
+                    state.eventSink(DeveloperSettingsEvents.SetSimplifiedSlidingSyncEnabled(it))
+                }
+            )
         }
         PreferenceCategory(title = "Showkase") {
             PreferenceText(

features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/developer/DeveloperSettingsPresenterTest.kt

@@ -21,6 +21,7 @@ import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
 import io.element.android.appconfig.ElementCallConfig
+import io.element.android.features.logout.test.FakeLogoutUseCase
 import io.element.android.features.preferences.impl.tasks.FakeClearCacheUseCase
 import io.element.android.features.preferences.impl.tasks.FakeComputeCacheSizeUseCase
 import io.element.android.features.rageshake.impl.preferences.DefaultRageshakePreferencesPresenter
@@ -35,6 +36,8 @@ import io.element.android.libraries.matrix.test.core.aBuildMeta
 import io.element.android.libraries.preferences.test.InMemoryAppPreferencesStore
 import io.element.android.tests.testutils.WarmUpRule
 import io.element.android.tests.testutils.awaitLastSequentialItem
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import org.junit.Rule
 import org.junit.Test
@@ -55,6 +58,7 @@ class DeveloperSettingsPresenterTest {
             assertThat(initialState.cacheSize).isEqualTo(AsyncData.Uninitialized)
             assertThat(initialState.customElementCallBaseUrlState).isNotNull()
             assertThat(initialState.customElementCallBaseUrlState.baseUrl).isNull()
+            assertThat(initialState.isSimpleSlidingSyncEnabled).isFalse()
             val loadedState = awaitItem()
             assertThat(loadedState.rageshakeState.isEnabled).isFalse()
             assertThat(loadedState.rageshakeState.isSupported).isTrue()
@@ -160,6 +164,30 @@ class DeveloperSettingsPresenterTest {
         }
     }
 
+    @Test
+    fun `present - toggling simplified sliding sync changes the preferences and logs out the user`() = runTest {
+        val logoutCallRecorder = lambdaRecorder<Boolean, String> { "" }
+        val logoutUseCase = FakeLogoutUseCase(logoutLambda = logoutCallRecorder)
+        val preferences = InMemoryAppPreferencesStore()
+        val presenter = createDeveloperSettingsPresenter(preferencesStore = preferences, logoutUseCase = logoutUseCase)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitLastSequentialItem()
+            assertThat(initialState.isSimpleSlidingSyncEnabled).isFalse()
+
+            initialState.eventSink(DeveloperSettingsEvents.SetSimplifiedSlidingSyncEnabled(true))
+            assertThat(awaitItem().isSimpleSlidingSyncEnabled).isTrue()
+            assertThat(preferences.isSimplifiedSlidingSyncEnabledFlow().first()).isTrue()
+            logoutCallRecorder.assertions().isCalledOnce()
+
+            initialState.eventSink(DeveloperSettingsEvents.SetSimplifiedSlidingSyncEnabled(false))
+            assertThat(awaitItem().isSimpleSlidingSyncEnabled).isFalse()
+            assertThat(preferences.isSimplifiedSlidingSyncEnabledFlow().first()).isFalse()
+            logoutCallRecorder.assertions().isCalledExactly(times = 2)
+        }
+    }
+
     private fun createDeveloperSettingsPresenter(
         featureFlagService: FakeFeatureFlagService = FakeFeatureFlagService(),
         cacheSizeUseCase: FakeComputeCacheSizeUseCase = FakeComputeCacheSizeUseCase(),
@@ -167,6 +195,7 @@ class DeveloperSettingsPresenterTest {
         rageshakePresenter: DefaultRageshakePreferencesPresenter = DefaultRageshakePreferencesPresenter(FakeRageShake(), FakeRageshakeDataStore()),
         preferencesStore: InMemoryAppPreferencesStore = InMemoryAppPreferencesStore(),
         buildMeta: BuildMeta = aBuildMeta(),
+        logoutUseCase: FakeLogoutUseCase = FakeLogoutUseCase(logoutLambda = { "" })
     ): DeveloperSettingsPresenter {
         return DeveloperSettingsPresenter(
             featureFlagService = featureFlagService,
@@ -175,6 +204,7 @@ class DeveloperSettingsPresenterTest {
             rageshakePresenter = rageshakePresenter,
             appPreferencesStore = preferencesStore,
             buildMeta = buildMeta,
+            logoutUseCase = logoutUseCase,
         )
     }
 }

features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/developer/DeveloperSettingsViewTest.kt

@@ -109,6 +109,19 @@ class DeveloperSettingsViewTest {
         rule.onNodeWithText("Clear cache").performClick()
         eventsRecorder.assertSingle(DeveloperSettingsEvents.ClearCache)
     }
+
+    @Config(qualifiers = "h1500dp")
+    @Test
+    fun `clicking on the simplified sliding sync switch emits the expected event`() {
+        val eventsRecorder = EventsRecorder<DeveloperSettingsEvents>()
+        rule.setDeveloperSettingsView(
+            state = aDeveloperSettingsState(
+                eventSink = eventsRecorder
+            ),
+        )
+        rule.onNodeWithText("Enable Simplified Sliding Sync").performClick()
+        eventsRecorder.assertSingle(DeveloperSettingsEvents.SetSimplifiedSlidingSyncEnabled(true))
+    }
 }
 
 private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setDeveloperSettingsView(

libraries/matrix/impl/build.gradle.kts

@@ -37,12 +37,13 @@ dependencies {
         debugImplementation(libs.matrix.sdk)
     }
     implementation(projects.appconfig)
-    implementation(projects.libraries.di)
     implementation(projects.libraries.androidutils)
+    implementation(projects.libraries.di)
+    implementation(projects.libraries.featureflag.api)
     implementation(projects.libraries.network)
+    implementation(projects.libraries.preferences.api)
     implementation(projects.services.analytics.api)
     implementation(projects.services.toolbox.api)
-    implementation(projects.libraries.featureflag.api)
     api(projects.libraries.matrix.api)
     implementation(libs.dagger)
     implementation(projects.libraries.core)

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

@@ -23,10 +23,12 @@ import io.element.android.libraries.matrix.impl.certificates.UserCertificatesPro
 import io.element.android.libraries.matrix.impl.proxy.ProxyProvider
 import io.element.android.libraries.matrix.impl.util.anonymizedTokens
 import io.element.android.libraries.network.useragent.UserAgentProvider
+import io.element.android.libraries.preferences.api.store.AppPreferencesStore
 import io.element.android.libraries.sessionstorage.api.SessionData
 import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.services.toolbox.api.systemclock.SystemClock
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.ClientBuilder
 import org.matrix.rustcomponents.sdk.Session
@@ -46,9 +48,18 @@ class RustMatrixClientFactory @Inject constructor(
     private val proxyProvider: ProxyProvider,
     private val clock: SystemClock,
     private val utdTracker: UtdTracker,
+    private val appPreferencesStore: AppPreferencesStore,
 ) {
     suspend fun create(sessionData: SessionData): RustMatrixClient = withContext(coroutineDispatchers.io) {
-        val client = getBaseClientBuilder(sessionData.sessionPath, sessionData.passphrase)
+        val client = getBaseClientBuilder(
+            sessionPath = sessionData.sessionPath,
+            passphrase = sessionData.passphrase,
+            slidingSync = if (appPreferencesStore.isSimplifiedSlidingSyncEnabledFlow().first()) {
+                ClientBuilderSlidingSync.Simplified
+            } else {
+                ClientBuilderSlidingSync.Restored
+            },
+        )
             .homeserverUrl(sessionData.homeserverUrl)
             .username(sessionData.userId)
             .use { it.build() }
@@ -79,6 +90,7 @@ class RustMatrixClientFactory @Inject constructor(
         sessionPath: String,
         passphrase: String?,
         slidingSyncProxy: String? = null,
+        slidingSync: ClientBuilderSlidingSync,
     ): ClientBuilder {
         return ClientBuilder()
             .sessionPath(sessionPath)
@@ -88,6 +100,13 @@ class RustMatrixClientFactory @Inject constructor(
             .addRootCertificates(userCertificatesProvider.provides())
             .autoEnableBackups(true)
             .autoEnableCrossSigning(true)
+            .run {
+                when (slidingSync) {
+                    ClientBuilderSlidingSync.Restored -> this
+                    ClientBuilderSlidingSync.Discovered -> requiresSlidingSync()
+                    ClientBuilderSlidingSync.Simplified -> simplifiedSlidingSync(true)
+                }
+            }
             .run {
                 // Workaround for non-nullable proxy parameter in the SDK, since each call to the ClientBuilder returns a new reference we need to keep
                 proxyProvider.provides()?.let { proxy(it) } ?: this
@@ -95,6 +114,17 @@ class RustMatrixClientFactory @Inject constructor(
     }
 }
 
+enum class ClientBuilderSlidingSync {
+    // The proxy will be supplied when restoring the Session.
+    Restored,
+
+    // A proxy must be discovered whilst building the session.
+    Discovered,
+
+    // Use Simplified Sliding Sync (discovery isn't a thing yet).
+    Simplified,
+}
+
 private fun SessionData.toSession() = Session(
     accessToken = accessToken,
     refreshToken = refreshToken,

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

@@ -29,6 +29,7 @@ import io.element.android.libraries.matrix.api.auth.OidcDetails
 import io.element.android.libraries.matrix.api.auth.qrlogin.MatrixQrCodeLoginData
 import io.element.android.libraries.matrix.api.auth.qrlogin.QrCodeLoginStep
 import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.impl.ClientBuilderSlidingSync
 import io.element.android.libraries.matrix.impl.RustMatrixClientFactory
 import io.element.android.libraries.matrix.impl.auth.qrlogin.QrErrorMapper
 import io.element.android.libraries.matrix.impl.auth.qrlogin.SdkQrCodeLoginData
@@ -210,6 +211,7 @@ class RustMatrixAuthenticationService @Inject constructor(
                     sessionPath = sessionPath,
                     passphrase = pendingPassphrase,
                     slidingSyncProxy = AuthenticationConfig.SLIDING_SYNC_PROXY_URL,
+                    slidingSync = ClientBuilderSlidingSync.Discovered,
                 )
                     .buildWithQrCode(
                         qrCodeData = (qrCodeData as SdkQrCodeLoginData).rustQrCodeData,
@@ -251,8 +253,8 @@ class RustMatrixAuthenticationService @Inject constructor(
             sessionPath = sessionPath,
             passphrase = pendingPassphrase,
             slidingSyncProxy = AuthenticationConfig.SLIDING_SYNC_PROXY_URL,
+            slidingSync = ClientBuilderSlidingSync.Discovered,
         )
-        .requiresSlidingSync()
 
     private fun clear() {
         currentClient?.close()

libraries/preferences/api/src/main/kotlin/io/element/android/libraries/preferences/api/store/AppPreferencesStore.kt

@@ -28,5 +28,8 @@ interface AppPreferencesStore {
     suspend fun setTheme(theme: String)
     fun getThemeFlow(): Flow<String?>
 
+    suspend fun setSimplifiedSlidingSyncEnabled(enabled: Boolean)
+    fun isSimplifiedSlidingSyncEnabledFlow(): Flow<Boolean>
+
     suspend fun reset()
 }

libraries/preferences/impl/src/main/kotlin/io/element/android/libraries/preferences/impl/store/DefaultAppPreferencesStore.kt

@@ -38,6 +38,7 @@ private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(na
 private val developerModeKey = booleanPreferencesKey("developerMode")
 private val customElementCallBaseUrlKey = stringPreferencesKey("elementCallBaseUrl")
 private val themeKey = stringPreferencesKey("theme")
+private val simplifiedSlidingSyncKey = booleanPreferencesKey("useSimplifiedSlidingSync")
 
 @ContributesBinding(AppScope::class)
 class DefaultAppPreferencesStore @Inject constructor(
@@ -87,6 +88,18 @@ class DefaultAppPreferencesStore @Inject constructor(
         }
     }
 
+    override suspend fun setSimplifiedSlidingSyncEnabled(enabled: Boolean) {
+        store.edit { prefs ->
+            prefs[simplifiedSlidingSyncKey] = enabled
+        }
+    }
+
+    override fun isSimplifiedSlidingSyncEnabledFlow(): Flow<Boolean> {
+        return store.data.map { prefs ->
+            prefs[simplifiedSlidingSyncKey] ?: false
+        }
+    }
+
     override suspend fun reset() {
         store.edit { it.clear() }
     }

libraries/preferences/test/src/main/kotlin/io/element/android/libraries/preferences/test/InMemoryAppPreferencesStore.kt

@@ -24,10 +24,12 @@ class InMemoryAppPreferencesStore(
     isDeveloperModeEnabled: Boolean = false,
     customElementCallBaseUrl: String? = null,
     theme: String? = null,
+    simplifiedSlidingSyncEnabled: Boolean = false
 ) : AppPreferencesStore {
     private val isDeveloperModeEnabled = MutableStateFlow(isDeveloperModeEnabled)
     private val customElementCallBaseUrl = MutableStateFlow(customElementCallBaseUrl)
     private val theme = MutableStateFlow(theme)
+    private val simplifiedSlidingSyncEnabled = MutableStateFlow(simplifiedSlidingSyncEnabled)
 
     override suspend fun setDeveloperModeEnabled(enabled: Boolean) {
         isDeveloperModeEnabled.value = enabled
@@ -53,6 +55,14 @@ class InMemoryAppPreferencesStore(
         return theme
     }
 
+    override suspend fun setSimplifiedSlidingSyncEnabled(enabled: Boolean) {
+        simplifiedSlidingSyncEnabled.value = enabled
+    }
+
+    override fun isSimplifiedSlidingSyncEnabledFlow(): Flow<Boolean> {
+        return simplifiedSlidingSyncEnabled
+    }
+
     override suspend fun reset() {
         // No op
     }

samples/minimal/build.gradle.kts

@@ -60,6 +60,7 @@ dependencies {
     implementation(projects.libraries.eventformatter.impl)
     implementation(projects.libraries.fullscreenintent.impl)
     implementation(projects.libraries.preferences.impl)
+    implementation(projects.libraries.preferences.test)
     implementation(projects.libraries.indicator.impl)
     implementation(projects.features.invite.impl)
     implementation(projects.features.roomlist.impl)

samples/minimal/src/main/kotlin/io/element/android/samples/minimal/MainActivity.kt

@@ -33,6 +33,7 @@ import io.element.android.libraries.matrix.impl.analytics.UtdTracker
 import io.element.android.libraries.matrix.impl.auth.OidcConfigurationProvider
 import io.element.android.libraries.matrix.impl.auth.RustMatrixAuthenticationService
 import io.element.android.libraries.network.useragent.SimpleUserAgentProvider
+import io.element.android.libraries.preferences.test.InMemoryAppPreferencesStore
 import io.element.android.libraries.sessionstorage.api.LoggedInState
 import io.element.android.libraries.sessionstorage.impl.memory.InMemorySessionStore
 import io.element.android.services.analytics.noop.NoopAnalyticsService
@@ -62,6 +63,7 @@ class MainActivity : ComponentActivity() {
                 proxyProvider = proxyProvider,
                 clock = DefaultSystemClock(),
                 utdTracker = UtdTracker(NoopAnalyticsService()),
+                appPreferencesStore = InMemoryAppPreferencesStore(),
             ),
             passphraseGenerator = NullPassphraseGenerator(),
             oidcConfigurationProvider = OidcConfigurationProvider(baseDirectory),