App Lifecycle — Expert Decisions
Expert decision frameworks for app lifecycle choices. Claude knows scenePhase and SceneDelegate — this skill provides judgment calls for architecture decisions and background task trade-offs.
Decision Trees
Lifecycle API Selection
What's your project setup?
├─ Pure SwiftUI app (iOS 14+)
│ └─ @main App + scenePhase
│ Simplest approach, sufficient for most apps
│
├─ Need UIKit integration
│ └─ SceneDelegate + UIHostingController
│ Required for some third-party SDKs
│
├─ Need pre-launch setup
│ └─ AppDelegate + SceneDelegate
│ SDK initialization, remote notifications
│
└─ Legacy app (pre-iOS 13)
└─ AppDelegate only
window property on AppDelegate
The trap: Using SceneDelegate when pure SwiftUI suffices. scenePhase covers most use cases without the boilerplate.
Background Task Strategy
What work needs to happen in background?
├─ Quick save (< 5 seconds)
│ └─ UIApplication.beginBackgroundTask
│ Request extra time in sceneDidEnterBackground
│
├─ Network sync (< 30 seconds)
│ └─ BGAppRefreshTask
│ System schedules, best-effort timing
│
├─ Large download/upload
│ └─ Background URL Session
│ Continues even after app termination
│
├─ Location tracking
│ └─ Location background mode
│ Significant change or continuous
│
└─ Long processing (> 30 seconds)
└─ BGProcessingTask
Runs during charging, overnight
State Restoration Approach
What state needs restoration?
├─ Simple navigation state
│ └─ @SceneStorage
│ Per-scene, automatic, Codable types only
│
├─ Complex navigation + data
│ └─ @AppStorage + manual encoding
│ More control, cross-scene sharing
│
├─ UIKit-based navigation
│ └─ State restoration identifiers
│ encodeRestorableState/decodeRestorableState
│
└─ Don't need restoration
└─ Start fresh each launch
Some apps are better this way
Launch Optimization Priority
What's blocking your launch time?
├─ SDK initialization
│ └─ Defer non-critical SDKs
│ Analytics can wait, auth cannot
│
├─ Database loading
│ └─ Lazy loading + skeleton UI
│ Show UI immediately, load data async
│
├─ Network requests
│ └─ Cache + background refresh
│ Never block launch for network
│
└─ Asset loading
└─ Progressive loading
Load visible content first
NEVER Do
Launch Time
NEVER block main thread during launch:
// ❌ UI frozen until network completes
func application(_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
let data = try! Data(contentsOf: remoteURL) // Synchronous network!
processData(data)
return true
}
// ✅ Defer non-critical work
func application(_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
setupCriticalServices() // Auth, crash reporting
Task.detached(priority: .background) {
await self.setupNonCriticalServices() // Analytics, prefetch
}
return true
}
NEVER initialize all SDKs synchronously:
// ❌ Each SDK adds to launch time
func application(...) -> Bool {
AnalyticsSDK.initialize() // 100ms
CrashReporterSDK.initialize() // 50ms
FeatureFlagsSDK.initialize() // 200ms
SocialSDK.initialize() // 150ms
// Total: 500ms added to launch!
return true
}
// ✅ Prioritize and defer
func application(...) -> Bool {
CrashReporterSDK.initialize() // Critical — catches launch crashes
DispatchQueue.main.async {
AnalyticsSDK.initialize() // Can wait one runloop
}
Task.detached(priority: .utility) {
FeatureFlagsSDK.initialize()
SocialSDK.initialize()
}
return true
}
Background Tasks
NEVER assume background time is guaranteed:
// ❌ May not complete — iOS can terminate anytime
func sceneDidEnterBackground(_ scene: UIScene) {
performLongSync() // No protection!
}
// ✅ Request background time and handle expiration
func sceneDidEnterBackground(_ scene: UIScene) {
var taskId: UIBackgroundTaskIdentifier = .invalid
taskId = UIApplication.shared.beginBackgroundTask {
// Expiration handler — save partial progress
savePartialProgress()
UIApplication.shared.endBackgroundTask(taskId)
}
Task {
await performSync()
UIApplication.shared.endBackgroundTask(taskId)
}
}
NEVER forget to end background tasks:
// ❌ Leaks background task — iOS may terminate app
func saveData() {
let taskId = UIApplication.shared.beginBackgroundTask { }
saveToDatabase()
// Missing: endBackgroundTask!
}
// ✅ Always end in both success and failure
func saveData() {
var taskId: UIBackgroundTaskIdentifier = .invalid
taskId = UIApplication.shared.beginBackgroundTask {
UIApplication.shared.endBackgroundTask(taskId)
}
defer { UIApplication.shared.endBackgroundTask(taskId) }
do {
try saveToDatabase()
} catch {
Logger.app.error("Save failed: \(error)")
}
}
State Transitions
NEVER trust applicationWillTerminate to be called:
// ❌ May never be called — iOS can kill app without notice
func applicationWillTerminate(_ application: UIApplication) {
saveCriticalData() // Not guaranteed to run!
}
// ✅ Save on every background transition
func sceneDidEnterBackground(_ scene: UIScene) {
saveCriticalData() // Called reliably
}
// Also save periodically during use
Timer.scheduledTimer(withTimeInterval: 60, repeats: true) { _ in
saveApplicationState()
}
NEVER do heavy work in sceneWillResignActive:
// ❌ Blocks app switcher animation
func sceneWillResignActive(_ scene: UIScene) {
generateThumbnails() // Visible lag in app switcher
syncToServer() // Delays user
}
// ✅ Only pause essential operations
func sceneWillResignActive(_ scene: UIScene) {
pauseVideoPlayback()
pauseAnimations()
// Heavy work goes in sceneDidEnterBackground
}
Scene Lifecycle
NEVER confuse scene disconnect with app termination:
// ❌ Wrong assumption
func sceneDidDisconnect(_ scene: UIScene) {
// App is terminating! <- WRONG
cleanupEverything()
}
// ✅ Scene disconnect means scene released, not app death
func sceneDidDisconnect(_ scene: UIScene) {
// Scene being released — save per-scene state
// App may continue running with other scenes
// Or system may reconnect this scene later
saveSceneState(scene)
}
Essential Patterns
SwiftUI Lifecycle Handler
@main
struct MyApp: App {
@Environment(\.scenePhase) private var scenePhase
@StateObject private var appState = AppState()
var body: some Scene {
WindowGroup {
ContentView()
.environmentObject(appState)
}
.onChange(of: scenePhase) { oldPhase, newPhase in
handlePhaseChange(from: oldPhase, to: newPhase)
}
}
private func handlePhaseChange(from old: ScenePhase, to new: ScenePhase) {
switch (old, new) {
case (_, .active):
appState.refreshDataIfStale()
case (.active, .inactive):
// Transitioning away — pause but don't save yet
appState.pauseActiveOperations()
case (_, .background):
appState.saveState()
scheduleBackgroundRefresh()
default:
break
}
}
}
Background Task Manager
final class BackgroundTaskManager {
static let shared = BackgroundTaskManager()
func registerTasks() {
BGTaskScheduler.shared.register(
forTaskWithIdentifier: "com.app.refresh",
using: nil
) { task in
self.handleAppRefresh(task as! BGAppRefreshTask)
}
BGTaskScheduler.shared.register(
forTaskWithIdentifier: "com.app.processing",
using: nil
) { task in
self.handleProcessing(task as! BGProcessingTask)
}
}
func scheduleRefresh() {
let request = BGAppRefreshTaskRequest(identifier: "com.app.refresh")
request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
try? BGTaskScheduler.shared.submit(request)
}
private func handleAppRefresh(_ task: BGAppRefreshTask) {
scheduleRefresh() // Schedule next refresh
let refreshTask = Task {
await performRefresh()
}
task.expirationHandler = {
refreshTask.cancel()
}
Task {
await refreshTask.value
task.setTaskCompleted(success: true)
}
}
}
Launch Time Optimization
@main
class AppDelegate: UIResponder, UIApplicationDelegate {
private var launchStartTime: CFAbsoluteTime = 0
func application(_ application: UIApplication,
willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
launchStartTime = CFAbsoluteTimeGetCurrent()
// Phase 1: Absolute minimum (crash reporting)
CrashReporter.initialize()
return true
}
func application(_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
// Phase 2: Required for first frame
configureAppearance()
// Phase 3: Deferred to after first frame
DispatchQueue.main.async {
self.completePostLaunchSetup()
let launchTime = CFAbsoluteTimeGetCurrent() - self.launchStartTime
Logger.app.info("Launch completed in \(launchTime)s")
}
return true
}
private func completePostLaunchSetup() {
// Analytics, feature flags, etc.
Task.detached(priority: .utility) {
Analytics.initialize()
FeatureFlags.refresh()
}
}
}
Quick Reference
Lifecycle Events Order
| Event | When | Use For | |-------|------|---------| | willFinishLaunching | Before UI | Crash reporting only | | didFinishLaunching | UI ready | Critical setup | | sceneWillEnterForeground | Coming to front | Undo background changes | | sceneDidBecomeActive | Fully active | Refresh, restart tasks | | sceneWillResignActive | Losing focus | Pause playback | | sceneDidEnterBackground | In background | Save state, start bg task | | sceneDidDisconnect | Scene released | Save scene state |
Background Task Limits
| Task Type | Time Limit | When Runs | |-----------|-----------|-----------| | beginBackgroundTask | ~30 seconds | Immediately | | BGAppRefreshTask | ~30 seconds | System discretion | | BGProcessingTask | Minutes | Charging, overnight | | Background URL Session | Unlimited | System managed |
State Restoration Options
| Approach | Scope | Types | Auto-save | |----------|-------|-------|-----------| | @SceneStorage | Per-scene | Codable | Yes | | @AppStorage | App-wide | Primitives | Yes | | Restoration ID | Per-VC | Custom | Manual |
Red Flags
| Smell | Problem | Fix | |-------|---------|-----| | Sync network in launch | Blocked UI | Async + skeleton UI | | All SDKs in didFinish | Slow launch | Prioritize + defer | | No beginBackgroundTask | Work may not complete | Always request time | | Missing endBackgroundTask | Leaked task | Use defer | | Heavy work in willResignActive | Laggy app switcher | Move to didEnterBackground | | Trust applicationWillTerminate | May not be called | Save on background | | Confuse sceneDidDisconnect | Scene != app termination | Save scene state only |