Managing Your App's Life Cycle

Respond to system notifications when your app is in the foreground or background, and handle other significant system-related events.


The current state of your app determines what it can and cannot do at any time. For example, a foreground app has the user’s attention, so it has priority over system resources, including the CPU. By contrast, a background app must do as little work as possible, and preferably nothing, because it is offscreen. As your app changes from state to state, you must adjust its behavior accordingly.

When your app’s state changes, UIKit notifies you by calling methods of the appropriate delegate object:

  • In iOS 13 and later, use UISceneDelegate objects to respond to life-cycle events in a scene-based app.

  • In iOS 12 and earlier, use the UIApplicationDelegate object to respond to life-cycle events.

Respond to Scene-Based Life-Cycle Events

If your app supports scenes, UIKit delivers separate life-cycle events for each. A scene represents one instance of your app’s UI running on a device. The user can create multiple scenes for each app, and show and hide them separately. Because each scene has its own life cycle, each can be in a different state of execution. For example, one scene might be in the foreground while others are in the background or are suspended.

The following figure shows the state transitions for scenes. When the user or system requests a new scene for your app, UIKit creates it and puts it in the unattached state. User-requested scenes move quickly to the foreground, where they appear onscreen. A system-requested scene typically moves to the background so that it can process an event. For example, the system might launch the scene in the background to process a location event. When the user dismisses your app's UI, UIKit moves the associated scene to the background state and eventually to the suspended state. UIKit can disconnect a background or suspended scene at any time to reclaim its resources, returning that scene to the unattached state.

An illustration showing the state transitions for a scene-based app. Scenes start in the unattached state and move to the foreground-active or background state. The foreground-inactive state acts as a transition state.

Use scene transitions to perform the following tasks:

Respond to App-Based Life-Cycle Events

In iOS 12 and earlier, and in apps that don't support scenes, UIKit delivers all life-cycle events to the UIApplicationDelegate object. The app delegate manages all of your app’s windows, including those displayed on separate screens. As a result, app state transitions affect your app's entire UI, including content on external displays.

The following figure shows the state transitions involving the app delegate object. After launch, the system puts the app in the inactive or background state, depending on whether the UI is about to appear onscreen. When launching to the foreground, the system transitions the app to the active state automatically. After that, the state fluctuates between active and background until the app terminates.

An illustration showing the state transitions for an app without scenes. The app launches into the active or background state. An app transitions through the inactive state.

Use app transitions to perform the following tasks:

Respond to Other Significant Events

In addition to handling life-cycle events, apps must also be prepared to handle the events listed in the following table. Use your UIApplicationDelegate object to handle most of these events. In some cases, you may also be able to handle them using notifications, allowing you to respond from other parts of your app.

Memory warnings

Received when your app’s memory usage is too high. Reduce the amount of memory your app uses; see Responding to Memory Warnings.

Protected data becomes available/unavailable

Received when the user locks or unlocks their device. See applicationProtectedDataDidBecomeAvailable(_:) and applicationProtectedDataWillBecomeUnavailable(_:).

Handoff tasks

Received when an NSUserActivity object needs to be processed. See application(_:didUpdate:).

Time changes

Received for several different time changes, such as when the phone carrier sends a time update. See applicationSignificantTimeChange(_:).

Open URLs

Received when your app needs to open a resource. See application(_:open:options:).


Behavioral Events

Responding to Memory Warnings

Free up memory when asked to do so by the system.

See Also

Life Cycle

Responding to the Launch of Your App

Initialize your app’s data structures, prepare your app to run, and respond to any launch-time requests from the system.

class UIApplication

The centralized point of control and coordination for apps running in iOS.

protocol UIApplicationDelegate

A set of methods that you use to manage shared behaviors for your app.


Manage multiple instances of your app’s UI simultaneously, and direct resources to the appropriate instance of your UI.