letro/letro-ios
1
0
Fork 0
Code Issues Pull Requests Actions 5 Packages Projects Releases 2 Wiki Activity

Display members of a space (#4629)

Browse Source 
* Present members of a space

* present the members modally from the space

* Implemented a room members flow coordinator to make such flow more modular and reusable

this is required since we will need to reuse this module also in the space settings, and later we could also replace it in the RoomFlowCoordinator.

* the implementation to support at least the SpaceFlowCoordinator is done a follow UP should do the refactor.

* remove modal usage from the flow, we want to always be a navigation flow

* Improved and implemented the room navigation in the members flow coordinator

* pr suggestions and refactored the start chat flow and the invite screen

* updated copies for managing room members

* Update ElementX/Sources/Screens/Spaces/SpaceScreen/SpaceScreenViewModel.swift

Co-authored-by: Doug <6060466+pixlwave@users.noreply.github.com>

---------

Co-authored-by: Doug <6060466+pixlwave@users.noreply.github.com>
This commit is contained in:
Mauro
2025-10-27 13:17:50 +01:00
committed by GitHub
parent 35f8145dde
commit 23194107bb
31 changed files with 561 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
ElementX/Resources/Localizations/en.lproj/Localizable.strings
View File

@@ -495,19 +495,19 @@
"screen_bottom_sheet_create_dm_confirmation_button_title" = "Send invite";
"screen_bottom_sheet_create_dm_message" = "Would you like to start a chat with %1$@?";
"screen_bottom_sheet_create_dm_title" = "Send invite?";
"screen_bottom_sheet_manage_room_member_ban" = "Ban from room";
"screen_bottom_sheet_manage_room_member_ban" = "Ban user";
"screen_bottom_sheet_manage_room_member_ban_member_confirmation_action" = "Ban";
"screen_bottom_sheet_manage_room_member_ban_member_confirmation_description" = "They won’t be able to join this room again if invited.";
"screen_bottom_sheet_manage_room_member_ban_member_confirmation_description" = "They won’t be able to join again if invited.";
"screen_bottom_sheet_manage_room_member_ban_member_confirmation_title" = "Are you sure you want to ban this member?";
"screen_bottom_sheet_manage_room_member_banning_user" = "Banning %1$@";
"screen_bottom_sheet_manage_room_member_kick_member_confirmation_action" = "Remove";
"screen_bottom_sheet_manage_room_member_kick_member_confirmation_title" = "Are you sure you want to remove this member?";
"screen_bottom_sheet_manage_room_member_member_user_info" = "View profile";
"screen_bottom_sheet_manage_room_member_remove" = "Remove from room";
"screen_bottom_sheet_manage_room_member_remove" = "Remove user";
"screen_bottom_sheet_manage_room_member_remove_confirmation_title" = "Remove member and ban from joining in the future?";
"screen_bottom_sheet_manage_room_member_removing_user" = "Removing %1$@…";
"screen_bottom_sheet_manage_room_member_unban" = "Unban from room";
"screen_bottom_sheet_manage_room_member_unban_member_confirmation_description" = "They would be able to join the room again if invited";
"screen_bottom_sheet_manage_room_member_unban" = "Unban user";
"screen_bottom_sheet_manage_room_member_unban_member_confirmation_description" = "They would be able to join again if invited";
"screen_bottom_sheet_manage_room_member_unban_member_confirmation_title" = "Are you sure you want to unban this member?";
"screen_bug_report_a11y_screenshot" = "Screenshot";
"screen_create_poll_option_accessibility_label" = "%1$@: %2$@";
@@ -1416,7 +1416,7 @@
"screen_room_details_security_title" = "Security";
"screen_room_details_topic_title" = "Topic";
"screen_room_error_failed_processing_media" = "Failed processing media to upload, please try again.";
"screen_room_member_list_manage_member_remove_confirmation_ban" = "Ban from room";
"screen_room_member_list_manage_member_remove_confirmation_ban" = "Ban user";
"screen_room_notification_settings_mode_all_messages" = "All messages";
"screen_room_notification_settings_mode_mentions_and_keywords" = "Mentions and Keywords only";
"screen_room_timeline_reactions_show_less" = "Show less";

55
ElementX/Sources/FlowCoordinators/RoomFlowCoordinator.swift
View File

@@ -1354,7 +1354,8 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
selectedUsers: .init(selectedUsersSubject),
roomType: .room(roomProxy: roomProxy),
userDiscoveryService: UserDiscoveryService(clientProxy: userSession.clientProxy),
userIndicatorController: flowParameters.userIndicatorController)
userIndicatorController: flowParameters.userIndicatorController,
appSettings: flowParameters.appSettings)
let coordinator = InviteUsersScreenCoordinator(parameters: inviteParameters)
stackCoordinator.setRootCoordinator(coordinator)
@@ -1363,22 +1364,10 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
guard let self else { return }
switch action {
case .cancel:
case .dismiss:
navigationStackCoordinator.setSheetCoordinator(nil)
case .proceed:
break
case .invite(let users):
self.inviteUsers(users, in: roomProxy)
case .toggleUser(let user):
var selectedUsers = selectedUsersSubject.value
if let index = selectedUsers.firstIndex(where: { $0.userID == user.userID }) {
selectedUsers.remove(at: index)
} else {
selectedUsers.append(user)
}
selectedUsersSubject.send(selectedUsers)
fatalError("Not handled in this flow.")
}
}
.store(in: &cancellables)
@@ -1388,42 +1377,6 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
}
}
private func inviteUsers(_ users: [String], in room: JoinedRoomProxyProtocol) {
if flowParameters.appSettings.enableKeyShareOnInvite {
showLoadingIndicator(title: L10n.screenRoomDetailsInvitePeoplePreparing,
message: L10n.screenRoomDetailsInvitePeopleDontClose)
} else {
showLoadingIndicator()
}
Task {
defer {
navigationStackCoordinator.setSheetCoordinator(nil)
hideLoadingIndicator()
}
let result: Result<Void, RoomProxyError> = await withTaskGroup(of: Result<Void, RoomProxyError>.self) { group in
for user in users {
group.addTask {
await room.invite(userID: user)
}
}
return await group.first { inviteResult in
inviteResult.isFailure
} ?? .success(())
}
guard case .failure = result else {
return
}
flowParameters.userIndicatorController.alertInfo = .init(id: .init(),
title: L10n.commonUnableToInviteTitle,
message: L10n.commonUnableToInviteMessage)
}
}
private func presentRolesAndPermissionsScreen() {
let parameters = RoomRolesAndPermissionsFlowCoordinatorParameters(roomProxy: roomProxy,
mediaProvider: userSession.mediaProvider,

318
ElementX/Sources/FlowCoordinators/RoomMembersFlowCoordinator.swift Normal file
View File

@@ -0,0 +1,318 @@
//
// 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 SwiftState
import SwiftUI
enum RoomMembersFlowCoordinatorAction {
case finished
case presentCallScreen(roomProxy: JoinedRoomProxyProtocol)
case verifyUser(userID: String)
}
enum RoomMembersFlowCoordinatorEntryPoint: Equatable {
/// To be used in a room when a member name is tapped
case roomMember(userID: String)
/// To be used in the context of room details, space details etc.
case roomMembersList
}
final class RoomMembersFlowCoordinator: FlowCoordinatorProtocol {
indirect enum State: StateType {
/// The state machine hasn't started.
case initial
/// The room members list
case roomMembersList
/// The details for a member of the room
case roomMemberDetails(userID: String, previousState: State)
/// In case the details won't load because the user has left the room we load the profile
case userProfile(userID: String, previousState: State)
/// The invite users screen
case inviteUsersScreen
/// A room flow has been started
case roomFlow(roomID: String, previousState: State)
}
enum Event: EventType {
case start
case presentRoomMembersList
case presentRoomMemberDetails(userID: String)
case dismissedRoomMemberDetails
case presentInviteUsersScreen
case dismissedInviteUsersScreen
case presentUserProfile(userID: String)
case dismissedUserProfile
case startRoomFlow(roomID: String)
case stopRoomFlow
}
private let entryPoint: RoomMembersFlowCoordinatorEntryPoint
private let roomProxy: JoinedRoomProxyProtocol
private let navigationStackCoordinator: NavigationStackCoordinator
private let flowParameters: CommonFlowParameters
private let stateMachine: StateMachine<State, Event>
private var cancellables = Set<AnyCancellable>()
private let actionsSubject: PassthroughSubject<RoomMembersFlowCoordinatorAction, Never> = .init()
var actions: AnyPublisher<RoomMembersFlowCoordinatorAction, Never> {
actionsSubject.eraseToAnyPublisher()
}
private var roomFlowCoordinator: RoomFlowCoordinator?
init(entryPoint: RoomMembersFlowCoordinatorEntryPoint,
roomProxy: JoinedRoomProxyProtocol,
navigationStackCoordinator: NavigationStackCoordinator,
flowParameters: CommonFlowParameters) {
self.entryPoint = entryPoint
self.roomProxy = roomProxy
self.flowParameters = flowParameters
self.navigationStackCoordinator = navigationStackCoordinator
stateMachine = .init(state: .initial)
configureStateMachine()
}
func start() {
switch entryPoint {
case .roomMember(let userID):
stateMachine.tryEvent(.presentRoomMemberDetails(userID: userID))
case .roomMembersList:
stateMachine.tryEvent(.presentRoomMembersList)
}
}
func handleAppRoute(_ appRoute: AppRoute, animated: Bool) {
fatalError("Unavailable")
}
func clearRoute(animated: Bool) {
if stateMachine.state == .inviteUsersScreen {
navigationStackCoordinator.setSheetCoordinator(nil, animated: animated)
} else if let roomFlowCoordinator {
roomFlowCoordinator.clearRoute(animated: animated)
}
// We don't support dismissing a sub flow by itself, only the entire chain.
// The presenter flow will take care of dismissing it
actionsSubject.send(.finished)
}
private func configureStateMachine() {
stateMachine.addRouteMapping { event, fromState, _ in
switch (fromState, event) {
case (.initial, .presentRoomMembersList):
return .roomMembersList
case (.initial, .presentRoomMemberDetails(let userID)):
// previous state doesn't matter in this csase
return .roomMemberDetails(userID: userID, previousState: fromState)
case (.roomMembersList, .presentRoomMemberDetails(let userID)):
return .roomMemberDetails(userID: userID, previousState: fromState)
case (.roomMemberDetails, .dismissedRoomMemberDetails):
return .roomMembersList
case (.roomMembersList, .presentInviteUsersScreen):
return .inviteUsersScreen
case (.inviteUsersScreen, .dismissedInviteUsersScreen):
return .roomMembersList
case (.roomMemberDetails(_, let previousState), .presentUserProfile(let userID)):
return .userProfile(userID: userID, previousState: previousState)
case (.userProfile(_, let previousState), .dismissedUserProfile):
return previousState
case (_, .startRoomFlow(let roomID)):
return .roomFlow(roomID: roomID, previousState: fromState)
case (.roomFlow(_, let previousState), .stopRoomFlow):
return previousState
default:
return nil
}
}
stateMachine.addAnyHandler(.any => .any) { [weak self] context in
guard let self else { return }
switch (context.fromState, context.event, context.toState) {
case (.initial, .presentRoomMembersList, .roomMembersList):
presentRoomMembersList()
case (.initial, .presentRoomMemberDetails, .roomMemberDetails(let userID, _)):
presentRoomMemberDetails(userID: userID)
case (.roomMembersList, .presentRoomMemberDetails, .roomMemberDetails(let userID, _)):
presentRoomMemberDetails(userID: userID)
case (.roomMemberDetails, .dismissedRoomMemberDetails, .roomMembersList):
break
case (.roomMembersList, .presentInviteUsersScreen, .inviteUsersScreen):
presentInviteUsersScreen()
case (.inviteUsersScreen, .dismissedInviteUsersScreen, .roomMembersList):
break
case (.roomMemberDetails, .presentUserProfile, .userProfile(let userID, _)):
replaceRoomMemberDetailsWithUserProfile(userID: userID)
case (.userProfile, .dismissedUserProfile, _):
break
case (_, .startRoomFlow(let roomID), .roomFlow):
startRoomFlow(roomID: roomID)
case (.roomFlow, .stopRoomFlow, _):
roomFlowCoordinator = nil
default:
fatalError("Unhandled transition")
}
}
}
private func presentRoomMembersList() {
let coordinator = RoomMembersListScreenCoordinator(parameters: .init(userSession: flowParameters.userSession,
roomProxy: roomProxy,
userIndicatorController: flowParameters.userIndicatorController,
analytics: flowParameters.analytics))
coordinator.actions.sink { [weak self] action in
guard let self else { return }
switch action {
case .invite:
stateMachine.tryEvent(.presentInviteUsersScreen)
case .selectedMember(let member):
stateMachine.tryEvent(.presentRoomMemberDetails(userID: member.userID))
}
}
.store(in: &cancellables)
navigationStackCoordinator.push(coordinator) { [weak self] in
self?.actionsSubject.send(.finished)
}
}
private func presentRoomMemberDetails(userID: String) {
let params = RoomMemberDetailsScreenCoordinatorParameters(userID: userID,
roomProxy: roomProxy,
userSession: flowParameters.userSession,
userIndicatorController: flowParameters.userIndicatorController,
analytics: flowParameters.analytics)
let coordinator = RoomMemberDetailsScreenCoordinator(parameters: params)
coordinator.actions.sink { [weak self] action in
guard let self else { return }
switch action {
case .openUserProfile:
stateMachine.tryEvent(.presentUserProfile(userID: userID))
case .openDirectChat(let roomID):
stateMachine.tryEvent(.startRoomFlow(roomID: roomID))
case .startCall(let roomProxy):
actionsSubject.send(.presentCallScreen(roomProxy: roomProxy))
case .verifyUser(let userID):
actionsSubject.send(.verifyUser(userID: userID))
}
}
.store(in: &cancellables)
navigationStackCoordinator.push(coordinator) { [weak self] in
guard let self else { return }
if entryPoint == .roomMember(userID: userID) {
actionsSubject.send(.finished)
} else {
stateMachine.tryEvent(.dismissedRoomMemberDetails)
}
}
}
private func presentInviteUsersScreen() {
let stackCoordinator = NavigationStackCoordinator()
let inviteParameters = InviteUsersScreenCoordinatorParameters(userSession: flowParameters.userSession,
selectedUsers: nil,
roomType: .room(roomProxy: roomProxy),
userDiscoveryService: UserDiscoveryService(clientProxy: flowParameters.userSession.clientProxy),
userIndicatorController: flowParameters.userIndicatorController,
appSettings: flowParameters.appSettings)
let coordinator = InviteUsersScreenCoordinator(parameters: inviteParameters)
stackCoordinator.setRootCoordinator(coordinator)
coordinator.actions.sink { [weak self] action in
guard let self else { return }
switch action {
case .dismiss:
navigationStackCoordinator.setSheetCoordinator(nil)
case .proceed:
fatalError("Not handled in this flow.")
}
}
.store(in: &cancellables)
navigationStackCoordinator.setSheetCoordinator(stackCoordinator) { [weak self] in
self?.stateMachine.tryEvent(.dismissedInviteUsersScreen)
}
}
private func replaceRoomMemberDetailsWithUserProfile(userID: String) {
let parameters = UserProfileScreenCoordinatorParameters(userID: userID,
isPresentedModally: false,
userSession: flowParameters.userSession,
userIndicatorController: flowParameters.userIndicatorController,
analytics: flowParameters.analytics)
let coordinator = UserProfileScreenCoordinator(parameters: parameters)
coordinator.actionsPublisher.sink { [weak self] action in
guard let self else { return }
switch action {
case .openDirectChat(let roomID):
stateMachine.tryEvent(.startRoomFlow(roomID: roomID))
case .startCall(let roomProxy):
actionsSubject.send(.presentCallScreen(roomProxy: roomProxy))
case .dismiss:
break // Not supported when pushed.
}
}
.store(in: &cancellables)
// Replace the RoomMemberDetailsScreen without any animation.
// If this pop and push happens before the previous navigation is completed it might break screen presentation logic
DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(500)) {
self.navigationStackCoordinator.pop(animated: false)
self.navigationStackCoordinator.push(coordinator, animated: false) { [weak self] in
self?.stateMachine.tryEvent(.dismissedUserProfile)
}
}
}
private func startRoomFlow(roomID: String) {
let coordinator = RoomFlowCoordinator(roomID: roomID,
isChildFlow: true,
navigationStackCoordinator: navigationStackCoordinator,
flowParameters: flowParameters)
coordinator.actions
.sink { [weak self] action in
guard let self else { return }
switch action {
case .presentCallScreen(let roomProxy):
actionsSubject.send(.presentCallScreen(roomProxy: roomProxy))
case .verifyUser(let userID):
actionsSubject.send(.verifyUser(userID: userID))
case .continueWithSpaceFlow:
fatalError("Will never trigger because only direct chats can be displayed in this flow")
case .finished:
stateMachine.tryEvent(.stopRoomFlow)
}
}
.store(in: &cancellables)
roomFlowCoordinator = coordinator
coordinator.handleAppRoute(.room(roomID: roomID, via: []), animated: true)
}
}

53
ElementX/Sources/FlowCoordinators/SpaceFlowCoordinator.swift
View File

@@ -41,6 +41,7 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
private var childSpaceFlowCoordinator: SpaceFlowCoordinator?
private var roomFlowCoordinator: RoomFlowCoordinator?
private var membersFlowCoordinator: RoomMembersFlowCoordinator?
indirect enum State: StateType {
/// The state machine hasn't started.
@@ -53,6 +54,8 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
case presentingChild(childSpaceID: String, previousState: State)
/// A room flow is in progress
case roomFlow(previousState: State)
/// A members flow is in progress
case membersFlow
case leftSpace
}
@@ -77,6 +80,9 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
case startRoomFlow(roomID: String)
case stopRoomFlow
case startMembersFlow
case stopMembersFlow
}
private let stateMachine: StateMachine<State, Event>
@@ -133,6 +139,9 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
case .roomFlow:
roomFlowCoordinator?.clearRoute(animated: animated)
clearRoute(animated: animated) // Re-run with the state machine back in the .space state.
case .membersFlow:
membersFlowCoordinator?.clearRoute(animated: animated)
clearRoute(animated: animated) // Re-run with the state machine back in the .space state.
}
}
@@ -193,6 +202,26 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
selectedSpaceRoomSubject.send(nil)
}
stateMachine.addRouteMapping { event, fromState, _ in
guard case .startMembersFlow = event, case .space = fromState else {
return nil
}
return .membersFlow
} handler: { [weak self] context in
guard let self, let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else {
fatalError("The room proxy must always be provided")
}
Task { await self.startMembersFlow(roomProxy: roomProxy) }
}
stateMachine.addRouteMapping { event, fromState, _ in
guard event == .stopMembersFlow, case .membersFlow = fromState else { return nil }
return .space
} handler: { [weak self] _ in
guard let self else { return }
membersFlowCoordinator = nil
}
stateMachine.addErrorHandler { context in
fatalError("Unexpected transition: \(context)")
}
@@ -219,6 +248,8 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
stateMachine.tryEvent(.startRoomFlow(roomID: roomID))
case .leftSpace:
stateMachine.tryEvent(.leftSpace)
case .displayMembers(let roomProxy):
stateMachine.tryEvent(.startMembersFlow, userInfo: roomProxy)
}
}
.store(in: &cancellables)
@@ -339,4 +370,26 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
coordinator.handleAppRoute(.room(roomID: roomID, via: []), animated: true)
selectedSpaceRoomSubject.send(roomID)
}
private func startMembersFlow(roomProxy: JoinedRoomProxyProtocol) async {
let flowCoordinator = RoomMembersFlowCoordinator(entryPoint: .roomMembersList,
roomProxy: roomProxy,
navigationStackCoordinator: navigationStackCoordinator,
flowParameters: flowParameters)
flowCoordinator.actions.sink { [weak self] actions in
guard let self else { return }
switch actions {
case .finished:
stateMachine.tryEvent(.stopMembersFlow)
case .presentCallScreen(let roomProxy):
actionsSubject.send(.presentCallScreen(roomProxy: roomProxy))
case .verifyUser(let userID):
actionsSubject.send(.verifyUser(userID: userID))
}
}
.store(in: &cancellables)
membersFlowCoordinator = flowCoordinator
flowCoordinator.start()
}
}

