App Lifecycle: what it is, app states in iOS and Android

What is App Lifecycle?

App Lifecycle is a finite state machine that describes all possible states of a mobile application and the transitions between them. Each state determines whether the app can execute code, display UI, and consume resources. iOS and Android have similar but not identical models — the differences stem from OS architecture: iOS uses strict memory control (suspended state), while Android uses flexible process management through onSaveInstanceState.

In iOS, the lifecycle is tightly bound to foreground/background: the app is either active or suspended. In Android, the lifecycle is more granular — an Activity/Window goes through 6+ states, and the process itself has an additional lifecycle through ProcessLifecycleOwner. Modern applications (since 2024) increasingly use architecture patterns based on lifecycle: SwiftUI Lifecycle (iOS 16+) via .scenePhase environment, Compose Lifecycle via LifecycleEventObserver. These patterns automatically handle context switching and prevent memory leaks. According to Google, proper lifecycle handling in Android reduces memory consumption by 30–40 % during background work.

iOS Lifecycle: AppDelegate and SceneDelegate

In iOS, the app lifecycle is managed through the UIApplicationDelegate class (AppDelegate). The main methods: application(_:didFinishLaunchingWithOptions:) — initialization on first launch; applicationDidBecomeActive — the app is visible and ready for interaction; applicationWillResignActive — transitioning to inactive state (incoming call, closing the notification shade); applicationDidEnterBackground — the app is hidden, ~5 seconds to save data; applicationWillEnterForeground — returning from background; applicationWillTerminate — termination (called only for older apps without suspended).

Starting with iOS 13, Apple introduced SceneDelegate (UISceneDelegate) to support multi-window applications on iPad and macOS Catalyst. SceneDelegate manages the lifecycle of each individual scene (window): scene(_:willConnectTo:options:) — scene creation; sceneDidBecomeActive — scene is active; sceneWillResignActive — scene loses focus; sceneDidEnterBackground — scene is hidden. AppDelegate handles global events (data loading, push notifications), while SceneDelegate handles the UI state of each window. In SwiftUI, lifecycle is handled through the environment value @Environment(\.scenePhase): .active, .inactive, .background — this provides a unified API for both SwiftUI and UIKit applications.

Android Lifecycle: Application and ProcessLifecycleOwner

In Android, the lifecycle starts with the Application class — a singleton created before any Activity. The Application.onCreate() method is the first entry point, used for global initialization (Analytics, DI, Crash Reporting). After that, the Activity launches with the sequence: onCreate() → onStart() → onResume(). When minimized: onPause() → onStop() → onSaveInstanceState(). When destroyed: onDestroy(). When returning: onRestart() → onStart() → onResume().

ProcessLifecycleOwner (from AndroidX Lifecycle 2.2+) tracks the lifecycle of the entire process, not an individual Activity. It provides two states: ON_RESUME (app in foreground) and ON_STOP (app is hidden). ProcessLifecycleOwner solves the problem of "when did the app go to background" at the process level — this is critical for SDKs, libraries, and modular applications. In Jetpack Compose, lifecycle is managed through LifecycleEventObserver and collectAsStateWithLifecycle, which automatically suspends data collection in background mode. Android 14 (API 34) added foreground service lifecycle notification via Service.onTimeout — the service must complete within 6 hours, otherwise the system forcibly stops it.

iOS and Android Lifecycle Comparison

The main difference: iOS forcibly transitions the app to Suspended (code stops executing) 5-10 seconds after entering the background. Android allows background work (services, WorkManager) for a longer period, but with limitations from Doze Mode (Android 6+) and background restrictions (Android 12+). ProcessLifecycleOwner in Android is the equivalent of UIApplicationDidEnterBackgroundNotification in iOS, with the difference that it fires on any transition to background, not just after losing focus.

Code Examples

iOS: AppDelegate with Lifecycle Methods

A basic AppDelegate implementation handling all lifecycle states. Saving data when transitioning to background and updating UI when returning.

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        Analytics.shared.initialize()
        return true
    }

    func applicationDidBecomeActive(_ application: UIApplication) {
        NotificationCenter.default.post(name: .appDidBecomeActive, object: nil)
    }

    func applicationWillResignActive(_ application: UIApplication) {
        NotificationCenter.default.post(name: .appWillResignActive, object: nil)
    }

    func applicationDidEnterBackground(_ application: UIApplication) {
        CoreDataManager.shared.saveContext()
        UserDefaults.standard.synchronize()
    }

    func applicationWillEnterForeground(_ application: UIApplication) {
        NetworkManager.shared.refreshSession()
    }
}

