SceneDelegate & Multi-Window

What Is a Scene?

A Scene represents a single instance of your app's UI, typically a window. iOS 13+ uses the scene architecture to support multiple windows on iPad and handle system-managed scene lifecycle.

Each scene has its own UISceneDelegate (or UIWindowSceneDelegate) that responds to lifecycle events specific to that window.

Scene Lifecycle Methods

The UIScene protocol provides these key methods:

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // Scene is about to connect
        // Set up the window and root view controller
        guard let windowScene = scene as? UIWindowScene else { return }
        let window = UIWindow(windowScene: windowScene)
        window.rootViewController = UIHostingController(rootView: ContentView())
        self.window = window
        window.makeKeyAndVisible()
    }
    
    func sceneDidBecomeActive(_ scene: UIScene) {
        // Scene became active (foreground)
    }
    
    func sceneWillResignActive(_ scene: UIScene) {
        // Scene will become inactive
    }
    
    func sceneDidEnterBackground(_ scene: UIScene) {
        // Scene entered background
    }
    
    func sceneWillEnterForeground(_ scene: UIScene) {
        // Scene will enter foreground from background
    }
}

SwiftUI Equivalents

In SwiftUI, you handle scene lifecycle through the App struct and environment:

@main
struct MyApp: App {
    @Environment(\.scenePhase) var scenePhase
    
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { _, phase in
            switch phase {
            case .active: handleActive()
            case .inactive: handleInactive()
            case .background: handleBackground()
            @unknown default: break
            }
        }
    }
    
    func handleActive() { /* scene became active */ }
    func handleInactive() { /* scene will resign active */ }
    func handleBackground() { /* scene entered background */ }
}

Scene Session

Each scene has a UISceneSession that holds persistent data for that scene. The system uses this to restore scenes after termination:

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options: UIScene.ConnectionOptions) {
    // session.stateRestorationActivity contains saved state
    if let activity = session.stateRestorationActivity {
        // Restore from activity
    }
}

In SwiftUI, WindowGroup handles state restoration automatically.

Enabling Multi-Window

iPad apps support multiple windows by default when using WindowGroup. To explicitly control this:

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup("Main") {
            ContentView()
        }
    }
}

To open a new window, the system provides the newWindowScene action:

struct ContentView: View {
    @Environment(\.openWindow) var openWindow
    
    var body: some View {
        Button("Open Settings Window") {
            openWindow(id: "settings")
        }
    }
}

Define the window group in your App struct:

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup("Main") {
            ContentView()
        }
        WindowGroup(id: "settings") {
            SettingsView()
        }
    }
}

Scene Phases on iPad

Each scene has its own phase. One scene can be active while another is in the background:

struct ContentView: View {
    @Environment(\.scenePhase) var scenePhase
    
    var body: some View {
        Text("This scene is \(scenePhase == .active ? "active" : "not active")")
    }
}

Handling Scene Destruction

The system can destroy scenes to free resources. The scene phase transitions to .background before destruction:

.onChange(of: scenePhase) { _, phase in
    if phase == .background {
        // Save scene-specific state before potential destruction
        saveSceneState()
    }
}

Scene-Level Configuration

Each scene can have different configurations:

var body: some Scene {
    WindowGroup("Document") {
        DocumentEditor()
    }
    .defaultSize(width: 800, height: 600)
    .windowResizability(.contentSize)
    
    WindowGroup("Inspector") {
        InspectorView()
    }
    .defaultSize(width: 300, height: 400)
}

Universal Apps

For apps that run on both iPhone and iPad:

#if os(iOS)
// iOS-specific scene configuration
#elseif os(macOS)
// macOS-specific scene configuration
#endif

Multi-window is primarily an iPad feature. iPhone apps have a single scene managed by the system.

Scene Phase Values

SwiftUI defines three scene phase values:

• .active - The scene is in the foreground and receiving user interaction
• .inactive - The scene is in the foreground but not receiving events (transitional state)
• .background - The scene is in the background, not visible to the user

Responding to Phase Changes

@main
struct MyApp: App {
    @Environment(\.scenePhase) var scenePhase
    
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { _, newPhase in
            switch newPhase {
            case .active:
                resumeTimers()
                refreshContent()
            case .inactive:
                pauseTimers()
                saveDraft()
            case .background:
                saveAllState()
                releaseHeavyResources()
            @unknown default:
                break
            }
        }
    }
}

Per-Scene Phase Observation

Each WindowGroup has its own scene phase. Multiple windows can be in different phases simultaneously:

struct MyScene: Scene {
    var body: some Scene {
        WindowGroup("Window 1") {
            ContentView()
        }
        .onChange(of: scenePhase) { _, phase in
            // Only affects Window 1
        }
    }
}

Practical Patterns

Auto-save on background:

.onChange(of: scenePhase) { _, phase in
    if phase == .background {
        modelContext.save()
    }
}

Resume animations when active:

@State private var isAnimating = false

.onChange(of: scenePhase) { _, phase in
    if phase == .active {
        withAnimation { isAnimating = true }
    } else {
        isAnimating = false
    }
}

Connect to services when active:

.onChange(of: scenePhase) { _, phase in
    if phase == .active {
        connectWebSocket()
    } else if phase == .background {
        disconnectWebSocket()
    }
}

Inactive State

The inactive state is brief and transitional. Common triggers include:

• Incoming phone call
• Siri activation
• App switcher gesture
• Notification banner overlay

Do not perform heavy work in the inactive state. Use it to pause ongoing operations that should not continue in the background.