Display the list of rooms with user-defined notification settings (#1535)

2026-11-02 21:33:26 +00:00 · 2023-08-22 14:33:39 +02:00
parent db1903ec05
commit b1ea23c925
34 changed files with 760 additions and 129 deletions
@@ -18,7 +18,9 @@ import Combine
 import SwiftUI

 struct NotificationSettingsEditScreenCoordinatorParameters {
-    let isDirect: Bool
+    weak var navigationStackCoordinator: NavigationStackCoordinator?
+    let chatType: NotificationSettingsChatType
+    let userSession: UserSessionProtocol
    let notificationSettings: NotificationSettingsProxyProtocol
 }

@@ -37,15 +39,38 @@ final class NotificationSettingsEditScreenCoordinator: CoordinatorProtocol {
    init(parameters: NotificationSettingsEditScreenCoordinatorParameters) {
        self.parameters = parameters
        
-        viewModel = NotificationSettingsEditScreenViewModel(isDirect: parameters.isDirect,
+        viewModel = NotificationSettingsEditScreenViewModel(chatType: parameters.chatType,
+                                                            userSession: parameters.userSession,
                                                            notificationSettingsProxy: parameters.notificationSettings)
    }
    
    func start() {
        viewModel.fetchInitialContent()
+        
+        viewModel.actions.sink { [weak self] action in
+            guard let self else { return }
+            switch action {
+            case .requestRoomNotificationSettingsPresentation(let roomID):
+                Task { await self.presentRoomNotificationSettings(roomID: roomID) }
+            }
+        }
+        .store(in: &cancellables)
    }
        
    func toPresentable() -> AnyView {
        AnyView(NotificationSettingsEditScreen(context: viewModel.context))
    }
+    
+    // MARK: - Private
+    
+    private func presentRoomNotificationSettings(roomID: String) async {
+        guard let roomProxy = await parameters.userSession.clientProxy.roomForIdentifier(roomID) else { return }
+         
+        let roomNotificationSettingsParameters = RoomNotificationSettingsScreenCoordinatorParameters(navigationStackCoordinator: parameters.navigationStackCoordinator,
+                                                                                                     notificationSettingsProxy: parameters.notificationSettings,
+                                                                                                     roomProxy: roomProxy,
+                                                                                                     displayAsUserDefinedRoomSettings: true)
+        let roomNotificationSettingsCoordinator = RoomNotificationSettingsScreenCoordinator(parameters: roomNotificationSettingsParameters)
+        parameters.navigationStackCoordinator?.push(roomNotificationSettingsCoordinator)
+    }
 }
@@ -16,7 +16,9 @@

 import Foundation

-enum NotificationSettingsEditScreenViewModelAction { }
+enum NotificationSettingsEditScreenViewModelAction {
+    case requestRoomNotificationSettingsPresentation(roomID: String)
+}

 enum NotificationSettingsEditScreenDefaultMode {
    case allMessages
@@ -26,22 +28,29 @@ enum NotificationSettingsEditScreenDefaultMode {
 struct NotificationSettingsEditScreenViewState: BindableState {
    var bindings: NotificationSettingsEditScreenViewStateBindings
    var strings: NotificationSettingsEditScreenStrings
-    var isDirect: Bool
+    var chatType: NotificationSettingsChatType
    var availableDefaultModes: [NotificationSettingsEditScreenDefaultMode] = [.allMessages, .mentionsAndKeywordsOnly]
    var defaultMode: NotificationSettingsEditScreenDefaultMode?
    var pendingMode: NotificationSettingsEditScreenDefaultMode?
+    var roomsWithUserDefinedMode: [NotificationSettingsEditScreenRoom] = []

    func isSelected(mode: NotificationSettingsEditScreenDefaultMode) -> Bool {
        pendingMode == nil && defaultMode == mode
    }
+    
+    var displayRoomsWithCustomSettings: Bool {
+        !roomsWithUserDefinedMode.isEmpty
+    }
 }

 struct NotificationSettingsEditScreenViewStateBindings {
+    var searchQuery = ""
    var alertInfo: AlertInfo<NotificationSettingsEditScreenErrorType>?
 }

 enum NotificationSettingsEditScreenViewAction {
    case setMode(NotificationSettingsEditScreenDefaultMode)
+    case selectRoom(roomIdentifier: String)
 }

 enum NotificationSettingsEditScreenErrorType: Hashable {
@@ -52,22 +61,60 @@ struct NotificationSettingsEditScreenStrings {
    let navigationTitle: String
    let modeSectionTitle: String
    
-    init(isDirect: Bool) {
-        if isDirect {
+    init(chatType: NotificationSettingsChatType) {
+        switch chatType {
+        case .oneToOneChat:
            navigationTitle = L10n.screenNotificationSettingsDirectChats
            modeSectionTitle = L10n.screenNotificationSettingsEditScreenDirectSectionHeader
-        } else {
+        case .groupChat:
            navigationTitle = L10n.screenNotificationSettingsGroupChats
            modeSectionTitle = L10n.screenNotificationSettingsEditScreenGroupSectionHeader
        }
    }
    
    func string(for mode: NotificationSettingsEditScreenDefaultMode) -> String {
+        switch mode {
+        case .allMessages:
+            return L10n.screenNotificationSettingsEditModeAllMessages
+        case .mentionsAndKeywordsOnly:
+            return L10n.screenNotificationSettingsEditModeMentionsAndKeywords
+        }
+    }
+    
+    func string(for mode: RoomNotificationModeProxy) -> String {
        switch mode {
        case .allMessages:
            return L10n.screenNotificationSettingsModeAll
        case .mentionsAndKeywordsOnly:
            return L10n.screenNotificationSettingsModeMentions
+        case .mute:
+            return L10n.commonMute
        }
    }
 }
+
+struct NotificationSettingsEditScreenRoom: Identifiable, Equatable {
+    static let placeholderLastMessage = AttributedString("Hidden last message")
+    
+    /// The list item identifier can be a real room identifier, a custom one for invalidated entries
+    /// or a completely unique one for empty items and skeletons
+    let id: String
+    
+    /// The real room identifier this item points to
+    let roomId: String?
+    
+    var name = ""
+        
+    var avatarURL: URL?
+    
+    var notificationMode: RoomNotificationModeProxy?
+    
+    var isPlaceholder = false
+    
+    static func placeholder() -> NotificationSettingsEditScreenRoom {
+        NotificationSettingsEditScreenRoom(id: UUID().uuidString,
+                                           roomId: nil,
+                                           name: "Placeholder room name",
+                                           isPlaceholder: true)
+    }
+}
@@ -21,27 +21,37 @@ typealias NotificationSettingsEditScreenViewModelType = StateStoreViewModel<Noti

 class NotificationSettingsEditScreenViewModel: NotificationSettingsEditScreenViewModelType, NotificationSettingsEditScreenViewModelProtocol {
    private var actionsSubject: PassthroughSubject<NotificationSettingsEditScreenViewModelAction, Never> = .init()
-    private let isDirect: Bool
+    private let chatType: NotificationSettingsChatType
    private let notificationSettingsProxy: NotificationSettingsProxyProtocol
-    @CancellableTask private var fetchSettingsTask: Task<Void, Error>?
+    private let userSession: UserSessionProtocol
+    private let roomSummaryProvider: RoomSummaryProviderProtocol?
+    
+    @CancellableTask private var fetchDefaultRoomNotificationModesTask: Task<Void, Error>?
+    @CancellableTask private var updateRoomsWithUserDefinedModeTask: Task<Void, Error>?
    
    var actions: AnyPublisher<NotificationSettingsEditScreenViewModelAction, Never> {
        actionsSubject.eraseToAnyPublisher()
    }
-
-    init(isDirect: Bool, notificationSettingsProxy: NotificationSettingsProxyProtocol) {
+    
+    init(chatType: NotificationSettingsChatType, userSession: UserSessionProtocol, notificationSettingsProxy: NotificationSettingsProxyProtocol) {
        let bindings = NotificationSettingsEditScreenViewStateBindings()
-        self.isDirect = isDirect
+        self.chatType = chatType
+        self.userSession = userSession
        self.notificationSettingsProxy = notificationSettingsProxy
+        roomSummaryProvider = userSession.clientProxy.roomSummaryProvider
+        
        super.init(initialViewState: NotificationSettingsEditScreenViewState(bindings: bindings,
-                                                                             strings: NotificationSettingsEditScreenStrings(isDirect: isDirect),
-                                                                             isDirect: isDirect))
+                                                                             strings: NotificationSettingsEditScreenStrings(chatType: chatType),
+                                                                             chatType: chatType),
+                   imageProvider: userSession.mediaProvider)
        
        setupNotificationSettingsSubscription()
+        setupRoomSummaryProviderSubscription()
    }
    
    func fetchInitialContent() {
-        fetchSettings()
+        fetchDefaultRoomNotificationModes()
+        updateRoomsWithUserDefinedMode()
    }
    
    // MARK: - Public
@@ -50,6 +60,8 @@ class NotificationSettingsEditScreenViewModel: NotificationSettingsEditScreenVie
        switch viewAction {
        case .setMode(let mode):
            setMode(mode)
+        case .selectRoom(let roomIdentifier):
+            actionsSubject.send(.requestRoomNotificationSettingsPresentation(roomID: roomIdentifier))
        }
    }
    
@@ -63,17 +75,19 @@ class NotificationSettingsEditScreenViewModel: NotificationSettingsEditScreenVie
                
                switch callback {
                case .settingsDidChange:
-                    self.fetchSettings()
+                    self.fetchDefaultRoomNotificationModes()
+                    self.updateRoomsWithUserDefinedMode()
                }
            }
            .store(in: &cancellables)
    }
    
-    private func fetchSettings() {
-        fetchSettingsTask = Task {
+    private func fetchDefaultRoomNotificationModes() {
+        fetchDefaultRoomNotificationModesTask = Task {
            var mode: RoomNotificationModeProxy?
-            let encrypted_mode = await notificationSettingsProxy.getDefaultRoomNotificationMode(isEncrypted: true, isOneToOne: isDirect)
-            let unencrypted_mode = await notificationSettingsProxy.getDefaultRoomNotificationMode(isEncrypted: false, isOneToOne: isDirect)
+            let isOneToOne = chatType == .oneToOneChat
+            let encrypted_mode = await notificationSettingsProxy.getDefaultRoomNotificationMode(isEncrypted: true, isOneToOne: isOneToOne)
+            let unencrypted_mode = await notificationSettingsProxy.getDefaultRoomNotificationMode(isEncrypted: false, isOneToOne: isOneToOne)
            if encrypted_mode == unencrypted_mode {
                mode = encrypted_mode
            }
@@ -90,6 +104,71 @@ class NotificationSettingsEditScreenViewModel: NotificationSettingsEditScreenVie
        }
    }
    
+    private func setupRoomSummaryProviderSubscription() {
+        guard let roomSummaryProvider else {
+            MXLog.error("Room summary provider unavailable")
+            return
+        }
+        
+        roomSummaryProvider.roomListPublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] _ in
+                self?.updateRoomsWithUserDefinedMode()
+            }
+            .store(in: &cancellables)
+    }
+    
+    private func updateRoomsWithUserDefinedMode() {
+        guard let roomSummaryProvider else {
+            MXLog.error("Room summary provider unavailable")
+            return
+        }
+        
+        updateRoomsWithUserDefinedModeTask = Task {
+            let roomsWithUserDefinedRules = try await notificationSettingsProxy.getRoomsWithUserDefinedRules()
+            guard !Task.isCancelled else { return }
+            
+            let filteredRoomsSummary = roomSummaryProvider.roomListPublisher.value.filter { summary in
+                roomsWithUserDefinedRules.contains(where: { summary.id == $0 })
+            }
+            
+            var roomsWithUserDefinedMode: [NotificationSettingsEditScreenRoom] = []
+            
+            for roomSummary in filteredRoomsSummary {
+                switch roomSummary {
+                case .empty, .invalidated:
+                    break
+                case .filled(let details):
+                    guard let roomProxy = await userSession.clientProxy.roomForIdentifier(details.id) else { continue }
+                    // `isOneToOneRoom` here is not the same as `isDirect` on the room. From the point of view of the push rule, a one-to-one room is a room with exactly two active members.
+                    let isOneToOneRoom = roomProxy.activeMembersCount == 2
+                    // display only the rooms we're interested in
+                    switch chatType {
+                    case .oneToOneChat where isOneToOneRoom,
+                         .groupChat where !isOneToOneRoom:
+                        await roomsWithUserDefinedMode.append(buildRoom(with: details))
+                    default:
+                        break
+                    }
+                }
+            }
+            
+            // Sort the room list
+            roomsWithUserDefinedMode.sort(by: { $0.name.localizedCompare($1.name) == .orderedAscending })
+            
+            state.roomsWithUserDefinedMode = roomsWithUserDefinedMode
+        }
+    }
+    
+    private func buildRoom(with details: RoomSummaryDetails) async -> NotificationSettingsEditScreenRoom {
+        let notificationMode = try? await notificationSettingsProxy.getUserDefinedRoomNotificationMode(roomId: details.id)
+        return NotificationSettingsEditScreenRoom(id: details.id,
+                                                  roomId: details.id,
+                                                  name: details.name,
+                                                  avatarURL: details.avatarURL,
+                                                  notificationMode: notificationMode)
+    }
+    
    private func setMode(_ mode: NotificationSettingsEditScreenDefaultMode) {
        guard state.pendingMode == nil, !state.isSelected(mode: mode) else { return }
        let roomNotificationModeProxy: RoomNotificationModeProxy
@@ -102,9 +181,12 @@ class NotificationSettingsEditScreenViewModel: NotificationSettingsEditScreenVie
        state.pendingMode = mode
        Task {
            do {
-                try await notificationSettingsProxy.setDefaultRoomNotificationMode(isEncrypted: true, isOneToOne: isDirect, mode: roomNotificationModeProxy)
-                try await notificationSettingsProxy.setDefaultRoomNotificationMode(isEncrypted: false, isOneToOne: isDirect, mode: roomNotificationModeProxy)
+                // On modern clients, we don't have different settings for encrypted and non-encrypted rooms.
+                let isOneToOne = chatType == .oneToOneChat
+                try await notificationSettingsProxy.setDefaultRoomNotificationMode(isEncrypted: true, isOneToOne: isOneToOne, mode: roomNotificationModeProxy)
+                try await notificationSettingsProxy.setDefaultRoomNotificationMode(isEncrypted: false, isOneToOne: isOneToOne, mode: roomNotificationModeProxy)
            } catch {
+                // In case of failure, we let the user retry
                let retryAction: () -> Void = { [weak self] in
                    self?.setMode(mode)
                }
@@ -14,16 +14,22 @@
 // limitations under the License.
 //

+import Compound
 import SwiftUI

 struct NotificationSettingsEditScreen: View {
    @ObservedObject var context: NotificationSettingsEditScreenViewModel.Context
+    @State var isSearching = false
    
    var body: some View {
        Form {
            notificationModeSection
+            
+            if context.viewState.displayRoomsWithCustomSettings {
+                roomsWithCustomSettingsSection
+            }
        }
-        .compoundForm()
+        .compoundList()
        .navigationTitle(context.viewState.strings.navigationTitle)
        .alert(item: $context.alertInfo)
        .track(screen: .settingsDefaultNotifications)
@@ -34,25 +40,27 @@ struct NotificationSettingsEditScreen: View {
    private var notificationModeSection: some View {
        Section {
            ForEach(context.viewState.availableDefaultModes, id: \.self) { mode in
-                Button {
-                    context.send(viewAction: .setMode(mode))
-                } label: {
-                    LabeledContent {
-                        if context.viewState.pendingMode == mode {
-                            ProgressView()
-                        } else {
-                            EmptyView()
-                        }
-                    } label: {
-                        Text(context.viewState.strings.string(for: mode))
-                    }
-                }
-                .buttonStyle(.compoundForm(accessory: .selected(context.viewState.isSelected(mode: mode))))
-                .disabled(context.viewState.pendingMode != nil)
+                ListRow(label: .plain(title: context.viewState.strings.string(for: mode)),
+                        details: (context.viewState.pendingMode == mode) ? .isWaiting(true) : nil,
+                        kind: .selection(isSelected: context.viewState.isSelected(mode: mode)) {
+                            context.send(viewAction: .setMode(mode))
+                        })
+                        .disabled(context.viewState.pendingMode != nil)
            }
        } header: {
            Text(context.viewState.strings.modeSectionTitle)
-                .compoundFormSectionHeader()
+                .compoundListSectionHeader()
+        }
+    }
+    
+    private var roomsWithCustomSettingsSection: some View {
+        Section {
+            ForEach(context.viewState.roomsWithUserDefinedMode, id: \.id) { room in
+                NotificationSettingsEditScreenRoomCell(room: room, context: context)
+            }
+        } header: {
+            Text(L10n.screenNotificationSettingsEditCustomSettingsSectionTitle)
+                .compoundListSectionHeader()
        }
        .compoundFormSection()
    }
@@ -64,7 +72,13 @@ struct NotificationSettingsEditScreen_Previews: PreviewProvider {
    static let viewModelGroupChats: NotificationSettingsEditScreenViewModel = {
        let notificationSettingsProxy = NotificationSettingsProxyMock(with: .init())
        notificationSettingsProxy.getDefaultRoomNotificationModeIsEncryptedIsOneToOneReturnValue = .allMessages
-        var viewModel = NotificationSettingsEditScreenViewModel(isDirect: false,
+        
+        notificationSettingsProxy.getRoomsWithUserDefinedRulesReturnValue = [RoomSummary].mockRooms.compactMap(\.id)
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "@alice:example.com",
+                                                                       roomSummaryProvider: MockRoomSummaryProvider(state: .loaded(.mockRooms))),
+                                          mediaProvider: MockMediaProvider())
+        var viewModel = NotificationSettingsEditScreenViewModel(chatType: .groupChat,
+                                                                userSession: userSession,
                                                                notificationSettingsProxy: notificationSettingsProxy)
        viewModel.fetchInitialContent()
        return viewModel
@@ -73,7 +87,12 @@ struct NotificationSettingsEditScreen_Previews: PreviewProvider {
    static let viewModelDirectChats: NotificationSettingsEditScreenViewModel = {
        let notificationSettingsProxy = NotificationSettingsProxyMock(with: .init())
        notificationSettingsProxy.getDefaultRoomNotificationModeIsEncryptedIsOneToOneReturnValue = .mentionsAndKeywordsOnly
-        var viewModel = NotificationSettingsEditScreenViewModel(isDirect: true,
+        notificationSettingsProxy.getRoomsWithUserDefinedRulesReturnValue = []
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "@alice:example.com",
+                                                                       roomSummaryProvider: MockRoomSummaryProvider(state: .loaded(.mockRooms))),
+                                          mediaProvider: MockMediaProvider())
+        var viewModel = NotificationSettingsEditScreenViewModel(chatType: .oneToOneChat,
+                                                                userSession: userSession,
                                                                notificationSettingsProxy: notificationSettingsProxy)
        viewModel.fetchInitialContent()
        return viewModel
@@ -82,7 +101,11 @@ struct NotificationSettingsEditScreen_Previews: PreviewProvider {
    static let viewModelDirectApplyingChange: NotificationSettingsEditScreenViewModel = {
        let notificationSettingsProxy = NotificationSettingsProxyMock(with: .init())
        notificationSettingsProxy.getDefaultRoomNotificationModeIsEncryptedIsOneToOneReturnValue = .mentionsAndKeywordsOnly
-        var viewModel = NotificationSettingsEditScreenViewModel(isDirect: true,
+        notificationSettingsProxy.getRoomsWithUserDefinedRulesReturnValue = []
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "John Doe"), mediaProvider: MockMediaProvider())
+
+        var viewModel = NotificationSettingsEditScreenViewModel(chatType: .oneToOneChat,
+                                                                userSession: userSession,
                                                                notificationSettingsProxy: notificationSettingsProxy)
        viewModel.state.pendingMode = .mentionsAndKeywordsOnly
        viewModel.fetchInitialContent()
@@ -0,0 +1,90 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Compound
+import SwiftUI
+
+struct NotificationSettingsEditScreenRoomCell: View {
+    @Environment(\.dynamicTypeSize) var dynamicTypeSize
+    
+    let room: NotificationSettingsEditScreenRoom
+    let context: NotificationSettingsEditScreenViewModel.Context
+    
+    var body: some View {
+        ListRow(label: .action(title: room.name,
+                               icon: avatar),
+                details: roomDetailsLabel,
+                kind: .navigationLink {
+                    if let roomId = room.roomId {
+                        context.send(viewAction: .selectRoom(roomIdentifier: roomId))
+                    }
+                })
+                .lineLimit(1)
+                .accessibilityIdentifier(A11yIdentifiers.notificationSettingsEditScreen.roomName(room.name))
+    }
+    
+    @ViewBuilder @MainActor
+    var avatar: some View {
+        if dynamicTypeSize < .accessibility3 {
+            LoadableAvatarImage(url: room.avatarURL,
+                                name: room.name,
+                                contentID: room.roomId,
+                                avatarSize: .room(on: .notificationSettings),
+                                imageProvider: context.imageProvider)
+                .dynamicTypeSize(dynamicTypeSize < .accessibility1 ? dynamicTypeSize : .accessibility1)
+                .accessibilityHidden(true)
+        }
+    }
+    
+    @MainActor
+    var roomDetailsLabel: ListDetailsLabel<EmptyView>? {
+        guard let mode = room.notificationMode else { return nil }
+        return .label(title: context.viewState.strings.string(for: mode),
+                      icon: EmptyView())
+    }
+}
+
+struct NotificationSettingsEditScreenRoomCell_Previews: PreviewProvider {
+    static var previews: some View {
+        let summaryProvider = MockRoomSummaryProvider(state: .loaded(.mockRooms))
+
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "John Doe", roomSummaryProvider: summaryProvider),
+                                          mediaProvider: MockMediaProvider())
+
+        let notificationSettingsProxy = NotificationSettingsProxyMock(with: .init())
+        notificationSettingsProxy.getRoomsWithUserDefinedRulesReturnValue = []
+        let viewModel = NotificationSettingsEditScreenViewModel(chatType: .groupChat,
+                                                                userSession: userSession,
+                                                                notificationSettingsProxy: notificationSettingsProxy)
+        
+        let rooms: [NotificationSettingsEditScreenRoom] = summaryProvider.roomListPublisher.value.compactMap { summary -> NotificationSettingsEditScreenRoom? in
+            switch summary {
+            case .empty, .invalidated:
+                return nil
+            case .filled(let details):
+                return NotificationSettingsEditScreenRoom(id: UUID().uuidString,
+                                                          roomId: details.id,
+                                                          name: details.name)
+            }
+        }
+
+        return VStack(spacing: 0) {
+            ForEach(rooms) { room in
+                NotificationSettingsEditScreenRoomCell(room: room, context: viewModel.context)
+            }
+        }
+    }
+}
@@ -19,6 +19,7 @@ import SwiftUI

 struct NotificationSettingsScreenCoordinatorParameters {
    weak var navigationStackCoordinator: NavigationStackCoordinator?
+    let userSession: UserSessionProtocol
    let userNotificationCenter: UserNotificationCenterProtocol
    let notificationSettings: NotificationSettingsProxyProtocol
    let isModallyPresented: Bool
@@ -45,7 +46,8 @@ final class NotificationSettingsScreenCoordinator: CoordinatorProtocol {
    init(parameters: NotificationSettingsScreenCoordinatorParameters) {
        self.parameters = parameters
        
-        viewModel = NotificationSettingsScreenViewModel(appSettings: ServiceLocator.shared.settings,
+        viewModel = NotificationSettingsScreenViewModel(userSession: parameters.userSession,
+                                                        appSettings: ServiceLocator.shared.settings,
                                                        userNotificationCenter: parameters.userNotificationCenter,
                                                        notificationSettingsProxy: parameters.notificationSettings,
                                                        isModallyPresented: parameters.isModallyPresented)
@@ -59,8 +61,8 @@ final class NotificationSettingsScreenCoordinator: CoordinatorProtocol {
            switch action {
            case .close:
                self.actionsSubject.send(.close)
-            case .editDefaultMode(let isDirect):
-                self.presentEditScreen(isDirect: isDirect)
+            case .editDefaultMode(let chatType):
+                self.presentEditScreen(chatType: chatType)
            }
        }
        .store(in: &cancellables)
@@ -72,8 +74,10 @@ final class NotificationSettingsScreenCoordinator: CoordinatorProtocol {
    
    // MARK: - Private
    
-    private func presentEditScreen(isDirect: Bool) {
-        let editSettingsParameters = NotificationSettingsEditScreenCoordinatorParameters(isDirect: isDirect,
+    private func presentEditScreen(chatType: NotificationSettingsChatType) {
+        let editSettingsParameters = NotificationSettingsEditScreenCoordinatorParameters(navigationStackCoordinator: parameters.navigationStackCoordinator,
+                                                                                         chatType: chatType,
+                                                                                         userSession: parameters.userSession,
                                                                                         notificationSettings: parameters.notificationSettings)
        let editSettingsCoordinator = NotificationSettingsEditScreenCoordinator(parameters: editSettingsParameters)
        navigationStackCoordinator?.push(editSettingsCoordinator)
@@ -19,7 +19,7 @@ import UIKit

 enum NotificationSettingsScreenViewModelAction {
    case close
-    case editDefaultMode(isDirect: Bool)
+    case editDefaultMode(chatType: NotificationSettingsChatType)
 }

 struct NotificationSettingsScreenViewState: BindableState {
@@ -24,13 +24,15 @@ class NotificationSettingsScreenViewModel: NotificationSettingsScreenViewModelTy
    private let appSettings: AppSettings
    private let userNotificationCenter: UserNotificationCenterProtocol
    private let notificationSettingsProxy: NotificationSettingsProxyProtocol
+    private let userSession: UserSessionProtocol
    @CancellableTask private var fetchSettingsTask: Task<Void, Error>?
    
    var actions: AnyPublisher<NotificationSettingsScreenViewModelAction, Never> {
        actionsSubject.eraseToAnyPublisher()
    }

-    init(appSettings: AppSettings, userNotificationCenter: UserNotificationCenterProtocol, notificationSettingsProxy: NotificationSettingsProxyProtocol, isModallyPresented: Bool) {
+    init(userSession: UserSessionProtocol, appSettings: AppSettings, userNotificationCenter: UserNotificationCenterProtocol, notificationSettingsProxy: NotificationSettingsProxyProtocol, isModallyPresented: Bool) {
+        self.userSession = userSession
        self.appSettings = appSettings
        self.userNotificationCenter = userNotificationCenter
        self.notificationSettingsProxy = notificationSettingsProxy
@@ -60,9 +62,9 @@ class NotificationSettingsScreenViewModel: NotificationSettingsScreenViewModelTy
        case .changedEnableNotifications:
            toggleNotifications()
        case .groupChatsTapped:
-            actionsSubject.send(.editDefaultMode(isDirect: false))
+            actionsSubject.send(.editDefaultMode(chatType: .groupChat))
        case .directChatsTapped:
-            actionsSubject.send(.editDefaultMode(isDirect: true))
+            actionsSubject.send(.editDefaultMode(chatType: .oneToOneChat))
        case .roomMentionChanged:
            guard let settings = state.settings, settings.roomMentionsEnabled != state.bindings.roomMentionsEnabled else {
                return
@@ -173,7 +173,10 @@ struct NotificationSettingsScreen_Previews: PreviewProvider {
        notificationSettingsProxy.isRoomMentionEnabledReturnValue = true
        notificationSettingsProxy.isCallEnabledReturnValue = false

-        var viewModel = NotificationSettingsScreenViewModel(appSettings: appSettings,
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "John Doe"), mediaProvider: MockMediaProvider())
+
+        var viewModel = NotificationSettingsScreenViewModel(userSession: userSession,
+                                                            appSettings: appSettings,
                                                            userNotificationCenter: notificationCenter,
                                                            notificationSettingsProxy: notificationSettingsProxy,
                                                            isModallyPresented: true)
@@ -142,6 +142,7 @@ final class SettingsScreenCoordinator: CoordinatorProtocol {
    
    private func presentNotificationSettings() {
        let notificationParameters = NotificationSettingsScreenCoordinatorParameters(navigationStackCoordinator: parameters.navigationStackCoordinator,
+                                                                                     userSession: parameters.userSession,
                                                                                     userNotificationCenter: UNUserNotificationCenter.current(),
                                                                                     notificationSettings: parameters.notificationSettings,
                                                                                     isModallyPresented: false)