Add media file limit size warning and media quality selection (#5131)

* Add `VideoCompressorPreset` enum

This represents the different compression presets used for processing videos before uploading them

* Add `VideoCompressorHelper` util class to calculate the scaled output size of the video given an input size and its optimal bitrate

Also add `MediaOptimizationConfig` which will be used to decide how to apply compression in `MediaPreProcessor`

* Add `RustMatrixClient.getMaxFileUploadSize()` function and `MaxUploadSizeProvider` so we can import only this functionality into other components

* Try preloading the max file upload size the first time we get network connectivity - it's a best effort

This should help ensure we'll have this value available later, even if we still need to load it asynchronously.

* Split the `compressMedia` preference into `compressImages` and `compressMediaPreset`

* Modify the media processing parts to use the new classes and utils

* Add `MediaOptimizationSelectorPresenter`, which will retrieve the compression values and the max file upload size, also estimating the compressed video file sizes if needed.

* Add a feature flag to allow selecting the media upload quality per upload

* Integrate the previous changes with the attachments preview screen

Add strings from localazy too.

* Adapt the rest of the app calls to upload media to using the media optimization configs

* Allow modifying the default compression values in advanced settings, based on the feature flag value

* Pass the `fileSize` in `MediaUploadInfo` too, to be able to check it against the `maxUploadSize`

* Update screenshots

---------

Co-authored-by: ElementBot <[email protected]>

Author: jmartinesp

appnav/src/main/kotlin/io/element/android/appnav/LoggedInFlowNode.kt

@@ -52,6 +52,8 @@ import io.element.android.features.ftue.api.state.FtueService
 import io.element.android.features.ftue.api.state.FtueState
 import io.element.android.features.home.api.HomeEntryPoint
 import io.element.android.features.logout.api.LogoutEntryPoint
+import io.element.android.features.networkmonitor.api.NetworkMonitor
+import io.element.android.features.networkmonitor.api.NetworkStatus
 import io.element.android.features.preferences.api.PreferencesEntryPoint
 import io.element.android.features.roomdirectory.api.RoomDescription
 import io.element.android.features.roomdirectory.api.RoomDirectoryEntryPoint
@@ -125,6 +127,7 @@ class LoggedInFlowNode @AssistedInject constructor(
     private val logoutEntryPoint: LogoutEntryPoint,
     private val incomingVerificationEntryPoint: IncomingVerificationEntryPoint,
     private val mediaPreviewConfigMigration: MediaPreviewConfigMigration,
+    private val networkMonitor: NetworkMonitor,
     snackbarDispatcher: SnackbarDispatcher,
 ) : BaseFlowNode<LoggedInFlowNode.NavTarget>(
     backstack = BackStack(
@@ -192,6 +195,12 @@ class LoggedInFlowNode @AssistedInject constructor(
                 matrixClient.sessionVerificationService().setListener(verificationListener)
                 mediaPreviewConfigMigration()
 
+                sessionCoroutineScope.launch {
+                    // Wait for the network to be connected before pre-fetching the max file upload size
+                    networkMonitor.connectivity.first { networkStatus -> networkStatus == NetworkStatus.Connected }
+                    matrixClient.getMaxFileUploadSize()
+                }
+
                 ftueService.state
                     .onEach { ftueState ->
                         when (ftueState) {

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenter.kt

@@ -37,6 +37,7 @@ import io.element.android.libraries.matrix.ui.media.AvatarAction
 import io.element.android.libraries.matrix.ui.room.address.RoomAddressValidity
 import io.element.android.libraries.matrix.ui.room.address.RoomAddressValidityEffect
 import io.element.android.libraries.mediapickers.api.PickerProvider
+import io.element.android.libraries.mediaupload.api.MediaOptimizationConfigProvider
 import io.element.android.libraries.mediaupload.api.MediaPreProcessor
 import io.element.android.libraries.permissions.api.PermissionsEvents
 import io.element.android.libraries.permissions.api.PermissionsPresenter
@@ -57,6 +58,7 @@ class ConfigureRoomPresenter @Inject constructor(
     permissionsPresenterFactory: PermissionsPresenter.Factory,
     private val featureFlagService: FeatureFlagService,
     private val roomAliasHelper: RoomAliasHelper,
+    private val mediaOptimizationConfigProvider: MediaOptimizationConfigProvider,
 ) : Presenter<ConfigureRoomState> {
     private val cameraPermissionPresenter: PermissionsPresenter = permissionsPresenterFactory.create(android.Manifest.permission.CAMERA)
     private var pendingPermissionRequest = false
@@ -201,7 +203,7 @@ class ConfigureRoomPresenter @Inject constructor(
             uri = avatarUri,
             mimeType = MimeTypes.Jpeg,
             deleteOriginal = false,
-            compressIfPossible = false,
+            mediaOptimizationConfig = mediaOptimizationConfigProvider.get(),
         ).getOrThrow()
         val byteArray = preprocessed.file.readBytes()
         return matrixClient.uploadMedia(MimeTypes.Jpeg, byteArray, null).getOrThrow()

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureBaseRoomPresenterTest.kt

@@ -35,6 +35,7 @@ import io.element.android.libraries.mediapickers.api.PickerProvider
 import io.element.android.libraries.mediapickers.test.FakePickerProvider
 import io.element.android.libraries.mediaupload.api.MediaPreProcessor
 import io.element.android.libraries.mediaupload.api.MediaUploadInfo
+import io.element.android.libraries.mediaupload.test.FakeMediaOptimizationConfigProvider
 import io.element.android.libraries.mediaupload.test.FakeMediaPreProcessor
 import io.element.android.libraries.permissions.api.PermissionsPresenter
 import io.element.android.libraries.permissions.test.FakePermissionsPresenter
@@ -411,6 +412,7 @@ class ConfigureBaseRoomPresenterTest {
         analyticsService: AnalyticsService = FakeAnalyticsService(),
         permissionsPresenter: PermissionsPresenter = FakePermissionsPresenter(),
         isKnockFeatureEnabled: Boolean = true,
+        mediaOptimizationConfigProvider: FakeMediaOptimizationConfigProvider = FakeMediaOptimizationConfigProvider(),
     ) = ConfigureRoomPresenter(
         dataStore = createRoomDataStore,
         matrixClient = matrixClient,
@@ -421,6 +423,7 @@ class ConfigureBaseRoomPresenterTest {
         roomAliasHelper = roomAliasHelper,
         featureFlagService = FakeFeatureFlagService(
             mapOf(FeatureFlags.Knock.key to isKnockFeatureEnabled)
-        )
+        ),
+        mediaOptimizationConfigProvider = mediaOptimizationConfigProvider,
     )
 }

features/messages/api/build.gradle.kts

@@ -17,5 +17,7 @@ android {
 dependencies {
     implementation(projects.libraries.architecture)
     implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.mediaviewer.api)
+    implementation(projects.libraries.preferences.api)
     api(projects.libraries.textcomposer.impl)
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesFlowNode.kt

@@ -462,6 +462,7 @@ class MessagesFlowNode @AssistedInject constructor(
             eventId = event.eventId,
             mediaInfo = MediaInfo(
                 filename = content.filename,
+                fileSize = content.fileSize,
                 caption = content.caption,
                 mimeType = content.mimeType,
                 formattedFileSize = content.formattedFileSize,

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewPresenter.kt

@@ -22,21 +22,26 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.element.android.features.messages.impl.attachments.Attachment
+import io.element.android.features.messages.impl.attachments.video.MediaOptimizationSelectorPresenter
 import io.element.android.libraries.androidutils.file.TemporaryUriDeleter
 import io.element.android.libraries.androidutils.file.safeDelete
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.core.coroutine.firstInstanceOf
 import io.element.android.libraries.core.extensions.runCatchingExceptions
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeImage
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeVideo
 import io.element.android.libraries.di.annotations.SessionCoroutineScope
 import io.element.android.libraries.featureflag.api.FeatureFlagService
 import io.element.android.libraries.featureflag.api.FeatureFlags
 import io.element.android.libraries.matrix.api.core.EventId
 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.MediaOptimizationConfig
 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.preferences.api.store.VideoCompressionPreset
 import io.element.android.libraries.textcomposer.model.TextEditorState
 import io.element.android.libraries.textcomposer.model.rememberMarkdownTextEditorState
 import kotlinx.coroutines.CancellationException
@@ -54,6 +59,7 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(
     private val permalinkBuilder: PermalinkBuilder,
     private val temporaryUriDeleter: TemporaryUriDeleter,
     private val featureFlagService: FeatureFlagService,
+    private val mediaOptimizationSelectorPresenterFactory: MediaOptimizationSelectorPresenter.Factory,
     @SessionCoroutineScope private val sessionCoroutineScope: CoroutineScope,
     private val dispatchers: CoroutineDispatchers,
 ) : Presenter<AttachmentsPreviewState> {
@@ -89,21 +95,80 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(
 
         var useSendQueue by remember { mutableStateOf(false) }
         var preprocessMediaJob by remember { mutableStateOf<Job?>(null) }
+
+        val mediaAttachment = attachment as Attachment.Media
+        val mediaOptimizationSelectorPresenter = remember {
+            mediaOptimizationSelectorPresenterFactory.create(mediaAttachment.localMedia)
+        }
+        val mediaOptimizationSelectorState = mediaOptimizationSelectorPresenter.present()
+
+        val observableSendState = snapshotFlow { sendActionState.value }
+
+        var displayFileTooLargeError by remember { mutableStateOf(false) }
+
         LaunchedEffect(Unit) {
             useSendQueue = featureFlagService.isFeatureEnabled(FeatureFlags.MediaUploadOnSendQueue)
+        }
 
-            preprocessMediaJob = preProcessAttachment(
-                attachment,
-                sendActionState
-            )
+        LaunchedEffect(mediaOptimizationSelectorState.displayMediaSelectorViews) {
+            // If the media optimization selector is not displayed, we can pre-process the media
+            // to prepare it for sending. This is done to avoid blocking the UI thread when the
+            // user clicks on the send button.
+            if (mediaOptimizationSelectorState.displayMediaSelectorViews == false) {
+                val mediaOptimizationConfig = MediaOptimizationConfig(
+                    compressImages = mediaOptimizationSelectorState.isImageOptimizationEnabled == true,
+                    videoCompressionPreset = mediaOptimizationSelectorState.selectedVideoPreset ?: VideoCompressionPreset.STANDARD,
+                )
+                preprocessMediaJob = preProcessAttachment(
+                    attachment = attachment,
+                    mediaOptimizationConfig = mediaOptimizationConfig,
+                    displayProgress = false,
+                    sendActionState = sendActionState,
+                )
+            }
         }
 
-        val observableSendState = snapshotFlow { sendActionState.value }
+        val maxUploadSize = mediaOptimizationSelectorState.maxUploadSize.dataOrNull()
+        LaunchedEffect(maxUploadSize) {
+            // Check file upload size if the media won't be processed for upload
+            val isImageFile = mediaAttachment.localMedia.info.mimeType.isMimeTypeImage()
+            val isVideoFile = mediaAttachment.localMedia.info.mimeType.isMimeTypeVideo()
+            if (maxUploadSize != null && !(isImageFile || isVideoFile)) {
+                // If file size is not known, we're permissive and allow sending. The SDK will cancel the upload if needed.
+                val fileSize = mediaAttachment.localMedia.info.fileSize ?: 0L
+                if (maxUploadSize < fileSize) {
+                    displayFileTooLargeError = true
+                }
+            }
+        }
+
+        val videoSizeEstimations = mediaOptimizationSelectorState.videoSizeEstimations.dataOrNull()
+        LaunchedEffect(videoSizeEstimations) {
+            if (videoSizeEstimations != null) {
+                // Check if the video size estimations are too large for the max upload size
+                displayFileTooLargeError = videoSizeEstimations.none { it.canUpload }
+            }
+        }
 
         fun handleEvents(attachmentsPreviewEvents: AttachmentsPreviewEvents) {
             when (attachmentsPreviewEvents) {
                 is AttachmentsPreviewEvents.SendAttachment -> {
                     ongoingSendAttachmentJob.value = coroutineScope.launch {
+                        // If the media optimization selector is displayed, we need to wait for the user to select the options
+                        // before we can pre-process the media.
+                        if (mediaOptimizationSelectorState.displayMediaSelectorViews == true) {
+                            val config = MediaOptimizationConfig(
+                                compressImages = mediaOptimizationSelectorState.isImageOptimizationEnabled == true,
+                                videoCompressionPreset = mediaOptimizationSelectorState.selectedVideoPreset ?: VideoCompressionPreset.STANDARD,
+                            )
+                            preprocessMediaJob = preProcessAttachment(
+                                attachment = attachment,
+                                mediaOptimizationConfig = config,
+                                displayProgress = true,
+                                sendActionState = sendActionState,
+                            )
+                        }
+
                         // If the processing was hidden before, make it visible now
                         if (sendActionState.value is SendActionState.Sending.Processing) {
                             sendActionState.value = SendActionState.Sending.Processing(displayProgress = true)
@@ -138,6 +203,8 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(
                     }
                 }
                 AttachmentsPreviewEvents.CancelAndDismiss -> {
+                    displayFileTooLargeError = false
+
                     // Cancel media preprocessing and sending
                     preprocessMediaJob?.cancel()
                     // If we couldn't send the pre-processed media, remove it
@@ -173,18 +240,24 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(
             textEditorState = textEditorState,
             allowCaption = allowCaption,
             showCaptionCompatibilityWarning = showCaptionCompatibilityWarning,
+            mediaOptimizationSelectorState = mediaOptimizationSelectorState,
+            displayFileTooLargeError = displayFileTooLargeError,
             eventSink = ::handleEvents
         )
     }
 
     private fun CoroutineScope.preProcessAttachment(
         attachment: Attachment,
+        mediaOptimizationConfig: MediaOptimizationConfig,
+        displayProgress: Boolean,
         sendActionState: MutableState<SendActionState>,
     ) = launch(dispatchers.io) {
         when (attachment) {
             is Attachment.Media -> {
                 preProcessMedia(
                     mediaAttachment = attachment,
+                    mediaOptimizationConfig = mediaOptimizationConfig,
+                    displayProgress = displayProgress,
                     sendActionState = sendActionState,
                 )
             }
@@ -193,12 +266,15 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(
 
     private suspend fun preProcessMedia(
         mediaAttachment: Attachment.Media,
+        mediaOptimizationConfig: MediaOptimizationConfig,
+        displayProgress: Boolean,
         sendActionState: MutableState<SendActionState>,
     ) {
-        sendActionState.value = SendActionState.Sending.Processing(displayProgress = false)
+        sendActionState.value = SendActionState.Sending.Processing(displayProgress = displayProgress)
         mediaSender.preProcessMedia(
             uri = mediaAttachment.localMedia.uri,
             mimeType = mediaAttachment.localMedia.info.mimeType,
+            mediaOptimizationConfig = mediaOptimizationConfig,
         ).fold(
             onSuccess = { mediaUploadInfo ->
                 sendActionState.value = SendActionState.Sending.ReadyToUpload(mediaUploadInfo)

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewState.kt

@@ -9,6 +9,7 @@ package io.element.android.features.messages.impl.attachments.preview
 
 import androidx.compose.runtime.Immutable
 import io.element.android.features.messages.impl.attachments.Attachment
+import io.element.android.features.messages.impl.attachments.video.MediaOptimizationSelectorState
 import io.element.android.libraries.mediaupload.api.MediaUploadInfo
 import io.element.android.libraries.textcomposer.model.TextEditorState
 
@@ -18,6 +19,8 @@ data class AttachmentsPreviewState(
     val textEditorState: TextEditorState,
     val allowCaption: Boolean,
     val showCaptionCompatibilityWarning: Boolean,
+    val mediaOptimizationSelectorState: MediaOptimizationSelectorState,
+    val displayFileTooLargeError: Boolean,
     val eventSink: (AttachmentsPreviewEvents) -> Unit
 )