App Lifecycle : qu'est-ce que c'est, états de l'application sous iOS et Android

Qu'est-ce qu'App Lifecycle ?

App Lifecycle est une machine à états finis qui décrit tous les états possibles d'une application mobile et les transitions entre eux. Chaque état détermine si l'application peut exécuter du code, afficher l'interface utilisateur et consommer des ressources. iOS et Android ont des modèles similaires mais non identiques — les différences proviennent de l'architecture du système d'exploitation : iOS utilise un contrôle strict de la mémoire (état suspended), tandis qu'Android utilise une gestion flexible des processus via onSaveInstanceState.

Sous iOS, le cycle de vie est étroitement lié au premier plan/arrière-plan : l'application est soit active, soit suspendue. Sous Android, le cycle de vie est plus granulaire — une Activity/Fenêtre passe par 6+ états, et le processus lui-même a un cycle de vie supplémentaire via ProcessLifecycleOwner. Les applications modernes (depuis 2024) utilisent de plus en plus des modèles d'architecture basés sur le cycle de vie : SwiftUI Lifecycle (iOS 16+) via l'environnement .scenePhase, Compose Lifecycle via LifecycleEventObserver. Ces modèles gèrent automatiquement les changements de contexte et préviennent les fuites mémoire. Selon Google, la gestion correcte du cycle de vie sous Android réduit la consommation mémoire de 30 à 40 % lors du travail en arrière-plan.

Cycle de vie iOS : AppDelegate et SceneDelegate

Sous iOS, le cycle de vie de l'application est géré via la classe UIApplicationDelegate (AppDelegate). Les principales méthodes : application(_:didFinishLaunchingWithOptions:) — initialisation au premier lancement ; applicationDidBecomeActive — l'application est visible et prête à interagir ; applicationWillResignActive — transition vers l'état inactif (appel entrant, fermeture du panneau de notifications) ; applicationDidEnterBackground — l'application est cachée, ~5 secondes pour sauvegarder les données ; applicationWillEnterForeground — retour de l'arrière-plan ; applicationWillTerminate — terminaison (appelée uniquement pour les anciennes applications sans suspended).

À partir d'iOS 13, Apple a introduit SceneDelegate (UISceneDelegate) pour prendre en charge les applications multi-fenêtres sur iPad et macOS Catalyst. SceneDelegate gère le cycle de vie de chaque scène (fenêtre) individuelle : scene(_:willConnectTo:options:) — création de la scène ; sceneDidBecomeActive — scène active ; sceneWillResignActive — scène perd le focus ; sceneDidEnterBackground — scène cachée. AppDelegate gère les événements globaux (chargement de données, notifications push), tandis que SceneDelegate gère l'état de l'interface utilisateur de chaque fenêtre. Dans SwiftUI, le cycle de vie est géré via la valeur d'environnement @Environment(\.scenePhase) : .active, .inactive, .background — cela fournit une API unifiée pour les applications SwiftUI et UIKit.

Cycle de vie Android : Application et ProcessLifecycleOwner

Sous Android, le cycle de vie commence avec la classe Application — un singleton créé avant toute Activity. La méthode Application.onCreate() est le premier point d'entrée, utilisée pour l'initialisation globale (Analytics, DI, Crash Reporting). Ensuite, l'Activity est lancée avec la séquence : onCreate() → onStart() → onResume(). Lors de la minimisation : onPause() → onStop() → onSaveInstanceState(). Lors de la destruction : onDestroy(). Au retour : onRestart() → onStart() → onResume().

