Render location events in the timeline (#1136)

* Start location integration in the timeline * Add warning * Add LocationRoomTimelineView * Add GeoURI * Refine LocationRoomTimelineView * Refine LocationRoomTimelineView * Add LocationRoomTimelineView previews * Cleanup code * Mock reply * Add FF for location events * Update project file * Fix MapLibreStaticMapView placeholder * Add MapTilerAttribution * Add LocationPinView * Fix layout * Start reply rendering * Refactor ReplyView.Icon * Add localisations * Fix reactions * Amend GeoURI regex * Add log * Fix tests * Attribution placement refactor * Cleanup * Replace NSRegularExpression with a regex * Cleanup * Update unit tests * isMediaType -> shouldFillBubble
2026-11-03 16:10:20 +00:00 · 2023-06-23 12:49:35 +02:00
parent 40fab35dd7
commit 07a6235fac
27 changed files with 886 additions and 65 deletions
@@ -0,0 +1,73 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+/// A structure that parses a geo URI (i.e. geo:53.99803101552848,-8.25347900390625;u=10) and constructs their constituent parts.
+struct GeoURI: Hashable {
+    // MARK: - Properties
+
+    let latitude: Double
+    let longitude: Double
+    let uncertainty: Double?
+
+    // MARK: - Setup
+
+    init?(string: String) {
+        guard let parsedURI = Self.parseGeoURI(from: string) else {
+            MXLog.warning("\(Self.self) failed to parse the string: \(string)")
+            return nil
+        }
+        self = parsedURI
+    }
+
+    init(latitude: Double, longitude: Double, uncertainty: Double? = nil) {
+        self.latitude = latitude
+        self.longitude = longitude
+        self.uncertainty = uncertainty
+    }
+
+    var string: String {
+        if let uncertainty {
+            return "geo:\(latitude),\(longitude);u=\(uncertainty)"
+        } else {
+            return "geo:\(latitude),\(longitude)"
+        }
+    }
+
+    // MARK: - Private
+
+    // Parse a geo URI string like "geo:53.99803101552848,-8.25347900390625;u=10"
+    private static func parseGeoURI(from string: String) -> GeoURI? {
+        guard
+            let matchOutput = try? RegexGeoURI.standard.wholeMatch(in: string)?.output,
+            let latitude = Double(matchOutput.latitude),
+            let longitude = Double(matchOutput.longitude)
+        else {
+            return nil
+        }
+
+        let uncertainty = matchOutput.uncertainty.flatMap(Double.init)
+        return .init(latitude: latitude, longitude: longitude, uncertainty: uncertainty)
+    }
+}
+
+// swiftlint:disable:next large_tuple
+private typealias RegexGeoURI = Regex<(Substring, latitude: Substring, longitude: Substring, uncertainty: Substring?)>
+
+private extension RegexGeoURI {
+    static let standard: Self = /geo:(?<latitude>-?\d+(?:\.\d+)?),(?<longitude>-?\d+(?:\.\d+)?)(?:;u=(?<uncertainty>\d+(?:\.\d+)?))?/
+}
@@ -24,6 +24,7 @@ enum EventBasedMessageTimelineItemContentType: Hashable {
    case notice(NoticeRoomTimelineItemContent)
    case text(TextRoomTimelineItemContent)
    case video(VideoRoomTimelineItemContent)
+    case location(LocationRoomTimelineItemContent)
 }

 protocol EventBasedMessageTimelineItemProtocol: EventBasedTimelineItemProtocol {
@@ -0,0 +1,39 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+struct LocationRoomTimelineItem: EventBasedMessageTimelineItemProtocol, Hashable {
+    let id: String
+
+    let timestamp: String
+    let isOutgoing: Bool
+    let isEditable: Bool
+
+    let sender: TimelineItemSender
+
+    let content: LocationRoomTimelineItemContent
+
+    var body: String {
+        content.body
+    }
+
+    var replyDetails: TimelineItemReplyDetails?
+
+    var properties = RoomTimelineItemProperties()
+
+    var contentType: EventBasedMessageTimelineItemContentType {
+        .location(content)
+    }
+}
@@ -0,0 +1,20 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+struct LocationRoomTimelineItemContent: Hashable {
+    let body: String
+    let geoURI: GeoURI?
+}
@@ -36,7 +36,7 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
        self.stateEventStringBuilder = stateEventStringBuilder
    }
    
-    // swiftlint:disable:next cyclomatic_complexity
+    // swiftlint:disable:next cyclomatic_complexity function_body_length
    func buildTimelineItem(for eventItemProxy: EventTimelineItemProxy) -> RoomTimelineItemProtocol? {
        let isOutgoing = eventItemProxy.isOwn
        
@@ -74,8 +74,11 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                return buildEmoteTimelineItem(for: eventItemProxy, messageTimelineItem, content, isOutgoing)
            case .audio(let content):
                return buildAudioTimelineItem(for: eventItemProxy, messageTimelineItem, content, isOutgoing)
-            case .location:
-                return nil
+            case .location(let content):
+                guard ServiceLocator.shared.settings.locationEventsEnabled else {
+                    return nil
+                }
+                return buildLocationTimelineItem(for: eventItemProxy, messageTimelineItem, content, isOutgoing)
            case .none:
                return nil
            }
@@ -298,6 +301,24 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                                                                     orderedReadReceipts: orderReadReceipts(eventItemProxy.readReceipts),
                                                                     transactionID: eventItemProxy.transactionID))
    }
