Replace showConfirmationDialog by disableAction Confirming state, and remove force boolean, we get read the state instead.

Also use AsyncActionView.

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisableEvents.kt

@@ -17,6 +17,6 @@
 package io.element.android.features.securebackup.impl.disable
 
 sealed interface SecureBackupDisableEvents {
-    data class DisableBackup(val force: Boolean) : SecureBackupDisableEvents
+    data object DisableBackup : SecureBackupDisableEvents
     data object DismissDialogs : SecureBackupDisableEvents
 }

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisablePresenter.kt

@@ -23,7 +23,6 @@ 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 io.element.android.features.securebackup.impl.loggerTagDisable
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
@@ -46,17 +45,14 @@ class SecureBackupDisablePresenter @Inject constructor(
         Timber.tag(loggerTagDisable.value).d("backupState: $backupState")
         val disableAction: MutableState<AsyncAction<Unit>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
         val coroutineScope = rememberCoroutineScope()
-        var showDialog by remember { mutableStateOf(false) }
         fun handleEvents(event: SecureBackupDisableEvents) {
             when (event) {
-                is SecureBackupDisableEvents.DisableBackup -> if (event.force) {
+                is SecureBackupDisableEvents.DisableBackup -> if (disableAction.value.isConfirming()) {
-                    showDialog = false
                     coroutineScope.disableBackup(disableAction)
                 } else {
-                    showDialog = true
+                    disableAction.value = AsyncAction.Confirming
                 }
                 SecureBackupDisableEvents.DismissDialogs -> {
-                    showDialog = false
                     disableAction.value = AsyncAction.Uninitialized
                 }
             }
@@ -65,7 +61,6 @@ class SecureBackupDisablePresenter @Inject constructor(
         return SecureBackupDisableState(
             backupState = backupState,
             disableAction = disableAction.value,
-            showConfirmationDialog = showDialog,
             appName = buildMeta.applicationName,
             eventSink = ::handleEvents
         )

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisableState.kt

@@ -22,7 +22,6 @@ import io.element.android.libraries.matrix.api.encryption.BackupState
 data class SecureBackupDisableState(
     val backupState: BackupState,
     val disableAction: AsyncAction<Unit>,
-    val showConfirmationDialog: Boolean,
     val appName: String,
     val eventSink: (SecureBackupDisableEvents) -> Unit
 )

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisableStateProvider.kt

@@ -24,7 +24,7 @@ open class SecureBackupDisableStateProvider : PreviewParameterProvider<SecureBac
     override val values: Sequence<SecureBackupDisableState>
         get() = sequenceOf(
             aSecureBackupDisableState(),
-            aSecureBackupDisableState(showConfirmationDialog = true),
+            aSecureBackupDisableState(disableAction = AsyncAction.Confirming),
             aSecureBackupDisableState(disableAction = AsyncAction.Loading),
             aSecureBackupDisableState(disableAction = AsyncAction.Failure(Exception("Failed to disable"))),
             // Add other states here
@@ -34,11 +34,9 @@ open class SecureBackupDisableStateProvider : PreviewParameterProvider<SecureBac
 fun aSecureBackupDisableState(
     backupState: BackupState = BackupState.UNKNOWN,
     disableAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
-    showConfirmationDialog: Boolean = false,
 ) = SecureBackupDisableState(
     backupState = backupState,
     disableAction = disableAction,
-    showConfirmationDialog = showConfirmationDialog,
     appName = "Element",
     eventSink = {}
 )

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisableView.kt

@@ -24,7 +24,6 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
@@ -34,11 +33,9 @@ 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.securebackup.impl.R
-import io.element.android.libraries.architecture.AsyncAction
-import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.designsystem.atomic.pages.FlowStepPage
+import io.element.android.libraries.designsystem.components.async.AsyncActionView
 import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
-import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
 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
@@ -53,11 +50,6 @@ fun SecureBackupDisableView(
     onBackClicked: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    LaunchedEffect(state.disableAction) {
-        if (state.disableAction is AsyncAction.Success) {
-            onDone()
-        }
-    }
     FlowStepPage(
         modifier = modifier,
         onBackClicked = onBackClicked,
@@ -68,17 +60,19 @@ fun SecureBackupDisableView(
         buttons = { Buttons(state = state) },
     )
 
-    if (state.showConfirmationDialog) {
+    AsyncActionView(
-        SecureBackupDisableConfirmationDialog(
+        async = state.disableAction,
-            onConfirm = { state.eventSink.invoke(SecureBackupDisableEvents.DisableBackup(force = true)) },
+        confirmingDialog = {
-            onDismiss = { state.eventSink.invoke(SecureBackupDisableEvents.DismissDialogs) },
+            SecureBackupDisableConfirmationDialog(
-        )
+                onConfirm = { state.eventSink.invoke(SecureBackupDisableEvents.DisableBackup) },
-    } else if (state.disableAction is AsyncAction.Failure) {
+                onDismiss = { state.eventSink.invoke(SecureBackupDisableEvents.DismissDialogs) },
-        ErrorDialog(
+            )
-            content = state.disableAction.error.let { it.message ?: it.toString() },
+        },
-            onDismiss = { state.eventSink.invoke(SecureBackupDisableEvents.DismissDialogs) },
+        progressDialog = {},
-        )
+        errorMessage = { it.message ?: it.toString() },
-    }
+        onErrorDismiss = { state.eventSink.invoke(SecureBackupDisableEvents.DismissDialogs) },
+        onSuccess = { onDone() },
+    )
 }
 
 @Composable
@@ -102,7 +96,7 @@ private fun ColumnScope.Buttons(
         showProgress = state.disableAction.isLoading(),
         destructive = true,
         modifier = Modifier.fillMaxWidth(),
-        onClick = { state.eventSink.invoke(SecureBackupDisableEvents.DisableBackup(force = false)) }
+        onClick = { state.eventSink.invoke(SecureBackupDisableEvents.DisableBackup) }
     )
 }
 

features/securebackup/impl/src/test/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisablePresenterTest.kt

@@ -43,7 +43,6 @@ class SecureBackupDisablePresenterTest {
             val initialState = awaitItem()
             assertThat(initialState.backupState).isEqualTo(BackupState.UNKNOWN)
             assertThat(initialState.disableAction).isEqualTo(AsyncAction.Uninitialized)
-            assertThat(initialState.showConfirmationDialog).isFalse()
             assertThat(initialState.appName).isEqualTo("Element")
         }
     }
@@ -55,13 +54,12 @@ class SecureBackupDisablePresenterTest {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.showConfirmationDialog).isFalse()
+            initialState.eventSink(SecureBackupDisableEvents.DisableBackup)
-            initialState.eventSink(SecureBackupDisableEvents.DisableBackup(force = false))
             val state = awaitItem()
-            assertThat(state.showConfirmationDialog).isTrue()
+            assertThat(state.disableAction).isEqualTo(AsyncAction.Confirming)
             initialState.eventSink(SecureBackupDisableEvents.DismissDialogs)
             val finalState = awaitItem()
-            assertThat(finalState.showConfirmationDialog).isFalse()
+            assertThat(finalState.disableAction).isEqualTo(AsyncAction.Uninitialized)
         }
     }
 
@@ -72,14 +70,12 @@ class SecureBackupDisablePresenterTest {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.showConfirmationDialog).isFalse()
+            assertThat(initialState.disableAction).isEqualTo(AsyncAction.Uninitialized)
-            initialState.eventSink(SecureBackupDisableEvents.DisableBackup(force = false))
+            initialState.eventSink(SecureBackupDisableEvents.DisableBackup)
             val state = awaitItem()
-            assertThat(state.showConfirmationDialog).isTrue()
+            assertThat(state.disableAction).isEqualTo(AsyncAction.Confirming)
-            initialState.eventSink(SecureBackupDisableEvents.DisableBackup(force = true))
+            initialState.eventSink(SecureBackupDisableEvents.DisableBackup)
-            skipItems(1)
             val loadingState = awaitItem()
-            assertThat(loadingState.showConfirmationDialog).isFalse()
             assertThat(loadingState.disableAction).isInstanceOf(AsyncAction.Loading::class.java)
             val finalState = awaitItem()
             assertThat(finalState.disableAction).isEqualTo(AsyncAction.Success(Unit))
@@ -98,14 +94,12 @@ class SecureBackupDisablePresenterTest {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.showConfirmationDialog).isFalse()
+            assertThat(initialState.disableAction).isEqualTo(AsyncAction.Uninitialized)
-            initialState.eventSink(SecureBackupDisableEvents.DisableBackup(force = false))
+            initialState.eventSink(SecureBackupDisableEvents.DisableBackup)
             val state = awaitItem()
-            assertThat(state.showConfirmationDialog).isTrue()
+            assertThat(state.disableAction).isEqualTo(AsyncAction.Confirming)
-            initialState.eventSink(SecureBackupDisableEvents.DisableBackup(force = true))
+            initialState.eventSink(SecureBackupDisableEvents.DisableBackup)
-            skipItems(1)
             val loadingState = awaitItem()
-            assertThat(loadingState.showConfirmationDialog).isFalse()
             assertThat(loadingState.disableAction).isInstanceOf(AsyncAction.Loading::class.java)
             val errorState = awaitItem()
             assertThat(errorState.disableAction).isInstanceOf(AsyncAction.Failure::class.java)