12
ElementX/Sources/Generated/Strings.swift
View File

@@ -1312,11 +1312,11 @@ internal enum L10n {
}
/// Send invite?
internal static var screenBottomSheetCreateDmTitle: String { return L10n.tr("Localizable", "screen_bottom_sheet_create_dm_title") }
/// Ban from room
/// Ban user
internal static var screenBottomSheetManageRoomMemberBan: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_ban") }
/// Ban
internal static var screenBottomSheetManageRoomMemberBanMemberConfirmationAction: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_ban_member_confirmation_action") }
/// They won’t be able to join this room again if invited.
/// They won’t be able to join again if invited.
internal static var screenBottomSheetManageRoomMemberBanMemberConfirmationDescription: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_ban_member_confirmation_description") }
/// Are you sure you want to ban this member?
internal static var screenBottomSheetManageRoomMemberBanMemberConfirmationTitle: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_ban_member_confirmation_title") }
@@ -1332,7 +1332,7 @@ internal enum L10n {
internal static var screenBottomSheetManageRoomMemberKickMemberConfirmationTitle: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_kick_member_confirmation_title") }
/// View profile
internal static var screenBottomSheetManageRoomMemberMemberUserInfo: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_member_user_info") }
/// Remove from room
/// Remove user
internal static var screenBottomSheetManageRoomMemberRemove: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_remove") }
/// Remove member and ban from joining in the future?
internal static var screenBottomSheetManageRoomMemberRemoveConfirmationTitle: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_remove_confirmation_title") }
@@ -1340,11 +1340,11 @@ internal enum L10n {
internal static func screenBottomSheetManageRoomMemberRemovingUser(_ p1: Any) -> String {
return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_removing_user", String(describing: p1))
}
/// Unban from room
/// Unban user
internal static var screenBottomSheetManageRoomMemberUnban: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_unban") }
/// Unban
internal static var screenBottomSheetManageRoomMemberUnbanMemberConfirmationAction: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_unban_member_confirmation_action") }
/// They would be able to join the room again if invited
/// They would be able to join again if invited
internal static var screenBottomSheetManageRoomMemberUnbanMemberConfirmationDescription: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_unban_member_confirmation_description") }
/// Are you sure you want to unban this member?
internal static var screenBottomSheetManageRoomMemberUnbanMemberConfirmationTitle: String { return L10n.tr("Localizable", "screen_bottom_sheet_manage_room_member_unban_member_confirmation_title") }
@@ -2468,7 +2468,7 @@ internal enum L10n {
internal static func screenRoomMemberListHeaderTitle(_ p1: Int) -> String {
return L10n.tr("Localizable", "screen_room_member_list_header_title", p1)
}
/// Ban from room
/// Ban user
internal static var screenRoomMemberListManageMemberRemoveConfirmationBan: String { return L10n.tr("Localizable", "screen_room_member_list_manage_member_remove_confirmation_ban") }
/// Only remove member
internal static var screenRoomMemberListManageMemberRemoveConfirmationKick: String { return L10n.tr("Localizable", "screen_room_member_list_manage_member_remove_confirmation_kick") }

8
ElementX/Sources/Screens/CreateRoom/CreateRoomCoordinator.swift
View File

@@ -13,14 +13,14 @@ struct CreateRoomCoordinatorParameters {
let userSession: UserSessionProtocol
let userIndicatorController: UserIndicatorControllerProtocol
let createRoomParameters: CurrentValuePublisher<CreateRoomFlowParameters, Never>
let selectedUsers: CurrentValuePublisher<[UserProfileProxy], Never>
let selectedUsers: [UserProfileProxy]
let appSettings: AppSettings
let analytics: AnalyticsService
}
enum CreateRoomCoordinatorAction {
case openRoom(withIdentifier: String)
case deselectUser(UserProfileProxy)
case updateSelectedUsers([UserProfileProxy])
case updateDetails(CreateRoomFlowParameters)
case displayMediaPickerWithMode(MediaPickerScreenMode)
case removeImage
@@ -48,8 +48,8 @@ final class CreateRoomCoordinator: CoordinatorProtocol {
viewModel.actions.sink { [weak self] action in
guard let self else { return }
switch action {
case .deselectUser(let user):
actionsSubject.send(.deselectUser(user))
case .updateSelectedUsers(let users):
actionsSubject.send(.updateSelectedUsers(users))
case .openRoom(let identifier):
actionsSubject.send(.openRoom(withIdentifier: identifier))
case .updateDetails(let details):

2
ElementX/Sources/Screens/CreateRoom/CreateRoomModels.swift
View File

@@ -18,7 +18,7 @@ enum CreateRoomScreenErrorType: Error {
enum CreateRoomViewModelAction {
case openRoom(withIdentifier: String)
case deselectUser(UserProfileProxy)
case updateSelectedUsers([UserProfileProxy])
case updateDetails(CreateRoomFlowParameters)
case displayMediaPicker
case displayCameraPicker

13
ElementX/Sources/Screens/CreateRoom/CreateRoomViewModel.swift
View File

@@ -28,7 +28,7 @@ class CreateRoomViewModel: CreateRoomViewModelType, CreateRoomViewModelProtocol
init(userSession: UserSessionProtocol,
createRoomParameters: CurrentValuePublisher<CreateRoomFlowParameters, Never>,
selectedUsers: CurrentValuePublisher<[UserProfileProxy], Never>,
selectedUsers: [UserProfileProxy],
analytics: AnalyticsService,
userIndicatorController: UserIndicatorControllerProtocol,
appSettings: AppSettings) {
@@ -46,7 +46,7 @@ class CreateRoomViewModel: CreateRoomViewModelType, CreateRoomViewModelProtocol
super.init(initialViewState: CreateRoomViewState(roomName: parameters.name,
serverName: userSession.clientProxy.userIDServerName ?? "",
isKnockingFeatureEnabled: appSettings.knockingEnabled,
selectedUsers: selectedUsers.value,
selectedUsers: selectedUsers,
aliasLocalPart: parameters.aliasLocalPart ?? roomAliasNameFromRoomDisplayName(roomName: parameters.name),
bindings: bindings),
mediaProvider: userSession.mediaProvider)
@@ -67,12 +67,6 @@ class CreateRoomViewModel: CreateRoomViewModelType, CreateRoomViewModelProtocol
}
.store(in: &cancellables)
selectedUsers
.sink { [weak self] users in
self?.state.selectedUsers = users
}
.store(in: &cancellables)
setupBindings()
}
@@ -85,7 +79,8 @@ class CreateRoomViewModel: CreateRoomViewModelType, CreateRoomViewModelProtocol
await createRoom()
}
case .deselectUser(let user):
actionsSubject.send(.deselectUser(user))
state.selectedUsers.removeAll { $0.userID == user.userID }
actionsSubject.send(.updateSelectedUsers(state.selectedUsers))
case .displayCameraPicker:
actionsSubject.send(.displayCameraPicker)
case .displayMediaPicker:

24
ElementX/Sources/Screens/InviteUsersScreen/InviteUsersScreenCoordinator.swift
View File

@@ -11,17 +11,16 @@ import SwiftUI
struct InviteUsersScreenCoordinatorParameters {
let userSession: UserSessionProtocol
let selectedUsers: CurrentValuePublisher<[UserProfileProxy], Never>
let selectedUsers: CurrentValuePublisher<[UserProfileProxy], Never>?
let roomType: InviteUsersScreenRoomType
let userDiscoveryService: UserDiscoveryServiceProtocol
let userIndicatorController: UserIndicatorControllerProtocol
let appSettings: AppSettings
}
enum InviteUsersScreenCoordinatorAction {
case cancel
case proceed
case invite(users: [String])
case toggleUser(UserProfileProxy)
case dismiss
case proceed(selectedUsers: [UserProfileProxy])
}
final class InviteUsersScreenCoordinator: CoordinatorProtocol {
@@ -38,21 +37,18 @@ final class InviteUsersScreenCoordinator: CoordinatorProtocol {
selectedUsers: parameters.selectedUsers,
roomType: parameters.roomType,
userDiscoveryService: parameters.userDiscoveryService,
userIndicatorController: parameters.userIndicatorController)
userIndicatorController: parameters.userIndicatorController,
appSettings: parameters.appSettings)
}
func start() {
viewModel.actions.sink { [weak self] action in
guard let self else { return }
switch action {
case .cancel:
actionsSubject.send(.cancel)
case .proceed:
actionsSubject.send(.proceed)
case .invite(let users):
actionsSubject.send(.invite(users: users))
case .toggleUser(let user):
actionsSubject.send(.toggleUser(user))
case .dismiss:
actionsSubject.send(.dismiss)
case .proceed(let selectedUsers):
actionsSubject.send(.proceed(selectedUsers: selectedUsers))
}
}
.store(in: &cancellables)

6
ElementX/Sources/Screens/InviteUsersScreen/InviteUsersScreenModels.swift
View File

@@ -15,10 +15,8 @@ enum InviteUsersScreenErrorType: Error {
}
enum InviteUsersScreenViewModelAction {
case cancel
case proceed
case invite(users: [String])
case toggleUser(UserProfileProxy)
case dismiss
case proceed(selectedUsers: [UserProfileProxy])
}
enum InviteUsersScreenRoomType {

96
ElementX/Sources/Screens/InviteUsersScreen/InviteUsersScreenViewModel.swift
View File

@@ -16,6 +16,7 @@ class InviteUsersScreenViewModel: InviteUsersScreenViewModelType, InviteUsersScr
private let roomType: InviteUsersScreenRoomType
private let userDiscoveryService: UserDiscoveryServiceProtocol
private let userIndicatorController: UserIndicatorControllerProtocol
private let appSettings: AppSettings
private var suggestedUsers = [UserProfileProxy]()
@@ -24,20 +25,25 @@ class InviteUsersScreenViewModel: InviteUsersScreenViewModelType, InviteUsersScr
actionsSubject.eraseToAnyPublisher()
}
private let selectedUsers: CurrentValuePublisher<[UserProfileProxy], Never>?
init(userSession: UserSessionProtocol,
selectedUsers: CurrentValuePublisher<[UserProfileProxy], Never>,
selectedUsers: CurrentValuePublisher<[UserProfileProxy], Never>?,
roomType: InviteUsersScreenRoomType,
userDiscoveryService: UserDiscoveryServiceProtocol,
userIndicatorController: UserIndicatorControllerProtocol) {
userIndicatorController: UserIndicatorControllerProtocol,
appSettings: AppSettings) {
self.roomType = roomType
self.userDiscoveryService = userDiscoveryService
self.userIndicatorController = userIndicatorController
self.appSettings = appSettings
self.selectedUsers = selectedUsers
super.init(initialViewState: InviteUsersScreenViewState(selectedUsers: selectedUsers.value,
super.init(initialViewState: InviteUsersScreenViewState(selectedUsers: selectedUsers?.value ?? [],
isCreatingRoom: roomType.isCreatingRoom),
mediaProvider: userSession.mediaProvider)
setupSubscriptions(selectedUsers: selectedUsers)
setupSubscriptions()
fetchMembersIfNeeded()
Task {
@@ -54,23 +60,67 @@ class InviteUsersScreenViewModel: InviteUsersScreenViewModelType, InviteUsersScr
override func process(viewAction: InviteUsersScreenViewAction) {
switch viewAction {
case .cancel:
actionsSubject.send(.cancel)
actionsSubject.send(.dismiss)
case .proceed:
switch roomType {
case .draft:
actionsSubject.send(.proceed)
case .room:
actionsSubject.send(.invite(users: state.selectedUsers.map(\.userID)))
actionsSubject.send(.proceed(selectedUsers: state.selectedUsers))
case .room(let roomProxy):
inviteUsers(state.selectedUsers.map(\.userID), roomProxy: roomProxy)
}
case .toggleUser(let user):
let willSelectUser = !state.selectedUsers.contains(user)
state.scrollToLastID = willSelectUser ? user.userID : nil
actionsSubject.send(.toggleUser(user))
toggleUser(user)
}
}
// MARK: - Private
private func toggleUser(_ user: UserProfileProxy) {
if state.selectedUsers.contains(user) {
state.scrollToLastID = nil
state.selectedUsers.removeAll(where: { $0.userID == user.userID })
} else {
state.scrollToLastID = user.userID
state.selectedUsers.append(user)
}
}
private func inviteUsers(_ users: [String], roomProxy: JoinedRoomProxyProtocol) {
if appSettings.enableKeyShareOnInvite {
showLoader(title: L10n.screenRoomDetailsInvitePeoplePreparing,
message: L10n.screenRoomDetailsInvitePeopleDontClose)
} else {
showLoader()
}
Task {
defer {
hideLoader()
actionsSubject.send(.dismiss)
}
let result: Result<Void, RoomProxyError> = await withTaskGroup(of: Result<Void, RoomProxyError>.self) { group in
for user in users {
group.addTask {
await roomProxy.invite(userID: user)
}
}
return await group.first { inviteResult in
inviteResult.isFailure
} ?? .success(())
}
guard case .failure = result else {
return
}
userIndicatorController.alertInfo = .init(id: .init(),
title: L10n.commonUnableToInviteTitle,
message: L10n.commonUnableToInviteMessage)
}
}
private func buildMembershipStateIfNeeded(members: [RoomMemberProxyProtocol]) {
showLoader()
@@ -92,7 +142,7 @@ class InviteUsersScreenViewModel: InviteUsersScreenViewModelType, InviteUsersScr
@CancellableTask
private var fetchUsersTask: Task<Void, Never>?
private func setupSubscriptions(selectedUsers: CurrentValuePublisher<[UserProfileProxy], Never>) {
private func setupSubscriptions() {
context.$viewState
.map(\.bindings.searchQuery)
.debounceTextQueriesAndRemoveDuplicates()
@@ -101,11 +151,13 @@ class InviteUsersScreenViewModel: InviteUsersScreenViewModelType, InviteUsersScr
}
.store(in: &cancellables)
selectedUsers
.sink { [weak self] users in
self?.state.selectedUsers = users
}
.store(in: &cancellables)
if let selectedUsers {
selectedUsers
.sink { [weak self] users in
self?.state.selectedUsers = users
}
.store(in: &cancellables)
}
}
private func fetchMembersIfNeeded() {
@@ -159,8 +211,14 @@ class InviteUsersScreenViewModel: InviteUsersScreenViewModelType, InviteUsersScr
private let userIndicatorID = UUID().uuidString
private func showLoader() {
userIndicatorController.submitIndicator(UserIndicator(id: userIndicatorID, type: .modal, title: L10n.commonLoading, persistent: true), delay: .milliseconds(200))
private func showLoader(title: String = L10n.commonLoading,
message: String? = nil) {
userIndicatorController.submitIndicator(UserIndicator(id: userIndicatorID,
type: .modal,
title: title,
message: message,
persistent: true),
delay: .milliseconds(200))
}
private func hideLoader() {

3
ElementX/Sources/Screens/InviteUsersScreen/View/InviteUsersScreen.swift
View File

@@ -158,7 +158,8 @@ struct InviteUsersScreen_Previews: PreviewProvider, TestablePreview {
selectedUsers: .init([]),
roomType: .draft,
userDiscoveryService: userDiscoveryService,
userIndicatorController: UserIndicatorControllerMock())
userIndicatorController: UserIndicatorControllerMock(),
appSettings: ServiceLocator.shared.settings)
}()
static var previews: some View {

1
ElementX/Sources/Screens/RoomMemberListScreen/View/RoomMembersListScreen.swift
View File

@@ -48,6 +48,7 @@ struct RoomMembersListScreen: View {
.autocorrectionDisabled()
.background(Color.compound.bgCanvasDefault.ignoresSafeArea())
.navigationTitle(L10n.commonPeople)
.navigationBarTitleDisplayMode(.inline)
.sheet(item: $context.manageMemeberViewModel) {
ManageRoomMemberSheetView(context: $0.context)
}

3
ElementX/Sources/Screens/Spaces/SpaceScreen/SpaceScreenCoordinator.swift
View File

@@ -24,6 +24,7 @@ enum SpaceScreenCoordinatorAction {
case selectUnjoinedSpace(SpaceRoomProxyProtocol)
case selectRoom(roomID: String)
case leftSpace
case displayMembers(roomProxy: JoinedRoomProxyProtocol)
}
final class SpaceScreenCoordinator: CoordinatorProtocol {
@@ -61,6 +62,8 @@ final class SpaceScreenCoordinator: CoordinatorProtocol {
actionsSubject.send(.selectRoom(roomID: roomID))
case .leftSpace:
actionsSubject.send(.leftSpace)
case .displayMembers(let roomProxy):
actionsSubject.send(.displayMembers(roomProxy: roomProxy))
}
}
.store(in: &cancellables)

3
ElementX/Sources/Screens/Spaces/SpaceScreen/SpaceScreenModels.swift
View File

@@ -13,12 +13,14 @@ enum SpaceScreenViewModelAction {
case selectUnjoinedSpace(SpaceRoomProxyProtocol)
case selectRoom(roomID: String)
case leftSpace
case displayMembers(roomProxy: JoinedRoomProxyProtocol)
}
struct SpaceScreenViewState: BindableState {
var space: SpaceRoomProxyProtocol
var permalink: URL?
var roomProxy: JoinedRoomProxyProtocol?
var isPaginating = false
var rooms: [SpaceRoomProxyProtocol]
@@ -42,4 +44,5 @@ enum SpaceScreenViewAction {
case toggleLeaveSpaceRoomDetails(id: String)
case confirmLeaveSpace
case spaceSettings
case displayMembers(roomProxy: JoinedRoomProxyProtocol)
}

12
ElementX/Sources/Screens/Spaces/SpaceScreen/SpaceScreenViewModel.swift
View File

@@ -68,9 +68,13 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
.store(in: &cancellables)
Task {
if case let .joined(roomProxy) = await userSession.clientProxy.roomForIdentifier(spaceRoomListProxy.id),
case let .success(permalinkURL) = await roomProxy.matrixToPermalink() {
state.permalink = permalinkURL
if case let .joined(roomProxy) = await userSession.clientProxy.roomForIdentifier(spaceRoomListProxy.id) {
// Required to listen for membership updates in the members flow
await roomProxy.subscribeForUpdates()
state.roomProxy = roomProxy
if case let .success(permalinkURL) = await roomProxy.matrixToPermalink() {
state.permalink = permalinkURL
}
}
}
}
@@ -115,6 +119,8 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
}
case .confirmLeaveSpace:
Task { await confirmLeaveSpace() }
case .displayMembers(let roomProxy):
actionsSubject.send(.displayMembers(roomProxy: roomProxy))
case .spaceSettings:
break // Not implemented.
}

17
ElementX/Sources/Screens/Spaces/SpaceScreen/View/SpaceScreen.swift
View File

@@ -62,8 +62,13 @@ struct SpaceScreen: View {
// controller attempts to anchor itself to the button that is no longer visible.
ToolbarItem(placement: .primaryAction) {
Menu {
if let permalink = context.viewState.permalink {
Section {
Section {
if let roomProxy = context.viewState.roomProxy {
Button { context.send(viewAction: .displayMembers(roomProxy: roomProxy)) } label: {
Label(L10n.screenSpaceMenuActionMembers, icon: \.user)
}
}
if let permalink = context.viewState.permalink {
ShareLink(item: permalink) {
Label(L10n.actionShare, icon: \.shareIos)
}
@@ -106,10 +111,16 @@ struct SpaceScreen_Previews: PreviewProvider, TestablePreview {
let spaceRoomListProxy = SpaceRoomListProxyMock(.init(spaceRoomProxy: spaceRoomProxy,
initialSpaceRooms: .mockSpaceList))
let clientProxy = ClientProxyMock(.init())
clientProxy.roomForIdentifierClosure = { _ in
.joined(JoinedRoomProxyMock(.init()))
}
let userSession = UserSessionMock(.init(clientProxy: clientProxy))
let viewModel = SpaceScreenViewModel(spaceRoomListProxy: spaceRoomListProxy,
spaceServiceProxy: SpaceServiceProxyMock(.init()),
selectedSpaceRoomPublisher: .init(nil),
userSession: UserSessionMock(.init()),
userSession: userSession,
userIndicatorController: UserIndicatorControllerMock())
return viewModel
}

31
ElementX/Sources/Screens/StartChatScreen/StartChatScreenCoordinator.swift
View File

@@ -87,20 +87,17 @@ final class StartChatScreenCoordinator: CoordinatorProtocol {
selectedUsers: selectedUsersPublisher,
roomType: .draft,
userDiscoveryService: parameters.userDiscoveryService,
userIndicatorController: parameters.userIndicatorController)
userIndicatorController: parameters.userIndicatorController,
appSettings: parameters.appSettings)
let coordinator = InviteUsersScreenCoordinator(parameters: inviteParameters)
coordinator.actions.sink { [weak self] action in
guard let self else { return }
switch action {
case .cancel:
break // Not shown in this flow.
case .proceed:
case .dismiss:
fatalError("Not shown in this flow.")
case .proceed(let selectedUsers):
self.selectedUsers.send(selectedUsers)
openCreateRoomScreen()
case .invite:
break
case .toggleUser(let user):
toggleUser(user)
}
}
.store(in: &cancellables)
@@ -115,15 +112,15 @@ final class StartChatScreenCoordinator: CoordinatorProtocol {
let createParameters = CreateRoomCoordinatorParameters(userSession: parameters.userSession,
userIndicatorController: parameters.userIndicatorController,
createRoomParameters: createRoomParametersPublisher,
selectedUsers: selectedUsersPublisher,
selectedUsers: selectedUsers.value,
appSettings: parameters.appSettings,
analytics: parameters.analytics)
let coordinator = CreateRoomCoordinator(parameters: createParameters)
coordinator.actions.sink { [weak self] action in
guard let self else { return }
switch action {
case .deselectUser(let user):
self.toggleUser(user)
case .updateSelectedUsers(let users):
self.selectedUsers.send(users)
case .updateDetails(let details):
self.createRoomParameters.send(details)
case .openRoom(let identifier):
@@ -190,16 +187,6 @@ final class StartChatScreenCoordinator: CoordinatorProtocol {
}
}
private func toggleUser(_ user: UserProfileProxy) {
var selectedUsers = selectedUsers.value
if let index = selectedUsers.firstIndex(where: { $0.userID == user.userID }) {
selectedUsers.remove(at: index)
} else {
selectedUsers.append(user)
}
self.selectedUsers.send(selectedUsers)
}
// MARK: Loading indicator
private static let loadingIndicatorIdentifier = "\(StartChatScreenCoordinator.self)-Loading"