Merge pull request #551 from vector-im/feature/fga/media_viewer_actions

Feature/fga/media viewer actions

app/src/main/AndroidManifest.xml

@@ -17,6 +17,9 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
+    <!-- To be able to install APK from the application -->
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
+
     <application
         android:name=".ElementXApplication"
         android:allowBackup="true"

build.gradle.kts

@@ -246,6 +246,7 @@ koverMerged {
                 excludes += "io.element.android.libraries.matrix.api.room.MatrixRoomMembersState*"
                 excludes += "io.element.android.libraries.push.impl.notifications.NotificationState*"
                 excludes += "io.element.android.features.messages.impl.media.local.pdf.PdfViewerState"
+                excludes += "io.element.android.features.messages.impl.media.local.LocalMediaViewState"
             }
             bound {
                 minValue = 90

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

@@ -32,6 +32,7 @@ import io.element.android.anvilannotations.ContributesNode
 import io.element.android.features.messages.api.MessagesEntryPoint
 import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.attachments.preview.AttachmentsPreviewNode
+import io.element.android.features.messages.impl.media.local.MediaInfo
 import io.element.android.features.messages.impl.media.viewer.MediaViewerNode
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemFileContent
@@ -64,10 +65,9 @@ class MessagesFlowNode @AssistedInject constructor(
 
         @Parcelize
         data class MediaViewer(
-            val title: String,
+            val mediaInfo: MediaInfo,
             val mediaSource: MediaSource,
             val thumbnailSource: MediaSource?,
-            val mimeType: String?,
         ) : NavTarget
 
         @Parcelize
@@ -100,10 +100,9 @@ class MessagesFlowNode @AssistedInject constructor(
             }
             is NavTarget.MediaViewer -> {
                 val inputs = MediaViewerNode.Inputs(
-                    name = navTarget.title,
+                    mediaInfo = navTarget.mediaInfo,
                     mediaSource = navTarget.mediaSource,
                     thumbnailSource = navTarget.thumbnailSource,
-                    mimeType = navTarget.mimeType,
                 )
                 createNode<MediaViewerNode>(buildContext, listOf(inputs))
             }
@@ -118,30 +117,39 @@ class MessagesFlowNode @AssistedInject constructor(
         when (event.content) {
             is TimelineItemImageContent -> {
                 val navTarget = NavTarget.MediaViewer(
-                    title = event.content.body,
+                    mediaInfo = MediaInfo(
+                        name = event.content.body,
+                        mimeType = event.content.mimeType,
+                        formattedFileSize = event.content.formattedFileSize
+                    ),
                     mediaSource = event.content.mediaSource,
                     thumbnailSource = event.content.mediaSource,
-                    mimeType = event.content.mimeType
                 )
                 backstack.push(navTarget)
             }
             is TimelineItemVideoContent -> {
                 val mediaSource = event.content.videoSource
                 val navTarget = NavTarget.MediaViewer(
-                    title = event.content.body,
+                    mediaInfo = MediaInfo(
+                        name = event.content.body,
+                        mimeType = event.content.mimeType,
+                        formattedFileSize = event.content.formattedFileSize
+                    ),
                     mediaSource = mediaSource,
                     thumbnailSource = event.content.thumbnailSource,
-                    mimeType = event.content.mimeType,
                 )
                 backstack.push(navTarget)
             }
             is TimelineItemFileContent -> {
                 val mediaSource = event.content.fileSource
                 val navTarget = NavTarget.MediaViewer(
-                    title = event.content.body,
+                    mediaInfo = MediaInfo(
+                        name = event.content.body,
+                        mimeType = event.content.mimeType,
+                        formattedFileSize = event.content.formattedFileSize
+                    ),
                     mediaSource = mediaSource,
                     thumbnailSource = event.content.thumbnailSource,
-                    mimeType = event.content.mimeType,
                 )
                 backstack.push(navTarget)
             }

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

@@ -76,6 +76,7 @@ import io.element.android.libraries.designsystem.theme.components.Scaffold
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.components.TopAppBar
 import io.element.android.libraries.designsystem.utils.LogCompositions
+import io.element.android.libraries.designsystem.utils.rememberSnackbarHostState
 import io.element.android.libraries.matrix.api.core.UserId
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.coroutines.launch
@@ -94,23 +95,11 @@ fun MessagesView(
     modifier: Modifier = Modifier,
 ) {
     LogCompositions(tag = "MessagesScreen", msg = "Root")
-    val coroutineScope = rememberCoroutineScope()
     var isMessageActionsBottomSheetVisible by rememberSaveable { mutableStateOf(false) }
 
     AttachmentStateView(state.composerState.attachmentsState, onPreviewAttachments)
 
-    val snackbarHostState = remember { SnackbarHostState() }
-    val snackbarMessageText = state.snackbarMessage?.let { stringResource(it.messageResId) }
-    if (snackbarMessageText != null) {
-        SideEffect {
-            coroutineScope.launch {
-                snackbarHostState.showSnackbar(
-                    message = snackbarMessageText,
-                    duration = state.snackbarMessage.duration
-                )
-            }
-        }
-    }
+    val snackbarHostState = rememberSnackbarHostState(snackbarMessage = state.snackbarMessage)
 
     // This is needed because the composer is inside an AndroidView that can't be affected by the FocusManager in Compose
     val localView = LocalView.current

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

@@ -84,7 +84,7 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(
         sendActionState: MutableState<Async<Unit>>,
     ) {
         suspend {
-            mediaSender.sendMedia(mediaAttachment.localMedia.uri, mediaAttachment.localMedia.mimeType, mediaAttachment.compressIfPossible)
+            mediaSender.sendMedia(mediaAttachment.localMedia.uri, mediaAttachment.localMedia.info.mimeType, mediaAttachment.compressIfPossible)
         }.executeResult(sendActionState)
     }
 }

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

@@ -20,21 +20,27 @@ import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import androidx.core.net.toUri
 import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.media.local.LocalMedia
+import io.element.android.features.messages.impl.media.local.MediaInfo
+import io.element.android.features.messages.impl.media.local.aFileInfo
+import io.element.android.features.messages.impl.media.local.aVideoInfo
+import io.element.android.features.messages.impl.media.local.anImageInfo
 import io.element.android.libraries.architecture.Async
-import io.element.android.libraries.core.mimetype.MimeTypes
 
 open class AttachmentsPreviewStateProvider : PreviewParameterProvider<AttachmentsPreviewState> {
     override val values: Sequence<AttachmentsPreviewState>
         get() = sequenceOf(
             anAttachmentsPreviewState(),
+            anAttachmentsPreviewState(mediaInfo = aFileInfo()),
             anAttachmentsPreviewState(sendActionState = Async.Loading()),
             anAttachmentsPreviewState(sendActionState = Async.Failure(RuntimeException())),
         )
 }
 
-fun anAttachmentsPreviewState(sendActionState: Async<Unit> = Async.Uninitialized) = AttachmentsPreviewState(
+fun anAttachmentsPreviewState(
+    mediaInfo: MediaInfo = anImageInfo(),
+    sendActionState: Async<Unit> = Async.Uninitialized) = AttachmentsPreviewState(
     attachment = Attachment.Media(
-        localMedia = LocalMedia("path".toUri(), MimeTypes.Jpeg, "an image", 1000L),
+        localMedia = LocalMedia("file://path".toUri(), mediaInfo),
         compressIfPossible = true
     ),
     sendActionState = sendActionState,

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

@@ -121,7 +121,8 @@ private fun AttachmentPreviewContent(
         Box(
             modifier = Modifier
                 .fillMaxWidth()
-                .weight(1f)
+                .weight(1f),
+            contentAlignment = Alignment.Center,
         ) {
             when (attachment) {
                 is Attachment.Media -> LocalMediaView(

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/helper/fileExtensionAndSize.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.helper
+
+import android.webkit.MimeTypeMap
+
+fun formatFileExtensionAndSize(name: String, size: String?): String {
+    val fileExtension = name.substringAfterLast('.', "")
+    // Makes sure the extension is known by the system, otherwise default to binary extension.
+    val safeExtension = if (MimeTypeMap.getSingleton().hasExtension(fileExtension)) {
+        fileExtension.uppercase()
+    } else {
+        "BIN"
+    }
+    return buildString {
+        append(safeExtension)
+        if (size != null) {
+            append(' ')
+            append("($size)")
+        }
+    }
+}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/AndroidLocalMediaActions.kt

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local
+
+import android.content.ContentResolver
+import android.content.ContentValues
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import androidx.annotation.RequiresApi
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.ui.platform.LocalContext
+import androidx.core.content.FileProvider
+import androidx.core.net.toFile
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.core.meta.BuildMeta
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.ApplicationContext
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class AndroidLocalMediaActions @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val coroutineDispatchers: CoroutineDispatchers,
+    private val buildMeta: BuildMeta,
+) : LocalMediaActions {
+
+    private var activityContext: Context? = null
+
+    @Composable
+    override fun Configure() {
+        val context = LocalContext.current
+        return DisposableEffect(Unit) {
+            activityContext = context
+            onDispose {
+                activityContext = null
+            }
+        }
+    }
+
+    override suspend fun saveOnDisk(localMedia: LocalMedia): Result<Unit> = withContext(coroutineDispatchers.io) {
+        require(localMedia.uri.scheme == ContentResolver.SCHEME_FILE)
+        runCatching {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                saveOnDiskUsingMediaStore(localMedia)
+            } else {
+                saveOnDiskUsingExternalStorageApi(localMedia)
+            }
+        }.onSuccess {
+            Timber.v("Save on disk succeed")
+        }.onFailure {
+            Timber.e(it, "Save on disk failed")
+        }
+    }
+
+    override suspend fun share(localMedia: LocalMedia): Result<Unit> = withContext(coroutineDispatchers.io) {
+        require(localMedia.uri.scheme == ContentResolver.SCHEME_FILE)
+        runCatching {
+            val shareableUri = localMedia.toShareableUri()
+            val shareMediaIntent = Intent(Intent.ACTION_SEND)
+                .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                .putExtra(Intent.EXTRA_STREAM, shareableUri)
+                .setTypeAndNormalize(localMedia.info.mimeType)
+            withContext(coroutineDispatchers.main) {
+                val intent = Intent.createChooser(shareMediaIntent, null)
+                activityContext!!.startActivity(intent)
+            }
+        }.onSuccess {
+            Timber.v("Share media succeed")
+        }.onFailure {
+            Timber.e(it, "Share media failed")
+        }
+    }
+
+    override suspend fun open(localMedia: LocalMedia): Result<Unit> = withContext(coroutineDispatchers.io) {
+        require(localMedia.uri.scheme == ContentResolver.SCHEME_FILE)
+        runCatching {
+            val openMediaIntent = Intent(Intent.ACTION_VIEW)
+                .setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                .setDataAndType(localMedia.toShareableUri(), localMedia.info.mimeType)
+            withContext(coroutineDispatchers.main) {
+                activityContext!!.startActivity(openMediaIntent)
+            }
+        }.onSuccess {
+            Timber.v("Open media succeed")
+        }.onFailure {
+            Timber.e(it, "Open media failed")
+        }
+    }
+
+    private fun LocalMedia.toShareableUri(): Uri {
+        val mediaAsFile = this.toFile()
+        val authority = "${buildMeta.applicationId}.fileprovider"
+        return FileProvider.getUriForFile(context, authority, mediaAsFile).normalizeScheme()
+    }
+
+    @RequiresApi(Build.VERSION_CODES.Q)
+    private fun saveOnDiskUsingMediaStore(localMedia: LocalMedia) {
+        val contentValues = ContentValues().apply {
+            put(MediaStore.MediaColumns.DISPLAY_NAME, localMedia.info.name)
+            put(MediaStore.MediaColumns.MIME_TYPE, localMedia.info.mimeType)
+            put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
+        }
+        val resolver = context.contentResolver
+        val outputUri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, contentValues)
+        if (outputUri != null) {
+            localMedia.openStream()?.use { input ->
+                resolver.openOutputStream(outputUri).use { output ->
+                    input.copyTo(output!!, DEFAULT_BUFFER_SIZE)
+                }
+            }
+        }
+    }
+
+    private fun saveOnDiskUsingExternalStorageApi(localMedia: LocalMedia) {
+        val target = File(
+            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
+            localMedia.info.name
+        )
+        localMedia.openStream()?.use { input ->
+            FileOutputStream(target).use { output ->
+                input.copyTo(output)
+            }
+        }
+    }
+
+    private fun LocalMedia.openStream(): InputStream? {
+        return context.contentResolver.openInputStream(uri)
+    }
+
+    /**
+     * Tries to extract a file from the uri.
+     */
+    private fun LocalMedia.toFile(): File {
+        return uri.toFile()
+    }
+}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/AndroidLocalMediaFactory.kt

@@ -20,33 +20,50 @@ import android.content.Context
 import android.net.Uri
 import androidx.core.net.toUri
 import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.messages.impl.timeline.util.FileSizeFormatter
 import io.element.android.libraries.androidutils.file.getFileName
 import io.element.android.libraries.androidutils.file.getFileSize
+import io.element.android.libraries.androidutils.file.getMimeType
 import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.di.ApplicationContext
 import io.element.android.libraries.matrix.api.media.MediaFile
+import io.element.android.libraries.matrix.api.media.toFile
 import javax.inject.Inject
 
 @ContributesBinding(AppScope::class)
 class AndroidLocalMediaFactory @Inject constructor(
-    @ApplicationContext private val context: Context
+    @ApplicationContext private val context: Context,
+    private val fileSizeFormatter: FileSizeFormatter,
 ) : LocalMediaFactory {
 
-    override fun createFromMediaFile(mediaFile: MediaFile, mimeType: String?): LocalMedia {
-        val uri = mediaFile.path().toUri()
-        return createFromUri(uri, mimeType)
+    override fun createFromMediaFile(mediaFile: MediaFile, mediaInfo: MediaInfo): LocalMedia {
+        val uri = mediaFile.toFile().toUri()
+        return createFromUri(
+            uri = uri,
+            mimeType = mediaInfo.mimeType,
+            name = mediaInfo.name,
+            formattedFileSize = mediaInfo.formattedFileSize
+        )
     }
 
-    override fun createFromUri(uri: Uri, mimeType: String?): LocalMedia {
-        val resolvedMimeType = mimeType ?: context.contentResolver.getType(uri) ?: MimeTypes.OctetStream
-        val fileName = context.getFileName(uri)
-        val fileSize = context.getFileSize(uri)
+    override fun createFromUri(
+        uri: Uri,
+        mimeType: String?,
+        name: String?,
+        formattedFileSize: String?
+    ): LocalMedia {
+        val resolvedMimeType = mimeType ?: context.getMimeType(uri) ?: MimeTypes.OctetStream
+        val fileName = name ?: context.getFileName(uri) ?: ""
+        val fileSize = formattedFileSize ?: fileSizeFormatter.format(context.getFileSize(uri))
         return LocalMedia(
             uri = uri,
-            mimeType = resolvedMimeType,
-            name = fileName,
-            size = fileSize
+            info = MediaInfo(
+                mimeType = resolvedMimeType,
+                name = fileName,
+                formattedFileSize = fileSize
+            )
         )
     }
 }
+

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/LocalMedia.kt

@@ -19,22 +19,11 @@ package io.element.android.features.messages.impl.media.local
 import android.net.Uri
 import android.os.Parcelable
 import androidx.compose.runtime.Immutable
-import kotlinx.parcelize.IgnoredOnParcel
 import kotlinx.parcelize.Parcelize
 
 @Parcelize
 @Immutable
 data class LocalMedia(
     val uri: Uri,
-    val mimeType: String,
-    val name: String?,
-    val size: Long,
-) : Parcelable {
-
-    /**
-     * This tries to convert the uri to a file if applicable, otherwise keep it as uri.
-     */
-    @IgnoredOnParcel val model: Any by lazy {
-        UriToFileMapper.map(uri) ?: uri
-    }
-}
+    val info: MediaInfo,
+) : Parcelable

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/LocalMediaActions.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local
+
+import androidx.compose.runtime.Composable
+
+interface LocalMediaActions {
+
+    @Composable
+    fun Configure()
+
+    /**
+     * Will save the current media to the Downloads directory.
+     * The [LocalMedia.uri] needs to have a file scheme.
+     */
+    suspend fun saveOnDisk(localMedia: LocalMedia): Result<Unit>
+
+    /**
+     * Will try to find a suitable application to share the media with.
+     * The [LocalMedia.uri] needs to have a file scheme.
+     */
+    suspend fun share(localMedia: LocalMedia): Result<Unit>
+
+    /**
+     * Will try to find a suitable application to open the media with.
+     * The [LocalMedia.uri] needs to have a file scheme.
+     */
+    suspend fun open(localMedia: LocalMedia): Result<Unit>
+}
+

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/LocalMediaFactory.kt

@@ -22,13 +22,21 @@ import io.element.android.libraries.matrix.api.media.MediaFile
 interface LocalMediaFactory {
 
     /**
-     * This method will create a [LocalMedia] with the given [MediaFile] and [mimeType].
+     * This method will create a [LocalMedia] with the given [MediaFile] and [MediaInfo].
      */
-    fun createFromMediaFile(mediaFile: MediaFile, mimeType: String?): LocalMedia
+    fun createFromMediaFile(
+        mediaFile: MediaFile,
+        mediaInfo: MediaInfo,
+    ): LocalMedia
 
     /**
-     * This method will create a [LocalMedia] with the given [uri] and [mimeType]
-     * If the [mimeType] is null, it'll try to read it from the content.
+     * This method will create a [LocalMedia] with the given mimeType, name and formattedFileSize
+     * If any of those params are null, it'll try to read them from the content.
      */
-    fun createFromUri(uri: Uri, mimeType: String?): LocalMedia
+    fun createFromUri(
+        uri: Uri,
+        mimeType: String?,
+        name: String?,
+        formattedFileSize: String?
+    ): LocalMedia
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/LocalMediaView.kt

@@ -17,18 +17,37 @@
 package io.element.android.features.messages.impl.media.local
 
 import android.annotation.SuppressLint
+import android.net.Uri
 import android.view.ViewGroup.LayoutParams.MATCH_PARENT
 import android.widget.FrameLayout
 import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Attachment
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalInspectionMode
 import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.lifecycle.Lifecycle
 import androidx.media3.common.MediaItem
@@ -36,6 +55,7 @@ import androidx.media3.common.Player
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.ui.AspectRatioFrameLayout
 import androidx.media3.ui.PlayerView
+import io.element.android.features.messages.impl.media.helper.formatFileExtensionAndSize
 import io.element.android.features.messages.impl.media.local.exoplayer.ExoPlayerWrapper
 import io.element.android.features.messages.impl.media.local.pdf.PdfViewer
 import io.element.android.features.messages.impl.media.local.pdf.rememberPdfViewerState
@@ -43,6 +63,9 @@ import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeImage
 import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeVideo
 import io.element.android.libraries.designsystem.R
+import io.element.android.libraries.designsystem.theme.ElementTheme
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.utils.OnLifecycleEvent
 import me.saket.telephoto.zoomable.ZoomSpec
 import me.saket.telephoto.zoomable.ZoomableState
@@ -55,39 +78,45 @@ import me.saket.telephoto.zoomable.rememberZoomableState
 fun LocalMediaView(
     localMedia: LocalMedia?,
     modifier: Modifier = Modifier,
-    mimeType: String? = localMedia?.mimeType,
-    onReady: () -> Unit = {},
+    localMediaViewState: LocalMediaViewState = rememberLocalMediaViewState(),
+    mediaInfo: MediaInfo? = localMedia?.info,
 ) {
     val zoomableState = rememberZoomableState(
         zoomSpec = ZoomSpec(maxZoomFactor = 5f)
     )
+    val mimeType = mediaInfo?.mimeType
     when {
         mimeType.isMimeTypeImage() -> MediaImageView(
+            localMediaViewState = localMediaViewState,
             localMedia = localMedia,
             zoomableState = zoomableState,
-            onReady = onReady,
             modifier = modifier
         )
         mimeType.isMimeTypeVideo() -> MediaVideoView(
+            localMediaViewState = localMediaViewState,
             localMedia = localMedia,
-            onReady = onReady,
             modifier = modifier
         )
         mimeType == MimeTypes.Pdf -> MediaPDFView(
+            localMediaViewState = localMediaViewState,
             localMedia = localMedia,
             zoomableState = zoomableState,
-            onReady = onReady,
             modifier = modifier
         )
-        else -> Unit
+        else -> MediaFileView(
+            localMediaViewState = localMediaViewState,
+            uri = localMedia?.uri,
+            info = mediaInfo,
+            modifier = modifier
+        )
     }
 }
 
 @Composable
 private fun MediaImageView(
+    localMediaViewState: LocalMediaViewState,
     localMedia: LocalMedia?,
     zoomableState: ZoomableState,
-    onReady: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     if (LocalInspectionMode.current) {
@@ -98,15 +127,11 @@ private fun MediaImageView(
         )
     } else {
         val zoomableImageState = rememberZoomableImageState(zoomableState)
-        LaunchedEffect(zoomableImageState.isImageDisplayed) {
-            if (zoomableImageState.isImageDisplayed) {
-                onReady()
-            }
-        }
+        localMediaViewState.isReady = zoomableImageState.isImageDisplayed
         ZoomableAsyncImage(
             modifier = modifier.fillMaxSize(),
             state = zoomableImageState,
-            model = localMedia?.model,
+            model = localMedia?.uri,
             contentDescription = "Image",
             contentScale = ContentScale.Fit,
         )
@@ -116,14 +141,14 @@ private fun MediaImageView(
 @UnstableApi
 @Composable
 fun MediaVideoView(
+    localMediaViewState: LocalMediaViewState,
     localMedia: LocalMedia?,
-    onReady: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val context = LocalContext.current
     val playerListener = object : Player.Listener {
         override fun onRenderedFirstFrame() {
-            onReady()
+            localMediaViewState.isReady = true
         }
     }
     val exoPlayer = remember {
@@ -170,19 +195,64 @@ fun MediaVideoView(
 
 @Composable
 fun MediaPDFView(
+    localMediaViewState: LocalMediaViewState,
     localMedia: LocalMedia?,
     zoomableState: ZoomableState,
-    onReady: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val pdfViewerState = rememberPdfViewerState(
-        model = localMedia?.model,
+        model = localMedia?.uri,
         zoomableState = zoomableState
     )
-    LaunchedEffect(pdfViewerState.isLoaded) {
-        if (pdfViewerState.isLoaded) {
-            onReady()
-        }
-    }
+    localMediaViewState.isReady = pdfViewerState.isLoaded
     PdfViewer(pdfViewerState = pdfViewerState, modifier = modifier)
 }
+
+@Composable
+fun MediaFileView(
+    localMediaViewState: LocalMediaViewState,
+    uri: Uri?,
+    info: MediaInfo?,
+    modifier: Modifier = Modifier,
+) {
+    localMediaViewState.isReady = uri != null
+    Box(modifier = modifier.padding(horizontal = 8.dp), contentAlignment = Alignment.Center) {
+        Column(horizontalAlignment = Alignment.CenterHorizontally) {
+            Box(
+                modifier = Modifier
+                    .size(72.dp)
+                    .clip(CircleShape)
+                    .background(MaterialTheme.colorScheme.onBackground),
+                contentAlignment = Alignment.Center,
+            ) {
+                Icon(
+                    imageVector = Icons.Outlined.Attachment,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.background,
+                    modifier = Modifier
+                        .size(32.dp)
+                        .rotate(-45f),
+                )
+            }
+            if (info != null) {
+                Spacer(modifier = Modifier.height(20.dp))
+                Text(
+                    text = info.name,
+                    maxLines = 2,
+                    fontSize = 16.sp,
+                    overflow = TextOverflow.Ellipsis,
+                    textAlign = TextAlign.Center,
+                    color = ElementTheme.colors.gray1400
+                )
+                Spacer(modifier = Modifier.height(4.dp))
+                Text(
+                    text = formatFileExtensionAndSize(info.name, info.formattedFileSize),
+                    fontSize = 14.sp,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    color = ElementTheme.colors.gray1400
+                )
+            }
+        }
+    }
+}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/LocalMediaViewState.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+
+@Stable
+class LocalMediaViewState {
+    var isReady: Boolean by mutableStateOf(false)
+}
+
+@Composable
+fun rememberLocalMediaViewState(): LocalMediaViewState {
+    return remember {
+        LocalMediaViewState()
+    }
+}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/MediaInfo.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local
+
+import android.os.Parcelable
+import io.element.android.libraries.core.mimetype.MimeTypes
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+data class MediaInfo(
+    val name: String,
+    val mimeType: String,
+    val formattedFileSize: String,
+) : Parcelable
+
+fun anImageInfo(): MediaInfo = MediaInfo(
+    "an image file.jpg", MimeTypes.Jpeg, "4MB"
+)
+
+fun aVideoInfo(): MediaInfo = MediaInfo(
+    "a video file.mp4", MimeTypes.Mp4, "14MB"
+)
+
+fun aPdfInfo(): MediaInfo = MediaInfo(
+    "a pdf file.pdf", MimeTypes.Pdf, "23MB"
+)
+
+fun aFileInfo(): MediaInfo = MediaInfo(
+    "an apk file.apk", MimeTypes.Apk, "50MB"
+)

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/UriToFileMapper.kt

@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2023 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.element.android.features.messages.impl.media.local
-
-import android.content.ContentResolver
-import android.net.Uri
-import io.element.android.libraries.androidutils.uri.ASSET_FILE_PATH_ROOT
-import io.element.android.libraries.androidutils.uri.firstPathSegment
-import java.io.File
-
-/**
- * Tries to convert a URI to a File.
- * Extracted from Coil [coil.map.FileUriMapper]
- */
-object UriToFileMapper {
-
-    fun map(data: Uri): File? {
-        if (!isApplicable(data)) return null
-        return if (data.scheme == ContentResolver.SCHEME_FILE) {
-            data.path?.let(::File)
-        } else {
-            // If the scheme is not "file", it's null, representing a literal path on disk.
-            // Assume the entire input, regardless of any reserved characters, is valid.
-            File(data.toString())
-        }
-    }
-
-    private fun isApplicable(data: Uri): Boolean {
-        return !isAssetUri(data) &&
-            data.scheme.let { it == null || it == ContentResolver.SCHEME_FILE } &&
-            data.path.orEmpty().startsWith('/') && data.firstPathSegment != null
-    }
-
-    private fun isAssetUri(uri: Uri): Boolean {
-        return uri.scheme == ContentResolver.SCHEME_FILE && uri.firstPathSegment == ASSET_FILE_PATH_ROOT
-    }
-}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfRendererManager.kt

@@ -43,11 +43,11 @@ class PdfRendererManager(
             mutex.withLock {
                 withContext(Dispatchers.IO) {
                     pdfRenderer = PdfRenderer(parcelFileDescriptor).apply {
-                        (0 until pageCount).map { pageIndex ->
-                            PdfPage(width, pageIndex, mutex, this, coroutineScope)
-                        }.also {
-                            mutablePdfPages.value = it
-                        }
+                        // Preload just 3 pages so we can render faster
+                        val firstPages = loadPages(from = 0, to = 3)
+                        mutablePdfPages.value = firstPages
+                        val nextPages = loadPages(from = 3, to = pageCount)
+                        mutablePdfPages.value = firstPages + nextPages
                     }
                 }
             }
@@ -65,4 +65,10 @@ class PdfRendererManager(
             }
         }
     }
+
+    private fun PdfRenderer.loadPages(from: Int, to: Int): List<PdfPage> {
+        return (from until minOf(to, pageCount)).map { pageIndex ->
+            PdfPage(width, pageIndex, mutex, this, coroutineScope)
+        }
+    }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/viewer/MediaViewerEvents.kt

@@ -17,6 +17,9 @@
 package io.element.android.features.messages.impl.media.viewer
 
 sealed interface MediaViewerEvents {
+    object SaveOnDisk: MediaViewerEvents
+    object Share: MediaViewerEvents
+    object OpenWith: MediaViewerEvents
     object RetryLoading : MediaViewerEvents
     object ClearLoadingError : MediaViewerEvents
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/viewer/MediaViewerNode.kt

@@ -24,6 +24,7 @@ import com.bumble.appyx.core.plugin.Plugin
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.messages.impl.media.local.MediaInfo
 import io.element.android.libraries.architecture.NodeInputs
 import io.element.android.libraries.architecture.inputs
 import io.element.android.libraries.designsystem.theme.ForcedDarkElementTheme
@@ -38,10 +39,9 @@ class MediaViewerNode @AssistedInject constructor(
 ) : Node(buildContext, plugins = plugins) {
 
     data class Inputs(
-        val name: String,
+        val mediaInfo: MediaInfo,
         val mediaSource: MediaSource,
         val thumbnailSource: MediaSource?,
-        val mimeType: String?
     ) : NodeInputs
 
     private val inputs: Inputs = inputs()
@@ -54,7 +54,8 @@ class MediaViewerNode @AssistedInject constructor(
             val state = presenter.present()
             MediaViewerView(
                 state = state,
-                modifier = modifier
+                modifier = modifier,
+                onBackPressed = this::navigateUp
             )
         }
     }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/viewer/MediaViewerPresenter.kt

@@ -16,6 +16,7 @@
 
 package io.element.android.features.messages.impl.media.viewer
 
+import android.content.ActivityNotFoundException
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.MutableState
@@ -28,18 +29,26 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.element.android.features.messages.impl.media.local.LocalMedia
+import io.element.android.features.messages.impl.media.local.LocalMediaActions
 import io.element.android.features.messages.impl.media.local.LocalMediaFactory
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.designsystem.utils.SnackbarDispatcher
+import io.element.android.libraries.designsystem.utils.SnackbarMessage
+import io.element.android.libraries.designsystem.utils.handleSnackbarMessage
 import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
 import io.element.android.libraries.matrix.api.media.MediaFile
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
+import io.element.android.libraries.androidutils.R as UtilsR
+import io.element.android.libraries.ui.strings.R as StringR
 
 class MediaViewerPresenter @AssistedInject constructor(
     @Assisted private val inputs: MediaViewerNode.Inputs,
     private val localMediaFactory: LocalMediaFactory,
     private val mediaLoader: MatrixMediaLoader,
+    private val localMediaActions: LocalMediaActions,
+    private val snackbarDispatcher: SnackbarDispatcher,
 ) : Presenter<MediaViewerState> {
 
     @AssistedFactory
@@ -57,6 +66,8 @@ class MediaViewerPresenter @AssistedInject constructor(
         val localMedia: MutableState<Async<LocalMedia>> = remember {
             mutableStateOf(Async.Uninitialized)
         }
+        val snackbarMessage = handleSnackbarMessage(snackbarDispatcher)
+        localMediaActions.Configure()
         DisposableEffect(loadMediaTrigger) {
             coroutineScope.downloadMedia(mediaFile, localMedia)
             onDispose {
@@ -68,29 +79,84 @@ class MediaViewerPresenter @AssistedInject constructor(
             when (mediaViewerEvents) {
                 MediaViewerEvents.RetryLoading -> loadMediaTrigger++
                 MediaViewerEvents.ClearLoadingError -> localMedia.value = Async.Uninitialized
+                MediaViewerEvents.SaveOnDisk -> coroutineScope.saveOnDisk(localMedia.value)
+                MediaViewerEvents.Share -> coroutineScope.share(localMedia.value)
+                MediaViewerEvents.OpenWith -> coroutineScope.open(localMedia.value)
             }
         }
 
         return MediaViewerState(
-            name = inputs.name,
-            mimeType = inputs.mimeType,
+            mediaInfo = inputs.mediaInfo,
             thumbnailSource = inputs.thumbnailSource,
             downloadedMedia = localMedia.value,
+            snackbarMessage = snackbarMessage,
             eventSink = ::handleEvents
         )
     }
 
     private fun CoroutineScope.downloadMedia(mediaFile: MutableState<MediaFile?>, localMedia: MutableState<Async<LocalMedia>>) = launch {
         localMedia.value = Async.Loading()
-        mediaLoader.downloadMediaFile(inputs.mediaSource, inputs.mimeType)
+        mediaLoader.downloadMediaFile(
+            source = inputs.mediaSource,
+            mimeType = inputs.mediaInfo.mimeType,
+            body = inputs.mediaInfo.name
+        )
             .onSuccess {
                 mediaFile.value = it
-            }.mapCatching {
-                localMediaFactory.createFromMediaFile(it, inputs.mimeType)
+            }.mapCatching { mediaFile ->
+                localMediaFactory.createFromMediaFile(
+                    mediaFile = mediaFile,
+                    mediaInfo = inputs.mediaInfo
+                )
             }.onSuccess {
                 localMedia.value = Async.Success(it)
             }.onFailure {
                 localMedia.value = Async.Failure(it)
             }
     }
+
+    private fun CoroutineScope.saveOnDisk(localMedia: Async<LocalMedia>) = launch {
+        if (localMedia is Async.Success) {
+            localMediaActions.saveOnDisk(localMedia.state)
+                .onSuccess {
+                    val snackbarMessage = SnackbarMessage(StringR.string.common_file_saved_on_disk_android)
+                    snackbarDispatcher.post(snackbarMessage)
+                }
+                .onFailure {
+                    val snackbarMessage = SnackbarMessage(mediaActionsError(it))
+                    snackbarDispatcher.post(snackbarMessage)
+                }
+        } else Unit
+    }
+
+    private fun CoroutineScope.share(localMedia: Async<LocalMedia>) = launch {
+        if (localMedia is Async.Success) {
+            localMediaActions.share(localMedia.state)
+                .onFailure {
+                    val snackbarMessage = SnackbarMessage(mediaActionsError(it))
+                    snackbarDispatcher.post(snackbarMessage)
+                }
+        } else Unit
+    }
+
+    private fun CoroutineScope.open(localMedia: Async<LocalMedia>) = launch {
+        if (localMedia is Async.Success) {
+            localMediaActions.open(localMedia.state)
+                .onFailure {
+                    val snackbarMessage = SnackbarMessage(mediaActionsError(it))
+                    snackbarDispatcher.post(snackbarMessage)
+                }
+        } else Unit
+    }
+
+    private fun mediaActionsError(throwable: Throwable): Int {
+        return if (throwable is ActivityNotFoundException) {
+            UtilsR.string.error_no_compatible_app_found
+        } else {
+            StringR.string.error_unknown
+        }
+    }
 }
+
+
+

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/viewer/MediaViewerState.kt

@@ -17,13 +17,15 @@
 package io.element.android.features.messages.impl.media.viewer
 
 import io.element.android.features.messages.impl.media.local.LocalMedia
+import io.element.android.features.messages.impl.media.local.MediaInfo
 import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.designsystem.utils.SnackbarMessage
 import io.element.android.libraries.matrix.api.media.MediaSource
 
 data class MediaViewerState(
-    val name: String,
-    val mimeType: String?,
+    val mediaInfo: MediaInfo,
     val thumbnailSource: MediaSource?,
     val downloadedMedia: Async<LocalMedia>,
+    val snackbarMessage: SnackbarMessage?,
     val eventSink: (MediaViewerEvents) -> Unit,
 )

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/viewer/MediaViewerStateProvider.kt

@@ -18,8 +18,12 @@ package io.element.android.features.messages.impl.media.viewer
 
 import android.net.Uri
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import androidx.media3.common.MimeTypes
 import io.element.android.features.messages.impl.media.local.LocalMedia
+import io.element.android.features.messages.impl.media.local.MediaInfo
+import io.element.android.features.messages.impl.media.local.aFileInfo
+import io.element.android.features.messages.impl.media.local.aPdfInfo
+import io.element.android.features.messages.impl.media.local.aVideoInfo
+import io.element.android.features.messages.impl.media.local.anImageInfo
 import io.element.android.libraries.architecture.Async
 
 open class MediaViewerStateProvider : PreviewParameterProvider<MediaViewerState> {
@@ -30,24 +34,41 @@ open class MediaViewerStateProvider : PreviewParameterProvider<MediaViewerState>
             aMediaViewerState(Async.Failure(IllegalStateException())),
             aMediaViewerState(
                 Async.Success(
-                    LocalMedia(
-                        Uri.EMPTY, MimeTypes.IMAGE_JPEG, "an image file", 100L
-                    )
+                    LocalMedia(Uri.EMPTY, anImageInfo())
                 ),
+                anImageInfo(),
             ),
             aMediaViewerState(
                 Async.Success(
-                    LocalMedia(
-                        Uri.EMPTY, MimeTypes.VIDEO_MP4, "a video file", 100L
-                    )
+                    LocalMedia(Uri.EMPTY, aVideoInfo())
                 ),
+                aVideoInfo(),
+            ),
+            aMediaViewerState(
+                Async.Success(
+                    LocalMedia(Uri.EMPTY, aPdfInfo())
+                ),
+                aPdfInfo(),
+            ),
+            aMediaViewerState(
+                Async.Loading(),
+                aFileInfo(),
+            ),
+            aMediaViewerState(
+                Async.Success(
+                    LocalMedia(Uri.EMPTY, aFileInfo())
+                ),
+                aFileInfo(),
             )
         )
 }
 
-fun aMediaViewerState(downloadedMedia: Async<LocalMedia> = Async.Uninitialized) = MediaViewerState(
-    name = "A media",
-    mimeType = MimeTypes.IMAGE_JPEG,
+fun aMediaViewerState(
+    downloadedMedia: Async<LocalMedia> = Async.Uninitialized,
+    mediaInfo: MediaInfo = anImageInfo(),
+) = MediaViewerState(
+    mediaInfo = mediaInfo,
     thumbnailSource = null,
     downloadedMedia = downloadedMedia,
+    snackbarMessage = null
 ) {}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/viewer/MediaViewerView.kt

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+@file:OptIn(ExperimentalMaterial3Api::class)
 
 package io.element.android.features.messages.impl.media.viewer
 
@@ -21,8 +22,21 @@ import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Download
+import androidx.compose.material.icons.filled.OpenInNew
+import androidx.compose.material.icons.filled.Share
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Snackbar
+import androidx.compose.material3.SnackbarHost
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -32,18 +46,25 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalInspectionMode
 import androidx.compose.ui.res.stringResource
 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.features.messages.impl.media.local.LocalMedia
 import io.element.android.features.messages.impl.media.local.LocalMediaView
+import io.element.android.features.messages.impl.media.local.rememberLocalMediaViewState
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.isLoading
+import io.element.android.libraries.designsystem.components.button.BackButton
 import io.element.android.libraries.designsystem.components.dialogs.RetryDialog
-import io.element.android.libraries.designsystem.modifiers.roundedBackground
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
-import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.IconButton
 import io.element.android.libraries.designsystem.theme.components.Scaffold
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+import io.element.android.libraries.designsystem.utils.rememberSnackbarHostState
 import io.element.android.libraries.matrix.api.media.MediaSource
 import io.element.android.libraries.matrix.ui.media.MediaRequestData
 import kotlinx.coroutines.delay
@@ -52,6 +73,7 @@ import io.element.android.libraries.ui.strings.R as StringR
 @Composable
 fun MediaViewerView(
     state: MediaViewerState,
+    onBackPressed: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
 
@@ -63,61 +85,132 @@ fun MediaViewerView(
         state.eventSink(MediaViewerEvents.ClearLoadingError)
     }
 
-    var showProgress by remember {
-        mutableStateOf(false)
-    }
+    val localMediaViewState = rememberLocalMediaViewState()
+    val showThumbnail = !localMediaViewState.isReady
+    val showProgress = rememberShowProgress(state.downloadedMedia)
+    val snackbarHostState = rememberSnackbarHostState(snackbarMessage = state.snackbarMessage)
 
-    // Trick to avoid showing progress indicator if the media is already on disk.
-    // When sdk will expose download progress we'll be able to remove this.
-    LaunchedEffect(state.downloadedMedia) {
-        showProgress = false
-        delay(100)
-        if (state.downloadedMedia.isLoading()) {
-            showProgress = true
-        }
-    }
-
-    var showThumbnail by remember {
-        mutableStateOf(true)
-    }
-
-    fun onMediaReady() {
-        showThumbnail = false
-    }
-
-    Scaffold(modifier) {
-        Box(
+    Scaffold(
+        modifier,
+        topBar = {
+            MediaViewerTopBar(
+                actionsEnabled = state.downloadedMedia is Async.Success,
+                onBackPressed = onBackPressed,
+                eventSink = state.eventSink
+            )
+        },
+        snackbarHost = {
+            SnackbarHost(snackbarHostState) { data ->
+                Snackbar(
+                    snackbarData = data,
+                    containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                    contentColor = MaterialTheme.colorScheme.primary
+                )
+            }
+        },
+    ) {
+        Column(
             modifier = Modifier
                 .fillMaxSize()
                 .padding(it),
-            contentAlignment = Alignment.Center
         ) {
-            if (state.downloadedMedia is Async.Failure) {
-                ErrorView(
-                    errorMessage = stringResource(id = StringR.string.error_unknown),
-                    onRetry = ::onRetry,
-                    onDismiss = ::onDismissError
+            if (showProgress) {
+                LinearProgressIndicator(
+                    Modifier
+                        .fillMaxWidth()
+                        .height(2.dp)
+                )
+            } else {
+                Spacer(Modifier.height(2.dp))
+            }
+            Box(
+                modifier = Modifier.fillMaxSize(),
+                contentAlignment = Alignment.Center
+            ) {
+                if (state.downloadedMedia is Async.Failure) {
+                    ErrorView(
+                        errorMessage = stringResource(id = StringR.string.error_unknown),
+                        onRetry = ::onRetry,
+                        onDismiss = ::onDismissError
+                    )
+                }
+                LocalMediaView(
+                    localMediaViewState = localMediaViewState,
+                    localMedia = state.downloadedMedia.dataOrNull(),
+                    mediaInfo = state.mediaInfo,
+                )
+                ThumbnailView(
+                    thumbnailSource = state.thumbnailSource,
+                    showThumbnail = showThumbnail,
                 )
             }
-            LocalMediaView(
-                localMedia = state.downloadedMedia.dataOrNull(),
-                mimeType = state.mimeType,
-                onReady = ::onMediaReady
-            )
-            ThumbnailView(
-                thumbnailSource = state.thumbnailSource,
-                showThumbnail = showThumbnail,
-                showProgress = showProgress,
-            )
         }
     }
 }
 
+@Composable
+private fun rememberShowProgress(downloadedMedia: Async<LocalMedia>): Boolean {
+    var showProgress by remember {
+        mutableStateOf(false)
+    }
+    if (LocalInspectionMode.current) {
+        showProgress = downloadedMedia.isLoading()
+    } else {
+        // Trick to avoid showing progress indicator if the media is already on disk.
+        // When sdk will expose download progress we'll be able to remove this.
+        LaunchedEffect(downloadedMedia) {
+            showProgress = false
+            delay(100)
+            if (downloadedMedia.isLoading()) {
+                showProgress = true
+            }
+        }
+    }
+    return showProgress
+}
+
+@Composable
+private fun MediaViewerTopBar(
+    actionsEnabled: Boolean,
+    onBackPressed: () -> Unit,
+    eventSink: (MediaViewerEvents) -> Unit,
+) {
+    TopAppBar(
+        title = {},
+        navigationIcon = { BackButton(onClick = onBackPressed) },
+        actions = {
+            IconButton(
+                enabled = actionsEnabled,
+                onClick = {
+                    eventSink(MediaViewerEvents.OpenWith)
+                },
+            ) {
+                Icon(imageVector = Icons.Default.OpenInNew, contentDescription = stringResource(id = StringR.string.action_open_with))
+            }
+            IconButton(
+                enabled = actionsEnabled,
+                onClick = {
+                    eventSink(MediaViewerEvents.SaveOnDisk)
+                },
+            ) {
+                Icon(imageVector = Icons.Default.Download, contentDescription = stringResource(id = StringR.string.action_save))
+            }
+            IconButton(
+                enabled = actionsEnabled,
+                onClick = {
+                    eventSink(MediaViewerEvents.Share)
+                },
+            ) {
+                Icon(imageVector = Icons.Default.Share, contentDescription = stringResource(id = StringR.string.action_share))
+            }
+        }
+    )
+}
+
 @Composable
 private fun ThumbnailView(
     thumbnailSource: MediaSource?,
     showThumbnail: Boolean,
-    showProgress: Boolean,
 ) {
     AnimatedVisibility(
         visible = showThumbnail,
@@ -139,14 +232,6 @@ private fun ThumbnailView(
                 contentScale = ContentScale.Fit,
                 contentDescription = null,
             )
-            if (showProgress) {
-                Box(
-                    modifier = Modifier.roundedBackground(),
-                    contentAlignment = Alignment.Center,
-                ) {
-                    CircularProgressIndicator()
-                }
-            }
         }
     }
 }
@@ -175,5 +260,6 @@ fun MediaViewerViewDarkPreview(@PreviewParameter(MediaViewerStateProvider::class
 private fun ContentToPreview(state: MediaViewerState) {
     MediaViewerView(
         state = state,
+        onBackPressed = {}
     )
 }

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

@@ -192,7 +192,7 @@ class MessageComposerPresenter @Inject constructor(
             is Attachment.Media -> {
                 sendMedia(
                     uri = attachment.localMedia.uri,
-                    mimeType = attachment.localMedia.mimeType,
+                    mimeType = attachment.localMedia.info.mimeType,
                     attachmentState = attachmentState
                 )
             }
@@ -210,12 +210,17 @@ class MessageComposerPresenter @Inject constructor(
             attachmentsState.value = AttachmentsState.None
             return
         }
-        val localMedia = localMediaFactory.createFromUri(uri, mimeType)
+        val localMedia = localMediaFactory.createFromUri(
+            uri = uri,
+            mimeType = mimeType,
+            name = null,
+            formattedFileSize = null
+        )
         val mediaAttachment = Attachment.Media(localMedia, compressIfPossible)
         val isPreviewable = when {
-            MimeTypes.isImage(localMedia.mimeType) -> true
-            MimeTypes.isVideo(localMedia.mimeType) -> true
-            MimeTypes.isAudio(localMedia.mimeType) -> true
+            MimeTypes.isImage(localMedia.info.mimeType) -> true
+            MimeTypes.isVideo(localMedia.info.mimeType) -> true
+            MimeTypes.isAudio(localMedia.info.mimeType) -> true
             else -> false
         }
         attachmentsState.value = if (isPreviewable) {

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/event/TimelineItemFileView.kt

@@ -20,8 +20,9 @@ import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Attachment
@@ -61,10 +62,13 @@ fun TimelineItemFileView(
             Icon(
                 imageVector = Icons.Outlined.Attachment,
                 contentDescription = "OpenFile",
-                modifier = Modifier.size(16.dp).rotate(-45f),
+                modifier = Modifier
+                    .size(16.dp)
+                    .rotate(-45f),
             )
         }
-        Column(modifier = Modifier.padding(horizontal = 8.dp),) {
+        Spacer(Modifier.width(8.dp))
+        Column {
             Text(
                 text = content.body,
                 maxLines = 2,
@@ -74,6 +78,9 @@ fun TimelineItemFileView(
             Text(
                 text = content.fileExtensionAndSize,
                 color = MaterialTheme.colorScheme.secondary,
+                fontSize = 12.sp,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
             )
         }
     }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentMessageFactory.kt

@@ -26,6 +26,7 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVideoContent
 import io.element.android.features.messages.impl.timeline.util.FileSizeFormatter
 import io.element.android.features.messages.impl.timeline.util.toHtmlDocument
+import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.matrix.api.timeline.item.event.EmoteMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
@@ -51,11 +52,12 @@ class TimelineItemContentMessageFactory @Inject constructor(
                 TimelineItemImageContent(
                     body = messageType.body,
                     mediaSource = messageType.source,
-                    mimeType = messageType.info?.mimetype,
+                    mimeType = messageType.info?.mimetype ?: MimeTypes.OctetStream,
                     blurhash = messageType.info?.blurhash,
                     width = messageType.info?.width?.toInt(),
                     height = messageType.info?.height?.toInt(),
-                    aspectRatio = aspectRatio
+                    aspectRatio = aspectRatio,
+                    formattedFileSize = fileSizeFormatter.format(messageType.info?.size ?: 0)
                 )
             }
             is VideoMessageType -> {
@@ -64,22 +66,21 @@ class TimelineItemContentMessageFactory @Inject constructor(
                     body = messageType.body,
                     thumbnailSource = messageType.info?.thumbnailSource,
                     videoSource = messageType.source,
-                    mimeType = messageType.info?.mimetype,
+                    mimeType = messageType.info?.mimetype ?: MimeTypes.OctetStream,
                     width = messageType.info?.width?.toInt(),
                     height = messageType.info?.height?.toInt(),
                     duration = messageType.info?.duration ?: 0L,
                     blurHash = messageType.info?.blurhash,
-                    aspectRatio = aspectRatio
+                    aspectRatio = aspectRatio,
+                    formattedFileSize = fileSizeFormatter.format(messageType.info?.size ?: 0)
                 )
             }
             is FileMessageType -> TimelineItemFileContent(
                 body = messageType.body,
                 thumbnailSource = messageType.info?.thumbnailSource,
                 fileSource = messageType.source,
-                mimeType = messageType.info?.mimetype,
-                formattedFileSize = messageType.info?.size?.let {
-                    fileSizeFormatter.format(it)
-                },
+                mimeType = messageType.info?.mimetype ?: MimeTypes.OctetStream,
+                formattedFileSize = fileSizeFormatter.format(messageType.info?.size ?: 0)
             )
             is NoticeMessageType -> TimelineItemNoticeContent(
                 body = messageType.body,

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemFileContent.kt

@@ -16,23 +16,17 @@
 
 package io.element.android.features.messages.impl.timeline.model.event
 
+import io.element.android.features.messages.impl.media.helper.formatFileExtensionAndSize
 import io.element.android.libraries.matrix.api.media.MediaSource
 
 data class TimelineItemFileContent(
     val body: String,
     val fileSource: MediaSource,
     val thumbnailSource: MediaSource?,
-    val formattedFileSize: String?,
-    val mimeType: String?,
+    val formattedFileSize: String,
+    val mimeType: String,
 ) : TimelineItemEventContent {
     override val type: String = "TimelineItemFileContent"
 
-    private val fileExtension = body.substringAfterLast('.', "").uppercase()
-    val fileExtensionAndSize = buildString {
-        append(fileExtension)
-        if (formattedFileSize != null) {
-            append(' ')
-            append("($formattedFileSize)")
-        }
-    }
+    val fileExtensionAndSize = formatFileExtensionAndSize(body, formattedFileSize)
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemImageContent.kt

@@ -21,7 +21,8 @@ import io.element.android.libraries.matrix.api.media.MediaSource
 data class TimelineItemImageContent(
     val body: String,
     val mediaSource: MediaSource,
-    val mimeType: String?,
+    val formattedFileSize: String,
+    val mimeType: String,
     val blurhash: String?,
     val width: Int?,
     val height: Int?,

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemImageContentProvider.kt

@@ -36,5 +36,6 @@ fun aTimelineItemImageContent() = TimelineItemImageContent(
     blurhash = "TQF5:I_NtRE4kXt7Z#MwkCIARPjr",
     width = null,
     height = 300,
-    aspectRatio = 0.5f
+    aspectRatio = 0.5f,
+    formattedFileSize = "4MB"
 )

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemVideoContent.kt

@@ -27,7 +27,8 @@ data class TimelineItemVideoContent(
     val blurHash: String?,
     val height: Int?,
     val width: Int?,
-    val mimeType: String?,
+    val mimeType: String,
+    val formattedFileSize: String,
 ) : TimelineItemEventContent {
     override val type: String = "TimelineItemImageContent"
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemVideoContentProvider.kt

@@ -17,6 +17,7 @@
 package io.element.android.features.messages.impl.timeline.model.event
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.matrix.api.media.MediaSource
 
 open class TimelineItemVideoContentProvider : PreviewParameterProvider<TimelineItemVideoContent> {
@@ -37,5 +38,6 @@ fun aTimelineItemVideoContent() = TimelineItemVideoContent(
     videoSource = MediaSource(""),
     height = 300,
     width = 150,
-    mimeType = null
+    mimeType = MimeTypes.Mp4,
+    formattedFileSize = "14MB"
 )

features/messages/impl/src/main/res/values/localazy.xml

@@ -9,5 +9,6 @@
   <string name="screen_room_attachment_source_camera_video">"Record a video"</string>
   <string name="screen_room_attachment_source_files">"Attachment"</string>
   <string name="screen_room_attachment_source_gallery">"Photo &amp; Video Library"</string>
+  <string name="screen_room_error_failed_retrieving_user_details">"Could not retrieve user details"</string>
   <string name="screen_room_error_failed_processing_media">"Failed processing media to upload, please try again."</string>
 </resources>

features/messages/impl/src/test/kotlin/io/element/android/features/messages/attachments/AttachmentsPreviewPresenterTest.kt

@@ -92,7 +92,6 @@ class AttachmentsPreviewPresenterTest {
     private fun anAttachmentsPreviewPresenter(
         localMedia: LocalMedia = aLocalMedia(
             uri = mockMediaUrl,
-            mimeType = MimeTypes.IMAGE_JPEG
         ),
         room: MatrixRoom = FakeMatrixRoom()
     ): AttachmentsPreviewPresenter {

features/messages/impl/src/test/kotlin/io/element/android/features/messages/fixtures/media.kt

@@ -17,21 +17,18 @@
 package io.element.android.features.messages.fixtures
 
 import android.net.Uri
-import androidx.media3.common.MimeTypes
 import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.media.local.LocalMedia
-import io.mockk.mockk
+import io.element.android.features.messages.impl.media.local.MediaInfo
+import io.element.android.features.messages.impl.media.local.anImageInfo
+import io.element.android.libraries.core.mimetype.MimeTypes
 
 fun aLocalMedia(
     uri: Uri,
-    mimeType: String = MimeTypes.IMAGE_JPEG,
-    name: String = "a media",
-    size: Long = 1000,
+    mediaInfo: MediaInfo = anImageInfo(),
 ) = LocalMedia(
     uri = uri,
-    mimeType = mimeType,
-    name = name,
-    size = size,
+    info = mediaInfo
 )
 
 fun aMediaAttachment(localMedia: LocalMedia, compressIfPossible: Boolean = true) = Attachment.Media(

features/messages/impl/src/test/kotlin/io/element/android/features/messages/media/FakeLocalMediaActions.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.media
+
+import androidx.compose.runtime.Composable
+import io.element.android.features.messages.impl.media.local.LocalMedia
+import io.element.android.features.messages.impl.media.local.LocalMediaActions
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import kotlinx.coroutines.withContext
+
+class FakeLocalMediaActions(private val coroutineDispatchers: CoroutineDispatchers) : LocalMediaActions {
+
+    var shouldFail = false
+
+    @Composable
+    override fun Configure() {
+        //NOOP
+    }
+
+    override suspend fun saveOnDisk(localMedia: LocalMedia): Result<Unit> = withContext(coroutineDispatchers.io) {
+        if (shouldFail) {
+            Result.failure(RuntimeException())
+        } else {
+            Result.success(Unit)
+        }
+    }
+
+    override suspend fun share(localMedia: LocalMedia): Result<Unit> = withContext(coroutineDispatchers.io) {
+        if (shouldFail) {
+            Result.failure(RuntimeException())
+        } else {
+            Result.success(Unit)
+        }
+    }
+
+    override suspend fun open(localMedia: LocalMedia): Result<Unit> = withContext(coroutineDispatchers.io) {
+        if (shouldFail) {
+            Result.failure(RuntimeException())
+        } else {
+            Result.success(Unit)
+        }
+    }
+}

features/messages/impl/src/test/kotlin/io/element/android/features/messages/media/FakeLocalMediaFactory.kt

@@ -20,18 +20,26 @@ import android.net.Uri
 import io.element.android.features.messages.fixtures.aLocalMedia
 import io.element.android.features.messages.impl.media.local.LocalMedia
 import io.element.android.features.messages.impl.media.local.LocalMediaFactory
+import io.element.android.features.messages.impl.media.local.MediaInfo
 import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.matrix.api.media.MediaFile
 
 class FakeLocalMediaFactory(private val localMediaUri: Uri) : LocalMediaFactory {
 
     var fallbackMimeType: String = MimeTypes.OctetStream
+    var fallbackName: String = "File name"
+    var fallbackFileSize = "0B"
 
-    override fun createFromMediaFile(mediaFile: MediaFile, mimeType: String?): LocalMedia {
-        return aLocalMedia(uri = localMediaUri, mimeType = mimeType ?: fallbackMimeType)
+    override fun createFromMediaFile(mediaFile: MediaFile, mediaInfo: MediaInfo): LocalMedia {
+        return aLocalMedia(uri = localMediaUri, mediaInfo = mediaInfo)
     }
 
-    override fun createFromUri(uri: Uri, mimeType: String?): LocalMedia {
-        return aLocalMedia(uri, mimeType ?: fallbackMimeType)
+    override fun createFromUri(uri: Uri, mimeType: String?, name: String?, formattedFileSize: String?): LocalMedia {
+        val mediaInfo = MediaInfo(
+            name = name ?: fallbackName,
+            mimeType = mimeType ?: fallbackMimeType,
+            formattedFileSize = formattedFileSize ?: fallbackFileSize
+        )
+        return aLocalMedia(uri, mediaInfo)
     }
 }

features/messages/impl/src/test/kotlin/io/element/android/features/messages/media/viewer/MediaViewerPresenterTest.kt

@@ -19,65 +19,122 @@
 package io.element.android.features.messages.media.viewer
 
 import android.net.Uri
-import androidx.media3.common.MimeTypes
 import app.cash.molecule.RecompositionClock
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
+import io.element.android.features.messages.impl.media.local.MediaInfo
 import io.element.android.features.messages.impl.media.viewer.MediaViewerEvents
 import io.element.android.features.messages.impl.media.viewer.MediaViewerNode
 import io.element.android.features.messages.impl.media.viewer.MediaViewerPresenter
+import io.element.android.features.messages.media.FakeLocalMediaActions
 import io.element.android.features.messages.media.FakeLocalMediaFactory
 import io.element.android.libraries.architecture.Async
-import io.element.android.libraries.matrix.test.FAKE_DELAY_IN_MS
+import io.element.android.libraries.designsystem.utils.SnackbarDispatcher
 import io.element.android.libraries.matrix.test.media.FakeMediaLoader
 import io.element.android.libraries.matrix.test.media.aMediaSource
+import io.element.android.tests.testutils.testCoroutineDispatchers
 import io.mockk.mockk
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 
-private const val TESTED_MIME_TYPE = MimeTypes.IMAGE_JPEG
-private const val TESTED_MEDIA_NAME = "MediaName"
+private val TESTED_MEDIA_INFO = MediaInfo(
+    name = "",
+    mimeType = "",
+    formattedFileSize = ""
+)
 
 class MediaViewerPresenterTest {
 
-    private val mockMediaUrl: Uri = mockk("localMediaUri")
-    private val localMediaFactory = FakeLocalMediaFactory(mockMediaUrl)
-    private val mediaLoader = FakeMediaLoader()
+    private val mockMediaUri: Uri = mockk("localMediaUri")
+    private val localMediaFactory = FakeLocalMediaFactory(mockMediaUri)
 
     @Test
     fun `present - download media success scenario`() = runTest {
-        val presenter = aMediaViewerPresenter()
+        val coroutineDispatchers = testCoroutineDispatchers(testScheduler, useUnconfinedTestDispatcher = false)
+        val mediaLoader = FakeMediaLoader(coroutineDispatchers)
+        val mediaActions = FakeLocalMediaActions(coroutineDispatchers)
+        val presenter = aMediaViewerPresenter(mediaLoader, mediaActions)
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
         }.test {
-            val initialState = awaitItem()
-            assertThat(initialState.downloadedMedia).isEqualTo(Async.Uninitialized)
-            assertThat(initialState.name).isEqualTo(TESTED_MEDIA_NAME)
-            val loadingState = awaitItem()
-            assertThat(loadingState.downloadedMedia).isInstanceOf(Async.Loading::class.java)
-            testScheduler.advanceTimeBy(FAKE_DELAY_IN_MS + 1)
-            val successState = awaitItem()
-            val successData = successState.downloadedMedia.dataOrNull()
-            assertThat(successState.downloadedMedia).isInstanceOf(Async.Success::class.java)
+            var state = awaitItem()
+            assertThat(state.downloadedMedia).isEqualTo(Async.Uninitialized)
+            assertThat(state.mediaInfo).isEqualTo(TESTED_MEDIA_INFO)
+            state = awaitItem()
+            assertThat(state.downloadedMedia).isInstanceOf(Async.Loading::class.java)
+            state = awaitItem()
+            val successData = state.downloadedMedia.dataOrNull()
+            assertThat(state.downloadedMedia).isInstanceOf(Async.Success::class.java)
             assertThat(successData).isNotNull()
         }
     }
 
+    @Test
+    fun `present - check all actions `() = runTest {
+        val coroutineDispatchers = testCoroutineDispatchers(testScheduler, useUnconfinedTestDispatcher = false)
+        val mediaLoader = FakeMediaLoader(coroutineDispatchers)
+        val mediaActions = FakeLocalMediaActions(coroutineDispatchers)
+        val presenter = aMediaViewerPresenter(mediaLoader, mediaActions)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            var state = awaitItem()
+            assertThat(state.downloadedMedia).isEqualTo(Async.Uninitialized)
+            state = awaitItem()
+            assertThat(state.downloadedMedia).isInstanceOf(Async.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)
+            // Should succeed without change of state
+            state.eventSink(MediaViewerEvents.OpenWith)
+            // Should succeed without change of state
+            state.eventSink(MediaViewerEvents.Share)
+            state.eventSink(MediaViewerEvents.SaveOnDisk)
+            state = awaitItem()
+            assertThat(state.snackbarMessage).isNotNull()
+            state = awaitItem()
+            assertThat(state.snackbarMessage).isNull()
+
+            // Check failures
+            mediaActions.shouldFail = true
+            state.eventSink(MediaViewerEvents.OpenWith)
+            state = awaitItem()
+            assertThat(state.snackbarMessage).isNotNull()
+            state = awaitItem()
+            assertThat(state.snackbarMessage).isNull()
+            state.eventSink(MediaViewerEvents.Share)
+            state = awaitItem()
+            assertThat(state.snackbarMessage).isNotNull()
+            state = awaitItem()
+            assertThat(state.snackbarMessage).isNull()
+            state.eventSink(MediaViewerEvents.SaveOnDisk)
+            state = awaitItem()
+            assertThat(state.snackbarMessage).isNotNull()
+            state = awaitItem()
+            assertThat(state.snackbarMessage).isNull()
+        }
+    }
+
     @Test
     fun `present - download media failure then retry with success scenario`() = runTest {
-        val presenter = aMediaViewerPresenter()
+        val coroutineDispatchers = testCoroutineDispatchers(testScheduler, useUnconfinedTestDispatcher = false)
+        val mediaLoader = FakeMediaLoader(coroutineDispatchers)
+        val mediaActions = FakeLocalMediaActions(coroutineDispatchers)
+        val presenter = aMediaViewerPresenter(mediaLoader, mediaActions)
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
         }.test {
             mediaLoader.shouldFail = true
             val initialState = awaitItem()
             assertThat(initialState.downloadedMedia).isEqualTo(Async.Uninitialized)
-            assertThat(initialState.name).isEqualTo(TESTED_MEDIA_NAME)
+            assertThat(initialState.mediaInfo).isEqualTo(TESTED_MEDIA_INFO)
             val loadingState = awaitItem()
             assertThat(loadingState.downloadedMedia).isInstanceOf(Async.Loading::class.java)
-            testScheduler.advanceTimeBy(FAKE_DELAY_IN_MS)
             val failureState = awaitItem()
             assertThat(failureState.downloadedMedia).isInstanceOf(Async.Failure::class.java)
             mediaLoader.shouldFail = false
@@ -86,7 +143,6 @@ class MediaViewerPresenterTest {
             skipItems(1)
             val retryLoadingState = awaitItem()
             assertThat(retryLoadingState.downloadedMedia).isInstanceOf(Async.Loading::class.java)
-            testScheduler.advanceTimeBy(FAKE_DELAY_IN_MS)
             val successState = awaitItem()
             val successData = successState.downloadedMedia.dataOrNull()
             assertThat(successState.downloadedMedia).isInstanceOf(Async.Success::class.java)
@@ -94,16 +150,20 @@ class MediaViewerPresenterTest {
         }
     }
 
-    private fun aMediaViewerPresenter(mimeType: String = TESTED_MIME_TYPE): MediaViewerPresenter {
+    private fun aMediaViewerPresenter(
+        mediaLoader: FakeMediaLoader,
+        localMediaActions: FakeLocalMediaActions,
+    ): MediaViewerPresenter {
         return MediaViewerPresenter(
             inputs = MediaViewerNode.Inputs(
-                name = TESTED_MEDIA_NAME,
+                mediaInfo = TESTED_MEDIA_INFO,
                 mediaSource = aMediaSource(),
-                mimeType = mimeType,
                 thumbnailSource = null
             ),
             localMediaFactory = localMediaFactory,
-            mediaLoader = mediaLoader
+            mediaLoader = mediaLoader,
+            localMediaActions = localMediaActions,
+            snackbarDispatcher = SnackbarDispatcher()
         )
     }
 }

features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListView.kt

@@ -41,17 +41,13 @@ import androidx.compose.material.icons.filled.Close
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Snackbar
-import androidx.compose.material3.SnackbarDuration
 import androidx.compose.material3.SnackbarHost
-import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberTopAppBarState
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -85,8 +81,8 @@ import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.noFontPadding
 import io.element.android.libraries.designsystem.theme.roomListUnreadIndicator
 import io.element.android.libraries.designsystem.utils.LogCompositions
+import io.element.android.libraries.designsystem.utils.rememberSnackbarHostState
 import io.element.android.libraries.matrix.api.core.RoomId
-import kotlinx.coroutines.launch
 import io.element.android.libraries.designsystem.R as DrawableR
 import io.element.android.libraries.ui.strings.R as StringR
 
@@ -184,21 +180,7 @@ fun RoomListContent(
         }
     }
 
-    val snackbarHostState = remember { SnackbarHostState() }
-    val snackbarMessageText = if (state.snackbarMessage != null) {
-        stringResource(state.snackbarMessage.messageResId)
-    } else null
-    val coroutineScope = rememberCoroutineScope()
-    if (snackbarMessageText != null) {
-        SideEffect {
-            coroutineScope.launch {
-                snackbarHostState.showSnackbar(
-                    message = snackbarMessageText,
-                    duration = SnackbarDuration.Short,
-                )
-            }
-        }
-    }
+    val snackbarHostState = rememberSnackbarHostState(snackbarMessage = state.snackbarMessage)
 
     Scaffold(
         modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/file/Context.kt

@@ -20,17 +20,24 @@ import android.content.ContentResolver
 import android.content.Context
 import android.net.Uri
 import android.provider.OpenableColumns
-import java.io.File
+import androidx.core.net.toFile
+
+fun Context.getMimeType(uri: Uri): String? = when (uri.scheme) {
+    ContentResolver.SCHEME_CONTENT -> contentResolver.getType(uri)
+    else -> null
+}
 
 fun Context.getFileName(uri: Uri): String? = when (uri.scheme) {
     ContentResolver.SCHEME_CONTENT -> getContentFileName(uri)
-    else -> uri.path?.let(::File)?.name
+    ContentResolver.SCHEME_FILE -> uri.toFile().name
+    else -> null
 }
 
 fun Context.getFileSize(uri: Uri): Long {
     return when (uri.scheme) {
         ContentResolver.SCHEME_CONTENT -> getContentFileSize(uri)
-        else -> uri.path?.let(::File)?.length()
+        ContentResolver.SCHEME_FILE -> uri.toFile().length()
+        else -> 0
     } ?: 0
 }
 

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/theme/components/Text.kt

@@ -66,6 +66,7 @@ fun Text(
     lineHeight: TextUnit = TextUnit.Unspecified,
     overflow: TextOverflow = TextOverflow.Clip,
     softWrap: Boolean = true,
+    minLines: Int = 1,
     maxLines: Int = Int.MAX_VALUE,
     onTextLayout: (TextLayoutResult) -> Unit = {},
     style: TextStyle = LocalTextStyle.current
@@ -84,6 +85,7 @@ fun Text(
         lineHeight = lineHeight,
         overflow = overflow,
         softWrap = softWrap,
+        minLines = minLines,
         maxLines = maxLines,
         onTextLayout = onTextLayout,
         style = style,
@@ -105,6 +107,7 @@ fun Text(
     lineHeight: TextUnit = TextUnit.Unspecified,
     overflow: TextOverflow = TextOverflow.Clip,
     softWrap: Boolean = true,
+    minLines: Int = 1,
     maxLines: Int = Int.MAX_VALUE,
     inlineContent: ImmutableMap<String, InlineTextContent> = persistentMapOf(),
     onTextLayout: (TextLayoutResult) -> Unit = {},
@@ -124,6 +127,7 @@ fun Text(
         lineHeight = lineHeight,
         overflow = overflow,
         softWrap = softWrap,
+        minLines = minLines,
         maxLines = maxLines,
         inlineContent = inlineContent,
         onTextLayout = onTextLayout,

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/utils/Snackbar.kt

@@ -18,11 +18,14 @@ package io.element.android.libraries.designsystem.utils
 
 import androidx.annotation.StringRes
 import androidx.compose.material3.SnackbarDuration
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
-import kotlinx.coroutines.Dispatchers
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.res.stringResource
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.update
@@ -56,7 +59,7 @@ fun handleSnackbarMessage(
     val snackbarMessage by snackbarDispatcher.snackbarMessage.collectAsState(initial = null)
     LaunchedEffect(snackbarMessage) {
         if (snackbarMessage != null) {
-            launch(Dispatchers.Main) {
+            launch {
                 snackbarDispatcher.clear()
             }
         }
@@ -64,6 +67,25 @@ fun handleSnackbarMessage(
     return snackbarMessage
 }
 
+@Composable
+fun rememberSnackbarHostState(snackbarMessage: SnackbarMessage?): SnackbarHostState {
+    val snackbarHostState = remember { SnackbarHostState() }
+    val coroutineScope = rememberCoroutineScope()
+    val snackbarMessageText = snackbarMessage?.let {
+        stringResource(id = snackbarMessage.messageResId)
+    }
+    LaunchedEffect(snackbarMessage) {
+        if (snackbarMessageText == null) return@LaunchedEffect
+        coroutineScope.launch {
+            snackbarHostState.showSnackbar(
+                message = snackbarMessageText,
+                duration = snackbarMessage.duration,
+            )
+        }
+    }
+    return snackbarHostState
+}
+
 data class SnackbarMessage(
     @StringRes val messageResId: Int,
     val duration: SnackbarDuration = SnackbarDuration.Short,

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/media/MatrixMediaLoader.kt

@@ -33,8 +33,9 @@ interface MatrixMediaLoader {
 
     /**
      * @param source to fetch the data for.
-     * @param mimeType: optional mime type
+     * @param mimeType: optional mime type.
+     * @param body: optional body which will be used to name the file.
      * @return a [Result] of [MediaFile]
      */
-    suspend fun downloadMediaFile(source: MediaSource, mimeType: String?): Result<MediaFile>
+    suspend fun downloadMediaFile(source: MediaSource, mimeType: String?, body: String?): Result<MediaFile>
 }

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/media/MediaFile.kt

@@ -17,6 +17,7 @@
 package io.element.android.libraries.matrix.api.media
 
 import java.io.Closeable
+import java.io.File
 
 /**
  * A wrapper around a media file on the disk.
@@ -25,3 +26,7 @@ import java.io.Closeable
 interface MediaFile : Closeable {
     fun path(): String
 }
+
+fun MediaFile.toFile(): File {
+    return File(path())
+}

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt

@@ -79,6 +79,7 @@ class RustMatrixClient constructor(
     private val coroutineScope: CoroutineScope,
     private val dispatchers: CoroutineDispatchers,
     private val baseDirectory: File,
+    private val baseCacheDirectory: File,
     private val clock: SystemClock,
 ) : MatrixClient {
 
@@ -188,7 +189,7 @@ class RustMatrixClient constructor(
     override val invitesDataSource: RoomSummaryDataSource
         get() = rustInvitesDataSource
 
-    private val rustMediaLoader = RustMediaLoader(dispatchers, client)
+    private val rustMediaLoader = RustMediaLoader(baseCacheDirectory, dispatchers, client)
     override val mediaLoader: MatrixMediaLoader
         get() = rustMediaLoader
 

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/auth/RustMatrixAuthenticationService.kt

@@ -16,10 +16,12 @@
 
 package io.element.android.libraries.matrix.impl.auth
 
+import android.content.Context
 import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.core.extensions.mapFailure
 import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.ApplicationContext
 import io.element.android.libraries.di.SingleIn
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
@@ -48,6 +50,7 @@ import org.matrix.rustcomponents.sdk.AuthenticationService as RustAuthentication
 @ContributesBinding(AppScope::class)
 @SingleIn(AppScope::class)
 class RustMatrixAuthenticationService @Inject constructor(
+    @ApplicationContext private val context: Context,
     private val baseDirectory: File,
     private val coroutineScope: CoroutineScope,
     private val coroutineDispatchers: CoroutineDispatchers,
@@ -179,6 +182,7 @@ class RustMatrixAuthenticationService @Inject constructor(
             coroutineScope = coroutineScope,
             dispatchers = coroutineDispatchers,
             baseDirectory = baseDirectory,
+            baseCacheDirectory = context.cacheDir,
             clock = clock,
         )
     }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/media/RustMediaLoader.kt

@@ -24,13 +24,21 @@ import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.Client
 import org.matrix.rustcomponents.sdk.mediaSourceFromUrl
 import org.matrix.rustcomponents.sdk.use
+import java.io.File
 import org.matrix.rustcomponents.sdk.MediaSource as RustMediaSource
 
 class RustMediaLoader(
+    baseCacheDirectory: File,
     private val dispatchers: CoroutineDispatchers,
-    private val innerClient: Client
+    private val innerClient: Client,
 ) : MatrixMediaLoader {
 
+    private val cacheDirectory = File(baseCacheDirectory, "temp/media").apply {
+        if (!exists()) {
+            mkdirs()
+        }
+    }
+
     @OptIn(ExperimentalUnsignedTypes::class)
     override suspend fun loadMediaContent(source: MediaSource): Result<ByteArray> =
         withContext(dispatchers.io) {
@@ -59,14 +67,16 @@ class RustMediaLoader(
             }
         }
 
-    override suspend fun downloadMediaFile(source: MediaSource, mimeType: String?): Result<MediaFile> =
+    override suspend fun downloadMediaFile(source: MediaSource, mimeType: String?, body: String?): Result<MediaFile> =
         withContext(dispatchers.io) {
             runCatching {
                 source.toRustMediaSource().use { mediaSource ->
                     val mediaFile = innerClient.getMediaFile(
                         mediaSource = mediaSource,
-                        body = null,
-                        mimeType = mimeType ?: "application/octet-stream"
+                        body = body,
+                        mimeType = mimeType ?: "application/octet-stream",
+                        //TODO uncomment when rust api will be merged
+                        //tempDir = cacheDirectory.path,
                     )
                     RustMediaFile(mediaFile)
                 }

libraries/matrix/test/build.gradle.kts

@@ -26,4 +26,6 @@ dependencies {
     api(projects.libraries.core)
     api(projects.libraries.matrix.api)
     api(libs.coroutines.core)
+    implementation(libs.coroutines.test)
+    implementation(projects.tests.testutils)
 }

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/FakeMatrixClient.kt

@@ -16,6 +16,7 @@
 
 package io.element.android.libraries.matrix.test
 
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.SessionId
@@ -36,15 +37,18 @@ import io.element.android.libraries.matrix.test.pushers.FakePushersService
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.libraries.matrix.test.room.FakeRoomSummaryDataSource
 import io.element.android.libraries.matrix.test.verification.FakeSessionVerificationService
+import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.StandardTestDispatcher
 
 class FakeMatrixClient(
     override val sessionId: SessionId = A_SESSION_ID,
+    private val coroutineDispatchers: CoroutineDispatchers = testCoroutineDispatchers(),
     private val userDisplayName: Result<String> = Result.success(A_USER_NAME),
     private val userAvatarURLString: Result<String> = Result.success(AN_AVATAR_URL),
     override val roomSummaryDataSource: RoomSummaryDataSource = FakeRoomSummaryDataSource(),
     override val invitesDataSource: RoomSummaryDataSource = FakeRoomSummaryDataSource(),
-    override val mediaLoader: MatrixMediaLoader = FakeMediaLoader(),
+    override val mediaLoader: MatrixMediaLoader = FakeMediaLoader(coroutineDispatchers),
     private val sessionVerificationService: FakeSessionVerificationService = FakeSessionVerificationService(),
     private val pushersService: FakePushersService = FakePushersService(),
     private val notificationService: FakeNotificationService = FakeNotificationService(),

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/media/FakeMediaLoader.kt

@@ -16,40 +16,40 @@
 
 package io.element.android.libraries.matrix.test.media
 
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
 import io.element.android.libraries.matrix.api.media.MediaFile
 import io.element.android.libraries.matrix.api.media.MediaSource
 import io.element.android.libraries.matrix.test.FAKE_DELAY_IN_MS
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.coroutineContext
 
-class FakeMediaLoader : MatrixMediaLoader {
+class FakeMediaLoader(private val coroutineDispatchers: CoroutineDispatchers) : MatrixMediaLoader {
 
     var shouldFail = false
 
-    override suspend fun loadMediaContent(source: MediaSource): Result<ByteArray> {
-        delay(FAKE_DELAY_IN_MS)
-        return if (shouldFail) {
+    override suspend fun loadMediaContent(source: MediaSource): Result<ByteArray> = withContext(coroutineDispatchers.io){
+        if (shouldFail) {
             Result.failure(RuntimeException())
         } else {
-            return Result.success(ByteArray(0))
+            Result.success(ByteArray(0))
         }
     }
 
-    override suspend fun loadMediaThumbnail(source: MediaSource, width: Long, height: Long): Result<ByteArray> {
-        delay(FAKE_DELAY_IN_MS)
-        return if (shouldFail) {
+    override suspend fun loadMediaThumbnail(source: MediaSource, width: Long, height: Long): Result<ByteArray>  = withContext(coroutineDispatchers.io){
+        if (shouldFail) {
             Result.failure(RuntimeException())
         } else {
-            return Result.success(ByteArray(0))
+            Result.success(ByteArray(0))
         }
     }
 
-    override suspend fun downloadMediaFile(source: MediaSource, mimeType: String?): Result<MediaFile> {
-        delay(FAKE_DELAY_IN_MS)
-        return if (shouldFail) {
+    override suspend fun downloadMediaFile(source: MediaSource, mimeType: String?, body: String?): Result<MediaFile> = withContext(coroutineDispatchers.io){
+        if (shouldFail) {
             Result.failure(RuntimeException())
         } else {
-            return Result.success(FakeMediaFile(""))
+            Result.success(FakeMediaFile(""))
         }
     }
 }

libraries/push/impl/src/main/res/values/localazy.xml

@@ -7,6 +7,7 @@
   <string name="notification_inline_reply_failed">"** Failed to send - please open room"</string>
   <string name="notification_invitation_action_join">"Join"</string>
   <string name="notification_invitation_action_reject">"Reject"</string>
+  <string name="notification_invite_body">"invited you"</string>
   <string name="notification_new_messages">"New Messages"</string>
   <string name="notification_room_action_mark_as_read">"Mark as read"</string>
   <string name="notification_sender_me">"Me"</string>

libraries/ui-strings/src/main/res/values/localazy.xml

@@ -34,6 +34,7 @@
   <string name="action_no">"No"</string>
   <string name="action_not_now">"Not now"</string>
   <string name="action_ok">"OK"</string>
+  <string name="action_open_with">"Open with"</string>
   <string name="action_quick_reply">"Quick reply"</string>
   <string name="action_quote">"Quote"</string>
   <string name="action_remove">"Remove"</string>
@@ -145,7 +146,20 @@
   <string name="room_timeline_beginning_of_room">"This is the beginning of %1$s."</string>
   <string name="room_timeline_beginning_of_room_no_name">"This is the beginning of this conversation."</string>
   <string name="room_timeline_read_marker_title">"New"</string>
+  <string name="screen_account_provider_change">"Change account provider"</string>
+  <string name="screen_account_provider_continue">"Continue"</string>
+  <string name="screen_account_provider_form_hint">"Homeserver address"</string>
+  <string name="screen_account_provider_form_notice">"Enter a search term or a domain address."</string>
+  <string name="screen_account_provider_form_subtitle">"Search for a company, community, or private server."</string>
+  <string name="screen_account_provider_form_title">"Find an account provider"</string>
+  <string name="screen_account_provider_signin_title">"You’re about to sign in to %s"</string>
+  <string name="screen_account_provider_signup_subtitle">"This is where you conversations will live — just like you would use an email provider to keep your emails."</string>
+  <string name="screen_account_provider_signup_title">"You’re about to create an account on %s"</string>
   <string name="screen_analytics_settings_share_data">"Share analytics data"</string>
+  <string name="screen_change_account_provider_matrix_org_subtitle">"Matrix.org is an open network for secure, decentralized communication."</string>
+  <string name="screen_change_account_provider_other">"Other"</string>
+  <string name="screen_change_account_provider_subtitle">"Use a different account provider, such as your own private server or a work account."</string>
+  <string name="screen_change_account_provider_title">"Change account provider"</string>
   <string name="screen_media_picker_error_failed_selection">"Failed selecting media, please try again."</string>
   <string name="screen_media_upload_preview_error_failed_processing">"Failed processing media to upload, please try again."</string>
   <string name="screen_media_upload_preview_error_failed_sending">"Failed uploading media, please try again."</string>
@@ -168,4 +182,4 @@
   <string name="screen_analytics_settings_read_terms">"You can read all our terms %1$s."</string>
   <string name="screen_analytics_settings_read_terms_content_link">"here"</string>
   <string name="screen_report_content_block_user">"Block user"</string>
-</resources>
+</resources>

samples/minimal/src/main/kotlin/io/element/android/samples/minimal/MainActivity.kt

@@ -40,6 +40,7 @@ class MainActivity : ComponentActivity() {
         val baseDirectory = File(applicationContext.filesDir, "sessions")
 
         RustMatrixAuthenticationService(
+            context = applicationContext,
             baseDirectory = baseDirectory,
             coroutineScope = Singleton.appScope,
             coroutineDispatchers = Singleton.coroutineDispatchers,

tests/testutils/build.gradle.kts

@@ -28,12 +28,6 @@ android {
 
 dependencies {
     implementation(libs.test.junit)
-    implementation(libs.test.mockk)
-    implementation(libs.test.truth)
-    implementation(libs.test.turbine)
     implementation(libs.coroutines.test)
-    implementation(projects.libraries.matrix.test)
-    implementation(projects.services.appnavstate.test)
-    implementation(projects.services.appnavstate.test)
     implementation(projects.libraries.core)
 }