Use the SDK's SpaceService, SpaceRoom and SpaceRoomList. (#4455)

2026-11-03 06:55:59 +00:00 · 2025-09-01 15:22:37 +01:00
parent 28094cfcac
commit 049bb7b740
20 changed files with 904 additions and 45 deletions
@@ -91,7 +91,7 @@ class SpaceExplorerFlowCoordinator: FlowCoordinatorProtocol {
        stateMachine.addRouteMapping { event, fromState, userInfo in
            guard event == .selectSpace, case .spaceList = fromState else { return nil }
            guard let spaceRoomListProxy = userInfo as? SpaceRoomListProxyProtocol else { fatalError("A space proxy must be provided.") }
-            return .spaceList(selectedSpaceID: spaceRoomListProxy.spaceRoom.id)
+            return .spaceList(selectedSpaceID: spaceRoomListProxy.spaceRoomProxy.id)
        } handler: { [weak self] context in
            guard let self, let spaceRoomListProxy = context.userInfo as? SpaceRoomListProxyProtocol else { return }
            startSpaceFlow(spaceRoomListProxy: spaceRoomListProxy)
@@ -156,6 +156,6 @@ class SpaceExplorerFlowCoordinator: FlowCoordinatorProtocol {
        }
        
        coordinator.start()
-        selectedSpaceSubject.send(spaceRoomListProxy.spaceRoom.id)
+        selectedSpaceSubject.send(spaceRoomListProxy.spaceRoomProxy.id)
    }
 }
