Better identification system for virtual items (#1361)

* better identification system

* better handling for unknown

ElementX/Sources/Services/Timeline/Fixtures/RoomTimelineItemFixtures.swift

@@ -20,14 +20,14 @@ enum RoomTimelineItemFixtures {
     /// The default timeline items used in Xcode previews etc.
     static var `default`: [RoomTimelineItemProtocol] = [
         SeparatorRoomTimelineItem(id: .init(timelineID: "Yesterday"), text: "Yesterday"),
-        TextRoomTimelineItem(id: .init(timelineID: UUID().uuidString),
+        TextRoomTimelineItem(id: .random,
                              timestamp: "10:10 AM",
                              isOutgoing: false,
                              isEditable: false,
                              sender: .init(id: "", displayName: "Jacob"),
                              content: .init(body: "That looks so good!"),
                              properties: RoomTimelineItemProperties(isEdited: true)),
-        TextRoomTimelineItem(id: .init(timelineID: UUID().uuidString),
+        TextRoomTimelineItem(id: .random,
                              timestamp: "10:11 AM",
                              isOutgoing: false,
                              isEditable: false,
@@ -36,7 +36,7 @@ enum RoomTimelineItemFixtures {
                              properties: RoomTimelineItemProperties(reactions: [
                                  AggregatedReaction(accountOwnerID: "me", key: "🙌", senders: [ReactionSender(senderID: "me", timestamp: Date())])
                              ])),
-        TextRoomTimelineItem(id: .init(timelineID: UUID().uuidString),
+        TextRoomTimelineItem(id: .random,
                              timestamp: "10:11 AM",
                              isOutgoing: false,
                              isEditable: false,
@@ -53,20 +53,20 @@ enum RoomTimelineItemFixtures {
                                                     ])
                              ])),
         SeparatorRoomTimelineItem(id: .init(timelineID: "Today"), text: "Today"),
-        TextRoomTimelineItem(id: .init(timelineID: UUID().uuidString),
+        TextRoomTimelineItem(id: .random,
                              timestamp: "5 PM",
                              isOutgoing: false,
                              isEditable: false,
                              sender: .init(id: "", displayName: "Helena"),
                              content: .init(body: "Wow, cool. Ok, lets go the usual place tomorrow?! Is that too soon?  Here’s the menu, let me know what you want it’s on me!"),
                              properties: RoomTimelineItemProperties(orderedReadReceipts: [ReadReceipt(userID: "alice", formattedTimestamp: nil)])),
-        TextRoomTimelineItem(id: .init(timelineID: UUID().uuidString),
+        TextRoomTimelineItem(id: .random,
                              timestamp: "5 PM",
                              isOutgoing: true,
                              isEditable: true,
                              sender: .init(id: "", displayName: "Bob"),
                              content: .init(body: "And John's speech was amazing!")),
-        TextRoomTimelineItem(id: .init(timelineID: UUID().uuidString),
+        TextRoomTimelineItem(id: .random,
                              timestamp: "5 PM",
                              isOutgoing: true,
                              isEditable: true,
@@ -77,7 +77,7 @@ enum RoomTimelineItemFixtures {
                                                                                           ReadReceipt(userID: "bob", formattedTimestamp: nil),
                                                                                           ReadReceipt(userID: "charlie", formattedTimestamp: nil),
                                                                                           ReadReceipt(userID: "dan", formattedTimestamp: nil)])),
-        TextRoomTimelineItem(id: .init(timelineID: UUID().uuidString),
+        TextRoomTimelineItem(id: .random,
                              timestamp: "5 PM",
                              isOutgoing: false,
                              isEditable: false,
@@ -216,7 +216,7 @@ enum RoomTimelineItemFixtures {
 
 private extension TextRoomTimelineItem {
     init(text: String, senderDisplayName: String) {
-        self.init(id: .init(timelineID: UUID().uuidString),
+        self.init(id: .random,
                   timestamp: "10:47 am",
                   isOutgoing: senderDisplayName == "Alice",
                   isEditable: false,

ElementX/Sources/Services/Timeline/RoomTimelineProvider.swift

@@ -171,14 +171,14 @@ class RoomTimelineProvider: RoomTimelineProviderProtocol {
 private extension TimelineItem {
     var debugIdentifier: DebugIdentifier {
         if let virtualTimelineItem = asVirtual() {
-            return virtualTimelineItem.debugIdentifier
+            return .virtual(timelineID: String(uniqueId()), dscription: virtualTimelineItem.description)
         } else if let eventTimelineItem = asEvent() {
             return .event(timelineID: String(uniqueId()),
                           eventID: eventTimelineItem.eventId(),
                           transactionID: eventTimelineItem.transactionId())
         }
         
-        return .unknown
+        return .unknown(timelineID: String(uniqueId()))
     }
 }
 
@@ -189,27 +189,27 @@ private extension TimelineItemProxy {
             return .event(timelineID: eventTimelineItem.id.timelineID,
                           eventID: eventTimelineItem.id.eventID,
                           transactionID: eventTimelineItem.id.transactionID)
-        case .virtual(let virtualTimelineItem):
-            return virtualTimelineItem.debugIdentifier
-        case .unknown:
-            return .unknown
+        case .virtual(let virtualTimelineItem, let timelineID):
+            return .virtual(timelineID: timelineID, dscription: virtualTimelineItem.description)
+        case .unknown(let item):
+            return .unknown(timelineID: String(item.uniqueId()))
         }
     }
 }
 
 private extension VirtualTimelineItem {
-    var debugIdentifier: DebugIdentifier {
+    var description: String {
         switch self {
         case .dayDivider(let timestamp):
-            return .virtual("DayDiviver(\(timestamp))")
+            return "DayDiviver(\(timestamp))"
         case .readMarker:
-            return .virtual("ReadMarker")
+            return "ReadMarker"
         }
     }
 }
 
 enum DebugIdentifier {
-    case event(timelineID: String?, eventID: String?, transactionID: String?)
-    case virtual(String)
-    case unknown
+    case event(timelineID: String, eventID: String?, transactionID: String?)
+    case virtual(timelineID: String, dscription: String)
+    case unknown(timelineID: String)
 }

ElementX/Sources/Services/Timeline/TimelineController/RoomTimelineController.swift

@@ -349,16 +349,15 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
             }
             
             return timelineItem
-        case .virtual(let virtualItem):
+        case .virtual(let virtualItem, let timelineID):
             switch virtualItem {
             case .dayDivider(let timestamp):
                 let date = Date(timeIntervalSince1970: TimeInterval(timestamp / 1000))
                 let dateString = date.formatted(date: .complete, time: .omitted)
                 
-                let identifier = date.formatted(.iso8601.dateSeparator(.dash))
-                return SeparatorRoomTimelineItem(id: .init(timelineID: identifier), text: dateString)
+                return SeparatorRoomTimelineItem(id: .init(timelineID: timelineID), text: dateString)
             case .readMarker:
-                return ReadMarkerRoomTimelineItem()
+                return ReadMarkerRoomTimelineItem(id: .init(timelineID: timelineID))
             }
         case .unknown:
             return nil

ElementX/Sources/Services/Timeline/TimelineItemProxy.swift

@@ -31,17 +31,24 @@ struct TimelineItemIdentifier: Hashable {
     var transactionID: String?
 }
 
+extension TimelineItemIdentifier {
+    /// Use only for mocks/tests
+    static var random: Self {
+        .init(timelineID: UUID().uuidString)
+    }
+}
+
 /// A light wrapper around timeline items returned from Rust.
 enum TimelineItemProxy {
     case event(EventTimelineItemProxy)
-    case virtual(MatrixRustSDK.VirtualTimelineItem)
+    case virtual(MatrixRustSDK.VirtualTimelineItem, timelineID: String)
     case unknown(MatrixRustSDK.TimelineItem)
     
     init(item: MatrixRustSDK.TimelineItem) {
         if let eventItem = item.asEvent() {
             self = .event(EventTimelineItemProxy(item: eventItem, id: item.uniqueId()))
         } else if let virtualItem = item.asVirtual() {
-            self = .virtual(virtualItem)
+            self = .virtual(virtualItem, timelineID: String(item.uniqueId()))
         } else {
             self = .unknown(item)
         }

ElementX/Sources/Services/Timeline/TimelineItems/Items/Virtual/ReadMarkerRoomTimelineItem.swift

@@ -17,5 +17,5 @@
 import Foundation
 
 struct ReadMarkerRoomTimelineItem: DecorationTimelineItemProtocol, Equatable {
-    let id = TimelineItemIdentifier(timelineID: "readMarkerTimelineItemIdentifier")
+    let id: TimelineItemIdentifier
 }