From 404b78e7c7016b764ab6cca8f34a6e7463866f2f Mon Sep 17 00:00:00 2001 From: Stefan Ceriu Date: Wed, 21 Aug 2024 12:57:32 +0300 Subject: [PATCH] Fixes problems processing invites, build rooms differently based on their membership --- .../Mocks/Generated/SDKGeneratedMocks.swift | 205 ++++++++++++++++++ .../Sources/Services/Client/ClientProxy.swift | 56 ++--- .../Services/Room/JoinedRoomProxy.swift | 13 +- 3 files changed, 232 insertions(+), 42 deletions(-) diff --git a/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift b/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift index 4776de6d3..256bb31b2 100644 --- a/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift +++ b/ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift @@ -4591,6 +4591,77 @@ open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder { } } + //MARK: - roomKeyRecipientStrategy + + var roomKeyRecipientStrategyStrategyUnderlyingCallsCount = 0 + open var roomKeyRecipientStrategyStrategyCallsCount: Int { + get { + if Thread.isMainThread { + return roomKeyRecipientStrategyStrategyUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = roomKeyRecipientStrategyStrategyUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + roomKeyRecipientStrategyStrategyUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + roomKeyRecipientStrategyStrategyUnderlyingCallsCount = newValue + } + } + } + } + open var roomKeyRecipientStrategyStrategyCalled: Bool { + return roomKeyRecipientStrategyStrategyCallsCount > 0 + } + open var roomKeyRecipientStrategyStrategyReceivedStrategy: CollectStrategy? + open var roomKeyRecipientStrategyStrategyReceivedInvocations: [CollectStrategy] = [] + + var roomKeyRecipientStrategyStrategyUnderlyingReturnValue: ClientBuilder! + open var roomKeyRecipientStrategyStrategyReturnValue: ClientBuilder! { + get { + if Thread.isMainThread { + return roomKeyRecipientStrategyStrategyUnderlyingReturnValue + } else { + var returnValue: ClientBuilder? = nil + DispatchQueue.main.sync { + returnValue = roomKeyRecipientStrategyStrategyUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + roomKeyRecipientStrategyStrategyUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + roomKeyRecipientStrategyStrategyUnderlyingReturnValue = newValue + } + } + } + } + open var roomKeyRecipientStrategyStrategyClosure: ((CollectStrategy) -> ClientBuilder)? + + open override func roomKeyRecipientStrategy(strategy: CollectStrategy) -> ClientBuilder { + roomKeyRecipientStrategyStrategyCallsCount += 1 + roomKeyRecipientStrategyStrategyReceivedStrategy = strategy + DispatchQueue.main.async { + self.roomKeyRecipientStrategyStrategyReceivedInvocations.append(strategy) + } + if let roomKeyRecipientStrategyStrategyClosure = roomKeyRecipientStrategyStrategyClosure { + return roomKeyRecipientStrategyStrategyClosure(strategy) + } else { + return roomKeyRecipientStrategyStrategyReturnValue + } + } + //MARK: - serverName var serverNameServerNameUnderlyingCallsCount = 0 @@ -15784,6 +15855,75 @@ open class RoomListItemSDKMock: MatrixRustSDK.RoomListItem { try await initTimelineEventTypeFilterInternalIdPrefixClosure?(eventTypeFilter, internalIdPrefix) } + //MARK: - invitedRoom + + open var invitedRoomThrowableError: Error? + var invitedRoomUnderlyingCallsCount = 0 + open var invitedRoomCallsCount: Int { + get { + if Thread.isMainThread { + return invitedRoomUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = invitedRoomUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + invitedRoomUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + invitedRoomUnderlyingCallsCount = newValue + } + } + } + } + open var invitedRoomCalled: Bool { + return invitedRoomCallsCount > 0 + } + + var invitedRoomUnderlyingReturnValue: Room! + open var invitedRoomReturnValue: Room! { + get { + if Thread.isMainThread { + return invitedRoomUnderlyingReturnValue + } else { + var returnValue: Room? = nil + DispatchQueue.main.sync { + returnValue = invitedRoomUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + invitedRoomUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + invitedRoomUnderlyingReturnValue = newValue + } + } + } + } + open var invitedRoomClosure: (() throws -> Room)? + + open override func invitedRoom() throws -> Room { + if let error = invitedRoomThrowableError { + throw error + } + invitedRoomCallsCount += 1 + if let invitedRoomClosure = invitedRoomClosure { + return try invitedRoomClosure() + } else { + return invitedRoomReturnValue + } + } + //MARK: - isDirect var isDirectUnderlyingCallsCount = 0 @@ -16044,6 +16184,71 @@ open class RoomListItemSDKMock: MatrixRustSDK.RoomListItem { } } + //MARK: - membership + + var membershipUnderlyingCallsCount = 0 + open var membershipCallsCount: Int { + get { + if Thread.isMainThread { + return membershipUnderlyingCallsCount + } else { + var returnValue: Int? = nil + DispatchQueue.main.sync { + returnValue = membershipUnderlyingCallsCount + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + membershipUnderlyingCallsCount = newValue + } else { + DispatchQueue.main.sync { + membershipUnderlyingCallsCount = newValue + } + } + } + } + open var membershipCalled: Bool { + return membershipCallsCount > 0 + } + + var membershipUnderlyingReturnValue: Membership! + open var membershipReturnValue: Membership! { + get { + if Thread.isMainThread { + return membershipUnderlyingReturnValue + } else { + var returnValue: Membership? = nil + DispatchQueue.main.sync { + returnValue = membershipUnderlyingReturnValue + } + + return returnValue! + } + } + set { + if Thread.isMainThread { + membershipUnderlyingReturnValue = newValue + } else { + DispatchQueue.main.sync { + membershipUnderlyingReturnValue = newValue + } + } + } + } + open var membershipClosure: (() -> Membership)? + + open override func membership() -> Membership { + membershipCallsCount += 1 + if let membershipClosure = membershipClosure { + return membershipClosure() + } else { + return membershipReturnValue + } + } + //MARK: - roomInfo open var roomInfoThrowableError: Error? diff --git a/ElementX/Sources/Services/Client/ClientProxy.swift b/ElementX/Sources/Services/Client/ClientProxy.swift index b212a0cbb..c5c946f1f 100644 --- a/ElementX/Sources/Services/Client/ClientProxy.swift +++ b/ElementX/Sources/Services/Client/ClientProxy.swift @@ -847,43 +847,33 @@ class ClientProxy: ClientProxyProtocol { private func buildRoomForIdentifier(_ identifier: String) async -> RoomProxyType? { guard let roomListService else { - MXLog.error("Failed retrieving room, room list service not set up") + MXLog.error("Failed retrieving room: \(identifier), room list service not set up") return nil } - guard let roomListItem = try? roomListService.room(roomId: identifier) else { - MXLog.error("Failed retrieving room, invalid room list item") - return nil - } - - if roomListItem.isTimelineInitialized() == false { - do { - try await roomListItem.initTimeline(eventTypeFilter: eventFilters, internalIdPrefix: nil) - } catch { - MXLog.error("Failed initializing room timeline with error: \(error)") - return nil - } - } - - guard let room = try? roomListItem.fullRoom() else { - MXLog.error("Failed retrieving room, invalid room list item full room") - return nil - } - - switch room.membership() { - case .invited: - return .invited(InvitedRoomProxy(roomListItem: roomListItem, - room: room)) - case .joined: - guard let roomProxy = await JoinedRoomProxy(roomListService: roomListService, - roomListItem: roomListItem, - room: room) else { - return nil - } + do { + let roomListItem = try roomListService.room(roomId: identifier) - return .joined(roomProxy) - case .left: - return .left + switch roomListItem.membership() { + case .invited: + return try .invited(InvitedRoomProxy(roomListItem: roomListItem, + room: roomListItem.invitedRoom())) + case .joined: + if roomListItem.isTimelineInitialized() == false { + try await roomListItem.initTimeline(eventTypeFilter: eventFilters, internalIdPrefix: nil) + } + + let roomProxy = try await JoinedRoomProxy(roomListService: roomListService, + roomListItem: roomListItem, + room: roomListItem.fullRoom()) + + return .joined(roomProxy) + case .left: + return .left + } + } catch { + MXLog.error("Failed retrieving room: \(identifier), with error: \(error)") + return nil } } diff --git a/ElementX/Sources/Services/Room/JoinedRoomProxy.swift b/ElementX/Sources/Services/Room/JoinedRoomProxy.swift index bc1a57b4b..a32346cf0 100644 --- a/ElementX/Sources/Services/Room/JoinedRoomProxy.swift +++ b/ElementX/Sources/Services/Room/JoinedRoomProxy.swift @@ -165,19 +165,14 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol { room.activeRoomCallParticipants() } - init?(roomListService: RoomListServiceProtocol, - roomListItem: RoomListItemProtocol, - room: RoomProtocol) async { + init(roomListService: RoomListServiceProtocol, + roomListItem: RoomListItemProtocol, + room: RoomProtocol) async throws { self.roomListService = roomListService self.roomListItem = roomListItem self.room = room - do { - timeline = try await TimelineProxy(timeline: room.timeline(), isLive: true) - } catch { - MXLog.error("Failed creating timeline with error: \(error)") - return nil - } + timeline = try await TimelineProxy(timeline: room.timeline(), isLive: true) Task { await updateMembers()