Non-decryptable timeline items and debug menu (#300)

* Fixes #292 - Added a timeline item context menu option for printing and showing their debug description
* Fixes #291 - Add support for non-decryptable timeline items

ElementX/Sources/Services/Timeline/MockRoomTimelineController.swift

@@ -108,4 +108,8 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
     func sendReply(_ message: String, to itemId: String) async { }
     
     func redact(_ eventID: String) async { }
+    
+    func debugDescriptionFor(_ itemId: String) -> String {
+        "Mock debug description"
+    }
 }

ElementX/Sources/Services/Timeline/RoomTimelineController.swift

@@ -126,6 +126,25 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
             break
         }
     }
+    
+    // Handle this paralel to the timeline items so we're not forced
+    // to bundle the Rust side objects within them
+    func debugDescriptionFor(_ itemId: String) -> String {
+        var description = "Unknown item"
+        timelineProvider.itemsPublisher.value.forEach { timelineItemProxy in
+            switch timelineItemProxy {
+            case .event(let item):
+                if item.id == itemId {
+                    description = item.debugDescription
+                    return
+                }
+            default:
+                break
+            }
+        }
+        
+        return description
+    }
 
     // MARK: - Private
     
@@ -155,8 +174,6 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
             
             switch itemProxy {
             case .event(let eventItem):
-                guard eventItem.isMessage || eventItem.isRedacted else { break } // To be handled in the future
-
                 newTimelineItems.append(timelineItemFactory.buildTimelineItemFor(eventItemProxy: eventItem,
                                                                                  inGroupState: inGroupState))
             default:

ElementX/Sources/Services/Timeline/RoomTimelineControllerProtocol.swift

@@ -46,4 +46,6 @@ protocol RoomTimelineControllerProtocol {
     func sendReply(_ message: String, to itemId: String) async
 
     func redact(_ eventID: String) async
+    
+    func debugDescriptionFor(_ itemId: String) -> String
 }

ElementX/Sources/Services/Timeline/TimelineItemProxy.swift

@@ -20,7 +20,7 @@ import MatrixRustSDK
 enum TimelineItemProxy {
     case event(EventTimelineItemProxy)
     case virtual(MatrixRustSDK.VirtualTimelineItem)
-    case other(MatrixRustSDK.TimelineItem)
+    case unknown(MatrixRustSDK.TimelineItem)
     
     init(item: MatrixRustSDK.TimelineItem) {
         if let eventItem = item.asEvent() {
@@ -28,7 +28,7 @@ enum TimelineItemProxy {
         } else if let virtualItem = item.asVirtual() {
             self = .virtual(virtualItem)
         } else {
-            self = .other(item)
+            self = .unknown(item)
         }
     }
 
@@ -42,7 +42,7 @@ enum TimelineItemProxy {
 }
 
 /// A light wrapper around event timeline items returned from Rust.
-struct EventTimelineItemProxy {
+struct EventTimelineItemProxy: CustomDebugStringConvertible {
     let item: MatrixRustSDK.EventTimelineItem
     
     init(item: MatrixRustSDK.EventTimelineItem) {
@@ -94,4 +94,10 @@ struct EventTimelineItemProxy {
             return .now
         }
     }
+    
+    // MARK: - CustomDebugStringConvertible
+    
+    var debugDescription: String {
+        item.fmtDebug()
+    }
 }

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

@@ -0,0 +1,38 @@
+//
+// 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 UIKit
+
+struct EncryptedRoomTimelineItem: EventBasedTimelineItemProtocol, Identifiable, Equatable {
+    enum EncryptionType: Equatable {
+        case megolmV1AesSha2(sessionId: String)
+        case olmV1Curve25519AesSha2(senderKey: String)
+        case unknown
+    }
+    
+    let id: String
+    let text: String
+    let encryptionType: EncryptionType
+    let timestamp: String
+    let inGroupState: TimelineItemInGroupState
+    let isOutgoing: Bool
+    
+    let senderId: String
+    var senderDisplayName: String?
+    var senderAvatar: UIImage?
+    
+    var properties = RoomTimelineItemProperties()
+}

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

@@ -41,6 +41,10 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
         let avatarURL = roomProxy.avatarURLStringForUserId(eventItemProxy.sender)
         let avatarImage = mediaProvider.imageFromURLString(avatarURL, avatarSize: .user(on: .timeline))
         let isOutgoing = eventItemProxy.isOwn
+        
+        if let encryptedMessage = eventItemProxy.content.asUnableToDecrypt() {
+            return buildEncryptedTimelineItem(eventItemProxy, encryptedMessage, isOutgoing, inGroupState, displayName, avatarImage)
+        }
 
         if eventItemProxy.isRedacted {
             return buildRedactedTimelineItem(eventItemProxy, isOutgoing, inGroupState, displayName, avatarImage)
@@ -67,7 +71,36 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
     }
     
     // MARK: - Private
-
+    
+    // swiftlint:disable:next function_parameter_count
+    private func buildEncryptedTimelineItem(_ eventItemProxy: EventTimelineItemProxy,
+                                            _ encryptedMessage: EncryptedMessage,
+                                            _ isOutgoing: Bool,
+                                            _ inGroupState: TimelineItemInGroupState,
+                                            _ displayName: String?,
+                                            _ avatarImage: UIImage?) -> RoomTimelineItemProtocol {
+        var encryptionType = EncryptedRoomTimelineItem.EncryptionType.unknown
+        switch encryptedMessage {
+        case .megolmV1AesSha2(let sessionId):
+            encryptionType = .megolmV1AesSha2(sessionId: sessionId)
+        case .olmV1Curve25519AesSha2(let senderKey):
+            encryptionType = .olmV1Curve25519AesSha2(senderKey: senderKey)
+        default:
+            break
+        }
+        
+        return EncryptedRoomTimelineItem(id: eventItemProxy.id,
+                                         text: ElementL10n.encryptionInformationDecryptionError,
+                                         encryptionType: encryptionType,
+                                         timestamp: eventItemProxy.originServerTs.formatted(date: .omitted, time: .shortened),
+                                         inGroupState: inGroupState,
+                                         isOutgoing: isOutgoing,
+                                         senderId: eventItemProxy.sender,
+                                         senderDisplayName: displayName,
+                                         senderAvatar: avatarImage,
+                                         properties: RoomTimelineItemProperties())
+    }
+    
     private func buildRedactedTimelineItem(_ eventItemProxy: EventTimelineItemProxy,
                                            _ isOutgoing: Bool,
                                            _ inGroupState: TimelineItemInGroupState,

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

@@ -31,6 +31,8 @@ struct RoomTimelineViewFactory: RoomTimelineViewFactoryProtocol {
             return .emote(item)
         case let item as RedactedRoomTimelineItem:
             return .redacted(item)
+        case let item as EncryptedRoomTimelineItem:
+            return .encrypted(item)
         default:
             fatalError("Unknown timeline item")
         }

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

@@ -24,6 +24,7 @@ enum RoomTimelineViewProvider: Identifiable, Equatable {
     case emote(EmoteRoomTimelineItem)
     case notice(NoticeRoomTimelineItem)
     case redacted(RedactedRoomTimelineItem)
+    case encrypted(EncryptedRoomTimelineItem)
     
     var id: String {
         switch self {
@@ -39,6 +40,8 @@ enum RoomTimelineViewProvider: Identifiable, Equatable {
             return item.id
         case .redacted(let item):
             return item.id
+        case .encrypted(let item):
+            return item.id
         }
     }
 }
@@ -58,6 +61,8 @@ extension RoomTimelineViewProvider: View {
             NoticeRoomTimelineView(timelineItem: item)
         case .redacted(let item):
             RedactedRoomTimelineView(timelineItem: item)
+        case .encrypted(let item):
+            EncryptedRoomTimelineView(timelineItem: item)
         }
     }
 }