Navigation between flows

[kickitt]

Hi Ilia! Could u provide an example of using this framework when u have something like AuthFlow, PreloaderFlow and MainFlow where Main flow is a TabView with different NavigationStacks? TY

[ivkuznetsov]

Hi! For the basic auth flow you need to use a custom root coordinator which is observing the session. And use rootCoordinator.rootView in your main view.

final class RootCoordinator: CustomCoordinator {
    
    @DI.Static(DI.session) private var session
    
    enum Root {
        case login(LoginCoordinator = .init())
        case tabs(TabsCoordinator = .init())
    }
    
    @Published var root: Root?
    
    @ViewBuilder
    func destination() -> some View {
        switch root {
        case .login(let coordinator):
            coordinator.view(for: .login)
        case .tabs(let coordinator):
            coordinator.rootView
        default: EmptyView()
        }
    }
    
    init() {
        root = session.isLoggedIn ? .tabs() : .login()
        
        session.session.sink(retained: self) { [weak self] in
            guard let wSelf = self else { return }
            
            if wSelf.session.isLoggedIn {
                if case .login(_) = wSelf.root {
                    self?.root = .tabs()
                }
            } else {
                if case .tabs(_) = wSelf.root {
                    self?.root = .login()
                }
            }
        }
    }
}

In tabs coordinator you need to create a child coordinator for each tab.

final class TabsCoordinator: CustomCoordinator {
    
    let chats = CommonCoordinator()
    let explore = CommonCoordinator()
    let profile = CommonCoordinator()
    
    @Published var tab: Int
    
    func destination() -> some View {
        TabsContainerScreen(coordinator: self)
    }
    
    init() {
        tab = chats.hashValue
    }
}

and make a tabs view for this

struct TabsContainerScreen: View {
    
    @ObservedObject var coordinator: TabsCoordinator
    
    var body: some View {
        TabView(selection: $coordinator.tab) {
              coordinator.chats.view(for: .chats)
                   .tabItem { Image(.tabConversations) }
                   .tag(coordinator.chats.hashValue)
                    
               coordinator.explore.view(for: .explore)
                   .tabItem { Image(.explore) }
                   .tag(coordinator.explore.hashValue)
                    
               coordinator.profile.view(for: .profile)
                  .tabItem { Image(.profile) }
                  .tag(coordinator.profile.hashValue)
        }
    }.navigationViewStyle(.stack)
}

[kickitt]

Big thanks! What about if MVVM-C and i need to create the coordinator for each module? Should i describe all routes in some common coordinator or it will be ok to create a coordinator per module with routes that used from current module only?

[kickitt]

@ivkuznetsov any suggestions?^^

[kickitt]

In other words is it possible to present or push some *Coordinator from Custom or Navigation coordinator?

[ivkuznetsov]

You need to consider a NavigationCoordinator as UINavigationController with known screens. So single navigation coordinator can push only its own screens. You can try to make a child coordinator in navigation, but it will lead to NavigationStack inside a NavigationStack, which I guess won't work correctly.

You can present modally any screen or child coordinator if you add conforming to ModalCoordinator. It's assumed that the child coordinator will be a stored property of the Modals enum with default initialization.

Thus basic logic is that single flow is a NavigationCoordinator and Custom or Modal coordinators operate with flows.

final class CommonCoordinator: NavigationCoordinator, ModalCoordinator {
    
    enum Screen: ScreenProtocol {
        case navigationScreen
        case userDetailsScreen(User)
        case postDetailsScreen(Post)
    }
    
    func destination(for screen: Screen) -> some View {
        switch Screen {
        case .navigationScreen: SomeScreen()
        case .postDetailsScreen(let post): PostScreen(post: post)
        case .userDetailsScreen(let user): UserScreen(user: user)
        }
    }
    
    enum Modal: ModalProtocol {
        case modalScreen
        case modalNavigation(CommonCoordinator = .init())
    }
    
    func destination(for modal: Modal) -> some View {
        switch modal {
        case .modalScreen1:
        case .modalNavigation(let coordinator): coordinator.view(for: .navigationScreen)
        }
    }
}


coordinator.present(. modalNavigation())