Not receive onDisappear event on the first WindowGroup

Another way to test this issue is just use the Official "Hello World" example. I just add onDisappear to the first window.

   WindowGroup("Hello World", id: "modules") {
            Modules()
                .environment(model)
                .onDisappear(){
                    print("Hello World Window On Disappear")
                }
        }
        .windowStyle(.plain)

Run the demo and open either immersive space, then tap the close X button below the Hello World window. And no onDisappear event called.

Hi @wangdinglu ,

This is interesting behavior. What's happening here is that you're not seeing the onDisappear of the last window to be closed. I'll attach some code here and you can play around with it. It's not the first window to be launched by the app that doesn't receive the closure, it's the last window to be closed by the user.

Try opening all 3 and then closing b and then a and then c. You'll notice that "a" does print a disappearing message since it's not the last window to be closed, but "c" won't.

I believe this is happening due to then app becoming inactive and then backgrounded when the last window is closed, so it doesn't print to the console when you'd expect it to. You can monitor this with scenePhase as I show in my code. You can monitor when the entire app becomes backgrounded, which you'd then know that you closed the final window.

import SwiftUI

@main
struct OnDisappearTestApp: App {
    @Environment(\.openWindow) private var openWindow
    @Environment(\.scenePhase) private var scenePhase
    
    var body: some Scene {
        WindowGroup(id: "a") {
            VStack {
                Text("a")
                Button("open b"){
                    openWindow(id: "b")
                }
                Button("open c"){
                    openWindow(id: "c")
                }
            }
            .onDisappear {
                print("a disappear")
            }
            .onAppear {
                print("a appear")
            }
        }
        
        
        WindowGroup(id: "b") {
            Text("b")
                .onAppear {
                    print("b appear")
                }
                .onDisappear {
                    print("b disappear")
                }
        }
        
        WindowGroup(id: "c") {
            Text("c")
                .onAppear {
                    print("c appear")
                }
                .onDisappear {
                    print("c disappear")
                }
        }
        
        .onChange(of: scenePhase) { _, phase in
            switch phase {
            case .active:
                print("active")
            case .inactive:
                print("inactive")
            case .background:
                print("background -> a/b/c disappeared")
            @unknown default:
                print("unknown default")
            }
        }
    }
}

@wangdinglu , try also putting scenePhase in the view you want to check the phase of.

scenePhase gives you different values depending on where you read it from. The app level is an aggregate of the phases of the windows of your app.

If you put it in the view, it reports the phase of the view.

For instance, if you have a ContentView and an ImmersiveSpace, and with the ImmersiveSpace open you want to see when ContentView is closed (and it's the only window open), scenePhase in ContentView would tell you when that window was closed.

Hi, useful answers here but I still have some difficulty to understand the logic behind these behaviors

Why when we put onDisappear on the ContentView , this handler/modifier is not called ?

Regards

The accepted answer works, but it seems like the view does not really get de-initialized, leading to memory leaks.

There is a workaround to listen to the scenePhase changes as suggested and call dismissWindow(id: "Your-Window-Id"). Then onDisappear will be called as well and the view is de-initialized correctly.

            .onDisappear {
                // ...
            }
            .onChange(of: scenePhase) { oldValue, newValue in
                if newValue == .background {
                    dismissWindow(id: "Your-Window-Id")
                }
            }

Is there already a feedback for this or a fix planned @Vision Pro Engineer? Even though the workaround works, it still seems a bit odd.