Rename Async to AsyncData

libraries/mediaviewer/api/src/main/kotlin/io/element/android/libraries/mediaviewer/api/viewer/MediaViewerPresenter.kt

@@ -29,7 +29,7 @@ import androidx.compose.runtime.setValue
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
-import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarDispatcher
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
@@ -64,8 +64,8 @@ class MediaViewerPresenter @AssistedInject constructor(
         val mediaFile: MutableState<MediaFile?> = remember {
             mutableStateOf(null)
         }
-        val localMedia: MutableState<Async<LocalMedia>> = remember {
-            mutableStateOf(Async.Uninitialized)
+        val localMedia: MutableState<AsyncData<LocalMedia>> = remember {
+            mutableStateOf(AsyncData.Uninitialized)
         }
         val snackbarMessage by snackbarDispatcher.collectSnackbarMessageAsState()
         localMediaActions.Configure()
@@ -79,7 +79,7 @@ class MediaViewerPresenter @AssistedInject constructor(
         fun handleEvents(mediaViewerEvents: MediaViewerEvents) {
             when (mediaViewerEvents) {
                 MediaViewerEvents.RetryLoading -> loadMediaTrigger++
-                MediaViewerEvents.ClearLoadingError -> localMedia.value = Async.Uninitialized
+                MediaViewerEvents.ClearLoadingError -> localMedia.value = AsyncData.Uninitialized
                 MediaViewerEvents.SaveOnDisk -> coroutineScope.saveOnDisk(localMedia.value)
                 MediaViewerEvents.Share -> coroutineScope.share(localMedia.value)
                 MediaViewerEvents.OpenWith -> coroutineScope.open(localMedia.value)
@@ -97,8 +97,8 @@ class MediaViewerPresenter @AssistedInject constructor(
         )
     }
 
-    private fun CoroutineScope.downloadMedia(mediaFile: MutableState<MediaFile?>, localMedia: MutableState<Async<LocalMedia>>) = launch {
-        localMedia.value = Async.Loading()
+    private fun CoroutineScope.downloadMedia(mediaFile: MutableState<MediaFile?>, localMedia: MutableState<AsyncData<LocalMedia>>) = launch {
+        localMedia.value = AsyncData.Loading()
         mediaLoader.downloadMediaFile(
             source = inputs.mediaSource,
             mimeType = inputs.mediaInfo.mimeType,
@@ -114,15 +114,15 @@ class MediaViewerPresenter @AssistedInject constructor(
                 )
             }
             .onSuccess {
-                localMedia.value = Async.Success(it)
+                localMedia.value = AsyncData.Success(it)
             }
             .onFailure {
-                localMedia.value = Async.Failure(it)
+                localMedia.value = AsyncData.Failure(it)
             }
     }
 
-    private fun CoroutineScope.saveOnDisk(localMedia: Async<LocalMedia>) = launch {
-        if (localMedia is Async.Success) {
+    private fun CoroutineScope.saveOnDisk(localMedia: AsyncData<LocalMedia>) = launch {
+        if (localMedia is AsyncData.Success) {
             localMediaActions.saveOnDisk(localMedia.data)
                 .onSuccess {
                     val snackbarMessage = SnackbarMessage(CommonStrings.common_file_saved_on_disk_android)
@@ -135,8 +135,8 @@ class MediaViewerPresenter @AssistedInject constructor(
         } else Unit
     }
 
-    private fun CoroutineScope.share(localMedia: Async<LocalMedia>) = launch {
-        if (localMedia is Async.Success) {
+    private fun CoroutineScope.share(localMedia: AsyncData<LocalMedia>) = launch {
+        if (localMedia is AsyncData.Success) {
             localMediaActions.share(localMedia.data)
                 .onFailure {
                     val snackbarMessage = SnackbarMessage(mediaActionsError(it))
@@ -145,8 +145,8 @@ class MediaViewerPresenter @AssistedInject constructor(
         } else Unit
     }
 
-    private fun CoroutineScope.open(localMedia: Async<LocalMedia>) = launch {
-        if (localMedia is Async.Success) {
+    private fun CoroutineScope.open(localMedia: AsyncData<LocalMedia>) = launch {
+        if (localMedia is AsyncData.Success) {
             localMediaActions.open(localMedia.data)
                 .onFailure {
                     val snackbarMessage = SnackbarMessage(mediaActionsError(it))

libraries/mediaviewer/api/src/main/kotlin/io/element/android/libraries/mediaviewer/api/viewer/MediaViewerState.kt

@@ -16,7 +16,7 @@
 
 package io.element.android.libraries.mediaviewer.api.viewer
 
-import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
 import io.element.android.libraries.matrix.api.media.MediaSource
 import io.element.android.libraries.mediaviewer.api.local.LocalMedia
@@ -25,7 +25,7 @@ import io.element.android.libraries.mediaviewer.api.local.MediaInfo
 data class MediaViewerState(
     val mediaInfo: MediaInfo,
     val thumbnailSource: MediaSource?,
-    val downloadedMedia: Async<LocalMedia>,
+    val downloadedMedia: AsyncData<LocalMedia>,
     val snackbarMessage: SnackbarMessage?,
     val canDownload: Boolean,
     val canShare: Boolean,

libraries/mediaviewer/api/src/main/kotlin/io/element/android/libraries/mediaviewer/api/viewer/MediaViewerStateProvider.kt

@@ -18,7 +18,7 @@ package io.element.android.libraries.mediaviewer.api.viewer
 
 import android.net.Uri
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.mediaviewer.api.local.LocalMedia
 import io.element.android.libraries.mediaviewer.api.local.MediaInfo
 import io.element.android.libraries.mediaviewer.api.local.aFileInfo
@@ -31,48 +31,48 @@ open class MediaViewerStateProvider : PreviewParameterProvider<MediaViewerState>
     override val values: Sequence<MediaViewerState>
         get() = sequenceOf(
             aMediaViewerState(),
-            aMediaViewerState(Async.Loading()),
-            aMediaViewerState(Async.Failure(IllegalStateException("error"))),
+            aMediaViewerState(AsyncData.Loading()),
+            aMediaViewerState(AsyncData.Failure(IllegalStateException("error"))),
             aMediaViewerState(
-                Async.Success(
+                AsyncData.Success(
                     LocalMedia(Uri.EMPTY, anImageInfo())
                 ),
                 anImageInfo(),
             ),
             aMediaViewerState(
-                Async.Success(
+                AsyncData.Success(
                     LocalMedia(Uri.EMPTY, aVideoInfo())
                 ),
                 aVideoInfo(),
             ),
             aMediaViewerState(
-                Async.Success(
+                AsyncData.Success(
                     LocalMedia(Uri.EMPTY, aPdfInfo())
                 ),
                 aPdfInfo(),
             ),
             aMediaViewerState(
-                Async.Loading(),
+                AsyncData.Loading(),
                 aFileInfo(),
             ),
             aMediaViewerState(
-                Async.Success(
+                AsyncData.Success(
                     LocalMedia(Uri.EMPTY, aFileInfo())
                 ),
                 aFileInfo(),
             ),
             aMediaViewerState(
-                Async.Loading(),
+                AsyncData.Loading(),
                 anAudioInfo(),
             ),
             aMediaViewerState(
-                Async.Success(
+                AsyncData.Success(
                     LocalMedia(Uri.EMPTY, anAudioInfo())
                 ),
                 anAudioInfo(),
             ),
             aMediaViewerState(
-                Async.Success(
+                AsyncData.Success(
                     LocalMedia(Uri.EMPTY, anImageInfo())
                 ),
                 anImageInfo(),
@@ -83,7 +83,7 @@ open class MediaViewerStateProvider : PreviewParameterProvider<MediaViewerState>
 }
 
 fun aMediaViewerState(
-    downloadedMedia: Async<LocalMedia> = Async.Uninitialized,
+    downloadedMedia: AsyncData<LocalMedia> = AsyncData.Uninitialized,
     mediaInfo: MediaInfo = anImageInfo(),
     canDownload: Boolean = true,
     canShare: Boolean = true,

libraries/mediaviewer/api/src/main/kotlin/io/element/android/libraries/mediaviewer/api/viewer/MediaViewerView.kt

@@ -47,7 +47,7 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import coil.compose.AsyncImage
-import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.designsystem.components.button.BackButton
 import io.element.android.libraries.designsystem.components.dialogs.RetryDialog
@@ -93,7 +93,7 @@ fun MediaViewerView(
         modifier,
         topBar = {
             MediaViewerTopBar(
-                actionsEnabled = state.downloadedMedia is Async.Success,
+                actionsEnabled = state.downloadedMedia is AsyncData.Success,
                 mimeType = state.mediaInfo.mimeType,
                 onBackPressed = onBackPressed,
                 canDownload = state.canDownload,
@@ -121,7 +121,7 @@ fun MediaViewerView(
                 modifier = Modifier.fillMaxSize(),
                 contentAlignment = Alignment.Center
             ) {
-                if (state.downloadedMedia is Async.Failure) {
+                if (state.downloadedMedia is AsyncData.Failure) {
                     ErrorView(
                         errorMessage = stringResource(id = CommonStrings.error_unknown),
                         onRetry = ::onRetry,
@@ -144,7 +144,7 @@ fun MediaViewerView(
 }
 
 @Composable
-private fun rememberShowProgress(downloadedMedia: Async<LocalMedia>): Boolean {
+private fun rememberShowProgress(downloadedMedia: AsyncData<LocalMedia>): Boolean {
     var showProgress by remember {
         mutableStateOf(false)
     }

libraries/mediaviewer/api/src/test/kotlin/io/element/android/libraries/mediaviewer/MediaViewerPresenterTest.kt

@@ -23,7 +23,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.Async
+import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarDispatcher
 import io.element.android.libraries.matrix.test.media.FakeMediaLoader
 import io.element.android.libraries.matrix.test.media.aMediaSource
@@ -60,13 +60,13 @@ class MediaViewerPresenterTest {
             presenter.present()
         }.test {
             var state = awaitItem()
-            assertThat(state.downloadedMedia).isEqualTo(Async.Uninitialized)
+            assertThat(state.downloadedMedia).isEqualTo(AsyncData.Uninitialized)
             assertThat(state.mediaInfo).isEqualTo(TESTED_MEDIA_INFO)
             state = awaitItem()
-            assertThat(state.downloadedMedia).isInstanceOf(Async.Loading::class.java)
+            assertThat(state.downloadedMedia).isInstanceOf(AsyncData.Loading::class.java)
             state = awaitItem()
             val successData = state.downloadedMedia.dataOrNull()
-            assertThat(state.downloadedMedia).isInstanceOf(Async.Success::class.java)
+            assertThat(state.downloadedMedia).isInstanceOf(AsyncData.Success::class.java)
             assertThat(successData).isNotNull()
         }
     }
@@ -81,15 +81,15 @@ class MediaViewerPresenterTest {
             presenter.present()
         }.test {
             var state = awaitItem()
-            assertThat(state.downloadedMedia).isEqualTo(Async.Uninitialized)
+            assertThat(state.downloadedMedia).isEqualTo(AsyncData.Uninitialized)
             state = awaitItem()
-            assertThat(state.downloadedMedia).isInstanceOf(Async.Loading::class.java)
+            assertThat(state.downloadedMedia).isInstanceOf(AsyncData.Loading::class.java)
             // no state changes while media is loading
             state.eventSink(MediaViewerEvents.OpenWith)
             state.eventSink(MediaViewerEvents.Share)
             state.eventSink(MediaViewerEvents.SaveOnDisk)
             state = awaitItem()
-            assertThat(state.downloadedMedia).isInstanceOf(Async.Success::class.java)
+            assertThat(state.downloadedMedia).isInstanceOf(AsyncData.Success::class.java)
             // Should succeed without change of state
             state.eventSink(MediaViewerEvents.OpenWith)
             // Should succeed without change of state
@@ -128,21 +128,21 @@ class MediaViewerPresenterTest {
         }.test {
             mediaLoader.shouldFail = true
             val initialState = awaitItem()
-            assertThat(initialState.downloadedMedia).isEqualTo(Async.Uninitialized)
+            assertThat(initialState.downloadedMedia).isEqualTo(AsyncData.Uninitialized)
             assertThat(initialState.mediaInfo).isEqualTo(TESTED_MEDIA_INFO)
             val loadingState = awaitItem()
-            assertThat(loadingState.downloadedMedia).isInstanceOf(Async.Loading::class.java)
+            assertThat(loadingState.downloadedMedia).isInstanceOf(AsyncData.Loading::class.java)
             val failureState = awaitItem()
-            assertThat(failureState.downloadedMedia).isInstanceOf(Async.Failure::class.java)
+            assertThat(failureState.downloadedMedia).isInstanceOf(AsyncData.Failure::class.java)
             mediaLoader.shouldFail = false
             failureState.eventSink(MediaViewerEvents.RetryLoading)
             //There is one recomposition because of the retry mechanism
             skipItems(1)
             val retryLoadingState = awaitItem()
-            assertThat(retryLoadingState.downloadedMedia).isInstanceOf(Async.Loading::class.java)
+            assertThat(retryLoadingState.downloadedMedia).isInstanceOf(AsyncData.Loading::class.java)
             val successState = awaitItem()
             val successData = successState.downloadedMedia.dataOrNull()
-            assertThat(successState.downloadedMedia).isInstanceOf(Async.Success::class.java)
+            assertThat(successState.downloadedMedia).isInstanceOf(AsyncData.Success::class.java)
             assertThat(successData).isNotNull()
         }
     }