Switch callbacks to combine (#1710)

* #750 - Convert the SoftLogoutScreen to combine * #750 - Convert the UserSessionFlowCoordinator to Combine * #750 - Convert the AnalyticsPromptScreen to Combine * #750 - Convert the LoginScreen to Combine * #750 - Convert the ServerSelectionScreen to Combine * #750 - Convert the EmojiPickerScreen to Combine * #750 - Convert the HomeScreen to Combine * #750 - Convert the MediaUploadPreviewScreen to Combine * #750 - Convert the OnboardingScreen to Combine * Rename `Onboarding` to `OnboardingScreen` * #750 - Convert the ReportContentScreen to Combine * #750 - Convert the RoomDetailsSscreen to Combine * #750 - Convert the RoomMemberDetailsScreen to Combine * #750 - Convert the RoomMembersListScreen to Combine * #750 - Convert the SessionVerificationScreen to Combine * #750 - Convert the SettingsScreen to Combine * #750 - Convert the AdvancedSettingsScreen to Combine * #750 - Convert the DeveloperOptionsScreen to Combine * Fix the unit tests * Use .sink action and the same cancellables constructor everywhere * Cleanup cancellables when setting up tests
2026-11-04 01:20:12 +00:00 · 2023-09-14 12:53:33 +03:00
parent a0d40b6f0c
commit a4e5e4f0ed
89 changed files with 884 additions and 589 deletions
@@ -36,7 +36,7 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
    
    private let stateMachine: StateMachine<State, Event> = .init(state: .initial)
    
-    private var cancellables: Set<AnyCancellable> = .init()
+    private var cancellables = Set<AnyCancellable>()
    
    private let actionsSubject: PassthroughSubject<RoomFlowCoordinatorAction, Never> = .init()
    var actions: AnyPublisher<RoomFlowCoordinatorAction, Never> {
@@ -456,16 +456,22 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                                                                  roomProxy: roomProxy,
                                                                  userIndicatorController: userIndicatorController)
        let coordinator = ReportContentScreenCoordinator(parameters: parameters)
-        coordinator.callback = { [weak self] completion in
-            self?.navigationStackCoordinator.setSheetCoordinator(nil)
-            
-            switch completion {
-            case .cancel:
-                break
-            case .finish:
-                userIndicatorController.submitIndicator(UserIndicator(title: L10n.commonReportSubmitted, iconName: "checkmark"))
+        
+        coordinator.actions
+            .sink { [weak self] action in
+                guard let self else { return }
+                
+                navigationStackCoordinator.setSheetCoordinator(nil)
+                
+                switch action {
+                case .cancel:
+                    break
+                case .finish:
+                    userIndicatorController.submitIndicator(UserIndicator(title: L10n.commonReportSubmitted, iconName: "checkmark"))
+                }
            }
-        }
+            .store(in: &cancellables)
+        
        navigationCoordinator.setRootCoordinator(coordinator)
        navigationStackCoordinator.setSheetCoordinator(userIndicatorController) { [weak self] in
            self?.stateMachine.tryEvent(.dismissReportContent)
@@ -508,12 +514,18 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                                                                       title: url.lastPathComponent,
                                                                       url: url)

-        let mediaUploadPreviewScreenCoordinator = MediaUploadPreviewScreenCoordinator(parameters: parameters) { [weak self] action in
-            switch action {
-            case .dismiss:
-                self?.navigationStackCoordinator.setSheetCoordinator(nil)
+        let mediaUploadPreviewScreenCoordinator = MediaUploadPreviewScreenCoordinator(parameters: parameters)
+        
+        mediaUploadPreviewScreenCoordinator.actions
+            .sink { [weak self] action in
+                guard let self else { return }
+                
+                switch action {
+                case .dismiss:
+                    navigationStackCoordinator.setSheetCoordinator(nil)
+                }
            }
-        }
+            .store(in: &cancellables)

        stackCoordinator.setRootCoordinator(mediaUploadPreviewScreenCoordinator)

@@ -526,18 +538,22 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
        let params = EmojiPickerScreenCoordinatorParameters(emojiProvider: emojiProvider,
                                                            itemID: itemID, selectedEmojis: selectedEmoji)
        let coordinator = EmojiPickerScreenCoordinator(parameters: params)
-        coordinator.callback = { [weak self] action in
+        
+        coordinator.actions.sink { [weak self] action in
+            guard let self else { return }
+            
            switch action {
            case let .emojiSelected(emoji: emoji, itemID: itemID):
                MXLog.debug("Selected \(emoji) for \(itemID)")
-                self?.navigationStackCoordinator.setSheetCoordinator(nil)
+                navigationStackCoordinator.setSheetCoordinator(nil)
                Task {
-                    await self?.timelineController?.toggleReaction(emoji, to: itemID)
+                    await self.timelineController?.toggleReaction(emoji, to: itemID)
                }
            case .dismiss:
-                self?.navigationStackCoordinator.setSheetCoordinator(nil)
+                navigationStackCoordinator.setSheetCoordinator(nil)
            }
        }
+        .store(in: &cancellables)
        
        navigationStackCoordinator.setSheetCoordinator(coordinator) { [weak self] in
            self?.stateMachine.tryEvent(.dismissEmojiPicker)
@@ -29,11 +29,12 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
    private let roomTimelineControllerFactory: RoomTimelineControllerFactoryProtocol
    private let appSettings: AppSettings
    private let analytics: AnalyticsService
+    private let actionsSubject: PassthroughSubject<UserSessionFlowCoordinatorAction, Never> = .init()
    
    private let stateMachine: UserSessionFlowCoordinatorStateMachine
    private let roomFlowCoordinator: RoomFlowCoordinator
    
-    private var cancellables: Set<AnyCancellable> = .init()
+    private var cancellables = Set<AnyCancellable>()
    private var migrationCancellable: AnyCancellable?
    
    private let sidebarNavigationStackCoordinator: NavigationStackCoordinator
@@ -41,7 +42,9 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {

    private let selectedRoomSubject = CurrentValueSubject<String?, Never>(nil)
    
-    var callback: ((UserSessionFlowCoordinatorAction) -> Void)?
+    var actions: AnyPublisher<UserSessionFlowCoordinatorAction, Never> {
+        actionsSubject.eraseToAnyPublisher()
+    }
    
    init(userSession: UserSessionProtocol,
         navigationSplitCoordinator: NavigationSplitCoordinator,
@@ -263,34 +266,36 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
                                                         navigationStackCoordinator: detailNavigationStackCoordinator,
                                                         selectedRoomPublisher: selectedRoomSubject.asCurrentValuePublisher())
        let coordinator = HomeScreenCoordinator(parameters: parameters)
-
-        coordinator.callback = { [weak self] action in
-            guard let self else { return }
-
-            switch action {
-            case .presentRoom(let roomID):
-                self.roomFlowCoordinator.handleAppRoute(.room(roomID: roomID), animated: true)
-            case .presentRoomDetails(let roomID):
-                self.roomFlowCoordinator.handleAppRoute(.roomDetails(roomID: roomID), animated: true)
-            case .roomLeft(let roomID):
-                if case .roomList(selectedRoomID: let selectedRoomID) = stateMachine.state,
-                   selectedRoomID == roomID {
-                    self.roomFlowCoordinator.handleAppRoute(.roomList, animated: true)
+        
+        coordinator.actions
+            .sink { [weak self] action in
+                guard let self else { return }
+                
+                switch action {
+                case .presentRoom(let roomID):
+                    roomFlowCoordinator.handleAppRoute(.room(roomID: roomID), animated: true)
+                case .presentRoomDetails(let roomID):
+                    roomFlowCoordinator.handleAppRoute(.roomDetails(roomID: roomID), animated: true)
+                case .roomLeft(let roomID):
+                    if case .roomList(selectedRoomID: let selectedRoomID) = stateMachine.state,
+                       selectedRoomID == roomID {
+                        roomFlowCoordinator.handleAppRoute(.roomList, animated: true)
+                    }
+                case .presentSettingsScreen:
+                    stateMachine.processEvent(.showSettingsScreen)
+                case .presentFeedbackScreen:
+                    stateMachine.processEvent(.feedbackScreen)
+                case .presentSessionVerificationScreen:
+                    stateMachine.processEvent(.showSessionVerificationScreen)
+                case .presentStartChatScreen:
+                    stateMachine.processEvent(.showStartChatScreen)
+                case .signOut:
+                    actionsSubject.send(.signOut)
+                case .presentInvitesScreen:
+                    stateMachine.processEvent(.showInvitesScreen)
                }
-            case .presentSettingsScreen:
-                self.stateMachine.processEvent(.showSettingsScreen)
-            case .presentFeedbackScreen:
-                self.stateMachine.processEvent(.feedbackScreen)
-            case .presentSessionVerificationScreen:
-                self.stateMachine.processEvent(.showSessionVerificationScreen)
-            case .presentStartChatScreen:
-                self.stateMachine.processEvent(.showStartChatScreen)
-            case .signOut:
-                self.callback?(.signOut)
-            case .presentInvitesScreen:
-                self.stateMachine.processEvent(.showInvitesScreen)
            }
-        }
+            .store(in: &cancellables)
        
        sidebarNavigationStackCoordinator.setRootCoordinator(coordinator)
    }
@@ -324,18 +329,22 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
                                                             notificationSettings: userSession.clientProxy.notificationSettings,
                                                             appSettings: appSettings)
        let settingsScreenCoordinator = SettingsScreenCoordinator(parameters: parameters)
-        settingsScreenCoordinator.callback = { [weak self] action in
-            guard let self else { return }
-            switch action {
-            case .dismiss:
-                self.navigationSplitCoordinator.setSheetCoordinator(nil)
-            case .logout:
-                self.navigationSplitCoordinator.setSheetCoordinator(nil)
-                self.callback?(.signOut)
-            case .clearCache:
-                self.callback?(.clearCache)
+        
+        settingsScreenCoordinator.actions
+            .sink { [weak self] action in
+                guard let self else { return }
+                
+                switch action {
+                case .dismiss:
+                    navigationSplitCoordinator.setSheetCoordinator(nil)
+                case .logout:
+                    navigationSplitCoordinator.setSheetCoordinator(nil)
+                    actionsSubject.send(.signOut)
+                case .clearCache:
+                    actionsSubject.send(.clearCache)
+                }
            }
-        }
+            .store(in: &cancellables)
        
        settingsNavigationStackCoordinator.setRootCoordinator(settingsScreenCoordinator, animated: animated)
        
@@ -355,9 +364,16 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
        
        let coordinator = SessionVerificationScreenCoordinator(parameters: parameters)
        
-        coordinator.callback = { [weak self] in
-            self?.navigationSplitCoordinator.setSheetCoordinator(nil)
-        }
+        coordinator.actions
+            .sink { [weak self] action in
+                guard let self else { return }
+                
+                switch action {
+                case .done:
+                    navigationSplitCoordinator.setSheetCoordinator(nil)
+                }
+            }
+            .store(in: &cancellables)
        
        navigationSplitCoordinator.setSheetCoordinator(coordinator, animated: animated) { [weak self] in
            self?.stateMachine.processEvent(.dismissedSessionVerificationScreen)