diff --git a/Components/SDKMocks/Sources/Generated/SDKGeneratedMocks.swift b/Components/SDKMocks/Sources/Generated/SDKGeneratedMocks.swift index 77b8627ae..49052c024 100644 --- a/Components/SDKMocks/Sources/Generated/SDKGeneratedMocks.swift +++ b/Components/SDKMocks/Sources/Generated/SDKGeneratedMocks.swift @@ -1961,6 +1961,39 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { } } + //MARK: - isStickyEventsSupported + + open var isStickyEventsSupportedThrowableError: Error? + private let isStickyEventsSupportedCallsCountLock = NSLock() + private var isStickyEventsSupportedUnderlyingCallsCount = 0 + open var isStickyEventsSupportedCallsCount: Int { + get { isStickyEventsSupportedCallsCountLock.withLock { isStickyEventsSupportedUnderlyingCallsCount } } + set { isStickyEventsSupportedCallsCountLock.withLock { isStickyEventsSupportedUnderlyingCallsCount = newValue } } + } + open var isStickyEventsSupportedCalled: Bool { + return isStickyEventsSupportedCallsCount > 0 + } + + private let isStickyEventsSupportedReturnValueLock = NSLock() + open var isStickyEventsSupportedUnderlyingReturnValue: Bool! + open var isStickyEventsSupportedReturnValue: Bool! { + get { isStickyEventsSupportedReturnValueLock.withLock { isStickyEventsSupportedUnderlyingReturnValue } } + set { isStickyEventsSupportedReturnValueLock.withLock { isStickyEventsSupportedUnderlyingReturnValue = newValue } } + } + open var isStickyEventsSupportedClosure: (() async throws -> Bool)? + + open override func isStickyEventsSupported() async throws -> Bool { + if let error = isStickyEventsSupportedThrowableError { + throw error + } + isStickyEventsSupportedCallsCountLock.withLock { isStickyEventsSupportedUnderlyingCallsCount += 1 } + if let isStickyEventsSupportedClosure = isStickyEventsSupportedClosure { + return try await isStickyEventsSupportedClosure() + } else { + return isStickyEventsSupportedReturnValue + } + } + //MARK: - isUserStatusSupported open var isUserStatusSupportedThrowableError: Error? @@ -2964,6 +2997,49 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable { } } + //MARK: - runSearchBackfill + + private let runSearchBackfillStrategyCallsCountLock = NSLock() + private var runSearchBackfillStrategyUnderlyingCallsCount = 0 + open var runSearchBackfillStrategyCallsCount: Int { + get { runSearchBackfillStrategyCallsCountLock.withLock { runSearchBackfillStrategyUnderlyingCallsCount } } + set { runSearchBackfillStrategyCallsCountLock.withLock { runSearchBackfillStrategyUnderlyingCallsCount = newValue } } + } + open var runSearchBackfillStrategyCalled: Bool { + return runSearchBackfillStrategyCallsCount > 0 + } + private let runSearchBackfillStrategyReceivedStrategyLock = NSLock() + private var runSearchBackfillStrategyUnderlyingReceivedStrategy: SearchBackfillStrategy? + open var runSearchBackfillStrategyReceivedStrategy: SearchBackfillStrategy? { + get { runSearchBackfillStrategyReceivedStrategyLock.withLock { runSearchBackfillStrategyUnderlyingReceivedStrategy } } + set { runSearchBackfillStrategyReceivedStrategyLock.withLock { runSearchBackfillStrategyUnderlyingReceivedStrategy = newValue } } + } + private let runSearchBackfillStrategyReceivedInvocationsLock = NSLock() + private var runSearchBackfillStrategyUnderlyingReceivedInvocations: [SearchBackfillStrategy] = [] + open var runSearchBackfillStrategyReceivedInvocations: [SearchBackfillStrategy] { + get { runSearchBackfillStrategyReceivedInvocationsLock.withLock { runSearchBackfillStrategyUnderlyingReceivedInvocations } } + set { runSearchBackfillStrategyReceivedInvocationsLock.withLock { runSearchBackfillStrategyUnderlyingReceivedInvocations = newValue } } + } + + private let runSearchBackfillStrategyReturnValueLock = NSLock() + open var runSearchBackfillStrategyUnderlyingReturnValue: TaskHandle! + open var runSearchBackfillStrategyReturnValue: TaskHandle! { + get { runSearchBackfillStrategyReturnValueLock.withLock { runSearchBackfillStrategyUnderlyingReturnValue } } + set { runSearchBackfillStrategyReturnValueLock.withLock { runSearchBackfillStrategyUnderlyingReturnValue = newValue } } + } + open var runSearchBackfillStrategyClosure: ((SearchBackfillStrategy) -> TaskHandle)? + + open override func runSearchBackfill(strategy: SearchBackfillStrategy) -> TaskHandle { + runSearchBackfillStrategyCallsCountLock.withLock { runSearchBackfillStrategyUnderlyingCallsCount += 1 } + runSearchBackfillStrategyReceivedStrategy = strategy + runSearchBackfillStrategyReceivedInvocationsLock.withLock { runSearchBackfillStrategyUnderlyingReceivedInvocations.append(strategy) } + if let runSearchBackfillStrategyClosure = runSearchBackfillStrategyClosure { + return runSearchBackfillStrategyClosure(strategy) + } else { + return runSearchBackfillStrategyReturnValue + } + } + //MARK: - searchUsers open var searchUsersSearchTermLimitThrowableError: Error? @@ -12195,16 +12271,27 @@ open class RoomSDKMock: MatrixRustSDK.Room, @unchecked Sendable { get { sendRawEventTypeContentReceivedInvocationsLock.withLock { sendRawEventTypeContentUnderlyingReceivedInvocations } } set { sendRawEventTypeContentReceivedInvocationsLock.withLock { sendRawEventTypeContentUnderlyingReceivedInvocations = newValue } } } - open var sendRawEventTypeContentClosure: ((String, String) async throws -> Void)? - open override func sendRaw(eventType: String, content: String) async throws { + private let sendRawEventTypeContentReturnValueLock = NSLock() + open var sendRawEventTypeContentUnderlyingReturnValue: String! + open var sendRawEventTypeContentReturnValue: String! { + get { sendRawEventTypeContentReturnValueLock.withLock { sendRawEventTypeContentUnderlyingReturnValue } } + set { sendRawEventTypeContentReturnValueLock.withLock { sendRawEventTypeContentUnderlyingReturnValue = newValue } } + } + open var sendRawEventTypeContentClosure: ((String, String) async throws -> String)? + + open override func sendRaw(eventType: String, content: String) async throws -> String { if let error = sendRawEventTypeContentThrowableError { throw error } sendRawEventTypeContentCallsCountLock.withLock { sendRawEventTypeContentUnderlyingCallsCount += 1 } sendRawEventTypeContentReceivedArguments = (eventType: eventType, content: content) sendRawEventTypeContentReceivedInvocationsLock.withLock { sendRawEventTypeContentUnderlyingReceivedInvocations.append((eventType: eventType, content: content)) } - try await sendRawEventTypeContentClosure?(eventType, content) + if let sendRawEventTypeContentClosure = sendRawEventTypeContentClosure { + return try await sendRawEventTypeContentClosure(eventType, content) + } else { + return sendRawEventTypeContentReturnValue + } } //MARK: - sendSingleReceipt @@ -13512,6 +13599,125 @@ open class RoomSDKMock: MatrixRustSDK.Room, @unchecked Sendable { withdrawVerificationAndResendUserIdsSendHandleReceivedInvocationsLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingReceivedInvocations.append((userIds: userIds, sendHandle: sendHandle)) } try await withdrawVerificationAndResendUserIdsSendHandleClosure?(userIds, sendHandle) } + + //MARK: - sendStickyRaw + + open var sendStickyRawEventTypeContentDurationMsThrowableError: Error? + private let sendStickyRawEventTypeContentDurationMsCallsCountLock = NSLock() + private var sendStickyRawEventTypeContentDurationMsUnderlyingCallsCount = 0 + open var sendStickyRawEventTypeContentDurationMsCallsCount: Int { + get { sendStickyRawEventTypeContentDurationMsCallsCountLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingCallsCount } } + set { sendStickyRawEventTypeContentDurationMsCallsCountLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingCallsCount = newValue } } + } + open var sendStickyRawEventTypeContentDurationMsCalled: Bool { + return sendStickyRawEventTypeContentDurationMsCallsCount > 0 + } + private let sendStickyRawEventTypeContentDurationMsReceivedArgumentsLock = NSLock() + private var sendStickyRawEventTypeContentDurationMsUnderlyingReceivedArguments: (eventType: String, content: String, durationMs: UInt64)? + open var sendStickyRawEventTypeContentDurationMsReceivedArguments: (eventType: String, content: String, durationMs: UInt64)? { + get { sendStickyRawEventTypeContentDurationMsReceivedArgumentsLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingReceivedArguments } } + set { sendStickyRawEventTypeContentDurationMsReceivedArgumentsLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingReceivedArguments = newValue } } + } + private let sendStickyRawEventTypeContentDurationMsReceivedInvocationsLock = NSLock() + private var sendStickyRawEventTypeContentDurationMsUnderlyingReceivedInvocations: [(eventType: String, content: String, durationMs: UInt64)] = [] + open var sendStickyRawEventTypeContentDurationMsReceivedInvocations: [(eventType: String, content: String, durationMs: UInt64)] { + get { sendStickyRawEventTypeContentDurationMsReceivedInvocationsLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingReceivedInvocations } } + set { sendStickyRawEventTypeContentDurationMsReceivedInvocationsLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingReceivedInvocations = newValue } } + } + + private let sendStickyRawEventTypeContentDurationMsReturnValueLock = NSLock() + open var sendStickyRawEventTypeContentDurationMsUnderlyingReturnValue: String! + open var sendStickyRawEventTypeContentDurationMsReturnValue: String! { + get { sendStickyRawEventTypeContentDurationMsReturnValueLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingReturnValue } } + set { sendStickyRawEventTypeContentDurationMsReturnValueLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingReturnValue = newValue } } + } + open var sendStickyRawEventTypeContentDurationMsClosure: ((String, String, UInt64) async throws -> String)? + + open override func sendStickyRaw(eventType: String, content: String, durationMs: UInt64) async throws -> String { + if let error = sendStickyRawEventTypeContentDurationMsThrowableError { + throw error + } + sendStickyRawEventTypeContentDurationMsCallsCountLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingCallsCount += 1 } + sendStickyRawEventTypeContentDurationMsReceivedArguments = (eventType: eventType, content: content, durationMs: durationMs) + sendStickyRawEventTypeContentDurationMsReceivedInvocationsLock.withLock { sendStickyRawEventTypeContentDurationMsUnderlyingReceivedInvocations.append((eventType: eventType, content: content, durationMs: durationMs)) } + if let sendStickyRawEventTypeContentDurationMsClosure = sendStickyRawEventTypeContentDurationMsClosure { + return try await sendStickyRawEventTypeContentDurationMsClosure(eventType, content, durationMs) + } else { + return sendStickyRawEventTypeContentDurationMsReturnValue + } + } + + //MARK: - stickyEvents + + private let stickyEventsCallsCountLock = NSLock() + private var stickyEventsUnderlyingCallsCount = 0 + open var stickyEventsCallsCount: Int { + get { stickyEventsCallsCountLock.withLock { stickyEventsUnderlyingCallsCount } } + set { stickyEventsCallsCountLock.withLock { stickyEventsUnderlyingCallsCount = newValue } } + } + open var stickyEventsCalled: Bool { + return stickyEventsCallsCount > 0 + } + + private let stickyEventsReturnValueLock = NSLock() + open var stickyEventsUnderlyingReturnValue: [StickyEvent]! + open var stickyEventsReturnValue: [StickyEvent]! { + get { stickyEventsReturnValueLock.withLock { stickyEventsUnderlyingReturnValue } } + set { stickyEventsReturnValueLock.withLock { stickyEventsUnderlyingReturnValue = newValue } } + } + open var stickyEventsClosure: (() -> [StickyEvent])? + + open override func stickyEvents() -> [StickyEvent] { + stickyEventsCallsCountLock.withLock { stickyEventsUnderlyingCallsCount += 1 } + if let stickyEventsClosure = stickyEventsClosure { + return stickyEventsClosure() + } else { + return stickyEventsReturnValue + } + } + + //MARK: - subscribeToStickyEvents + + private let subscribeToStickyEventsListenerCallsCountLock = NSLock() + private var subscribeToStickyEventsListenerUnderlyingCallsCount = 0 + open var subscribeToStickyEventsListenerCallsCount: Int { + get { subscribeToStickyEventsListenerCallsCountLock.withLock { subscribeToStickyEventsListenerUnderlyingCallsCount } } + set { subscribeToStickyEventsListenerCallsCountLock.withLock { subscribeToStickyEventsListenerUnderlyingCallsCount = newValue } } + } + open var subscribeToStickyEventsListenerCalled: Bool { + return subscribeToStickyEventsListenerCallsCount > 0 + } + private let subscribeToStickyEventsListenerReceivedListenerLock = NSLock() + private var subscribeToStickyEventsListenerUnderlyingReceivedListener: StickyEventsListener? + open var subscribeToStickyEventsListenerReceivedListener: StickyEventsListener? { + get { subscribeToStickyEventsListenerReceivedListenerLock.withLock { subscribeToStickyEventsListenerUnderlyingReceivedListener } } + set { subscribeToStickyEventsListenerReceivedListenerLock.withLock { subscribeToStickyEventsListenerUnderlyingReceivedListener = newValue } } + } + private let subscribeToStickyEventsListenerReceivedInvocationsLock = NSLock() + private var subscribeToStickyEventsListenerUnderlyingReceivedInvocations: [StickyEventsListener] = [] + open var subscribeToStickyEventsListenerReceivedInvocations: [StickyEventsListener] { + get { subscribeToStickyEventsListenerReceivedInvocationsLock.withLock { subscribeToStickyEventsListenerUnderlyingReceivedInvocations } } + set { subscribeToStickyEventsListenerReceivedInvocationsLock.withLock { subscribeToStickyEventsListenerUnderlyingReceivedInvocations = newValue } } + } + + private let subscribeToStickyEventsListenerReturnValueLock = NSLock() + open var subscribeToStickyEventsListenerUnderlyingReturnValue: TaskHandle! + open var subscribeToStickyEventsListenerReturnValue: TaskHandle! { + get { subscribeToStickyEventsListenerReturnValueLock.withLock { subscribeToStickyEventsListenerUnderlyingReturnValue } } + set { subscribeToStickyEventsListenerReturnValueLock.withLock { subscribeToStickyEventsListenerUnderlyingReturnValue = newValue } } + } + open var subscribeToStickyEventsListenerClosure: ((StickyEventsListener) -> TaskHandle)? + + open override func subscribeToStickyEvents(listener: StickyEventsListener) -> TaskHandle { + subscribeToStickyEventsListenerCallsCountLock.withLock { subscribeToStickyEventsListenerUnderlyingCallsCount += 1 } + subscribeToStickyEventsListenerReceivedListener = listener + subscribeToStickyEventsListenerReceivedInvocationsLock.withLock { subscribeToStickyEventsListenerUnderlyingReceivedInvocations.append(listener) } + if let subscribeToStickyEventsListenerClosure = subscribeToStickyEventsListenerClosure { + return subscribeToStickyEventsListenerClosure(listener) + } else { + return subscribeToStickyEventsListenerReturnValue + } + } } open class RoomDirectorySearchSDKMock: MatrixRustSDK.RoomDirectorySearch, @unchecked Sendable { public init() { @@ -15991,6 +16197,35 @@ open class SessionVerificationControllerSDKMock: MatrixRustSDK.SessionVerificati try await declineVerificationClosure?() } + //MARK: - requestCancelInfo + + private let requestCancelInfoCallsCountLock = NSLock() + private var requestCancelInfoUnderlyingCallsCount = 0 + open var requestCancelInfoCallsCount: Int { + get { requestCancelInfoCallsCountLock.withLock { requestCancelInfoUnderlyingCallsCount } } + set { requestCancelInfoCallsCountLock.withLock { requestCancelInfoUnderlyingCallsCount = newValue } } + } + open var requestCancelInfoCalled: Bool { + return requestCancelInfoCallsCount > 0 + } + + private let requestCancelInfoReturnValueLock = NSLock() + open var requestCancelInfoUnderlyingReturnValue: SessionVerificationCancelInfo? + open var requestCancelInfoReturnValue: SessionVerificationCancelInfo? { + get { requestCancelInfoReturnValueLock.withLock { requestCancelInfoUnderlyingReturnValue } } + set { requestCancelInfoReturnValueLock.withLock { requestCancelInfoUnderlyingReturnValue = newValue } } + } + open var requestCancelInfoClosure: (() -> SessionVerificationCancelInfo?)? + + open override func requestCancelInfo() -> SessionVerificationCancelInfo? { + requestCancelInfoCallsCountLock.withLock { requestCancelInfoUnderlyingCallsCount += 1 } + if let requestCancelInfoClosure = requestCancelInfoClosure { + return requestCancelInfoClosure() + } else { + return requestCancelInfoReturnValue + } + } + //MARK: - requestDeviceVerification open var requestDeviceVerificationThrowableError: Error? @@ -16049,6 +16284,35 @@ open class SessionVerificationControllerSDKMock: MatrixRustSDK.SessionVerificati try await requestUserVerificationUserIdClosure?(userId) } + //MARK: - sasCancelInfo + + private let sasCancelInfoCallsCountLock = NSLock() + private var sasCancelInfoUnderlyingCallsCount = 0 + open var sasCancelInfoCallsCount: Int { + get { sasCancelInfoCallsCountLock.withLock { sasCancelInfoUnderlyingCallsCount } } + set { sasCancelInfoCallsCountLock.withLock { sasCancelInfoUnderlyingCallsCount = newValue } } + } + open var sasCancelInfoCalled: Bool { + return sasCancelInfoCallsCount > 0 + } + + private let sasCancelInfoReturnValueLock = NSLock() + open var sasCancelInfoUnderlyingReturnValue: SessionVerificationCancelInfo? + open var sasCancelInfoReturnValue: SessionVerificationCancelInfo? { + get { sasCancelInfoReturnValueLock.withLock { sasCancelInfoUnderlyingReturnValue } } + set { sasCancelInfoReturnValueLock.withLock { sasCancelInfoUnderlyingReturnValue = newValue } } + } + open var sasCancelInfoClosure: (() -> SessionVerificationCancelInfo?)? + + open override func sasCancelInfo() -> SessionVerificationCancelInfo? { + sasCancelInfoCallsCountLock.withLock { sasCancelInfoUnderlyingCallsCount += 1 } + if let sasCancelInfoClosure = sasCancelInfoClosure { + return sasCancelInfoClosure() + } else { + return sasCancelInfoReturnValue + } + } + //MARK: - setDelegate private let setDelegateDelegateCallsCountLock = NSLock() @@ -18193,6 +18457,53 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline, @unchecked Sendable { } fileprivate var underlyingHandle: UInt64! + //MARK: - abortSend + + open var abortSendItemIdTargetThrowableError: Error? + private let abortSendItemIdTargetCallsCountLock = NSLock() + private var abortSendItemIdTargetUnderlyingCallsCount = 0 + open var abortSendItemIdTargetCallsCount: Int { + get { abortSendItemIdTargetCallsCountLock.withLock { abortSendItemIdTargetUnderlyingCallsCount } } + set { abortSendItemIdTargetCallsCountLock.withLock { abortSendItemIdTargetUnderlyingCallsCount = newValue } } + } + open var abortSendItemIdTargetCalled: Bool { + return abortSendItemIdTargetCallsCount > 0 + } + private let abortSendItemIdTargetReceivedArgumentsLock = NSLock() + private var abortSendItemIdTargetUnderlyingReceivedArguments: (itemId: EventOrTransactionId, target: SendTarget)? + open var abortSendItemIdTargetReceivedArguments: (itemId: EventOrTransactionId, target: SendTarget)? { + get { abortSendItemIdTargetReceivedArgumentsLock.withLock { abortSendItemIdTargetUnderlyingReceivedArguments } } + set { abortSendItemIdTargetReceivedArgumentsLock.withLock { abortSendItemIdTargetUnderlyingReceivedArguments = newValue } } + } + private let abortSendItemIdTargetReceivedInvocationsLock = NSLock() + private var abortSendItemIdTargetUnderlyingReceivedInvocations: [(itemId: EventOrTransactionId, target: SendTarget)] = [] + open var abortSendItemIdTargetReceivedInvocations: [(itemId: EventOrTransactionId, target: SendTarget)] { + get { abortSendItemIdTargetReceivedInvocationsLock.withLock { abortSendItemIdTargetUnderlyingReceivedInvocations } } + set { abortSendItemIdTargetReceivedInvocationsLock.withLock { abortSendItemIdTargetUnderlyingReceivedInvocations = newValue } } + } + + private let abortSendItemIdTargetReturnValueLock = NSLock() + open var abortSendItemIdTargetUnderlyingReturnValue: Bool! + open var abortSendItemIdTargetReturnValue: Bool! { + get { abortSendItemIdTargetReturnValueLock.withLock { abortSendItemIdTargetUnderlyingReturnValue } } + set { abortSendItemIdTargetReturnValueLock.withLock { abortSendItemIdTargetUnderlyingReturnValue = newValue } } + } + open var abortSendItemIdTargetClosure: ((EventOrTransactionId, SendTarget) async throws -> Bool)? + + open override func abortSend(itemId: EventOrTransactionId, target: SendTarget) async throws -> Bool { + if let error = abortSendItemIdTargetThrowableError { + throw error + } + abortSendItemIdTargetCallsCountLock.withLock { abortSendItemIdTargetUnderlyingCallsCount += 1 } + abortSendItemIdTargetReceivedArguments = (itemId: itemId, target: target) + abortSendItemIdTargetReceivedInvocationsLock.withLock { abortSendItemIdTargetUnderlyingReceivedInvocations.append((itemId: itemId, target: target)) } + if let abortSendItemIdTargetClosure = abortSendItemIdTargetClosure { + return try await abortSendItemIdTargetClosure(itemId, target) + } else { + return abortSendItemIdTargetReturnValue + } + } + //MARK: - addListener private let addListenerListenerCallsCountLock = NSLock() @@ -18351,6 +18662,114 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline, @unchecked Sendable { try await editEventOrTransactionIdNewContentClosure?(eventOrTransactionId, newContent) } + //MARK: - editAudio + + open var editAudioEventIdParamsAudioInfoThrowableError: Error? + private let editAudioEventIdParamsAudioInfoCallsCountLock = NSLock() + private var editAudioEventIdParamsAudioInfoUnderlyingCallsCount = 0 + open var editAudioEventIdParamsAudioInfoCallsCount: Int { + get { editAudioEventIdParamsAudioInfoCallsCountLock.withLock { editAudioEventIdParamsAudioInfoUnderlyingCallsCount } } + set { editAudioEventIdParamsAudioInfoCallsCountLock.withLock { editAudioEventIdParamsAudioInfoUnderlyingCallsCount = newValue } } + } + open var editAudioEventIdParamsAudioInfoCalled: Bool { + return editAudioEventIdParamsAudioInfoCallsCount > 0 + } + private let editAudioEventIdParamsAudioInfoReceivedArgumentsLock = NSLock() + private var editAudioEventIdParamsAudioInfoUnderlyingReceivedArguments: (eventId: String, params: UploadParameters, audioInfo: AudioInfo)? + open var editAudioEventIdParamsAudioInfoReceivedArguments: (eventId: String, params: UploadParameters, audioInfo: AudioInfo)? { + get { editAudioEventIdParamsAudioInfoReceivedArgumentsLock.withLock { editAudioEventIdParamsAudioInfoUnderlyingReceivedArguments } } + set { editAudioEventIdParamsAudioInfoReceivedArgumentsLock.withLock { editAudioEventIdParamsAudioInfoUnderlyingReceivedArguments = newValue } } + } + private let editAudioEventIdParamsAudioInfoReceivedInvocationsLock = NSLock() + private var editAudioEventIdParamsAudioInfoUnderlyingReceivedInvocations: [(eventId: String, params: UploadParameters, audioInfo: AudioInfo)] = [] + open var editAudioEventIdParamsAudioInfoReceivedInvocations: [(eventId: String, params: UploadParameters, audioInfo: AudioInfo)] { + get { editAudioEventIdParamsAudioInfoReceivedInvocationsLock.withLock { editAudioEventIdParamsAudioInfoUnderlyingReceivedInvocations } } + set { editAudioEventIdParamsAudioInfoReceivedInvocationsLock.withLock { editAudioEventIdParamsAudioInfoUnderlyingReceivedInvocations = newValue } } + } + open var editAudioEventIdParamsAudioInfoClosure: ((String, UploadParameters, AudioInfo) async throws -> Void)? + + open override func editAudio(eventId: String, params: UploadParameters, audioInfo: AudioInfo) async throws { + if let error = editAudioEventIdParamsAudioInfoThrowableError { + throw error + } + editAudioEventIdParamsAudioInfoCallsCountLock.withLock { editAudioEventIdParamsAudioInfoUnderlyingCallsCount += 1 } + editAudioEventIdParamsAudioInfoReceivedArguments = (eventId: eventId, params: params, audioInfo: audioInfo) + editAudioEventIdParamsAudioInfoReceivedInvocationsLock.withLock { editAudioEventIdParamsAudioInfoUnderlyingReceivedInvocations.append((eventId: eventId, params: params, audioInfo: audioInfo)) } + try await editAudioEventIdParamsAudioInfoClosure?(eventId, params, audioInfo) + } + + //MARK: - editFile + + open var editFileEventIdParamsFileInfoThrowableError: Error? + private let editFileEventIdParamsFileInfoCallsCountLock = NSLock() + private var editFileEventIdParamsFileInfoUnderlyingCallsCount = 0 + open var editFileEventIdParamsFileInfoCallsCount: Int { + get { editFileEventIdParamsFileInfoCallsCountLock.withLock { editFileEventIdParamsFileInfoUnderlyingCallsCount } } + set { editFileEventIdParamsFileInfoCallsCountLock.withLock { editFileEventIdParamsFileInfoUnderlyingCallsCount = newValue } } + } + open var editFileEventIdParamsFileInfoCalled: Bool { + return editFileEventIdParamsFileInfoCallsCount > 0 + } + private let editFileEventIdParamsFileInfoReceivedArgumentsLock = NSLock() + private var editFileEventIdParamsFileInfoUnderlyingReceivedArguments: (eventId: String, params: UploadParameters, fileInfo: FileInfo)? + open var editFileEventIdParamsFileInfoReceivedArguments: (eventId: String, params: UploadParameters, fileInfo: FileInfo)? { + get { editFileEventIdParamsFileInfoReceivedArgumentsLock.withLock { editFileEventIdParamsFileInfoUnderlyingReceivedArguments } } + set { editFileEventIdParamsFileInfoReceivedArgumentsLock.withLock { editFileEventIdParamsFileInfoUnderlyingReceivedArguments = newValue } } + } + private let editFileEventIdParamsFileInfoReceivedInvocationsLock = NSLock() + private var editFileEventIdParamsFileInfoUnderlyingReceivedInvocations: [(eventId: String, params: UploadParameters, fileInfo: FileInfo)] = [] + open var editFileEventIdParamsFileInfoReceivedInvocations: [(eventId: String, params: UploadParameters, fileInfo: FileInfo)] { + get { editFileEventIdParamsFileInfoReceivedInvocationsLock.withLock { editFileEventIdParamsFileInfoUnderlyingReceivedInvocations } } + set { editFileEventIdParamsFileInfoReceivedInvocationsLock.withLock { editFileEventIdParamsFileInfoUnderlyingReceivedInvocations = newValue } } + } + open var editFileEventIdParamsFileInfoClosure: ((String, UploadParameters, FileInfo) async throws -> Void)? + + open override func editFile(eventId: String, params: UploadParameters, fileInfo: FileInfo) async throws { + if let error = editFileEventIdParamsFileInfoThrowableError { + throw error + } + editFileEventIdParamsFileInfoCallsCountLock.withLock { editFileEventIdParamsFileInfoUnderlyingCallsCount += 1 } + editFileEventIdParamsFileInfoReceivedArguments = (eventId: eventId, params: params, fileInfo: fileInfo) + editFileEventIdParamsFileInfoReceivedInvocationsLock.withLock { editFileEventIdParamsFileInfoUnderlyingReceivedInvocations.append((eventId: eventId, params: params, fileInfo: fileInfo)) } + try await editFileEventIdParamsFileInfoClosure?(eventId, params, fileInfo) + } + + //MARK: - editImage + + open var editImageEventIdParamsThumbnailSourceImageInfoThrowableError: Error? + private let editImageEventIdParamsThumbnailSourceImageInfoCallsCountLock = NSLock() + private var editImageEventIdParamsThumbnailSourceImageInfoUnderlyingCallsCount = 0 + open var editImageEventIdParamsThumbnailSourceImageInfoCallsCount: Int { + get { editImageEventIdParamsThumbnailSourceImageInfoCallsCountLock.withLock { editImageEventIdParamsThumbnailSourceImageInfoUnderlyingCallsCount } } + set { editImageEventIdParamsThumbnailSourceImageInfoCallsCountLock.withLock { editImageEventIdParamsThumbnailSourceImageInfoUnderlyingCallsCount = newValue } } + } + open var editImageEventIdParamsThumbnailSourceImageInfoCalled: Bool { + return editImageEventIdParamsThumbnailSourceImageInfoCallsCount > 0 + } + private let editImageEventIdParamsThumbnailSourceImageInfoReceivedArgumentsLock = NSLock() + private var editImageEventIdParamsThumbnailSourceImageInfoUnderlyingReceivedArguments: (eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo)? + open var editImageEventIdParamsThumbnailSourceImageInfoReceivedArguments: (eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo)? { + get { editImageEventIdParamsThumbnailSourceImageInfoReceivedArgumentsLock.withLock { editImageEventIdParamsThumbnailSourceImageInfoUnderlyingReceivedArguments } } + set { editImageEventIdParamsThumbnailSourceImageInfoReceivedArgumentsLock.withLock { editImageEventIdParamsThumbnailSourceImageInfoUnderlyingReceivedArguments = newValue } } + } + private let editImageEventIdParamsThumbnailSourceImageInfoReceivedInvocationsLock = NSLock() + private var editImageEventIdParamsThumbnailSourceImageInfoUnderlyingReceivedInvocations: [(eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo)] = [] + open var editImageEventIdParamsThumbnailSourceImageInfoReceivedInvocations: [(eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo)] { + get { editImageEventIdParamsThumbnailSourceImageInfoReceivedInvocationsLock.withLock { editImageEventIdParamsThumbnailSourceImageInfoUnderlyingReceivedInvocations } } + set { editImageEventIdParamsThumbnailSourceImageInfoReceivedInvocationsLock.withLock { editImageEventIdParamsThumbnailSourceImageInfoUnderlyingReceivedInvocations = newValue } } + } + open var editImageEventIdParamsThumbnailSourceImageInfoClosure: ((String, UploadParameters, UploadSource?, ImageInfo) async throws -> Void)? + + open override func editImage(eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo) async throws { + if let error = editImageEventIdParamsThumbnailSourceImageInfoThrowableError { + throw error + } + editImageEventIdParamsThumbnailSourceImageInfoCallsCountLock.withLock { editImageEventIdParamsThumbnailSourceImageInfoUnderlyingCallsCount += 1 } + editImageEventIdParamsThumbnailSourceImageInfoReceivedArguments = (eventId: eventId, params: params, thumbnailSource: thumbnailSource, imageInfo: imageInfo) + editImageEventIdParamsThumbnailSourceImageInfoReceivedInvocationsLock.withLock { editImageEventIdParamsThumbnailSourceImageInfoUnderlyingReceivedInvocations.append((eventId: eventId, params: params, thumbnailSource: thumbnailSource, imageInfo: imageInfo)) } + try await editImageEventIdParamsThumbnailSourceImageInfoClosure?(eventId, params, thumbnailSource, imageInfo) + } + //MARK: - editRevisions open var editRevisionsEventIdThrowableError: Error? @@ -18398,6 +18817,42 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline, @unchecked Sendable { } } + //MARK: - editVideo + + open var editVideoEventIdParamsThumbnailSourceVideoInfoThrowableError: Error? + private let editVideoEventIdParamsThumbnailSourceVideoInfoCallsCountLock = NSLock() + private var editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingCallsCount = 0 + open var editVideoEventIdParamsThumbnailSourceVideoInfoCallsCount: Int { + get { editVideoEventIdParamsThumbnailSourceVideoInfoCallsCountLock.withLock { editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingCallsCount } } + set { editVideoEventIdParamsThumbnailSourceVideoInfoCallsCountLock.withLock { editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingCallsCount = newValue } } + } + open var editVideoEventIdParamsThumbnailSourceVideoInfoCalled: Bool { + return editVideoEventIdParamsThumbnailSourceVideoInfoCallsCount > 0 + } + private let editVideoEventIdParamsThumbnailSourceVideoInfoReceivedArgumentsLock = NSLock() + private var editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingReceivedArguments: (eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo)? + open var editVideoEventIdParamsThumbnailSourceVideoInfoReceivedArguments: (eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo)? { + get { editVideoEventIdParamsThumbnailSourceVideoInfoReceivedArgumentsLock.withLock { editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingReceivedArguments } } + set { editVideoEventIdParamsThumbnailSourceVideoInfoReceivedArgumentsLock.withLock { editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingReceivedArguments = newValue } } + } + private let editVideoEventIdParamsThumbnailSourceVideoInfoReceivedInvocationsLock = NSLock() + private var editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingReceivedInvocations: [(eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo)] = [] + open var editVideoEventIdParamsThumbnailSourceVideoInfoReceivedInvocations: [(eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo)] { + get { editVideoEventIdParamsThumbnailSourceVideoInfoReceivedInvocationsLock.withLock { editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingReceivedInvocations } } + set { editVideoEventIdParamsThumbnailSourceVideoInfoReceivedInvocationsLock.withLock { editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingReceivedInvocations = newValue } } + } + open var editVideoEventIdParamsThumbnailSourceVideoInfoClosure: ((String, UploadParameters, UploadSource?, VideoInfo) async throws -> Void)? + + open override func editVideo(eventId: String, params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo) async throws { + if let error = editVideoEventIdParamsThumbnailSourceVideoInfoThrowableError { + throw error + } + editVideoEventIdParamsThumbnailSourceVideoInfoCallsCountLock.withLock { editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingCallsCount += 1 } + editVideoEventIdParamsThumbnailSourceVideoInfoReceivedArguments = (eventId: eventId, params: params, thumbnailSource: thumbnailSource, videoInfo: videoInfo) + editVideoEventIdParamsThumbnailSourceVideoInfoReceivedInvocationsLock.withLock { editVideoEventIdParamsThumbnailSourceVideoInfoUnderlyingReceivedInvocations.append((eventId: eventId, params: params, thumbnailSource: thumbnailSource, videoInfo: videoInfo)) } + try await editVideoEventIdParamsThumbnailSourceVideoInfoClosure?(eventId, params, thumbnailSource, videoInfo) + } + //MARK: - endPoll open var endPollPollStartEventIdTextThrowableError: Error? @@ -18856,6 +19311,53 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline, @unchecked Sendable { retryDecryptionSessionIdsClosure?(sessionIds) } + //MARK: - retrySend + + open var retrySendItemIdTargetThrowableError: Error? + private let retrySendItemIdTargetCallsCountLock = NSLock() + private var retrySendItemIdTargetUnderlyingCallsCount = 0 + open var retrySendItemIdTargetCallsCount: Int { + get { retrySendItemIdTargetCallsCountLock.withLock { retrySendItemIdTargetUnderlyingCallsCount } } + set { retrySendItemIdTargetCallsCountLock.withLock { retrySendItemIdTargetUnderlyingCallsCount = newValue } } + } + open var retrySendItemIdTargetCalled: Bool { + return retrySendItemIdTargetCallsCount > 0 + } + private let retrySendItemIdTargetReceivedArgumentsLock = NSLock() + private var retrySendItemIdTargetUnderlyingReceivedArguments: (itemId: EventOrTransactionId, target: SendTarget)? + open var retrySendItemIdTargetReceivedArguments: (itemId: EventOrTransactionId, target: SendTarget)? { + get { retrySendItemIdTargetReceivedArgumentsLock.withLock { retrySendItemIdTargetUnderlyingReceivedArguments } } + set { retrySendItemIdTargetReceivedArgumentsLock.withLock { retrySendItemIdTargetUnderlyingReceivedArguments = newValue } } + } + private let retrySendItemIdTargetReceivedInvocationsLock = NSLock() + private var retrySendItemIdTargetUnderlyingReceivedInvocations: [(itemId: EventOrTransactionId, target: SendTarget)] = [] + open var retrySendItemIdTargetReceivedInvocations: [(itemId: EventOrTransactionId, target: SendTarget)] { + get { retrySendItemIdTargetReceivedInvocationsLock.withLock { retrySendItemIdTargetUnderlyingReceivedInvocations } } + set { retrySendItemIdTargetReceivedInvocationsLock.withLock { retrySendItemIdTargetUnderlyingReceivedInvocations = newValue } } + } + + private let retrySendItemIdTargetReturnValueLock = NSLock() + open var retrySendItemIdTargetUnderlyingReturnValue: Bool! + open var retrySendItemIdTargetReturnValue: Bool! { + get { retrySendItemIdTargetReturnValueLock.withLock { retrySendItemIdTargetUnderlyingReturnValue } } + set { retrySendItemIdTargetReturnValueLock.withLock { retrySendItemIdTargetUnderlyingReturnValue = newValue } } + } + open var retrySendItemIdTargetClosure: ((EventOrTransactionId, SendTarget) async throws -> Bool)? + + open override func retrySend(itemId: EventOrTransactionId, target: SendTarget) async throws -> Bool { + if let error = retrySendItemIdTargetThrowableError { + throw error + } + retrySendItemIdTargetCallsCountLock.withLock { retrySendItemIdTargetUnderlyingCallsCount += 1 } + retrySendItemIdTargetReceivedArguments = (itemId: itemId, target: target) + retrySendItemIdTargetReceivedInvocationsLock.withLock { retrySendItemIdTargetUnderlyingReceivedInvocations.append((itemId: itemId, target: target)) } + if let retrySendItemIdTargetClosure = retrySendItemIdTargetClosure { + return try await retrySendItemIdTargetClosure(itemId, target) + } else { + return retrySendItemIdTargetReturnValue + } + } + //MARK: - send open var sendMsgThrowableError: Error? diff --git a/ElementX.xcodeproj/project.pbxproj b/ElementX.xcodeproj/project.pbxproj index 580de0adb..e42d6643c 100644 --- a/ElementX.xcodeproj/project.pbxproj +++ b/ElementX.xcodeproj/project.pbxproj @@ -10915,7 +10915,7 @@ repositoryURL = "https://github.com/element-hq/matrix-rust-components-swift"; requirement = { kind = exactVersion; - version = 26.09.22; + version = 26.09.25; }; }; 701C7BEF8F70F7A83E852DCC /* XCRemoteSwiftPackageReference "GZIP" */ = { diff --git a/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved index 249b9b321..b8d78b0bd 100644 --- a/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved +++ b/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved @@ -176,8 +176,8 @@ "kind" : "remoteSourceControl", "location" : "https://github.com/element-hq/matrix-rust-components-swift", "state" : { - "revision" : "91eb17c79944811b4d5e3a18e389b351ee1e0a5e", - "version" : "26.9.22" + "revision" : "3718c227f8b9a49268eac51feb9c063433f03304", + "version" : "26.9.25" } }, { diff --git a/ElementX/Sources/Mocks/SDK/EventTimelineItem.swift b/ElementX/Sources/Mocks/SDK/EventTimelineItem.swift index 1fe146c19..0579ee5bb 100644 --- a/ElementX/Sources/Mocks/SDK/EventTimelineItem.swift +++ b/ElementX/Sources/Mocks/SDK/EventTimelineItem.swift @@ -45,6 +45,8 @@ nonisolated extension EventTimelineItem { eventTypeRaw: nil, timestamp: UInt64(Date.mock.timeIntervalSince1970 * 1000), localSendState: nil, + editSendState: nil, + redactionSendState: nil, localCreatedAt: nil, readReceipts: [:], origin: nil, diff --git a/ElementX/Sources/Other/Logging/TraceLogPack.swift b/ElementX/Sources/Other/Logging/TraceLogPack.swift index 2024e75f4..1fbf7ff05 100644 --- a/ElementX/Sources/Other/Logging/TraceLogPack.swift +++ b/ElementX/Sources/Other/Logging/TraceLogPack.swift @@ -10,11 +10,12 @@ import Foundation import MatrixRustSDK nonisolated enum TraceLogPack: Codable, CaseIterable { - case eventCache, sendQueue, timeline, notificationClient, syncProfiling, latestEvents, search + case eventCache, backPagination, sendQueue, timeline, notificationClient, syncProfiling, latestEvents, search var title: String { switch self { case .eventCache: "Event cache" + case .backPagination: "Back pagination" case .sendQueue: "Send queue" case .timeline: "Timeline" case .notificationClient: "Notification client" @@ -30,6 +31,7 @@ nonisolated extension TraceLogPack { init(rustLogPack: MatrixRustSDK.TraceLogPacks) { self = switch rustLogPack { case .eventCache: .eventCache + case .backPagination: .backPagination case .sendQueue: .sendQueue case .timeline: .timeline case .notificationClient: .notificationClient @@ -42,6 +44,7 @@ nonisolated extension TraceLogPack { var rustLogPack: MatrixRustSDK.TraceLogPacks { switch self { case .eventCache: .eventCache + case .backPagination: .backPagination case .sendQueue: .sendQueue case .timeline: .timeline case .notificationClient: .notificationClient diff --git a/project.yml b/project.yml index ec3ca319e..a4d486a07 100644 --- a/project.yml +++ b/project.yml @@ -75,7 +75,7 @@ packages: # Element/Matrix dependencies MatrixRustSDK: url: https://github.com/element-hq/matrix-rust-components-swift - exactVersion: 26.09.22 + exactVersion: 26.09.25 # path: ../matrix-rust-sdk Compound: path: compound-ios