Fixes problems processing invites, build rooms differently based on their membership

2026-11-03 06:55:59 +00:00 · 2024-08-21 12:57:32 +03:00
parent e281a3f242
commit 404b78e7c7
3 changed files with 232 additions and 42 deletions
@@ -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?
@@ -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
        }
    }
    
@@ -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()