Sebastien Lato

Posted on Dec 7

SwiftUI App Lifecycle Mastery — Scene Phases, Background Tasks & State

#architecture #lifecycle #concurrency #swiftui

Most SwiftUI tutorials ignore one of the most important parts of real production apps:

The app lifecycle.

When does your app save data?

When do background tasks run?

When should async work pause or cancel?

What happens when the user locks their device mid-request?

What if your view disappears while a task is running?

How do you prevent crashes during transitions?

This guide covers all the lifecycle patterns that production iOS apps need, using the modern SwiftUI APIs.

By the end, your app will be more stable, predictable, and senior-level engineered. 🚀

🧱 1. Understanding Scene Phases (Foreground, Background, Inactive)

SwiftUI exposes lifecycle events via:

@Environment(\.scenePhase) var scenePhase

Use it at the root of your app:

.onChange(of: scenePhase) { phase in
    switch phase {
    case .active:
        print("App in foreground")
    case .inactive:
        print("App inactive (interruptions, transitions)")
    case .background:
        print("App in background — save work ASAP")
    default:
        break
    }
}

When does each happen?

| Phase       | Meaning                                              |
|-------------|------------------------------------------------------|
| .active     | App is on screen and interactive                     |
| .inactive   | Transition moments (Siri, notifications, multitask)  |
| .background | App is off-screen; limited time to finish work       |

Rule:

📌 Save state on .background, resume work on .active.

💾 2. Automatically Save User Data on Background

Use scenePhase inside your app root:

@Environment(\.scenePhase) private var scenePhase
@StateObject private var store = AppStateStore()

var body: some Scene {
    WindowGroup {
        ContentView()
            .onChange(of: scenePhase) { phase in
                if phase == .background {
                    store.persist()
                }
            }
    }
}

Your app becomes resilient:

sudden quit
device lock
app switch
low-memory kill

No lost data.

🏎 3. Cancel Tasks When Views Disappear

SwiftUI .task blocks auto-cancel, but custom tasks do NOT unless you manage them.

Pattern:

var loadTask: Task<Void, Never>?

func load() {
    loadTask?.cancel()
    loadTask = Task {
        await fetchData()
    }
}

func onDisappear() {
    loadTask?.cancel()
}

Or inside a View:

.task {
    await vm.load()
}
.onDisappear {
    vm.cancelTasks()
}

Rule:
📌 Always cancel long tasks when the user navigates away.

🔄 4. Debounce App Resume Events

When the app becomes active, multiple "resume" triggers may fire.

Use a debounce:

@MainActor
func onResume() {
    resumeTask?.cancel()
    resumeTask = Task {
        try await Task.sleep(for: .milliseconds(120))
        await refreshData()
    }
}

Perfect for:

refreshing APIs
refreshing user permissions
refreshing sessions

💤 5. Background Refresh Tasks (Modern iOS API)

Schedule:

func scheduleBackgroundRefresh() {
    let request = BGAppRefreshTaskRequest(identifier: "app.refresh")
    request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
    try? BGTaskScheduler.shared.submit(request)
}

Handle:

BGTaskScheduler.shared.register(forTaskWithIdentifier: "app.refresh", using: nil) { task in
    Task {
        await refreshData()
        task.setTaskCompleted(success: true)
    }
}

Use this for:

syncing cloud data
refreshing cached content
lightweight periodic tasks

🧭 6. Lifecycle-Driven Navigation

If your app requires navigation based on lifecycle (ex: onboarding → login → home):

Create an AppState object:

@Observable
class AppState {
    enum Route { case onboarding, login, home }
    var route: Route = .onboarding
}

Use it at the root:

@Environment(AppState.self) var appState

switch appState.route {
case .onboarding: OnboardingView()
case .login: LoginView()
case .home: HomeView()
}

Update on lifecycle:

.onChange(of: scenePhase) { phase in
    if phase == .active {
        appState.route = auth.isLoggedIn ? .home : .login
    }
}

Your navigation becomes dynamic and centralized.

🧠 7. Handling Interruptions (Calls, Siri, Multitasking)

Use the inactive phase:

.onChange(of: scenePhase) { phase in
    if phase == .inactive {
        vm.pauseAudio()
    }
}

Or resume when active:

if phase == .active {
    vm.resumeAudioIfNeeded()
}

This makes your app feel native and polished.

🛑 8. Prevent Crashes During Transition

Never mutate state during a disappearing lifecycle event unless on main actor.

Correct:

.onDisappear {
    Task { @MainActor in
        vm.cleanUp()
    }
}

This avoids ViewModel updates while SwiftUI is tearing down the view hierarchy.

🚫 9. Don’t Start Heavy Work in Initializers

Wrong:

init() {
    Task { await load() }
}

Why?

ViewModels might be recreated unexpectedly
tasks cannot be cancelled
bad in previews + tests

Correct:

.task {
    await vm.load()
}

Let the View lifecycle own async work.

🧩 10. App Lifecycle + DI + Async = Clean Architecture

Here’s the modern architecture chain:

Scene Phase
    ↓ triggers
App State (global)
    ↓ configures
Dependency Injection (services)
    ↓ powers
ViewModels (async work)
    ↓ drives
Views (UI)

Lifecycle is not isolated — it binds your entire architecture together.

🚀 Final Thoughts

Mastering app lifecycle makes your SwiftUI apps:

stable
predictable
offline-safe
crash-resistant
background-friendly
professional
ready for real users

It’s one of the biggest differences between:

❌ a student project
and
✅ a production-grade iOS app.

DEV Community