esNetworkConnectivity = false request.requiresExternalPower = false do { try backgroundTaskScheduler.submit(request) } catch { print("Background task submission failed: (error)") } } }

### Step 3: Bridge UIKit and SwiftUI
Modern apps often mix frameworks. The coordinator must bridge `UIApplicationDelegate`, `UISceneDelegate`, and SwiftUI’s `scenePhase`.

```swift
// SwiftUI Scene Integration
struct AppScene: Scene {
    @Environment(\.scenePhase) private var phase
    @State private var coordinator = LifecycleCoordinator()
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(coordinator)
                .onChange(of: phase) { oldPhase, newPhase in
                    let state = switch newPhase {
                    case .background: .background
                    case .inactive: .inactive
                    case .active: .active
                    @unknown default: .active
                    }
                    Task { @MainActor in
                        coordinator.transition(to: state)
                    }
                }
        }
    }
}

// UIKit AppDelegate Bridge
@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    let coordinator = LifecycleCoordinator()
    
    func application(_ application: UIApplication, didChangeConnectivity connectivity: UIScene.Connection) {
        // Handle scene lifecycle if not using SwiftUI
    }
    
    func applicationDidEnterBackground(_ application: UIApplication) {
        Task { @MainActor in
            coordinator.transition(to: .background)
        }
    }
    
    func applicationDidBecomeActive(_ application: UIApplication) {
        Task { @MainActor in
            coordinator.transition(to: .active)
        }
    }
    
    func applicationWillTerminate(_ application: UIApplication) {
        Task { @MainActor in
            coordinator.transition(to: .terminating)
        }
    }
}

Step 4: Enforce Background Execution Boundaries

iOS grants ~30 seconds for background transitions. Use UIApplication.shared.beginBackgroundTask(expirationHandler:) judiciously, and prefer BGTaskScheduler for deferred work.

func performBackgroundCleanup() {
    var backgroundTask: UIBackgroundTaskIdentifier = .invalid
    
    backgroundTask = UIApplication.shared.beginBackgroundTask {
        // Expiration handler: must finish or app terminates
        UIApplication.shared.endBackgroundTask(backgroundTask)
        backgroundTask = .invalid
    }
    
    Task.detached {
        // Non-UI work: cache flush, analytics flush, DB vacuum
        await performCleanupOperations()
        
        await MainActor.run {
            if backgroundTask != .invalid {
                UIApplication.shared.endBackgroundTask(backgroundTask)
            }
        }
    }
}

Architecture Decisions

• Coordinator over Distributed Observers: Predictable state transitions, single cleanup point, testable via mock state injection.
• @Observable over @StateObject/@EnvironmentObject: iOS 17+ observation model reduces boilerplate and eliminates willSet/didSet race conditions.
• Explicit MainActor Boundaries: Lifecycle callbacks may fire on background threads. All UI/state mutations must be marshaled to @MainActor.
• State Preservation vs Caching: Use UIStateRestoring for UI state, UserDefaults/FileManager for configuration, and in-memory caches for transient data. Never conflate them.

Pitfall Guide

1. Assuming scenePhase == .active Guarantees Foreground Execution

   • Issue: .active includes picture-in-picture, split-view, and background audio contexts.
   • Fix: Cross-reference with UIApplication.shared.applicationState and scene activation state.

2. Blocking sceneWillResignActive with Synchronous Work

   • Issue: iOS suspends the app if the transition isn’t completed within ~4 seconds.
   • Fix: Dispatch heavy work to Task.detached and return immediately.

3. Ignoring Memory Warnings in Modern Apps

   • Issue: UIApplication.didReceiveMemoryWarningNotification is still fired, but many apps rely solely on ARC.
   • Fix: Implement explicit cache pruning and release non-critical image/data buffers.

4. Using UserDefaults for Complex State Restoration

   • Issue: Property list serialization fails for custom types, and sync writes block the main thread.
   • Fix: Use Codable + FileManager or NSKeyedArchiver for state restoration. Reserve UserDefaults for primitives.

5. Treating Background Time as Infinite

   • Issue: Background tasks are throttled, suspended, or terminated based on battery, thermal, and system load.
   • Fix: Use BGTaskScheduler for deferred work, implement expiration handlers, and design idempotent operations.

6. SwiftUI onChange Without State Deduplication

   • Issue: scenePhase may fire multiple times for the same logical state, triggering redundant work.
   • Fix: Compare oldPhase and newPhase, or use the coordinator’s state equality check.

7. Forgetting Multi-Scene State Divergence

   • Issue: iPadOS allows multiple scenes with independent lifecycles. Global singletons cause stale state.
   • Fix: Scope lifecycle state to UIScene or use scene-aware coordinators with unique identifiers.

Production Bundle

Action Checklist

• Replace scattered NotificationCenter observers with a centralized @Observable coordinator
• Map all lifecycle transitions and enforce state equality checks before execution
• Implement BGTaskScheduler for deferred background work; remove legacy beginBackgroundTask where possible
• Add memory warning handlers that prune caches without deallocating active sessions
• Bridge UIKit UIApplicationDelegate and SwiftUI scenePhase to the same coordinator
• Write unit tests that inject state transitions and verify observer callbacks
• Audit state restoration: separate UI state, configuration, and transient data

Decision Matrix

Configuration Template

import Foundation
import UIKit
import BackgroundTasks

@Observable
@MainActor
final class AppLifecycleManager {
    enum State: Equatable {
        case active, inactive, background, suspended, terminating
    }
    
    private(set) var currentState: State = .active
    private var handlers: [ObjectIdentifier: (State) -> Void] = [:]
    
    init() {
        setupSystemObservers()
        scheduleDeferredTasks()
    }
    
    func subscribe(_ object: AnyObject, _ handler: @escaping (State) -> Void) {
        handlers[ObjectIdentifier(object)] = handler
    }
    
    func unsubscribe(_ object: AnyObject) {
        handlers.removeValue(forKey: ObjectIdentifier(object))
    }
    
    func transition(to state: State) {
        guard currentState != state else { return }
        currentState = state
        handlers.values.forEach { $0(state) }
    }
    
    private func setupSystemObservers() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleMemoryWarning),
            name: UIApplication.didReceiveMemoryWarningNotification,
            object: nil
        )
    }
    
    @objc private func handleMemoryWarning() {
        // Implement cache pruning here
    }
    
    private func scheduleDeferredTasks() {
        let request = BGProcessingTaskRequest(identifier: "com.yourapp.lifecycle.cleanup")
        request.requiresNetworkConnectivity = false
        request.requiresExternalPower = false
        try? BGTaskScheduler.shared.submit(request)
    }
}

Quick Start Guide

1. Replace Delegate Sprawl: Create AppLifecycleManager and inject it via @Environment in SwiftUI or a shared instance in UIKit.
2. Wire System Callbacks: Map UIApplication and UIScene lifecycle methods to transition(to:) calls. Ensure all mutations occur on @MainActor.
3. Subscribe Critical Services: Attach network managers, cache layers, and analytics to the coordinator. Trigger cleanup on .background and .terminating.
4. Validate with State Injection: Write tests that call transition(to:) directly and assert service behavior. Simulate memory warnings and background expirations.
5. Audit Production Telemetry: Monitor crash reports for lifecycle-related EXC_BAD_ACCESS and background task timeouts. Iterate until metrics align with the State-Machine Coordinator benchmarks.

The iOS app lifecycle is not a setup phase. It is a runtime contract with the operating system. Treat it as a deterministic state machine, enforce execution boundaries, and centralize state transitions. The result is predictable behavior, lower crash rates, and apps that respect platform constraints rather than fight them.