Space filters (#4977)

* Add support for SpaceFilters on the SpaceServiceProxy level and a screen that renders them * Add aliases to a couple of space room mocks * Update translations and related snapshots * Add a feature flag for space filters * Add a new room summary provider filter that takes a list of room identifiers next to the normal state filters This will take the SpaceFilter's descendants and combine it with the normal filters to reduce the rooms shown * Add a new space filter button to the home screen and link it to the SpaceFiltersScreen and the actual RoomSummaryProvider room list filters * Bump the RustSDK to v26.01.20-2 for SpaceFilter support. * Add a cancellation button to the space filters screen * Make the filter presentation mode liquidy, move the sheet to within the home screen. * Address PR comments
2026-11-02 21:06:00 +00:00 · 2026-01-21 22:19:39 +02:00
parent 0d34a28ec2
commit b4b9f6affa
41 changed files with 808 additions and 13 deletions
@@ -67,6 +67,7 @@ final class AppSettings {
        case linkPreviewsEnabled
        case focusEventOnNotificationTap
        case linkNewDeviceEnabled
+        case spaceFiltersEnabled
        
        // Spaces
        case spaceSettingsEnabled
@@ -420,6 +421,9 @@ final class AppSettings {
    @UserPreference(key: UserDefaultsKeys.linkNewDeviceEnabled, defaultValue: false, storageType: .userDefaults(store))
    var linkNewDeviceEnabled
    
+    @UserPreference(key: UserDefaultsKeys.spaceFiltersEnabled, defaultValue: false, storageType: .userDefaults(store))
+    var spaceFiltersEnabled
+    
    @UserPreference(key: UserDefaultsKeys.developerOptionsEnabled, defaultValue: isDevelopmentBuild, storageType: .userDefaults(store))
    var developerOptionsEnabled
 }
@@ -684,7 +684,7 @@ class ChatsTabFlowCoordinator: FlowCoordinatorProtocol {
        let hostingController = UIHostingController(rootView: coordinator.toPresentable())
        hostingController.view.backgroundColor = .clear
        flowParameters.windowManager.globalSearchWindow.rootViewController = hostingController
-
+        
        flowParameters.windowManager.showGlobalSearch()
    }
    
@@ -23,7 +23,7 @@ class ChatsTabFlowCoordinatorStateMachine {
                
        /// Showing the home screen. The `roomListSelectedRoomID` represents the timeline shown on the detail panel (if any)
        case roomList(detailState: DetailState?)
-                
+                        
        /// Showing the feedback screen.
        case feedbackScreen(detailState: DetailState?)
        
@@ -52,7 +52,7 @@ class ChatsTabFlowCoordinatorStateMachine {
        
        case declineAndBlockUserScreen(detailState: DetailState?)
        
-        /// The selected room ID from the state if available.
+        /// The state of the currently selected room
        var detailState: DetailState? {
            switch self {
            case .initial, .userProfileScreen, .shareExtensionRoomList:
@@ -157,7 +157,7 @@ class ChatsTabFlowCoordinatorStateMachine {
            case (.roomList(let detailState), .deselectRoom):
                // Ignore the flow's dismissal if it has already been replaced with a space.
                return detailState == .space ? nil : .roomList(detailState: nil)
-            
+                                
            case (.roomList, .startSpaceFlow):
                return .roomList(detailState: .space)
            case (.roomList, .finishedSpaceFlow):
@@ -1606,6 +1606,12 @@ internal enum L10n {
  internal static var screenCreateRoomRoomAccessSectionKnockingOptionDescription: String { return L10n.tr("Localizable", "screen_create_room_room_access_section_knocking_option_description") }
  /// Allow ask to join
  internal static var screenCreateRoomRoomAccessSectionKnockingOptionTitle: String { return L10n.tr("Localizable", "screen_create_room_room_access_section_knocking_option_title") }
+  /// Anyone in %1$@ can join but everyone else must request access.
+  internal static func screenCreateRoomRoomAccessSectionKnockingRestrictedOptionDescription(_ p1: Any) -> String {
+    return L10n.tr("Localizable", "screen_create_room_room_access_section_knocking_restricted_option_description", String(describing: p1))
+  }
+  /// Ask to join
+  internal static var screenCreateRoomRoomAccessSectionKnockingRestrictedOptionTitle: String { return L10n.tr("Localizable", "screen_create_room_room_access_section_knocking_restricted_option_title") }
  /// Only people invited can join.
  internal static var screenCreateRoomRoomAccessSectionPrivateOptionDescription: String { return L10n.tr("Localizable", "screen_create_room_room_access_section_private_option_description") }
  /// Private
@@ -1614,6 +1620,12 @@ internal enum L10n {
  internal static var screenCreateRoomRoomAccessSectionPublicOptionDescription: String { return L10n.tr("Localizable", "screen_create_room_room_access_section_public_option_description") }
  /// Public
  internal static var screenCreateRoomRoomAccessSectionPublicOptionTitle: String { return L10n.tr("Localizable", "screen_create_room_room_access_section_public_option_title") }
+  /// Anyone in %1$@ can join.
+  internal static func screenCreateRoomRoomAccessSectionRestrictedOptionDescription(_ p1: Any) -> String {
+    return L10n.tr("Localizable", "screen_create_room_room_access_section_restricted_option_description", String(describing: p1))
+  }
+  /// Standard
+  internal static var screenCreateRoomRoomAccessSectionRestrictedOptionTitle: String { return L10n.tr("Localizable", "screen_create_room_room_access_section_restricted_option_title") }
  /// Who has access
  internal static var screenCreateRoomRoomAccessSectionTitle: String { return L10n.tr("Localizable", "screen_create_room_room_access_section_title") }
  /// You’ll need an address in order to make it visible in the public directory.
@@ -16814,6 +16814,11 @@ class SpaceServiceProxyMock: SpaceServiceProxyProtocol, @unchecked Sendable {
        set(value) { underlyingTopLevelSpacesPublisher = value }
    }
    var underlyingTopLevelSpacesPublisher: CurrentValuePublisher<[SpaceServiceRoomProtocol], Never>!
+    var spaceFilterPublisher: CurrentValuePublisher<[SpaceServiceFilter], Never> {
+        get { return underlyingSpaceFilterPublisher }
+        set(value) { underlyingSpaceFilterPublisher = value }
+    }
+    var underlyingSpaceFilterPublisher: CurrentValuePublisher<[SpaceServiceFilter], Never>!

    //MARK: - spaceRoomList

@@ -51,7 +51,7 @@ extension RoomSummaryProviderMock {
                }
                
                roomListSubject.send(rooms)
-            case let .all(filters):
+            case let .rooms(_, filters), let .all(filters):
                var rooms = initialRooms
                
                if filters.count > 1 {
@@ -60,6 +60,7 @@ extension [SpaceServiceRoomProtocol] {
                                       isSpace: true,
                                       childrenCount: 1,
                                       joinedMembersCount: 500,
+                                       canonicalAlias: "#the-foundation:matrix.org",
                                       state: .joined)),
            SpaceServiceRoomMock(.init(id: "space2",
                                       name: "The Second Foundation",
@@ -72,6 +73,7 @@ extension [SpaceServiceRoomProtocol] {
                                       isSpace: true,
                                       childrenCount: 25000,
                                       joinedMembersCount: 1_000_000_000,
+                                       canonicalAlias: "#the-galactic-empire:matrix.org",
                                       state: .joined)),
            SpaceServiceRoomMock(.init(id: "space4",
                                       name: "The Korellians",
@@ -14,6 +14,7 @@ import MatrixRustSDKMocks
 extension SpaceServiceProxyMock {
    struct Configuration {
        var topLevelSpaces: [SpaceServiceRoomProtocol] = []
+        var spaceFilters: [SpaceServiceFilter] = []
        var joinedParentSpaces: [SpaceServiceRoomProtocol] = []
        var spaceRoomLists: [String: SpaceRoomListProxyMock] = [:]
        var leaveSpaceRooms: [LeaveSpaceRoom] = []
@@ -23,6 +24,8 @@ extension SpaceServiceProxyMock {
        self.init()
        
        topLevelSpacesPublisher = .init(configuration.topLevelSpaces)
+        spaceFilterPublisher = .init(configuration.spaceFilters)
+        
        joinedParentsChildIDReturnValue = .success(configuration.joinedParentSpaces)
        spaceRoomListSpaceIDClosure = { spaceID in
            if let spaceRoomList = configuration.spaceRoomLists[spaceID] {
@@ -31,6 +34,7 @@ extension SpaceServiceProxyMock {
                .failure(.sdkError(ClientProxyMockError.generic))
            }
        }
+        
        leaveSpaceSpaceIDClosure = { spaceID in
            .success(LeaveSpaceHandleProxy(spaceID: spaceID,
                                           leaveHandle: LeaveSpaceHandleSDKMock(.init(rooms: configuration.leaveSpaceRooms))))
@@ -45,13 +49,21 @@ extension SpaceServiceProxyMock {

 extension SpaceServiceProxyMock.Configuration {
    static var populated: SpaceServiceProxyMock.Configuration {
+        let spaceFilters = [SpaceServiceRoomProtocol].mockJoinedSpaces.reduce(into: [SpaceServiceFilter]()) { partialResult, spaceRoom in
+            partialResult.append(SpaceServiceFilter(room: spaceRoom, level: 0, descendants: .init()))
+            partialResult.append(SpaceServiceFilter(room: spaceRoom, level: 1, descendants: .init()))
+        }
+                
        let spaceRoomLists = [SpaceServiceRoomProtocol].mockJoinedSpaces.map {
            ($0.id, SpaceRoomListProxyMock(.init(spaceServiceRoom: $0, initialSpaceRooms: .mockSpaceList)))
        }
+        
        let subSpaceRoomLists = [SpaceServiceRoomProtocol].mockSpaceList.map {
            ($0.id, SpaceRoomListProxyMock(.init(spaceServiceRoom: $0, initialSpaceRooms: .mockSingleRoom)))
        }
        
-        return .init(topLevelSpaces: .mockJoinedSpaces, spaceRoomLists: .init(uniqueKeysWithValues: spaceRoomLists + subSpaceRoomLists))
+        return .init(topLevelSpaces: .mockJoinedSpaces,
+                     spaceFilters: spaceFilters,
+                     spaceRoomLists: .init(uniqueKeysWithValues: spaceRoomLists + subSpaceRoomLists))
    }
 }
@@ -108,6 +108,7 @@ enum A11yIdentifiers {
        let userAvatar = "home_screen-user_avatar"
        let recoveryKeyConfirmationBannerContinue = "home_screen-recovery_key_confirmation_continue"
        let startChat = "home_screen-start_chat"
+        let spaceFilters = "home_screen-space_filters"
        
        let roomNamePrefix = "home_screen-room_name"
        func roomName(_ name: String) -> String {
@@ -141,6 +141,7 @@ enum RoomAvatarSizeOnScreen {
    case chats
    case spaces
    case spaceSettings
+    case spaceFilters
    case authorizedSpaces
    case timeline
    case leaveSpace
@@ -161,7 +162,7 @@ enum RoomAvatarSizeOnScreen {
        case .chats, .spaces, .spaceSettings:
            return 52
        case .timeline, .leaveSpace, .roomDirectorySearch,
-             .completionSuggestions, .authorizedSpaces:
+             .completionSuggestions, .authorizedSpaces, .spaceFilters:
            return 32
        case .notificationSettings:
            return 30
@@ -113,6 +113,10 @@ extension SDKListener: SpaceRoomListSpaceListener where T == SpaceRoom? {
    func onUpdate(space: SpaceRoom?) { onUpdateClosure(space) }
 }

+extension SDKListener: SpaceServiceSpaceFiltersListener where T == [SpaceFilterUpdate] {
+    func onUpdate(filterUpdates: [SpaceFilterUpdate]) { onUpdateClosure(filterUpdates) }
+}
+
 // MARK: Room

 extension SDKListener: RoomInfoListener where T == RoomInfo {
@@ -26,6 +26,8 @@ enum TestablePreviewsDictionary {
        "BugReportScreen_Previews" : BugReportScreen_Previews.self,
        "CallInviteRoomTimelineView_Previews" : CallInviteRoomTimelineView_Previews.self,
        "CallNotificationRoomTimelineView_Previews" : CallNotificationRoomTimelineView_Previews.self,
+        "ChatsSpaceFilterCell_Previews" : ChatsSpaceFilterCell_Previews.self,
+        "ChatsSpaceFiltersScreen_Previews" : ChatsSpaceFiltersScreen_Previews.self,
        "CollapsibleRoomTimelineView_Previews" : CollapsibleRoomTimelineView_Previews.self,
        "CompletionSuggestion_Previews" : CompletionSuggestion_Previews.self,
        "ComposerToolbar_Previews" : ComposerToolbar_Previews.self,
@@ -0,0 +1,32 @@
+//
+// Copyright 2025 Element Creations 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
+
+enum ChatsSpaceFiltersScreenViewModelAction {
+    case confirm(SpaceServiceFilter)
+    case cancel
+}
+
+struct ChatsSpaceFiltersScreenViewState: BindableState {
+    var filters = [SpaceServiceFilter]()
+    var bindings: ChatsSpaceFiltersScreenViewStateBindings
+}
+
+struct ChatsSpaceFiltersScreenViewStateBindings { }
+
+enum ChatsSpaceFiltersScreenViewAction: CustomStringConvertible {
+    case confirm(SpaceServiceFilter)
+    case cancel
+    
+    var description: String {
+        switch self {
+        case .confirm: "Confirm"
+        case .cancel: "Cancel"
+        }
+    }
+}
@@ -0,0 +1,50 @@
+//
+// Copyright 2025 Element Creations 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 SwiftUI
+
+typealias ChatsSpaceFiltersScreenViewModelType = StateStoreViewModelV2<ChatsSpaceFiltersScreenViewState, ChatsSpaceFiltersScreenViewAction>
+
+class ChatsSpaceFiltersScreenViewModel: ChatsSpaceFiltersScreenViewModelType, ChatsSpaceFiltersScreenViewModelProtocol, Identifiable {
+    private let spaceService: SpaceServiceProxyProtocol
+    
+    private let actionsSubject: PassthroughSubject<ChatsSpaceFiltersScreenViewModelAction, Never> = .init()
+    var actionsPublisher: AnyPublisher<ChatsSpaceFiltersScreenViewModelAction, Never> {
+        actionsSubject.eraseToAnyPublisher()
+    }
+    
+    let id = UUID()
+    
+    init(spaceService: SpaceServiceProxyProtocol,
+         mediaProvider: MediaProviderProtocol) {
+        self.spaceService = spaceService
+        
+        super.init(initialViewState: ChatsSpaceFiltersScreenViewState(bindings: .init()),
+                   mediaProvider: mediaProvider)
+        
+        state.filters = spaceService.spaceFilterPublisher.value
+        
+        spaceService.spaceFilterPublisher.sink { [weak self] filters in
+            self?.state.filters = filters
+        }
+        .store(in: &cancellables)
+    }
+    
+    // MARK: - Public
+    
+    override func process(viewAction: ChatsSpaceFiltersScreenViewAction) {
+        MXLog.info("View model: received view action: \(viewAction)")
+        
+        switch viewAction {
+        case .confirm(let filter):
+            actionsSubject.send(.confirm(filter))
+        case .cancel:
+            actionsSubject.send(.cancel)
+        }
+    }
+}
@@ -0,0 +1,14 @@
+//
+// Copyright 2025 Element Creations 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
+
+@MainActor
+protocol ChatsSpaceFiltersScreenViewModelProtocol {
+    var actionsPublisher: AnyPublisher<ChatsSpaceFiltersScreenViewModelAction, Never> { get }
+    var context: ChatsSpaceFiltersScreenViewModelType.Context { get }
+}
@@ -0,0 +1,104 @@
+//
+// Copyright 2025 Element Creations 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 Compound
+import SwiftUI
+
+struct ChatsSpaceFilterCell: View {
+    @Environment(\.dynamicTypeSize) var dynamicTypeSize
+    
+    let filter: SpaceServiceFilter
+    let mediaProvider: MediaProviderProtocol!
+        
+    private let verticalInsets = 12.0
+    private let horizontalInsets = 16.0
+    
+    let action: (SpaceServiceFilter) -> Void
+
+    var body: some View {
+        Button {
+            action(filter)
+        } label: {
+            HStack(spacing: 12.0) {
+                HStack(spacing: 8.0) {
+                    if filter.level > 0 {
+                        Spacer(minLength: 16 * CGFloat(filter.level))
+                    }
+                    
+                    HStack(spacing: 12.0) {
+                        avatar
+                        
+                        content
+                            .padding(.vertical, verticalInsets)
+                            .overlay(alignment: .bottom) {
+                                Rectangle()
+                                    .fill(Color.compound.borderDisabled)
+                                    .frame(height: 1 / UIScreen.main.scale)
+                                    .padding(.trailing, -horizontalInsets)
+                            }
+                    }
+                    .accessibilityElement(children: .combine)
+                }
+            }
+        }
+        .padding(.horizontal, horizontalInsets)
+    }
+    
+    @ViewBuilder @MainActor
+    private var avatar: some View {
+        if dynamicTypeSize < .accessibility3 {
+            RoomAvatarImage(avatar: filter.room.avatar,
+                            avatarSize: .room(on: .spaceFilters),
+                            mediaProvider: mediaProvider)
+                .dynamicTypeSize(dynamicTypeSize < .accessibility1 ? dynamicTypeSize : .accessibility1)
+                .accessibilityHidden(true)
+        }
+    }
+    
+    private var content: some View {
+        HStack(spacing: 16) {
+            VStack(alignment: .leading, spacing: 2) {
+                Text(filter.room.name)
+                    .font(.compound.bodyLG)
+                    .foregroundColor(.compound.textPrimary)
+                    .lineLimit(1)
+                
+                ZStack {
+                    // Hidden text to maintain consistent height.
+                    Text("")
+                        .hidden()
+                    
+                    if let alias = filter.room.canonicalAlias {
+                        Text(alias)
+                            .font(.compound.bodyMD)
+                            .foregroundColor(.compound.textSecondary)
+                            .lineLimit(1)
+                    }
+                }
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+        }
+    }
+}
+
+struct ChatsSpaceFilterCell_Previews: PreviewProvider, TestablePreview {
+    static let mediaProvider = MediaProviderMock(configuration: .init())
+    
+    static let spaces = [SpaceServiceRoomProtocol].mockJoinedSpaces2
+    
+    static var previews: some View {
+        VStack(spacing: 0) {
+            ForEach(spaces, id: \.id) { space in
+                ChatsSpaceFilterCell(filter: .init(room: space, level: 0, descendants: .init()),
+                                     mediaProvider: mediaProvider) { _ in }
+                ChatsSpaceFilterCell(filter: .init(room: space, level: 1, descendants: .init()),
+                                     mediaProvider: mediaProvider) { _ in }
+            }
+        }
+    }
+}
@@ -0,0 +1,56 @@
+//
+// Copyright 2025 Element Creations Ltd.
+//
+// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+// Please see LICENSE files in the repository root for full details.
+//
+
+import Compound
+import SwiftUI
+
+struct ChatsSpaceFiltersScreen: View {
+    @Bindable var context: ChatsSpaceFiltersScreenViewModel.Context
+    
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                LazyVStack(spacing: 0) {
+                    ForEach(context.viewState.filters) { filter in
+                        ChatsSpaceFilterCell(filter: filter,
+                                             mediaProvider: context.mediaProvider) { filter in
+                            context.send(viewAction: .confirm(filter))
+                        }
+                    }
+                }
+            }
+            .toolbar { toolbar }
+            .navigationTitle(L10n.screenRoomlistYourSpaces)
+            .navigationBarTitleDisplayMode(.inline)
+        }
+        .presentationDragIndicator(.visible)
+    }
+    
+    @ToolbarContentBuilder
+    private var toolbar: some ToolbarContent {
+        ToolbarItem(placement: .cancellationAction) {
+            ToolbarButton(role: .cancel) {
+                context.send(viewAction: .cancel)
+            }
+        }
+    }
+}
+
+// MARK: - Previews
+
+struct ChatsSpaceFiltersScreen_Previews: PreviewProvider, TestablePreview {
+    static let viewModel = makeViewModel()
+    
+    static var previews: some View {
+        ChatsSpaceFiltersScreen(context: viewModel.context)
+    }
+    
+    static func makeViewModel() -> ChatsSpaceFiltersScreenViewModel {
+        ChatsSpaceFiltersScreenViewModel(spaceService: SpaceServiceProxyMock(.populated),
+                                         mediaProvider: MediaProviderMock(configuration: .init()))
+    }
+}
@@ -43,6 +43,7 @@ enum HomeScreenViewAction {
    case dismissNewSoundBanner
    case updateVisibleItemRange(Range<Int>)
    case globalSearch
+    case spaceFilters
    case markRoomAsUnread(roomIdentifier: String)
    case markRoomAsRead(roomIdentifier: String)
    case markRoomAsFavourite(roomIdentifier: String, isFavourite: Bool)
@@ -109,6 +110,10 @@ struct HomeScreenViewState: BindableState {
    
    var reportRoomEnabled = false
    
+    var spaceFiltersEnabled = false
+    
+    var selectedSpaceFilter: SpaceServiceFilter?
+    
    var visibleRooms: [HomeScreenRoom] {
        if roomListMode == .skeletons {
            return placeholderRooms
@@ -150,6 +155,8 @@ struct HomeScreenViewStateBindings {
    
    var alertInfo: AlertInfo<UUID>?
    var leaveRoomAlertItem: LeaveRoomAlertItem?
+    
+    var spaceFiltersViewModel: ChatsSpaceFiltersScreenViewModel?
 }

 struct HomeScreenRoom: Identifiable, Equatable {
@@ -15,6 +15,7 @@ typealias HomeScreenViewModelType = StateStoreViewModel<HomeScreenViewState, Hom

 class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol {
    private let userSession: UserSessionProtocol
+    private let spaceFilterSubject: CurrentValueSubject<SpaceServiceFilter?, Never>
    private let analyticsService: AnalyticsService
    private let appSettings: AppSettings
    private let notificationManager: NotificationManagerProtocol
@@ -39,9 +40,12 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
        self.notificationManager = notificationManager
        self.userIndicatorController = userIndicatorController
        
+        spaceFilterSubject = CurrentValueSubject<SpaceServiceFilter?, Never>(nil)
+        
        roomSummaryProvider = userSession.clientProxy.roomSummaryProvider
        
        super.init(initialViewState: .init(userID: userSession.clientProxy.userID,
+                                           spaceFiltersEnabled: appSettings.spaceFiltersEnabled,
                                           bindings: .init(filtersState: .init(appSettings: appSettings))),
                   mediaProvider: userSession.mediaProvider)
        
@@ -112,12 +116,22 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
            }
            .store(in: &cancellables)
        
+        appSettings.$spaceFiltersEnabled
+            .receive(on: DispatchQueue.main)
+            .weakAssign(to: \.state.spaceFiltersEnabled, on: self)
+            .store(in: &cancellables)
+        
        userSession.clientProxy.hideInviteAvatarsPublisher
            .removeDuplicates()
            .receive(on: DispatchQueue.main)
            .weakAssign(to: \.state.hideInviteAvatars, on: self)
            .store(in: &cancellables)
        
+        spaceFilterSubject
+            .receive(on: DispatchQueue.main)
+            .weakAssign(to: \.state.selectedSpaceFilter, on: self)
+            .store(in: &cancellables)
+        
        Task {
            state.reportRoomEnabled = await userSession.clientProxy.isReportRoomSupported
        }
@@ -126,9 +140,9 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
        let searchQuery = context.$viewState.map(\.bindings.searchQuery)
        let activeFilters = context.$viewState.map(\.bindings.filtersState.activeFilters)
        isSearchFieldFocused
-            .combineLatest(searchQuery, activeFilters)
+            .combineLatest(searchQuery, activeFilters, spaceFilterSubject)
            .removeDuplicates { $0 == $1 }
-            .sink { [weak self] isSearchFieldFocused, _, _ in
+            .sink { [weak self] isSearchFieldFocused, _, _, _ in
                guard let self else { return }
                // isSearchFieldFocused` is sometimes turning to true after cancelling the search. So to be extra sure we are updating the values correctly we read them directly in the next run loop, and we add a small delay if the value has changed
                let delay = isSearchFieldFocused == self.context.viewState.bindings.isSearchFieldFocused ? 0.0 : 0.05
@@ -175,6 +189,26 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
            actionsSubject.send(.presentStartChatScreen)
        case .globalSearch:
            actionsSubject.send(.presentGlobalSearch)
+        case .spaceFilters:
+            if spaceFilterSubject.value != nil {
+                spaceFilterSubject.send(nil)
+            } else {
+                state.bindings.spaceFiltersViewModel = ChatsSpaceFiltersScreenViewModel(spaceService: userSession.clientProxy.spaceService,
+                                                                                        mediaProvider: userSession.mediaProvider)
+                
+                state.bindings.spaceFiltersViewModel?.actionsPublisher.sink { [weak self] action in
+                    guard let self else { return }
+                    
+                    switch action {
+                    case .confirm(let spaceServiceFilter):
+                        spaceFilterSubject.send(spaceServiceFilter)
+                        state.bindings.spaceFiltersViewModel = nil
+                    case .cancel:
+                        state.bindings.spaceFiltersViewModel = nil
+                    }
+                }
+                .store(in: &cancellables)
+            }
        case .markRoomAsUnread(let roomIdentifier):
            Task {
                guard case let .joined(roomProxy) = await userSession.clientProxy.roomForIdentifier(roomIdentifier) else {
@@ -242,7 +276,12 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
            if state.bindings.isSearchFieldFocused {
                roomSummaryProvider?.setFilter(.search(query: state.bindings.searchQuery))
            } else {
-                roomSummaryProvider?.setFilter(.all(filters: state.bindings.filtersState.activeFilters.set))
+                if let spaceFilter = spaceFilterSubject.value {
+                    roomSummaryProvider?.setFilter(.rooms(roomsIDs: spaceFilter.descendants,
+                                                          filters: state.bindings.filtersState.activeFilters.set))
+                } else {
+                    roomSummaryProvider?.setFilter(.all(filters: state.bindings.filtersState.activeFilters.set))
+                }
            }
        }
    }
@@ -16,21 +16,39 @@ struct HomeScreen: View {
    
    @State private var scrollViewAdapter = ScrollViewAdapter()
    
+    @Namespace private var navigationTransitionNamespace
+    private enum NavigationTransitionSourceID {
+        case spaceFilters
+    }
+    
    var body: some View {
        HomeScreenContent(context: context, scrollViewAdapter: scrollViewAdapter)
            .alert(item: $context.alertInfo)
            .alert(item: $context.leaveRoomAlertItem,
                   actions: leaveRoomAlertActions,
                   message: leaveRoomAlertMessage)
-            .navigationTitle(L10n.screenRoomlistMainSpaceTitle)
+            .navigationTitle(title)
            .toolbar { toolbar }
            .background(Color.compound.bgCanvasDefault.ignoresSafeArea())
            .track(screen: .Home)
            .toolbarBloom(hasSearchBar: true)
            .sentryTrace("\(Self.self)")
+            .sheet(item: $context.spaceFiltersViewModel) { vm in
+                ChatsSpaceFiltersScreen(context: vm.context)
+                    .navigationTransition(.zoom(sourceID: NavigationTransitionSourceID.spaceFilters,
+                                                in: navigationTransitionNamespace))
+            }
    }
    
    // MARK: - Private
+    
+    private var title: String {
+        if let selectedSpace = context.viewState.selectedSpaceFilter {
+            selectedSpace.room.name
+        } else {
+            L10n.screenRoomlistMainSpaceTitle
+        }
+    }
        
    @ToolbarContentBuilder
    private var toolbar: some ToolbarContent {
@@ -47,6 +65,20 @@ struct HomeScreen: View {
                    .buttonStyle(.compound(.super, size: .toolbarIcon))
            }
        }
+        
+        if context.viewState.spaceFiltersEnabled {
+            if #available(iOS 26, *) {
+                ToolbarSpacer(.fixed, placement: .primaryAction)
+            }
+               
+            ToolbarItem(placement: .primaryAction) {
+                SpaceFiltersButton(selected: context.viewState.selectedSpaceFilter != nil) {
+                    context.send(viewAction: .spaceFilters)
+                }
+                .matchedTransitionSource(id: NavigationTransitionSourceID.spaceFilters,
+                                         in: navigationTransitionNamespace)
+            }
+        }
    }
    
    private var settingsButton: some View {
@@ -93,6 +125,42 @@ struct HomeScreen: View {
    private func leaveRoomAlertMessage(_ item: LeaveRoomAlertItem) -> some View {
        Text(item.subtitle)
    }
+    
+    private struct SpaceFiltersButton: View {
+        var selected = false
+        var action: () -> Void
+        
+        var body: some View {
+            if #available(iOS 26, *) {
+                if selected {
+                    content
+                        .backportButtonStyleGlassProminent()
+                        .tint(.compound.bgAccentRest)
+                } else {
+                    content
+                }
+            } else {
+                if selected {
+                    content
+                        .buttonStyle(.compound(.primary, size: .toolbarIcon))
+                } else {
+                    content
+                        .buttonStyle(.compound(.tertiary, size: .toolbarIcon))
+                }
+            }
+        }
+        
+        private var content: some View {
+            Button {
+                action()
+            } label: {
+                CompoundIcon(\.filter)
+            }
+            .accessibilityLabel(L10n.screenRoomlistYourSpaces)
+            .accessibilityAddTraits(selected ? .isSelected : [])
+            .accessibilityIdentifier(A11yIdentifiers.homeScreen.spaceFilters)
+        }
+    }
 }

 // MARK: - Previews
@@ -70,6 +70,7 @@ protocol DeveloperOptionsProtocol: AnyObject {
    
    var spaceSettingsEnabled: Bool { get set }
    var createSpaceEnabled: Bool { get set }
+    var spaceFiltersEnabled: Bool { get set }
 }

 extension AppSettings: DeveloperOptionsProtocol { }
@@ -52,6 +52,10 @@ struct DeveloperOptionsScreen: View {
            }
            
            Section("Spaces") {
+                Toggle(isOn: $context.spaceFiltersEnabled) {
+                    Text("Space filters")
+                }
+                
                Toggle(isOn: $context.spaceSettingsEnabled) {
                    Text("Space settings")
                }
@@ -133,6 +133,18 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
                [.normalizedMatchRoomName(pattern: query)] + baseFilter
            }
            _ = listUpdatesSubscriptionResult?.controller().setFilter(kind: .all(filters: filters))
+        case .rooms(let roomIDs, let filters):
+            var rustFilters = filters.map(\.rustFilter) + baseFilter
+            
+            if !roomIDs.isEmpty {
+                rustFilters.append(.identifiers(identifiers: Array(roomIDs)))
+            }
+            
+            if !filters.contains(.lowPriority), appSettings.lowPriorityFilterEnabled {
+                rustFilters.append(.nonLowPriority)
+            }
+            
+            _ = listUpdatesSubscriptionResult?.controller().setFilter(kind: .all(filters: rustFilters))
        case let .all(filters):
            var rustFilters = filters.map(\.rustFilter) + baseFilter
            
@@ -40,6 +40,8 @@ enum RoomSummaryProviderFilter: Equatable {
    case search(query: String)
    /// Includes only what satisfies the filters used
    case all(filters: Set<RoomListFilter>)
+    /// Include only rooms from the given that satisfy the given filters
+    case rooms(roomsIDs: Set<String>, filters: Set<RoomListFilter>)
 }

 // sourcery: AutoMockable
@@ -19,6 +19,12 @@ class SpaceServiceProxy: SpaceServiceProxyProtocol {
        spacesSubject.asCurrentValuePublisher()
    }
    
+    private var spaceFilterHandle: TaskHandle?
+    private let spaceFilterSubject = CurrentValueSubject<[SpaceServiceFilter], Never>([])
+    var spaceFilterPublisher: CurrentValuePublisher<[SpaceServiceFilter], Never> {
+        spaceFilterSubject.asCurrentValuePublisher()
+    }
+    
    init(spaceService: SpaceServiceProtocol) {
        self.spaceService = spaceService
        
@@ -27,7 +33,11 @@ class SpaceServiceProxy: SpaceServiceProxyProtocol {
    
    private func setupSubscriptions() async {
        topLevelSpacesHandle = await spaceService.subscribeToTopLevelJoinedSpaces(listener: SDKListener { [weak self] updates in
-            self?.handleUpdates(updates)
+            self?.handleSpaceListUpdates(updates)
+        })
+        
+        spaceFilterHandle = await spaceService.subscribeToSpaceFilters(listener: SDKListener { [weak self] updates in
+            self?.handleSpaceFilterUpdates(updates)
        })
    }
    
@@ -87,7 +97,7 @@ class SpaceServiceProxy: SpaceServiceProxyProtocol {
    
    // MARK: - Private
    
-    private func handleUpdates(_ updates: [SpaceListUpdate]) {
+    private func handleSpaceListUpdates(_ updates: [SpaceListUpdate]) {
        var spaces = spacesSubject.value
        
        for update in updates {
@@ -119,4 +129,37 @@ class SpaceServiceProxy: SpaceServiceProxyProtocol {
        
        spacesSubject.send(spaces)
    }
+    
+    private func handleSpaceFilterUpdates(_ updates: [SpaceFilterUpdate]) {
+        var filters = spaceFilterSubject.value
+        
+        for update in updates {
+            switch update {
+            case .append(let spaceFilters):
+                filters.append(contentsOf: spaceFilters.map(SpaceServiceFilter.init))
+            case .clear:
+                filters.removeAll()
+            case .pushFront(let filter):
+                filters.insert(SpaceServiceFilter(filter: filter), at: 0)
+            case .pushBack(let filter):
+                filters.append(SpaceServiceFilter(filter: filter))
+            case .popFront:
+                filters.removeFirst()
+            case .popBack:
+                filters.removeLast()
+            case .insert(let index, let filter):
+                filters.insert(SpaceServiceFilter(filter: filter), at: Int(index))
+            case .set(let index, let filter):
+                filters[Int(index)] = SpaceServiceFilter(filter: filter)
+            case .remove(let index):
+                filters.remove(at: Int(index))
+            case .truncate(let length):
+                filters.removeSubrange(Int(length)..<filters.count)
+            case .reset(let spaceFilters):
+                filters = spaceFilters.map(SpaceServiceFilter.init)
+            }
+        }
+        
+        spaceFilterSubject.send(filters)
+    }
 }
@@ -7,15 +7,44 @@
 //

 import Foundation
+import MatrixRustSDK

 enum SpaceServiceProxyError: Error {
    case sdkError(Error)
    case missingSpace
 }

+struct SpaceServiceFilter: Identifiable, Equatable {
+    let room: SpaceServiceRoomProtocol
+    let level: UInt
+    let descendants: Set<String>
+    
+    init(room: SpaceServiceRoomProtocol, level: UInt, descendants: Set<String>) {
+        self.room = room
+        self.level = level
+        self.descendants = descendants
+    }
+    
+    init(filter: SpaceFilter) {
+        room = SpaceServiceRoom(spaceRoom: filter.spaceRoom)
+        level = UInt(max(filter.level, 0))
+        descendants = Set(filter.descendants)
+    }
+    
+    // Same rooms might appear on multiple levels
+    var id: String {
+        room.id + "\(level)"
+    }
+    
+    static func == (lhs: SpaceServiceFilter, rhs: SpaceServiceFilter) -> Bool {
+        lhs.room.id == rhs.room.id
+    }
+}
+
 // sourcery: AutoMockable
 protocol SpaceServiceProxyProtocol {
    var topLevelSpacesPublisher: CurrentValuePublisher<[SpaceServiceRoomProtocol], Never> { get }
+    var spaceFilterPublisher: CurrentValuePublisher<[SpaceServiceFilter], Never> { get }
    
    func spaceRoomList(spaceID: String) async -> Result<SpaceRoomListProxyProtocol, SpaceServiceProxyError>
    /// Returns a joined space given its identifier