File messages on timeline (#311)

* Create media player screen * Introduce `FileCache` to cache message attachments * Add file loading functionality into the media provider * Process tap action on timeline items * Pass item taps to view model * Navigate to media player on view model callback * Commit project file * Add changelog * Add file messages into the timeline * Create file preview screen * Display files in the preview screen * Commit project file * Update Rust SDK to 1.0.19-alpha * Add changelog * Bump the RustSDK to `v1.0.20-alpha` * Configure audio session on video playback Co-authored-by: Stefan Ceriu <stefanc@matrix.org>
2026-11-03 16:10:20 +00:00 · 2022-11-16 14:34:37 +03:00
parent ce6b0041d2
commit 287fa4cad5
30 changed files with 1019 additions and 61 deletions
@@ -75,7 +75,7 @@ class RoomProxy: RoomProxyProtocol {
    }
    
    var isEncrypted: Bool {
-        room.isEncrypted()
+        (try? room.isEncrypted()) ?? false
    }
    
    var isTombstoned: Bool {
@@ -124,6 +124,16 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
                return .displayVideo(videoURL: videoURL)
            }
            return .none
+        case let item as FileRoomTimelineItem:
+            await loadFileForTimelineItem(item)
+            guard let index = timelineItems.firstIndex(where: { $0.id == itemId }),
+                  let item = timelineItems[index] as? FileRoomTimelineItem else {
+                return .none
+            }
+            if let fileURL = item.cachedFileURL {
+                return .displayFile(fileURL: fileURL, title: item.text)
+            }
+            return .none
        default:
            return .none
        }
@@ -338,6 +348,34 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
            break
        }
    }
