Change type of SecureBackupEnableState.enableAction from AsyncData to AsyncAction

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnablePresenter.kt

@@ -22,7 +22,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import io.element.android.features.securebackup.impl.loggerTagDisable
-import io.element.android.libraries.architecture.AsyncData
+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.encryption.EncryptionService
@@ -36,14 +36,14 @@ class SecureBackupEnablePresenter @Inject constructor(
 ) : Presenter<SecureBackupEnableState> {
     @Composable
     override fun present(): SecureBackupEnableState {
-        val enableAction = remember { mutableStateOf<AsyncData<Unit>>(AsyncData.Uninitialized) }
+        val enableAction = remember { mutableStateOf<AsyncAction<Unit>>(AsyncAction.Uninitialized) }
         val coroutineScope = rememberCoroutineScope()
         fun handleEvents(event: SecureBackupEnableEvents) {
             when (event) {
                 is SecureBackupEnableEvents.EnableBackup ->
                     coroutineScope.enableBackup(enableAction)
                 SecureBackupEnableEvents.DismissDialog -> {
-                    enableAction.value = AsyncData.Uninitialized
+                    enableAction.value = AsyncAction.Uninitialized
                 }
             }
         }
@@ -54,7 +54,7 @@ class SecureBackupEnablePresenter @Inject constructor(
         )
     }
 
-    private fun CoroutineScope.enableBackup(action: MutableState<AsyncData<Unit>>) = launch {
+    private fun CoroutineScope.enableBackup(action: MutableState<AsyncAction<Unit>>) = launch {
         suspend {
             Timber.tag(loggerTagDisable.value).d("Calling encryptionService.enableBackups()")
             encryptionService.enableBackups().getOrThrow()

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnableState.kt

@@ -16,9 +16,9 @@
 
 package io.element.android.features.securebackup.impl.enable
 
-import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.architecture.AsyncAction
 
 data class SecureBackupEnableState(
-    val enableAction: AsyncData<Unit>,
+    val enableAction: AsyncAction<Unit>,
     val eventSink: (SecureBackupEnableEvents) -> Unit
 )

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnableStateProvider.kt

@@ -17,20 +17,20 @@
 package io.element.android.features.securebackup.impl.enable
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.architecture.AsyncAction
 
 open class SecureBackupEnableStateProvider : PreviewParameterProvider<SecureBackupEnableState> {
     override val values: Sequence<SecureBackupEnableState>
         get() = sequenceOf(
             aSecureBackupEnableState(),
-            aSecureBackupEnableState(enableAction = AsyncData.Loading()),
-            aSecureBackupEnableState(enableAction = AsyncData.Failure(Exception("Failed to enable"))),
+            aSecureBackupEnableState(enableAction = AsyncAction.Loading),
+            aSecureBackupEnableState(enableAction = AsyncAction.Failure(Exception("Failed to enable"))),
             // Add other states here
         )
 }
 
 fun aSecureBackupEnableState(
-    enableAction: AsyncData<Unit> = AsyncData.Uninitialized,
+    enableAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
 ) = SecureBackupEnableState(
     enableAction = enableAction,
     eventSink = {}

features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnableView.kt

@@ -19,16 +19,14 @@ package io.element.android.features.securebackup.impl.enable
 import androidx.compose.foundation.layout.ColumnScope
 import androidx.compose.foundation.layout.fillMaxWidth
 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
 import androidx.compose.ui.res.vectorResource
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import io.element.android.features.securebackup.impl.R
-import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.designsystem.atomic.pages.FlowStepPage
-import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
+import io.element.android.libraries.designsystem.components.async.AsyncActionView
 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
@@ -41,11 +39,6 @@ fun SecureBackupEnableView(
     onBackClicked: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    LaunchedEffect(state.enableAction) {
-        if (state.enableAction is AsyncData.Success) {
-            onDone()
-        }
-    }
     FlowStepPage(
         modifier = modifier,
         onBackClicked = onBackClicked,
@@ -53,12 +46,12 @@ fun SecureBackupEnableView(
         iconVector = ImageVector.vectorResource(CommonDrawables.ic_key),
         buttons = { Buttons(state = state) }
     )
-    if (state.enableAction is AsyncData.Failure) {
-        ErrorDialog(
-            content = state.enableAction.error.let { it.message ?: it.toString() },
-            onDismiss = { state.eventSink.invoke(SecureBackupEnableEvents.DismissDialog) },
-        )
-    }
+    AsyncActionView(
+        async = state.enableAction,
+        progressDialog = { },
+        onSuccess = { onDone() },
+        onErrorDismiss = { state.eventSink.invoke(SecureBackupEnableEvents.DismissDialog) }
+    )
 }
 
 @Composable

features/securebackup/impl/src/test/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnablePresenterTest.kt

@@ -20,7 +20,7 @@ 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.AsyncData
+import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.matrix.api.encryption.EncryptionService
 import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.matrix.test.encryption.FakeEncryptionService
@@ -40,7 +40,7 @@ class SecureBackupEnablePresenterTest {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.enableAction).isEqualTo(AsyncData.Uninitialized)
+            assertThat(initialState.enableAction).isEqualTo(AsyncAction.Uninitialized)
         }
     }
 
@@ -53,9 +53,9 @@ class SecureBackupEnablePresenterTest {
             val initialState = awaitItem()
             initialState.eventSink(SecureBackupEnableEvents.EnableBackup)
             val loadingState = awaitItem()
-            assertThat(loadingState.enableAction).isInstanceOf(AsyncData.Loading::class.java)
+            assertThat(loadingState.enableAction).isInstanceOf(AsyncAction.Loading::class.java)
             val finalState = awaitItem()
-            assertThat(finalState.enableAction).isEqualTo(AsyncData.Success(Unit))
+            assertThat(finalState.enableAction).isEqualTo(AsyncAction.Success(Unit))
         }
     }
 
@@ -70,12 +70,12 @@ class SecureBackupEnablePresenterTest {
             val initialState = awaitItem()
             initialState.eventSink(SecureBackupEnableEvents.EnableBackup)
             val loadingState = awaitItem()
-            assertThat(loadingState.enableAction).isInstanceOf(AsyncData.Loading::class.java)
+            assertThat(loadingState.enableAction).isInstanceOf(AsyncAction.Loading::class.java)
             val errorState = awaitItem()
-            assertThat(errorState.enableAction).isEqualTo(AsyncData.Failure<Unit>(AN_EXCEPTION))
+            assertThat(errorState.enableAction).isEqualTo(AsyncAction.Failure(AN_EXCEPTION))
             errorState.eventSink(SecureBackupEnableEvents.DismissDialog)
             val finalState = awaitItem()
-            assertThat(finalState.enableAction).isEqualTo(AsyncData.Uninitialized)
+            assertThat(finalState.enableAction).isEqualTo(AsyncAction.Uninitialized)
         }
     }