remove create room parameters by reference and use coordinator flow instead

ElementX/Sources/Screens/CreateRoom/CreateRoomCoordinator.swift

@@ -19,12 +19,14 @@ import SwiftUI
 
 struct CreateRoomCoordinatorParameters {
     let userSession: UserSessionProtocol
-    let createRoomParameters: CreateRoomVolatileParameters
+    let createRoomParameters: CurrentValuePublisher<CreateRoomFlowParameters, Never>
+    let selectedUsers: CurrentValuePublisher<[UserProfile], Never>
 }
 
 enum CreateRoomCoordinatorAction {
     case createRoom
     case deselectUser(UserProfile)
+    case updateDetails(CreateRoomFlowParameters)
 }
 
 final class CreateRoomCoordinator: CoordinatorProtocol {
@@ -39,7 +41,9 @@ final class CreateRoomCoordinator: CoordinatorProtocol {
     
     init(parameters: CreateRoomCoordinatorParameters) {
         self.parameters = parameters
-        viewModel = CreateRoomViewModel(userSession: parameters.userSession, createRoomParameters: parameters.createRoomParameters)
+        viewModel = CreateRoomViewModel(userSession: parameters.userSession,
+                                        createRoomParameters: parameters.createRoomParameters,
+                                        selectedUsers: parameters.selectedUsers)
     }
     
     func start() {
@@ -50,6 +54,8 @@ final class CreateRoomCoordinator: CoordinatorProtocol {
                 self.actionsSubject.send(.deselectUser(user))
             case .createRoom:
                 self.actionsSubject.send(.createRoom)
+            case .updateDetails(let details):
+                self.actionsSubject.send(.updateDetails(details))
             }
         }
         .store(in: &cancellables)

ElementX/Sources/Screens/CreateRoom/CreateRoomModels.swift

@@ -19,6 +19,7 @@ import Foundation
 enum CreateRoomViewModelAction {
     case createRoom
     case deselectUser(UserProfile)
+    case updateDetails(CreateRoomFlowParameters)
 }
 
 struct CreateRoomViewState: BindableState {

ElementX/Sources/Screens/CreateRoom/CreateRoomViewModel.swift

@@ -21,15 +21,25 @@ typealias CreateRoomViewModelType = StateStoreViewModel<CreateRoomViewState, Cre
 
 class CreateRoomViewModel: CreateRoomViewModelType, CreateRoomViewModelProtocol {
     private var actionsSubject: PassthroughSubject<CreateRoomViewModelAction, Never> = .init()
-    private let createRoomParameters: CreateRoomVolatileParameters
+    private var createRoomParameters: CreateRoomFlowParameters
     var actions: AnyPublisher<CreateRoomViewModelAction, Never> {
         actionsSubject.eraseToAnyPublisher()
     }
+    
+    init(userSession: UserSessionProtocol,
+         createRoomParameters: CurrentValuePublisher<CreateRoomFlowParameters, Never>,
+         selectedUsers: CurrentValuePublisher<[UserProfile], Never>) {
+        let parameters = createRoomParameters.value
+        self.createRoomParameters = parameters
+        let bindings = CreateRoomViewStateBindings(roomName: parameters.name, roomTopic: parameters.topic, isRoomPrivate: parameters.isRoomPrivate)
 
-    init(userSession: UserSessionProtocol, createRoomParameters: CreateRoomVolatileParameters) {
-        let bindings = CreateRoomViewStateBindings(roomName: createRoomParameters.name, roomTopic: createRoomParameters.topic, isRoomPrivate: createRoomParameters.isRoomPrivate)
-        self.createRoomParameters = createRoomParameters
-        super.init(initialViewState: CreateRoomViewState(selectedUsers: createRoomParameters.selectedUsers, bindings: bindings), imageProvider: userSession.mediaProvider)
+        super.init(initialViewState: CreateRoomViewState(selectedUsers: selectedUsers.value, bindings: bindings), imageProvider: userSession.mediaProvider)
+        
+        selectedUsers
+            .sink { [weak self] users in
+                self?.state.selectedUsers = users
+            }
+            .store(in: &cancellables)
         
         setupBindings()
     }
@@ -41,7 +51,6 @@ class CreateRoomViewModel: CreateRoomViewModelType, CreateRoomViewModelProtocol
         case .createRoom:
             actionsSubject.send(.createRoom)
         case .deselectUser(let user):
-            state.selectedUsers.removeAll(where: { $0.userID == user.userID })
             actionsSubject.send(.deselectUser(user))
         }
     }
@@ -51,10 +60,13 @@ class CreateRoomViewModel: CreateRoomViewModelType, CreateRoomViewModelProtocol
     private func setupBindings() {
         context.$viewState
             .map(\.bindings)
+            .throttle(for: 0.5, scheduler: DispatchQueue.main, latest: true)
             .sink { [weak self] bindings in
-                self?.createRoomParameters.name = bindings.roomName
-                self?.createRoomParameters.topic = bindings.roomTopic
-                self?.createRoomParameters.isRoomPrivate = bindings.isRoomPrivate
+                guard let self else { return }
+                createRoomParameters.name = bindings.roomName
+                createRoomParameters.topic = bindings.roomTopic
+                createRoomParameters.isRoomPrivate = bindings.isRoomPrivate
+                actionsSubject.send(.updateDetails(createRoomParameters))
             }
             .store(in: &cancellables)
     }

ElementX/Sources/Screens/CreateRoom/View/CreateRoomScreen.swift

@@ -160,16 +160,17 @@ struct CreateRoom_Previews: PreviewProvider {
     static let viewModel = {
         let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "@userid:example.com"),
                                           mediaProvider: MockMediaProvider())
-        let parameters = CreateRoomVolatileParameters()
-        parameters.selectedUsers = [.mockAlice, .mockBob, .mockCharlie]
-        return CreateRoomViewModel(userSession: userSession, createRoomParameters: parameters)
+        let parameters = CreateRoomFlowParameters()
+        let selectedUsers: [UserProfile] = [.mockAlice, .mockBob, .mockCharlie]
+        
+        return CreateRoomViewModel(userSession: userSession, createRoomParameters: .init(parameters), selectedUsers: .init(selectedUsers))
     }()
     
     static let emtpyViewModel = {
         let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "@userid:example.com"),
                                           mediaProvider: MockMediaProvider())
-        let parameters = CreateRoomVolatileParameters()
-        return CreateRoomViewModel(userSession: userSession, createRoomParameters: parameters)
+        let parameters = CreateRoomFlowParameters()
+        return CreateRoomViewModel(userSession: userSession, createRoomParameters: .init(parameters), selectedUsers: .init([]))
     }()
     
     static var previews: some View {

ElementX/Sources/Screens/InviteUsersScreen/InviteUsersScreenCoordinator.swift

@@ -18,14 +18,15 @@ import Combine
 import SwiftUI
 
 struct InviteUsersScreenCoordinatorParameters {
-    let navigationStackCoordinator: NavigationStackCoordinator?
     let userSession: UserSessionProtocol
     let userDiscoveryService: UserDiscoveryServiceProtocol
-    let createRoomParameters: CreateRoomVolatileParameters?
+    let selectedUsers: CurrentValuePublisher<[UserProfile], Never>
 }
 
 enum InviteUsersScreenCoordinatorAction {
     case close
+    case proceed
+    case toggleUser(UserProfile)
 }
 
 final class InviteUsersScreenCoordinator: CoordinatorProtocol {
@@ -41,7 +42,7 @@ final class InviteUsersScreenCoordinator: CoordinatorProtocol {
     init(parameters: InviteUsersScreenCoordinatorParameters) {
         self.parameters = parameters
         
-        viewModel = InviteUsersScreenViewModel(userSession: parameters.userSession, userDiscoveryService: parameters.userDiscoveryService)
+        viewModel = InviteUsersScreenViewModel(selectedUsers: parameters.selectedUsers, userSession: parameters.userSession, userDiscoveryService: parameters.userDiscoveryService)
     }
     
     func start() {
@@ -49,33 +50,17 @@ final class InviteUsersScreenCoordinator: CoordinatorProtocol {
             guard let self else { return }
             switch action {
             case .close:
-                
                 self.actionsSubject.send(.close)
-            case .proceed(let users):
-                self.openCreateRoomScreenWith(users)
+            case .proceed:
+                self.actionsSubject.send(.proceed)
+            case .toggleUser(let user):
+                self.actionsSubject.send(.toggleUser(user))
             }
         }
         .store(in: &cancellables)
     }
-        
+    
     func toPresentable() -> AnyView {
         AnyView(InviteUsersScreen(context: viewModel.context))
     }
-    
-    private func openCreateRoomScreenWith(_ users: [UserProfile]) {
-        guard let createRoomParameters = parameters.createRoomParameters else { return }
-        createRoomParameters.selectedUsers = users
-        let paramenters = CreateRoomCoordinatorParameters(userSession: parameters.userSession, createRoomParameters: createRoomParameters)
-        let coordinator = CreateRoomCoordinator(parameters: paramenters)
-        coordinator.actions.sink { [weak self] result in
-            switch result {
-            case .deselectUser(let user):
-                self?.viewModel.context.send(viewAction: .deselectUser(user))
-            default:
-                break
-            }
-        }
-        .store(in: &cancellables)
-        parameters.navigationStackCoordinator?.push(coordinator)
-    }
 }

ElementX/Sources/Screens/InviteUsersScreen/InviteUsersScreenModels.swift

@@ -22,13 +22,15 @@ enum InviteUsersScreenErrorType: Error {
 
 enum InviteUsersScreenViewModelAction {
     case close
-    case proceed(users: [UserProfile])
+    case proceed
+    case toggleUser(UserProfile)
 }
 
 struct InviteUsersScreenViewState: BindableState {
     var bindings = InviteUsersScreenViewStateBindings()
     
     var usersSection: UserDiscoverySection = .init(type: .suggestions, users: [])
+    
     var selectedUsers: [UserProfile] = []
     
     var isSearching: Bool {
@@ -56,6 +58,5 @@ struct InviteUsersScreenViewStateBindings {
 enum InviteUsersScreenViewAction {
     case close
     case proceed
-    case tapUser(UserProfile)
-    case deselectUser(UserProfile)
+    case toggleUser(UserProfile)
 }

ElementX/Sources/Screens/InviteUsersScreen/InviteUsersScreenViewModel.swift

@@ -28,10 +28,16 @@ class InviteUsersScreenViewModel: InviteUsersScreenViewModelType, InviteUsersScr
         actionsSubject.eraseToAnyPublisher()
     }
     
-    init(userSession: UserSessionProtocol, userDiscoveryService: UserDiscoveryServiceProtocol) {
+    init(selectedUsers: CurrentValuePublisher<[UserProfile], Never>, userSession: UserSessionProtocol, userDiscoveryService: UserDiscoveryServiceProtocol) {
         self.userSession = userSession
         self.userDiscoveryService = userDiscoveryService
-        super.init(initialViewState: InviteUsersScreenViewState(), imageProvider: userSession.mediaProvider)
+        super.init(initialViewState: InviteUsersScreenViewState(selectedUsers: selectedUsers.value), imageProvider: userSession.mediaProvider)
+        
+        selectedUsers
+            .sink { [weak self] users in
+                self?.state.selectedUsers = users
+            }
+            .store(in: &cancellables)
         
         setupSubscriptions()
     }
@@ -43,27 +49,11 @@ class InviteUsersScreenViewModel: InviteUsersScreenViewModelType, InviteUsersScr
         case .close:
             actionsSubject.send(.close)
         case .proceed:
-            actionsSubject.send(.proceed(users: state.selectedUsers))
-        case .tapUser(let user):
-            if state.isUserSelected(user) {
-                deselect(user)
-            } else {
-                select(user)
-            }
-        case .deselectUser(let user):
-            deselect(user)
+            actionsSubject.send(.proceed)
+        case .toggleUser(let user):
+            actionsSubject.send(.toggleUser(user))
         }
     }
-    
-    private func select(_ user: UserProfile) {
-        state.selectedUsers.append(user)
-        state.scrollToLastID = user.userID
-    }
-    
-    private func deselect(_ user: UserProfile) {
-        state.selectedUsers.removeAll(where: { $0.userID == user.userID })
-        state.scrollToLastID = nil
-    }
 
     // MARK: - Private
     

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

@@ -67,7 +67,7 @@ struct InviteUsersScreen: View {
     private var usersSection: some View {
         Section {
             ForEach(context.viewState.usersSection.users, id: \.userID) { user in
-                Button { context.send(viewAction: .tapUser(user)) } label: {
+                Button { context.send(viewAction: .toggleUser(user)) } label: {
                     UserProfileCell(user: user,
                                     imageProvider: context.imageProvider)
                 }
@@ -112,7 +112,7 @@ struct InviteUsersScreen: View {
     }
     
     private func deselect(_ user: UserProfile) {
-        context.send(viewAction: .deselectUser(user))
+        context.send(viewAction: .toggleUser(user))
     }
 }
 
@@ -125,7 +125,7 @@ struct InviteUsersScreen_Previews: PreviewProvider {
         let userDiscoveryService = UserDiscoveryServiceMock()
         userDiscoveryService.fetchSuggestionsReturnValue = .success([.mockAlice])
         userDiscoveryService.searchProfilesWithReturnValue = .success([.mockAlice])
-        return InviteUsersScreenViewModel(userSession: userSession, userDiscoveryService: userDiscoveryService)
+        return InviteUsersScreenViewModel(selectedUsers: .init([]), userSession: userSession, userDiscoveryService: userDiscoveryService)
     }()
     
     static var previews: some View {

ElementX/Sources/Screens/StartChatScreen/StartChatScreenCoordinator.swift

@@ -35,8 +35,15 @@ final class StartChatScreenCoordinator: CoordinatorProtocol {
     private let actionsSubject: PassthroughSubject<StartChatScreenCoordinatorAction, Never> = .init()
     private var cancellables: Set<AnyCancellable> = .init()
     
-    // this is needed to persist some data in this flow and then destroy them when the flow is eneded
-    private var createRoomParameters = CreateRoomVolatileParameters()
+    private var createRoomParameters = CurrentValueSubject<CreateRoomFlowParameters, Never>(.init())
+    private var createRoomParametersPublisher: CurrentValuePublisher<CreateRoomFlowParameters, Never> {
+        createRoomParameters.asCurrentValuePublisher()
+    }
+    
+    private let selectedUsers = CurrentValueSubject<[UserProfile], Never>([])
+    private var selectedUsersPublisher: CurrentValuePublisher<[UserProfile], Never> {
+        selectedUsers.asCurrentValuePublisher()
+    }
     
     var actions: AnyPublisher<StartChatScreenCoordinatorAction, Never> {
         actionsSubject.eraseToAnyPublisher()
@@ -73,19 +80,59 @@ final class StartChatScreenCoordinator: CoordinatorProtocol {
     // MARK: - Private
     
     private func presentInviteUsersScreen() {
-        createRoomParameters = .init()
-        let inviteParameters = InviteUsersScreenCoordinatorParameters(navigationStackCoordinator: parameters.navigationStackCoordinator,
-                                                                      userSession: parameters.userSession,
+        let inviteParameters = InviteUsersScreenCoordinatorParameters(userSession: parameters.userSession,
                                                                       userDiscoveryService: parameters.userDiscoveryService,
-                                                                      createRoomParameters: createRoomParameters)
+                                                                      selectedUsers: selectedUsersPublisher)
         let coordinator = InviteUsersScreenCoordinator(parameters: inviteParameters)
         coordinator.actions.sink { [weak self] result in
+            guard let self else { return }
+            
             switch result {
             case .close:
-                self?.parameters.navigationStackCoordinator?.pop()
+                parameters.navigationStackCoordinator?.pop()
+            case .proceed:
+                openCreateRoomScreen()
+            case .toggleUser(let user):
+                toggleUser(user)
             }
         }
         .store(in: &cancellables)
+        
+        parameters.navigationStackCoordinator?.push(coordinator) { [weak self] in
+            self?.createRoomParameters.send(.init())
+            self?.selectedUsers.send([])
+        }
+    }
+    
+    private func openCreateRoomScreen() {
+        let paramenters = CreateRoomCoordinatorParameters(userSession: parameters.userSession,
+                                                          createRoomParameters: createRoomParametersPublisher,
+                                                          selectedUsers: selectedUsersPublisher)
+        let coordinator = CreateRoomCoordinator(parameters: paramenters)
+        coordinator.actions.sink { [weak self] result in
+            switch result {
+            case .deselectUser(let user):
+                self?.toggleUser(user)
+            case .updateDetails(let details):
+                self?.createRoomParameters.send(details)
+            case .createRoom:
+                break
+            }
+        }
+        .store(in: &cancellables)
+        
         parameters.navigationStackCoordinator?.push(coordinator)
     }
+    
+    // MARK: - Private
+    
+    private func toggleUser(_ user: UserProfile) {
+        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)
+    }
 }

ElementX/Sources/Services/CreateRoom/CreateRoomFlowParameters.swift

@@ -16,10 +16,9 @@
 
 import Foundation
 
-/// This parameters are only used in the create room flow for having a a volatile persisted object that will be disposed once the flow is ended
-class CreateRoomVolatileParameters {
+/// This parameters are only used in the create room flow for having persisted informations between screens
+struct CreateRoomFlowParameters {
     var name = ""
     var topic = ""
-    var selectedUsers: [UserProfile] = []
     var isRoomPrivate = true
 }

ElementX/Sources/UITests/UITestsAppCoordinator.swift

@@ -14,6 +14,7 @@
 // limitations under the License.
 //
 
+import Combine
 import SwiftUI
 import UIKit
 
@@ -53,6 +54,7 @@ class MockScreen: Identifiable {
     let id: UITestsScreenIdentifier
     
     private var retainedState = [Any]()
+    private var cancellables: Set<AnyCancellable> = []
     
     init(id: UITestsScreenIdentifier) {
         self.id = id
@@ -409,16 +411,32 @@ class MockScreen: Identifiable {
             userDiscoveryMock.fetchSuggestionsReturnValue = .success([.mockAlice, .mockBob, .mockCharlie])
             userDiscoveryMock.searchProfilesWithReturnValue = .success([])
             let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "@mock:client.com"), mediaProvider: MockMediaProvider())
-            let coordinator = InviteUsersScreenCoordinator(parameters: .init(navigationStackCoordinator: navigationStackCoordinator, userSession: userSession, userDiscoveryService: userDiscoveryMock, createRoomParameters: nil))
+            let usersSubject = CurrentValueSubject<[UserProfile], Never>([])
+            let coordinator = InviteUsersScreenCoordinator(parameters: .init(userSession: userSession, userDiscoveryService: userDiscoveryMock, selectedUsers: usersSubject.asCurrentValuePublisher()))
+            coordinator.actions.sink { action in
+                switch action {
+                case .toggleUser(let user):
+                    var selectedUsers = usersSubject.value
+                    if let index = selectedUsers.firstIndex(where: { $0.userID == user.userID }) {
+                        selectedUsers.remove(at: index)
+                    } else {
+                        selectedUsers.append(user)
+                    }
+                    usersSubject.send(selectedUsers)
+                default:
+                    break
+                }
+            }
+            .store(in: &cancellables)
             navigationStackCoordinator.setRootCoordinator(coordinator)
             return navigationStackCoordinator
         case .createRoom:
             let navigationStackCoordinator = NavigationStackCoordinator()
             let clientProxy = MockClientProxy(userID: "@mock:client.com")
             let mockUserSession = MockUserSession(clientProxy: clientProxy, mediaProvider: MockMediaProvider())
-            let createRoomParameters = CreateRoomVolatileParameters()
-            createRoomParameters.selectedUsers = [.mockAlice, .mockBob, .mockCharlie]
-            let parameters = CreateRoomCoordinatorParameters(userSession: mockUserSession, createRoomParameters: createRoomParameters)
+            let createRoomParameters = CreateRoomFlowParameters()
+            let selectedUsers: [UserProfile] = [.mockAlice, .mockBob, .mockCharlie]
+            let parameters = CreateRoomCoordinatorParameters(userSession: mockUserSession, createRoomParameters: .init(createRoomParameters), selectedUsers: .init(selectedUsers))
             let coordinator = CreateRoomCoordinator(parameters: parameters)
             navigationStackCoordinator.setRootCoordinator(coordinator)
             return navigationStackCoordinator
@@ -426,8 +444,8 @@ class MockScreen: Identifiable {
             let navigationStackCoordinator = NavigationStackCoordinator()
             let clientProxy = MockClientProxy(userID: "@mock:client.com")
             let mockUserSession = MockUserSession(clientProxy: clientProxy, mediaProvider: MockMediaProvider())
-            let createRoomParameters = CreateRoomVolatileParameters()
-            let parameters = CreateRoomCoordinatorParameters(userSession: mockUserSession, createRoomParameters: createRoomParameters)
+            let createRoomParameters = CreateRoomFlowParameters()
+            let parameters = CreateRoomCoordinatorParameters(userSession: mockUserSession, createRoomParameters: .init(createRoomParameters), selectedUsers: .init([]))
             let coordinator = CreateRoomCoordinator(parameters: parameters)
             navigationStackCoordinator.setRootCoordinator(coordinator)
             return navigationStackCoordinator