From 2c4a8b34a70c78d2d74f74b642f0ec85c4ef6814 Mon Sep 17 00:00:00 2001 From: Stefan Ceriu Date: Wed, 21 May 2025 21:57:23 +0300 Subject: [PATCH] Bump the SDK to 25.05.21 and adopt the new way of dealing with timelines and delegates. The room list items no longer hold any timeline instances and they can now be created through the normal `room.timelineWithConfiguration` mechanism. This also means that we can move the UTD hook away from the sync service and into the client itself but setting it is now fallible as it can only be set once. --- ElementX.xcodeproj/project.pbxproj | 2 +- .../xcshareddata/swiftpm/Package.resolved | 4 +- .../Mocks/Generated/SDKGeneratedMocks.swift | 612 ++++++++++-------- .../Sources/Services/Client/ClientProxy.swift | 30 +- .../Services/Room/JoinedRoomProxy.swift | 39 +- NSE/Sources/NSEUserSession.swift | 2 +- project.yml | 2 +- 7 files changed, 404 insertions(+), 287 deletions(-) diff --git a/ElementX.xcodeproj/project.pbxproj b/ElementX.xcodeproj/project.pbxproj index 47f30d348..4dd135a19 100644 --- a/ElementX.xcodeproj/project.pbxproj +++ b/ElementX.xcodeproj/project.pbxproj @@ -8708,7 +8708,7 @@ repositoryURL = "https://github.com/element-hq/matrix-rust-components-swift"; requirement = { kind = exactVersion; - version = 25.05.19; + version = 25.05.21; }; }; 701C7BEF8F70F7A83E852DCC /* XCRemoteSwiftPackageReference "GZIP" */ = { diff --git a/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved index f5de71ae3..f7c1681b8 100644 --- a/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved +++ b/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved @@ -158,8 +158,8 @@ "kind" : "remoteSourceControl", "location" : "https://github.com/element-hq/matrix-rust-components-swift", "state" : { - "revision" : "a290a27931a75db67b93f27329b09f5110553415", - "version" : "25.5.19" + "revision" : "ce4a5f25ada21246d62e4b54c26fb1414432fb77", + "version" : "25.5.21" } }, { diff --git a/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift b/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift index d5208c5cb..681fb5134 100644 --- a/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift +++ b/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift @@ -1125,6 +1125,75 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { } } + //MARK: - getInviteAvatarsDisplayPolicy + + open var getInviteAvatarsDisplayPolicyThrowableError: Error? + var getInviteAvatarsDisplayPolicyUnderlyingCallsCount = 0 + open var getInviteAvatarsDisplayPolicyCallsCount: Int { + get { + if Thread.isMainThread { + return getInviteAvatarsDisplayPolicyUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = getInviteAvatarsDisplayPolicyUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + getInviteAvatarsDisplayPolicyUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + getInviteAvatarsDisplayPolicyUnderlyingCallsCount = newValue + } + } + } + } + open var getInviteAvatarsDisplayPolicyCalled: Bool { + return getInviteAvatarsDisplayPolicyCallsCount > 0 + } + + var getInviteAvatarsDisplayPolicyUnderlyingReturnValue: InviteAvatars! + open var getInviteAvatarsDisplayPolicyReturnValue: InviteAvatars! { + get { + if Thread.isMainThread { + return getInviteAvatarsDisplayPolicyUnderlyingReturnValue + } else { + var returnValue: InviteAvatars? = nil + DispatchQueue.main.sync { + returnValue = getInviteAvatarsDisplayPolicyUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + getInviteAvatarsDisplayPolicyUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + getInviteAvatarsDisplayPolicyUnderlyingReturnValue = newValue + } + } + } + } + open var getInviteAvatarsDisplayPolicyClosure: (() async throws -> InviteAvatars)? + + open override func getInviteAvatarsDisplayPolicy() async throws -> InviteAvatars { + if let error = getInviteAvatarsDisplayPolicyThrowableError { + throw error + } + getInviteAvatarsDisplayPolicyCallsCount += 1 + if let getInviteAvatarsDisplayPolicyClosure = getInviteAvatarsDisplayPolicyClosure { + return try await getInviteAvatarsDisplayPolicyClosure() + } else { + return getInviteAvatarsDisplayPolicyReturnValue + } + } + //MARK: - getMediaContent open var getMediaContentMediaSourceThrowableError: Error? @@ -1275,6 +1344,75 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { } } + //MARK: - getMediaPreviewDisplayPolicy + + open var getMediaPreviewDisplayPolicyThrowableError: Error? + var getMediaPreviewDisplayPolicyUnderlyingCallsCount = 0 + open var getMediaPreviewDisplayPolicyCallsCount: Int { + get { + if Thread.isMainThread { + return getMediaPreviewDisplayPolicyUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = getMediaPreviewDisplayPolicyUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + getMediaPreviewDisplayPolicyUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + getMediaPreviewDisplayPolicyUnderlyingCallsCount = newValue + } + } + } + } + open var getMediaPreviewDisplayPolicyCalled: Bool { + return getMediaPreviewDisplayPolicyCallsCount > 0 + } + + var getMediaPreviewDisplayPolicyUnderlyingReturnValue: MediaPreviews! + open var getMediaPreviewDisplayPolicyReturnValue: MediaPreviews! { + get { + if Thread.isMainThread { + return getMediaPreviewDisplayPolicyUnderlyingReturnValue + } else { + var returnValue: MediaPreviews? = nil + DispatchQueue.main.sync { + returnValue = getMediaPreviewDisplayPolicyUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + getMediaPreviewDisplayPolicyUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + getMediaPreviewDisplayPolicyUnderlyingReturnValue = newValue + } + } + } + } + open var getMediaPreviewDisplayPolicyClosure: (() async throws -> MediaPreviews)? + + open override func getMediaPreviewDisplayPolicy() async throws -> MediaPreviews { + if let error = getMediaPreviewDisplayPolicyThrowableError { + throw error + } + getMediaPreviewDisplayPolicyCallsCount += 1 + if let getMediaPreviewDisplayPolicyClosure = getMediaPreviewDisplayPolicyClosure { + return try await getMediaPreviewDisplayPolicyClosure() + } else { + return getMediaPreviewDisplayPolicyReturnValue + } + } + //MARK: - getMediaThumbnail open var getMediaThumbnailMediaSourceWidthHeightThrowableError: Error? @@ -3650,6 +3788,7 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { //MARK: - setDelegate + open var setDelegateDelegateThrowableError: Error? var setDelegateDelegateUnderlyingCallsCount = 0 open var setDelegateDelegateCallsCount: Int { get { @@ -3704,16 +3843,19 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { } } } - open var setDelegateDelegateClosure: ((ClientDelegate?) -> TaskHandle?)? + open var setDelegateDelegateClosure: ((ClientDelegate?) throws -> TaskHandle?)? - open override func setDelegate(delegate: ClientDelegate?) -> TaskHandle? { + open override func setDelegate(delegate: ClientDelegate?) throws -> TaskHandle? { + if let error = setDelegateDelegateThrowableError { + throw error + } setDelegateDelegateCallsCount += 1 setDelegateDelegateReceivedDelegate = delegate DispatchQueue.main.async { self.setDelegateDelegateReceivedInvocations.append(delegate) } if let setDelegateDelegateClosure = setDelegateDelegateClosure { - return setDelegateDelegateClosure(delegate) + return try setDelegateDelegateClosure(delegate) } else { return setDelegateDelegateReturnValue } @@ -3765,6 +3907,98 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { try await setDisplayNameNameClosure?(name) } + //MARK: - setInviteAvatarsDisplayPolicy + + open var setInviteAvatarsDisplayPolicyPolicyThrowableError: Error? + var setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount = 0 + open var setInviteAvatarsDisplayPolicyPolicyCallsCount: Int { + get { + if Thread.isMainThread { + return setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount = newValue + } + } + } + } + open var setInviteAvatarsDisplayPolicyPolicyCalled: Bool { + return setInviteAvatarsDisplayPolicyPolicyCallsCount > 0 + } + open var setInviteAvatarsDisplayPolicyPolicyReceivedPolicy: InviteAvatars? + open var setInviteAvatarsDisplayPolicyPolicyReceivedInvocations: [InviteAvatars] = [] + open var setInviteAvatarsDisplayPolicyPolicyClosure: ((InviteAvatars) async throws -> Void)? + + open override func setInviteAvatarsDisplayPolicy(policy: InviteAvatars) async throws { + if let error = setInviteAvatarsDisplayPolicyPolicyThrowableError { + throw error + } + setInviteAvatarsDisplayPolicyPolicyCallsCount += 1 + setInviteAvatarsDisplayPolicyPolicyReceivedPolicy = policy + DispatchQueue.main.async { + self.setInviteAvatarsDisplayPolicyPolicyReceivedInvocations.append(policy) + } + try await setInviteAvatarsDisplayPolicyPolicyClosure?(policy) + } + + //MARK: - setMediaPreviewDisplayPolicy + + open var setMediaPreviewDisplayPolicyPolicyThrowableError: Error? + var setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount = 0 + open var setMediaPreviewDisplayPolicyPolicyCallsCount: Int { + get { + if Thread.isMainThread { + return setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount = newValue + } + } + } + } + open var setMediaPreviewDisplayPolicyPolicyCalled: Bool { + return setMediaPreviewDisplayPolicyPolicyCallsCount > 0 + } + open var setMediaPreviewDisplayPolicyPolicyReceivedPolicy: MediaPreviews? + open var setMediaPreviewDisplayPolicyPolicyReceivedInvocations: [MediaPreviews] = [] + open var setMediaPreviewDisplayPolicyPolicyClosure: ((MediaPreviews) async throws -> Void)? + + open override func setMediaPreviewDisplayPolicy(policy: MediaPreviews) async throws { + if let error = setMediaPreviewDisplayPolicyPolicyThrowableError { + throw error + } + setMediaPreviewDisplayPolicyPolicyCallsCount += 1 + setMediaPreviewDisplayPolicyPolicyReceivedPolicy = policy + DispatchQueue.main.async { + self.setMediaPreviewDisplayPolicyPolicyReceivedInvocations.append(policy) + } + try await setMediaPreviewDisplayPolicyPolicyClosure?(policy) + } + //MARK: - setMediaRetentionPolicy open var setMediaRetentionPolicyPolicyThrowableError: Error? @@ -3857,6 +4091,52 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { try await setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangClosure?(identifiers, kind, appDisplayName, deviceDisplayName, profileTag, lang) } + //MARK: - setUtdDelegate + + open var setUtdDelegateUtdDelegateThrowableError: Error? + var setUtdDelegateUtdDelegateUnderlyingCallsCount = 0 + open var setUtdDelegateUtdDelegateCallsCount: Int { + get { + if Thread.isMainThread { + return setUtdDelegateUtdDelegateUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = setUtdDelegateUtdDelegateUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + setUtdDelegateUtdDelegateUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + setUtdDelegateUtdDelegateUnderlyingCallsCount = newValue + } + } + } + } + open var setUtdDelegateUtdDelegateCalled: Bool { + return setUtdDelegateUtdDelegateCallsCount > 0 + } + open var setUtdDelegateUtdDelegateReceivedUtdDelegate: UnableToDecryptDelegate? + open var setUtdDelegateUtdDelegateReceivedInvocations: [UnableToDecryptDelegate] = [] + open var setUtdDelegateUtdDelegateClosure: ((UnableToDecryptDelegate) async throws -> Void)? + + open override func setUtdDelegate(utdDelegate: UnableToDecryptDelegate) async throws { + if let error = setUtdDelegateUtdDelegateThrowableError { + throw error + } + setUtdDelegateUtdDelegateCallsCount += 1 + setUtdDelegateUtdDelegateReceivedUtdDelegate = utdDelegate + DispatchQueue.main.async { + self.setUtdDelegateUtdDelegateReceivedInvocations.append(utdDelegate) + } + try await setUtdDelegateUtdDelegateClosure?(utdDelegate) + } + //MARK: - slidingSyncVersion var slidingSyncVersionUnderlyingCallsCount = 0 @@ -4068,6 +4348,81 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { } } + //MARK: - subscribeToMediaPreviewConfig + + open var subscribeToMediaPreviewConfigListenerThrowableError: Error? + var subscribeToMediaPreviewConfigListenerUnderlyingCallsCount = 0 + open var subscribeToMediaPreviewConfigListenerCallsCount: Int { + get { + if Thread.isMainThread { + return subscribeToMediaPreviewConfigListenerUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = subscribeToMediaPreviewConfigListenerUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + subscribeToMediaPreviewConfigListenerUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + subscribeToMediaPreviewConfigListenerUnderlyingCallsCount = newValue + } + } + } + } + open var subscribeToMediaPreviewConfigListenerCalled: Bool { + return subscribeToMediaPreviewConfigListenerCallsCount > 0 + } + open var subscribeToMediaPreviewConfigListenerReceivedListener: MediaPreviewConfigListener? + open var subscribeToMediaPreviewConfigListenerReceivedInvocations: [MediaPreviewConfigListener] = [] + + var subscribeToMediaPreviewConfigListenerUnderlyingReturnValue: TaskHandle! + open var subscribeToMediaPreviewConfigListenerReturnValue: TaskHandle! { + get { + if Thread.isMainThread { + return subscribeToMediaPreviewConfigListenerUnderlyingReturnValue + } else { + var returnValue: TaskHandle? = nil + DispatchQueue.main.sync { + returnValue = subscribeToMediaPreviewConfigListenerUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + subscribeToMediaPreviewConfigListenerUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + subscribeToMediaPreviewConfigListenerUnderlyingReturnValue = newValue + } + } + } + } + open var subscribeToMediaPreviewConfigListenerClosure: ((MediaPreviewConfigListener) async throws -> TaskHandle)? + + open override func subscribeToMediaPreviewConfig(listener: MediaPreviewConfigListener) async throws -> TaskHandle { + if let error = subscribeToMediaPreviewConfigListenerThrowableError { + throw error + } + subscribeToMediaPreviewConfigListenerCallsCount += 1 + subscribeToMediaPreviewConfigListenerReceivedListener = listener + DispatchQueue.main.async { + self.subscribeToMediaPreviewConfigListenerReceivedInvocations.append(listener) + } + if let subscribeToMediaPreviewConfigListenerClosure = subscribeToMediaPreviewConfigListenerClosure { + return try await subscribeToMediaPreviewConfigListenerClosure(listener) + } else { + return subscribeToMediaPreviewConfigListenerReturnValue + } + } + //MARK: - subscribeToSendQueueStatus var subscribeToSendQueueStatusListenerUnderlyingCallsCount = 0 @@ -17583,75 +17938,6 @@ open class RoomListItemSDKMock: MatrixRustSDK.RoomListItem, @unchecked Sendable } } - //MARK: - fullRoom - - open var fullRoomThrowableError: Error? - var fullRoomUnderlyingCallsCount = 0 - open var fullRoomCallsCount: Int { - get { - if Thread.isMainThread { - return fullRoomUnderlyingCallsCount - } else { - var returnValue: Int? = nil - DispatchQueue.main.sync { - returnValue = fullRoomUnderlyingCallsCount - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - fullRoomUnderlyingCallsCount = newValue - } else { - DispatchQueue.main.sync { - fullRoomUnderlyingCallsCount = newValue - } - } - } - } - open var fullRoomCalled: Bool { - return fullRoomCallsCount > 0 - } - - var fullRoomUnderlyingReturnValue: Room! - open var fullRoomReturnValue: Room! { - get { - if Thread.isMainThread { - return fullRoomUnderlyingReturnValue - } else { - var returnValue: Room? = nil - DispatchQueue.main.sync { - returnValue = fullRoomUnderlyingReturnValue - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - fullRoomUnderlyingReturnValue = newValue - } else { - DispatchQueue.main.sync { - fullRoomUnderlyingReturnValue = newValue - } - } - } - } - open var fullRoomClosure: (() throws -> Room)? - - open override func fullRoom() throws -> Room { - if let error = fullRoomThrowableError { - throw error - } - fullRoomCallsCount += 1 - if let fullRoomClosure = fullRoomClosure { - return try fullRoomClosure() - } else { - return fullRoomReturnValue - } - } - //MARK: - id var idUnderlyingCallsCount = 0 @@ -17717,52 +18003,6 @@ open class RoomListItemSDKMock: MatrixRustSDK.RoomListItem, @unchecked Sendable } } - //MARK: - initTimeline - - open var initTimelineEventTypeFilterInternalIdPrefixThrowableError: Error? - var initTimelineEventTypeFilterInternalIdPrefixUnderlyingCallsCount = 0 - open var initTimelineEventTypeFilterInternalIdPrefixCallsCount: Int { - get { - if Thread.isMainThread { - return initTimelineEventTypeFilterInternalIdPrefixUnderlyingCallsCount - } else { - var returnValue: Int? = nil - DispatchQueue.main.sync { - returnValue = initTimelineEventTypeFilterInternalIdPrefixUnderlyingCallsCount - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - initTimelineEventTypeFilterInternalIdPrefixUnderlyingCallsCount = newValue - } else { - DispatchQueue.main.sync { - initTimelineEventTypeFilterInternalIdPrefixUnderlyingCallsCount = newValue - } - } - } - } - open var initTimelineEventTypeFilterInternalIdPrefixCalled: Bool { - return initTimelineEventTypeFilterInternalIdPrefixCallsCount > 0 - } - open var initTimelineEventTypeFilterInternalIdPrefixReceivedArguments: (eventTypeFilter: TimelineEventTypeFilter?, internalIdPrefix: String?)? - open var initTimelineEventTypeFilterInternalIdPrefixReceivedInvocations: [(eventTypeFilter: TimelineEventTypeFilter?, internalIdPrefix: String?)] = [] - open var initTimelineEventTypeFilterInternalIdPrefixClosure: ((TimelineEventTypeFilter?, String?) async throws -> Void)? - - open override func initTimeline(eventTypeFilter: TimelineEventTypeFilter?, internalIdPrefix: String?) async throws { - if let error = initTimelineEventTypeFilterInternalIdPrefixThrowableError { - throw error - } - initTimelineEventTypeFilterInternalIdPrefixCallsCount += 1 - initTimelineEventTypeFilterInternalIdPrefixReceivedArguments = (eventTypeFilter: eventTypeFilter, internalIdPrefix: internalIdPrefix) - DispatchQueue.main.async { - self.initTimelineEventTypeFilterInternalIdPrefixReceivedInvocations.append((eventTypeFilter: eventTypeFilter, internalIdPrefix: internalIdPrefix)) - } - try await initTimelineEventTypeFilterInternalIdPrefixClosure?(eventTypeFilter, internalIdPrefix) - } - //MARK: - isDirect var isDirectUnderlyingCallsCount = 0 @@ -17893,71 +18133,6 @@ open class RoomListItemSDKMock: MatrixRustSDK.RoomListItem, @unchecked Sendable } } - //MARK: - isTimelineInitialized - - var isTimelineInitializedUnderlyingCallsCount = 0 - open var isTimelineInitializedCallsCount: Int { - get { - if Thread.isMainThread { - return isTimelineInitializedUnderlyingCallsCount - } else { - var returnValue: Int? = nil - DispatchQueue.main.sync { - returnValue = isTimelineInitializedUnderlyingCallsCount - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - isTimelineInitializedUnderlyingCallsCount = newValue - } else { - DispatchQueue.main.sync { - isTimelineInitializedUnderlyingCallsCount = newValue - } - } - } - } - open var isTimelineInitializedCalled: Bool { - return isTimelineInitializedCallsCount > 0 - } - - var isTimelineInitializedUnderlyingReturnValue: Bool! - open var isTimelineInitializedReturnValue: Bool! { - get { - if Thread.isMainThread { - return isTimelineInitializedUnderlyingReturnValue - } else { - var returnValue: Bool? = nil - DispatchQueue.main.sync { - returnValue = isTimelineInitializedUnderlyingReturnValue - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - isTimelineInitializedUnderlyingReturnValue = newValue - } else { - DispatchQueue.main.sync { - isTimelineInitializedUnderlyingReturnValue = newValue - } - } - } - } - open var isTimelineInitializedClosure: (() -> Bool)? - - open override func isTimelineInitialized() -> Bool { - isTimelineInitializedCallsCount += 1 - if let isTimelineInitializedClosure = isTimelineInitializedClosure { - return isTimelineInitializedClosure() - } else { - return isTimelineInitializedReturnValue - } - } - //MARK: - latestEvent var latestEventUnderlyingCallsCount = 0 @@ -20528,77 +20703,6 @@ open class SyncServiceBuilderSDKMock: MatrixRustSDK.SyncServiceBuilder, @uncheck return withOfflineModeReturnValue } } - - //MARK: - withUtdHook - - var withUtdHookDelegateUnderlyingCallsCount = 0 - open var withUtdHookDelegateCallsCount: Int { - get { - if Thread.isMainThread { - return withUtdHookDelegateUnderlyingCallsCount - } else { - var returnValue: Int? = nil - DispatchQueue.main.sync { - returnValue = withUtdHookDelegateUnderlyingCallsCount - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - withUtdHookDelegateUnderlyingCallsCount = newValue - } else { - DispatchQueue.main.sync { - withUtdHookDelegateUnderlyingCallsCount = newValue - } - } - } - } - open var withUtdHookDelegateCalled: Bool { - return withUtdHookDelegateCallsCount > 0 - } - open var withUtdHookDelegateReceivedDelegate: UnableToDecryptDelegate? - open var withUtdHookDelegateReceivedInvocations: [UnableToDecryptDelegate] = [] - - var withUtdHookDelegateUnderlyingReturnValue: SyncServiceBuilder! - open var withUtdHookDelegateReturnValue: SyncServiceBuilder! { - get { - if Thread.isMainThread { - return withUtdHookDelegateUnderlyingReturnValue - } else { - var returnValue: SyncServiceBuilder? = nil - DispatchQueue.main.sync { - returnValue = withUtdHookDelegateUnderlyingReturnValue - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - withUtdHookDelegateUnderlyingReturnValue = newValue - } else { - DispatchQueue.main.sync { - withUtdHookDelegateUnderlyingReturnValue = newValue - } - } - } - } - open var withUtdHookDelegateClosure: ((UnableToDecryptDelegate) async -> SyncServiceBuilder)? - - open override func withUtdHook(delegate: UnableToDecryptDelegate) async -> SyncServiceBuilder { - withUtdHookDelegateCallsCount += 1 - withUtdHookDelegateReceivedDelegate = delegate - DispatchQueue.main.async { - self.withUtdHookDelegateReceivedInvocations.append(delegate) - } - if let withUtdHookDelegateClosure = withUtdHookDelegateClosure { - return await withUtdHookDelegateClosure(delegate) - } else { - return withUtdHookDelegateReturnValue - } - } } open class TaskHandleSDKMock: MatrixRustSDK.TaskHandle, @unchecked Sendable { init() { diff --git a/ElementX/Sources/Services/Client/ClientProxy.swift b/ElementX/Sources/Services/Client/ClientProxy.swift index b3b570138..cb6347b2e 100644 --- a/ElementX/Sources/Services/Client/ClientProxy.swift +++ b/ElementX/Sources/Services/Client/ClientProxy.swift @@ -169,11 +169,13 @@ class ClientProxy: ClientProxyProtocol { roomListStateUpdateTaskHandle = createRoomListServiceObserver(roomListService) roomListStateLoadingStateUpdateTaskHandle = createRoomListLoadingStateUpdateObserver(roomListService) - delegateHandle = client.setDelegate(delegate: ClientDelegateWrapper { [weak self] isSoftLogout in + delegateHandle = try client.setDelegate(delegate: ClientDelegateWrapper { [weak self] isSoftLogout in self?.hasEncounteredAuthError = true self?.actionsSubject.send(.receivedAuthError(isSoftLogout: isSoftLogout)) }) + try await client.setUtdDelegate(utdDelegate: ClientDecryptionErrorDelegate(actionsSubject: actionsSubject)) + networkMonitor.reachabilityPublisher .removeDuplicates() .receive(on: DispatchQueue.main) @@ -900,24 +902,6 @@ class ClientProxy: ClientProxyProtocol { }) } - private let eventFilters: TimelineEventTypeFilter = { - var stateEventFilters: [StateEventType] = [.roomAliases, - .roomCanonicalAlias, - .roomGuestAccess, - .roomHistoryVisibility, - .roomJoinRules, - .roomPinnedEvents, - .roomPowerLevels, - .roomServerAcl, - .roomTombstone, - .spaceChild, - .spaceParent, - .policyRuleRoom, - .policyRuleServer, - .policyRuleUser] - return .exclude(eventTypes: stateEventFilters.map { FilterTimelineEventType.state(eventType: $0) }) - }() - private func buildRoomForIdentifier(_ roomID: String) async -> RoomProxyType? { do { let roomListItem = try roomListService.room(roomId: roomID) @@ -935,13 +919,14 @@ class ClientProxy: ClientProxyProtocol { } return nil case .joined: - if roomListItem.isTimelineInitialized() == false { - try await roomListItem.initTimeline(eventTypeFilter: eventFilters, internalIdPrefix: nil) + guard let room = try client.getRoom(roomId: roomID) else { + MXLog.error("Could not find room with ID: \(roomID)") + return nil } let roomProxy = try await JoinedRoomProxy(roomListService: roomListService, roomListItem: roomListItem, - room: roomListItem.fullRoom()) + room: room) return .joined(roomProxy) case .left: @@ -1119,7 +1104,6 @@ private struct ClientProxyServices { let syncService = try await client .syncService() .withCrossProcessLock() - .withUtdHook(delegate: ClientDecryptionErrorDelegate(actionsSubject: actionsSubject)) .finish() let roomListService = syncService.roomListService() diff --git a/ElementX/Sources/Services/Room/JoinedRoomProxy.swift b/ElementX/Sources/Services/Room/JoinedRoomProxy.swift index 4fe9e2def..8e8ddccf1 100644 --- a/ElementX/Sources/Services/Room/JoinedRoomProxy.swift +++ b/ElementX/Sources/Services/Room/JoinedRoomProxy.swift @@ -39,7 +39,8 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol { filter: .all, internalIdPrefix: nil, dateDividerMode: .daily, - trackReadReceipts: false)) + trackReadReceipts: false, + reportUtds: true)) let timeline = TimelineProxy(timeline: sdkTimeline, kind: .pinned) @@ -108,7 +109,14 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol { self.room = room infoSubject = try await .init(RoomInfoProxy(roomInfo: room.roomInfo())) - timeline = try await TimelineProxy(timeline: room.timeline(), kind: .live) + + timeline = try await TimelineProxy(timeline: room.timelineWithConfiguration(configuration: .init(focus: .live, + filter: .eventTypeFilter(filter: eventFilters), + internalIdPrefix: nil, + dateDividerMode: .daily, + trackReadReceipts: true, + reportUtds: true)), + kind: .live) Task { await updateMembers() @@ -123,6 +131,24 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol { } } + private let eventFilters: TimelineEventTypeFilter = { + var stateEventFilters: [StateEventType] = [.roomAliases, + .roomCanonicalAlias, + .roomGuestAccess, + .roomHistoryVisibility, + .roomJoinRules, + .roomPinnedEvents, + .roomPowerLevels, + .roomServerAcl, + .roomTombstone, + .spaceChild, + .spaceParent, + .policyRuleRoom, + .policyRuleServer, + .policyRuleUser] + return .exclude(eventTypes: stateEventFilters.map { FilterTimelineEventType.state(eventType: $0) }) + }() + func subscribeForUpdates() async { guard !subscribedForUpdates else { MXLog.warning("Room already subscribed for updates") @@ -169,7 +195,8 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol { filter: .all, internalIdPrefix: UUID().uuidString, dateDividerMode: .daily, - trackReadReceipts: false)) + trackReadReceipts: false, + reportUtds: true)) return .success(TimelineProxy(timeline: sdkTimeline, kind: .detached)) } catch let error as FocusEventError { @@ -196,7 +223,8 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol { filter: .all, internalIdPrefix: UUID().uuidString, dateDividerMode: .daily, - trackReadReceipts: true)) + trackReadReceipts: true, + reportUtds: true)) let timeline = TimelineProxy(timeline: sdkTimeline, kind: .thread) await timeline.subscribeForUpdates() @@ -232,7 +260,8 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol { filter: .onlyMessage(types: rustMessageTypes), internalIdPrefix: nil, dateDividerMode: .monthly, - trackReadReceipts: false)) + trackReadReceipts: false, + reportUtds: true)) let timeline = TimelineProxy(timeline: sdkTimeline, kind: .media(presentation)) await timeline.subscribeForUpdates() diff --git a/NSE/Sources/NSEUserSession.swift b/NSE/Sources/NSEUserSession.swift index c7bd7a185..d5ab5e5ba 100644 --- a/NSE/Sources/NSEUserSession.swift +++ b/NSE/Sources/NSEUserSession.swift @@ -49,7 +49,7 @@ final class NSEUserSession { .sessionPassphrase(passphrase: credentials.restorationToken.passphrase) baseClient = try await clientBuilder.build() - delegateHandle = baseClient.setDelegate(delegate: ClientDelegateWrapper()) + delegateHandle = try baseClient.setDelegate(delegate: ClientDelegateWrapper()) try await baseClient.restoreSessionWith(session: credentials.restorationToken.session, roomLoadSettings: .one(roomId: roomID)) diff --git a/project.yml b/project.yml index 89f21538d..bfbcd306e 100644 --- a/project.yml +++ b/project.yml @@ -65,7 +65,7 @@ packages: # Element/Matrix dependencies MatrixRustSDK: url: https://github.com/element-hq/matrix-rust-components-swift - exactVersion: 25.05.19 + exactVersion: 25.05.21 # path: ../matrix-rust-sdk Compound: url: https://github.com/element-hq/compound-ios