Sign out: direct flow if not last session and if not currently backing up keys #2072

Extract some stuff from existing Logout to avoid duplication.
2023-12-26 12:10:11 +01:00
parent 43f87b206f
commit c65f5ed560
16 changed files with 477 additions and 52 deletions
--- a/features/logout/api/src/main/kotlin/io/element/android/features/logout/api/direct/DirectLogoutEvents.kt
+++ b/features/logout/api/src/main/kotlin/io/element/android/features/logout/api/direct/DirectLogoutEvents.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023 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.logout.api.direct
+
+sealed interface DirectLogoutEvents {
+    data class Logout(val ignoreSdkError: Boolean) : DirectLogoutEvents
+    data object CloseDialogs : DirectLogoutEvents
+}
--- a/features/logout/api/src/main/kotlin/io/element/android/features/logout/api/direct/DirectLogoutPresenter.kt
+++ b/features/logout/api/src/main/kotlin/io/element/android/features/logout/api/direct/DirectLogoutPresenter.kt
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023 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.logout.api.direct
+
+import io.element.android.libraries.architecture.Presenter
+
+interface DirectLogoutPresenter : Presenter<DirectLogoutState>
--- a/features/logout/api/src/main/kotlin/io/element/android/features/logout/api/direct/DirectLogoutState.kt
+++ b/features/logout/api/src/main/kotlin/io/element/android/features/logout/api/direct/DirectLogoutState.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 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.logout.api.direct
+
+import io.element.android.libraries.architecture.Async
+
+data class DirectLogoutState(
+    val canDoDirectSignOut: Boolean,
+    val showConfirmationDialog: Boolean,
+    val logoutAction: Async<String?>,
+    val eventSink: (DirectLogoutEvents) -> Unit,
+)
--- a/features/logout/api/src/main/kotlin/io/element/android/features/logout/api/direct/DirectLogoutView.kt
+++ b/features/logout/api/src/main/kotlin/io/element/android/features/logout/api/direct/DirectLogoutView.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2023 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.logout.api.direct
+
+import androidx.compose.runtime.Composable
+
+interface DirectLogoutView {
+    @Composable
+    fun render(
+        state: DirectLogoutState,
+        onSuccessLogout: (logoutUrlResult: String?) -> Unit
+    )
+}
--- a/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/LogoutView.kt
+++ b/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/LogoutView.kt
@@ -22,7 +22,6 @@ import androidx.compose.foundation.layout.ColumnScope
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
@@ -31,10 +30,11 @@ import androidx.compose.ui.res.vectorResource
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import io.element.android.compound.theme.ElementTheme
+import io.element.android.features.logout.impl.tools.isBackingUp
+import io.element.android.features.logout.impl.ui.LogoutActionDialog
+import io.element.android.features.logout.impl.ui.LogoutConfirmationDialog
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.designsystem.atomic.pages.FlowStepPage
-import io.element.android.libraries.designsystem.components.ProgressDialog
-import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
 import io.element.android.libraries.designsystem.theme.components.Button