+
+    private func buildLocationTimelineItem(for eventItemProxy: EventTimelineItemProxy,
+                                           _ messageTimelineItem: Message,
+                                           _ messageContent: LocationContent,
+                                           _ isOutgoing: Bool) -> RoomTimelineItemProtocol {
+        LocationRoomTimelineItem(id: eventItemProxy.id,
+                                 timestamp: eventItemProxy.timestamp.formatted(date: .omitted, time: .shortened),
+                                 isOutgoing: isOutgoing,
+                                 isEditable: eventItemProxy.isEditable,
+                                 sender: eventItemProxy.sender,
+                                 content: buildLocationTimelineItemContent(messageContent),
+                                 replyDetails: buildReplyToDetailsFrom(details: messageTimelineItem.inReplyTo()),
+                                 properties: RoomTimelineItemProperties(isEdited: messageTimelineItem.isEdited(),
+                                                                        reactions: aggregateReactions(eventItemProxy.reactions),
+                                                                        deliveryStatus: eventItemProxy.deliveryStatus,
+                                                                        orderedReadReceipts: orderReadReceipts(eventItemProxy.readReceipts),
+                                                                        transactionID: eventItemProxy.transactionID))
+    }
    
    private func aggregateReactions(_ reactions: [Reaction]) -> [AggregatedReaction] {
        reactions.map { reaction in
@@ -334,7 +355,7 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                                     source: MediaSourceProxy(source: messageContent.source, mimeType: messageContent.info?.mimetype),
                                     contentType: UTType(mimeType: messageContent.info?.mimetype, fallbackFilename: messageContent.body))
    }
-    
+
    private func buildImageTimelineItemContent(_ messageContent: ImageMessageContent) -> ImageRoomTimelineItemContent {
        let thumbnailSource = messageContent.info?.thumbnailSource.map { MediaSourceProxy(source: $0, mimeType: messageContent.info?.thumbnailInfo?.mimetype) }
        let width = messageContent.info?.width.map(CGFloat.init)
@@ -354,7 +375,7 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                     blurhash: messageContent.info?.blurhash,
                     contentType: UTType(mimeType: messageContent.info?.mimetype, fallbackFilename: messageContent.body))
    }
-    
+
    private func buildVideoTimelineItemContent(_ messageContent: VideoMessageContent) -> VideoRoomTimelineItemContent {
        let thumbnailSource = messageContent.info?.thumbnailSource.map { MediaSourceProxy(source: $0, mimeType: messageContent.info?.thumbnailInfo?.mimetype) }
        let width = messageContent.info?.width.map(CGFloat.init)
@@ -375,7 +396,11 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                     blurhash: messageContent.info?.blurhash,
                     contentType: UTType(mimeType: messageContent.info?.mimetype, fallbackFilename: messageContent.body))
    }
