Support gallery messages (#6519)

* Support gallery messages

* Address review

* Remove unused function

* Fix indent

* Add "Gallery" message prefix

* Support galleries for image editing

* Fix tapping on a tile opens the last item

* Fix overflow count

* Add caption editing to gallery messages

* Use the new gallery string for prefix

* Lock sending galleries behind a feature flag

* Fix detekts

* Fix

* Ensure image edition is saved when navigating

* Fix sending media broken on edited gallery.

* Fix tests

* Order imports

* Remove unused parameters.

* Fix copyright header of new files.

* Fix Konsist test

* Extract new previews to a dedicated file.

* Sync strings

* Remove unused import

* Update screenshots

* Trigger CI

* Remove parameters with default value.

* More cleanup

* Restore sendAsFile behavior.

* Improve Preview.

* Improve Preview.

* Improve Preview.

* Fix gallery sending cancel and retry issue

* Ensure any previous job is cancelled.

* Fix issue in summary message

* Gallery feature is disabled by default.

* Kotlin convention

* Remove useless parenthesis

* Update screenshots

* Fix test

* List -> ImmutableList

* Remove useless code.

* Render formatted caption for attachment list.

* Replace set of Booleans by an enum

* Remove unused model for individual caption in a gallery Event.

* Fix tests

* Fix tests

* Rework MediaViewer entry point.

And ensure that the clicked image from the gallery is displayed first.

* Ensure gallery item can be click in the pinned message list
Improve the gallery item click handling code.

* Improve code and fix separator color
Closes #7101

* React on attachment item click
Improve code

* Improve code and support 0 items in gallery.

* Fix click on attachment item not rendering anything.

---------

Co-authored-by: Benoit Marty <benoitm@element.io>
Co-authored-by: Benoit Marty <benoit@matrix.org>
Co-authored-by: ElementBot <android@element.io>

libraries/eventformatter/impl/src/main/kotlin/io/element/android/libraries/eventformatter/impl/DefaultPinnedMessagesBannerFormatter.kt

@@ -18,6 +18,7 @@ import io.element.android.libraries.matrix.api.timeline.item.event.AudioMessageT
 import io.element.android.libraries.matrix.api.timeline.item.event.EmoteMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.EventTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.LocationMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.MessageContent
@@ -104,6 +105,9 @@ class DefaultPinnedMessagesBannerFormatter(
             is OtherMessageType -> {
                 messageType.body
             }
+            is GalleryMessageType -> {
+                messageType.body.prefixWith(CommonStrings.common_gallery)
+            }
             is NoticeMessageType -> {
                 messageType.body
             }

libraries/eventformatter/impl/src/main/kotlin/io/element/android/libraries/eventformatter/impl/DefaultRoomLatestEventFormatter.kt

@@ -23,6 +23,7 @@ import io.element.android.libraries.matrix.api.timeline.item.event.EventContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseMessageLikeContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseStateContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.LegacyCallInviteContent
 import io.element.android.libraries.matrix.api.timeline.item.event.LiveLocationContent
@@ -167,6 +168,9 @@ class DefaultRoomLatestEventFormatter(
             is OtherMessageType -> {
                 messageType.body
             }
+            is GalleryMessageType -> {
+                messageType.body.prefixWith(sp.getString(CommonStrings.common_gallery))
+            }
             is NoticeMessageType -> {
                 messageType.body
             }

libraries/eventformatter/impl/src/test/kotlin/io/element/android/libraries/eventformatter/impl/DefaultPinnedMessagesBannerFormatterTest.kt

@@ -22,6 +22,7 @@ import io.element.android.libraries.matrix.api.timeline.item.event.EventTimeline
 import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseMessageLikeContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseStateContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.LocationMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.MembershipChange
@@ -141,6 +142,7 @@ class DefaultPinnedMessagesBannerFormatterTest : RobolectricTest() {
             AudioMessageType(body, null, null, MediaSource("url"), null),
             VoiceMessageType(body, null, null, MediaSource("url"), null, null),
             ImageMessageType(body, null, null, MediaSource("url"), null),
+            GalleryMessageType(body, null, emptyList()),
             StickerMessageType(body, null, null, MediaSource("url"), null),
             FileMessageType(body, null, null, MediaSource("url"), null),
             LocationMessageType(body, "geo:1,2", null, null),
@@ -163,6 +165,7 @@ class DefaultPinnedMessagesBannerFormatterTest : RobolectricTest() {
                 is VideoMessageType,
                 is AudioMessageType,
                 is ImageMessageType,
+                is GalleryMessageType,
                 is StickerMessageType,
                 is FileMessageType,
                 is LocationMessageType -> AnnotatedString::class.java
@@ -181,6 +184,7 @@ class DefaultPinnedMessagesBannerFormatterTest : RobolectricTest() {
                 is AudioMessageType -> "Audio: Shared body"
                 is VoiceMessageType -> "Voice message"
                 is ImageMessageType -> "Image: Shared body"
+                is GalleryMessageType -> "Gallery: Shared body"
                 is StickerMessageType -> "Sticker: Shared body"
                 is FileMessageType -> "File: Shared body"
                 is LocationMessageType -> "Shared location: Shared body"

libraries/eventformatter/impl/src/test/kotlin/io/element/android/libraries/eventformatter/impl/DefaultRoomLatestEventFormatterTest.kt

@@ -23,6 +23,7 @@ import io.element.android.libraries.matrix.api.timeline.item.event.EventContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseMessageLikeContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseStateContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.LocationMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.MembershipChange
@@ -195,6 +196,7 @@ class DefaultRoomLatestEventFormatterTest : RobolectricTest() {
             AudioMessageType(body, null, null, MediaSource("url"), null),
             VoiceMessageType(body, null, null, MediaSource("url"), null, null),
             ImageMessageType(body, null, null, MediaSource("url"), null),
+            GalleryMessageType(body, null, emptyList()),
             StickerMessageType(body, null, null, MediaSource("url"), null),
             FileMessageType(body, null, null, MediaSource("url"), null),
             LocationMessageType(body, "geo:1,2", null, null),
@@ -227,6 +229,7 @@ class DefaultRoomLatestEventFormatterTest : RobolectricTest() {
                 is AudioMessageType -> "Audio: Shared body"
                 is VoiceMessageType -> "Voice message"
                 is ImageMessageType -> "Image: Shared body"
+                is GalleryMessageType -> "Gallery: Shared body"
                 is StickerMessageType -> "Sticker: Shared body"
                 is FileMessageType -> "File: Shared body"
                 is LocationMessageType -> "Shared location"
@@ -247,6 +250,7 @@ class DefaultRoomLatestEventFormatterTest : RobolectricTest() {
                 is TextMessageType -> false
                 is NoticeMessageType -> false
                 is OtherMessageType -> false
+                is GalleryMessageType -> true
             }
             if (shouldCreateAnnotatedString) {
                 assertWithMessage("$type doesn't produce an AnnotatedString")
@@ -264,6 +268,7 @@ class DefaultRoomLatestEventFormatterTest : RobolectricTest() {
                 is AudioMessageType -> "$expectedPrefix: Audio: Shared body"
                 is VoiceMessageType -> "$expectedPrefix: Voice message"
                 is ImageMessageType -> "$expectedPrefix: Image: Shared body"
+                is GalleryMessageType -> "$expectedPrefix: Gallery: Shared body"
                 is StickerMessageType -> "$expectedPrefix: Sticker: Shared body"
                 is FileMessageType -> "$expectedPrefix: File: Shared body"
                 is LocationMessageType -> "$expectedPrefix: Shared location"
@@ -284,6 +289,7 @@ class DefaultRoomLatestEventFormatterTest : RobolectricTest() {
                 is TextMessageType -> true
                 is NoticeMessageType -> true
                 is OtherMessageType -> true
+                is GalleryMessageType -> true
             }
             if (shouldCreateAnnotatedString) {
                 assertWithMessage("$type doesn't produce an AnnotatedString")

libraries/featureflag/api/src/main/kotlin/io/element/android/libraries/featureflag/api/FeatureFlags.kt

@@ -137,4 +137,11 @@ enum class FeatureFlags(
         defaultValue = { false },
         isFinished = false,
     ),
+    SendGalleryMessages(
+        key = "feature.send_gallery_messages",
+        title = "Send gallery messages",
+        description = "Allow sending multiple media items in a single message.",
+        defaultValue = { false },
+        isFinished = false,
+    ),
 }

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.api.media
+
+import java.io.File
+
+sealed interface GalleryItemInfo {
+    val file: File
+
+    data class Image(
+        override val file: File,
+        val imageInfo: ImageInfo,
+        val thumbnailFile: File?,
+    ) : GalleryItemInfo
+
+    data class Video(
+        override val file: File,
+        val videoInfo: VideoInfo,
+        val thumbnailFile: File?,
+    ) : GalleryItemInfo
+
+    data class Audio(
+        override val file: File,
+        val audioInfo: AudioInfo,
+    ) : GalleryItemInfo
+
+    data class MediaFile(
+        override val file: File,
+        val fileInfo: FileInfo,
+    ) : GalleryItemInfo
+}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/Timeline.kt

@@ -16,6 +16,7 @@ import io.element.android.libraries.matrix.api.core.ThreadId
 import io.element.android.libraries.matrix.api.core.TransactionId
 import io.element.android.libraries.matrix.api.media.AudioInfo
 import io.element.android.libraries.matrix.api.media.FileInfo
+import io.element.android.libraries.matrix.api.media.GalleryItemInfo
 import io.element.android.libraries.matrix.api.media.ImageInfo
 import io.element.android.libraries.matrix.api.media.MediaUploadHandler
 import io.element.android.libraries.matrix.api.media.VideoInfo
@@ -157,6 +158,13 @@ interface Timeline : AutoCloseable {
         inReplyToEventId: EventId?,
     ): Result<MediaUploadHandler>
 
+    suspend fun sendGallery(
+        items: List<GalleryItemInfo>,
+        caption: String?,
+        formattedCaption: String?,
+        inReplyToEventId: EventId?,
+    ): Result<MediaUploadHandler>
+
     suspend fun redactEvent(eventOrTransactionId: EventOrTransactionId, reason: String?): Result<Unit>
 
     suspend fun toggleReaction(emoji: String, eventOrTransactionId: EventOrTransactionId): Result<Boolean>

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/item/event/MessageType.kt

@@ -102,6 +102,21 @@ data class TextMessageType(
     val formatted: FormattedBody?
 ) : MessageType
 
+data class GalleryMessageType(
+    val body: String,
+    val formatted: FormattedBody?,
+    val items: List<GalleryItemType>,
+) : MessageType
+
+@Immutable
+sealed interface GalleryItemType {
+    data class Image(val content: ImageMessageType) : GalleryItemType
+    data class Audio(val content: AudioMessageType) : GalleryItemType
+    data class Video(val content: VideoMessageType) : GalleryItemType
+    data class File(val content: FileMessageType) : GalleryItemType
+    data class Other(val itemType: String, val body: String) : GalleryItemType
+}
+
 data class OtherMessageType(
     val msgType: String,
     val body: String,

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

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.media
+
+import io.element.android.libraries.matrix.api.timeline.item.event.FormattedBody
+import org.matrix.rustcomponents.sdk.FormattedBody as RustFormattedBody
+import org.matrix.rustcomponents.sdk.MessageFormat as RustMessageFormat
+
+fun FormattedBody.map(): RustFormattedBody = RustFormattedBody(
+    format = format.map(),
+    body = body,
+)
+
+private fun io.element.android.libraries.matrix.api.timeline.item.event.MessageFormat.map(): RustMessageFormat {
+    return when (this) {
+        io.element.android.libraries.matrix.api.timeline.item.event.MessageFormat.HTML -> RustMessageFormat.Html
+        io.element.android.libraries.matrix.api.timeline.item.event.MessageFormat.UNKNOWN -> RustMessageFormat.Unknown("")
+    }
+}

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.media
+
+import io.element.android.libraries.matrix.api.media.GalleryItemInfo
+import org.matrix.rustcomponents.sdk.GalleryItemInfo as RustGalleryItemInfo
+import org.matrix.rustcomponents.sdk.UploadSource as RustUploadSource
+
+fun GalleryItemInfo.map(): RustGalleryItemInfo = when (this) {
+    is GalleryItemInfo.Image -> {
+        RustGalleryItemInfo.Image(
+            imageInfo = imageInfo.map(),
+            source = RustUploadSource.File(file.path),
+            caption = null,
+            formattedCaption = null,
+            thumbnailSource = thumbnailFile?.path?.let(RustUploadSource::File),
+        )
+    }
+    is GalleryItemInfo.Video -> {
+        RustGalleryItemInfo.Video(
+            videoInfo = videoInfo.map(),
+            source = RustUploadSource.File(file.path),
+            caption = null,
+            formattedCaption = null,
+            thumbnailSource = thumbnailFile?.path?.let(RustUploadSource::File),
+        )
+    }
+    is GalleryItemInfo.Audio -> {
+        RustGalleryItemInfo.Audio(
+            audioInfo = audioInfo.map(),
+            source = RustUploadSource.File(file.path),
+            caption = null,
+            formattedCaption = null,
+        )
+    }
+    is GalleryItemInfo.MediaFile -> {
+        RustGalleryItemInfo.File(
+            fileInfo = fileInfo.map(),
+            source = RustUploadSource.File(file.path),
+            caption = null,
+            formattedCaption = null,
+        )
+    }
+}

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.media
+
+import io.element.android.libraries.androidutils.file.safeDelete
+import io.element.android.libraries.core.extensions.runCatchingExceptions
+import io.element.android.libraries.matrix.api.media.MediaUploadHandler
+import org.matrix.rustcomponents.sdk.SendGalleryJoinHandle
+import java.io.File
+
+class GalleryMediaUploadHandlerImpl(
+    private val filesToUpload: List<File>,
+    private val sendGalleryJoinHandle: SendGalleryJoinHandle,
+) : MediaUploadHandler {
+    override suspend fun await(): Result<Unit> =
+        runCatchingExceptions {
+            sendGalleryJoinHandle.join()
+        }
+            .also { cleanUpFiles() }
+
+    override fun cancel() {
+        sendGalleryJoinHandle.cancel()
+        cleanUpFiles()
+    }
+
+    private fun cleanUpFiles() {
+        filesToUpload.forEach { file -> file.safeDelete() }
+    }
+}

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

@@ -97,7 +97,10 @@ private fun MessageLikeEventContent.toContent(senderId: UserId): NotificationCon
             is MessageLikeEventContent.ReactionContent -> NotificationContent.MessageLike.ReactionContent(relatedEventId)
             MessageLikeEventContent.RoomEncrypted -> NotificationContent.MessageLike.RoomEncrypted
             is MessageLikeEventContent.RoomMessage -> {
-                NotificationContent.MessageLike.RoomMessage(senderId, EventMessageMapper().mapMessageType(messageType))
+                NotificationContent.MessageLike.RoomMessage(
+                    senderId,
+                    EventMessageMapper().mapMessageType(messageType)
+                )
             }
             is MessageLikeEventContent.RoomRedaction -> NotificationContent.MessageLike.RoomRedaction(
                 redactedEventId = redactedEventId?.let(::EventId),

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

@@ -219,6 +219,7 @@ class JoinedRustRoom(
                     RoomMessageEventMessageType.IMAGE,
                     RoomMessageEventMessageType.VIDEO,
                     RoomMessageEventMessageType.AUDIO,
+                    RoomMessageEventMessageType.GALLERY,
                 )
             )
             is CreateTimelineParams.Focused,

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

@@ -15,6 +15,7 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.media.AudioInfo
 import io.element.android.libraries.matrix.api.media.FileInfo
+import io.element.android.libraries.matrix.api.media.GalleryItemInfo
 import io.element.android.libraries.matrix.api.media.ImageInfo
 import io.element.android.libraries.matrix.api.media.MediaUploadHandler
 import io.element.android.libraries.matrix.api.media.VideoInfo
@@ -30,6 +31,7 @@ import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.api.timeline.TimelineException
 import io.element.android.libraries.matrix.api.timeline.item.event.EventOrTransactionId
 import io.element.android.libraries.matrix.api.timeline.item.event.InReplyTo
+import io.element.android.libraries.matrix.impl.media.GalleryMediaUploadHandlerImpl
 import io.element.android.libraries.matrix.impl.media.MediaUploadHandlerImpl
 import io.element.android.libraries.matrix.impl.media.map
 import io.element.android.libraries.matrix.impl.poll.toInner
@@ -67,6 +69,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.EditedContent
 import org.matrix.rustcomponents.sdk.FormattedBody
+import org.matrix.rustcomponents.sdk.GalleryUploadParameters
 import org.matrix.rustcomponents.sdk.MessageFormat
 import org.matrix.rustcomponents.sdk.PollData
 import org.matrix.rustcomponents.sdk.SendAttachmentJoinHandle
@@ -535,6 +538,42 @@ class RustTimeline(
         }
     }
 
+    override suspend fun sendGallery(
+        items: List<GalleryItemInfo>,
+        caption: String?,
+        formattedCaption: String?,
+        inReplyToEventId: EventId?,
+    ): Result<MediaUploadHandler> {
+        Timber.d("Sending gallery with ${items.size} items")
+        val allFiles = items.flatMap { item ->
+            when (item) {
+                is GalleryItemInfo.Image -> listOfNotNull(item.file, item.thumbnailFile)
+                is GalleryItemInfo.Video -> listOfNotNull(item.file, item.thumbnailFile)
+                is GalleryItemInfo.Audio -> listOf(item.file)
+                is GalleryItemInfo.MediaFile -> listOf(item.file)
+            }
+        }
+        return sendGalleryAttachment(allFiles) {
+            inner.sendGallery(
+                params = GalleryUploadParameters(
+                    caption = caption,
+                    formattedCaption = formattedCaption?.let {
+                        FormattedBody(body = it, format = MessageFormat.Html)
+                    },
+                    mentions = null,
+                    inReplyTo = inReplyToEventId?.value,
+                ),
+                itemInfos = items.map { it.map() },
+            )
+        }
+    }
+
+    private fun sendGalleryAttachment(files: List<File>, handle: () -> org.matrix.rustcomponents.sdk.SendGalleryJoinHandle): Result<MediaUploadHandler> {
+        return runCatchingExceptions {
+            GalleryMediaUploadHandlerImpl(files, handle())
+        }
+    }
+
     override suspend fun createPoll(
         question: String,
         answers: List<String>,

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/item/event/EventMessageMapper.kt

@@ -13,6 +13,8 @@ import io.element.android.libraries.matrix.api.timeline.item.event.AudioMessageT
 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.FormattedBody
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryItemType
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.InReplyTo
 import io.element.android.libraries.matrix.api.timeline.item.event.LocationMessageType
@@ -31,12 +33,10 @@ import org.matrix.rustcomponents.sdk.MessageType
 import org.matrix.rustcomponents.sdk.MsgLikeKind
 import org.matrix.rustcomponents.sdk.use
 import org.matrix.rustcomponents.sdk.FormattedBody as RustFormattedBody
+import org.matrix.rustcomponents.sdk.GalleryItemType as RustGalleryItemType
 import org.matrix.rustcomponents.sdk.MessageFormat as RustMessageFormat
 import org.matrix.rustcomponents.sdk.MessageType as RustMessageType
 
-// https://github.com/Johennes/matrix-spec-proposals/blob/johannes/msgtype-galleries/proposals/4274-inline-media-galleries.md#unstable-prefix
-private const val MSG_TYPE_GALLERY_UNSTABLE = "dm.filament.gallery"
-
 class EventMessageMapper {
     private val inReplyToMapper by lazy { InReplyToMapper(TimelineEventContentMapper()) }
 
@@ -124,8 +124,64 @@ class EventMessageMapper {
             OtherMessageType(type.msgtype, type.body)
         }
         is MessageType.Gallery -> {
-            // TODO expose the GalleryType.
-            OtherMessageType(MSG_TYPE_GALLERY_UNSTABLE, type.content.body)
+            GalleryMessageType(
+                body = type.content.body,
+                formatted = type.content.formatted?.map(),
+                items = type.content.itemtypes.map { mapGalleryItemType(it) },
+            )
+        }
+    }
+
+    private fun mapGalleryItemType(type: RustGalleryItemType): GalleryItemType = when (type) {
+        is RustGalleryItemType.Image -> {
+            GalleryItemType.Image(
+                content = ImageMessageType(
+                    filename = type.content.filename,
+                    caption = type.content.caption,
+                    formattedCaption = type.content.formattedCaption?.map(),
+                    source = type.content.source.map(),
+                    info = type.content.info?.map(),
+                )
+            )
+        }
+        is RustGalleryItemType.Audio -> {
+            GalleryItemType.Audio(
+                content = AudioMessageType(
+                    filename = type.content.filename,
+                    caption = type.content.caption,
+                    formattedCaption = type.content.formattedCaption?.map(),
+                    source = type.content.source.map(),
+                    info = type.content.info?.map(),
+                )
+            )
+        }
+        is RustGalleryItemType.Video -> {
+            GalleryItemType.Video(
+                content = VideoMessageType(
+                    filename = type.content.filename,
+                    caption = type.content.caption,
+                    formattedCaption = type.content.formattedCaption?.map(),
+                    source = type.content.source.map(),
+                    info = type.content.info?.map(),
+                )
+            )
+        }
+        is RustGalleryItemType.File -> {
+            GalleryItemType.File(
+                content = FileMessageType(
+                    filename = type.content.filename,
+                    caption = type.content.caption,
+                    formattedCaption = type.content.formattedCaption?.map(),
+                    source = type.content.source.map(),
+                    info = type.content.info?.map(),
+                )
+            )
+        }
+        is RustGalleryItemType.Other -> {
+            GalleryItemType.Other(
+                itemType = type.itemtype,
+                body = type.body,
+            )
         }
     }
 }

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

@@ -13,6 +13,7 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.TransactionId
 import io.element.android.libraries.matrix.api.media.AudioInfo
 import io.element.android.libraries.matrix.api.media.FileInfo
+import io.element.android.libraries.matrix.api.media.GalleryItemInfo
 import io.element.android.libraries.matrix.api.media.ImageInfo
 import io.element.android.libraries.matrix.api.media.MediaUploadHandler
 import io.element.android.libraries.matrix.api.media.VideoInfo
@@ -293,6 +294,29 @@ class FakeTimeline(
         )
     }
 
+    var sendGalleryLambda: (
+        items: List<GalleryItemInfo>,
+        caption: String?,
+        formattedCaption: String?,
+        inReplyToEventId: EventId?,
+    ) -> Result<MediaUploadHandler> = { _, _, _, _ ->
+        Result.success(FakeMediaUploadHandler())
+    }
+
+    override suspend fun sendGallery(
+        items: List<GalleryItemInfo>,
+        caption: String?,
+        formattedCaption: String?,
+        inReplyToEventId: EventId?,
+    ): Result<MediaUploadHandler> = simulateLongTask {
+        sendGalleryLambda(
+            items,
+            caption,
+            formattedCaption,
+            inReplyToEventId,
+        )
+    }
+
     var sendLocationLambda: (
         body: String,
         geoUri: String,

libraries/mediapickers/api/src/main/kotlin/io/element/android/libraries/mediapickers/api/PickerProvider.kt

@@ -23,12 +23,23 @@ interface PickerProvider {
         onResult: (Uri?) -> Unit
     ): PickerLauncher<PickVisualMediaRequest, Uri?>
 
+    @Composable
+    fun registerGalleryMultiPicker(
+        onResult: (uris: List<Uri>) -> Unit
+    ): PickerLauncher<PickVisualMediaRequest, List<Uri>>
+
     @Composable
     fun registerFilePicker(
         mimeType: String,
         onResult: (uri: Uri?, mimeType: String?) -> Unit,
     ): PickerLauncher<String, Uri?>
 
+    @Composable
+    fun registerFileMultiPicker(
+        mimeType: String,
+        onResult: (uris: List<Uri>) -> Unit,
+    ): PickerLauncher<Array<String>, List<Uri>>
+
     @Composable
     fun registerCameraPhotoPicker(onResult: (Uri?) -> Unit): PickerLauncher<Uri, Boolean>
 

libraries/mediapickers/api/src/main/kotlin/io/element/android/libraries/mediapickers/api/PickerType.kt

@@ -15,6 +15,9 @@ import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.runtime.Immutable
 import io.element.android.libraries.core.mimetype.MimeTypes
 
+// As per MSC4274, the recommended item cap is 60.
+private const val MAX_GALLERY_ITEMS = 60
+
 @Immutable
 sealed interface PickerType<Input, Output> {
     fun getContract(): ActivityResultContract<Input, Output>
@@ -34,6 +37,13 @@ sealed interface PickerType<Input, Output> {
         }
     }
 
+    data object ImageAndVideoMulti : PickerType<PickVisualMediaRequest, List<Uri>> {
+        override fun getContract() = ActivityResultContracts.PickMultipleVisualMedia(MAX_GALLERY_ITEMS)
+        override fun getDefaultRequest(): PickVisualMediaRequest {
+            return PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageAndVideo)
+        }
+    }
+
     object Camera {
         data class Photo(val destUri: Uri) : PickerType<Uri, Boolean> {
             override fun getContract() = ActivityResultContracts.TakePicture()
@@ -56,4 +66,13 @@ sealed interface PickerType<Input, Output> {
             return mimeType
         }
     }
+
+    data class FileMulti(val mimeType: String = MimeTypes.Any) : PickerType<Array<String>, List<Uri>> {
+        override fun getContract(): ActivityResultContract<Array<String>, List<Uri>> {
+            return ActivityResultContracts.OpenMultipleDocuments()
+        }
+        override fun getDefaultRequest(): Array<String> {
+            return arrayOf(mimeType)
+        }
+    }
 }

libraries/mediapickers/impl/src/main/kotlin/io/element/android/libraries/mediapickers/impl/DefaultPickerProvider.kt

@@ -80,6 +80,23 @@ class DefaultPickerProvider(
         }
     }
 
+    /**
+     * Remembers and returns a [PickerLauncher] for selecting multiple gallery items (images/videos).
+     * [onResult] will be called with the list of selected file [Uri]s.
+     */
+    @Composable
+    override fun registerGalleryMultiPicker(
+        onResult: (uris: List<Uri>) -> Unit
+    ): PickerLauncher<PickVisualMediaRequest, List<Uri>> {
+        return if (LocalInspectionMode.current) {
+            NoOpPickerLauncher { onResult(emptyList()) }
+        } else {
+            rememberPickerLauncher(type = PickerType.ImageAndVideoMulti) { uris ->
+                onResult(uris)
+            }
+        }
+    }
+
     /**
      * Remembers and returns a [PickerLauncher] for a file of a certain [mimeType] (any type of file, by default).
      * [onResult] will be called with either the selected file's [Uri] or `null` if nothing was selected.
@@ -100,6 +117,24 @@ class DefaultPickerProvider(
         }
     }
 
+    /**
+     * Remembers and returns a [PickerLauncher] for selecting multiple files of a certain [mimeType].
+     * [onResult] will be called with the list of selected file URIs.
+     */
+    @Composable
+    override fun registerFileMultiPicker(
+        mimeType: String,
+        onResult: (uris: List<Uri>) -> Unit,
+    ): PickerLauncher<Array<String>, List<Uri>> {
+        return if (LocalInspectionMode.current) {
+            NoOpPickerLauncher { onResult(emptyList()) }
+        } else {
+            rememberPickerLauncher(type = PickerType.FileMulti(mimeType)) { uris ->
+                onResult(uris)
+            }
+        }
+    }
+
     /**
      * Remembers and returns a [PickerLauncher] for taking a photo with a camera app.
      * @param [onResult] will be called with either the photo's [Uri] or `null` if nothing was selected.
@@ -113,7 +148,6 @@ class DefaultPickerProvider(
             val tmpFile = remember { getTemporaryFile("photo.jpg") }
             val tmpFileUri = remember(tmpFile) { getTemporaryUri(tmpFile) }
             rememberPickerLauncher(type = PickerType.Camera.Photo(tmpFileUri)) { success ->
-                // Execute callback
                 onResult(if (success) tmpFileUri else null)
             }
         }
@@ -125,7 +159,6 @@ class DefaultPickerProvider(
      */
     @Composable
     override fun registerCameraVideoPicker(onResult: (Uri?) -> Unit): PickerLauncher<Uri, Boolean> {
-        // Tests and UI preview can't handle Context or FileProviders, so we might as well disable the whole picker
         return if (LocalInspectionMode.current) {
             NoOpPickerLauncher { onResult(null) }
         } else {

libraries/mediapickers/test/src/main/kotlin/io/element/android/libraries/mediapickers/test/FakePickerProvider.kt

@@ -30,11 +30,21 @@ class FakePickerProvider : PickerProvider {
         return NoOpPickerLauncher { onResult(result) }
     }
 
+    @Composable
+    override fun registerGalleryMultiPicker(onResult: (uris: List<Uri>) -> Unit): PickerLauncher<PickVisualMediaRequest, List<Uri>> {
+        return NoOpPickerLauncher { onResult(result?.let { listOf(it) } ?: emptyList()) }
+    }
+
     @Composable
     override fun registerFilePicker(mimeType: String, onResult: (Uri?, String?) -> Unit): PickerLauncher<String, Uri?> {
         return NoOpPickerLauncher { onResult(result, this.mimeType) }
     }
 
+    @Composable
+    override fun registerFileMultiPicker(mimeType: String, onResult: (uris: List<Uri>) -> Unit): PickerLauncher<Array<String>, List<Uri>> {
+        return NoOpPickerLauncher { onResult(result?.let { listOf(it) } ?: emptyList()) }
+    }
+
     @Composable
     override fun registerCameraPhotoPicker(onResult: (Uri?) -> Unit): PickerLauncher<Uri, Boolean> {
         return NoOpPickerLauncher { onResult(result) }

libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaSender.kt

@@ -61,5 +61,12 @@ interface MediaSender {
         inReplyToEventId: EventId? = null,
     ): Result<Unit>
 
+    suspend fun sendGallery(
+        mediaUploadInfos: List<MediaUploadInfo>,
+        caption: String?,
+        formattedCaption: String?,
+        inReplyToEventId: EventId?,
+    ): Result<Unit>
+
     fun cleanUp()
 }

libraries/mediaupload/api/src/main/kotlin/io/element/android/libraries/mediaupload/api/MediaUploadInfo.kt

@@ -10,6 +10,7 @@ package io.element.android.libraries.mediaupload.api
 
 import io.element.android.libraries.matrix.api.media.AudioInfo
 import io.element.android.libraries.matrix.api.media.FileInfo
+import io.element.android.libraries.matrix.api.media.GalleryItemInfo
 import io.element.android.libraries.matrix.api.media.ImageInfo
 import io.element.android.libraries.matrix.api.media.VideoInfo
 import java.io.File
@@ -31,3 +32,30 @@ fun MediaUploadInfo.allFiles(): List<File> {
         (this@allFiles as? MediaUploadInfo.Video)?.thumbnailFile,
     )
 }
+
+fun MediaUploadInfo.toGalleryItemInfo(): GalleryItemInfo {
+    return when (this) {
+        is MediaUploadInfo.Image -> GalleryItemInfo.Image(
+            file = file,
+            imageInfo = imageInfo,
+            thumbnailFile = thumbnailFile,
+        )
+        is MediaUploadInfo.Video -> GalleryItemInfo.Video(
+            file = file,
+            videoInfo = videoInfo,
+            thumbnailFile = thumbnailFile,
+        )
+        is MediaUploadInfo.Audio -> GalleryItemInfo.Audio(
+            file = file,
+            audioInfo = audioInfo,
+        )
+        is MediaUploadInfo.VoiceMessage -> GalleryItemInfo.Audio(
+            file = file,
+            audioInfo = audioInfo,
+        )
+        is MediaUploadInfo.AnyFile -> GalleryItemInfo.MediaFile(
+            file = file,
+            fileInfo = fileInfo,
+        )
+    }
+}

libraries/mediaupload/impl/src/main/kotlin/io/element/android/libraries/mediaupload/impl/DefaultMediaSender.kt

@@ -27,6 +27,7 @@ import io.element.android.libraries.mediaupload.api.MediaSender
 import io.element.android.libraries.mediaupload.api.MediaSenderFactory
 import io.element.android.libraries.mediaupload.api.MediaSenderRoomFactory
 import io.element.android.libraries.mediaupload.api.MediaUploadInfo
+import io.element.android.libraries.mediaupload.api.toGalleryItemInfo
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Job
 import timber.log.Timber
@@ -167,6 +168,29 @@ class DefaultMediaSender(
             .handleSendResult(mediaId(uri))
     }
 
+    override suspend fun sendGallery(
+        mediaUploadInfos: List<MediaUploadInfo>,
+        caption: String?,
+        formattedCaption: String?,
+        inReplyToEventId: EventId?,
+    ): Result<Unit> {
+        val galleryLogId = "gallery[${mediaUploadInfos.size} items]"
+        Timber.d("Sending $galleryLogId")
+        return getTimeline().flatMap { timeline ->
+            val galleryItems = mediaUploadInfos.map { it.toGalleryItemInfo() }
+            timeline.sendGallery(
+                items = galleryItems,
+                caption = caption,
+                formattedCaption = formattedCaption,
+                inReplyToEventId = inReplyToEventId,
+            )
+        }
+            .flatMapCatching { uploadHandler ->
+                uploadHandler.await()
+            }
+            .handleSendResult(galleryLogId)
+    }
+
     private fun Result<Unit>.handleSendResult(mediaId: String) = this
         .onFailure { error ->
             val job = ongoingUploadJobs.remove(Job)

libraries/mediaupload/test/src/main/kotlin/io/element/android/libraries/mediaupload/test/FakeMediaSender.kt

@@ -19,6 +19,7 @@ class FakeMediaSender(
     private val sendPreProcessedMediaResult: () -> Result<Unit> = { lambdaError() },
     private val sendMediaResult: () -> Result<Unit> = { lambdaError() },
     private val sendVoiceMessageResult: () -> Result<Unit> = { lambdaError() },
+    private val sendGalleryResult: () -> Result<Unit> = { lambdaError() },
     private val cleanUpResult: () -> Unit = { lambdaError() },
 ) : MediaSender {
     override suspend fun preProcessMedia(
@@ -58,6 +59,15 @@ class FakeMediaSender(
         return sendVoiceMessageResult()
     }
 
+    override suspend fun sendGallery(
+        mediaUploadInfos: List<MediaUploadInfo>,
+        caption: String?,
+        formattedCaption: String?,
+        inReplyToEventId: EventId?,
+    ): Result<Unit> {
+        return sendGalleryResult()
+    }
+
     override fun cleanUp() {
         cleanUpResult()
     }

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.mediaviewer.api
+
+import android.os.Parcelable
+import io.element.android.libraries.matrix.api.media.MediaSource
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+data class GalleryItemData(
+    val filename: String,
+    val mimeType: String,
+    val mediaSource: MediaSource,
+    val thumbnailSource: MediaSource?,
+    val type: Type,
+) : Parcelable {
+    enum class Type {
+        Image,
+        Video,
+        Audio,
+        File,
+    }
+}

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

@@ -13,6 +13,24 @@ import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.matrix.api.core.UserId
 import kotlinx.parcelize.Parcelize
 
+@Parcelize
+data class GalleryInfo(
+    val caption: String?,
+    val formattedCaption: CharSequence? = null,
+    val senderId: UserId?,
+    val senderName: String?,
+    val senderAvatar: String?,
+    val dateSent: String?,
+    val dateSentFull: String?,
+    val initialIndex: Int,
+    val isAttachment: Boolean,
+) : Parcelable
+
+@Parcelize
+data class AvatarInfo(
+    val filename: String,
+) : Parcelable
+
 @Parcelize
 data class MediaInfo(
     val filename: String,

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

@@ -35,19 +35,29 @@ interface MediaViewerEntryPoint : FeatureEntryPoint {
         fun forwardEvent(eventId: EventId, fromPinnedEvents: Boolean)
     }
 
-    data class Params(
-        val mode: MediaViewerMode,
-        val eventId: EventId?,
-        val mediaInfo: MediaInfo,
-        val mediaSource: MediaSource,
-        val thumbnailSource: MediaSource?,
-        val canShowInfo: Boolean,
-    ) : NodeInputs
+    sealed interface Params : NodeInputs {
+        data class RoomMedia(
+            val mode: MediaViewerMode,
+            val eventId: EventId?,
+            val mediaInfo: MediaInfo,
+            val mediaSource: MediaSource,
+            val thumbnailSource: MediaSource?,
+        ) : Params
+
+        data class EventGallery(
+            val eventId: EventId?,
+            val galleryInfo: GalleryInfo,
+            val galleryItems: List<GalleryItemData>,
+        ) : Params
+
+        data class Avatar(
+            val avatarInfo: AvatarInfo,
+            val mediaSource: MediaSource,
+            val thumbnailSource: MediaSource?,
+        ) : Params
+    }
 
     sealed interface MediaViewerMode : Parcelable {
-        @Parcelize
-        data object SingleMedia : MediaViewerMode
-
         @Parcelize
         data class TimelineImagesAndVideos(val timelineMode: Timeline.Mode) : MediaViewerMode
 

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/DefaultMediaViewerEntryPoint.kt

@@ -13,40 +13,20 @@ import com.bumble.appyx.core.node.Node
 import dev.zacsweers.metro.AppScope
 import dev.zacsweers.metro.ContributesBinding
 import io.element.android.libraries.architecture.createNode
-import io.element.android.libraries.core.mimetype.MimeTypes
-import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.media.MediaSource
-import io.element.android.libraries.mediaviewer.api.MediaInfo
+import io.element.android.libraries.mediaviewer.api.AvatarInfo
 import io.element.android.libraries.mediaviewer.api.MediaViewerEntryPoint
 import io.element.android.libraries.mediaviewer.impl.viewer.MediaViewerNode
 
 @ContributesBinding(AppScope::class)
 class DefaultMediaViewerEntryPoint : MediaViewerEntryPoint {
     override fun createParamsForAvatar(filename: String, avatarUrl: String): MediaViewerEntryPoint.Params {
-        // We need to fake the MimeType here for the viewer to work.
-        val mimeType = MimeTypes.Images
-        return MediaViewerEntryPoint.Params(
-            mode = MediaViewerEntryPoint.MediaViewerMode.SingleMedia,
-            eventId = null,
-            mediaInfo = MediaInfo(
+        return MediaViewerEntryPoint.Params.Avatar(
+            avatarInfo = AvatarInfo(
                 filename = filename,
-                fileSize = null,
-                caption = null,
-                formattedCaption = null,
-                mimeType = mimeType,
-                formattedFileSize = "",
-                fileExtension = "",
-                senderId = UserId("@dummy:server.org"),
-                senderName = null,
-                senderAvatar = null,
-                dateSent = null,
-                dateSentFull = null,
-                waveform = null,
-                duration = null,
             ),
             mediaSource = MediaSource(url = avatarUrl),
             thumbnailSource = null,
-            canShowInfo = false,
         )
     }
 

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/datasource/EventItemFactory.kt

@@ -13,6 +13,7 @@ import io.element.android.libraries.androidutils.filesize.FileSizeFormatter
 import io.element.android.libraries.dateformatter.api.DateFormatter
 import io.element.android.libraries.dateformatter.api.DateFormatterMode
 import io.element.android.libraries.dateformatter.api.toHumanReadableDuration
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.event.AudioMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.CallNotifyContent
@@ -20,6 +21,8 @@ import io.element.android.libraries.matrix.api.timeline.item.event.EmoteMessageT
 import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseMessageLikeContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseStateContent
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryItemType
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.LegacyCallInviteContent
 import io.element.android.libraries.matrix.api.timeline.item.event.LiveLocationContent
@@ -54,7 +57,7 @@ class EventItemFactory(
 ) {
     fun create(
         currentTimelineItem: MatrixTimelineItem.Event,
-    ): MediaItem.Event? {
+    ): List<MediaItem.Event> {
         val event = currentTimelineItem.event
         val dateSent = dateFormatter.format(
             currentTimelineItem.event.timestamp,
@@ -79,7 +82,7 @@ class EventItemFactory(
             is LiveLocationContent,
             UnknownContent -> {
                 Timber.w("Should not happen: ${content.javaClass.simpleName}")
-                null
+                emptyList()
             }
             is MessageContent -> {
                 when (val type = content.type) {
@@ -89,9 +92,93 @@ class EventItemFactory(
                     is LocationMessageType,
                     is TextMessageType -> {
                         Timber.w("Should not happen: ${content.type}")
-                        null
+                        emptyList()
                     }
-                    is AudioMessageType -> MediaItem.Audio(
+                    is GalleryMessageType -> {
+                        val baseId = currentTimelineItem.uniqueId.value
+                        type.items.mapIndexedNotNull { index, galleryItem ->
+                            val id = UniqueId("${baseId}_$index")
+                            when (galleryItem) {
+                                is GalleryItemType.Image -> {
+                                    val c = galleryItem.content
+                                    MediaItem.Image(
+                                        id = id,
+                                        eventId = currentTimelineItem.eventId,
+                                        mediaInfo = createMediaInfo(
+                                            filename = c.filename,
+                                            fileSize = c.info?.size,
+                                            caption = c.caption,
+                                            mimeType = c.info?.mimetype.orEmpty(),
+                                            fileExtension = c.filename,
+                                            event = event,
+                                            dateSent = dateSent,
+                                            dateSentFull = dateSentFull,
+                                        ),
+                                        mediaSource = c.source,
+                                        thumbnailSource = c.info?.thumbnailSource,
+                                    )
+                                }
+                                is GalleryItemType.Video -> {
+                                    val c = galleryItem.content
+                                    MediaItem.Video(
+                                        id = id,
+                                        eventId = currentTimelineItem.eventId,
+                                        mediaInfo = createMediaInfo(
+                                            filename = c.filename,
+                                            fileSize = c.info?.size,
+                                            caption = c.caption,
+                                            mimeType = c.info?.mimetype.orEmpty(),
+                                            fileExtension = c.filename,
+                                            event = event,
+                                            dateSent = dateSent,
+                                            dateSentFull = dateSentFull,
+                                            duration = c.info?.duration?.inWholeMilliseconds?.toHumanReadableDuration(),
+                                        ),
+                                        mediaSource = c.source,
+                                        thumbnailSource = c.info?.thumbnailSource,
+                                    )
+                                }
+                                is GalleryItemType.Audio -> {
+                                    val c = galleryItem.content
+                                    MediaItem.Audio(
+                                        id = id,
+                                        eventId = currentTimelineItem.eventId,
+                                        mediaInfo = createMediaInfo(
+                                            filename = c.filename,
+                                            fileSize = c.info?.size,
+                                            caption = c.caption,
+                                            mimeType = c.info?.mimetype.orEmpty(),
+                                            fileExtension = c.filename,
+                                            event = event,
+                                            dateSent = dateSent,
+                                            dateSentFull = dateSentFull,
+                                        ),
+                                        mediaSource = c.source,
+                                    )
+                                }
+                                is GalleryItemType.File -> {
+                                    val c = galleryItem.content
+                                    MediaItem.File(
+                                        id = id,
+                                        eventId = currentTimelineItem.eventId,
+                                        mediaInfo = createMediaInfo(
+                                            filename = c.filename,
+                                            fileSize = c.info?.size,
+                                            caption = c.caption,
+                                            mimeType = c.info?.mimetype.orEmpty(),
+                                            fileExtension = c.filename,
+                                            event = event,
+                                            dateSent = dateSent,
+                                            dateSentFull = dateSentFull,
+                                        ),
+                                        mediaSource = c.source,
+                                    )
+                                }
+                                is GalleryItemType.Other -> null
+                            }
+                        }
+                    }
+                    is AudioMessageType -> listOf(MediaItem.Audio(
                         id = currentTimelineItem.uniqueId,
                         eventId = currentTimelineItem.eventId,
                         mediaInfo = MediaInfo(
@@ -111,8 +198,8 @@ class EventItemFactory(
                             duration = null,
                         ),
                         mediaSource = type.source,
-                    )
-                    is FileMessageType -> MediaItem.File(
+                    ))
+                    is FileMessageType -> listOf(MediaItem.File(
                         id = currentTimelineItem.uniqueId,
                         eventId = currentTimelineItem.eventId,
                         mediaInfo = MediaInfo(
@@ -133,8 +220,8 @@ class EventItemFactory(
                         ),
                         mediaSource = type.source,
                         // TODO We may want to add a thumbnailSource and set it to type.info?.thumbnailSource
-                    )
-                    is ImageMessageType -> MediaItem.Image(
+                    ))
+                    is ImageMessageType -> listOf(MediaItem.Image(
                         id = currentTimelineItem.uniqueId,
                         eventId = currentTimelineItem.eventId,
                         mediaInfo = MediaInfo(
@@ -155,8 +242,8 @@ class EventItemFactory(
                         ),
                         mediaSource = type.source,
                         thumbnailSource = type.info?.thumbnailSource,
-                    )
-                    is StickerMessageType -> MediaItem.Image(
+                    ))
+                    is StickerMessageType -> listOf(MediaItem.Image(
                         id = currentTimelineItem.uniqueId,
                         eventId = currentTimelineItem.eventId,
                         mediaInfo = MediaInfo(
@@ -177,8 +264,8 @@ class EventItemFactory(
                         ),
                         mediaSource = type.source,
                         thumbnailSource = type.info?.thumbnailSource,
-                    )
-                    is VideoMessageType -> MediaItem.Video(
+                    ))
+                    is VideoMessageType -> listOf(MediaItem.Video(
                         id = currentTimelineItem.uniqueId,
                         eventId = currentTimelineItem.eventId,
                         mediaInfo = MediaInfo(
@@ -199,8 +286,8 @@ class EventItemFactory(
                         ),
                         mediaSource = type.source,
                         thumbnailSource = type.info?.thumbnailSource,
-                    )
-                    is VoiceMessageType -> MediaItem.Voice(
+                    ))
+                    is VoiceMessageType -> listOf(MediaItem.Voice(
                         id = currentTimelineItem.uniqueId,
                         eventId = currentTimelineItem.eventId,
                         mediaInfo = MediaInfo(
@@ -220,9 +307,36 @@ class EventItemFactory(
                             duration = type.info?.duration?.inWholeMilliseconds?.toHumanReadableDuration(),
                         ),
                         mediaSource = type.source,
-                    )
+                    ))
                 }
             }
         }
     }
+
+    private fun createMediaInfo(
+        filename: String,
+        fileSize: Long?,
+        caption: String?,
+        mimeType: String,
+        fileExtension: String,
+        event: io.element.android.libraries.matrix.api.timeline.item.event.EventTimelineItem,
+        dateSent: String,
+        dateSentFull: String,
+        waveform: List<Float>? = null,
+        duration: String? = null,
+    ) = MediaInfo(
+        filename = filename,
+        fileSize = fileSize,
+        caption = caption,
+        mimeType = mimeType,
+        formattedFileSize = fileSize?.let { fileSizeFormatter.format(it) }.orEmpty(),
+        fileExtension = fileExtensionExtractor.extractFromName(fileExtension),
+        senderId = event.sender,
+        senderName = event.senderProfile.getDisambiguatedDisplayName(event.sender),
+        senderAvatar = event.senderProfile.getAvatarUrl(),
+        dateSent = dateSent,
+        dateSentFull = dateSentFull,
+        waveform = waveform,
+        duration = duration,
+    )
 }

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/datasource/TimelineMediaItemsFactory.kt

@@ -9,10 +9,8 @@
 package io.element.android.libraries.mediaviewer.impl.datasource
 
 import dev.zacsweers.metro.Inject
-import io.element.android.libraries.androidutils.diff.DefaultDiffCacheInvalidator
-import io.element.android.libraries.androidutils.diff.DiffCacheUpdater
-import io.element.android.libraries.androidutils.diff.MutableListDiffCache
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.mediaviewer.impl.model.MediaItem
 import kotlinx.collections.immutable.ImmutableList
@@ -32,18 +30,8 @@ class TimelineMediaItemsFactory(
 ) {
     private val _timelineItems = MutableSharedFlow<ImmutableList<MediaItem>>(replay = 1)
     private val lock = Mutex()
-    private val diffCache = MutableListDiffCache<MediaItem>()
-    private val diffCacheUpdater = DiffCacheUpdater<MatrixTimelineItem, MediaItem>(
-        diffCache = diffCache,
-        detectMoves = false,
-        cacheInvalidator = DefaultDiffCacheInvalidator()
-    ) { old, new ->
-        if (old is MatrixTimelineItem.Event && new is MatrixTimelineItem.Event) {
-            old.uniqueId == new.uniqueId
-        } else {
-            false
-        }
-    }
+    private val cache = mutableMapOf<UniqueId, List<MediaItem>>()
+    private var previousTimelineItems: List<MatrixTimelineItem> = emptyList()
 
     val timelineItems: Flow<ImmutableList<MediaItem>> = _timelineItems.distinctUntilChanged()
 
@@ -51,39 +39,42 @@ class TimelineMediaItemsFactory(
         timelineItems: List<MatrixTimelineItem>,
     ) = withContext(dispatchers.computation) {
         lock.withLock {
-            diffCacheUpdater.updateWith(timelineItems)
-            buildAndEmitTimelineItemStates(timelineItems)
-        }
-    }
-
-    private suspend fun buildAndEmitTimelineItemStates(
-        timelineItems: List<MatrixTimelineItem>,
-    ) {
-        val newTimelineItemStates = ArrayList<MediaItem>()
-        for (index in diffCache.indices().reversed()) {
-            val cacheItem = diffCache.get(index)
-            if (cacheItem == null) {
-                buildAndCacheItem(timelineItems, index)?.also { timelineItemState ->
-                    newTimelineItemStates.add(timelineItemState)
+            val newTimelineItemStates = ArrayList<MediaItem>()
+            for (index in timelineItems.indices.reversed()) {
+                when (val currentTimelineItem = timelineItems[index]) {
+                    is MatrixTimelineItem.Event -> {
+                        val cachedItems = cache[currentTimelineItem.uniqueId]
+                        val items = if (cachedItems != null && isItemUnchanged(currentTimelineItem, previousTimelineItems)) {
+                            cachedItems
+                        } else {
+                            eventItemFactory.create(currentTimelineItem).also { newItems ->
+                                cache[currentTimelineItem.uniqueId] = newItems
+                            }
+                        }
+                        newTimelineItemStates.addAll(items.asReversed())
+                    }
+                    is MatrixTimelineItem.Virtual -> {
+                        virtualItemFactory.create(currentTimelineItem)?.also {
+                            newTimelineItemStates.add(it)
+                        }
+                    }
+                    MatrixTimelineItem.Other -> Unit
                 }
-            } else {
-                newTimelineItemStates.add(cacheItem)
             }
+            previousTimelineItems = timelineItems
+            _timelineItems.emit(newTimelineItemStates.toImmutableList())
         }
-        _timelineItems.emit(newTimelineItemStates.toImmutableList())
     }
 
-    private fun buildAndCacheItem(
-        timelineItems: List<MatrixTimelineItem>,
-        index: Int,
-    ): MediaItem? {
-        val timelineItem =
-            when (val currentTimelineItem = timelineItems[index]) {
-                is MatrixTimelineItem.Event -> eventItemFactory.create(currentTimelineItem)
-                is MatrixTimelineItem.Virtual -> virtualItemFactory.create(currentTimelineItem)
-                MatrixTimelineItem.Other -> null
-            }
-        diffCache[index] = timelineItem
-        return timelineItem
+    private fun isItemUnchanged(
+        currentTimelineItem: MatrixTimelineItem.Event,
+        previousItems: List<MatrixTimelineItem>,
+    ): Boolean {
+        if (previousItems.isEmpty()) return false
+        val previousIndex = previousItems.indexOfFirst { it is MatrixTimelineItem.Event && it.uniqueId == currentTimelineItem.uniqueId }
+        if (previousIndex < 0) return false
+        val previousItem = previousItems[previousIndex] as? MatrixTimelineItem.Event ?: return false
+        return previousItem.event.eventId == currentTimelineItem.event.eventId &&
+               previousItem.event.timestamp == currentTimelineItem.event.timestamp
     }
 }

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/gallery/root/MediaGalleryFlowNode.kt

@@ -128,13 +128,12 @@ class MediaGalleryFlowNode(
                 mediaViewerEntryPoint.createNode(
                     parentNode = this,
                     buildContext = buildContext,
-                    params = MediaViewerEntryPoint.Params(
+                    params = MediaViewerEntryPoint.Params.RoomMedia(
                         mode = navTarget.mode,
                         eventId = navTarget.eventId,
                         mediaInfo = navTarget.mediaInfo,
                         mediaSource = navTarget.mediaSource,
                         thumbnailSource = navTarget.thumbnailSource,
-                        canShowInfo = true,
                     ),
                     callback = callback,
                 )

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/viewer/GalleryMediaGalleryDataSource.kt

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.mediaviewer.impl.viewer
+
+import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.UniqueId
+import io.element.android.libraries.matrix.api.timeline.Timeline
+import io.element.android.libraries.mediaviewer.api.GalleryInfo
+import io.element.android.libraries.mediaviewer.api.GalleryItemData
+import io.element.android.libraries.mediaviewer.api.MediaInfo
+import io.element.android.libraries.mediaviewer.impl.datasource.MediaGalleryDataSource
+import io.element.android.libraries.mediaviewer.impl.model.GroupedMediaItems
+import io.element.android.libraries.mediaviewer.impl.model.MediaItem
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.flowOf
+
+class GalleryMediaGalleryDataSource(
+    private val data: GroupedMediaItems,
+) : MediaGalleryDataSource {
+    override val isReady: Boolean = true
+    override fun start(coroutineScope: CoroutineScope) = Unit
+    override fun groupedMediaItemsFlow() = flowOf(AsyncData.Success(data))
+    override fun getLastData(): AsyncData<GroupedMediaItems> = AsyncData.Success(data)
+    override suspend fun loadMore(direction: Timeline.PaginationDirection) = Unit
+    override suspend fun deleteItem(eventId: EventId) = Unit
+
+    companion object {
+        fun createFrom(
+            eventId: EventId?,
+            galleryItems: List<GalleryItemData>,
+            galleryInfo: GalleryInfo,
+        ): GalleryMediaGalleryDataSource {
+            val imageAndVideoItems = mutableListOf<MediaItem.Event>()
+            val fileItems = mutableListOf<MediaItem.Event>()
+
+            galleryItems.forEachIndexed { index, galleryItem ->
+                val itemMediaInfo = MediaInfo(
+                    filename = galleryItem.filename,
+                    fileSize = null,
+                    caption = galleryInfo.caption,
+                    mimeType = galleryItem.mimeType,
+                    formattedFileSize = "",
+                    fileExtension = galleryItem.filename.substringAfterLast('.', ""),
+                    senderId = galleryInfo.senderId,
+                    senderName = galleryInfo.senderName,
+                    senderAvatar = galleryInfo.senderAvatar,
+                    dateSent = galleryInfo.dateSent,
+                    dateSentFull = galleryInfo.dateSentFull,
+                    waveform = null,
+                    duration = null,
+                )
+                val id = UniqueId("${eventId?.value ?: "gallery"}_$index")
+                val mediaItem: MediaItem.Event = when (galleryItem.type) {
+                    GalleryItemData.Type.Video -> MediaItem.Video(
+                        id = id,
+                        eventId = eventId,
+                        mediaInfo = itemMediaInfo,
+                        mediaSource = galleryItem.mediaSource,
+                        thumbnailSource = galleryItem.thumbnailSource,
+                    )
+                    GalleryItemData.Type.Audio -> MediaItem.Audio(
+                        id = id,
+                        eventId = eventId,
+                        mediaInfo = itemMediaInfo,
+                        mediaSource = galleryItem.mediaSource,
+                    )
+                    GalleryItemData.Type.File -> MediaItem.File(
+                        id = id,
+                        eventId = eventId,
+                        mediaInfo = itemMediaInfo,
+                        mediaSource = galleryItem.mediaSource,
+                    )
+                    GalleryItemData.Type.Image -> MediaItem.Image(
+                        id = id,
+                        eventId = eventId,
+                        mediaInfo = itemMediaInfo,
+                        mediaSource = galleryItem.mediaSource,
+                        thumbnailSource = galleryItem.thumbnailSource,
+                    )
+                }
+                when (mediaItem) {
+                    is MediaItem.Image, is MediaItem.Video -> imageAndVideoItems.add(mediaItem)
+                    is MediaItem.Audio, is MediaItem.File, is MediaItem.Voice -> fileItems.add(mediaItem)
+                }
+            }
+
+            return GalleryMediaGalleryDataSource(
+                data = GroupedMediaItems(
+                    imageAndVideoItems = imageAndVideoItems.toImmutableList(),
+                    fileItems = fileItems.toImmutableList(),
+                )
+            )
+        }
+    }
+}

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/viewer/MediaViewerDataSource.kt

@@ -62,7 +62,6 @@ class MediaViewerDataSource(
     private val mediaFiles: ConcurrentHashMap<MediaSource, MediaFile> = ConcurrentHashMap()
 
     private val galleryMode = when (mode) {
-        MediaViewerMode.SingleMedia,
         is MediaViewerMode.TimelineImagesAndVideos -> MediaGalleryMode.Images
         is MediaViewerMode.TimelineFilesAndAudios -> MediaGalleryMode.Files
     }
@@ -98,9 +97,12 @@ class MediaViewerDataSource(
     /**
      * Find the index of the page corresponding to the given eventId, or null if not found.
      */
-    fun findEventIndex(eventId: EventId?): Int? {
+    fun findEventIndex(eventId: EventId?, mediaSource: MediaSource? = null): Int? {
         if (eventId == null) return null
-        return dataFlow.value.indexOfFirst { (it as? MediaViewerPageData.MediaViewerData)?.eventId == eventId }.takeIf { it >= 0 }
+        return dataFlow.value.indexOfFirst {
+            val pageData = it as? MediaViewerPageData.MediaViewerData
+            pageData?.eventId == eventId && (mediaSource == null || pageData.mediaSource == mediaSource)
+        }.takeIf { it >= 0 }
     }
 
     @VisibleForTesting

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/viewer/MediaViewerNode.kt

@@ -74,42 +74,49 @@ class MediaViewerNode(
         callback.onDone()
     }
 
-    private val mediaGallerySource = if (inputs.mode == MediaViewerEntryPoint.MediaViewerMode.SingleMedia) {
-        SingleMediaGalleryDataSource.createFrom(inputs)
-    } else {
-        val eventId = inputs.eventId
-        if (eventId == null) {
-            // Should not happen
-            timelineMediaGalleryDataSource
-        } else {
-            // Can we use a specific timeline?
-            val timelineMode = inputs.mode.getTimelineMode()
-            when (timelineMode) {
-                null -> timelineMediaGalleryDataSource
-                Timeline.Mode.Live,
-                is Timeline.Mode.FocusedOnEvent,
-                is Timeline.Mode.Thread -> {
-                    // Does timelineMediaGalleryDataSource knows the eventId?
-                    val lastData = timelineMediaGalleryDataSource.getLastData().dataOrNull()
-                    val isEventKnown = lastData?.hasEvent(eventId) == true
-                    if (isEventKnown) {
-                        timelineMediaGalleryDataSource
-                    } else {
+    private val mediaGallerySource = when (inputs) {
+        is MediaViewerEntryPoint.Params.Avatar ->
+            SingleMediaGalleryDataSource.createFrom(inputs)
+        is MediaViewerEntryPoint.Params.EventGallery ->
+            GalleryMediaGalleryDataSource.createFrom(
+                eventId = inputs.eventId,
+                galleryItems = inputs.galleryItems,
+                galleryInfo = inputs.galleryInfo,
+            )
+        is MediaViewerEntryPoint.Params.RoomMedia -> {
+            val eventId = inputs.eventId
+            if (eventId == null) {
+                // Should not happen
+                timelineMediaGalleryDataSource
+            } else {
+                // Can we use a specific timeline?
+                val timelineMode = inputs.mode.getTimelineMode()
+                when (timelineMode) {
+                    Timeline.Mode.Live,
+                    is Timeline.Mode.FocusedOnEvent,
+                    is Timeline.Mode.Thread -> {
+                        // Does timelineMediaGalleryDataSource knows the eventId?
+                        val lastData = timelineMediaGalleryDataSource.getLastData().dataOrNull()
+                        val isEventKnown = lastData?.hasEvent(eventId) == true
+                        if (isEventKnown) {
+                            timelineMediaGalleryDataSource
+                        } else {
+                            focusedTimelineMediaGalleryDataSourceFactory.createFor(
+                                eventId = eventId,
+                                mediaItem = inputs.toMediaItem(),
+                                onlyPinnedEvents = false,
+                            )
+                        }
+                    }
+                    Timeline.Mode.PinnedEvents -> {
                         focusedTimelineMediaGalleryDataSourceFactory.createFor(
                             eventId = eventId,
                             mediaItem = inputs.toMediaItem(),
-                            onlyPinnedEvents = false,
+                            onlyPinnedEvents = true,
                         )
                     }
+                    Timeline.Mode.Media -> timelineMediaGalleryDataSource
                 }
-                Timeline.Mode.PinnedEvents -> {
-                    focusedTimelineMediaGalleryDataSourceFactory.createFor(
-                        eventId = eventId,
-                        mediaItem = inputs.toMediaItem(),
-                        onlyPinnedEvents = true,
-                    )
-                }
-                Timeline.Mode.Media -> timelineMediaGalleryDataSource
             }
         }
     }
@@ -118,7 +125,18 @@ class MediaViewerNode(
         inputs = inputs,
         navigator = this,
         dataSource = MediaViewerDataSource(
-            mode = inputs.mode,
+            mode = when (inputs) {
+                is MediaViewerEntryPoint.Params.Avatar ->
+                    MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos(Timeline.Mode.Media)
+                is MediaViewerEntryPoint.Params.EventGallery ->
+                    if (inputs.galleryInfo.isAttachment) {
+                        MediaViewerEntryPoint.MediaViewerMode.TimelineFilesAndAudios(Timeline.Mode.Media)
+                    } else {
+                        MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos(Timeline.Mode.Media)
+                    }
+                is MediaViewerEntryPoint.Params.RoomMedia ->
+                    inputs.mode
+            },
             coroutineScope = lifecycleScope,
             dispatcher = coroutineDispatchers.computation,
             galleryDataSource = mediaGallerySource,
@@ -149,10 +167,9 @@ class MediaViewerNode(
     }
 }
 
-internal fun MediaViewerEntryPoint.MediaViewerMode.getTimelineMode(): Timeline.Mode? {
+internal fun MediaViewerEntryPoint.MediaViewerMode.getTimelineMode(): Timeline.Mode {
     return when (this) {
         is MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos -> timelineMode
         is MediaViewerEntryPoint.MediaViewerMode.TimelineFilesAndAudios -> timelineMode
-        else -> null
     }
 }

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

@@ -67,20 +67,31 @@ class MediaViewerPresenter(
     // Use a local snackbarDispatcher because this presenter is used in an Overlay Node
     private val snackbarDispatcher = SnackbarDispatcher()
 
+    private val eventId = inputs.eventId()
+    private val mediaSource = inputs.mediaSource()
+
     @Composable
     override fun present(): MediaViewerState {
         val coroutineScope = rememberCoroutineScope()
-        val currentIndex = remember { mutableIntStateOf(dataSource.findEventIndex(inputs.eventId) ?: 0) }
+        val currentIndex = remember {
+            val firstIndex = if (inputs is MediaViewerEntryPoint.Params.EventGallery) {
+                // Order is reversed so we have to reverse the index
+                inputs.galleryItems.lastIndex - inputs.galleryInfo.initialIndex
+            } else {
+                dataSource.findEventIndex(eventId, mediaSource) ?: 0
+            }
+            mutableIntStateOf(firstIndex)
+        }
         val data = dataSource.produceState { flow ->
             flow.collectLatest { new ->
                 val existingItem = value.getOrNull(currentIndex.intValue)
                 val newItem = new.getOrNull(currentIndex.intValue)
-                if (existingItem is MediaViewerPageData.MediaViewerData && existingItem.eventId == inputs.eventId && newItem != existingItem) {
-                    currentIndex.intValue = dataSource.findEventIndex(inputs.eventId) ?: 0
+                if (existingItem is MediaViewerPageData.MediaViewerData && existingItem.eventId == eventId && newItem != existingItem) {
+                    currentIndex.intValue = dataSource.findEventIndex(eventId, mediaSource) ?: 0
                 } else if (currentIndex.intValue > 0 && value.firstOrNull() is MediaViewerPageData.Loading &&
                     new.firstOrNull() !is MediaViewerPageData.Loading) {
                     // Restore index based on the eventId after the initial items have been loaded
-                    currentIndex.intValue = dataSource.findEventIndex(inputs.eventId) ?: 0
+                    currentIndex.intValue = dataSource.findEventIndex(eventId, mediaSource) ?: 0
                 }
                 value = new
             }
@@ -140,7 +151,8 @@ class MediaViewerPresenter(
                     mediaBottomSheetState = MediaBottomSheetState.Hidden
                     navigator.onForwardClick(
                         eventId = event.eventId,
-                        fromPinnedEvents = inputs.mode.getTimelineMode() == Timeline.Mode.PinnedEvents,
+                        // TODO We can have a pinned gallery
+                        fromPinnedEvents = inputs.mode()?.getTimelineMode() == Timeline.Mode.PinnedEvents,
                     )
                 }
                 is MediaViewerEvent.OpenInfo -> coroutineScope.launch {
@@ -176,11 +188,11 @@ class MediaViewerPresenter(
         }
 
         return MediaViewerState(
-            initiallySelectedEventId = inputs.eventId,
+            initiallySelectedEventId = eventId,
             listData = data.value,
             currentIndex = currentIndex.intValue,
             snackbarMessage = snackbarMessage,
-            canShowInfo = inputs.canShowInfo,
+            canShowInfo = inputs !is MediaViewerEntryPoint.Params.Avatar,
             mediaBottomSheetState = mediaBottomSheetState,
             eventSink = ::handleEvent,
         )
@@ -224,13 +236,14 @@ class MediaViewerPresenter(
     }
 
     private fun showNoMoreItemsSnackbar() {
-        val messageResId = when (inputs.mode) {
-            MediaViewerEntryPoint.MediaViewerMode.SingleMedia,
-            is MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos -> R.string.screen_media_details_no_more_media_to_show
-            is MediaViewerEntryPoint.MediaViewerMode.TimelineFilesAndAudios -> R.string.screen_media_details_no_more_files_to_show
+        if (inputs is MediaViewerEntryPoint.Params.RoomMedia) {
+            val messageResId = when (inputs.mode) {
+                is MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos -> R.string.screen_media_details_no_more_media_to_show
+                is MediaViewerEntryPoint.MediaViewerMode.TimelineFilesAndAudios -> R.string.screen_media_details_no_more_files_to_show
+            }
+            val message = SnackbarMessage(messageResId)
+            snackbarDispatcher.post(message)
         }
-        val message = SnackbarMessage(messageResId)
-        snackbarDispatcher.post(message)
     }
 
     private fun CoroutineScope.downloadMedia(
@@ -292,3 +305,21 @@ class MediaViewerPresenter(
         }
     }
 }
+
+private fun MediaViewerEntryPoint.Params.eventId() = when (this) {
+    is MediaViewerEntryPoint.Params.Avatar -> null
+    is MediaViewerEntryPoint.Params.EventGallery -> eventId
+    is MediaViewerEntryPoint.Params.RoomMedia -> eventId
+}
+
+private fun MediaViewerEntryPoint.Params.mediaSource() = when (this) {
+    is MediaViewerEntryPoint.Params.Avatar -> mediaSource
+    is MediaViewerEntryPoint.Params.EventGallery -> null
+    is MediaViewerEntryPoint.Params.RoomMedia -> mediaSource
+}
+
+private fun MediaViewerEntryPoint.Params.mode() = when (this) {
+    is MediaViewerEntryPoint.Params.Avatar -> null
+    is MediaViewerEntryPoint.Params.EventGallery -> null
+    is MediaViewerEntryPoint.Params.RoomMedia -> mode
+}

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/viewer/PagerKeysHandler.kt

@@ -11,6 +11,7 @@ package io.element.android.libraries.mediaviewer.impl.viewer
 import dev.zacsweers.metro.Inject
 import io.element.android.libraries.mediaviewer.impl.model.MediaItem
 import io.element.android.libraries.mediaviewer.impl.model.eventId
+import io.element.android.libraries.mediaviewer.impl.model.mediaSource
 
 /**
  * x and y are loading items.
@@ -50,31 +51,32 @@ class PagerKeysHandler {
         if (cachedData.mediaItems.isEmpty()) {
             cachedData = Data(mediaItems, 0)
         } else {
-            // Search a common item in both lists, i.e. an item with the same eventId
-            val itemInCacheIndex = cachedData.mediaItems.indexOfFirst { mediaItem ->
-                mediaItem is MediaItem.Event && mediaItems
+            // Search a common item in both lists using eventId + mediaSource to handle gallery items
+            val itemInCacheIndex = cachedData.mediaItems.indexOfFirst { cachedItem ->
+                cachedItem is MediaItem.Event && mediaItems
                     .filterIsInstance<MediaItem.Event>()
-                    .any { mediaItem.eventId() == it.eventId() }
+                    .any { newItem ->
+                        cachedItem.eventId() == newItem.eventId() &&
+                            cachedItem.mediaSource().safeUrl == newItem.mediaSource().safeUrl
+                    }
             }
             cachedData = if (itemInCacheIndex == -1) {
-                // If the item is not found, start with a new cache
                 Data(mediaItems, 0)
             } else {
                 val cachedItem = cachedData.mediaItems[itemInCacheIndex]
                 val eventId = (cachedItem as? MediaItem.Event)?.eventId()
-                if (eventId == null) {
-                    // Should not happen, but in this case, start with a new cache
+                val cachedSourceUrl = (cachedItem as? MediaItem.Event)?.mediaSource()?.safeUrl
+                if (eventId == null || cachedSourceUrl == null) {
                     Data(mediaItems, 0)
                 } else {
-                    // Search the index of the item in the new list
                     val itemIndex = mediaItems.indexOfFirst { mediaItem ->
-                        mediaItem is MediaItem.Event && mediaItem.eventId() == eventId
+                        mediaItem is MediaItem.Event &&
+                            mediaItem.eventId() == eventId &&
+                            mediaItem.mediaSource().safeUrl == cachedSourceUrl
                     }
                     if (itemIndex == -1) {
-                        // If the item is not found, start with a new cache
                         Data(mediaItems, 0)
                     } else {
-                        // Update the cache with the new list and the new offset
                         Data(mediaItems, cachedData.keyOffset + itemInCacheIndex - itemIndex.toLong())
                     }
                 }

libraries/mediaviewer/impl/src/main/kotlin/io/element/android/libraries/mediaviewer/impl/viewer/SingleMediaGalleryDataSource.kt

@@ -9,12 +9,14 @@
 package io.element.android.libraries.mediaviewer.impl.viewer
 
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeAudio
 import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeImage
 import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeVideo
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.Timeline
+import io.element.android.libraries.mediaviewer.api.MediaInfo
 import io.element.android.libraries.mediaviewer.api.MediaViewerEntryPoint
 import io.element.android.libraries.mediaviewer.impl.datasource.MediaGalleryDataSource
 import io.element.android.libraries.mediaviewer.impl.model.GroupedMediaItems
@@ -36,17 +38,40 @@ class SingleMediaGalleryDataSource(
     override suspend fun deleteItem(eventId: EventId) = Unit
 
     companion object {
-        fun createFrom(params: MediaViewerEntryPoint.Params) = SingleMediaGalleryDataSource(
+        fun createFrom(params: MediaViewerEntryPoint.Params.Avatar) = SingleMediaGalleryDataSource(
             data = GroupedMediaItems(
                 // Always use imageAndVideoItems, in Single mode, this is the data that will be used
-                imageAndVideoItems = persistentListOf(params.toMediaItem()),
+                imageAndVideoItems = persistentListOf(
+                    MediaItem.Image(
+                        id = UniqueId("dummy"),
+                        eventId = null,
+                        mediaInfo = MediaInfo(
+                            filename = params.avatarInfo.filename,
+                            caption = null,
+                            formattedCaption = null,
+                            mimeType = MimeTypes.Images,
+                            fileSize = null,
+                            formattedFileSize = "",
+                            fileExtension = "",
+                            senderId = null,
+                            senderName = null,
+                            senderAvatar = null,
+                            dateSent = null,
+                            dateSentFull = null,
+                            waveform = null,
+                            duration = null,
+                        ),
+                        mediaSource = params.mediaSource,
+                        thumbnailSource = params.thumbnailSource,
+                    )
+                ),
                 fileItems = persistentListOf(),
             )
         )
     }
 }
 
-fun MediaViewerEntryPoint.Params.toMediaItem() = when {
+fun MediaViewerEntryPoint.Params.RoomMedia.toMediaItem() = when {
     mediaInfo.mimeType.isMimeTypeImage() -> {
         MediaItem.Image(
             id = UniqueId("dummy"),

libraries/mediaviewer/impl/src/test/kotlin/io/element/android/libraries/mediaviewer/impl/DefaultMediaViewerEntryPointTest.kt

@@ -13,14 +13,12 @@ import androidx.arch.core.executor.testing.InstantTaskExecutorRule
 import com.bumble.appyx.core.modality.BuildContext
 import com.google.common.truth.Truth.assertThat
 import io.element.android.features.enterprise.test.FakeEnterpriseService
-import io.element.android.libraries.core.mimetype.MimeTypes
 import io.element.android.libraries.matrix.api.core.EventId
-import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.media.MediaSource
 import io.element.android.libraries.matrix.test.A_SESSION_ID
 import io.element.android.libraries.matrix.test.media.FakeMatrixMediaLoader
 import io.element.android.libraries.mediaplayer.test.FakeAudioFocus
-import io.element.android.libraries.mediaviewer.api.MediaInfo
+import io.element.android.libraries.mediaviewer.api.AvatarInfo
 import io.element.android.libraries.mediaviewer.api.MediaViewerEntryPoint
 import io.element.android.libraries.mediaviewer.impl.datasource.createTimelineMediaGalleryDataSource
 import io.element.android.libraries.mediaviewer.impl.viewer.MediaViewerNode
@@ -128,7 +126,7 @@ class DefaultMediaViewerEntryPointTest {
             override fun forwardEvent(eventId: EventId, fromPinnedEvents: Boolean) = lambdaError()
         }
         val params = entryPoint.createParamsForAvatar(
-            filename = "fn",
+            filename = "avatar.png",
             avatarUrl = "avatarUrl",
         )
         val result = entryPoint.createNode(
@@ -139,27 +137,10 @@ class DefaultMediaViewerEntryPointTest {
         )
         assertThat(result).isInstanceOf(MediaViewerNode::class.java)
         assertThat(result.plugins).contains(
-            MediaViewerEntryPoint.Params(
-                mode = MediaViewerEntryPoint.MediaViewerMode.SingleMedia,
-                eventId = null,
-                mediaInfo = MediaInfo(
-                    filename = "fn",
-                    fileSize = null,
-                    caption = null,
-                    mimeType = MimeTypes.Images,
-                    formattedFileSize = "",
-                    fileExtension = "",
-                    senderId = UserId("@dummy:server.org"),
-                    senderName = null,
-                    senderAvatar = null,
-                    dateSent = null,
-                    dateSentFull = null,
-                    waveform = null,
-                    duration = null,
-                ),
+            MediaViewerEntryPoint.Params.Avatar(
+                avatarInfo = AvatarInfo(filename = "avatar.png"),
                 mediaSource = MediaSource(url = "avatarUrl"),
                 thumbnailSource = null,
-                canShowInfo = false,
             )
         )
         assertThat(result.plugins).contains(callback)

libraries/mediaviewer/impl/src/test/kotlin/io/element/android/libraries/mediaviewer/impl/datasource/DefaultEventItemFactoryTest.kt

@@ -97,7 +97,7 @@ class DefaultEventItemFactoryTest {
                     )
                 )
             )
-            assertThat(result).isNull()
+            assertThat(result).isEmpty()
         }
     }
 
@@ -122,7 +122,7 @@ class DefaultEventItemFactoryTest {
                     )
                 )
             )
-            assertThat(result).isNull()
+            assertThat(result).isEmpty()
         }
     }
 
@@ -150,7 +150,7 @@ class DefaultEventItemFactoryTest {
                 )
             )
         )
-        assertThat(result).isEqualTo(
+        assertThat(result).containsExactly(
             MediaItem.File(
                 id = A_UNIQUE_ID,
                 eventId = AN_EVENT_ID,
@@ -201,7 +201,7 @@ class DefaultEventItemFactoryTest {
                 )
             )
         )
-        assertThat(result).isEqualTo(
+        assertThat(result).containsExactly(
             MediaItem.Image(
                 id = A_UNIQUE_ID,
                 eventId = AN_EVENT_ID,
@@ -249,7 +249,7 @@ class DefaultEventItemFactoryTest {
                 )
             )
         )
-        assertThat(result).isEqualTo(
+        assertThat(result).containsExactly(
             MediaItem.Audio(
                 id = A_UNIQUE_ID,
                 eventId = AN_EVENT_ID,
@@ -301,7 +301,7 @@ class DefaultEventItemFactoryTest {
                 )
             )
         )
-        assertThat(result).isEqualTo(
+        assertThat(result).containsExactly(
             MediaItem.Video(
                 id = A_UNIQUE_ID,
                 eventId = AN_EVENT_ID,
@@ -353,7 +353,7 @@ class DefaultEventItemFactoryTest {
                 )
             )
         )
-        assertThat(result).isEqualTo(
+        assertThat(result).containsExactly(
             MediaItem.Voice(
                 id = A_UNIQUE_ID,
                 eventId = AN_EVENT_ID,
@@ -404,7 +404,7 @@ class DefaultEventItemFactoryTest {
                 )
             )
         )
-        assertThat(result).isEqualTo(
+        assertThat(result).containsExactly(
             MediaItem.Image(
                 id = A_UNIQUE_ID,
                 eventId = AN_EVENT_ID,

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

@@ -30,6 +30,7 @@ import io.element.android.libraries.matrix.test.room.FakeBaseRoom
 import io.element.android.libraries.matrix.test.room.FakeJoinedRoom
 import io.element.android.libraries.matrix.test.room.powerlevels.FakeRoomPermissions
 import io.element.android.libraries.matrix.test.timeline.FakeTimeline
+import io.element.android.libraries.mediaviewer.api.AvatarInfo
 import io.element.android.libraries.mediaviewer.api.MediaViewerEntryPoint
 import io.element.android.libraries.mediaviewer.api.anApkMediaInfo
 import io.element.android.libraries.mediaviewer.api.local.LocalMediaFactory
@@ -109,7 +110,11 @@ class MediaViewerPresenterTest {
     fun `present - initial state cannot show info`() = runTest {
         val presenter = createMediaViewerPresenter(
             localMediaFactory = localMediaFactory,
-            canShowInfo = false,
+            inputs = MediaViewerEntryPoint.Params.Avatar(
+                avatarInfo = AvatarInfo(filename = "avatar.png"),
+                mediaSource = aMediaSource(),
+                thumbnailSource = null,
+            ),
             room = FakeJoinedRoom(
                 baseRoom = FakeBaseRoom(
                     roomPermissions = FakeRoomPermissions(
@@ -639,7 +644,7 @@ class MediaViewerPresenterTest {
                     }
                 )
             )
-            skipItems(2)
+            skipItems(1)
             val stateWithSnackbar = awaitItem()
             assertThat(stateWithSnackbar.snackbarMessage!!.messageResId).isEqualTo(expectedSnackbarResId)
         }
@@ -932,29 +937,31 @@ class MediaViewerPresenterTest {
 
 internal fun TestScope.createMediaViewerPresenter(
     localMediaFactory: LocalMediaFactory,
+    inputs: MediaViewerEntryPoint.Params? = null,
     eventId: EventId? = null,
-    mode: MediaViewerEntryPoint.MediaViewerMode = MediaViewerEntryPoint.MediaViewerMode.SingleMedia,
+    mode: MediaViewerEntryPoint.MediaViewerMode = MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos(Timeline.Mode.Media),
     matrixMediaLoader: FakeMatrixMediaLoader = FakeMatrixMediaLoader(),
     localMediaActions: FakeLocalMediaActions = FakeLocalMediaActions(),
     mediaGalleryDataSource: MediaGalleryDataSource = FakeMediaGalleryDataSource(
         startLambda = { },
     ),
-    canShowInfo: Boolean = true,
     mediaViewerNavigator: MediaViewerNavigator = FakeMediaViewerNavigator(),
     room: JoinedRoom = FakeJoinedRoom(
         liveTimeline = FakeTimeline(),
     ),
 ): MediaViewerPresenter {
+    val actualInputs = inputs ?: createMediaViewerEntryPointParams(eventId = eventId, mode = mode)
+    val actualMode = when (actualInputs) {
+        is MediaViewerEntryPoint.Params.Avatar -> MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos(Timeline.Mode.Media)
+        is MediaViewerEntryPoint.Params.EventGallery -> MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos(Timeline.Mode.Media)
+        is MediaViewerEntryPoint.Params.RoomMedia -> actualInputs.mode
+    }
     return MediaViewerPresenter(
-        inputs = createMediaViewerEntryPointParams(
-            eventId = eventId,
-            mode = mode,
-            canShowInfo = canShowInfo,
-        ),
+        inputs = actualInputs,
         navigator = mediaViewerNavigator,
         dataSource = MediaViewerDataSource(
             coroutineScope = backgroundScope,
-            mode = mode,
+            mode = actualMode,
             dispatcher = testCoroutineDispatchers().computation,
             galleryDataSource = mediaGalleryDataSource,
             mediaLoader = matrixMediaLoader,
@@ -969,13 +976,11 @@ internal fun TestScope.createMediaViewerPresenter(
 
 internal fun createMediaViewerEntryPointParams(
     eventId: EventId? = null,
-    mode: MediaViewerEntryPoint.MediaViewerMode = MediaViewerEntryPoint.MediaViewerMode.SingleMedia,
-    canShowInfo: Boolean = true,
-) = MediaViewerEntryPoint.Params(
+    mode: MediaViewerEntryPoint.MediaViewerMode = MediaViewerEntryPoint.MediaViewerMode.TimelineFilesAndAudios(timelineMode = Timeline.Mode.Media),
+) = MediaViewerEntryPoint.Params.RoomMedia(
     mode = mode,
     eventId = eventId,
     mediaInfo = TESTED_MEDIA_INFO,
     mediaSource = aMediaSource(),
     thumbnailSource = null,
-    canShowInfo = canShowInfo,
 )

libraries/mediaviewer/impl/src/test/kotlin/io/element/android/libraries/mediaviewer/impl/viewer/SingleMediaGalleryDataSourceTest.kt

@@ -160,23 +160,20 @@ class SingleMediaGalleryDataSourceTest {
 
     private fun testFactory(
         mediaInfo: MediaInfo,
-        expectedResult: (MediaViewerEntryPoint.Params) -> MediaItem,
+        expectedResult: (MediaViewerEntryPoint.Params.RoomMedia) -> MediaItem,
     ) {
         val params = aMediaViewerEntryPointParams(mediaInfo)
-        val result = SingleMediaGalleryDataSource.createFrom(params)
-        val resultData = result.getLastData().dataOrNull()
-        assertThat(resultData!!.imageAndVideoItems.first()).isEqualTo(expectedResult(params))
-        assertThat(resultData.fileItems).isEmpty()
+        val result = params.toMediaItem()
+        assertThat(result).isEqualTo(expectedResult(params))
     }
 
     internal fun aMediaViewerEntryPointParams(
         mediaInfo: MediaInfo,
-    ) = MediaViewerEntryPoint.Params(
-        mode = MediaViewerEntryPoint.MediaViewerMode.SingleMedia,
+    ) = MediaViewerEntryPoint.Params.RoomMedia(
+        mode = MediaViewerEntryPoint.MediaViewerMode.TimelineImagesAndVideos(Timeline.Mode.Media),
         eventId = AN_EVENT_ID,
         mediaInfo = mediaInfo,
         mediaSource = aMediaSource(url = "aUrl"),
         thumbnailSource = aMediaSource(url = "aThumbnailUrl"),
-        canShowInfo = true,
     )
 }

libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolver.kt

@@ -41,6 +41,7 @@ import io.element.android.libraries.matrix.api.timeline.item.event.AudioMessageT
 import io.element.android.libraries.matrix.api.timeline.item.event.EmoteMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.EventType
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.GalleryMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.LocationMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.NoticeMessageType
@@ -344,6 +345,7 @@ class DefaultNotifiableEventResolver(
             is TextMessageType -> messageType.toPlainText(permalinkParser = permalinkParser)
             is VideoMessageType -> messageType.bestDescription
             is LocationMessageType -> messageType.body
+            is GalleryMessageType -> messageType.body
             is OtherMessageType -> messageType.body
         }
     }

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

@@ -5,6 +5,8 @@
   <string name="a11y_address">"Address"</string>
   <string name="a11y_avatar">"Avatar"</string>
   <string name="a11y_collapse_message_text_field">"Minimise message text field"</string>
+  <string name="a11y_create_poll_votes_allowed_decrease">"Decrease votes allowed per person"</string>
+  <string name="a11y_create_poll_votes_allowed_increase">"Increase votes allowed per person"</string>
   <string name="a11y_delete">"Delete"</string>
   <plurals name="a11y_digits_entered">
     <item quantity="one">"%1$d digit entered"</item>
@@ -194,9 +196,11 @@
   <string name="action_translate">"Translate"</string>
   <string name="action_try_again">"Try again"</string>
   <string name="action_unpin">"Unpin"</string>
+  <string name="action_video_call">"Video call"</string>
   <string name="action_view">"View"</string>
   <string name="action_view_in_timeline">"View in timeline"</string>
   <string name="action_view_source">"View source"</string>
+  <string name="action_voice_call">"Voice call"</string>
   <string name="action_yes">"Yes"</string>
   <string name="action_yes_try_again">"Yes, try again"</string>
   <string name="banner_migrate_to_native_sliding_sync_description">"Your server now supports a new, faster protocol. Log out and log back in to upgrade now. Doing this now will help you avoid a forced logout when the old protocol is removed later."</string>
@@ -261,6 +265,7 @@ Reason: %1$s."</string>
   <string name="common_file_saved_on_disk_android">"File saved to Downloads"</string>
   <string name="common_forward_message">"Forward message"</string>
   <string name="common_frequently_used">"Frequently used"</string>
+  <string name="common_gallery">"Gallery"</string>
   <string name="common_gif">"GIF"</string>
   <string name="common_group_call_in_progress">"Group call in progress"</string>
   <string name="common_image">"Image"</string>
@@ -488,6 +493,7 @@ Are you sure you want to continue?"</string>
   <string name="screen_create_poll_options_section_title">"Options"</string>
   <string name="screen_create_poll_remove_accessibility_label">"Remove %1$s"</string>
   <string name="screen_create_poll_settings_section_title">"Settings"</string>
+  <string name="screen_create_poll_votes_allowed_per_person">"Votes allowed per person"</string>
   <string name="screen_live_location_sheet_nobody_sharing">"Nobody is sharing their location"</string>
   <string name="screen_live_location_sheet_sharing_live_location">"Sharing live location"</string>
   <plurals name="screen_live_location_sheet_subtitle">