From b7fcb76094b016beeb09b5a28deebb1299b22a76 Mon Sep 17 00:00:00 2001 From: Stefan Ceriu Date: Fri, 28 Jun 2024 10:26:24 +0300 Subject: [PATCH] Remove redundant remove failed sent message menu --- .../Mocks/Generated/SDKGeneratedMocks.swift | 424 +++++++++++++----- .../Screens/RoomScreen/RoomScreenModels.swift | 2 - .../RoomScreen/RoomScreenViewModel.swift | 8 - .../Style/TimelineItemBubbledStylerView.swift | 20 +- 4 files changed, 324 insertions(+), 130 deletions(-) diff --git a/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift b/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift index 8628763aa..3c59bdd6e 100644 --- a/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift +++ b/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift @@ -4,82 +4,6 @@ // swiftlint:disable all import Foundation import MatrixRustSDK -open class AbortSendHandleSDKMock: MatrixRustSDK.AbortSendHandle { - init() { - super.init(noPointer: .init()) - } - - public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { - fatalError("init(unsafeFromRawPointer:) has not been implemented") - } - - fileprivate var pointer: UnsafeMutableRawPointer! - - //MARK: - abort - - var abortUnderlyingCallsCount = 0 - open var abortCallsCount: Int { - get { - if Thread.isMainThread { - return abortUnderlyingCallsCount - } else { - var returnValue: Int? = nil - DispatchQueue.main.sync { - returnValue = abortUnderlyingCallsCount - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - abortUnderlyingCallsCount = newValue - } else { - DispatchQueue.main.sync { - abortUnderlyingCallsCount = newValue - } - } - } - } - open var abortCalled: Bool { - return abortCallsCount > 0 - } - - var abortUnderlyingReturnValue: Bool! - open var abortReturnValue: Bool! { - get { - if Thread.isMainThread { - return abortUnderlyingReturnValue - } else { - var returnValue: Bool? = nil - DispatchQueue.main.sync { - returnValue = abortUnderlyingReturnValue - } - - return returnValue! - } - } - set { - if Thread.isMainThread { - abortUnderlyingReturnValue = newValue - } else { - DispatchQueue.main.sync { - abortUnderlyingReturnValue = newValue - } - } - } - } - open var abortClosure: (() async -> Bool)? - - open override func abort() async -> Bool { - abortCallsCount += 1 - if let abortClosure = abortClosure { - return await abortClosure() - } else { - return abortReturnValue - } - } -} open class ClientSDKMock: MatrixRustSDK.Client { init() { super.init(noPointer: .init()) @@ -711,15 +635,15 @@ open class ClientSDKMock: MatrixRustSDK.Client { } open var enableAllSendQueuesEnableReceivedEnable: Bool? open var enableAllSendQueuesEnableReceivedInvocations: [Bool] = [] - open var enableAllSendQueuesEnableClosure: ((Bool) -> Void)? + open var enableAllSendQueuesEnableClosure: ((Bool) async -> Void)? - open override func enableAllSendQueues(enable: Bool) { + open override func enableAllSendQueues(enable: Bool) async { enableAllSendQueuesEnableCallsCount += 1 enableAllSendQueuesEnableReceivedEnable = enable DispatchQueue.main.async { self.enableAllSendQueuesEnableReceivedInvocations.append(enable) } - enableAllSendQueuesEnableClosure?(enable) + await enableAllSendQueuesEnableClosure?(enable) } //MARK: - encryption @@ -9246,6 +9170,82 @@ open class NotificationSettingsSDKMock: MatrixRustSDK.NotificationSettings { try await unmuteRoomRoomIdIsEncryptedIsOneToOneClosure?(roomId, isEncrypted, isOneToOne) } } +open class OidcAuthorizationDataSDKMock: MatrixRustSDK.OidcAuthorizationData { + init() { + super.init(noPointer: .init()) + } + + public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + fatalError("init(unsafeFromRawPointer:) has not been implemented") + } + + fileprivate var pointer: UnsafeMutableRawPointer! + + //MARK: - loginUrl + + var loginUrlUnderlyingCallsCount = 0 + open var loginUrlCallsCount: Int { + get { + if Thread.isMainThread { + return loginUrlUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = loginUrlUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + loginUrlUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + loginUrlUnderlyingCallsCount = newValue + } + } + } + } + open var loginUrlCalled: Bool { + return loginUrlCallsCount > 0 + } + + var loginUrlUnderlyingReturnValue: String! + open var loginUrlReturnValue: String! { + get { + if Thread.isMainThread { + return loginUrlUnderlyingReturnValue + } else { + var returnValue: String? = nil + DispatchQueue.main.sync { + returnValue = loginUrlUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + loginUrlUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + loginUrlUnderlyingReturnValue = newValue + } + } + } + } + open var loginUrlClosure: (() -> String)? + + open override func loginUrl() -> String { + loginUrlCallsCount += 1 + if let loginUrlClosure = loginUrlClosure { + return loginUrlClosure() + } else { + return loginUrlReturnValue + } + } +} open class QrCodeDataSDKMock: MatrixRustSDK.QrCodeData { init() { super.init(noPointer: .init()) @@ -14819,6 +14819,71 @@ open class RoomListItemSDKMock: MatrixRustSDK.RoomListItem { } } + //MARK: - isEncrypted + + var isEncryptedUnderlyingCallsCount = 0 + open var isEncryptedCallsCount: Int { + get { + if Thread.isMainThread { + return isEncryptedUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = isEncryptedUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + isEncryptedUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + isEncryptedUnderlyingCallsCount = newValue + } + } + } + } + open var isEncryptedCalled: Bool { + return isEncryptedCallsCount > 0 + } + + var isEncryptedUnderlyingReturnValue: Bool! + open var isEncryptedReturnValue: Bool! { + get { + if Thread.isMainThread { + return isEncryptedUnderlyingReturnValue + } else { + var returnValue: Bool? = nil + DispatchQueue.main.sync { + returnValue = isEncryptedUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + isEncryptedUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + isEncryptedUnderlyingReturnValue = newValue + } + } + } + } + open var isEncryptedClosure: (() async -> Bool)? + + open override func isEncrypted() async -> Bool { + isEncryptedCallsCount += 1 + if let isEncryptedClosure = isEncryptedClosure { + return await isEncryptedClosure() + } else { + return isEncryptedReturnValue + } + } + //MARK: - isTimelineInitialized var isTimelineInitializedUnderlyingCallsCount = 0 @@ -15755,6 +15820,86 @@ open class SendAttachmentJoinHandleSDKMock: MatrixRustSDK.SendAttachmentJoinHand try await joinClosure?() } } +open class SendHandleSDKMock: MatrixRustSDK.SendHandle { + init() { + super.init(noPointer: .init()) + } + + public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + fatalError("init(unsafeFromRawPointer:) has not been implemented") + } + + fileprivate var pointer: UnsafeMutableRawPointer! + + //MARK: - abort + + open var abortThrowableError: Error? + var abortUnderlyingCallsCount = 0 + open var abortCallsCount: Int { + get { + if Thread.isMainThread { + return abortUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = abortUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + abortUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + abortUnderlyingCallsCount = newValue + } + } + } + } + open var abortCalled: Bool { + return abortCallsCount > 0 + } + + var abortUnderlyingReturnValue: Bool! + open var abortReturnValue: Bool! { + get { + if Thread.isMainThread { + return abortUnderlyingReturnValue + } else { + var returnValue: Bool? = nil + DispatchQueue.main.sync { + returnValue = abortUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + abortUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + abortUnderlyingReturnValue = newValue + } + } + } + } + open var abortClosure: (() async throws -> Bool)? + + open override func abort() async throws -> Bool { + if let error = abortThrowableError { + throw error + } + abortCallsCount += 1 + if let abortClosure = abortClosure { + return try await abortClosure() + } else { + return abortReturnValue + } + } +} open class SessionVerificationControllerSDKMock: MatrixRustSDK.SessionVerificationController { init() { super.init(noPointer: .init()) @@ -17056,16 +17201,16 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline { //MARK: - edit - open var editNewContentEventIdThrowableError: Error? - var editNewContentEventIdUnderlyingCallsCount = 0 - open var editNewContentEventIdCallsCount: Int { + open var editItemNewContentThrowableError: Error? + var editItemNewContentUnderlyingCallsCount = 0 + open var editItemNewContentCallsCount: Int { get { if Thread.isMainThread { - return editNewContentEventIdUnderlyingCallsCount + return editItemNewContentUnderlyingCallsCount } else { var returnValue: Int? = nil DispatchQueue.main.sync { - returnValue = editNewContentEventIdUnderlyingCallsCount + returnValue = editItemNewContentUnderlyingCallsCount } return returnValue! @@ -17073,31 +17218,106 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline { } set { if Thread.isMainThread { - editNewContentEventIdUnderlyingCallsCount = newValue + editItemNewContentUnderlyingCallsCount = newValue } else { DispatchQueue.main.sync { - editNewContentEventIdUnderlyingCallsCount = newValue + editItemNewContentUnderlyingCallsCount = newValue } } } } - open var editNewContentEventIdCalled: Bool { - return editNewContentEventIdCallsCount > 0 + open var editItemNewContentCalled: Bool { + return editItemNewContentCallsCount > 0 } - open var editNewContentEventIdReceivedArguments: (newContent: RoomMessageEventContentWithoutRelation, eventId: String)? - open var editNewContentEventIdReceivedInvocations: [(newContent: RoomMessageEventContentWithoutRelation, eventId: String)] = [] - open var editNewContentEventIdClosure: ((RoomMessageEventContentWithoutRelation, String) async throws -> Void)? + open var editItemNewContentReceivedArguments: (item: EventTimelineItem, newContent: RoomMessageEventContentWithoutRelation)? + open var editItemNewContentReceivedInvocations: [(item: EventTimelineItem, newContent: RoomMessageEventContentWithoutRelation)] = [] - open override func edit(newContent: RoomMessageEventContentWithoutRelation, eventId: String) async throws { - if let error = editNewContentEventIdThrowableError { + var editItemNewContentUnderlyingReturnValue: Bool! + open var editItemNewContentReturnValue: Bool! { + get { + if Thread.isMainThread { + return editItemNewContentUnderlyingReturnValue + } else { + var returnValue: Bool? = nil + DispatchQueue.main.sync { + returnValue = editItemNewContentUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + editItemNewContentUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + editItemNewContentUnderlyingReturnValue = newValue + } + } + } + } + open var editItemNewContentClosure: ((EventTimelineItem, RoomMessageEventContentWithoutRelation) async throws -> Bool)? + + open override func edit(item: EventTimelineItem, newContent: RoomMessageEventContentWithoutRelation) async throws -> Bool { + if let error = editItemNewContentThrowableError { throw error } - editNewContentEventIdCallsCount += 1 - editNewContentEventIdReceivedArguments = (newContent: newContent, eventId: eventId) + editItemNewContentCallsCount += 1 + editItemNewContentReceivedArguments = (item: item, newContent: newContent) DispatchQueue.main.async { - self.editNewContentEventIdReceivedInvocations.append((newContent: newContent, eventId: eventId)) + self.editItemNewContentReceivedInvocations.append((item: item, newContent: newContent)) } - try await editNewContentEventIdClosure?(newContent, eventId) + if let editItemNewContentClosure = editItemNewContentClosure { + return try await editItemNewContentClosure(item, newContent) + } else { + return editItemNewContentReturnValue + } + } + + //MARK: - editByEventId + + open var editByEventIdEventIdNewContentThrowableError: Error? + var editByEventIdEventIdNewContentUnderlyingCallsCount = 0 + open var editByEventIdEventIdNewContentCallsCount: Int { + get { + if Thread.isMainThread { + return editByEventIdEventIdNewContentUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = editByEventIdEventIdNewContentUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + editByEventIdEventIdNewContentUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + editByEventIdEventIdNewContentUnderlyingCallsCount = newValue + } + } + } + } + open var editByEventIdEventIdNewContentCalled: Bool { + return editByEventIdEventIdNewContentCallsCount > 0 + } + open var editByEventIdEventIdNewContentReceivedArguments: (eventId: String, newContent: RoomMessageEventContentWithoutRelation)? + open var editByEventIdEventIdNewContentReceivedInvocations: [(eventId: String, newContent: RoomMessageEventContentWithoutRelation)] = [] + open var editByEventIdEventIdNewContentClosure: ((String, RoomMessageEventContentWithoutRelation) async throws -> Void)? + + open override func editByEventId(eventId: String, newContent: RoomMessageEventContentWithoutRelation) async throws { + if let error = editByEventIdEventIdNewContentThrowableError { + throw error + } + editByEventIdEventIdNewContentCallsCount += 1 + editByEventIdEventIdNewContentReceivedArguments = (eventId: eventId, newContent: newContent) + DispatchQueue.main.async { + self.editByEventIdEventIdNewContentReceivedInvocations.append((eventId: eventId, newContent: newContent)) + } + try await editByEventIdEventIdNewContentClosure?(eventId, newContent) } //MARK: - editPoll @@ -17845,13 +18065,13 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline { open var sendMsgReceivedMsg: RoomMessageEventContentWithoutRelation? open var sendMsgReceivedInvocations: [RoomMessageEventContentWithoutRelation] = [] - var sendMsgUnderlyingReturnValue: AbortSendHandle! - open var sendMsgReturnValue: AbortSendHandle! { + var sendMsgUnderlyingReturnValue: SendHandle! + open var sendMsgReturnValue: SendHandle! { get { if Thread.isMainThread { return sendMsgUnderlyingReturnValue } else { - var returnValue: AbortSendHandle? = nil + var returnValue: SendHandle? = nil DispatchQueue.main.sync { returnValue = sendMsgUnderlyingReturnValue } @@ -17869,9 +18089,9 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline { } } } - open var sendMsgClosure: ((RoomMessageEventContentWithoutRelation) async throws -> AbortSendHandle)? + open var sendMsgClosure: ((RoomMessageEventContentWithoutRelation) async throws -> SendHandle)? - open override func send(msg: RoomMessageEventContentWithoutRelation) async throws -> AbortSendHandle { + open override func send(msg: RoomMessageEventContentWithoutRelation) async throws -> SendHandle { if let error = sendMsgThrowableError { throw error } diff --git a/ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift b/ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift index e75285db5..830fa4f8e 100644 --- a/ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift +++ b/ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift @@ -114,7 +114,6 @@ enum RoomScreenViewAction { case displayRoomMemberDetails(userID: String) case displayReactionSummary(itemID: TimelineItemIdentifier, key: String) case displayEmojiPicker(itemID: TimelineItemIdentifier) - case displayMessageSendingFailureAlert(itemID: TimelineItemIdentifier) case displayReadReceipts(itemID: TimelineItemIdentifier) case displayCall @@ -216,7 +215,6 @@ struct ReadReceiptSummaryInfo: Identifiable { enum RoomScreenAlertInfoType: Hashable { case audioRecodingPermissionError case pollEndConfirmation(String) - case messageSendingFailure(TimelineItemIdentifier) } struct RoomMemberState { diff --git a/ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift b/ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift index 181fee14b..8bf7674e4 100644 --- a/ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift +++ b/ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift @@ -178,8 +178,6 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol roomScreenInteractionHandler.displayEmojiPicker(for: itemID) case .displayReactionSummary(let itemID, let key): displayReactionSummary(for: itemID, selectedKey: key) - case .displayMessageSendingFailureAlert(let itemID): - displayAlert(.messageSendingFailure(itemID)) case .displayReadReceipts(itemID: let itemID): displayReadReceipts(for: itemID) case .displayCall: @@ -764,12 +762,6 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol message: L10n.commonPollEndConfirmation, primaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil), secondaryButton: .init(title: L10n.actionOk, action: { self.roomScreenInteractionHandler.endPoll(pollStartID: pollStartID) })) - case .messageSendingFailure(let itemID): - state.bindings.alertInfo = .init(id: type, title: L10n.screenRoomRetrySendMenuTitle, primaryButton: .init(title: L10n.actionRemove, role: .destructive) { - Task { - await self.timelineController.redact(itemID) - } - }) } } diff --git a/ElementX/Sources/Screens/RoomScreen/View/Style/TimelineItemBubbledStylerView.swift b/ElementX/Sources/Screens/RoomScreen/View/Style/TimelineItemBubbledStylerView.swift index 950ccd0ba..ab69adc8a 100644 --- a/ElementX/Sources/Screens/RoomScreen/View/Style/TimelineItemBubbledStylerView.swift +++ b/ElementX/Sources/Screens/RoomScreen/View/Style/TimelineItemBubbledStylerView.swift @@ -110,11 +110,7 @@ struct TimelineItemBubbledStylerView: View { VStack(alignment: alignment, spacing: -3) { messageBubble .timelineItemAccessibility(timelineItem) { - if adjustedDeliveryStatus == .sendingFailed { - context.send(viewAction: .displayMessageSendingFailureAlert(itemID: timelineItem.id)) - } else { - context.send(viewAction: .displayTimelineItemMenu(itemID: timelineItem.id)) - } + context.send(viewAction: .displayTimelineItemMenu(itemID: timelineItem.id)) } if !timelineItem.properties.reactions.isEmpty { @@ -168,22 +164,10 @@ struct TimelineItemBubbledStylerView: View { timelineItem.bubbleSendInfoLayoutType .layout { contentWithReply - interactiveLocalizedSendInfo + layoutedLocalizedSendInfo } } - @ViewBuilder - var interactiveLocalizedSendInfo: some View { - if adjustedDeliveryStatus == .sendingFailed { - layoutedLocalizedSendInfo - .onTapGesture { - context.send(viewAction: .displayMessageSendingFailureAlert(itemID: timelineItem.id)) - } - } else { - layoutedLocalizedSendInfo - } - } - @ViewBuilder var layoutedLocalizedSendInfo: some View { switch timelineItem.bubbleSendInfoLayoutType {