Account deactivation.

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

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl
+
+sealed interface AccountDeactivationEvents {
+    data class SetEraseData(val eraseData: Boolean) : AccountDeactivationEvents
+    data class SetPassword(val password: String) : AccountDeactivationEvents
+    data class DeactivateAccount(val isRetry: Boolean) : AccountDeactivationEvents
+    data object CloseDialogs : AccountDeactivationEvents
+}

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.libraries.di.SessionScope
+
+@ContributesNode(SessionScope::class)
+class AccountDeactivationNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: AccountDeactivationPresenter,
+) : Node(buildContext, plugins = plugins) {
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        AccountDeactivationView(
+            state = state,
+            onBackClick = ::navigateUp,
+            modifier = modifier,
+        )
+    }
+}

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

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.runCatchingUpdatingState
+import io.element.android.libraries.matrix.api.MatrixClient
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+class AccountDeactivationPresenter @Inject constructor(
+    private val matrixClient: MatrixClient,
+) : Presenter<AccountDeactivationState> {
+    @Composable
+    override fun present(): AccountDeactivationState {
+        val localCoroutineScope = rememberCoroutineScope()
+        val action: MutableState<AsyncAction<Unit>> = remember {
+            mutableStateOf(AsyncAction.Uninitialized)
+        }
+
+        val formState = remember { mutableStateOf(DeactivateFormState.Default) }
+
+        fun handleEvents(event: AccountDeactivationEvents) {
+            when (event) {
+                is AccountDeactivationEvents.SetEraseData -> {
+                    updateFormState(formState) {
+                        copy(eraseData = event.eraseData)
+                    }
+                }
+                is AccountDeactivationEvents.SetPassword -> {
+                    updateFormState(formState) {
+                        copy(password = event.password)
+                    }
+                }
+                is AccountDeactivationEvents.DeactivateAccount ->
+                    if (action.value.isConfirming() || event.isRetry) {
+                        localCoroutineScope.deactivateAccount(
+                            formState = formState.value,
+                            action
+                        )
+                    } else {
+                        action.value = AsyncAction.Confirming
+                    }
+                AccountDeactivationEvents.CloseDialogs -> {
+                    action.value = AsyncAction.Uninitialized
+                }
+            }
+        }
+
+        return AccountDeactivationState(
+            deactivateFormState = formState.value,
+            accountDeactivationAction = action.value,
+            eventSink = ::handleEvents
+        )
+    }
+
+    private fun updateFormState(formState: MutableState<DeactivateFormState>, updateLambda: DeactivateFormState.() -> DeactivateFormState) {
+        formState.value = updateLambda(formState.value)
+    }
+
+    private fun CoroutineScope.deactivateAccount(
+        formState: DeactivateFormState,
+        action: MutableState<AsyncAction<Unit>>,
+    ) = launch {
+        suspend {
+            matrixClient.deactivateAccount(
+                password = formState.password,
+                eraseData = formState.eraseData,
+            ).getOrThrow()
+        }.runCatchingUpdatingState(action)
+    }
+}

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl
+
+import android.os.Parcelable
+import io.element.android.libraries.architecture.AsyncAction
+import kotlinx.parcelize.Parcelize
+
+data class AccountDeactivationState(
+    val deactivateFormState: DeactivateFormState,
+    val accountDeactivationAction: AsyncAction<Unit>,
+    val eventSink: (AccountDeactivationEvents) -> Unit,
+) {
+    val submitEnabled: Boolean
+        get() = accountDeactivationAction is AsyncAction.Uninitialized &&
+            deactivateFormState.password.isNotEmpty()
+}
+
+@Parcelize
+data class DeactivateFormState(
+    val eraseData: Boolean,
+    val password: String
+) : Parcelable {
+    companion object {
+        val Default = DeactivateFormState(false, "")
+    }
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.AsyncAction
+
+open class AccountDeactivationStateProvider : PreviewParameterProvider<AccountDeactivationState> {
+    private val filledForm = aDeactivateFormState(eraseData = true, password = "password")
+    override val values: Sequence<AccountDeactivationState>
+        get() = sequenceOf(
+            anAccountDeactivationState(),
+            anAccountDeactivationState(
+                deactivateFormState = filledForm
+            ),
+            anAccountDeactivationState(
+                deactivateFormState = filledForm,
+                accountDeactivationAction = AsyncAction.Confirming,
+            ),
+            anAccountDeactivationState(
+                deactivateFormState = filledForm,
+                accountDeactivationAction = AsyncAction.Loading
+            ),
+            anAccountDeactivationState(
+                deactivateFormState = filledForm,
+                accountDeactivationAction = AsyncAction.Failure(Exception("Failed to deactivate account"))
+            ),
+        )
+}
+
+internal fun aDeactivateFormState(
+    eraseData: Boolean = false,
+    password: String = "",
+) = DeactivateFormState(
+    eraseData = eraseData,
+    password = password,
+)
+
+internal fun anAccountDeactivationState(
+    deactivateFormState: DeactivateFormState = aDeactivateFormState(),
+    accountDeactivationAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
+    eventSink: (AccountDeactivationEvents) -> Unit = {},
+) = AccountDeactivationState(
+    deactivateFormState = deactivateFormState,
+    accountDeactivationAction = accountDeactivationAction,
+    eventSink = eventSink,
+)

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

@@ -0,0 +1,324 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+@file:OptIn(ExperimentalComposeUiApi::class)
+
+package io.element.android.features.logout.impl
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.autofill.AutofillType
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.input.PasswordVisualTransformation
+import androidx.compose.ui.text.input.VisualTransformation
+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.deactivation.impl.R
+import io.element.android.features.logout.impl.ui.AccountDeactivationActionDialog
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.designsystem.atomic.organisms.InfoListItem
+import io.element.android.libraries.designsystem.atomic.organisms.InfoListOrganism
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.components.form.textFieldState
+import io.element.android.libraries.designsystem.components.list.SwitchListItem
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.aliasScreenTitle
+import io.element.android.libraries.designsystem.theme.components.Button
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.IconButton
+import io.element.android.libraries.designsystem.theme.components.OutlinedTextField
+import io.element.android.libraries.designsystem.theme.components.Scaffold
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+import io.element.android.libraries.designsystem.theme.components.autofill
+import io.element.android.libraries.designsystem.theme.components.onTabOrEnterKeyFocusNext
+import io.element.android.libraries.ui.strings.CommonStrings
+import kotlinx.collections.immutable.persistentListOf
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AccountDeactivationView(
+    state: AccountDeactivationState,
+    onBackClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val eventSink = state.eventSink
+
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                navigationIcon = {
+                    BackButton(onClick = onBackClick)
+                },
+                title = {
+                    Text(
+                        text = stringResource(R.string.screen_deactivate_account_title),
+                        style = ElementTheme.typography.aliasScreenTitle,
+                    )
+                },
+            )
+        },
+    ) { padding ->
+        val scrollState = rememberScrollState()
+        Column(
+            modifier = Modifier
+                .imePadding()
+                .padding(padding)
+                .consumeWindowInsets(padding)
+                .verticalScroll(state = scrollState)
+                .padding(vertical = 16.dp, horizontal = 20.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Content(
+                state = state,
+                onSubmitClick = {
+                    eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+                }
+            )
+            Spacer(modifier = Modifier.height(32.dp))
+            Buttons(
+                state = state,
+                onSubmitClick = {
+                    eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+                }
+            )
+        }
+    }
+    AccountDeactivationActionDialog(
+        state.accountDeactivationAction,
+        onConfirmClick = {
+            eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+        },
+        onRetryClick = {
+            eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = true))
+        },
+        onDismissDialog = {
+            eventSink(AccountDeactivationEvents.CloseDialogs)
+        },
+    )
+}
+
+@Composable
+private fun ColumnScope.Buttons(
+    state: AccountDeactivationState,
+    onSubmitClick: () -> Unit,
+) {
+    val logoutAction = state.accountDeactivationAction
+    Button(
+        text = stringResource(CommonStrings.action_deactivate),
+        showProgress = logoutAction is AsyncAction.Loading,
+        destructive = true,
+        enabled = state.submitEnabled,
+        modifier = Modifier.fillMaxWidth(),
+        onClick = onSubmitClick,
+    )
+}
+
+@Composable
+private fun Content(
+    state: AccountDeactivationState,
+    onSubmitClick: () -> Unit,
+) {
+    val isLoading by remember(state.deactivateFormState) {
+        derivedStateOf {
+            state.accountDeactivationAction is AsyncAction.Loading
+        }
+    }
+    val eraseData = state.deactivateFormState.eraseData
+    var passwordFieldState by textFieldState(stateValue = state.deactivateFormState.password)
+
+    val focusManager = LocalFocusManager.current
+    val eventSink = state.eventSink
+
+    Column(
+        modifier = Modifier.fillMaxWidth(),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        Text(
+            text = stringResource(R.string.screen_deactivate_account_description),
+            style = ElementTheme.typography.fontBodyMdRegular,
+            color = ElementTheme.colors.textSecondary,
+        )
+        InfoListOrganism(
+            items = persistentListOf(
+                InfoListItem(
+                    message = stringResource(R.string.screen_deactivate_account_list_item_1),
+                    iconComposable = {
+                        Icon(
+                            modifier = Modifier.size(20.dp),
+                            imageVector = CompoundIcons.Close(),
+                            contentDescription = null,
+                            tint = ElementTheme.colors.iconCriticalPrimary,
+                        )
+                    },
+                    iconVector = CompoundIcons.Close(),
+                ),
+                InfoListItem(
+                    message = stringResource(R.string.screen_deactivate_account_list_item_2),
+                    iconComposable = {
+                        Icon(
+                            modifier = Modifier.size(20.dp),
+                            imageVector = CompoundIcons.Close(),
+                            contentDescription = null,
+                            tint = ElementTheme.colors.iconCriticalPrimary,
+                        )
+                    },
+                ),
+                InfoListItem(
+                    message = stringResource(R.string.screen_deactivate_account_list_item_3),
+                    iconComposable = {
+                        Icon(
+                            modifier = Modifier.size(20.dp),
+                            imageVector = CompoundIcons.Close(),
+                            contentDescription = null,
+                            tint = ElementTheme.colors.iconCriticalPrimary,
+                        )
+                    },
+                ),
+                InfoListItem(
+                    message = stringResource(R.string.screen_deactivate_account_list_item_4),
+                    iconComposable = {
+                        Icon(
+                            modifier = Modifier.size(20.dp),
+                            imageVector = CompoundIcons.Check(),
+                            contentDescription = null,
+                            tint = ElementTheme.colors.iconSuccessPrimary,
+                        )
+                    },
+                ),
+            ),
+            textStyle = ElementTheme.typography.fontBodyMdRegular,
+            textColor = ElementTheme.colors.textSecondary,
+            iconTint = ElementTheme.colors.iconSuccessPrimary,
+            backgroundColor = Color.Transparent,
+        )
+
+        Column {
+            SwitchListItem(
+                headline = stringResource(R.string.screen_deactivate_account_delete_all_messages),
+                value = eraseData,
+                onChange = {
+                    eventSink(AccountDeactivationEvents.SetEraseData(it))
+                },
+                enabled = !isLoading,
+            )
+            Text(
+                modifier = Modifier.padding(start = 16.dp),
+                text = stringResource(R.string.screen_deactivate_account_delete_all_messages_notice),
+                style = ElementTheme.typography.fontBodySmRegular,
+                color = ElementTheme.colors.textSecondary,
+            )
+        }
+
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(top = 16.dp),
+        ) {
+            Text(
+                text = stringResource(CommonStrings.action_confirm_password),
+                style = ElementTheme.typography.fontBodySmMedium,
+                color = ElementTheme.colors.textSecondary,
+            )
+            var passwordVisible by remember { mutableStateOf(false) }
+            if (isLoading) {
+                // Ensure password is hidden when user submits the form
+                passwordVisible = false
+            }
+            OutlinedTextField(
+                value = passwordFieldState,
+                readOnly = isLoading,
+                modifier = Modifier
+                    .padding(top = 8.dp)
+                    .fillMaxWidth()
+                    .onTabOrEnterKeyFocusNext(focusManager)
+                    .autofill(
+                        autofillTypes = listOf(AutofillType.Password),
+                        onFill = {
+                            val sanitized = it.sanitize()
+                            passwordFieldState = sanitized
+                            eventSink(AccountDeactivationEvents.SetPassword(sanitized))
+                        }
+                    ),
+                onValueChange = {
+                    val sanitized = it.sanitize()
+                    passwordFieldState = sanitized
+                    eventSink(AccountDeactivationEvents.SetPassword(sanitized))
+                },
+                placeholder = {
+                    Text(text = stringResource(CommonStrings.common_password))
+                },
+                visualTransformation = if (passwordVisible) VisualTransformation.None else PasswordVisualTransformation(),
+                trailingIcon = {
+                    val image =
+                        if (passwordVisible) CompoundIcons.VisibilityOn() else CompoundIcons.VisibilityOff()
+                    val description =
+                        if (passwordVisible) stringResource(CommonStrings.a11y_hide_password) else stringResource(CommonStrings.a11y_show_password)
+
+                    IconButton(onClick = { passwordVisible = !passwordVisible }) {
+                        Icon(imageVector = image, description)
+                    }
+                },
+                keyboardOptions = KeyboardOptions(
+                    keyboardType = KeyboardType.Password,
+                    imeAction = ImeAction.Done,
+                ),
+                keyboardActions = KeyboardActions(
+                    onDone = { onSubmitClick() }
+                ),
+                singleLine = true,
+            )
+        }
+    }
+}
+
+/**
+ * Ensure that the string does not contain any new line characters, which can happen when pasting values.
+ */
+private fun String.sanitize(): String {
+    return replace("\n", "")
+}
+
+@PreviewsDayNight
+@Composable
+internal fun AccountDeactivationViewPreview(
+    @PreviewParameter(AccountDeactivationStateProvider::class) state: AccountDeactivationState,
+) = ElementPreview {
+    AccountDeactivationView(
+        state,
+        onBackClick = {},
+    )
+}

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

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.deactivation.api.AccountDeactivationEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.AppScope
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultAccountDeactivationEntryPoint @Inject constructor() : AccountDeactivationEntryPoint {
+    override fun createNode(parentNode: Node, buildContext: BuildContext): Node {
+        return parentNode.createNode<AccountDeactivationNode>(buildContext)
+    }
+}

