Mobile app lifecycle: background, suspension, process death and restore

HOW IT FITS TOGETHER

KEY TERMS

App vs scene lifecycle (iOS)

Since iOS 13 each scene (a window of your UI) has its own lifecycle: unattached, foreground inactive, foreground active, background, suspended. The app delegate still handles launch and process-level events. Building with the iOS 27 SDK makes the UIScene lifecycle mandatory; React Native 0.88 added single-scene SceneDelegate support for this.

Activity vs process lifecycle (Android)

Android never kills an activity to free memory; it kills the whole process. Kill priority follows process importance: foreground, visible, service, then cached processes, which are killed first and may already be frozen. ViewModels survive rotation, not process death.

System-initiated vs user-initiated dismissal

Saved instance state (rememberSaveable, SavedStateHandle) and iOS scene storage are restored after the system kills the app, because the user still expects to come back. After the user swipes the app away, force-stops it or presses Back to finish it, that state is discarded on purpose.

Saved state vs persistence

Saved state is for small, transient UI values: the selected ID, a query, a scroll position, an unfinished text field. It is serialized on the main thread into a Bundle, so large data belongs in a database or file. Rule of thumb: persist what the user would be angry to lose, save-state what they would be annoyed to re-navigate.

Background execution on iOS

Background time is a set of narrow grants: beginBackgroundTask to finish a critical task, BGAppRefreshTask and BGProcessingTask that the system schedules, BGContinuedProcessingTask (iOS 26) for user-started long work shown in a Live Activity, background URLSession for transfers, and silent pushes that Apple says not to send more than two or three times an hour.

Background execution on Android

WorkManager is the default for deferrable and guaranteed work. Foreground services need a declared type and a visible notification; apps targeting Android 15 get at most 6 hours per day for dataSync and mediaProcessing services. Most apps cannot start a foreground service from the background, with exemptions such as a high-priority FCM message.

React Native AppState

AppState reports active, background and, on iOS only, inactive; Android adds focus and blur events, and iOS adds memoryWarning. JS gets no event when the app is suspended or killed, and after process death the JS runtime, every store and the navigation stack start empty even if Android restores the native activity.

IN YOUR STACK

import { useEffect, useRef } from "react";
import { AppState } from "react-native";

export function useLifecycle(handlers: { onBackground: () => void; onForeground: () => void }) {
  const latest = useRef(handlers);
  latest.current = handlers;
  const wasBackgrounded = useRef(false);

  useEffect(() => {
    const sub = AppState.addEventListener("change", (next) => {
      if (next === "background") {
        wasBackgrounded.current = true;
        latest.current.onBackground(); // last reliable moment: no event fires on suspend or kill
      } else if (next === "active" && wasBackgrounded.current) {
        wasBackgrounded.current = false;
        latest.current.onForeground(); // reconnect, refetch, re-check auth
      }
      // "inactive" (iOS): Control Center, a call or the app switcher. Not a departure.
    });
    return () => sub.remove();
  }, []);
}

// useLifecycle({ onBackground: () => drafts.flushSync(), onForeground: () => queryClient.invalidateQueries() });

@main
struct NotesApp: App {
  @Environment(\.scenePhase) private var scenePhase
  @State private var store = DraftStore() // an @Observable model

  var body: some Scene {
    WindowGroup { RootView().environment(store) }
      .onChange(of: scenePhase) { _, phase in
        switch phase {
        case .active: store.resync()
        case .inactive: break // transient: Control Center, a call, the app switcher
        case .background: store.flushToDisk() // suspension follows silently
        @unknown default: break
        }
      }
  }
}

struct EditorView: View {
  // Per scene, restored by the system after the process is killed. Small values only.
  @SceneStorage("editor.noteID") private var noteID: String?
  @SceneStorage("editor.tab") private var tab = "body"

  var body: some View { NoteEditor(noteID: noteID, tab: $tab) }
}

// App-wide foreground/background, the native equivalent of AppState (lifecycle-process).
class AppVisibilityObserver(private val sync: SyncManager) : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) = sync.resume()       // first activity started
    override fun onStop(owner: LifecycleOwner) = sync.flushAndPause() // last activity stopped
}

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(AppVisibilityObserver(SyncManager(this)))
    }
}

