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
2026-11-02 21:33:26 +00:00 · 2022-11-08 13:17:38 +02:00
parent 7a7680b165
commit 89742ceb53
17 changed files with 312 additions and 21 deletions
@@ -19,16 +19,6 @@ import UIKit

 enum RoomScreenViewModelAction { }

-enum TimelineItemContextMenuAction: Identifiable, Hashable {
-    case copy
-    case quote
-    case copyPermalink
-    case redact
-    case reply
-    
-    var id: Self { self }
-}
-
 enum RoomScreenComposerMode: Equatable {
    case `default`
    case reply(id: String, displayName: String)
@@ -67,6 +57,8 @@ struct RoomScreenViewStateBindings {
    
    /// Information describing the currently displayed alert.
    var alertInfo: AlertInfo<RoomScreenErrorType>?
+    
+    var debugInfo: DebugScreen.DebugInfo?
 }

 enum RoomScreenErrorType: Hashable {
@@ -161,10 +161,10 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
        }
    }
    
-    private func contextMenuActionsForItemId(_ itemId: String) -> [TimelineItemContextMenuAction] {
+    private func contextMenuActionsForItemId(_ itemId: String) -> TimelineItemContextMenuActions {
        guard let timelineItem = timelineController.timelineItems.first(where: { $0.id == itemId }),
              timelineItem is EventBasedTimelineItemProtocol else {
-            return []
+            return .init(actions: [])
        }
        
        var actions: [TimelineItemContextMenuAction] = [
@@ -175,7 +175,7 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
            actions.append(.redact)
        }
        
-        return actions
+        return .init(actions: actions)
    }
    
    private func processContentMenuAction(_ action: TimelineItemContextMenuAction, itemId: String) {
@@ -202,6 +202,10 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
        case .reply:
            state.bindings.composerFocused = true
            state.composerMode = .reply(id: item.id, displayName: item.senderDisplayName ?? item.senderId)
+        case .viewSource:
+            let debugDescription = timelineController.debugDescriptionFor(item.id)
+            MXLog.info(debugDescription)
+            state.bindings.debugInfo = .init(title: "Timeline item", content: debugDescription)
        }
        
        switch action {
@@ -0,0 +1,53 @@
+//
+// 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 SwiftUI
+
+struct DebugScreen: View {
+    struct DebugInfo: Identifiable {
+        let id = UUID()
+        let title: String
+        var content: String
+    }
+    
+    @Environment(\.presentationMode) private var presentationMode
+    
+    let info: DebugInfo
+    
+    var body: some View {
+        NavigationView {
+            ScrollView {
+                Text(info.content)
+                    .padding()
+                    .font(.element.footnote)
+            }
+            .navigationBarTitleDisplayMode(.inline)
+            .navigationTitle(info.title)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button(ElementL10n.actionCancel) {
+                        presentationMode.wrappedValue.dismiss()
+                    }
+                }
+                ToolbarItem(placement: .secondaryAction) {
+                    Button(ElementL10n.actionCopy) {
+                        UIPasteboard.general.string = info.content
+                    }
+                }
+            }
+        }
+    }
+}
@@ -41,6 +41,7 @@ struct RoomScreen: View {
            }
        }
        .alert(item: $context.alertInfo) { $0.alert }