ProcessLifecycleOwner (d'AndroidX Lifecycle 2.2+) suit le cycle de vie de l'ensemble du processus, pas d'une Activity individuelle. Il fournit deux états : ON_RESUME (application au premier plan) et ON_STOP (application cachée). ProcessLifecycleOwner résout le problème du « quand l'application est passée en arrière-plan » au niveau du processus — c'est essentiel pour les SDK, bibliothèques et applications modulaires. Dans Jetpack Compose, le cycle de vie est géré via LifecycleEventObserver et collectAsStateWithLifecycle, qui suspend automatiquement la collecte de données en mode arrière-plan. Android 14 (API 34) a ajouté une notification de cycle de vie du service de premier plan via Service.onTimeout — le service doit se terminer dans les 6 heures, sinon le système l'arrête de force.

Comparaison du cycle de vie iOS et Android

La principale différence : iOS force la transition de l'application vers Suspended (le code cesse de s'exécuter) 5 à 10 secondes après son entrée en arrière-plan. Android permet le travail en arrière-plan (services, WorkManager) pendant une période plus longue, mais avec les limitations du mode Doze (Android 6+) et des restrictions d'arrière-plan (Android 12+). ProcessLifecycleOwner sous Android est l'équivalent de UIApplicationDidEnterBackgroundNotification sous iOS, à la différence près qu'il se déclenche lors de toute transition vers l'arrière-plan, pas seulement après une perte de focus.

Exemples de code

iOS : AppDelegate avec méthodes de cycle de vie

Implémentation de base d'AppDelegate gérant tous les états du cycle de vie. Sauvegarde des données lors du passage en arrière-plan et mise à jour de l'interface utilisateur au retour.

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 est le point central du cycle de vie. applicationDidEnterBackground est une méthode critique : iOS donne ~5 secondes pour sauvegarder. applicationDidBecomeActive — mettez à jour l'interface utilisateur, redémarrez les animations. Pour SceneDelegate (iOS 13+), la logique du cycle de vie est répartie entre les scènes : sceneDidBecomeActive / sceneDidEnterBackground gèrent les fenêtres individuelles.

iOS : SceneDelegate (iOS 13+)

SceneDelegate pour les applications iPad multi-fenêtres. Chaque scène a son propre cycle de vie, indépendant des autres fenêtres.

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 gère le cycle de vie d'une scène individuelle. sceneDidBecomeActive / sceneDidEnterBackground sont les équivalents des méthodes AppDelegate pour une fenêtre spécifique. sceneDidDisconnect est appelé lorsqu'une scène se ferme (l'utilisateur a fermé une fenêtre sur iPad). Pour la compatibilité avec iOS 12 et versions antérieures, AppDelegate doit dupliquer la logique de SceneDelegate. Sous iOS 17+, vous pouvez utiliser @Observable pour suspendre/reprendre automatiquement les tâches en fonction de scenePhase.

Android : Application avec ProcessLifecycleOwner

ProcessLifecycleOwner suit quand l'application est au premier plan/arrière-plan au niveau du processus. C'est l'approche optimale pour la gestion globale du cycle de vie.

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 est la seule façon correcte de suivre la transition vers l'arrière-plan au niveau de l'application. ON_START se déclenche lorsque l'application devient visible (premier plan), ON_STOP — lorsqu'elle est complètement cachée (arrière-plan). Contrairement au cycle de vie d'Activity, ProcessLifecycleOwner n'est pas lié à un écran spécifique. Pour Jetpack Compose, utilisez LifecycleResumeEffect ou collectAsStateWithLifecycle au lieu d'une observation manuelle.

Android : Cycle de vie d'Activity avec ViewModel

ViewModel + Lifecycle est l'architecture Android correcte pour la gestion du cycle de vie. ViewModel est automatiquement nettoyé lors d'onDestroy, empêchant les fuites.

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 — libération des ressources")
    }
}

// Dans 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 — pause des animations")
    }

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

ViewModel survit à la rotation de l'écran et n'est détruit qu'à la fin de l'Activity. onCleared() est l'endroit pour libérer les ressources et se désabonner des flux. LiveData suspend automatiquement l'observation lors d'onPause et la reprend lors d'onResume — cela offre une protection contre les fuites et les crashs pendant le travail en arrière-plan. Dans Compose, utilisez collectAsStateWithLifecycle() dans le même but.