// Screen-level: subscribe while visible, clean up on ON_STOP or when the composable leaves.
@Composable
fun LivePrices(feed: PriceFeed, viewModel: PricesViewModel) {
    LifecycleStartEffect(feed) {
        val subscription = feed.subscribe()
        onStopOrDispose { subscription.close() }
    }
    val prices by viewModel.prices.collectAsStateWithLifecycle() // pauses collection in background
    PriceList(prices)
}

class SearchViewModel(
    private val savedState: SavedStateHandle,
    private val repo: SearchRepository,
) : ViewModel() {
    // ViewModel survives rotation; SavedStateHandle also survives system-initiated process death.
    val query: StateFlow<String> = savedState.getStateFlow("query", "")

    val results: StateFlow<List<Hit>> = query
        .debounce(300)
        .mapLatest { repo.search(it) } // results are re-fetched, never saved in the Bundle
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())

    fun onQueryChange(q: String) { savedState["query"] = q }
}

@Composable
fun SearchScreen(vm: SearchViewModel) {
    val query by vm.query.collectAsStateWithLifecycle()
    val hits by vm.results.collectAsStateWithLifecycle()
    var filtersOpen by rememberSaveable { mutableStateOf(false) } // pure UI state
    val listState = rememberLazyListState() // saveable: scroll position comes back too

    SearchLayout(query, vm::onQueryChange, hits, filtersOpen, { filtersOpen = it }, listState)
}

import AsyncStorage from "@react-native-async-storage/async-storage";
import { NavigationContainer, type NavigationState } from "@react-navigation/native";
import { useEffect, useState } from "react";
import { Linking } from "react-native";
const KEY = "NAVIGATION_STATE_V1"; // bump when the route tree changes
export function Root() {
  const [ready, setReady] = useState(false);
  const [initialState, setInitialState] = useState<NavigationState | undefined>();

  useEffect(() => {
    const restore = async () => {
      if ((await Linking.getInitialURL()) != null) return; // a deep link wins over restore
      const saved = await AsyncStorage.getItem(KEY);
      if (saved) setInitialState(JSON.parse(saved));
    };
    restore().finally(() => setReady(true));
  }, []);

  if (!ready) return null; // keep the splash screen up meanwhile
  return (
    <NavigationContainer initialState={initialState} onStateChange={(s) => AsyncStorage.setItem(KEY, JSON.stringify(s))}>
      <RootStack />
    </NavigationContainer>
  );
}

WHEN TO REACH FOR WHAT

WHERE IT BITES

• Saving on terminate or onDestroy. Neither runs when the system kills a suspended or cached process; save when the app enters the background.
• Assuming React state survives because the app looked alive in the switcher. After process death a React Native app cold-starts with empty stores and the initial route.
• Keeping a WebSocket or timer as if it ran in the background. Both freeze on suspension; on foreground, reconnect and resync from a cursor rather than trusting the old connection.
• Putting large objects in saved state: it is serialized on the main thread into a Bundle held by the system, and oversized Bundles crash with TransactionTooLargeException.
• Restoring navigation into a screen whose data or auth is gone. Validate the session and refetch by ID before rendering restored screens.
• Testing only rotations and app switches. Process death needs an explicit test: Don't keep activities or adb shell am kill on Android; on iOS, send the app to the background, stop it from Xcode, then relaunch it.

WHEN IT BREAKS IN PRODUCTION

• Background sync stops or never runs
• Offline edits conflict or vanish on reconnect
• WebSockets disconnect, duplicate, or lose events
• Users get logged out at random

SOURCES

• Apple: Managing your app's life cycle (opens in new tab)Checked 2026-11-06
• Apple TN3187: Migrating to the UIKit scene-based life cycle (opens in new tab)Checked 2026-11-06
• React Native 0.88: SceneDelegate support (opens in new tab)Checked 2026-11-06
• Expo Router: Migrating from React Navigation (opens in new tab)Checked 2026-11-06
• Apple: Choosing background strategies for your app (opens in new tab)Checked 2026-11-06
• Android: The activity lifecycle (opens in new tab)Checked 2026-11-06
• Android: Processes and app lifecycle (opens in new tab)Checked 2026-11-06
• Android: Foreground service timeouts (opens in new tab)Checked 2026-11-06
• React Native: AppState (opens in new tab)Checked 2026-11-06