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/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)
         }
     }
 }