features/deactivation/impl/src/main/kotlin/io/element/android/features/logout/impl/ui/AccountDeactivationActionDialog.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.designsystem.components.ProgressDialog
+import io.element.android.libraries.designsystem.components.dialogs.RetryDialog
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun AccountDeactivationActionDialog(
+    state: AsyncAction<Unit>,
+    onConfirmClick: () -> Unit,
+    onRetryClick: () -> Unit,
+    onDismissDialog: () -> Unit,
+) {
+    when (state) {
+        AsyncAction.Uninitialized ->
+            Unit
+        AsyncAction.Confirming ->
+            AccountDeactivationConfirmationDialog(
+                onSubmitClick = onConfirmClick,
+                onDismiss = onDismissDialog
+            )
+        is AsyncAction.Loading ->
+            ProgressDialog(text = stringResource(CommonStrings.common_please_wait))
+        is AsyncAction.Failure ->
+            RetryDialog(
+                title = stringResource(id = CommonStrings.dialog_title_error),
+                content = stringResource(id = CommonStrings.error_unknown),
+                onRetry = onRetryClick,
+                onDismiss = onDismissDialog,
+            )
+        is AsyncAction.Success -> Unit
+    }
+}

features/deactivation/impl/src/main/kotlin/io/element/android/features/logout/impl/ui/AccountDeactivationConfirmationDialog.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import io.element.android.features.deactivation.impl.R
+import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun AccountDeactivationConfirmationDialog(
+    onSubmitClick: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    ConfirmationDialog(
+        title = stringResource(id = R.string.screen_deactivate_account_title),
+        content = stringResource(R.string.screen_deactivate_account_confirmation_dialog_content),
+        submitText = stringResource(id = CommonStrings.action_deactivate),
+        onSubmitClick = onSubmitClick,
+        onDismiss = onDismiss,
+        destructiveSubmit = true,
+    )
+}

