Add support for joining rooms from a space. (#4501)

* Add support for joining rooms from a space. Doesn't yet handle the Join button 🤔 * Handle the join button for both rooms and spaces. Also refactor more instances of spaceRoom to spaceRoomProxy.
2026-11-04 00:49:44 +00:00 · 2025-09-11 16:41:19 +01:00
parent 880f2060f4
commit c2ac60f1e6
30 changed files with 304 additions and 34 deletions
@@ -158,7 +158,7 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
        let parameters = SpaceScreenCoordinatorParameters(spaceRoomListProxy: spaceRoomListProxy,
                                                          spaceServiceProxy: spaceServiceProxy,
                                                          selectedSpaceRoomPublisher: selectedSpaceRoomSubject.asCurrentValuePublisher(),
-                                                          mediaProvider: flowParameters.userSession.mediaProvider,
+                                                          userSession: flowParameters.userSession,
                                                          userIndicatorController: flowParameters.userIndicatorController)
        let coordinator = SpaceScreenCoordinator(parameters: parameters)
        coordinator.actionsPublisher
@@ -15,6 +15,7 @@ struct ClientProxyMockConfiguration {
    var deviceID: String?
    var roomSummaryProvider: RoomSummaryProviderProtocol = RoomSummaryProviderMock(.init())
    var joinedSpaceRooms: [SpaceRoomProxyProtocol] = []
+    var roomPreviews: [RoomPreviewProxyProtocol]?
    var roomDirectorySearchProxy: RoomDirectorySearchProxyProtocol?
    
    var recoveryState: SecureBackupRecoveryState = .enabled
@@ -65,6 +66,7 @@ extension ClientProxyMock {
        directRoomForUserIDReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
        createDirectRoomWithExpectedRoomNameReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
        createRoomNameTopicIsRoomPrivateIsKnockingOnlyUserIDsAvatarURLAliasLocalPartReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
+        canJoinRoomWithReturnValue = true
        uploadMediaReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
        loadUserDisplayNameReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
        setUserDisplayNameReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
@@ -95,13 +97,23 @@ extension ClientProxyMock {
        roomForIdentifierClosure = { [weak self] identifier in
            if let room = self?.roomSummaryProvider.roomListPublisher.value.first(where: { $0.id == identifier }) {
                await .joined(JoinedRoomProxyMock(.init(id: room.id, name: room.name)))
-            } else if let spaceRoom = configuration.joinedSpaceRooms.first(where: { $0.id == identifier }) {
-                await .joined(JoinedRoomProxyMock(.init(id: spaceRoom.id, name: spaceRoom.name)))
+            } else if let spaceRoomProxy = configuration.joinedSpaceRooms.first(where: { $0.id == identifier }) {
+                await .joined(JoinedRoomProxyMock(.init(id: spaceRoomProxy.id, name: spaceRoomProxy.name)))
            } else {
                nil
            }
        }
        
+        if let roomPreviews = configuration.roomPreviews {
+            roomPreviewForIdentifierViaClosure = { roomID, _ in
+                if let preview = roomPreviews.first(where: { $0.info.id == roomID }) {
+                    .success(preview)
+                } else {
+                    .failure(.roomPreviewIsPrivate)
+                }
+            }
+        }
+        
        userIdentityForReturnValue = .success(UserIdentityProxyMock(configuration: .init()))
        
        underlyingIsReportRoomSupported = true
@@ -2987,6 +2987,76 @@ class ClientProxyMock: ClientProxyProtocol, @unchecked Sendable {
            return knockRoomAliasMessageReturnValue
        }
    }
+    //MARK: - canJoinRoom
+
+    var canJoinRoomWithUnderlyingCallsCount = 0
+    var canJoinRoomWithCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return canJoinRoomWithUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = canJoinRoomWithUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                canJoinRoomWithUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    canJoinRoomWithUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var canJoinRoomWithCalled: Bool {
+        return canJoinRoomWithCallsCount > 0
+    }
+    var canJoinRoomWithReceivedRules: [AllowRule]?
+    var canJoinRoomWithReceivedInvocations: [[AllowRule]] = []
+
+    var canJoinRoomWithUnderlyingReturnValue: Bool!
+    var canJoinRoomWithReturnValue: Bool! {
+        get {
+            if Thread.isMainThread {
+                return canJoinRoomWithUnderlyingReturnValue
+            } else {
+                var returnValue: Bool? = nil
+                DispatchQueue.main.sync {
+                    returnValue = canJoinRoomWithUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                canJoinRoomWithUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    canJoinRoomWithUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    var canJoinRoomWithClosure: (([AllowRule]) -> Bool)?
+
+    func canJoinRoom(with rules: [AllowRule]) -> Bool {
+        canJoinRoomWithCallsCount += 1
+        canJoinRoomWithReceivedRules = rules
+        DispatchQueue.main.async {
+            self.canJoinRoomWithReceivedInvocations.append(rules)
+        }
+        if let canJoinRoomWithClosure = canJoinRoomWithClosure {
+            return canJoinRoomWithClosure(rules)
+        } else {
+            return canJoinRoomWithReturnValue
+        }
+    }
    //MARK: - uploadMedia

    var uploadMediaUnderlyingCallsCount = 0
@@ -96,4 +96,18 @@ extension RoomPreviewProxyMock {
        
        underlyingOwnMembershipDetails = roomMembershipDetails
    }
+    
+    convenience init(spaceRoomProxy: SpaceRoomProxyProtocol) {
+        self.init(Configuration(roomID: spaceRoomProxy.id,
+                                canonicalAlias: spaceRoomProxy.canonicalAlias ?? "",
+                                name: spaceRoomProxy.name ?? "",
+                                topic: spaceRoomProxy.topic ?? "",
+                                avatarURL: spaceRoomProxy.avatarURL?.absoluteString ?? "",
+                                numJoinedMembers: UInt64(spaceRoomProxy.joinedMembersCount),
+                                numActiveMembers: UInt64(spaceRoomProxy.joinedMembersCount),
+                                roomType: spaceRoomProxy.isSpace ? .space : .room,
+                                membership: nil,
+                                joinRule: spaceRoomProxy.joinRule ?? .restricted(rules: []),
+                                isDirect: false))
+    }
 }
@@ -19,8 +19,8 @@ extension SpaceServiceProxyMock {
        self.init()
        
        joinedSpacesPublisher = .init(configuration.joinedSpaces)
-        spaceRoomListForClosure = { spaceRoom in
-            if let spaceRoomList = configuration.spaceRoomLists[spaceRoom.id] {
+        spaceRoomListForClosure = { spaceRoomProxy in
+            if let spaceRoomList = configuration.spaceRoomLists[spaceRoomProxy.id] {
                .success(spaceRoomList)
            } else {
                .failure(.sdkError(ClientProxyMockError.generic))
@@ -6,6 +6,7 @@
 //

 import Combine
+import MatrixRustSDK
 import SwiftUI

 typealias JoinRoomScreenViewModelType = StateStoreViewModel<JoinRoomScreenViewState, JoinRoomScreenViewAction>
@@ -211,8 +212,8 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
                    state.mode = .inviteRequired
                case .knock, .knockRestricted:
                    state.mode = appSettings.knockingEnabled ? .knockable : .joinable
-                case .restricted:
-                    state.mode = .restricted
+                case .restricted(let rules):
+                    state.mode = clientProxy.canJoinRoom(with: rules) ? .joinable : .restricted
                default:
                    state.mode = .joinable
                }
@@ -306,7 +306,8 @@ struct JoinRoomScreen: View {
 struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
    static let unknownViewModel = makeViewModel(mode: .unknown)
    static let joinableViewModel = makeViewModel(mode: .joinable)
-    static let restrictedViewModel = makeViewModel(mode: .restricted)
+    static let restrictedViewModel = makeViewModel(mode: .restricted, canJoinRoom: false)
+    static let restrictedJoinableViewModel = makeViewModel(mode: .restricted)
    static let inviteRequiredViewModel = makeViewModel(mode: .inviteRequired)
    static let invitedViewModel = makeViewModel(mode: .invited(isDM: false))
    static let invitedDMViewModel = makeViewModel(mode: .invited(isDM: true))
@@ -321,6 +322,8 @@ struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
        makePreview(viewModel: unknownViewModel, mode: .unknown)
        makePreview(viewModel: joinableViewModel, mode: .joinable)
        makePreview(viewModel: restrictedViewModel, mode: .restricted)
+        makePreview(viewModel: restrictedJoinableViewModel, mode: .restricted,
+                    customPreviewName: "RestrictedJoinable")
        makePreview(viewModel: inviteRequiredViewModel, mode: .inviteRequired)
        makePreview(viewModel: invitedViewModel, mode: .invited(isDM: false))
        makePreview(viewModel: invitedDMViewModel, mode: .invited(isDM: true))
@@ -359,11 +362,14 @@ struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
        }
    }
    
-    static func makeViewModel(mode: JoinRoomScreenMode, hideInviteAvatars: Bool = false) -> JoinRoomScreenViewModel {
+    static func makeViewModel(mode: JoinRoomScreenMode,
+                              canJoinRoom: Bool = true,
+                              hideInviteAvatars: Bool = false) -> JoinRoomScreenViewModel {
        let appSettings = AppSettings()
        appSettings.knockingEnabled = true
        
        let clientProxy = ClientProxyMock(.init(hideInviteAvatars: hideInviteAvatars))
+        clientProxy.canJoinRoomWithReturnValue = canJoinRoom
        
        switch mode {
        case .unknown:
@@ -14,6 +14,7 @@ struct SpaceRoomCell: View {
    
    let spaceRoomProxy: SpaceRoomProxyProtocol
    let isSelected: Bool
+    var isJoining = false
    let mediaProvider: MediaProviderProtocol!
    
    enum Action { case select(SpaceRoomProxyProtocol), join(SpaceRoomProxyProtocol) }
@@ -116,6 +117,12 @@ struct SpaceRoomCell: View {
            Button(L10n.actionJoin) { action(.join(spaceRoomProxy)) }
                .font(.compound.bodyLG)
                .foregroundStyle(.compound.textActionAccent)
+                .opacity(isJoining ? 0 : 1)
+                .overlay {
+                    if isJoining {
+                        ProgressView()
+                    }
+                }
        case .joined, .knocked, .banned:
            EmptyView()
        }
@@ -145,6 +152,15 @@ struct SpaceRoomCell_Previews: PreviewProvider, TestablePreview {
                              isSelected: false,
                              mediaProvider: mediaProvider) { _ in }
            }
+            
+            SpaceRoomCell(spaceRoomProxy: SpaceRoomProxyMock(.init(id: "Space being joined", isSpace: true)),
+                          isSelected: false,
+                          isJoining: true,
+                          mediaProvider: mediaProvider) { _ in }
+            SpaceRoomCell(spaceRoomProxy: SpaceRoomProxyMock(.init(id: "Room being joined", isSpace: false)),
+                          isSelected: false,
+                          isJoining: true,
+                          mediaProvider: mediaProvider) { _ in }
        }
    }
 }
@@ -58,7 +58,7 @@ class SpaceListScreenViewModel: SpaceListScreenViewModelType, SpaceListScreenVie
        switch viewAction {
        case .spaceAction(.select(let spaceRoomProxy)):
            Task { await selectSpace(spaceRoomProxy) }
-        case .spaceAction(.join(let spaceRoom)):
+        case .spaceAction(.join(let spaceRoomProxy)):
            #warning("Implement joining.")
        case .showSettings:
            actionsSubject.send(.showSettings)
@@ -58,9 +58,9 @@ struct SpaceListScreen: View {
    }
    
    var spaces: some View {
-        ForEach(context.viewState.joinedSpaces, id: \.id) { spaceRoom in
-            SpaceRoomCell(spaceRoomProxy: spaceRoom,
-                          isSelected: spaceRoom.id == context.viewState.selectedSpaceID,
+        ForEach(context.viewState.joinedSpaces, id: \.id) { spaceRoomProxy in
+            SpaceRoomCell(spaceRoomProxy: spaceRoomProxy,
+                          isSelected: spaceRoomProxy.id == context.viewState.selectedSpaceID,
                          mediaProvider: context.mediaProvider) { action in
                context.send(viewAction: .spaceAction(action))
            }
@@ -14,7 +14,7 @@ struct SpaceScreenCoordinatorParameters {
    let spaceRoomListProxy: SpaceRoomListProxyProtocol
    let spaceServiceProxy: SpaceServiceProxyProtocol
    let selectedSpaceRoomPublisher: CurrentValuePublisher<String?, Never>
-    let mediaProvider: MediaProviderProtocol
+    let userSession: UserSessionProtocol
    let userIndicatorController: UserIndicatorControllerProtocol
 }

@@ -40,7 +40,7 @@ final class SpaceScreenCoordinator: CoordinatorProtocol {
        viewModel = SpaceScreenViewModel(spaceRoomListProxy: parameters.spaceRoomListProxy,
                                         spaceServiceProxy: parameters.spaceServiceProxy,
                                         selectedSpaceRoomPublisher: parameters.selectedSpaceRoomPublisher,
-                                         mediaProvider: parameters.mediaProvider,
+                                         userSession: parameters.userSession,
                                         userIndicatorController: parameters.userIndicatorController)
    }
    
@@ -58,6 +58,10 @@ final class SpaceScreenCoordinator: CoordinatorProtocol {
        }
        .store(in: &cancellables)
    }
+    
+    func stop() {
+        viewModel.stop()
+    }
        
    func toPresentable() -> AnyView {
        AnyView(SpaceScreen(context: viewModel.context))
@@ -18,6 +18,7 @@ struct SpaceScreenViewState: BindableState {
    var isPaginating = false
    var rooms: [SpaceRoomProxyProtocol]
    var selectedSpaceRoomID: String?
+    var joiningRoomIDs: Set<String> = []
    
    var bindings = SpaceScreenViewStateBindings()
    
@@ -12,6 +12,7 @@ typealias SpaceScreenViewModelType = StateStoreViewModelV2<SpaceScreenViewState,

 class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtocol {
    private let spaceServiceProxy: SpaceServiceProxyProtocol
+    private let clientProxy: ClientProxyProtocol
    private let userIndicatorController: UserIndicatorControllerProtocol
    
    private let actionsSubject: PassthroughSubject<SpaceScreenViewModelAction, Never> = .init()
@@ -22,15 +23,16 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
    init(spaceRoomListProxy: SpaceRoomListProxyProtocol,
         spaceServiceProxy: SpaceServiceProxyProtocol,
         selectedSpaceRoomPublisher: CurrentValuePublisher<String?, Never>,
-         mediaProvider: MediaProviderProtocol,
+         userSession: UserSessionProtocol,
         userIndicatorController: UserIndicatorControllerProtocol) {
        self.spaceServiceProxy = spaceServiceProxy
+        clientProxy = userSession.clientProxy
        self.userIndicatorController = userIndicatorController
        
        super.init(initialViewState: SpaceScreenViewState(space: spaceRoomListProxy.spaceRoomProxy,
                                                          rooms: spaceRoomListProxy.spaceRoomsPublisher.value,
                                                          selectedSpaceRoomID: selectedSpaceRoomPublisher.value),
-                   mediaProvider: mediaProvider)
+                   mediaProvider: userSession.mediaProvider)
        
        spaceRoomListProxy.spaceRoomsPublisher
            .receive(on: DispatchQueue.main)
@@ -67,16 +69,20 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
        case .spaceAction(.select(let spaceRoomProxy)):
            if spaceRoomProxy.isSpace {
                Task { await selectSpace(spaceRoomProxy) }
-            } else if spaceRoomProxy.state == .joined {
-                // This probably doesn't need the state condition as the room flow will show a join screen,
-                // but we can allow this later, once we've updated the design to indicate the parent space.
+            } else {
+                // No need to check the join state, the room flow will show an appropriately configured join screen if needed.
                actionsSubject.send(.selectRoom(roomID: spaceRoomProxy.id))
            }
-        case .spaceAction(.join(let spaceID)):
-            #warning("Implement joining.")
+        case .spaceAction(.join(let spaceRoomProxy)):
+            Task { await join(spaceRoomProxy) }
        }
    }
    
+    func stop() {
+        // If we pop this screen with running join operations, we don't want them to do anything.
+        state.joiningRoomIDs.removeAll()
+    }
+    
    // MARK: - Private
    
    private func selectSpace(_ spaceRoomProxy: SpaceRoomProxyProtocol) async {
@@ -89,6 +95,25 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
        }
    }
    
+    private func join(_ spaceRoomProxy: SpaceRoomProxyProtocol) async {
+        state.joiningRoomIDs.insert(spaceRoomProxy.id)
+        defer { state.joiningRoomIDs.remove(spaceRoomProxy.id) }
+        
+        guard case .success = await clientProxy.joinRoom(spaceRoomProxy.id, via: []) else {
+            showFailureIndicator()
+            return
+        }
+        
+        // If multiple join operations are running, then only show the last one.
+        guard state.joiningRoomIDs == [spaceRoomProxy.id] else { return }
+        
+        if spaceRoomProxy.isSpace {
+            await selectSpace(spaceRoomProxy)
+        } else {
+            actionsSubject.send(.selectRoom(roomID: spaceRoomProxy.id))
+        }
+    }
+    
    // MARK: - Indicators
    
    private static var failureIndicatorID: String { "\(Self.self)-Failure" }
@@ -11,4 +11,6 @@ import Combine
 protocol SpaceScreenViewModelProtocol {
    var actionsPublisher: AnyPublisher<SpaceScreenViewModelAction, Never> { get }
    var context: SpaceScreenViewModelType.Context { get }
+    
+    func stop()
 }
@@ -30,6 +30,7 @@ struct SpaceScreen: View {
        ForEach(context.viewState.rooms, id: \.id) { spaceRoomProxy in
            SpaceRoomCell(spaceRoomProxy: spaceRoomProxy,
                          isSelected: spaceRoomProxy.id == context.viewState.selectedSpaceRoomID,
+                          isJoining: context.viewState.joiningRoomIDs.contains(spaceRoomProxy.id),
                          mediaProvider: context.mediaProvider) { action in
                context.send(viewAction: .spaceAction(action))
            }
@@ -78,7 +79,7 @@ struct SpaceScreen_Previews: PreviewProvider, TestablePreview {
        let viewModel = SpaceScreenViewModel(spaceRoomListProxy: spaceRoomListProxy,
                                             spaceServiceProxy: SpaceServiceProxyMock(.init()),
                                             selectedSpaceRoomPublisher: .init(nil),
-                                             mediaProvider: MediaProviderMock(configuration: .init()),
+                                             userSession: UserSessionMock(.init()),
                                             userIndicatorController: UserIndicatorControllerMock())
        return viewModel
    }
@@ -542,6 +542,17 @@ class ClientProxy: ClientProxyProtocol {
        }
    }
    
+    func canJoinRoom(with rules: [AllowRule]) -> Bool {
+        for rule in rules {
+            if case let .roomMembership(roomID) = rule,
+               let room = try? client.getRoom(roomId: roomID),
+               room.membership() == .joined {
+                return true
+            }
+        }
+        return false
+    }
+    
    func uploadMedia(_ media: MediaInfo) async -> Result<String, ClientProxyError> {
        guard let mimeType = media.mimeType else {
            MXLog.error("Failed uploading media, invalid mime type: \(media)")
@@ -165,6 +165,8 @@ protocol ClientProxyProtocol: AnyObject {
    
    func knockRoomAlias(_ roomAlias: String, message: String?) async -> Result<Void, ClientProxyError>
    
+    func canJoinRoom(with rules: [AllowRule]) -> Bool
+    
    func uploadMedia(_ media: MediaInfo) async -> Result<String, ClientProxyError>
    
    func roomForIdentifier(_ identifier: String) async -> RoomProxyType?
@@ -574,7 +574,8 @@ class MockScreen: Identifiable {
            let clientProxy = ClientProxyMock(.init(userID: "@mock:client.com",
                                                    deviceID: "MOCKCLIENT",
                                                    roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded(.mockRooms))),
-                                                    joinedSpaceRooms: .mockSingleRoom))
+                                                    joinedSpaceRooms: .mockSingleRoom,
+                                                    roomPreviews: [SpaceRoomProxyProtocol].mockSpaceList.map(RoomPreviewProxyMock.init)))
            
            // The tab bar remains hidden for the non-spaces tests as we don't supply any mock spaces.
            let spaceServiceProxy = SpaceServiceProxyMock(id == .userSessionSpacesFlow ? .populated : .init())