+
+    private func loadFileForTimelineItem(_ timelineItem: FileRoomTimelineItem) async {
+        if timelineItem.cachedFileURL != nil {
+            // already cached
+            return
+        }
+
+        guard let source = timelineItem.source else {
+            return
+        }
+
+        // This is not great. We could better estimate file extension from the mimetype.
+        guard let fileExtension = timelineItem.text.split(separator: ".").last else {
+            return
+        }
+        switch await mediaProvider.loadFileFromSource(source, fileExtension: String(fileExtension)) {
+        case .success(let fileURL):
+            guard let index = timelineItems.firstIndex(where: { $0.id == timelineItem.id }),
+                  var item = timelineItems[index] as? FileRoomTimelineItem else {
+                return
+            }
+
+            item.cachedFileURL = fileURL
+            timelineItems[index] = item
+        case .failure:
+            break
+        }
+    }
    
    private func loadUserAvatarForTimelineItem(_ timelineItem: EventBasedTimelineItemProtocol) async {
        if timelineItem.shouldShowSenderDetails == false {
@@ -26,6 +26,7 @@ enum RoomTimelineControllerCallback {

 enum RoomTimelineControllerAction {
    case displayVideo(videoURL: URL)
+    case displayFile(fileURL: URL, title: String?)
    case none
 }

@@ -116,7 +116,7 @@ extension MessageTimelineItem where Content == MatrixRustSDK.ImageMessageContent

 extension MatrixRustSDK.VideoMessageContent: MessageContentProtocol { }

-/// A timeline item that represents an `m.room.message` event with a `msgtype` of `m.image`.
+/// A timeline item that represents an `m.room.message` event with a `msgtype` of `m.video`.
 extension MessageTimelineItem where Content == MatrixRustSDK.VideoMessageContent {
    var source: MediaSource {
        MediaSource(source: content.source)
@@ -145,3 +145,19 @@ extension MessageTimelineItem where Content == MatrixRustSDK.VideoMessageContent
        content.info?.blurhash
    }
 }
+
+extension MatrixRustSDK.FileMessageContent: MessageContentProtocol { }
+
+/// A timeline item that represents an `m.room.message` event with a `msgtype` of `m.file`.
+extension MessageTimelineItem where Content == MatrixRustSDK.FileMessageContent {
+    var source: MediaSource {
+        MediaSource(source: content.source)
+    }
+
+    var thumbnailSource: MediaSource? {
+        guard let src = content.info?.thumbnailSource else {
+            return nil
+        }
+        return MediaSource(source: src)
+    }
+}
@@ -0,0 +1,37 @@
+//
+// Copyright 2022 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import UIKit
+
+struct FileRoomTimelineItem: EventBasedTimelineItemProtocol, Identifiable, Equatable {
+    let id: String
+    let text: String
+    let timestamp: String
+    let inGroupState: TimelineItemInGroupState
+    let isOutgoing: Bool
+    let isEditable: Bool
+    
+    let senderId: String
+    var senderDisplayName: String?
+    var senderAvatar: UIImage?
+
+    let source: MediaSource?
+    let thumbnailSource: MediaSource?
+    var cachedFileURL: URL?
+    
+    var properties = RoomTimelineItemProperties()
+}
@@ -62,6 +62,9 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
        case .video(let content):
            let message = MessageTimelineItem(item: eventItemProxy.item, content: content)
            return buildVideoTimelineItemFromMessage(message, isOutgoing, inGroupState, displayName, avatarImage)
+        case .file(let content):
+            let message = MessageTimelineItem(item: eventItemProxy.item, content: content)
+            return buildFileTimelineItemFromMessage(message, isOutgoing, inGroupState, displayName, avatarImage)
        case .notice(content: let content):
            let message = MessageTimelineItem(item: eventItemProxy.item, content: content)
            return buildNoticeTimelineItemFromMessage(message, isOutgoing, inGroupState, displayName, avatarImage)
@@ -227,6 +230,26 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                                     properties: RoomTimelineItemProperties(isEdited: message.isEdited,
                                                                            reactions: aggregateReactions(message.reactions)))
    }
+
+    private func buildFileTimelineItemFromMessage(_ message: MessageTimelineItem<FileMessageContent>,
+                                                  _ isOutgoing: Bool,
+                                                  _ inGroupState: TimelineItemInGroupState,
+                                                  _ displayName: String?,
+                                                  _ avatarImage: UIImage?) -> RoomTimelineItemProtocol {
+        FileRoomTimelineItem(id: message.id,
+                             text: message.body,
+                             timestamp: message.originServerTs.formatted(date: .omitted, time: .shortened),
+                             inGroupState: inGroupState,
+                             isOutgoing: isOutgoing,
+                             isEditable: message.isEditable,
+                             senderId: message.sender,
+                             senderDisplayName: displayName,
+                             senderAvatar: avatarImage,
+                             source: message.source,
+                             thumbnailSource: message.thumbnailSource,
+                             properties: RoomTimelineItemProperties(isEdited: message.isEdited,
+                                                                    reactions: aggregateReactions(message.reactions)))
+    }
    
    private func buildNoticeTimelineItemFromMessage(_ message: MessageTimelineItem<NoticeMessageContent>,
                                                    _ isOutgoing: Bool,
@@ -25,6 +25,8 @@ struct RoomTimelineViewFactory: RoomTimelineViewFactoryProtocol {
            return .image(item)
        case let item as VideoRoomTimelineItem:
            return .video(item)
+        case let item as FileRoomTimelineItem:
+            return .file(item)
        case let item as SeparatorRoomTimelineItem:
            return .separator(item)
        case let item as NoticeRoomTimelineItem:
@@ -22,6 +22,7 @@ enum RoomTimelineViewProvider: Identifiable, Equatable {
    case separator(SeparatorRoomTimelineItem)
    case image(ImageRoomTimelineItem)
    case video(VideoRoomTimelineItem)
+    case file(FileRoomTimelineItem)
    case emote(EmoteRoomTimelineItem)
    case notice(NoticeRoomTimelineItem)
    case redacted(RedactedRoomTimelineItem)
@@ -37,6 +38,8 @@ enum RoomTimelineViewProvider: Identifiable, Equatable {
            return item.id
        case .video(let item):
            return item.id
+        case .file(let item):
+            return item.id
        case .emote(let item):
            return item.id
        case .notice(let item):
@@ -60,6 +63,8 @@ extension RoomTimelineViewProvider: View {
            ImageRoomTimelineView(timelineItem: item)
        case .video(let item):
            VideoRoomTimelineView(timelineItem: item)
+        case .file(let item):
+            FileRoomTimelineView(timelineItem: item)
        case .emote(let item):
            EmoteRoomTimelineView(timelineItem: item)
        case .notice(let item):