AppDelegate is the central lifecycle point. applicationDidEnterBackground is a critical method: iOS gives ~5 seconds for saving. applicationDidBecomeActive — update UI, restart animations. For SceneDelegate (iOS 13+), lifecycle logic is distributed across scenes: sceneDidBecomeActive / sceneDidEnterBackground manage individual windows.

iOS: SceneDelegate (iOS 13+)

SceneDelegate for multi-window iPad applications. Each scene has its own lifecycle, independent of other windows.

import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(
        _ scene: UIScene,
        willConnectTo session: UISceneSession,
        options connectionOptions: UIScene.ConnectionOptions
    ) {
        guard let windowScene = (scene as? UIWindowScene) else { return }
        window = UIWindow(windowScene: windowScene)
        window?.rootViewController = ViewController()
        window?.makeKeyAndVisible()
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        PlayerManager.shared.resume()
    }

    func sceneDidEnterBackground(_ scene: UIScene) {
        PlayerManager.shared.pause()
        CoreDataManager.shared.saveContext()
    }

    func sceneDidDisconnect(_ scene: UIScene) {
        PlayerManager.shared.cleanup()
    }
}

SceneDelegate manages the lifecycle of an individual scene. sceneDidBecomeActive / sceneDidEnterBackground are the equivalents of AppDelegate methods for a specific window. sceneDidDisconnect is called when a scene closes (the user closed a window on iPad). For compatibility with iOS 12 and below, AppDelegate must duplicate SceneDelegate logic. In iOS 17+, you can use @Observable to automatically pause/resume tasks based on scenePhase.

Android: Application with ProcessLifecycleOwner

ProcessLifecycleOwner tracks when the app is in foreground/background at the process level. This is the optimal approach for global lifecycle management.

import android.app.Application
import androidx.lifecycle.ProcessLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent

class MainApplication : Application() {

    override fun onCreate() {
        super.onCreate()

        ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())
    }
}

class AppLifecycleObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onEnterForeground() {
        Analytics.shared.onForeground()
        NetworkMonitor.shared.start()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onEnterBackground() {
        Analytics.shared.onBackground()
        NetworkMonitor.shared.stop()
    }
}

ProcessLifecycleOwner is the only correct way to track the transition to background at the application level. ON_START fires when the app becomes visible (foreground), ON_STOP — when completely hidden (background). Unlike Activity lifecycle, ProcessLifecycleOwner is not tied to a specific screen. For Jetpack Compose, use LifecycleResumeEffect or collectAsStateWithLifecycle instead of manual observation.

Android: Activity Lifecycle with ViewModel

ViewModel + Lifecycle is the correct Android architecture for lifecycle management. ViewModel is automatically cleared on onDestroy, preventing leaks.

import androidx.lifecycle.ViewModel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData

class TimerViewModel : ViewModel() {

    private val _time = MutableLiveData<Long>()
    val time: LiveData<Long> = _time

    private var startTime = System.currentTimeMillis()

    init {
        updateTime()
    }

    private fun updateTime() {
        _time.value = System.currentTimeMillis() - startTime
    }

    override fun onCleared() {
        super.onCleared()
        Logger.d("ViewModel cleared — releasing resources")
    }
}

// In Activity
class TimerActivity : AppCompatActivity() {

    private val viewModel: TimerViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Logger.d("Activity created")
    }

    override fun onResume() {
        super.onResume()
        viewModel.time.observe(this) { Logger.d("Time: $it") }
    }

    override fun onPause() {
        super.onPause()
        Logger.d("Activity paused — pausing animations")
    }

    override fun onDestroy() {
        super.onDestroy()
        Logger.d("Activity destroyed — cleanup")
    }
}

ViewModel survives screen rotation and is only destroyed when the Activity finishes. onCleared() is the place to release resources and unsubscribe from streams. LiveData automatically pauses observation on onPause and resumes on onResume — this provides protection against leaks and crashes during background work. In Compose, use collectAsStateWithLifecycle() for the same purpose.