@@ -81,10 +81,7 @@ fun LogoutView(

    // Log out confirmation dialog
    if (state.showConfirmationDialog) {
-        ConfirmationDialog(
-            title = stringResource(id = CommonStrings.action_signout),
-            content = stringResource(id = R.string.screen_signout_confirmation_dialog_content),
-            submitText = stringResource(id = CommonStrings.action_signout),
+        LogoutConfirmationDialog(
            onSubmitClicked = {
                eventSink(LogoutEvents.Logout(ignoreSdkError = false))
            },
@@ -94,28 +91,18 @@ fun LogoutView(
        )
    }

-    when (state.logoutAction) {
-        is Async.Loading ->
-            ProgressDialog(text = stringResource(id = R.string.screen_signout_in_progress_dialog_content))
-        is Async.Failure ->
-            ConfirmationDialog(
-                title = stringResource(id = CommonStrings.dialog_title_error),
-                content = stringResource(id = CommonStrings.error_unknown),
-                submitText = stringResource(id = CommonStrings.action_signout_anyway),
-                onSubmitClicked = {
-                    eventSink(LogoutEvents.Logout(ignoreSdkError = true))
-                },
-                onDismiss = {
-                    eventSink(LogoutEvents.CloseDialogs)
-                }
-            )
-        Async.Uninitialized ->
-            Unit
-        is Async.Success ->
-            LaunchedEffect(state.logoutAction) {
-                onSuccessLogout(state.logoutAction.data)
-            }
-    }
+    LogoutActionDialog(
+        state.logoutAction,
+        onForceLogoutClicked = {
+            eventSink(LogoutEvents.Logout(ignoreSdkError = true))
+        },
+        onDismissError = {
+            eventSink(LogoutEvents.CloseDialogs)
+        },
+        onSuccessLogout = {
+            onSuccessLogout(it)
+        },
+    )
 }

@Composable
@@ -146,17 +133,6 @@ private fun subtitle(state: LogoutState): String? {
    }
 }

-private fun BackupUploadState.isBackingUp(): Boolean {
-    return when (this) {
-        BackupUploadState.Waiting,
-        is BackupUploadState.Uploading -> true
-        is BackupUploadState.SteadyException -> exception is SteadyStateException.Connection
-        BackupUploadState.Unknown,
-        BackupUploadState.Done,
-        BackupUploadState.Error -> false
-    }
-}
-
@Composable
 private fun ColumnScope.Buttons(
    state: LogoutState,
--- a/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/direct/DefaultDirectLogoutPresenter.kt
+++ b/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/direct/DefaultDirectLogoutPresenter.kt
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2023 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.logout.impl.direct
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.logout.api.direct.DirectLogoutEvents
+import io.element.android.features.logout.api.direct.DirectLogoutPresenter
+import io.element.android.features.logout.api.direct.DirectLogoutState
+import io.element.android.features.logout.impl.tools.isBackingUp
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.runCatchingUpdatingState
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.featureflag.api.FeatureFlagService
+import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.encryption.BackupUploadState
+import io.element.android.libraries.matrix.api.encryption.EncryptionService
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@ContributesBinding(SessionScope::class)
+class DefaultDirectLogoutPresenter @Inject constructor(
+    private val matrixClient: MatrixClient,
+    private val encryptionService: EncryptionService,
+    private val featureFlagService: FeatureFlagService,
+) : DirectLogoutPresenter {
+    @Composable
+    override fun present(): DirectLogoutState {
+        val localCoroutineScope = rememberCoroutineScope()
+
+        val logoutAction: MutableState<Async<String?>> = remember {
+            mutableStateOf(Async.Uninitialized)
+        }
+
+        val secureStorageFlag by featureFlagService.isFeatureEnabledFlow(FeatureFlags.SecureStorage)
+            .collectAsState(initial = null)
+
+        val backupUploadState: BackupUploadState by remember(secureStorageFlag) {
+            when (secureStorageFlag) {
+                true -> encryptionService.waitForBackupUploadSteadyState()
+                false -> flowOf(BackupUploadState.Done)
+                else -> emptyFlow()
+            }
+        }
+            .collectAsState(initial = BackupUploadState.Unknown)
+
+        var showLogoutDialog by remember { mutableStateOf(false) }
+        var isLastSession by remember { mutableStateOf(false) }
+        LaunchedEffect(Unit) {
+            isLastSession = encryptionService.isLastDevice().getOrNull() ?: false
+        }
+
+        fun handleEvents(event: DirectLogoutEvents) {
+            when (event) {
+                is DirectLogoutEvents.Logout -> {
+                    if (showLogoutDialog || event.ignoreSdkError) {
+                        showLogoutDialog = false
+                        localCoroutineScope.logout(logoutAction, event.ignoreSdkError)
+                    } else {
+                        showLogoutDialog = true
+                    }
+                }
+                DirectLogoutEvents.CloseDialogs -> {
+                    logoutAction.value = Async.Uninitialized
+                    showLogoutDialog = false
+                }
+            }
+        }
+
+        return DirectLogoutState(
+            canDoDirectSignOut = !isLastSession &&
+                !backupUploadState.isBackingUp(),
+            showConfirmationDialog = showLogoutDialog,
+            logoutAction = logoutAction.value,
+            eventSink = ::handleEvents
+        )
+    }
+
+    private fun CoroutineScope.logout(
+        logoutAction: MutableState<Async<String?>>,
+        ignoreSdkError: Boolean,
+    ) = launch {
+        suspend {
+            matrixClient.logout(ignoreSdkError)
+        }.runCatchingUpdatingState(logoutAction)
+    }
+}
--- a/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/direct/DefaultDirectLogoutView.kt
+++ b/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/direct/DefaultDirectLogoutView.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2023 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.logout.impl.direct
+
+import androidx.compose.runtime.Composable
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.logout.api.direct.DirectLogoutEvents
+import io.element.android.features.logout.api.direct.DirectLogoutState
+import io.element.android.features.logout.api.direct.DirectLogoutView
+import io.element.android.features.logout.impl.ui.LogoutActionDialog
+import io.element.android.features.logout.impl.ui.LogoutConfirmationDialog
+import io.element.android.libraries.di.SessionScope
+import javax.inject.Inject
+
+@ContributesBinding(SessionScope::class)
+class DefaultDirectLogoutView @Inject constructor() : DirectLogoutView {
+    @Composable
+    override fun render(
+        state: DirectLogoutState,
+        onSuccessLogout: (logoutUrlResult: String?) -> Unit,
+    ) {
+        val eventSink = state.eventSink
+        // Log out confirmation dialog
+        if (state.showConfirmationDialog) {
+            LogoutConfirmationDialog(
+                onSubmitClicked = {
+                    eventSink(DirectLogoutEvents.Logout(ignoreSdkError = false))
+                },
+                onDismiss = {
+                    eventSink(DirectLogoutEvents.CloseDialogs)
+                }
+            )
+        }
+
+        LogoutActionDialog(
+            state.logoutAction,
+            onForceLogoutClicked = {
+                eventSink(DirectLogoutEvents.Logout(ignoreSdkError = true))
+            },
+            onDismissError = {
+                eventSink(DirectLogoutEvents.CloseDialogs)
+            },
+            onSuccessLogout = {
+                onSuccessLogout(it)
+            },
+        )
+    }
+}
--- a/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/tools/Extensions.kt
+++ b/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/tools/Extensions.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 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.logout.impl.tools
+
+import io.element.android.libraries.matrix.api.encryption.BackupUploadState
+import io.element.android.libraries.matrix.api.encryption.SteadyStateException
+
+internal fun BackupUploadState.isBackingUp(): Boolean {
+    return when (this) {
+        BackupUploadState.Waiting,
+        is BackupUploadState.Uploading -> true
+        is BackupUploadState.SteadyException -> exception is SteadyStateException.Connection
+        BackupUploadState.Unknown,
+        BackupUploadState.Done,
+        BackupUploadState.Error -> false
+    }
+}
--- a/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/ui/LogoutActionDialog.kt
+++ b/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/ui/LogoutActionDialog.kt
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2023 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.logout.impl.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.res.stringResource
+import io.element.android.features.logout.impl.R
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.designsystem.components.ProgressDialog
+import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun LogoutActionDialog(
+    state: Async<String?>,
+    onForceLogoutClicked: () -> Unit,
+    onDismissError: () -> Unit,
+    onSuccessLogout: (String?) -> Unit,
+) {
+    when (state) {
+        is Async.Loading ->
+            ProgressDialog(text = stringResource(id = R.string.screen_signout_in_progress_dialog_content))
+        is Async.Failure ->
+            ConfirmationDialog(
+                title = stringResource(id = CommonStrings.dialog_title_error),
+                content = stringResource(id = CommonStrings.error_unknown),
+                submitText = stringResource(id = CommonStrings.action_signout_anyway),
+                onSubmitClicked = onForceLogoutClicked,
+                onDismiss = onDismissError,
+            )
+        Async.Uninitialized ->
+            Unit
+        is Async.Success ->
+            LaunchedEffect(state) {
+                onSuccessLogout(state.data)
+            }
+    }
+}
--- a/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/ui/LogoutConfirmationDialog.kt
+++ b/features/logout/impl/src/main/kotlin/io/element/android/features/logout/impl/ui/LogoutConfirmationDialog.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 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.logout.impl.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import io.element.android.features.logout.impl.R
+import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun LogoutConfirmationDialog(
+    onSubmitClicked: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    ConfirmationDialog(
+        title = stringResource(id = CommonStrings.action_signout),
+        content = stringResource(id = R.string.screen_signout_confirmation_dialog_content),
+        submitText = stringResource(id = CommonStrings.action_signout),
+        onSubmitClicked = onSubmitClicked,
+        onDismiss = onDismiss,
+    )
+}
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootNode.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootNode.kt
@@ -27,16 +27,19 @@ import com.bumble.appyx.core.plugin.plugins
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
+import io.element.android.compound.theme.ElementTheme
+import io.element.android.features.logout.api.direct.DirectLogoutView
 import io.element.android.libraries.androidutils.browser.openUrlInChromeCustomTab
 import io.element.android.libraries.di.SessionScope
 import io.element.android.libraries.matrix.api.user.MatrixUser
-import io.element.android.compound.theme.ElementTheme
+import timber.log.Timber

@ContributesNode(SessionScope::class)
 class PreferencesRootNode @AssistedInject constructor(
    @Assisted buildContext: BuildContext,
    @Assisted plugins: List<Plugin>,
    private val presenter: PreferencesRootPresenter,
+    private val directLogoutView: DirectLogoutView,
 ) : Node(buildContext, plugins = plugins) {

    interface Callback : Plugin {
@@ -95,6 +98,13 @@ class PreferencesRootNode @AssistedInject constructor(
        }
    }

+    private fun onSuccessLogout(activity: Activity, url: String?) {
+        Timber.d("Success (direct) logout with result url: $url")
+        url?.let {
+            activity.openUrlInChromeCustomTab(null, false, it)
+        }
+    }
+
    private fun onOpenNotificationSettings() {
        plugins<Callback>().forEach { it.onOpenNotificationSettings() }
    }
@@ -133,5 +143,12 @@ class PreferencesRootNode @AssistedInject constructor(
            onOpenUserProfile = this::onOpenUserProfile,
            onSignOutClicked = this::onSignOutClicked,
        )
+
+        directLogoutView.render(
+            state = state.directLogoutState,
+            onSuccessLogout = {
+                onSuccessLogout(activity, it)
+            }
+        )
    }
 }
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootPresenter.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootPresenter.kt
@@ -24,6 +24,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
+import io.element.android.features.logout.api.direct.DirectLogoutPresenter
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.core.meta.BuildType
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarDispatcher
@@ -50,6 +51,7 @@ class PreferencesRootPresenter @Inject constructor(
    private val snackbarDispatcher: SnackbarDispatcher,
    private val featureFlagService: FeatureFlagService,
    private val indicatorService: IndicatorService,
+    private val directLogoutPresenter: DirectLogoutPresenter,
 ) : Presenter<PreferencesRootState> {

    @Composable
@@ -88,6 +90,8 @@ class PreferencesRootPresenter @Inject constructor(
            mutableStateOf(null)
        }

+        val directLogoutState = directLogoutPresenter.present()
+
        LaunchedEffect(Unit) {
            initAccountManagementUrl(accountManagementUrl, devicesManagementUrl)
        }
@@ -105,6 +109,7 @@ class PreferencesRootPresenter @Inject constructor(
            showDeveloperSettings = showDeveloperSettings,
            showNotificationSettings = showNotificationSettings.value,
            showLockScreenSettings = showLockScreenSettings.value,
+            directLogoutState = directLogoutState,
            snackbarMessage = snackbarMessage,
        )
    }
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootState.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootState.kt
@@ -16,6 +16,7 @@

 package io.element.android.features.preferences.impl.root

+import io.element.android.features.logout.api.direct.DirectLogoutState
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
 import io.element.android.libraries.matrix.api.user.MatrixUser

@@ -31,5 +32,6 @@ data class PreferencesRootState(
    val showDeveloperSettings: Boolean,
    val showLockScreenSettings: Boolean,
    val showNotificationSettings: Boolean,
+    val directLogoutState: DirectLogoutState,
    val snackbarMessage: SnackbarMessage?,
 )
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootStateProvider.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootStateProvider.kt
@@ -16,6 +16,8 @@

 package io.element.android.features.preferences.impl.root

+import io.element.android.features.logout.api.direct.DirectLogoutState
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
 import io.element.android.libraries.ui.strings.CommonStrings

@@ -32,4 +34,12 @@ fun aPreferencesRootState() = PreferencesRootState(
    showNotificationSettings = true,
    showLockScreenSettings = true,
    snackbarMessage = SnackbarMessage(CommonStrings.common_verification_complete),
+    directLogoutState = aDirectLogoutState(),
+)
+
+fun aDirectLogoutState() = DirectLogoutState(
+    canDoDirectSignOut = true,
+    showConfirmationDialog = false,
+    logoutAction = Async.Uninitialized,
+    eventSink = {},
 )
--- a/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootView.kt
+++ b/features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootView.kt
@@ -29,6 +29,7 @@ import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import io.element.android.compound.theme.ElementTheme
 import io.element.android.compound.tokens.generated.CompoundIcons
+import io.element.android.features.logout.api.direct.DirectLogoutEvents
 import io.element.android.features.preferences.impl.R
 import io.element.android.features.preferences.impl.user.UserPreferences
 import io.element.android.libraries.designsystem.components.list.ListItemContent
@@ -57,7 +58,7 @@ fun PreferencesRootView(
    onManageAccountClicked: (url: String) -> Unit,
    onOpenAnalytics: () -> Unit,
    onOpenRageShake: () -> Unit,
-    onOpenLockScreenSettings: ()->Unit,
+    onOpenLockScreenSettings: () -> Unit,
    onOpenAbout: () -> Unit,
    onOpenDeveloperSettings: () -> Unit,
    onOpenAdvancedSettings: () -> Unit,
@@ -91,7 +92,7 @@ fun PreferencesRootView(
        if (state.showSecureBackup) {
            ListItem(
                headlineContent = { Text(stringResource(id = CommonStrings.common_chat_backup)) },
-                leadingContent = ListItemContent.Icon(IconSource.Resource(CommonDrawables.ic_key_filled),),
+                leadingContent = ListItemContent.Icon(IconSource.Resource(CommonDrawables.ic_key_filled)),
                trailingContent = ListItemContent.Badge.takeIf { state.showSecureBackupBadge },
                onClick = onSecureBackupClicked,
            )
@@ -162,7 +163,13 @@ fun PreferencesRootView(
            headlineContent = { Text(stringResource(id = CommonStrings.action_signout)) },
            leadingContent = ListItemContent.Icon(IconSource.Resource(CommonDrawables.ic_sign_out)),
            style = ListItemStyle.Destructive,
-            onClick = onSignOutClicked,
+            onClick = {
+                if (state.directLogoutState.canDoDirectSignOut) {
+                    state.directLogoutState.eventSink(DirectLogoutEvents.Logout(ignoreSdkError = false))
+                } else {
+                    onSignOutClicked()
+                }
+            },
        )
        Text(
            modifier = Modifier
--- a/features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootPresenterTest.kt
+++ b/features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootPresenterTest.kt
@@ -16,10 +16,14 @@

 package io.element.android.features.preferences.impl.root

+import androidx.compose.runtime.Composable
 import app.cash.molecule.RecompositionMode
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
+import io.element.android.features.logout.api.direct.DirectLogoutPresenter
+import io.element.android.features.logout.api.direct.DirectLogoutState
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.core.meta.BuildType
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarDispatcher
 import io.element.android.libraries.featureflag.test.FakeFeatureFlagService
@@ -41,23 +45,34 @@ class PreferencesRootPresenterTest {
    @get:Rule
    val warmUpRule = WarmUpRule()

+    private val aDirectLogoutState = DirectLogoutState(
+        canDoDirectSignOut = true,
+        showConfirmationDialog = false,
+        logoutAction = Async.Uninitialized,
+        eventSink = {},
+    )
+
    @Test
    fun `present - initial state`() = runTest {
        val matrixClient = FakeMatrixClient()
        val sessionVerificationService = FakeSessionVerificationService()
        val presenter = PreferencesRootPresenter(
-            matrixClient,
-            sessionVerificationService,
-            FakeAnalyticsService(),
-            BuildType.DEBUG,
-            FakeVersionFormatter(),
-            SnackbarDispatcher(),
-            FakeFeatureFlagService(),
-            DefaultIndicatorService(
+            matrixClient = matrixClient,
+            sessionVerificationService = sessionVerificationService,
+            analyticsService = FakeAnalyticsService(),
+            buildType = BuildType.DEBUG,
+            versionFormatter = FakeVersionFormatter(),
+            snackbarDispatcher = SnackbarDispatcher(),
+            featureFlagService = FakeFeatureFlagService(),
+            indicatorService = DefaultIndicatorService(
                sessionVerificationService = sessionVerificationService,
                encryptionService = FakeEncryptionService(),
                featureFlagService = FakeFeatureFlagService(),
            ),
+            directLogoutPresenter = object : DirectLogoutPresenter {
+                @Composable
+                override fun present() = aDirectLogoutState
+            }
        )
        moleculeFlow(RecompositionMode.Immediate) {
            presenter.present()
@@ -77,6 +92,7 @@ class PreferencesRootPresenterTest {
            assertThat(loadedState.showAnalyticsSettings).isFalse()
            assertThat(loadedState.accountManagementUrl).isNull()
            assertThat(loadedState.devicesManagementUrl).isNull()
+            assertThat(loadedState.directLogoutState).isEqualTo(aDirectLogoutState)
        }
    }
 }