Detect when an app is running in the background or foreground

Swift version: 5.10

Detecting whether your app is in the foreground or background is useful for managing resources, pausing tasks, or updating UI elements only when the app is active. iOS provides lifecycle notifications to track these state changes.

Prerequisites

To monitor the app’s state, you need to:

1. Use UIApplication lifecycle notifications.

2. Implement scene lifecycle methods (for iOS 13+).

3. Detect the app’s state directly using UIApplication.shared.applicationState.

Method 1: Using UIApplication Lifecycle Notifications

You can use NSNotificationCenter to observe when your app moves between foreground and background.

Copied!import UIKit

class AppStateObserver {
    static let shared = AppStateObserver()
    
    func startObserving() {
        NotificationCenter.default.addObserver(self, selector: #selector(appDidEnterBackground), name: UIApplication.didEnterBackgroundNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(appWillEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(appDidBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(appWillResignActive), name: UIApplication.willResignActiveNotification, object: nil)
    }
    
    @objc func appDidEnterBackground() {
        print("App moved to background")
    }
    
    @objc func appWillEnterForeground() {
        print("App will enter foreground")
    }
    
    @objc func appDidBecomeActive() {
        print("App became active")
    }
    
    @objc func appWillResignActive() {
        print("App will resign active (e.g., user pressed Home button)")
    }
}
import UIKit

class AppStateObserver {
    static let shared = AppStateObserver()
    
    func startObserving() {
        NotificationCenter.default.addObserver(self, selector: #selector(appDidEnterBackground), name: UIApplication.didEnterBackgroundNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(appWillEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(appDidBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(appWillResignActive), name: UIApplication.willResignActiveNotification, object: nil)
    }
    
    @objc func appDidEnterBackground() {
        print("App moved to background")
    }
    
    @objc func appWillEnterForeground() {
        print("App will enter foreground")
    }
    
    @objc func appDidBecomeActive() {
        print("App became active")
    }
    
    @objc func appWillResignActive() {
        print("App will resign active (e.g., user pressed Home button)")
    }
}

How it works:

• didEnterBackgroundNotification fires when the app moves to the background.

• willEnterForegroundNotification fires just before the app returns to the foreground.

• didBecomeActiveNotification fires when the app is fully active.

• willResignActiveNotification fires when the app is about to go inactive (e.g., when receiving a phone call).

📌 Call AppStateObserver.shared.startObserving() inside your AppDelegate or SceneDelegate to start monitoring.

Method 2: Using Scene Lifecycle Methods (iOS 13+)

For apps using the SceneDelegate, you can track foreground and background states at the scene level.

Implementation in SceneDelegate.swift:

Copied!func sceneWillEnterForeground(_ scene: UIScene) {
    print("Scene will enter foreground")
}

func sceneDidEnterBackground(_ scene: UIScene) {
    print("Scene entered background")
}

func sceneDidBecomeActive(_ scene: UIScene) {
    print("Scene became active")
}

func sceneWillResignActive(_ scene: UIScene) {
    print("Scene will resign active")
}
func sceneWillEnterForeground(_ scene: UIScene) {
    print("Scene will enter foreground")
}

func sceneDidEnterBackground(_ scene: UIScene) {
    print("Scene entered background")
}

func sceneDidBecomeActive(_ scene: UIScene) {
    print("Scene became active")
}

func sceneWillResignActive(_ scene: UIScene) {
    print("Scene will resign active")
}

How it works:

• sceneDidEnterBackground detects when a specific scene moves to the background.

• sceneWillEnterForeground detects when it returns.

• sceneDidBecomeActive detects when the scene is fully active.

• sceneWillResignActive fires when the scene is about to be paused.

✅ Use this approach if your app supports multiple scenes (iPads or iPhones with multitasking).

Method 3: Checking App State Directly

You can check the app’s current state anytime using UIApplication.shared.applicationState.

Example:

Copied!let state = UIApplication.shared.applicationState

switch state {
case .active:
    print("App is active")
case .background:
    print("App is in the background")
case .inactive:
    print("App is inactive (transitioning)")
@unknown default:
    print("Unknown state")
}
let state = UIApplication.shared.applicationState

switch state {
case .active:
    print("App is active")
case .background:
    print("App is in the background")
case .inactive:
    print("App is inactive (transitioning)")
@unknown default:
    print("Unknown state")
}

How it works:

• .active means the app is running in the foreground.

• .background means the app is fully in the background.

• .inactive means the app is in a transition state (e.g., when switching apps or receiving a call).

Conclusion

By using these techniques, you can accurately detect when your app is running in the foreground or background:

✅ Use UIApplication notifications for broad app-level state tracking.

✅ Use SceneDelegate methods for multi-scene-aware apps (iOS 13+).

✅ Directly check the app’s state with applicationState when needed.

---