SwiftUI: Detect NavigationView goes back to main view

Question

I have a NavigationView and the following view structure ViewA -> ViewB -> ViewC and I'm trying to figure out how to detect when ViewB goes back to ViewAViewB -> ViewA. Here is my Code:

struct ViewA: View {
    var body: some View {
        NavigationView {
            NavigationLink{
                ViewB()
            }label: {
                Text("Go to ViewB")
                
            }
        }
    }
}

struct ViewB: View {
    @Environment(\.presentationMode) var presentationMode: Binding
    var body: some View {
        NavigationLink{
            ViewC()
        }label: {
            Text("Go to ViewC")
        }
        .onAppear{
            print("onAppear \(presentationMode.wrappedValue.isPresented)")
        }
        .onDisappear{
            print("onDisappear \(presentationMode.wrappedValue.isPresented)")
        }
    }
}

struct ViewC: View {
    var body: some View {
        Text("ViewC")
    }
}

With the following code:

        .onAppear{
            print("onAppear \(presentationMode.wrappedValue.isPresented)")
        }
        .onDisappear{
            print("onDisappear \(presentationMode.wrappedValue.isPresented)")
        }

with the code above I can detect when ViewC goes ViewB (per console output onAppear true). But my question is how can detect when ViewB -> ViewA.

Any of you knows how can accomplish this or if there is a way around to detect this?

I'll really appreciate your help

why not do the same in `ViewA` as you do in `ViewB`. In `ViewA` add `.onAppear{ print("----> onAppear ViewA") }` and `.onDisappear{ print("----> onDisappear ViewA") }` The combination of disappearing from a view and appearing in another should give you a way to determine going from `ViewB` to `ViewA`. Note however, that `NavigationView` is deprecated and you should use `NavigationStack` that would make all this much easier. — workingdog support Ukraine, May 02 '23 at 03:44

score 1 · Answer 1 · answered May 04 '23 at 18:50

Here is a solution based on the new NavigationStack which lets you record the navigation path (as @workingdog mentioned):

struct ViewA: View {
    
    @State private var navigationPath: [String] = []
    
    var body: some View {
        NavigationStack(path: $navigationPath) {
            NavigationLink(value: "B") {
                Text("Go to ViewB")
            }
            .navigationDestination(for: String.self) { destination in
                if destination == "B" {
                    ViewB()
                } else {
                    ViewC()
                }
            }
        }
        .onChange(of: navigationPath) { newValue in
            print(newValue)
            if newValue == [] {
                print("Coming from ViewB to ViewA") // trigger your action here
            }
        }
    }
}

struct ViewB: View {

    var body: some View {
        NavigationLink(value: "C") {
            Text("Go to ViewC")
        }
    }
}

struct ViewC: View {
    
    var body: some View {
        Text("ViewC")
    }
}

B25Dec · Answer 2 · 2023-05-05T02:11:15.890

Though both of approaches are correct, mentioned by @ChrisR is also working well. If i was working on it i would have used environmentObject something like below approach. Hope it helps. Working well tested on Xcode 14.3

class NavigationLinkDestination: ObservableObject {
    @Published var currentView: String = ""
}

struct ContentView: View {
    @StateObject var navigationLinkDest = NavigationLinkDestination()
    var body: some View {
        NavigationView {
            NavigationLink{
                ViewB()
            }label: {
                Text("Go to ViewB").onAppear {
                    navigationLinkDest.currentView = "ViewA"
                    print("current view \(navigationLinkDest.currentView)")
                }
                
            }
        }.environmentObject(navigationLinkDest)
    }
}

struct ViewB: View {
    @EnvironmentObject var navigationLinkDest: NavigationLinkDestination
    var body: some View {
        NavigationLink{
            ViewC()
        }label: {
            Text("Go to ViewC").onAppear {
                navigationLinkDest.currentView = "View B"
                print("current view \(navigationLinkDest.currentView)")
            }
        }.environmentObject(navigationLinkDest)
    }
}


struct ViewC: View {
    @EnvironmentObject var navigationLinkDest: NavigationLinkDestination
    var body: some View {
        Text("ViewC").onAppear {
            navigationLinkDest.currentView = "View C"
            print(navigationLinkDest.currentView)
        }.environmentObject(navigationLinkDest)
    }
}

score 1 · Answer 3 · answered May 06 '23 at 05:32

If you want to keep using NavigationView for compatibility with iOS 15 and earlier, then you can reliably be notified when ViewB is popped by making the state of ViewA’s NavigationLink explicit.

You used the NavigationLink(destination:label:) initializer, which means the NavigationLink has a hidden flag that tracks whether it is active or not.

Instead, store that flag yourself, and use a custom Binding with the NavigationLink(isActive:destination:label:) initializer to be notified when the NavigationView activates or deactivates the link.

struct ViewA: View {
    @State var linkIsActive = false
    
    var body: some View {
        NavigationView {
            NavigationLink(isActive: Binding(
                get: { linkIsActive },
                set: {
                    if $0 != linkIsActive {
                        linkIsActive = $0
                        print($0 ? "pushing ViewB" : "popping ViewB")
                    }
                }
            )) {
                ViewB()
            } label: {
                Text("Go to ViewB")
            }
        }
        .navigationViewStyle(.stack)
    }
}

SwiftUI: Detect NavigationView goes back to main view

3 Answers3