Refactor the JoinRoom screen to take advantage of newer APIs and support more joinRule/membership combinations (i.e. invite required, restricted, banned) (#3685)

- expose the full RoomPreview and RoomMembershipDetails through their own proxies - implement standard mocks for all the different combinations - converge on a single room info provider - rebuild all the previews - prioritise the preview data over the room one.
2026-11-02 12:07:55 +00:00 · 2025-01-20 19:07:11 +02:00
parent f20847f62b
commit 8577f53613
48 changed files with 504 additions and 248 deletions
@@ -12,13 +12,16 @@ enum JoinRoomScreenViewModelAction {
    case dismiss
 }

-enum JoinRoomScreenInteractionMode {
+enum JoinRoomScreenMode: Equatable {
    case loading
    case unknown
+    case joinable
+    case restricted
+    case inviteRequired
    case invited
-    case join
-    case knock
+    case knockable
    case knocked
+    case banned(sender: String?, reason: String?)
 }

 struct JoinRoomScreenRoomDetails {
@@ -31,12 +34,11 @@ struct JoinRoomScreenRoomDetails {
 }

 struct JoinRoomScreenViewState: BindableState {
-    // Maybe use room summary details or similar here??
    let roomID: String
    
    var roomDetails: JoinRoomScreenRoomDetails?
    
-    var mode: JoinRoomScreenInteractionMode = .loading
+    var mode: JoinRoomScreenMode = .loading
    
    var bindings = JoinRoomScreenViewStateBindings()
    
@@ -46,10 +48,14 @@ struct JoinRoomScreenViewState: BindableState {
    
    var subtitle: String? {
        switch mode {
-        case .loading: nil
-        case .unknown: L10n.screenJoinRoomSubtitleNoPreview
-        case .invited, .join, .knock: roomDetails?.canonicalAlias
-        case .knocked: nil
+        case .loading:
+            nil
+        case .unknown:
+            L10n.screenJoinRoomSubtitleNoPreview
+        case .knocked:
+            nil
+        default:
+            roomDetails?.canonicalAlias
        }
    }
    
@@ -17,7 +17,7 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
    private let clientProxy: ClientProxyProtocol
    private let userIndicatorController: UserIndicatorControllerProtocol
    
-    private var roomPreviewDetails: RoomPreviewDetails?
+    private var roomPreview: RoomPreviewProxyProtocol?
    private var room: RoomProxyType?
    
    private let actionsSubject: PassthroughSubject<JoinRoomScreenViewModelAction, Never> = .init()
@@ -72,22 +72,21 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
    private func loadRoomDetails() async {
        showLoadingIndicator()
        
-        defer {
-            hideLoadingIndicator()
-            updateRoomDetails()
-        }
-        
        await updateRoom()
        
        switch await clientProxy.roomPreviewForIdentifier(roomID, via: via) {
-        case .success(let roomPreviewDetails):
-            self.roomPreviewDetails = roomPreviewDetails
-            updateRoomDetails()
+        case .success(let roomPreview):
+            self.roomPreview = roomPreview
+            await updateRoomDetails()
        case .failure(.roomPreviewIsPrivate):
            break // Handled by the mode, we don't need an error indicator.
        case .failure:
            userIndicatorController.submitIndicator(UserIndicator(title: L10n.errorUnknown))
        }
+        
+        hideLoadingIndicator()
+        
+        await updateRoomDetails()
    }
    
    private func updateRoom() async {
@@ -97,58 +96,77 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
        // take priority over the preview one.
        if let room = await clientProxy.roomForIdentifier(roomID) {
            self.room = room
-            updateRoomDetails()
+            await updateRoomDetails()
        }
    }
    
-    private func updateRoomDetails() {
-        var roomPreviewInfo: BaseRoomInfoProxyProtocol?
+    private func updateRoomDetails() async {
+        var roomInfo: BaseRoomInfoProxyProtocol?
        var inviter: RoomInviterDetails?
        
        switch room {
        case .joined(let joinedRoomProxy):
-            roomPreviewInfo = joinedRoomProxy.infoPublisher.value
+            roomInfo = joinedRoomProxy.infoPublisher.value
        case .invited(let invitedRoomProxy):
            inviter = invitedRoomProxy.inviter.map(RoomInviterDetails.init)
-            roomPreviewInfo = invitedRoomProxy.info
+            roomInfo = invitedRoomProxy.info
        case .knocked(let knockedRoomProxy):
-            roomPreviewInfo = knockedRoomProxy.info
+            roomInfo = knockedRoomProxy.info
        default:
            break
        }
-        
-        let name = roomPreviewInfo?.displayName ?? roomPreviewDetails?.name
-        state.roomDetails = JoinRoomScreenRoomDetails(name: name,
-                                                      topic: roomPreviewInfo?.topic ?? roomPreviewDetails?.topic,
-                                                      canonicalAlias: roomPreviewInfo?.canonicalAlias ?? roomPreviewDetails?.canonicalAlias,
-                                                      avatar: roomPreviewInfo?.avatar ?? .room(id: roomID, name: name ?? "", avatarURL: roomPreviewDetails?.avatarURL),
-                                                      memberCount: UInt(roomPreviewInfo?.activeMembersCount ?? Int(roomPreviewDetails?.memberCount ?? 0)),
+
+        let info = roomPreview?.info ?? roomInfo
+        state.roomDetails = JoinRoomScreenRoomDetails(name: info?.displayName,
+                                                      topic: info?.topic,
+                                                      canonicalAlias: info?.canonicalAlias,
+                                                      avatar: info?.avatar ?? .room(id: roomID, name: info?.displayName ?? "", avatarURL: nil),
+                                                      memberCount: UInt(info?.activeMembersCount ?? 0),
                                                      inviter: inviter)
        
-        updateMode()
+        await updateMode()
    }
    
-    private func updateMode() {
-        if case .knocked = room {
-            state.mode = .knocked
+    private func updateMode() async {
+        if roomPreview == nil, room == nil {
+            state.mode = .unknown
            return
        }
        
-        // Check invites first to show Accept/Decline buttons on public rooms.
-        if case .invited = room {
-            state.mode = .invited
-            return
-        }
-        
-        if roomPreviewDetails?.isInvited ?? false {
-            state.mode = .invited
-            return
-        }
-        
-        if roomPreviewDetails?.canKnock ?? false, appSettings.knockingEnabled {
-            state.mode = .knock
-        } else {
-            state.mode = .join
+        if let roomPreview {
+            let membershipDetails = await roomPreview.ownMembershipDetails
+            
+            switch roomPreview.info.membership {
+            case .invited:
+                state.mode = .invited
+            case .knocked:
+                state.mode = .knocked
+            case .banned:
+                state.mode = .banned(sender: membershipDetails?.senderRoomMember?.displayName ?? membershipDetails?.senderRoomMember?.userID,
+                                     reason: membershipDetails?.ownRoomMember.membershipChangeReason)
+            default:
+                switch roomPreview.info.joinRule {
+                case .private, .invite:
+                    state.mode = .inviteRequired
+                case .knock, .knockRestricted:
+                    state.mode = appSettings.knockingEnabled ? .knockable : .joinable
+                case .restricted:
+                    state.mode = .restricted
+                default:
+                    state.mode = .joinable
+                }
+            }
+        } else if let room {
+            switch room {
+            case .invited:
+                state.mode = .invited
+            case .knocked:
+                state.mode = .knocked
+            case .banned:
+                state.mode = .banned(sender: nil, reason: nil)
+            default:
+                state.mode = .joinable
+            }
        }
    }
    
@@ -27,7 +27,7 @@ struct JoinRoomScreen: View {
                mainContent
            }
        } bottomContent: {
-            buttons
+            bottomContent
        }
        .alert(item: $context.alertInfo)
        .background()
@@ -86,7 +86,7 @@ struct JoinRoomScreen: View {
                        .lineLimit(3)
                }
                
-                if context.viewState.mode == .knock {
+                if context.viewState.mode == .knockable {
                    knockMessage
                        .padding(.top, 19)
                }
@@ -148,27 +148,76 @@ struct JoinRoomScreen: View {
    }
    
    @ViewBuilder
-    var buttons: some View {
+    var bottomContent: some View {
        switch context.viewState.mode {
-        case .loading, .unknown:
+        case .loading:
            EmptyView()
-        case .knock:
+        case .joinable:
+            joinButton
+        case .unknown, .restricted: // If unknown, do our best.
+            VStack(spacing: 24) {
+                bottomNoticeMessage(L10n.screenJoinRoomJoinRestrictedMessage)
+                
+                joinButton
+            }
+        case .knockable:
            Button(L10n.screenJoinRoomKnockAction) { context.send(viewAction: .knock) }
                .buttonStyle(.compound(.super))
        case .knocked:
            Button(L10n.screenJoinRoomCancelKnockAction) { context.send(viewAction: .cancelKnock) }
                .buttonStyle(.compound(.secondary))
-        case .join:
-            Button(L10n.screenJoinRoomJoinAction) { context.send(viewAction: .join) }
-                .buttonStyle(.compound(.super))
+        case .inviteRequired:
+            bottomNoticeMessage(L10n.screenJoinRoomInviteRequiredMessage)
        case .invited:
            ViewThatFits {
                HStack(spacing: 8) { inviteButtons }
                VStack(spacing: 16) { inviteButtons }
            }
+        case .banned(let sender, let reason):
+            if let sender, let reason {
+                bottomErrorMessage(title: L10n.screenJoinRoomBanByMessage(sender),
+                                   subtitle: L10n.screenJoinRoomBanReason(reason))
+            } else {
+                bottomErrorMessage(title: L10n.screenJoinRoomBanMessage, subtitle: nil)
+            }
        }
    }
    
+    func bottomNoticeMessage(_ notice: String) -> some View {
+        Label(notice, icon: \.info)
+            .labelStyle(.custom(spacing: 12, alignment: .top))
+            .font(.compound.bodyLGSemibold)
+            .foregroundStyle(.compound.textPrimary)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding()
+            .background(.compound.bgSubtleSecondary)
+            .cornerRadius(14, corners: .allCorners)
+    }
+    
+    func bottomErrorMessage(title: String, subtitle: String?) -> some View {
+        Label {
+            VStack(alignment: .leading, spacing: 4) {
+                Text(title)
+                    .font(.compound.bodyLGSemibold)
+                    .foregroundStyle(.compound.textCriticalPrimary)
+                
+                if let subtitle {
+                    Text(subtitle)
+                        .font(.compound.bodyMD)
+                        .foregroundStyle(.compound.textSecondary)
+                }
+            }
+        } icon: {
+            CompoundIcon(\.error)
+                .foregroundStyle(.compound.iconCriticalPrimary)
+        }
+        .labelStyle(.custom(spacing: 12, alignment: .top))
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding()
+        .background(.compound.bgSubtleSecondary)
+        .cornerRadius(14, corners: .allCorners)
+    }
+    
    @ViewBuilder
    var inviteButtons: some View {
        Button(L10n.actionDecline) { context.send(viewAction: .declineInvite) }
@@ -177,6 +226,11 @@ struct JoinRoomScreen: View {
            .buttonStyle(.compound(.primary))
    }
    
+    var joinButton: some View {
+        Button(L10n.screenJoinRoomJoinAction) { context.send(viewAction: .join) }
+            .buttonStyle(.compound(.super))
+    }
+    
    @ToolbarContentBuilder
    private var toolbar: some ToolbarContent {
        if context.viewState.mode == .knocked {
@@ -193,101 +247,75 @@ struct JoinRoomScreen: View {

 struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
    static let unknownViewModel = makeViewModel(mode: .unknown)
-    static let knockViewModel = makeViewModel(mode: .knock)
-    static let joinViewModel = makeViewModel(mode: .join)
-    static let inviteViewModel = makeViewModel(mode: .invited)
+    static let joinableViewModel = makeViewModel(mode: .joinable)
+    static let restrictedViewModel = makeViewModel(mode: .restricted)
+    static let inviteRequiredViewModel = makeViewModel(mode: .inviteRequired)
+    static let invitedViewModel = makeViewModel(mode: .invited)
+    static let knockableViewModel = makeViewModel(mode: .knockable)
    static let knockedViewModel = makeViewModel(mode: .knocked)
+    static let bannedViewModel = makeViewModel(mode: .banned(sender: "Bob", reason: "Spamming"))
    
    static var previews: some View {
-        NavigationStack {
-            JoinRoomScreen(context: unknownViewModel.context)
-        }
-        .snapshotPreferences(expect: unknownViewModel.context.$viewState.map { state in
-            state.roomDetails != nil
-        })
-        .previewDisplayName("Unknown")
-        
-        NavigationStack {
-            JoinRoomScreen(context: knockViewModel.context)
-        }
-        .snapshotPreferences(expect: knockViewModel.context.$viewState.map { state in
-            state.roomDetails != nil
-        })
-        .previewDisplayName("Knock")
-        
-        NavigationStack {
-            JoinRoomScreen(context: joinViewModel.context)
-        }
-        .snapshotPreferences(expect: joinViewModel.context.$viewState.map { state in
-            state.roomDetails != nil
-        })
-        .previewDisplayName("Join")
-        
-        NavigationStack {
-            JoinRoomScreen(context: inviteViewModel.context)
-        }
-        .snapshotPreferences(expect: inviteViewModel.context.$viewState.map { state in
-            state.roomDetails != nil
-        })
-        .previewDisplayName("Invite")
-        
-        NavigationStack {
-            JoinRoomScreen(context: knockedViewModel.context)
-        }
-        .snapshotPreferences(expect: knockedViewModel.context.$viewState.map { state in
-            state.roomDetails != nil
-        })
-        .previewDisplayName("Knocked")
+        makePreview(viewModel: unknownViewModel, previewDisplayName: "Unknown")
+        makePreview(viewModel: joinableViewModel, previewDisplayName: "Joinable")
+        makePreview(viewModel: restrictedViewModel, previewDisplayName: "Restricted")
+        makePreview(viewModel: inviteRequiredViewModel, previewDisplayName: "InviteRequired")
+        makePreview(viewModel: invitedViewModel, previewDisplayName: "Invited")
+        makePreview(viewModel: knockableViewModel, previewDisplayName: "Knockable")
+        makePreview(viewModel: knockedViewModel, previewDisplayName: "Knocked")
+        makePreview(viewModel: bannedViewModel, previewDisplayName: "Banned")
    }
    
-    static func makeViewModel(mode: JoinRoomScreenInteractionMode) -> JoinRoomScreenViewModel {
+    static func makePreview(viewModel: JoinRoomScreenViewModel, previewDisplayName: String) -> some View {
+        NavigationStack {
+            JoinRoomScreen(context: viewModel.context)
+        }
+        .snapshotPreferences(expect: viewModel.context.$viewState.map { state in
+            state.roomDetails != nil
+        })
+        .previewDisplayName(previewDisplayName)
+    }
+    
+    static func makeViewModel(mode: JoinRoomScreenMode) -> JoinRoomScreenViewModel {
+        ServiceLocator.shared.settings.knockingEnabled = true
+        
        let clientProxy = ClientProxyMock(.init())
        
-        // swiftlint:disable:next large_tuple
-        let membership: (isJoined: Bool, isInvited: Bool, isPublic: Bool, canKnock: Bool) = switch mode {
-        case .loading, .unknown:
-            (false, false, false, false)
-        case .invited:
-            (false, true, false, false)
-        case .join:
-            (false, false, true, false)
-        case .knock:
-            (false, false, false, true)
-        case .knocked:
-            (false, false, false, false)
-        }
-        
-        if mode == .unknown {
+        switch mode {
+        case .unknown:
            clientProxy.roomPreviewForIdentifierViaReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
-        } else {
-            switch mode {
-            case .knocked:
-                clientProxy.roomForIdentifierClosure = { _ in
-                    .knocked(KnockedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
-                }
-            case .invited:
-                clientProxy.roomForIdentifierClosure = { _ in
-                    .invited(InvitedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
-                }
-            default:
-                break
+            clientProxy.roomForIdentifierReturnValue = nil
+        case .joinable:
+            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.joinable)
+            clientProxy.roomForIdentifierReturnValue = nil
+        case .restricted:
+            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.restricted)
+            clientProxy.roomForIdentifierReturnValue = nil
+        case .inviteRequired:
+            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.inviteRequired)
+            clientProxy.roomForIdentifierReturnValue = nil
+        case .invited:
+            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.invited())
+            clientProxy.roomForIdentifierClosure = { _ in
+                .invited(InvitedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
            }
-            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(.init(roomID: "1",
-                                                                                name: "The Three-Body Problem - 三体",
-                                                                                canonicalAlias: "#3🌞problem:matrix.org",
-                                                                                // swiftlint:disable:next line_length
-                                                                                topic: "“Science and technology were the only keys to opening the door to the future, and people approached science with the faith and sincerity of elementary school students.”",
-                                                                                avatarURL: .mockMXCAvatar,
-                                                                                memberCount: UInt(100),
-                                                                                isHistoryWorldReadable: nil,
-                                                                                isJoined: membership.isJoined,
-                                                                                isInvited: membership.isInvited,
-                                                                                isPublic: membership.isPublic,
-                                                                                canKnock: membership.canKnock))
+        case .knockable:
+            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.knockable)
+            clientProxy.roomForIdentifierReturnValue = nil
+        case .knocked:
+            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.knocked)
+            clientProxy.roomForIdentifierClosure = { _ in
+                .knocked(KnockedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
+            }
+        case .banned:
+            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.banned)
+            clientProxy.roomForIdentifierClosure = { _ in
+                .banned
+            }
+        default:
+            break
        }
        
-        ServiceLocator.shared.settings.knockingEnabled = true
-        
        return JoinRoomScreenViewModel(roomID: "1",
                                       via: [],
                                       appSettings: ServiceLocator.shared.settings,