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 21:33:26 +00:00 · 2025-01-20 19:07:11 +02:00
parent f20847f62b
commit 8577f53613
48 changed files with 504 additions and 248 deletions
@@ -3187,13 +3187,13 @@ class ClientProxyMock: ClientProxyProtocol, @unchecked Sendable {
    var roomPreviewForIdentifierViaReceivedArguments: (identifier: String, via: [String])?
    var roomPreviewForIdentifierViaReceivedInvocations: [(identifier: String, via: [String])] = []

-    var roomPreviewForIdentifierViaUnderlyingReturnValue: Result<RoomPreviewDetails, ClientProxyError>!
-    var roomPreviewForIdentifierViaReturnValue: Result<RoomPreviewDetails, ClientProxyError>! {
+    var roomPreviewForIdentifierViaUnderlyingReturnValue: Result<RoomPreviewProxyProtocol, ClientProxyError>!
+    var roomPreviewForIdentifierViaReturnValue: Result<RoomPreviewProxyProtocol, ClientProxyError>! {
        get {
            if Thread.isMainThread {
                return roomPreviewForIdentifierViaUnderlyingReturnValue
            } else {
-                var returnValue: Result<RoomPreviewDetails, ClientProxyError>? = nil
+                var returnValue: Result<RoomPreviewProxyProtocol, ClientProxyError>? = nil
                DispatchQueue.main.sync {
                    returnValue = roomPreviewForIdentifierViaUnderlyingReturnValue
                }
@@ -3211,9 +3211,9 @@ class ClientProxyMock: ClientProxyProtocol, @unchecked Sendable {
            }
        }
    }
-    var roomPreviewForIdentifierViaClosure: ((String, [String]) async -> Result<RoomPreviewDetails, ClientProxyError>)?
+    var roomPreviewForIdentifierViaClosure: ((String, [String]) async -> Result<RoomPreviewProxyProtocol, ClientProxyError>)?

-    func roomPreviewForIdentifier(_ identifier: String, via: [String]) async -> Result<RoomPreviewDetails, ClientProxyError> {
+    func roomPreviewForIdentifier(_ identifier: String, via: [String]) async -> Result<RoomPreviewProxyProtocol, ClientProxyError> {
        roomPreviewForIdentifierViaCallsCount += 1
        roomPreviewForIdentifierViaReceivedArguments = (identifier: identifier, via: via)
        DispatchQueue.main.async {
@@ -13416,6 +13416,15 @@ class RoomMemberProxyMock: RoomMemberProxyProtocol, @unchecked Sendable {
    }
    var underlyingRole: RoomMemberRole!

+}
+class RoomMembershipDetailsProxyMock: RoomMembershipDetailsProxyProtocol, @unchecked Sendable {
+    var ownRoomMember: RoomMemberProxyProtocol {
+        get { return underlyingOwnRoomMember }
+        set(value) { underlyingOwnRoomMember = value }
+    }
+    var underlyingOwnRoomMember: RoomMemberProxyProtocol!
+    var senderRoomMember: RoomMemberProxyProtocol?
+
 }
 class RoomNotificationSettingsProxyMock: RoomNotificationSettingsProxyProtocol, @unchecked Sendable {
    var mode: RoomNotificationModeProxy {
@@ -13429,6 +13438,31 @@ class RoomNotificationSettingsProxyMock: RoomNotificationSettingsProxyProtocol,
    }
    var underlyingIsDefault: Bool!

+}
+class RoomPreviewProxyMock: RoomPreviewProxyProtocol, @unchecked Sendable {
+    var info: RoomPreviewInfoProxy {
+        get { return underlyingInfo }
+        set(value) { underlyingInfo = value }
+    }
+    var underlyingInfo: RoomPreviewInfoProxy!
+    var ownMembershipDetailsCallsCount = 0
+    var ownMembershipDetailsCalled: Bool {
+        return ownMembershipDetailsCallsCount > 0
+    }
+
+    var ownMembershipDetails: RoomMembershipDetailsProxyProtocol? {
+        get async {
+            ownMembershipDetailsCallsCount += 1
+            if let ownMembershipDetailsClosure = ownMembershipDetailsClosure {
+                return await ownMembershipDetailsClosure()
+            } else {
+                return underlyingOwnMembershipDetails
+            }
+        }
+    }
+    var underlyingOwnMembershipDetails: RoomMembershipDetailsProxyProtocol?
+    var ownMembershipDetailsClosure: (() async -> RoomMembershipDetailsProxyProtocol?)?
+
 }
 class RoomProxyMock: RoomProxyProtocol, @unchecked Sendable {
    var id: String {
@@ -0,0 +1,90 @@
+//
+// 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
+
+extension RoomPreviewProxyMock {
+    struct Configuration {
+        var roomID = "1"
+        var canonicalAlias = "#3🌞problem:matrix.org"
+        var name = "The Three-Body Problem - 三体"
+        var 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.”"
+        var avatarURL = URL.mockMXCAvatar.absoluteString
+        var numJoinedMembers = UInt64(100)
+        var numActiveMembers = UInt64(100)
+        var roomType = RoomType.room
+        var membership: Membership?
+        var joinRule: JoinRule
+    }
+    
+    static var joinable: RoomPreviewProxyMock {
+        .init(.init(membership: nil, joinRule: .public))
+    }
+    
+    static var restricted: RoomPreviewProxyMock {
+        .init(.init(membership: nil, joinRule: .restricted(rules: [])))
+    }
+    
+    static var inviteRequired: RoomPreviewProxyMock {
+        .init(.init(membership: nil, joinRule: .invite))
+    }
+    
+    static func invited(roomID: String? = nil) -> RoomPreviewProxyMock {
+        if let roomID {
+            return .init(.init(roomID: roomID, membership: .invited, joinRule: .invite))
+        }
+        
+        return .init(.init(membership: .invited, joinRule: .invite))
+    }
+    
+    static var knockable: RoomPreviewProxyMock {
+        .init(.init(membership: nil, joinRule: .knock))
+    }
+    
+    static var knockableRestricted: RoomPreviewProxyMock {
+        .init(.init(membership: nil, joinRule: .knockRestricted(rules: [])))
+    }
+    
+    static var knocked: RoomPreviewProxyMock {
+        .init(.init(membership: .knocked, joinRule: .knock))
+    }
+    
+    static var banned: RoomPreviewProxyMock {
+        .init(.init(membership: .banned, joinRule: .public))
+    }
+    
+    convenience init(_ configuration: RoomPreviewProxyMock.Configuration) {
+        self.init()
+        underlyingInfo = .init(roomPreviewInfo: .init(roomId: configuration.roomID,
+                                                      canonicalAlias: configuration.canonicalAlias,
+                                                      name: configuration.name,
+                                                      topic: configuration.topic,
+                                                      avatarUrl: configuration.avatarURL,
+                                                      numJoinedMembers: configuration.numJoinedMembers,
+                                                      numActiveMembers: configuration.numActiveMembers,
+                                                      roomType: configuration.roomType,
+                                                      isHistoryWorldReadable: nil,
+                                                      membership: configuration.membership,
+                                                      joinRule: configuration.joinRule,
+                                                      isDirect: nil,
+                                                      heroes: nil))
+        
+        let roomMembershipDetails = RoomMembershipDetailsProxyMock()
+        
+        let mockMember = RoomMemberProxyMock()
+        mockMember.userID = "@bob:matrix.org"
+        mockMember.displayName = "Billy Bob"
+        mockMember.avatarURL = .mockMXCUserAvatar
+        mockMember.membershipChangeReason = "Ain't nobody need no reason"
+        
+        roomMembershipDetails.senderRoomMember = mockMember
+        roomMembershipDetails.ownRoomMember = mockMember
+        
+        underlyingOwnMembershipDetails = roomMembershipDetails
+    }
+}
@@ -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,
@@ -516,11 +516,10 @@ class ClientProxy: ClientProxyProtocol {
        return await buildRoomForIdentifier(identifier)
    }
    
-    func roomPreviewForIdentifier(_ identifier: String, via: [String]) async -> Result<RoomPreviewDetails, ClientProxyError> {
+    func roomPreviewForIdentifier(_ identifier: String, via: [String]) async -> Result<RoomPreviewProxyProtocol, ClientProxyError> {
        do {
            let roomPreview = try await client.getRoomPreviewFromRoomId(roomId: identifier, viaServers: via)
-            let roomPreviewInfo = try roomPreview.info()
-            return .success(.init(roomPreviewInfo))
+            return try .success(RoomPreviewProxy(roomPreview: roomPreview))
        } catch let error as ClientError where error.code == .forbidden {
            return .failure(.roomPreviewIsPrivate)
        } catch {
@@ -1155,40 +1154,3 @@ private class SendQueueRoomErrorListenerProxy: SendQueueRoomErrorListener {
        onErrorClosure(roomId, error)
    }
 }
-
-private extension RoomPreviewDetails {
-    init(_ roomPreviewInfo: RoomPreviewInfo) {
-        self = RoomPreviewDetails(roomID: roomPreviewInfo.roomId,
-                                  name: roomPreviewInfo.name,
-                                  canonicalAlias: roomPreviewInfo.canonicalAlias,
-                                  topic: roomPreviewInfo.topic,
-                                  avatarURL: roomPreviewInfo.avatarUrl.flatMap(URL.init(string:)),
-                                  memberCount: UInt(roomPreviewInfo.numJoinedMembers),
-                                  isHistoryWorldReadable: roomPreviewInfo.isHistoryWorldReadable ?? false,
-                                  isJoined: roomPreviewInfo.membership == .joined,
-                                  isInvited: roomPreviewInfo.membership == .invited,
-                                  isPublic: roomPreviewInfo.isPublic,
-                                  canKnock: roomPreviewInfo.canKnock)
-    }
-}
-
-private extension RoomPreviewInfo {
-    var canKnock: Bool {
-        switch joinRule {
-        case .knock, .knockRestricted:
-            return true
-        default:
-            return false
-        }
-    }
-    
-    var isPublic: Bool {
-        switch joinRule {
-        // for restricted rooms we want to show optimistically that the we may be able to join the room
-        case .public, .restricted:
-            return true
-        default:
-            return false
-        }
-    }
-}
@@ -61,20 +61,6 @@ enum SessionVerificationState {
    case unverified
 }

-struct RoomPreviewDetails {
-    let roomID: String
-    let name: String?
-    let canonicalAlias: String?
-    let topic: String?
-    let avatarURL: URL?
-    let memberCount: UInt
-    let isHistoryWorldReadable: Bool?
-    let isJoined: Bool
-    let isInvited: Bool
-    let isPublic: Bool
-    let canKnock: Bool
-}
-
 // sourcery: AutoMockable
 protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
    var actionsPublisher: AnyPublisher<ClientProxyAction, Never> { get }
@@ -154,7 +140,7 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
    
    func roomForIdentifier(_ identifier: String) async -> RoomProxyType?
    
-    func roomPreviewForIdentifier(_ identifier: String, via: [String]) async -> Result<RoomPreviewDetails, ClientProxyError>
+    func roomPreviewForIdentifier(_ identifier: String, via: [String]) async -> Result<RoomPreviewProxyProtocol, ClientProxyError>
    
    @discardableResult func loadUserDisplayName() async -> Result<Void, ClientProxyError>
    
@@ -7,7 +7,6 @@

 import Foundation
 import MatrixRustSDK
-import UIKit

 class KnockedRoomProxy: KnockedRoomProxyProtocol {
    private let roomListItem: RoomListItemProtocol
@@ -113,6 +113,9 @@ struct RoomPreviewInfoProxy: BaseRoomInfoProxyProtocol {
    var isSpace: Bool { roomPreviewInfo.roomType == .space }
    var activeMembersCount: Int { Int(roomPreviewInfo.numActiveMembers ?? roomPreviewInfo.numJoinedMembers) }
    
+    var joinRule: JoinRule { roomPreviewInfo.joinRule }
+    var membership: Membership? { roomPreviewInfo.membership }
+    
    /// The room's avatar info for use in a ``RoomAvatarImage``.
    var avatar: RoomAvatar {
        if isDirect, avatarURL == nil {
@@ -0,0 +1,13 @@
+//
+// Copyright 2024 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
+
+struct RoomMembershipDetailsProxy: RoomMembershipDetailsProxyProtocol {
+    let ownRoomMember: RoomMemberProxyProtocol
+    let senderRoomMember: RoomMemberProxyProtocol?
+}
@@ -0,0 +1,14 @@
+//
+// Copyright 2024 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
+
+// sourcery: AutoMockable
+protocol RoomMembershipDetailsProxyProtocol {
+    var ownRoomMember: RoomMemberProxyProtocol { get }
+    var senderRoomMember: RoomMemberProxyProtocol? { get }
+}
@@ -0,0 +1,35 @@
+//
+// Copyright 2024 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 MatrixRustSDK
+
+final class RoomPreviewProxy: RoomPreviewProxyProtocol {
+    private let roomPreview: RoomPreview
+    
+    let info: RoomPreviewInfoProxy
+    
+    init(roomPreview: RoomPreview) throws {
+        self.roomPreview = roomPreview
+        info = try .init(roomPreviewInfo: roomPreview.info())
+    }
+    
+    var ownMembershipDetails: RoomMembershipDetailsProxyProtocol? {
+        get async {
+            guard let details = await roomPreview.ownMembershipDetails() else {
+                return nil
+            }
+            
+            var senderRoomMember: RoomMemberProxy?
+            if let member = details.senderRoomMember {
+                senderRoomMember = .init(member: member)
+            }
+            
+            return RoomMembershipDetailsProxy(ownRoomMember: RoomMemberProxy(member: details.ownRoomMember),
+                                              senderRoomMember: senderRoomMember)
+        }
+    }
+}
@@ -0,0 +1,14 @@
+//
+// Copyright 2024 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
+
+// sourcery: AutoMockable
+protocol RoomPreviewProxyProtocol {
+    var info: RoomPreviewInfoProxy { get }
+    var ownMembershipDetails: RoomMembershipDetailsProxyProtocol? { get async }
+}