Sulkta-OSS/element-x-ada
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename AsyncView to AsyncActionView

Browse source
This commit is contained in:
Benoit Marty 2024-01-04 16:49:22 +01:00
parent 7b2341aec7
commit e42005fc52
71 changed files with 369 additions and 315 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -25,7 +25,7 @@ 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.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.core.meta.BuildMeta
@ -44,7 +44,7 @@ class SecureBackupDisablePresenter @Inject constructor(
override fun present(): SecureBackupDisableState {
val backupState by encryptionService.backupStateStateFlow.collectAsState()
Timber.tag(loggerTagDisable.value).d("backupState: $backupState")
val disableAction = remember { mutableStateOf<AsyncData<Unit>>(AsyncData.Uninitialized) }
val disableAction: MutableState<AsyncAction<Unit>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
val coroutineScope = rememberCoroutineScope()
var showDialog by remember { mutableStateOf(false) }
fun handleEvents(event: SecureBackupDisableEvents) {
@ -57,7 +57,7 @@ class SecureBackupDisablePresenter @Inject constructor(
}
SecureBackupDisableEvents.DismissDialogs -> {
showDialog = false
disableAction.value = AsyncData.Uninitialized
disableAction.value = AsyncAction.Uninitialized
}
}
}
@ -71,7 +71,7 @@ class SecureBackupDisablePresenter @Inject constructor(
)
}
private fun CoroutineScope.disableBackup(disableAction: MutableState<AsyncData<Unit>>) = launch {
private fun CoroutineScope.disableBackup(disableAction: MutableState<AsyncAction<Unit>>) = launch {
suspend {
Timber.tag(loggerTagDisable.value).d("Calling encryptionService.disableRecovery()")
encryptionService.disableRecovery().getOrThrow()

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

@ -16,12 +16,12 @@
package io.element.android.features.securebackup.impl.disable
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.architecture.AsyncAction
import io.element.android.libraries.matrix.api.encryption.BackupState
data class SecureBackupDisableState(
val backupState: BackupState,
val disableAction: AsyncData<Unit>,
val disableAction: AsyncAction<Unit>,
val showConfirmationDialog: Boolean,
val appName: String,
val eventSink: (SecureBackupDisableEvents) -> Unit

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

@ -17,7 +17,7 @@
package io.element.android.features.securebackup.impl.disable
import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.architecture.AsyncAction
import io.element.android.libraries.matrix.api.encryption.BackupState
open class SecureBackupDisableStateProvider : PreviewParameterProvider<SecureBackupDisableState> {
@ -25,15 +25,15 @@ open class SecureBackupDisableStateProvider : PreviewParameterProvider<SecureBac
get() = sequenceOf(
aSecureBackupDisableState(),
aSecureBackupDisableState(showConfirmationDialog = true),
aSecureBackupDisableState(disableAction = AsyncData.Loading()),
aSecureBackupDisableState(disableAction = AsyncData.Failure(Exception("Failed to disable"))),
aSecureBackupDisableState(disableAction = AsyncAction.Loading),
aSecureBackupDisableState(disableAction = AsyncAction.Failure(Exception("Failed to disable"))),
// Add other states here
)
}
fun aSecureBackupDisableState(
backupState: BackupState = BackupState.UNKNOWN,
disableAction: AsyncData<Unit> = AsyncData.Uninitialized,
disableAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
showConfirmationDialog: Boolean = false,
) = SecureBackupDisableState(
backupState = backupState,

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

@ -34,6 +34,7 @@ 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.dialogs.ConfirmationDialog
@ -53,7 +54,7 @@ fun SecureBackupDisableView(
modifier: Modifier = Modifier,
) {
LaunchedEffect(state.disableAction) {
if (state.disableAction is AsyncData.Success) {
if (state.disableAction is AsyncAction.Success) {
onDone()
}
}
@ -72,7 +73,7 @@ fun SecureBackupDisableView(
onConfirm = { state.eventSink.invoke(SecureBackupDisableEvents.DisableBackup(force = true)) },
onDismiss = { state.eventSink.invoke(SecureBackupDisableEvents.DismissDialogs) },
)
} else if (state.disableAction is AsyncData.Failure) {
} else if (state.disableAction is AsyncAction.Failure) {
ErrorDialog(
content = state.disableAction.error.let { it.message ?: it.toString() },
onDismiss = { state.eventSink.invoke(SecureBackupDisableEvents.DismissDialogs) },

10
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyPresenter.kt
View file

@ -27,7 +27,7 @@ import androidx.compose.runtime.setValue
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyUserStory
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyViewState
import io.element.android.features.securebackup.impl.tools.RecoveryKeyTools
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
@ -46,14 +46,14 @@ class SecureBackupEnterRecoveryKeyPresenter @Inject constructor(
var recoveryKey by rememberSaveable {
mutableStateOf("")
}
val submitAction = remember {
mutableStateOf<AsyncData<Unit>>(AsyncData.Uninitialized)
val submitAction: MutableState<AsyncAction<Unit>> = remember {
mutableStateOf(AsyncAction.Uninitialized)
}
fun handleEvents(event: SecureBackupEnterRecoveryKeyEvents) {
when (event) {
SecureBackupEnterRecoveryKeyEvents.ClearDialog -> {
submitAction.value = AsyncData.Uninitialized
submitAction.value = AsyncAction.Uninitialized
}
is SecureBackupEnterRecoveryKeyEvents.OnRecoveryKeyChange -> {
val previousRecoveryKey = recoveryKey
@ -86,7 +86,7 @@ class SecureBackupEnterRecoveryKeyPresenter @Inject constructor(
private fun CoroutineScope.submitRecoveryKey(
recoveryKey: String,
action: MutableState<AsyncData<Unit>>
action: MutableState<AsyncAction<Unit>>
) = launch {
suspend {
encryptionService.recover(recoveryKey).getOrThrow()

4
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyState.kt
View file

@ -17,12 +17,12 @@
package io.element.android.features.securebackup.impl.enter
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyViewState
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.architecture.AsyncAction
// Do not use default value, so no member get forgotten in the presenters.
data class SecureBackupEnterRecoveryKeyState(
val recoveryKeyViewState: RecoveryKeyViewState,
val isSubmitEnabled: Boolean,
val submitAction: AsyncData<Unit>,
val submitAction: AsyncAction<Unit>,
val eventSink: (SecureBackupEnterRecoveryKeyEvents) -> Unit
)

7
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyStateProvider.kt
View file

@ -20,6 +20,7 @@ import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyUserStory
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyViewState
import io.element.android.features.securebackup.impl.setup.views.aFormattedRecoveryKey
import io.element.android.libraries.architecture.AsyncAction
import io.element.android.libraries.architecture.AsyncData
open class SecureBackupEnterRecoveryKeyStateProvider : PreviewParameterProvider<SecureBackupEnterRecoveryKeyState> {
@ -27,15 +28,15 @@ open class SecureBackupEnterRecoveryKeyStateProvider : PreviewParameterProvider<
get() = sequenceOf(
aSecureBackupEnterRecoveryKeyState(recoveryKey = ""),
aSecureBackupEnterRecoveryKeyState(),
aSecureBackupEnterRecoveryKeyState(submitAction = AsyncData.Loading()),
aSecureBackupEnterRecoveryKeyState(submitAction = AsyncData.Failure(Exception("A Failure"))),
aSecureBackupEnterRecoveryKeyState(submitAction = AsyncAction.Loading),
aSecureBackupEnterRecoveryKeyState(submitAction = AsyncAction.Failure(Exception("A Failure"))),
)
}
fun aSecureBackupEnterRecoveryKeyState(
recoveryKey: String = aFormattedRecoveryKey(),
isSubmitEnabled: Boolean = recoveryKey.isNotEmpty(),
submitAction: AsyncData<Unit> = AsyncData.Uninitialized,
submitAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
) = SecureBackupEnterRecoveryKeyState(
recoveryKeyViewState = RecoveryKeyViewState(
recoveryKeyUserStory = RecoveryKeyUserStory.Enter,

4
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyView.kt
View file

@ -29,7 +29,7 @@ import androidx.compose.ui.unit.dp
import io.element.android.features.securebackup.impl.R
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyView
import io.element.android.libraries.designsystem.atomic.pages.FlowStepPage
import io.element.android.libraries.designsystem.components.async.AsyncView
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
@ -43,7 +43,7 @@ fun SecureBackupEnterRecoveryKeyView(
onBackClicked: () -> Unit,
modifier: Modifier = Modifier,
) {
AsyncView(
AsyncActionView(
async = state.submitAction,
onSuccess = { onDone() },
showProgressDialog = false,

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

@ -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.BackupState
import io.element.android.libraries.matrix.api.encryption.EncryptionService
import io.element.android.libraries.matrix.test.core.aBuildMeta
@ -42,7 +42,7 @@ class SecureBackupDisablePresenterTest {
}.test {
val initialState = awaitItem()
assertThat(initialState.backupState).isEqualTo(BackupState.UNKNOWN)
assertThat(initialState.disableAction).isEqualTo(AsyncData.Uninitialized)
assertThat(initialState.disableAction).isEqualTo(AsyncAction.Uninitialized)
assertThat(initialState.showConfirmationDialog).isFalse()
assertThat(initialState.appName).isEqualTo("Element")
}
@ -80,9 +80,9 @@ class SecureBackupDisablePresenterTest {
skipItems(1)
val loadingState = awaitItem()
assertThat(loadingState.showConfirmationDialog).isFalse()
assertThat(loadingState.disableAction).isInstanceOf(AsyncData.Loading::class.java)
assertThat(loadingState.disableAction).isInstanceOf(AsyncAction.Loading::class.java)
val finalState = awaitItem()
assertThat(finalState.disableAction).isEqualTo(AsyncData.Success(Unit))
assertThat(finalState.disableAction).isEqualTo(AsyncAction.Success(Unit))
}
}
@ -106,12 +106,12 @@ class SecureBackupDisablePresenterTest {
skipItems(1)
val loadingState = awaitItem()
assertThat(loadingState.showConfirmationDialog).isFalse()
assertThat(loadingState.disableAction).isInstanceOf(AsyncData.Loading::class.java)
assertThat(loadingState.disableAction).isInstanceOf(AsyncAction.Loading::class.java)
val errorState = awaitItem()
assertThat(errorState.disableAction).isInstanceOf(AsyncData.Failure::class.java)
assertThat(errorState.disableAction).isInstanceOf(AsyncAction.Failure::class.java)
errorState.eventSink(SecureBackupDisableEvents.DismissDialogs)
val finalState = awaitItem()
assertThat(finalState.disableAction).isEqualTo(AsyncData.Uninitialized)
assertThat(finalState.disableAction).isEqualTo(AsyncAction.Uninitialized)
}
}

14
features/securebackup/impl/src/test/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyPresenterTest.kt
View file

@ -23,7 +23,7 @@ import com.google.common.truth.Truth.assertThat
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyUserStory
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyViewState
import io.element.android.features.securebackup.impl.tools.RecoveryKeyTools
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
@ -44,7 +44,7 @@ class SecureBackupEnterRecoveryKeyPresenterTest {
}.test {
val initialState = awaitItem()
assertThat(initialState.isSubmitEnabled).isFalse()
assertThat(initialState.submitAction).isEqualTo(AsyncData.Uninitialized)
assertThat(initialState.submitAction).isEqualTo(AsyncAction.Uninitialized)
assertThat(initialState.recoveryKeyViewState).isEqualTo(
RecoveryKeyViewState(
recoveryKeyUserStory = RecoveryKeyUserStory.Enter,
@ -76,22 +76,22 @@ class SecureBackupEnterRecoveryKeyPresenterTest {
encryptionService.givenRecoverFailure(AN_EXCEPTION)
withRecoveryKeyState.eventSink(SecureBackupEnterRecoveryKeyEvents.Submit)
val loadingState = awaitItem()
assertThat(loadingState.submitAction).isEqualTo(AsyncData.Loading<Unit>())
assertThat(loadingState.submitAction).isEqualTo(AsyncAction.Loading)
assertThat(loadingState.isSubmitEnabled).isFalse()
val errorState = awaitItem()
assertThat(errorState.submitAction).isEqualTo(AsyncData.Failure<Unit>(AN_EXCEPTION))
assertThat(errorState.submitAction).isEqualTo(AsyncAction.Failure(AN_EXCEPTION))
assertThat(errorState.isSubmitEnabled).isFalse()
errorState.eventSink(SecureBackupEnterRecoveryKeyEvents.ClearDialog)
val clearedState = awaitItem()
assertThat(clearedState.submitAction).isEqualTo(AsyncData.Uninitialized)
assertThat(clearedState.submitAction).isEqualTo(AsyncAction.Uninitialized)
assertThat(clearedState.isSubmitEnabled).isTrue()
encryptionService.givenRecoverFailure(null)
clearedState.eventSink(SecureBackupEnterRecoveryKeyEvents.Submit)
val loadingState2 = awaitItem()
assertThat(loadingState2.submitAction).isEqualTo(AsyncData.Loading<Unit>())
assertThat(loadingState2.submitAction).isEqualTo(AsyncAction.Loading)
assertThat(loadingState2.isSubmitEnabled).isFalse()
val finalState = awaitItem()
assertThat(finalState.submitAction).isEqualTo(AsyncData.Success(Unit))
assertThat(finalState.submitAction).isEqualTo(AsyncAction.Success(Unit))
assertThat(finalState.isSubmitEnabled).isFalse()
}
}