diff --git a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewPresenter.kt b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewPresenter.kt index bc3e121070..69d28d8f20 100644 --- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewPresenter.kt +++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewPresenter.kt @@ -8,6 +8,7 @@ package io.element.android.features.messages.impl.attachments.preview import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.MutableState import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf @@ -19,10 +20,16 @@ import dagger.assisted.AssistedFactory import dagger.assisted.AssistedInject import io.element.android.features.messages.impl.attachments.Attachment import io.element.android.libraries.androidutils.file.TemporaryUriDeleter +import io.element.android.libraries.androidutils.file.safeDelete +import io.element.android.libraries.architecture.AsyncData import io.element.android.libraries.architecture.Presenter +import io.element.android.libraries.featureflag.api.FeatureFlagService +import io.element.android.libraries.featureflag.api.FeatureFlags import io.element.android.libraries.matrix.api.core.ProgressCallback import io.element.android.libraries.matrix.api.permalink.PermalinkBuilder import io.element.android.libraries.mediaupload.api.MediaSender +import io.element.android.libraries.mediaupload.api.MediaUploadInfo +import io.element.android.libraries.mediaupload.api.allFiles import io.element.android.libraries.textcomposer.model.TextEditorState import io.element.android.libraries.textcomposer.model.rememberMarkdownTextEditorState import kotlinx.coroutines.CancellationException @@ -39,6 +46,7 @@ class AttachmentsPreviewPresenter @AssistedInject constructor( private val mediaSender: MediaSender, private val permalinkBuilder: PermalinkBuilder, private val temporaryUriDeleter: TemporaryUriDeleter, + private val featureFlagsService: FeatureFlagService, ) : Presenter { @AssistedFactory interface Factory { @@ -63,19 +71,62 @@ class AttachmentsPreviewPresenter @AssistedInject constructor( val ongoingSendAttachmentJob = remember { mutableStateOf(null) } + val userSentAttachment = remember { mutableStateOf(false) } + + val mediaUploadInfoState = remember { mutableStateOf>(AsyncData.Uninitialized) } + LaunchedEffect(Unit) { + preProcessAttachment( + attachment, + mediaUploadInfoState, + ) + } + + LaunchedEffect(userSentAttachment.value, mediaUploadInfoState.value) { + if (userSentAttachment.value) { + // User confirmed sending the attachment + when (val mediaUploadInfo = mediaUploadInfoState.value) { + is AsyncData.Success -> { + // Pre-processing is done, send the attachment + val caption = markdownTextEditorState.getMessageMarkdown(permalinkBuilder) + .takeIf { it.isNotEmpty() } + ongoingSendAttachmentJob.value = coroutineScope.launch { + sendPreProcessedMedia( + mediaUploadInfo = mediaUploadInfo.data, + caption = caption, + sendActionState = sendActionState, + ) + } + } + is AsyncData.Failure -> { + // Pre-processing has failed, show the error + sendActionState.value = SendActionState.Failure(mediaUploadInfo.error) + } + AsyncData.Uninitialized, + is AsyncData.Loading -> { + // Pre-processing is still in progress, do nothing + } + } + } + } + fun handleEvents(attachmentsPreviewEvents: AttachmentsPreviewEvents) { when (attachmentsPreviewEvents) { - is AttachmentsPreviewEvents.SendAttachment -> { - val caption = markdownTextEditorState.getMessageMarkdown(permalinkBuilder) - .takeIf { it.isNotEmpty() } - ongoingSendAttachmentJob.value = coroutineScope.sendAttachment( - attachment = attachment, - caption = caption, - sendActionState = sendActionState, - ) + is AttachmentsPreviewEvents.SendAttachment -> coroutineScope.launch { + val useSendQueue = featureFlagsService.isFeatureEnabled(FeatureFlags.MediaUploadOnSendQueue) + userSentAttachment.value = true + val instantSending = mediaUploadInfoState.value.isReady() && useSendQueue + sendActionState.value = if (instantSending) { + SendActionState.Sending.InstantSending + } else { + SendActionState.Sending.Processing + } } AttachmentsPreviewEvents.Cancel -> { - coroutineScope.cancel(attachment) + coroutineScope.cancel( + attachment, + mediaUploadInfoState.value, + sendActionState, + ) } AttachmentsPreviewEvents.ClearSendState -> { ongoingSendAttachmentJob.value?.let { @@ -95,56 +146,95 @@ class AttachmentsPreviewPresenter @AssistedInject constructor( ) } - private fun CoroutineScope.sendAttachment( + private fun CoroutineScope.preProcessAttachment( attachment: Attachment, - caption: String?, - sendActionState: MutableState, + mediaUploadInfoState: MutableState>, ) = launch { when (attachment) { is Attachment.Media -> { - sendMedia( + preProcessMedia( mediaAttachment = attachment, - caption = caption, - sendActionState = sendActionState, + mediaUploadInfoState = mediaUploadInfoState, ) } } } + private suspend fun preProcessMedia( + mediaAttachment: Attachment.Media, + mediaUploadInfoState: MutableState>, + ) { + mediaUploadInfoState.value = AsyncData.Loading() + mediaSender.preProcessMedia( + uri = mediaAttachment.localMedia.uri, + mimeType = mediaAttachment.localMedia.info.mimeType, + ).fold( + onSuccess = { mediaUploadInfo -> + mediaUploadInfoState.value = AsyncData.Success(mediaUploadInfo) + }, + onFailure = { + Timber.e(it, "Failed to pre-process media") + if (it is CancellationException) { + throw it + } else { + mediaUploadInfoState.value = AsyncData.Failure(it) + } + } + ) + } + private fun CoroutineScope.cancel( attachment: Attachment, + mediaUploadInfo: AsyncData, + sendActionState: MutableState, ) = launch { // Delete the temporary file when (attachment) { is Attachment.Media -> { temporaryUriDeleter.delete(attachment.localMedia.uri) + mediaUploadInfo.dataOrNull()?.let { data -> + cleanUp(data) + } } } + // Reset the sendActionState to ensure that dialog is closed before the screen + sendActionState.value = SendActionState.Done onDoneListener() } - private suspend fun sendMedia( - mediaAttachment: Attachment.Media, + private fun cleanUp( + mediaUploadInfo: MediaUploadInfo, + ) { + mediaUploadInfo.allFiles().forEach { file -> + file.safeDelete() + } + } + + private suspend fun sendPreProcessedMedia( + mediaUploadInfo: MediaUploadInfo, caption: String?, sendActionState: MutableState, ) = runCatching { val context = coroutineContext val progressCallback = object : ProgressCallback { override fun onProgress(current: Long, total: Long) { + // Note will not happen if useSendQueue is true if (context.isActive) { sendActionState.value = SendActionState.Sending.Uploading(current.toFloat() / total.toFloat()) } } } - sendActionState.value = SendActionState.Sending.Processing - mediaSender.sendMedia( - uri = mediaAttachment.localMedia.uri, - mimeType = mediaAttachment.localMedia.info.mimeType, + mediaSender.sendPreProcessedMedia( + mediaUploadInfo = mediaUploadInfo, caption = caption, + formattedCaption = null, progressCallback = progressCallback ).getOrThrow() }.fold( onSuccess = { + cleanUp(mediaUploadInfo) + // Reset the sendActionState to ensure that dialog is closed before the screen + sendActionState.value = SendActionState.Done onDoneListener() }, onFailure = { error -> diff --git a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewState.kt b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewState.kt index 5fed2acfb2..0e9724c460 100644 --- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewState.kt +++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewState.kt @@ -27,9 +27,11 @@ sealed interface SendActionState { @Immutable sealed interface Sending : SendActionState { + data object InstantSending : Sending data object Processing : Sending data class Uploading(val progress: Float) : Sending } data class Failure(val error: Throwable) : SendActionState + data object Done : SendActionState } diff --git a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewStateProvider.kt b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewStateProvider.kt index 78f3ffc81a..1c55245e46 100644 --- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewStateProvider.kt +++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewStateProvider.kt @@ -26,6 +26,7 @@ open class AttachmentsPreviewStateProvider : PreviewParameterProvider Unit ) { when (sendActionState) { - is SendActionState.Sending -> { + is SendActionState.Sending.Processing -> { ProgressDialog( - type = when (sendActionState) { - is SendActionState.Sending.Uploading -> ProgressDialogType.Determinate(sendActionState.progress) - SendActionState.Sending.Processing -> ProgressDialogType.Indeterminate - }, + type = ProgressDialogType.Indeterminate, + text = stringResource(id = CommonStrings.common_sending), + showCancelButton = true, + onDismissRequest = onDismissClick, + ) + } + is SendActionState.Sending.Uploading -> { + ProgressDialog( + type = ProgressDialogType.Determinate(sendActionState.progress), text = stringResource(id = CommonStrings.common_sending), showCancelButton = true, onDismissRequest = onDismissClick, diff --git a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/attachments/AttachmentsPreviewPresenterTest.kt b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/attachments/AttachmentsPreviewPresenterTest.kt index 4f35c592f1..48e5c208b6 100644 --- a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/attachments/AttachmentsPreviewPresenterTest.kt +++ b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/attachments/AttachmentsPreviewPresenterTest.kt @@ -20,6 +20,8 @@ import io.element.android.features.messages.impl.attachments.preview.OnDoneListe import io.element.android.features.messages.impl.attachments.preview.SendActionState import io.element.android.features.messages.impl.fixtures.aMediaAttachment import io.element.android.libraries.androidutils.file.TemporaryUriDeleter +import io.element.android.libraries.featureflag.api.FeatureFlags +import io.element.android.libraries.featureflag.test.FakeFeatureFlagService import io.element.android.libraries.matrix.api.core.ProgressCallback import io.element.android.libraries.matrix.api.media.AudioInfo import io.element.android.libraries.matrix.api.media.FileInfo @@ -40,10 +42,12 @@ import io.element.android.libraries.preferences.test.InMemorySessionPreferencesS import io.element.android.tests.testutils.WarmUpRule import io.element.android.tests.testutils.fake.FakeTemporaryUriDeleter import io.element.android.tests.testutils.lambda.any +import io.element.android.tests.testutils.lambda.lambdaError import io.element.android.tests.testutils.lambda.lambdaRecorder import io.element.android.tests.testutils.lambda.value import io.element.android.tests.testutils.test import io.mockk.mockk +import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.test.advanceUntilIdle import kotlinx.coroutines.test.runTest @@ -84,16 +88,142 @@ class AttachmentsPreviewPresenterTest { val initialState = awaitItem() assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Uploading(0f)) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Uploading(0.5f)) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Uploading(1f)) - advanceUntilIdle() + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Done) sendFileResult.assertions().isCalledOnce() onDoneListener.assertions().isCalledOnce() } } + @Test + fun `present - send media after pre-processing success scenario`() = runTest { + val sendFileResult = lambdaRecorder> { _, _, _, _, _ -> + Result.success(FakeMediaUploadHandler()) + } + val room = FakeMatrixRoom( + sendFileResult = sendFileResult, + ) + val onDoneListener = lambdaRecorder { } + val processLatch = CompletableDeferred() + val presenter = createAttachmentsPreviewPresenter( + room = room, + mediaPreProcessor = FakeMediaPreProcessor( + processLatch = processLatch, + ), + onDoneListener = { onDoneListener() }, + ) + moleculeFlow(RecompositionMode.Immediate) { + presenter.present() + }.test { + val initialState = awaitItem() + assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) + // Pre-processing finishes + processLatch.complete(Unit) + advanceUntilIdle() + initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.InstantSending) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Done) + sendFileResult.assertions().isCalledOnce() + onDoneListener.assertions().isCalledOnce() + } + } + + @Test + fun `present - send media before pre-processing success scenario`() = runTest { + val sendFileResult = lambdaRecorder> { _, _, _, _, _ -> + Result.success(FakeMediaUploadHandler()) + } + val room = FakeMatrixRoom( + sendFileResult = sendFileResult, + ) + val onDoneListener = lambdaRecorder { } + val processLatch = CompletableDeferred() + val presenter = createAttachmentsPreviewPresenter( + room = room, + mediaPreProcessor = FakeMediaPreProcessor( + processLatch = processLatch, + ), + onDoneListener = { onDoneListener() }, + ) + moleculeFlow(RecompositionMode.Immediate) { + presenter.present() + }.test { + val initialState = awaitItem() + assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) + initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) + // Pre-processing finishes + processLatch.complete(Unit) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Done) + sendFileResult.assertions().isCalledOnce() + onDoneListener.assertions().isCalledOnce() + } + } + + @Test + fun `present - send media with pre-processing failure after user sends media`() = runTest { + val room = FakeMatrixRoom() + val onDoneListener = lambdaRecorder { } + val processLatch = CompletableDeferred() + val presenter = createAttachmentsPreviewPresenter( + room = room, + mediaPreProcessor = FakeMediaPreProcessor().apply { + givenResult(Result.failure(Exception())) + }, + onDoneListener = { onDoneListener() }, + ) + moleculeFlow(RecompositionMode.Immediate) { + presenter.present() + }.test { + val initialState = awaitItem() + assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) + initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) + // Pre-processing finishes + processLatch.complete(Unit) + assertThat(awaitItem().sendActionState).isInstanceOf(SendActionState.Failure::class.java) + } + } + + @Test + fun `present - send media with pre-processing failure before user sends media`() = runTest { + val room = FakeMatrixRoom() + val onDoneListener = lambdaRecorder { } + val processLatch = CompletableDeferred() + val presenter = createAttachmentsPreviewPresenter( + room = room, + mediaPreProcessor = FakeMediaPreProcessor().apply { + givenResult(Result.failure(Exception())) + }, + onDoneListener = { onDoneListener() }, + ) + moleculeFlow(RecompositionMode.Immediate) { + presenter.present() + }.test { + val initialState = awaitItem() + assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) + // Pre-processing finishes + processLatch.complete(Unit) + advanceUntilIdle() + initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.InstantSending) + assertThat(awaitItem().sendActionState).isInstanceOf(SendActionState.Failure::class.java) + } + } + @Test fun `present - cancel scenario`() = runTest { val onDoneListener = lambdaRecorder { } @@ -108,6 +238,8 @@ class AttachmentsPreviewPresenterTest { val initialState = awaitItem() assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) initialState.eventSink(AttachmentsPreviewEvents.Cancel) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Done) deleteCallback.assertions().isCalledOnce() onDoneListener.assertions().isCalledOnce() } @@ -138,8 +270,10 @@ class AttachmentsPreviewPresenterTest { assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) initialState.textEditorState.setMarkdown(A_CAPTION) initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) - advanceUntilIdle() + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Done) sendImageResult.assertions().isCalledOnce().with( any(), any(), @@ -177,8 +311,10 @@ class AttachmentsPreviewPresenterTest { assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) initialState.textEditorState.setMarkdown(A_CAPTION) initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) - advanceUntilIdle() + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Done) sendVideoResult.assertions().isCalledOnce().with( any(), any(), @@ -214,8 +350,10 @@ class AttachmentsPreviewPresenterTest { assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) initialState.textEditorState.setMarkdown(A_CAPTION) initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) - advanceUntilIdle() + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Done) sendAudioResult.assertions().isCalledOnce().with( any(), any(), @@ -243,8 +381,9 @@ class AttachmentsPreviewPresenterTest { val initialState = awaitItem() assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) - val loadingState = awaitItem() - assertThat(loadingState.sendActionState).isEqualTo(SendActionState.Sending.Processing) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) val failureState = awaitItem() assertThat(failureState.sendActionState).isEqualTo(SendActionState.Failure(failure)) sendFileResult.assertions().isCalledOnce() @@ -263,6 +402,8 @@ class AttachmentsPreviewPresenterTest { val initialState = awaitItem() assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle) initialState.eventSink(AttachmentsPreviewEvents.SendAttachment) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) + assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing) initialState.eventSink(AttachmentsPreviewEvents.ClearSendState) assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Idle) @@ -277,7 +418,8 @@ class AttachmentsPreviewPresenterTest { permalinkBuilder: PermalinkBuilder = FakePermalinkBuilder(), mediaPreProcessor: MediaPreProcessor = FakeMediaPreProcessor(), temporaryUriDeleter: TemporaryUriDeleter = FakeTemporaryUriDeleter(), - onDoneListener: OnDoneListener = OnDoneListener {}, + onDoneListener: OnDoneListener = OnDoneListener { lambdaError() }, + mediaUploadOnSendQueueEnabled: Boolean = true, ): AttachmentsPreviewPresenter { return AttachmentsPreviewPresenter( attachment = aMediaAttachment(localMedia), @@ -285,6 +427,9 @@ class AttachmentsPreviewPresenterTest { mediaSender = MediaSender(mediaPreProcessor, room, InMemorySessionPreferencesStore()), permalinkBuilder = permalinkBuilder, temporaryUriDeleter = temporaryUriDeleter, + featureFlagsService = FakeFeatureFlagService( + initialState = mapOf(FeatureFlags.MediaUploadOnSendQueue.key to mediaUploadOnSendQueueEnabled), + ) ) } } diff --git a/libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaSender.kt b/libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaSender.kt index 77e6d021d5..b9618d86dd 100644 --- a/libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaSender.kt +++ b/libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaSender.kt @@ -27,6 +27,35 @@ class MediaSender @Inject constructor( private val ongoingUploadJobs = ConcurrentHashMap() val hasOngoingMediaUploads get() = ongoingUploadJobs.isNotEmpty() + suspend fun preProcessMedia( + uri: Uri, + mimeType: String, + ): Result { + val compressIfPossible = sessionPreferencesStore.doesCompressMedia().first() + return preProcessor + .process( + uri = uri, + mimeType = mimeType, + deleteOriginal = false, + compressIfPossible = compressIfPossible, + ) + } + + suspend fun sendPreProcessedMedia( + mediaUploadInfo: MediaUploadInfo, + caption: String?, + formattedCaption: String?, + progressCallback: ProgressCallback?, + ): Result { + return room.sendMedia( + uploadInfo = mediaUploadInfo, + progressCallback = progressCallback, + caption = caption, + formattedCaption = formattedCaption + ) + .handleSendResult() + } + suspend fun sendMedia( uri: Uri, mimeType: String, diff --git a/libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaUploadInfo.kt b/libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaUploadInfo.kt index 279acd1719..dfc36a40f5 100644 --- a/libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaUploadInfo.kt +++ b/libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaUploadInfo.kt @@ -22,3 +22,11 @@ sealed interface MediaUploadInfo { data class VoiceMessage(override val file: File, val audioInfo: AudioInfo, val waveform: List) : MediaUploadInfo data class AnyFile(override val file: File, val fileInfo: FileInfo) : MediaUploadInfo } + +fun MediaUploadInfo.allFiles(): List { + return listOfNotNull( + file, + (this@allFiles as? MediaUploadInfo.Image)?.thumbnailFile, + (this@allFiles as? MediaUploadInfo.Video)?.thumbnailFile, + ) +} diff --git a/libraries/mediaupload/test/src/main/kotlin/io/element/android/libraries/mediaupload/test/FakeMediaPreProcessor.kt b/libraries/mediaupload/test/src/main/kotlin/io/element/android/libraries/mediaupload/test/FakeMediaPreProcessor.kt index efb3b77ed8..3ec4efcfaa 100644 --- a/libraries/mediaupload/test/src/main/kotlin/io/element/android/libraries/mediaupload/test/FakeMediaPreProcessor.kt +++ b/libraries/mediaupload/test/src/main/kotlin/io/element/android/libraries/mediaupload/test/FakeMediaPreProcessor.kt @@ -16,10 +16,13 @@ import io.element.android.libraries.matrix.api.media.VideoInfo import io.element.android.libraries.mediaupload.api.MediaPreProcessor import io.element.android.libraries.mediaupload.api.MediaUploadInfo import io.element.android.tests.testutils.simulateLongTask +import kotlinx.coroutines.CompletableDeferred import java.io.File import kotlin.time.Duration.Companion.seconds -class FakeMediaPreProcessor : MediaPreProcessor { +class FakeMediaPreProcessor( + private val processLatch: CompletableDeferred? = null, +) : MediaPreProcessor { var processCallCount = 0 private set @@ -41,6 +44,7 @@ class FakeMediaPreProcessor : MediaPreProcessor { deleteOriginal: Boolean, compressIfPossible: Boolean ): Result = simulateLongTask { + processLatch?.await() processCallCount++ result } diff --git a/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_4_en.png b/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_4_en.png index e799726c52..8510d977be 100644 --- a/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_4_en.png +++ b/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_4_en.png @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:361ff23fd2ff99aecfdffd10b45e9235d86183d4856cb2a3e99f85b9e04c2d59 -size 51376 +oid sha256:3a92cb782d97553f364fab3df3fe159557a26aad8b7e5c176b40616c2f05abdd +size 51410 diff --git a/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_5_en.png b/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_5_en.png index df965394aa..e799726c52 100644 --- a/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_5_en.png +++ b/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_5_en.png @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:efbfed755b29293009f45fca33f58863b612772de9a1d55593c979dbb04ff6f2 -size 88981 +oid sha256:361ff23fd2ff99aecfdffd10b45e9235d86183d4856cb2a3e99f85b9e04c2d59 +size 51376 diff --git a/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_6_en.png b/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_6_en.png new file mode 100644 index 0000000000..df965394aa --- /dev/null +++ b/tests/uitests/src/test/snapshots/images/features.messages.impl.attachments.preview_AttachmentsView_6_en.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:efbfed755b29293009f45fca33f58863b612772de9a1d55593c979dbb04ff6f2 +size 88981