@@ -104,7 +104,7 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
        stateMachine.addRouteMapping { event, fromState, userInfo in
            guard event == .startChildFlow, case .space = fromState else { return nil }
            guard let spaceRoomListProxy = userInfo as? SpaceRoomListProxyProtocol else { fatalError("A space proxy must be provided.") }
-            return .presentingChild(childSpaceID: spaceRoomListProxy.spaceRoom.id, previousState: fromState)
+            return .presentingChild(childSpaceID: spaceRoomListProxy.spaceRoomProxy.id, previousState: fromState)
        } handler: { [weak self] context in
            guard let self, let spaceRoomListProxy = context.userInfo as? SpaceRoomListProxyProtocol else { return }
            startChildFlow(for: spaceRoomListProxy)
@@ -15840,21 +15840,21 @@ class SessionVerificationControllerProxyMock: SessionVerificationControllerProxy
    }
 }
 class SpaceRoomListProxyMock: SpaceRoomListProxyProtocol, @unchecked Sendable {
-    var spaceRoom: SpaceRoomProxyProtocol {
-        get { return underlyingSpaceRoom }
-        set(value) { underlyingSpaceRoom = value }
+    var spaceRoomProxy: SpaceRoomProxyProtocol {
+        get { return underlyingSpaceRoomProxy }
+        set(value) { underlyingSpaceRoomProxy = value }
    }
-    var underlyingSpaceRoom: SpaceRoomProxyProtocol!
+    var underlyingSpaceRoomProxy: SpaceRoomProxyProtocol!
    var spaceRoomsPublisher: CurrentValuePublisher<[SpaceRoomProxyProtocol], Never> {
        get { return underlyingSpaceRoomsPublisher }
        set(value) { underlyingSpaceRoomsPublisher = value }
    }
    var underlyingSpaceRoomsPublisher: CurrentValuePublisher<[SpaceRoomProxyProtocol], Never>!
-    var paginationStatePublisher: CurrentValuePublisher<SpaceRoomListProxyPaginationState, Never> {
+    var paginationStatePublisher: CurrentValuePublisher<SpaceRoomListPaginationState, Never> {
        get { return underlyingPaginationStatePublisher }
        set(value) { underlyingPaginationStatePublisher = value }
    }
-    var underlyingPaginationStatePublisher: CurrentValuePublisher<SpaceRoomListProxyPaginationState, Never>!
+    var underlyingPaginationStatePublisher: CurrentValuePublisher<SpaceRoomListPaginationState, Never>!

    //MARK: - paginate

@@ -15964,7 +15964,7 @@ class SpaceServiceProxyMock: SpaceServiceProxyProtocol, @unchecked Sendable {
    var spaceRoomListForCalled: Bool {
        return spaceRoomListForCallsCount > 0
    }
-    var spaceRoomListForReceivedSpaceRoom: SpaceRoomProxyProtocol?
+    var spaceRoomListForReceivedSpaceRoomProxy: SpaceRoomProxyProtocol?
    var spaceRoomListForReceivedInvocations: [SpaceRoomProxyProtocol] = []

    var spaceRoomListForUnderlyingReturnValue: Result<SpaceRoomListProxyProtocol, SpaceServiceProxyError>!
@@ -15993,14 +15993,14 @@ class SpaceServiceProxyMock: SpaceServiceProxyProtocol, @unchecked Sendable {
    }
    var spaceRoomListForClosure: ((SpaceRoomProxyProtocol) async -> Result<SpaceRoomListProxyProtocol, SpaceServiceProxyError>)?

-    func spaceRoomList(for spaceRoom: SpaceRoomProxyProtocol) async -> Result<SpaceRoomListProxyProtocol, SpaceServiceProxyError> {
+    func spaceRoomList(for spaceRoomProxy: SpaceRoomProxyProtocol) async -> Result<SpaceRoomListProxyProtocol, SpaceServiceProxyError> {
        spaceRoomListForCallsCount += 1
-        spaceRoomListForReceivedSpaceRoom = spaceRoom
+        spaceRoomListForReceivedSpaceRoomProxy = spaceRoomProxy
        DispatchQueue.main.async {
-            self.spaceRoomListForReceivedInvocations.append(spaceRoom)
+            self.spaceRoomListForReceivedInvocations.append(spaceRoomProxy)
        }
        if let spaceRoomListForClosure = spaceRoomListForClosure {
-            return await spaceRoomListForClosure(spaceRoom)
+            return await spaceRoomListForClosure(spaceRoomProxy)
        } else {
            return spaceRoomListForReturnValue
        }
@@ -4572,6 +4572,71 @@ open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable {
        }
    }

+    //MARK: - spaceService
+
+    var spaceServiceUnderlyingCallsCount = 0
+    open var spaceServiceCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return spaceServiceUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = spaceServiceUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                spaceServiceUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    spaceServiceUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var spaceServiceCalled: Bool {
+        return spaceServiceCallsCount > 0
+    }
+
+    var spaceServiceUnderlyingReturnValue: SpaceService!
+    open var spaceServiceReturnValue: SpaceService! {
+        get {
+            if Thread.isMainThread {
+                return spaceServiceUnderlyingReturnValue
+            } else {
+                var returnValue: SpaceService? = nil
+                DispatchQueue.main.sync {
+                    returnValue = spaceServiceUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                spaceServiceUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    spaceServiceUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var spaceServiceClosure: (() -> SpaceService)?
+
+    open override func spaceService() -> SpaceService {
+        spaceServiceCallsCount += 1
+        if let spaceServiceClosure = spaceServiceClosure {
+            return spaceServiceClosure()
+        } else {
+            return spaceServiceReturnValue
+        }
+    }
+
    //MARK: - startSsoLogin

    open var startSsoLoginRedirectUrlIdpIdThrowableError: Error?
@@ -21111,6 +21176,551 @@ open class SessionVerificationEmojiSDKMock: MatrixRustSDK.SessionVerificationEmo
        }
    }
 }
+open class SpaceRoomListSDKMock: MatrixRustSDK.SpaceRoomList, @unchecked Sendable {
+    init() {
+        super.init(noPointer: .init())
+    }
+
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        fatalError("init(unsafeFromRawPointer:) has not been implemented")
+    }
+
+    fileprivate var pointer: UnsafeMutableRawPointer!
+
+    //MARK: - paginate
+
+    open var paginateThrowableError: Error?
+    var paginateUnderlyingCallsCount = 0
+    open var paginateCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return paginateUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = paginateUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                paginateUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    paginateUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var paginateCalled: Bool {
+        return paginateCallsCount > 0
+    }
+    open var paginateClosure: (() async throws -> Void)?
+
+    open override func paginate() async throws {
+        if let error = paginateThrowableError {
+            throw error
+        }
+        paginateCallsCount += 1
+        try await paginateClosure?()
+    }
+
+    //MARK: - paginationState
+
+    var paginationStateUnderlyingCallsCount = 0
+    open var paginationStateCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return paginationStateUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = paginationStateUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                paginationStateUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    paginationStateUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var paginationStateCalled: Bool {
+        return paginationStateCallsCount > 0
+    }
+
+    var paginationStateUnderlyingReturnValue: SpaceRoomListPaginationState!
+    open var paginationStateReturnValue: SpaceRoomListPaginationState! {
+        get {
+            if Thread.isMainThread {
+                return paginationStateUnderlyingReturnValue
+            } else {
+                var returnValue: SpaceRoomListPaginationState? = nil
+                DispatchQueue.main.sync {
+                    returnValue = paginationStateUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                paginationStateUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    paginationStateUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var paginationStateClosure: (() -> SpaceRoomListPaginationState)?
+
+    open override func paginationState() -> SpaceRoomListPaginationState {
+        paginationStateCallsCount += 1
+        if let paginationStateClosure = paginationStateClosure {
+            return paginationStateClosure()
+        } else {
+            return paginationStateReturnValue
+        }
+    }
+
+    //MARK: - rooms
+
+    var roomsUnderlyingCallsCount = 0
+    open var roomsCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return roomsUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = roomsUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                roomsUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    roomsUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var roomsCalled: Bool {
+        return roomsCallsCount > 0
+    }
+
+    var roomsUnderlyingReturnValue: [SpaceRoom]!
+    open var roomsReturnValue: [SpaceRoom]! {
+        get {
+            if Thread.isMainThread {
+                return roomsUnderlyingReturnValue
+            } else {
+                var returnValue: [SpaceRoom]? = nil
+                DispatchQueue.main.sync {
+                    returnValue = roomsUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                roomsUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    roomsUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var roomsClosure: (() -> [SpaceRoom])?
+
+    open override func rooms() -> [SpaceRoom] {
+        roomsCallsCount += 1
+        if let roomsClosure = roomsClosure {
+            return roomsClosure()
+        } else {
+            return roomsReturnValue
+        }
+    }
+
+    //MARK: - subscribeToPaginationStateUpdates
+
+    var subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = 0
+    open var subscribeToPaginationStateUpdatesListenerCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var subscribeToPaginationStateUpdatesListenerCalled: Bool {
+        return subscribeToPaginationStateUpdatesListenerCallsCount > 0
+    }
+    open var subscribeToPaginationStateUpdatesListenerReceivedListener: SpaceRoomListPaginationStateListener?
+    open var subscribeToPaginationStateUpdatesListenerReceivedInvocations: [SpaceRoomListPaginationStateListener] = []
+
+    var subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue: TaskHandle!
+    open var subscribeToPaginationStateUpdatesListenerReturnValue: TaskHandle! {
+        get {
+            if Thread.isMainThread {
+                return subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue
+            } else {
+                var returnValue: TaskHandle? = nil
+                DispatchQueue.main.sync {
+                    returnValue = subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var subscribeToPaginationStateUpdatesListenerClosure: ((SpaceRoomListPaginationStateListener) -> TaskHandle)?
+
+    open override func subscribeToPaginationStateUpdates(listener: SpaceRoomListPaginationStateListener) -> TaskHandle {
+        subscribeToPaginationStateUpdatesListenerCallsCount += 1
+        subscribeToPaginationStateUpdatesListenerReceivedListener = listener
+        DispatchQueue.main.async {
+            self.subscribeToPaginationStateUpdatesListenerReceivedInvocations.append(listener)
+        }
+        if let subscribeToPaginationStateUpdatesListenerClosure = subscribeToPaginationStateUpdatesListenerClosure {
+            return subscribeToPaginationStateUpdatesListenerClosure(listener)
+        } else {
+            return subscribeToPaginationStateUpdatesListenerReturnValue
+        }
+    }
+
+    //MARK: - subscribeToRoomUpdate
+
+    var subscribeToRoomUpdateListenerUnderlyingCallsCount = 0
+    open var subscribeToRoomUpdateListenerCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return subscribeToRoomUpdateListenerUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = subscribeToRoomUpdateListenerUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                subscribeToRoomUpdateListenerUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    subscribeToRoomUpdateListenerUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var subscribeToRoomUpdateListenerCalled: Bool {
+        return subscribeToRoomUpdateListenerCallsCount > 0
+    }
+    open var subscribeToRoomUpdateListenerReceivedListener: SpaceRoomListEntriesListener?
+    open var subscribeToRoomUpdateListenerReceivedInvocations: [SpaceRoomListEntriesListener] = []
+
+    var subscribeToRoomUpdateListenerUnderlyingReturnValue: TaskHandle!
+    open var subscribeToRoomUpdateListenerReturnValue: TaskHandle! {
+        get {
+            if Thread.isMainThread {
+                return subscribeToRoomUpdateListenerUnderlyingReturnValue
+            } else {
+                var returnValue: TaskHandle? = nil
+                DispatchQueue.main.sync {
+                    returnValue = subscribeToRoomUpdateListenerUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                subscribeToRoomUpdateListenerUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    subscribeToRoomUpdateListenerUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var subscribeToRoomUpdateListenerClosure: ((SpaceRoomListEntriesListener) -> TaskHandle)?
+
+    open override func subscribeToRoomUpdate(listener: SpaceRoomListEntriesListener) -> TaskHandle {
+        subscribeToRoomUpdateListenerCallsCount += 1
+        subscribeToRoomUpdateListenerReceivedListener = listener
+        DispatchQueue.main.async {
+            self.subscribeToRoomUpdateListenerReceivedInvocations.append(listener)
+        }
+        if let subscribeToRoomUpdateListenerClosure = subscribeToRoomUpdateListenerClosure {
+            return subscribeToRoomUpdateListenerClosure(listener)
+        } else {
+            return subscribeToRoomUpdateListenerReturnValue
+        }
+    }
+}
+open class SpaceServiceSDKMock: MatrixRustSDK.SpaceService, @unchecked Sendable {
+    init() {
+        super.init(noPointer: .init())
+    }
+
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        fatalError("init(unsafeFromRawPointer:) has not been implemented")
+    }
+
+    fileprivate var pointer: UnsafeMutableRawPointer!
+
+    //MARK: - joinedSpaces
+
+    var joinedSpacesUnderlyingCallsCount = 0
+    open var joinedSpacesCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return joinedSpacesUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = joinedSpacesUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                joinedSpacesUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    joinedSpacesUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var joinedSpacesCalled: Bool {
+        return joinedSpacesCallsCount > 0
+    }
+
+    var joinedSpacesUnderlyingReturnValue: [SpaceRoom]!
+    open var joinedSpacesReturnValue: [SpaceRoom]! {
+        get {
+            if Thread.isMainThread {
+                return joinedSpacesUnderlyingReturnValue
+            } else {
+                var returnValue: [SpaceRoom]? = nil
+                DispatchQueue.main.sync {
+                    returnValue = joinedSpacesUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                joinedSpacesUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    joinedSpacesUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var joinedSpacesClosure: (() async -> [SpaceRoom])?
+
+    open override func joinedSpaces() async -> [SpaceRoom] {
+        joinedSpacesCallsCount += 1
+        if let joinedSpacesClosure = joinedSpacesClosure {
+            return await joinedSpacesClosure()
+        } else {
+            return joinedSpacesReturnValue
+        }
+    }
+
+    //MARK: - spaceRoomList
+
+    open var spaceRoomListSpaceIdThrowableError: Error?
+    var spaceRoomListSpaceIdUnderlyingCallsCount = 0
+    open var spaceRoomListSpaceIdCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return spaceRoomListSpaceIdUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = spaceRoomListSpaceIdUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                spaceRoomListSpaceIdUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    spaceRoomListSpaceIdUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var spaceRoomListSpaceIdCalled: Bool {
+        return spaceRoomListSpaceIdCallsCount > 0
+    }
+    open var spaceRoomListSpaceIdReceivedSpaceId: String?
+    open var spaceRoomListSpaceIdReceivedInvocations: [String] = []
+
+    var spaceRoomListSpaceIdUnderlyingReturnValue: SpaceRoomList!
+    open var spaceRoomListSpaceIdReturnValue: SpaceRoomList! {
+        get {
+            if Thread.isMainThread {
+                return spaceRoomListSpaceIdUnderlyingReturnValue
+            } else {
+                var returnValue: SpaceRoomList? = nil
+                DispatchQueue.main.sync {
+                    returnValue = spaceRoomListSpaceIdUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                spaceRoomListSpaceIdUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    spaceRoomListSpaceIdUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var spaceRoomListSpaceIdClosure: ((String) async throws -> SpaceRoomList)?
+
+    open override func spaceRoomList(spaceId: String) async throws -> SpaceRoomList {
+        if let error = spaceRoomListSpaceIdThrowableError {
+            throw error
+        }
+        spaceRoomListSpaceIdCallsCount += 1
+        spaceRoomListSpaceIdReceivedSpaceId = spaceId
+        DispatchQueue.main.async {
+            self.spaceRoomListSpaceIdReceivedInvocations.append(spaceId)
+        }
+        if let spaceRoomListSpaceIdClosure = spaceRoomListSpaceIdClosure {
+            return try await spaceRoomListSpaceIdClosure(spaceId)
+        } else {
+            return spaceRoomListSpaceIdReturnValue
+        }
+    }
+
+    //MARK: - subscribeToJoinedSpaces
+
+    var subscribeToJoinedSpacesListenerUnderlyingCallsCount = 0
+    open var subscribeToJoinedSpacesListenerCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return subscribeToJoinedSpacesListenerUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = subscribeToJoinedSpacesListenerUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                subscribeToJoinedSpacesListenerUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    subscribeToJoinedSpacesListenerUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var subscribeToJoinedSpacesListenerCalled: Bool {
+        return subscribeToJoinedSpacesListenerCallsCount > 0
+    }
+    open var subscribeToJoinedSpacesListenerReceivedListener: SpaceServiceJoinedSpacesListener?
+    open var subscribeToJoinedSpacesListenerReceivedInvocations: [SpaceServiceJoinedSpacesListener] = []
+
+    var subscribeToJoinedSpacesListenerUnderlyingReturnValue: TaskHandle!
+    open var subscribeToJoinedSpacesListenerReturnValue: TaskHandle! {
+        get {
+            if Thread.isMainThread {
+                return subscribeToJoinedSpacesListenerUnderlyingReturnValue
+            } else {
+                var returnValue: TaskHandle? = nil
+                DispatchQueue.main.sync {
+                    returnValue = subscribeToJoinedSpacesListenerUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                subscribeToJoinedSpacesListenerUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    subscribeToJoinedSpacesListenerUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var subscribeToJoinedSpacesListenerClosure: ((SpaceServiceJoinedSpacesListener) async -> TaskHandle)?
+
+    open override func subscribeToJoinedSpaces(listener: SpaceServiceJoinedSpacesListener) async -> TaskHandle {
+        subscribeToJoinedSpacesListenerCallsCount += 1
+        subscribeToJoinedSpacesListenerReceivedListener = listener
+        DispatchQueue.main.async {
+            self.subscribeToJoinedSpacesListenerReceivedInvocations.append(listener)
+        }
+        if let subscribeToJoinedSpacesListenerClosure = subscribeToJoinedSpacesListenerClosure {
+            return await subscribeToJoinedSpacesListenerClosure(listener)
+        } else {
+            return subscribeToJoinedSpacesListenerReturnValue
+        }
+    }
+}
 open class SpanSDKMock: MatrixRustSDK.Span, @unchecked Sendable {
    init() {
        super.init(noPointer: .init())
@@ -21395,6 +22005,42 @@ open class SyncServiceSDKMock: MatrixRustSDK.SyncService, @unchecked Sendable {

    fileprivate var pointer: UnsafeMutableRawPointer!

+    //MARK: - expireSessions
+
+    var expireSessionsUnderlyingCallsCount = 0
+    open var expireSessionsCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return expireSessionsUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = expireSessionsUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                expireSessionsUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    expireSessionsUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var expireSessionsCalled: Bool {
+        return expireSessionsCallsCount > 0
+    }
+    open var expireSessionsClosure: (() async -> Void)?
+
+    open override func expireSessions() async {
+        expireSessionsCallsCount += 1
+        await expireSessionsClosure?()
+    }
+
    //MARK: - roomListService

    var roomListServiceUnderlyingCallsCount = 0
@@ -13,12 +13,12 @@ extension SpaceRoomListProxyMock {
    class Configuration {
        var spaceRoomProxy: SpaceRoomProxyProtocol
        var initialSpaceRooms: [SpaceRoomProxyProtocol]
-        var paginationStateSubject: CurrentValueSubject<SpaceRoomListProxyPaginationState, Never>
+        var paginationStateSubject: CurrentValueSubject<SpaceRoomListPaginationState, Never>
        var paginationResponses: [[SpaceRoomProxyProtocol]]
        
        init(spaceRoomProxy: SpaceRoomProxyProtocol,
             initialSpaceRooms: [SpaceRoomProxyProtocol] = [],
-             paginationStateSubject: CurrentValueSubject<SpaceRoomListProxyPaginationState, Never> = .init(.idle(endReached: true)),
+             paginationStateSubject: CurrentValueSubject<SpaceRoomListPaginationState, Never> = .init(.idle(endReached: true)),
             paginationResponses: [[SpaceRoomProxyProtocol]] = []) {
            self.spaceRoomProxy = spaceRoomProxy
            self.initialSpaceRooms = initialSpaceRooms
@@ -32,7 +32,7 @@ extension SpaceRoomListProxyMock {
        
        let spaceRoomsSubject: CurrentValueSubject<[SpaceRoomProxyProtocol], Never> = .init(configuration.initialSpaceRooms)
        
-        spaceRoom = configuration.spaceRoomProxy
+        spaceRoomProxy = configuration.spaceRoomProxy
        spaceRoomsPublisher = spaceRoomsSubject.asCurrentValuePublisher()
        paginationStatePublisher = configuration.paginationStateSubject.asCurrentValuePublisher()
        
@@ -78,6 +78,20 @@ extension SDKListener: RoomListLoadingStateListener where T == RoomListLoadingSt
    func onUpdate(state: RoomListLoadingState) { onUpdateClosure(state) }
 }

+// MARK: Spaces
+
+extension SDKListener: SpaceServiceJoinedSpacesListener where T == [SpaceListUpdate] {
+    func onUpdate(rooms: [SpaceListUpdate]) { onUpdateClosure(rooms) }
+}
+
+extension SDKListener: SpaceRoomListEntriesListener where T == [SpaceListUpdate] {
+    func onUpdate(roomUpdates: [SpaceListUpdate]) { onUpdateClosure(roomUpdates) }
+}
+
+extension SDKListener: SpaceRoomListPaginationStateListener where T == SpaceRoomListPaginationState {
+    func onUpdate(paginationState: SpaceRoomListPaginationState) { onUpdateClosure(paginationState) }
+}
+
 // MARK: Room

 extension SDKListener: RoomInfoListener where T == RoomInfo {
@@ -35,7 +35,7 @@ final class SpaceScreenCoordinator: CoordinatorProtocol {
    init(parameters: SpaceScreenCoordinatorParameters) {
        self.parameters = parameters
        
-        viewModel = SpaceScreenViewModel(spaceRoomList: parameters.spaceRoomListProxy,
+        viewModel = SpaceScreenViewModel(spaceRoomListProxy: parameters.spaceRoomListProxy,
                                         spaceServiceProxy: parameters.spaceServiceProxy,
                                         mediaProvider: parameters.mediaProvider,
                                         userIndicatorController: parameters.userIndicatorController)
@@ -19,30 +19,32 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
        actionsSubject.eraseToAnyPublisher()
    }

-    init(spaceRoomList: SpaceRoomListProxyProtocol,
+    init(spaceRoomListProxy: SpaceRoomListProxyProtocol,
         spaceServiceProxy: SpaceServiceProxyProtocol,
         mediaProvider: MediaProviderProtocol,
         userIndicatorController: UserIndicatorControllerProtocol) {
        self.spaceServiceProxy = spaceServiceProxy
        self.userIndicatorController = userIndicatorController
        
-        super.init(initialViewState: SpaceScreenViewState(space: spaceRoomList.spaceRoom,
-                                                          rooms: spaceRoomList.spaceRoomsPublisher.value),
+        super.init(initialViewState: SpaceScreenViewState(space: spaceRoomListProxy.spaceRoomProxy,
+                                                          rooms: spaceRoomListProxy.spaceRoomsPublisher.value),
                   mediaProvider: mediaProvider)
        
-        spaceRoomList.spaceRoomsPublisher
+        spaceRoomListProxy.spaceRoomsPublisher
            .receive(on: DispatchQueue.main)
            .weakAssign(to: \.state.rooms, on: self)
            .store(in: &cancellables)
        
-        spaceRoomList.paginationStatePublisher
+        // As the server is slow, we just let the screen automatically paginate everything in. We can
+        // switch this to use the scroll position once Synapse receives some performance improvements.
+        spaceRoomListProxy.paginationStatePublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] paginationState in
                switch paginationState {
                case .idle(let endReached):
                    self?.state.isPaginating = false
                    guard !endReached else { return }
-                    Task { await spaceRoomList.paginate() }
+                    Task { await spaceRoomListProxy.paginate() }
                case .loading:
                    self?.state.isPaginating = true
                }
@@ -64,7 +64,7 @@ struct SpaceScreen_Previews: PreviewProvider, TestablePreview {
        let spaceRoomListProxy = SpaceRoomListProxyMock(.init(spaceRoomProxy: spaceRoomProxy,
                                                              initialSpaceRooms: .mockSpaceList))
        
-        let viewModel = SpaceScreenViewModel(spaceRoomList: spaceRoomListProxy,
+        let viewModel = SpaceScreenViewModel(spaceRoomListProxy: spaceRoomListProxy,
                                             spaceServiceProxy: SpaceServiceProxyMock(.init()),
                                             mediaProvider: MediaProviderMock(configuration: .init()),
                                             userIndicatorController: UserIndicatorControllerMock())
@@ -166,9 +166,7 @@ class ClientProxy: ClientProxyProtocol {
        
        secureBackupController = SecureBackupController(encryption: client.encryption())
        
-        // Temporarily using the mock until the SDK is updated.
-        // spaceService = SpaceServiceProxy(spaceService: client.spaceService())
-        spaceService = SpaceServiceProxyMock(.init())
+        spaceService = SpaceServiceProxy(spaceService: client.spaceService())
        
        let configuredAppService = try await ClientProxyServices(client: client,
                                                                 actionsSubject: actionsSubject,
@@ -0,0 +1,82 @@
+//
+// Copyright 2025 New Vector Ltd.
+//
+// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+// Please see LICENSE files in the repository root for full details.
+//
+
+import Combine
+import MatrixRustSDK
+
+class SpaceRoomListProxy: SpaceRoomListProxyProtocol {
+    private let spaceRoomList: SpaceRoomListProtocol
+    let spaceRoomProxy: SpaceRoomProxyProtocol
+    
+    private var spaceRoomsHandle: TaskHandle?
+    private let spaceRoomsSubject = CurrentValueSubject<[SpaceRoomProxyProtocol], Never>([])
+    var spaceRoomsPublisher: CurrentValuePublisher<[SpaceRoomProxyProtocol], Never> {
+        spaceRoomsSubject.asCurrentValuePublisher()
+    }
+    
+    private let paginationStateHandle: TaskHandle
+    let paginationStatePublisher: CurrentValuePublisher<SpaceRoomListPaginationState, Never>
+    
+    init(_ spaceRoomList: SpaceRoomListProtocol, spaceRoomProxy: SpaceRoomProxyProtocol) {
+        self.spaceRoomList = spaceRoomList
+        self.spaceRoomProxy = spaceRoomProxy
+        
+        let paginationStateSubject = CurrentValueSubject<SpaceRoomListPaginationState, Never>(spaceRoomList.paginationState())
+        paginationStatePublisher = paginationStateSubject.asCurrentValuePublisher()
+        
+        paginationStateHandle = spaceRoomList.subscribeToPaginationStateUpdates(listener: SDKListener { paginationState in
+            paginationStateSubject.send(paginationState)
+        })
+        
+        spaceRoomsHandle = spaceRoomList.subscribeToRoomUpdate(listener: SDKListener { [weak self] updates in
+            self?.handleUpdates(updates)
+        })
+    }
+    
+    func paginate() async {
+        do {
+            try await spaceRoomList.paginate()
+        } catch {
+            MXLog.error("Pagination failure: \(error)")
+        }
+    }
+    
+    // MARK: - Private
+    
+    private func handleUpdates(_ updates: [SpaceListUpdate]) {
+        var rooms = spaceRoomsSubject.value
+        
+        for update in updates {
+            switch update {
+            case .append(let spaceRooms):
+                rooms.append(contentsOf: spaceRooms.map(SpaceRoomProxy.init))
+            case .clear:
+                rooms.removeAll()
+            case .pushFront(let spaceRoom):
+                rooms.insert(SpaceRoomProxy(spaceRoom: spaceRoom), at: 0)
+            case .pushBack(let spaceRoom):
+                rooms.append(SpaceRoomProxy(spaceRoom: spaceRoom))
+            case .popFront:
+                rooms.removeFirst()
+            case .popBack:
+                rooms.removeLast()
+            case .insert(let index, let spaceRoom):
+                rooms.insert(SpaceRoomProxy(spaceRoom: spaceRoom), at: Int(index))
+            case .set(let index, let spaceRoom):
+                rooms[Int(index)] = SpaceRoomProxy(spaceRoom: spaceRoom)
+            case .remove(let index):
+                rooms.remove(at: Int(index))
+            case .truncate(let length):
+                rooms.removeSubrange(Int(length)..<rooms.count)
+            case .reset(let spaceRooms):
+                rooms = spaceRooms.map(SpaceRoomProxy.init)
+            }
+        }
+        
+        spaceRoomsSubject.send(rooms)
+    }
+}
@@ -8,18 +8,12 @@
 import Combine
 import MatrixRustSDK

-// Temporary until the SDK is updated.
-enum SpaceRoomListProxyPaginationState: Equatable {
-    case idle(endReached: Bool)
-    case loading
-}
-
 // sourcery: AutoMockable
 protocol SpaceRoomListProxyProtocol {
-    var spaceRoom: SpaceRoomProxyProtocol { get }
+    var spaceRoomProxy: SpaceRoomProxyProtocol { get }
    
    var spaceRoomsPublisher: CurrentValuePublisher<[SpaceRoomProxyProtocol], Never> { get }
-    var paginationStatePublisher: CurrentValuePublisher<SpaceRoomListProxyPaginationState, Never> { get }
+    var paginationStatePublisher: CurrentValuePublisher<SpaceRoomListPaginationState, Never> { get }
    
    func paginate() async
 }
@@ -0,0 +1,34 @@
+//
+// Copyright 2025 New Vector Ltd.
+//
+// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+// Please see LICENSE files in the repository root for full details.
+//
+
+import Foundation
+import MatrixRustSDK
+
+class SpaceRoomProxy: SpaceRoomProxyProtocol {
+    private let spaceRoom: SpaceRoom
+    
+    init(spaceRoom: SpaceRoom) {
+        self.spaceRoom = spaceRoom
+    }
+    
+    lazy var id = spaceRoom.roomId
+    var name: String? { spaceRoom.name }
+    var avatarURL: URL? { spaceRoom.avatarUrl.flatMap(URL.init) }
+    
+    var isSpace: Bool { spaceRoom.roomType == .space }
+    var childrenCount: Int { Int(spaceRoom.childrenCount) }
+    
+    var joinedMembersCount: Int { Int(spaceRoom.numJoinedMembers) }
+    var heroes: [UserProfileProxy] { (spaceRoom.heroes ?? []).map(UserProfileProxy.init) }
+    var topic: String? { spaceRoom.topic }
+    var canonicalAlias: String? { spaceRoom.canonicalAlias }
+    
+    var joinRule: JoinRule? { spaceRoom.joinRule }
+    var worldReadable: Bool? { spaceRoom.worldReadable }
+    var guestCanJoin: Bool { spaceRoom.guestCanJoin }
+    var state: Membership? { spaceRoom.state }
+}
@@ -0,0 +1,76 @@
+//
+// Copyright 2025 New Vector Ltd.
+//
+// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+// Please see LICENSE files in the repository root for full details.
+//
+
+import Combine
+import Foundation
+import MatrixRustSDK
+
+class SpaceServiceProxy: SpaceServiceProxyProtocol {
+    private let spaceService: SpaceServiceProtocol
+    
+    private var joinedSpacesHandle: TaskHandle?
+    private let spacesSubject = CurrentValueSubject<[SpaceRoomProxyProtocol], Never>([])
+    var joinedSpacesPublisher: CurrentValuePublisher<[SpaceRoomProxyProtocol], Never> {
+        spacesSubject.asCurrentValuePublisher()
+    }
+    
+    init(spaceService: SpaceServiceProtocol) {
+        self.spaceService = spaceService
+        
+        Task { await setupSubscriptions() }
+    }
+    
+    private func setupSubscriptions() async {
+        joinedSpacesHandle = await spaceService.subscribeToJoinedSpaces(listener: SDKListener { [weak self] updates in
+            self?.handleUpdates(updates)
+        })
+    }
+    
+    func spaceRoomList(for spaceRoomProxy: SpaceRoomProxyProtocol) async -> Result<SpaceRoomListProxyProtocol, SpaceServiceProxyError> {
+        do {
+            return try await .success(SpaceRoomListProxy(spaceService.spaceRoomList(spaceId: spaceRoomProxy.id), spaceRoomProxy: spaceRoomProxy))
+        } catch {
+            MXLog.error("Failed creating space room list for \(spaceRoomProxy.id): \(error)")
+            return .failure(.sdkError(error))
+        }
+    }
+    
+    // MARK: - Private
+    
+    private func handleUpdates(_ updates: [SpaceListUpdate]) {
+        var spaces = spacesSubject.value
+        
+        for update in updates {
+            switch update {
+            case .append(let spaceRooms):
+                spaces.append(contentsOf: spaceRooms.map(SpaceRoomProxy.init))
+            case .clear:
+                spaces.removeAll()
+            case .pushFront(let spaceRoom):
+                spaces.insert(SpaceRoomProxy(spaceRoom: spaceRoom), at: 0)
+            case .pushBack(let spaceRoom):
+                spaces.append(SpaceRoomProxy(spaceRoom: spaceRoom))
+            case .popFront:
+                spaces.removeFirst()
+            case .popBack:
+                spaces.removeLast()
+            case .insert(let index, let spaceRoom):
+                spaces.insert(SpaceRoomProxy(spaceRoom: spaceRoom), at: Int(index))
+            case .set(let index, let spaceRoom):
+                spaces[Int(index)] = SpaceRoomProxy(spaceRoom: spaceRoom)
+            case .remove(let index):
+                spaces.remove(at: Int(index))
+            case .truncate(let length):
+                spaces.removeSubrange(Int(length)..<spaces.count)
+            case .reset(let spaceRooms):
+                spaces = spaceRooms.map(SpaceRoomProxy.init)
+            }
+        }
+        
+        spacesSubject.send(spaces)
+    }
+}
@@ -15,5 +15,5 @@ enum SpaceServiceProxyError: Error {
 protocol SpaceServiceProxyProtocol {
    var joinedSpacesPublisher: CurrentValuePublisher<[SpaceRoomProxyProtocol], Never> { get }
    
-    func spaceRoomList(for spaceRoom: SpaceRoomProxyProtocol) async -> Result<SpaceRoomListProxyProtocol, SpaceServiceProxyError>
+    func spaceRoomList(for spaceRoomProxy: SpaceRoomProxyProtocol) async -> Result<SpaceRoomListProxyProtocol, SpaceServiceProxyError>
 }