.NET MAUI App Lifecycle

App states

A MAUI app moves through four logical states:

State Meaning

Not Running App process does not exist.

Running App is in the foreground and receiving input.

Deactivated App is visible but lost focus (e.g. a dialog or split-screen).

Stopped App is fully backgrounded; UI is not visible.

Typical flow: Not Running → Running → Deactivated → Stopped → Running (resumed) or Not Running (terminated).

Cross-platform Window events

Microsoft.Maui.Controls.Window exposes six lifecycle events:

Event When it fires

Created

Window has been created (native window allocated).

Activated

Window has been activated and is receiving input.

Deactivated

Window lost focus but may still be visible.

Stopped

Window is no longer visible (backgrounded).

Resumed

Window returns to the foreground after being stopped.

Destroying

Window is being torn down (native window deallocated).

Important: Resumed never fires on the app's first launch. It only fires when returning from the Stopped state.

Subscribing to Window events

Option A – Override CreateWindow in App

public partial class App : Application { protected override Window CreateWindow(IActivationState? activationState) { var window = base.CreateWindow(activationState);

    window.Created += (s, e) => Log("Window Created");
    window.Activated += (s, e) => Log("Window Activated");
    window.Deactivated += (s, e) => Log("Window Deactivated");
    window.Stopped += (s, e) => Log("Window Stopped");
    window.Resumed += (s, e) => Log("Window Resumed");
    window.Destroying += (s, e) => Log("Window Destroying");

    return window;
}

}

Option B – Custom Window subclass with overrides

public class AppWindow : Window { public AppWindow() : base() { } public AppWindow(Page page) : base(page) { }

protected override void OnCreated() { /* init work */ }
protected override void OnActivated() { /* refresh UI */ }
protected override void OnDeactivated() { /* pause timers */ }
protected override void OnStopped() { /* save state */ }
protected override void OnResumed() { /* restore state */ }
protected override void OnDestroying() { /* cleanup */ }

}

Return it from CreateWindow :

protected override Window CreateWindow(IActivationState? activationState) { return new AppWindow(new AppShell()); }

Platform lifecycle event mapping

Android

Window event Android Activity callback

Created OnCreate

Activated OnResume

Deactivated OnPause

Stopped OnStop

Resumed OnRestart → OnStart → OnResume

Destroying OnDestroy

iOS / Mac Catalyst

Window event UIKit callback

Created WillFinishLaunching / SceneWillConnect

Activated DidBecomeActive

Deactivated WillResignActive

Stopped DidEnterBackground

Resumed WillEnterForeground

Destroying WillTerminate

Windows (WinUI)

Window event WinUI callback

Created OnLaunched

Activated Activated (foreground)

Deactivated Activated (background)

Stopped VisibilityChanged (false)

Resumed VisibilityChanged (true)

Destroying Closed

Platform-specific lifecycle events

Use ConfigureLifecycleEvents in MauiProgram.cs to hook directly into native callbacks:

builder.ConfigureLifecycleEvents(events => { #if ANDROID events.AddAndroid(android => android .OnCreate((activity, bundle) => Log("Android OnCreate")) .OnStart(activity => Log("Android OnStart")) .OnResume(activity => Log("Android OnResume")) .OnPause(activity => Log("Android OnPause")) .OnStop(activity => Log("Android OnStop")) .OnDestroy(activity => Log("Android OnDestroy"))); #elif IOS || MACCATALYST events.AddiOS(ios => ios .WillFinishLaunching((app, options) => { Log("iOS WillFinishLaunching"); return true; }) .SceneWillConnect((scene, session, options) => Log("iOS SceneWillConnect")) .DidBecomeActive(app => Log("iOS DidBecomeActive")) .WillResignActive(app => Log("iOS WillResignActive")) .DidEnterBackground(app => Log("iOS DidEnterBackground")) .WillTerminate(app => Log("iOS WillTerminate"))); #elif WINDOWS events.AddWindows(windows => windows .OnLaunched((app, args) => Log("Windows OnLaunched")) .OnActivated((window, args) => Log("Windows Activated")) .OnClosed((window, args) => Log("Windows Closed"))); #endif });

State preservation pattern

Save and restore transient state during backgrounding:

protected override void OnStopped() { base.OnStopped(); Preferences.Set("draft_text", _viewModel.DraftText); Preferences.Set("scroll_position", _viewModel.ScrollY); }

protected override void OnResumed() { base.OnResumed(); _viewModel.DraftText = Preferences.Get("draft_text", string.Empty); _viewModel.ScrollY = Preferences.Get("scroll_position", 0.0); }

For larger state, use SecureStorage or file-based serialization instead of Preferences .

Key behavioural notes

• Resumed ≠ first launch. Resumed only fires when returning from Stopped . On first launch the sequence is Created → Activated .

• Deactivated ≠ Stopped. A dialog or split-screen triggers Deactivated without Stopped .

• Android back button may call Destroying without Stopped if the activity finishes.

• iOS scene lifecycle is used on iOS 13+; older delegate methods are still forwarded.

• Multiple windows (iPad, Mac Catalyst, desktop Windows): each Window instance fires its own events independently.

• Keep lifecycle handlers fast. Long-running work should use Task.Run or background services to avoid ANR/watchdog kills.