+        .sheet(item: $context.debugInfo) { DebugScreen(info: $0) }
    }
    
    private func sendMessage() {
@@ -0,0 +1,91 @@
+//
+// 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 SwiftUI
+
+struct EncryptedRoomTimelineView: View {
+    @State private var showEncryptionInfo = false
+    
+    let timelineItem: EncryptedRoomTimelineItem
+    
+    var body: some View {
+        TimelineStyler(timelineItem: timelineItem) {
+            Button {
+                showEncryptionInfo = !showEncryptionInfo
+            } label: {
+                HStack(alignment: .top) {
+                    Image(systemName: "lock.shield")
+                        .foregroundColor(.red)
+                        .padding(.top, 1.0)
+                    if showEncryptionInfo {
+                        FormattedBodyText(text: encryptionDetails)
+                    } else {
+                        FormattedBodyText(text: timelineItem.text)
+                    }
+                }
+                .animation(nil, value: showEncryptionInfo)
+            }
+        }
+        .id(timelineItem.id)
+    }
+    
+    private var encryptionDetails: String {
+        switch timelineItem.encryptionType {
+        case .unknown:
+            return "Unknown"
+        case .megolmV1AesSha2(let sessionId):
+            return "Megolm session id: \(sessionId)"
+        case .olmV1Curve25519AesSha2(let senderKey):
+            return "Olm sender key: \(senderKey)"
+        }
+    }
+}
+
+struct EncryptedRoomTimelineView_Previews: PreviewProvider {
+    static var previews: some View {
+        body.preferredColorScheme(.light)
+        body.preferredColorScheme(.dark)
+        body.preferredColorScheme(.light)
+            .timelineStyle(.plain)
+        body.preferredColorScheme(.dark)
+            .timelineStyle(.plain)
+    }
+    
+    @ViewBuilder
+    static var body: some View {
+        VStack(alignment: .leading, spacing: 20.0) {
+            EncryptedRoomTimelineView(timelineItem: itemWith(text: "Text",
+                                                             timestamp: "Now",
+                                                             isOutgoing: false,
+                                                             senderId: "Bob"))
+            
+            EncryptedRoomTimelineView(timelineItem: itemWith(text: "Some other text",
+                                                             timestamp: "Later",
+                                                             isOutgoing: true,
+                                                             senderId: "Anne"))
+        }
+    }
+    
+    private static func itemWith(text: String, timestamp: String, isOutgoing: Bool, senderId: String) -> EncryptedRoomTimelineItem {
+        EncryptedRoomTimelineItem(id: UUID().uuidString,
+                                  text: text,
+                                  encryptionType: .unknown,
+                                  timestamp: timestamp,
+                                  inGroupState: .single,
+                                  isOutgoing: isOutgoing,
+                                  senderId: senderId)
+    }
+}
@@ -16,13 +16,38 @@

 import SwiftUI

+struct TimelineItemContextMenuActions {
+    let actions: [TimelineItemContextMenuAction]
+    let debugActions: [TimelineItemContextMenuAction] = [.viewSource]
+}
+
+enum TimelineItemContextMenuAction: Identifiable, Hashable {
+    case copy
+    case quote
+    case copyPermalink
+    case redact
+    case reply
+    case viewSource
+    
+    var id: Self { self }
+}
+
 public struct TimelineItemContextMenu: View {
-    let contextMenuActions: [TimelineItemContextMenuAction]
+    let contextMenuActions: TimelineItemContextMenuActions
    let callback: (TimelineItemContextMenuAction) -> Void
    
    @ViewBuilder
    public var body: some View {
-        ForEach(contextMenuActions, id: \.self) { item in
+        viewsForActions(contextMenuActions.actions)
+        Menu {
+            viewsForActions(contextMenuActions.debugActions)
+        } label: {
+            Label("Developer", systemImage: "hammer")
+        }
+    }
+    
+    private func viewsForActions(_ actions: [TimelineItemContextMenuAction]) -> some View {
+        ForEach(actions, id: \.self) { item in
            switch item {
            case .copy:
                Button { callback(item) } label: {
@@ -44,6 +69,10 @@ public struct TimelineItemContextMenu: View {
                Button(role: .destructive) { callback(item) } label: {
                    Label(ElementL10n.messageActionItemRedact, systemImage: "trash")
                }
+            case .viewSource:
+                Button { callback(item) } label: {
+                    Label(ElementL10n.viewSource, systemImage: "doc.text.below.ecg")
+                }
            }
        }
    }
@@ -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"
+    }
 }
@@ -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:
@@ -46,4 +46,6 @@ protocol RoomTimelineControllerProtocol {
    func sendReply(_ message: String, to itemId: String) async

    func redact(_ eventID: String) async
+    
+    func debugDescriptionFor(_ itemId: String) -> String
 }
@@ -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()
+    }
 }
@@ -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()
+}
@@ -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,
@@ -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")
        }
@@ -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)
        }
    }
 }