Video messages on timeline (#304)

* Create timeline item and view for video

* Create video timeline items in factory, do not bubble them

* Add changelog

* Update packages

* Revert DTCoreText update

ElementX/Sources/Services/Timeline/TimelineItems/Items/VideoRoomTimelineItem.swift

@@ -0,0 +1,42 @@
+//
+// 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 VideoRoomTimelineItem: EventBasedTimelineItemProtocol, Identifiable, Equatable {
+    let id: String
+    let text: String
+    let timestamp: String
+    let inGroupState: TimelineItemInGroupState
+    let isOutgoing: Bool
+    
+    let senderId: String
+    var senderDisplayName: String?
+    var senderAvatar: UIImage?
+
+    let duration: UInt64
+    let source: MediaSource?
+    let thumbnailSource: MediaSource?
+    var image: UIImage?
+    
+    var width: CGFloat?
+    var height: CGFloat?
+    var aspectRatio: CGFloat?
+    var blurhash: String?
+    
+    var properties = RoomTimelineItemProperties()
+}

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineItemFactory.swift

@@ -59,6 +59,9 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
         case .image(content: let content):
             let message = MessageTimelineItem(item: eventItemProxy.item, content: content)
             return buildImageTimelineItemFromMessage(message, isOutgoing, inGroupState, displayName, avatarImage)
+        case .video(let content):
+            let message = MessageTimelineItem(item: eventItemProxy.item, content: content)
+            return buildVideoTimelineItemFromMessage(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)
@@ -187,6 +190,37 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                                      properties: RoomTimelineItemProperties(isEdited: message.isEdited,
                                                                             reactions: aggregateReactions(message.reactions)))
     }
+
+    private func buildVideoTimelineItemFromMessage(_ message: MessageTimelineItem<VideoMessageContent>,
+                                                   _ isOutgoing: Bool,
+                                                   _ inGroupState: TimelineItemInGroupState,
+                                                   _ displayName: String?,
+                                                   _ avatarImage: UIImage?) -> RoomTimelineItemProtocol {
+        var aspectRatio: CGFloat?
+        if let width = message.width,
+           let height = message.height {
+            aspectRatio = width / height
+        }
+        
+        return VideoRoomTimelineItem(id: message.id,
+                                     text: message.body,
+                                     timestamp: message.originServerTs.formatted(date: .omitted, time: .shortened),
+                                     inGroupState: inGroupState,
+                                     isOutgoing: isOutgoing,
+                                     senderId: message.sender,
+                                     senderDisplayName: displayName,
+                                     senderAvatar: avatarImage,
+                                     duration: message.duration,
+                                     source: message.source,
+                                     thumbnailSource: message.thumbnailSource,
+                                     image: mediaProvider.imageFromSource(message.thumbnailSource),
+                                     width: message.width,
+                                     height: message.height,
+                                     aspectRatio: aspectRatio,
+                                     blurhash: message.blurhash,
+                                     properties: RoomTimelineItemProperties(isEdited: message.isEdited,
+                                                                            reactions: aggregateReactions(message.reactions)))
+    }
     
     private func buildNoticeTimelineItemFromMessage(_ message: MessageTimelineItem<NoticeMessageContent>,
                                                     _ isOutgoing: Bool,

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineViewFactory.swift

@@ -23,6 +23,8 @@ struct RoomTimelineViewFactory: RoomTimelineViewFactoryProtocol {
             return .text(item)
         case let item as ImageRoomTimelineItem:
             return .image(item)
+        case let item as VideoRoomTimelineItem:
+            return .video(item)
         case let item as SeparatorRoomTimelineItem:
             return .separator(item)
         case let item as NoticeRoomTimelineItem:

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineViewProvider.swift

@@ -21,6 +21,7 @@ enum RoomTimelineViewProvider: Identifiable, Equatable {
     case text(TextRoomTimelineItem)
     case separator(SeparatorRoomTimelineItem)
     case image(ImageRoomTimelineItem)
+    case video(VideoRoomTimelineItem)
     case emote(EmoteRoomTimelineItem)
     case notice(NoticeRoomTimelineItem)
     case redacted(RedactedRoomTimelineItem)
@@ -34,6 +35,8 @@ enum RoomTimelineViewProvider: Identifiable, Equatable {
             return item.id
         case .image(let item):
             return item.id
+        case .video(let item):
+            return item.id
         case .emote(let item):
             return item.id
         case .notice(let item):
@@ -55,6 +58,8 @@ extension RoomTimelineViewProvider: View {
             SeparatorRoomTimelineView(timelineItem: item)
         case .image(let item):
             ImageRoomTimelineView(timelineItem: item)
+        case .video(let item):
+            VideoRoomTimelineView(timelineItem: item)
         case .emote(let item):
             EmoteRoomTimelineView(timelineItem: item)
         case .notice(let item):