-    
+
+    private func buildLocationTimelineItemContent(_ locationContent: LocationContent) -> LocationRoomTimelineItemContent {
+        LocationRoomTimelineItemContent(body: locationContent.body, geoURI: .init(string: locationContent.geoUri))
+    }
+
    private func buildFileTimelineItemContent(_ messageContent: FileMessageContent) -> FileRoomTimelineItemContent {
        let thumbnailSource = messageContent.info?.thumbnailSource.map { MediaSourceProxy(source: $0, mimeType: messageContent.info?.thumbnailInfo?.mimetype) }
        
@@ -490,8 +515,8 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                replyContent = .text(buildTextTimelineItemContent(content))
            case .video(let content):
                replyContent = .video(buildVideoTimelineItemContent(content))
-            case .location:
-                return nil
+            case .location(let content):
+                replyContent = .location(buildLocationTimelineItemContent(content))
            case .none:
                return nil
            }
@@ -35,6 +35,7 @@ enum RoomTimelineViewProvider: Identifiable, Hashable {
    case timelineStart(TimelineStartRoomTimelineItem, TimelineGroupStyle)
    case state(StateRoomTimelineItem, TimelineGroupStyle)
    case group(CollapsibleTimelineItem, TimelineGroupStyle)
+    case location(LocationRoomTimelineItem, TimelineGroupStyle)
    
    // swiftlint:disable:next cyclomatic_complexity
    init(timelineItem: RoomTimelineItemProtocol, groupStyle: TimelineGroupStyle) {
@@ -73,6 +74,8 @@ enum RoomTimelineViewProvider: Identifiable, Hashable {
            self = .state(item, groupStyle)
        case let item as CollapsibleTimelineItem:
            self = .group(item, groupStyle)
+        case let item as LocationRoomTimelineItem:
+            self = .location(item, groupStyle)
        default:
            fatalError("Unknown timeline item")
        }
@@ -96,7 +99,8 @@ enum RoomTimelineViewProvider: Identifiable, Hashable {
             .unsupported(let item as RoomTimelineItemProtocol, _),
             .timelineStart(let item as RoomTimelineItemProtocol, _),
             .state(let item as RoomTimelineItemProtocol, _),
-             .group(let item as RoomTimelineItemProtocol, _):
+             .group(let item as RoomTimelineItemProtocol, _),
+             .location(let item as RoomTimelineItemProtocol, _):
            return item.id
        }
    }
@@ -114,9 +118,14 @@ enum RoomTimelineViewProvider: Identifiable, Hashable {
             .encrypted(let item as EventBasedTimelineItemProtocol, _),
             .sticker(let item as EventBasedTimelineItemProtocol, _),
             .unsupported(let item as EventBasedTimelineItemProtocol, _),
-             .state(let item as EventBasedTimelineItemProtocol, _):
+             .state(let item as EventBasedTimelineItemProtocol, _),
+             .location(let item as EventBasedTimelineItemProtocol, _):
            return item.properties.deliveryStatus == .sending || item.properties.deliveryStatus == .sendingFailed
-        default:
+        case .separator,
+             .readMarker,
+             .paginationIndicator,
+             .timelineStart,
+             .group:
            return false
        }
    }
@@ -124,7 +133,7 @@ enum RoomTimelineViewProvider: Identifiable, Hashable {
    /// Whether or not it is possible to send a reaction to this timeline item.
    var isReactable: Bool {
        switch self {
-        case .text, .image, .video, .audio, .file, .emote, .notice, .sticker:
+        case .text, .image, .video, .audio, .file, .emote, .notice, .sticker, .location:
            return true
        case .redacted, .encrypted, .unsupported, .state: // Event based items that aren't reactable
            return false
@@ -178,6 +187,8 @@ extension RoomTimelineViewProvider: View {
            StateRoomTimelineView(timelineItem: item)
        case .group(let item, _):
            CollapsibleRoomTimelineView(timelineItem: item)
+        case .location(let item, _):
+            LocationRoomTimelineView(timelineItem: item)
        }
    }
    
@@ -199,7 +210,8 @@ extension RoomTimelineViewProvider: View {
             .unsupported(_, let groupStyle),
             .timelineStart(_, let groupStyle),
             .state(_, let groupStyle),
-             .group(_, let groupStyle):
+             .group(_, let groupStyle),
+             .location(_, let groupStyle):
            return groupStyle
        }
    }