Update the SDK and enable event permalinks. (#2748)

ElementX.xcodeproj/project.pbxproj

@@ -7332,7 +7332,7 @@
 			repositoryURL = "https://github.com/matrix-org/matrix-rust-components-swift";
 			requirement = {
 				kind = exactVersion;
-				version = 1.1.60;
+				version = 1.1.61;
 			};
 		};
 		821C67C9A7F8CC3FD41B28B4 /* XCRemoteSwiftPackageReference "emojibase-bindings" */ = {

ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -139,8 +139,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/matrix-org/matrix-rust-components-swift",
       "state" : {
-        "revision" : "33cad4cb0c95a39bacdd8845d81da17e8a221481",
+        "revision" : "8def4c4c5cc5a95699431a509f1dcd55ec9b59d2",
-        "version" : "1.1.60"
+        "version" : "1.1.61"
       }
     },
     {

ElementX/Sources/Application/Navigation/AppRoutes.swift

@@ -142,11 +142,9 @@ struct MatrixPermalinkParser: URLParser {
         case .user(let id):
             return .userProfile(userID: id)
         case .eventOnRoomId(let roomID, let eventID):
-            // return .event(roomID: roomID, eventID: eventID)
+            return .event(roomID: roomID, eventID: eventID)
-            return nil
         case .eventOnRoomAlias(let alias, let eventID):
-            // return .eventOnRoomAlias(alias: alias, eventID: eventID)
+            return .eventOnRoomAlias(alias: alias, eventID: eventID)
-            return nil
         default:
             return nil
         }

ElementX/Sources/Mocks/RoomProxyMock.swift

@@ -44,7 +44,7 @@ struct RoomProxyMockConfiguration {
         mock.underlyingActions = Empty(completeImmediately: false).eraseToAnyPublisher()
         
         let timelineProvider = RoomTimelineProviderMock()
-        timelineProvider.paginationState = .init(backward: timelineStartReached ? .timelineStartReached : .idle, forward: .timelineStartReached)
+        timelineProvider.paginationState = .init(backward: timelineStartReached ? .timelineEndReached : .idle, forward: .timelineEndReached)
         timelineProvider.underlyingMembershipChangePublisher = PassthroughSubject().eraseToAnyPublisher()
         mock.underlyingTimelineProvider = timelineProvider
         return mock

ElementX/Sources/Screens/RoomPollsHistoryScreen/RoomPollsHistoryScreenViewModel.swift

@@ -83,7 +83,7 @@ class RoomPollsHistoryScreenViewModel: RoomPollsHistoryScreenViewModelType, Room
                 case .updatedTimelineItems:
                     self.updatePollsList(filter: state.bindings.filter)
                 case .paginationState(let paginationState):
-                    let canBackPaginate = paginationState.backward != .timelineStartReached
+                    let canBackPaginate = paginationState.backward != .timelineEndReached
                     if self.state.canBackPaginate != canBackPaginate {
                         self.state.canBackPaginate = canBackPaginate
                     }

ElementX/Sources/Screens/RoomScreen/RoomScreenInteractionHandler.swift

@@ -130,7 +130,7 @@ class RoomScreenInteractionHandler {
 
         if let encryptedItem = timelineItem as? EncryptedRoomTimelineItem {
             switch encryptedItem.encryptionType {
-            case .megolmV1AesSha2(let sessionID):
+            case .megolmV1AesSha2(let sessionID, _):
                 debugActions.append(.retryDecryption(sessionID: sessionID))
             default:
                 break

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -234,7 +234,7 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
         switch await timelineController.focusOnEvent(eventID, timelineSize: Constants.detachedTimelineSize) {
         case .success:
             state.timelineViewState.focussedEventID = eventID
-        case .failure(let error):
+        case .failure:
             MXLog.error("Failed to focus on event \(eventID)")
             displayError(.toast(L10n.commonFailed))
         }
@@ -475,7 +475,7 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
                 break
             }
             
-            if state.timelineViewState.paginationState.forward == .timelineStartReached {
+            if state.timelineViewState.paginationState.forward == .timelineEndReached {
                 focusLive()
             }
             

ElementX/Sources/Screens/RoomScreen/View/Timeline/HighlightedTimelineItemModifier.swift

@@ -47,6 +47,7 @@ private struct HighlightedTimelineItemModifier: ViewModifier {
     }
 }
 
+// swiftlint:disable line_length
 struct HighlightedTimelineItemModifier_Previews: PreviewProvider, TestablePreview {
     static var previews: some View {
         ScrollView {
@@ -83,3 +84,5 @@ struct HighlightedTimelineItemModifier_Previews: PreviewProvider, TestablePrevie
         }
     }
 }
+
+// swiftlint:enable line_length

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -817,7 +817,7 @@ class ClientProxy: ClientProxyProtocol {
         do {
             let roomListItem = try roomListService?.room(roomId: identifier)
             if roomListItem?.isTimelineInitialized() == false {
-                try await roomListItem?.initTimeline(eventTypeFilter: eventFilters)
+                try await roomListItem?.initTimeline(eventTypeFilter: eventFilters, internalIdPrefix: nil)
             }
             let fullRoom = try await roomListItem?.fullRoom()
             

ElementX/Sources/Services/Room/RoomProxy.swift

@@ -160,14 +160,13 @@ class RoomProxy: RoomProxyProtocol {
     }
     
     func timelineFocusedOnEvent(eventID: String, numberOfEvents: UInt16) async -> Result<TimelineProxyProtocol, RoomProxyError> {
-        .failure(.sdkError(RoomProxyMockError.generic))
+        do {
-//        do {
+            let timeline = try await room.timelineFocusedOnEvent(eventId: eventID, numContextEvents: numberOfEvents, internalIdPrefix: UUID().uuidString)
-//            let timeline = try await room.timelineFocusedOnEvent(eventId: eventID, numContextEvents: numberOfEvents, internalIdPrefix: UUID().uuidString)
+            return .success(TimelineProxy(timeline: timeline, isLive: false))
-//            return .success(TimelineProxy(timeline: timeline, isLive: false))
+        } catch {
-//        } catch {
+            MXLog.error("Failed to create a timeline focussed on: \(eventID) with error: \(error)")
-//            MXLog.error("Failed to create a timeline focussed on: \(eventID) with error: \(error)")
+            return .failure(.sdkError(error))
-//            return .failure(.sdkError(error))
+        }
-//        }
     }
     
     func redact(_ eventID: String) async -> Result<Void, RoomProxyError> {

ElementX/Sources/Services/Timeline/RoomTimelineProviderProtocol.swift

@@ -19,9 +19,9 @@ import Foundation
 import MatrixRustSDK
 
 struct PaginationState: Equatable {
-    static var `default` = PaginationState(backward: .idle, forward: .timelineStartReached)
+    static var `default` = PaginationState(backward: .idle, forward: .timelineEndReached)
-    let backward: BackPaginationStatus
+    let backward: PaginationStatus
-    let forward: BackPaginationStatus
+    let forward: PaginationStatus
 }
 
 @MainActor

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

@@ -36,7 +36,7 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
     private var client: UITestsSignalling.Client?
     
     init(listenForSignals: Bool = false) {
-        callbacks.send(.paginationState(PaginationState(backward: .idle, forward: .timelineStartReached)))
+        callbacks.send(.paginationState(PaginationState(backward: .idle, forward: .timelineEndReached)))
         callbacks.send(.isLive(true))
         
         guard listenForSignals else { return }
@@ -62,7 +62,7 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
     }
 
     func paginateBackwards(requestSize: UInt16) async -> Result<Void, RoomTimelineControllerError> {
-        callbacks.send(.paginationState(PaginationState(backward: .paginating, forward: .timelineStartReached)))
+        callbacks.send(.paginationState(PaginationState(backward: .paginating, forward: .timelineEndReached)))
         
         if client == nil {
             try? await simulateBackPagination()
@@ -173,8 +173,8 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
     /// Prepends the next chunk of items to the `timelineItems` array.
     private func simulateBackPagination() async throws {
         defer {
-            callbacks.send(.paginationState(PaginationState(backward: backPaginationResponses.isEmpty ? .timelineStartReached : .idle,
+            callbacks.send(.paginationState(PaginationState(backward: backPaginationResponses.isEmpty ? .timelineEndReached : .idle,
-                                                            forward: .timelineStartReached)))
+                                                            forward: .timelineEndReached)))
         }
         
         guard !backPaginationResponses.isEmpty else { return }

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

@@ -321,7 +321,7 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         
         // Check if we need to add anything to the top of the timeline.
         switch paginationState.backward {
-        case .timelineStartReached:
+        case .timelineEndReached:
             if !roomProxy.isEncryptedOneToOneRoom {
                 let timelineStart = TimelineStartRoomTimelineItem(name: roomProxy.name)
                 newTimelineItems.insert(timelineStart, at: 0)
@@ -335,7 +335,7 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         switch paginationState.forward {
         case .paginating:
             newTimelineItems.insert(PaginationIndicatorRoomTimelineItem(position: .end), at: newTimelineItems.count)
-        case .idle, .timelineStartReached:
+        case .idle, .timelineEndReached:
             break
         }
         

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

@@ -18,11 +18,16 @@ import UIKit
 
 struct EncryptedRoomTimelineItem: EventBasedTimelineItemProtocol, Equatable {
     enum EncryptionType: Hashable {
-        case megolmV1AesSha2(sessionId: String)
+        case megolmV1AesSha2(sessionID: String, cause: UTDCause)
         case olmV1Curve25519AesSha2(senderKey: String)
         case unknown
     }
     
+    enum UTDCause: Hashable {
+        case membership
+        case unknown
+    }
+    
     let id: TimelineItemIdentifier
     let body: String
     let encryptionType: EncryptionType

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

@@ -162,11 +162,15 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
                                             _ isOutgoing: Bool) -> RoomTimelineItemProtocol {
         var encryptionType = EncryptedRoomTimelineItem.EncryptionType.unknown
         switch encryptedMessage {
-        case .megolmV1AesSha2(let sessionId):
+        case .megolmV1AesSha2(let sessionID, let cause):
-            encryptionType = .megolmV1AesSha2(sessionId: sessionId)
+            let cause: EncryptedRoomTimelineItem.UTDCause = switch cause {
+            case .unknown: .unknown
+            case .membership: .membership
+            }
+            encryptionType = .megolmV1AesSha2(sessionID: sessionID, cause: cause)
         case .olmV1Curve25519AesSha2(let senderKey):
             encryptionType = .olmV1Curve25519AesSha2(senderKey: senderKey)
-        default:
+        case .unknown:
             break
         }
         

ElementX/Sources/Services/Timeline/TimelineProxy.swift

@@ -31,8 +31,8 @@ final class TimelineProxy: TimelineProxyProtocol {
     // periphery:ignore - retaining purpose
     private var timelineListener: RoomTimelineListener?
     
-    private let backPaginationStatusSubject = CurrentValueSubject<BackPaginationStatus, Never>(.idle)
+    private let backPaginationStatusSubject = CurrentValueSubject<PaginationStatus, Never>(.idle)
-    private let forwardPaginationStatusSubject = CurrentValueSubject<BackPaginationStatus, Never>(.timelineStartReached)
+    private let forwardPaginationStatusSubject = CurrentValueSubject<PaginationStatus, Never>(.timelineEndReached)
     private let timelineUpdatesSubject = PassthroughSubject<[TimelineDiff], Never>()
     
     private let actionsSubject = PassthroughSubject<TimelineProxyAction, Never>()
@@ -150,7 +150,7 @@ final class TimelineProxy: TimelineProxyProtocol {
         MXLog.info("Paginating backwards")
         
         do {
-            _ = try timeline.paginateBackwards(opts: .simpleRequest(eventLimit: requestSize, waitForToken: true))
+            _ = try await timeline.paginateBackwards(numEvents: requestSize)
             MXLog.info("Finished paginating backwards")
             
             return .success(())
@@ -161,28 +161,27 @@ final class TimelineProxy: TimelineProxyProtocol {
     }
     
     func paginateForwards(requestSize: UInt16) async -> Result<Void, TimelineProxyError> {
-        .failure(.failedPaginatingBackwards)
         // This extra check is necessary as forwards pagination status doesn't support subscribing.
         // We need it to make sure we send a valid status after a failure.
-//        guard forwardPaginationStatusSubject.value == .idle else {
+        guard forwardPaginationStatusSubject.value == .idle else {
-//            MXLog.error("Attempting to paginate forwards when already at the end.")
+            MXLog.error("Attempting to paginate forwards when already at the end.")
-//            return .failure(.failedPaginatingBackwards)
+            return .failure(.failedPaginatingBackwards)
-//        }
+        }
-//
+
-//        MXLog.info("Paginating forwards")
+        MXLog.info("Paginating forwards")
-//        forwardPaginationStatusSubject.send(.paginating)
+        forwardPaginationStatusSubject.send(.paginating)
-//
+
-//        do {
+        do {
-//            let timelineEndReached = try await timeline.paginateForwards(numEvents: requestSize)
+            let timelineEndReached = try await timeline.focusedPaginateForwards(numEvents: 16)
-//            MXLog.info("Finished paginating forwards")
+            MXLog.info("Finished paginating forwards")
-//
+
-//            forwardPaginationStatusSubject.send(timelineEndReached ? .timelineEndReached : .idle)
+            forwardPaginationStatusSubject.send(timelineEndReached ? .timelineEndReached : .idle)
-//            return .success(())
+            return .success(())
-//        } catch {
+        } catch {
-//            MXLog.error("Failed paginating forwards with error: \(error)")
+            MXLog.error("Failed paginating forwards with error: \(error)")
-//            forwardPaginationStatusSubject.send(.idle)
+            forwardPaginationStatusSubject.send(.idle)
-//            return .failure(.failedPaginatingBackwards)
+            return .failure(.failedPaginatingBackwards)
-//        }
+        }
     }
     
     func retryDecryption(for sessionID: String) async {
@@ -560,7 +559,7 @@ final class TimelineProxy: TimelineProxyProtocol {
         }
         
         // Forward pagination doesn't support observation, set the initial state ourself.
-        forwardPaginationStatusSubject.send(isLive ? .timelineStartReached : .idle)
+        forwardPaginationStatusSubject.send(isLive ? .timelineEndReached : .idle)
     }
 }
 
@@ -576,14 +575,14 @@ private final class RoomTimelineListener: TimelineListener {
     }
 }
 
-private final class RoomPaginationStatusListener: BackPaginationStatusListener {
+private final class RoomPaginationStatusListener: PaginationStatusListener {
-    private let onUpdateClosure: (BackPaginationStatus) -> Void
+    private let onUpdateClosure: (PaginationStatus) -> Void
 
-    init(_ onUpdateClosure: @escaping (BackPaginationStatus) -> Void) {
+    init(_ onUpdateClosure: @escaping (PaginationStatus) -> Void) {
         self.onUpdateClosure = onUpdateClosure
     }
 
-    func onUpdate(status: BackPaginationStatus) {
+    func onUpdate(status: PaginationStatus) {
         onUpdateClosure(status)
     }
 }

project.yml

@@ -49,7 +49,7 @@ packages:
   # Element/Matrix dependencies
   MatrixRustSDK:
     url: https://github.com/matrix-org/matrix-rust-components-swift
-    exactVersion: 1.1.60
+    exactVersion: 1.1.61
     # path: ../matrix-rust-sdk
   Compound:
     url: https://github.com/element-hq/compound-ios