Coordinator Pattern

Why Coordinators?

The Coordinator pattern centralizes navigation logic outside of view controllers and views. It provides a single source of truth for navigation flows, making apps easier to test and maintain.

Coordinator Protocol

Define a base protocol that all coordinators conform to.

protocol Coordinator: AnyObject {
    var childCoordinators: [Coordinator] { get set }
    func start()
}

extension Coordinator {
    func addChild(_ coordinator: Coordinator) {
        childCoordinators.append(coordinator)
    }
    
    func removeChild(_ coordinator: Coordinator) {
        childCoordinators = childCoordinators.filter { $0 !== coordinator }
    }
    
    func removeAllChildren() {
        childCoordinators.removeAll()
    }
}

App Coordinator

The root coordinator manages the main navigation and child coordinators.

class AppCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    var navigationController: UINavigationController
    
    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }
    
    func start() {
        showLogin()
    }
    
    func showLogin() {
        let loginCoordinator = LoginCoordinator()
        loginCoordinator.delegate = self
        addChild(loginCoordinator)
        loginCoordinator.start()
    }
    
    func showMainApp() {
        let mainCoordinator = MainTabCoordinator()
        addChild(mainCoordinator)
        mainCoordinator.start()
    }
}

extension AppCoordinator: LoginCoordinatorDelegate {
    func loginDidComplete() {
        removeAllChildren()
        showMainApp()
    }
}

Feature Coordinators

Each feature has its own coordinator managing its navigation flow with delegate callbacks to report completion.

Managing Child Coordinators

Child coordinators handle specific navigation flows within a feature. They report completion back to the parent via delegate pattern.

class ProfileCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    weak var delegate: ProfileCoordinatorDelegate?
    
    func start() {
        let profileVC = ProfileViewController()
        profileVC.onEditProfile = { [weak self] in self?.showEditProfile() }
        profileVC.onLogout = { [weak self] in self?.delegate?.profileDidLogout() }
    }
    
    func showEditProfile() {
        let editCoordinator = EditProfileCoordinator()
        editCoordinator.delegate = self
        addChild(editCoordinator)
        editCoordinator.start()
    }
}

extension ProfileCoordinator: EditProfileCoordinatorDelegate {
    func editDidComplete() { removeChild(self) }
}

Coordinator as ObservableObject

For SwiftUI, make coordinators ObservableObject to drive view state.

class ShopCoordinator: ObservableObject, Coordinator {
    var childCoordinators: [Coordinator] = []
    @Published var currentView: ShopView = .list
    
    enum ShopView: Hashable {
        case list, cart, checkout
    }
    
    func start() { currentView = .list }
    func showCart() { currentView = .cart }
    func showCheckout() { currentView = .checkout }
}

Using Coordinators in SwiftUI

Inject coordinators into the SwiftUI environment for navigation.

struct ShopView: View {
    @StateObject var coordinator = ShopCoordinator()
    
    var body: some View {
        NavigationStack {
            List {
                Button("View Cart") { coordinator.showCart() }
            }
            .navigationDestination(for: ShopCoordinator.ShopView.self) { view in
                switch view {
                case .cart: CartView()
                case .checkout: CheckoutView()
                case .list: EmptyView()
                }
            }
        }
        .environmentObject(coordinator)
    }
}

NavigationPath with Coordinators

Combine NavigationPath with coordinators for type-safe navigation.

class NavigationCoordinator: ObservableObject {
    var path = NavigationPath()
    
    func showDetail(id: String) {
        path.append(id)
    }
    
    func showSettings() {
        path.append(SettingsRoute())
    }
    
    func popToRoot() {
        path = NavigationPath()
    }
}

struct ContentView: View {
    @StateObject var coordinator = NavigationCoordinator()
    
    var body: some View {
        NavigationStack(path: $coordinator.path) {
            HomeView()
                .navigationDestination(for: String.self) { id in
                    DetailView(id: id)
                }
                .navigationDestination(for: SettingsRoute.self) { _ in
                    SettingsView()
                }
        }
        .environmentObject(coordinator)
    }
}

Sheet and FullScreenCover Coordination

Handle modal presentations through coordinators.

enum SheetType: Identifiable {
    case profile, settings, about
    var id: String { String(describing: self) }
}

class SheetCoordinator: ObservableObject {
    @Published var activeSheet: SheetType?
    @Published var activeFullScreenCover: SheetType?
    
    func showProfile() { activeSheet = .profile }
    func showSettings() { activeFullScreenCover = .settings }
    func dismiss() { activeSheet = nil; activeFullScreenCover = nil }
}

Coordinator Testing

Coordinators make navigation logic testable by mocking delegate callbacks.

class MockLoginCoordinatorDelegate: LoginCoordinatorDelegate {
    var loginCompleted = false
    func loginDidComplete() { loginCompleted = true }
}

func testLoginFlow() {
    let coordinator = LoginCoordinator()
    let delegate = MockLoginCoordinatorDelegate()
    coordinator.delegate = delegate
    coordinator.start()
    coordinator.loginButtonTapped()
    assert(delegate.loginCompleted)
}