features/deactivation/impl/src/main/res/values/localazy.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_deactivate_account_confirmation_dialog_content">"Please confirm that you want to deactivate your account. This action cannot be undone."</string>
+  <string name="screen_deactivate_account_delete_all_messages">"Delete all my messages"</string>
+  <string name="screen_deactivate_account_delete_all_messages_notice">"Warning: Future users may see incomplete conversations."</string>
+  <string name="screen_deactivate_account_description">"Deactivating your account is irreversible, it will:"</string>
+  <string name="screen_deactivate_account_list_item_1">"Permanently disable your account (you can\'t log back in, and your ID can\'t be reused)."</string>
+  <string name="screen_deactivate_account_list_item_2">"Remove you from all chat rooms."</string>
+  <string name="screen_deactivate_account_list_item_3">"Delete your account information from our identity server."</string>
+  <string name="screen_deactivate_account_list_item_4">"Your messages will still be visible to registered users but won’t be available to new or unregistered users if you choose to delete them."</string>
+  <string name="screen_deactivate_account_title">"Account deactivation"</string>
+</resources>

features/deactivation/impl/src/test/kotlin/io/element/android/features/logout/impl/AccountDeactivationPresenterTest.kt

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl
+
+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.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.lambda.value
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountDeactivationPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createPresenter()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.accountDeactivationAction).isEqualTo(AsyncAction.Uninitialized)
+            assertThat(initialState.deactivateFormState).isEqualTo(DeactivateFormState.Default)
+        }
+    }
+
+    @Test
+    fun `present - form update`() = runTest {
+        val presenter = createPresenter()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.deactivateFormState).isEqualTo(DeactivateFormState.Default)
+            initialState.eventSink(AccountDeactivationEvents.SetEraseData(true))
+            val updatedState = awaitItem()
+            assertThat(updatedState.deactivateFormState).isEqualTo(DeactivateFormState.Default.copy(eraseData = true))
+            assertThat(updatedState.submitEnabled).isFalse()
+            updatedState.eventSink(AccountDeactivationEvents.SetPassword("password"))
+            val updatedState2 = awaitItem()
+            assertThat(updatedState2.deactivateFormState).isEqualTo(DeactivateFormState(password = "password", eraseData = true))
+            assertThat(updatedState2.submitEnabled).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - submit`() = runTest {
+        val recorder = lambdaRecorder<String, Boolean, Result<Unit>> { _, _ ->
+            Result.success(Unit)
+        }
+        val matrixClient = FakeMatrixClient(
+            deactivateAccountResult = recorder
+        )
+        val presenter = createPresenter(matrixClient)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(AccountDeactivationEvents.SetPassword("password"))
+            skipItems(1)
+            initialState.eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+            val updatedState = awaitItem()
+            assertThat(updatedState.accountDeactivationAction).isEqualTo(AsyncAction.Confirming)
+            updatedState.eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+            val updatedState2 = awaitItem()
+            assertThat(updatedState2.accountDeactivationAction).isEqualTo(AsyncAction.Loading)
+            val finalState = awaitItem()
+            assertThat(finalState.accountDeactivationAction).isEqualTo(AsyncAction.Success(Unit))
+            recorder.assertions().isCalledOnce().with(value("password"), value(false))
+        }
+    }
+
+    @Test
+    fun `present - submit with error and retry`() = runTest {
+        val recorder = lambdaRecorder<String, Boolean, Result<Unit>> { _, _ ->
+            Result.failure(AN_EXCEPTION)
+        }
+        val matrixClient = FakeMatrixClient(
+            deactivateAccountResult = recorder
+        )
+        val presenter = createPresenter(matrixClient)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(AccountDeactivationEvents.SetPassword("password"))
+            initialState.eventSink(AccountDeactivationEvents.SetEraseData(true))
+            skipItems(2)
+            initialState.eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+            val updatedState = awaitItem()
+            assertThat(updatedState.accountDeactivationAction).isEqualTo(AsyncAction.Confirming)
+            updatedState.eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+            val updatedState2 = awaitItem()
+            assertThat(updatedState2.accountDeactivationAction).isEqualTo(AsyncAction.Loading)
+            val finalState = awaitItem()
+            assertThat(finalState.accountDeactivationAction).isEqualTo(AsyncAction.Failure(AN_EXCEPTION))
+            recorder.assertions().isCalledOnce().with(value("password"), value(true))
+            // Retry
+            finalState.eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = true))
+            val finalState2 = awaitItem()
+            assertThat(finalState2.accountDeactivationAction).isEqualTo(AsyncAction.Loading)
+            assertThat(awaitItem().accountDeactivationAction).isEqualTo(AsyncAction.Failure(AN_EXCEPTION))
+        }
+    }
+
+    @Test
+    fun `present - submit with error and cancel`() = runTest {
+        val recorder = lambdaRecorder<String, Boolean, Result<Unit>> { _, _ ->
+            Result.failure(AN_EXCEPTION)
+        }
+        val matrixClient = FakeMatrixClient(
+            deactivateAccountResult = recorder
+        )
+        val presenter = createPresenter(matrixClient)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(AccountDeactivationEvents.SetPassword("password"))
+            initialState.eventSink(AccountDeactivationEvents.SetEraseData(true))
+            skipItems(2)
+            initialState.eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+            val updatedState = awaitItem()
+            assertThat(updatedState.accountDeactivationAction).isEqualTo(AsyncAction.Confirming)
+            updatedState.eventSink(AccountDeactivationEvents.DeactivateAccount(isRetry = false))
+            val updatedState2 = awaitItem()
+            assertThat(updatedState2.accountDeactivationAction).isEqualTo(AsyncAction.Loading)
+            val finalState = awaitItem()
+            assertThat(finalState.accountDeactivationAction).isEqualTo(AsyncAction.Failure(AN_EXCEPTION))
+            recorder.assertions().isCalledOnce().with(value("password"), value(true))
+            // Cancel
+            finalState.eventSink(AccountDeactivationEvents.CloseDialogs)
+            val finalState2 = awaitItem()
+            assertThat(finalState2.accountDeactivationAction).isEqualTo(AsyncAction.Uninitialized)
+        }
+    }
+
+    private fun createPresenter(
+        matrixClient: MatrixClient = FakeMatrixClient(),
+    ) = AccountDeactivationPresenter(
+        matrixClient = matrixClient,
+    )
+}

features/deactivation/impl/src/test/kotlin/io/element/android/features/logout/impl/AccountDeactivationViewTest.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ * Please see LICENSE in the repository root for full details.
+ */
+
+package io.element.android.features.logout.impl
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.AndroidComposeTestRule
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.element.android.tests.testutils.EnsureNeverCalled
+import io.element.android.tests.testutils.EventsRecorder
+import io.element.android.tests.testutils.ensureCalledOnce
+import io.element.android.tests.testutils.pressBack
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TestRule
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class AccountDeactivationViewTest {
+    @get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun `clicking on back invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<AccountDeactivationEvents>(expectEvents = false)
+        ensureCalledOnce {
+            rule.setAccountDeactivationView(
+                state = anAccountDeactivationState(eventSink = eventsRecorder),
+                onBackClick = it,
+            )
+            rule.pressBack()
+        }
+    }
+
+    // TODO Add more tests
+}
+
+private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setAccountDeactivationView(
+    state: AccountDeactivationState,
+    onBackClick: () -> Unit = EnsureNeverCalled(),
+) {
+    setContent {
+        AccountDeactivationView(
+            state = state,
+            onBackClick = onBackClick,
+        )
+    }
+}