Cycle de vie dans le développement mobile : définition, étapes et fonctionnement

Cycle de vie de l'application (App Lifecycle)

Avant d'aborder le cycle de vie des écrans individuels, il est important de comprendre le cycle de vie de l'ensemble de l'application. Dans iOS, l'application passe par cinq états : Not Running (non exécutée), Inactive (en arrière-plan, ne reçoit pas d'événements), Active (active), Background (en arrière-plan, code en cours d'exécution) et Suspended (en arrière-plan, code suspendu). Ces états sont gérés dans AppDelegate via les méthodes applicationDidFinishLaunching, applicationDidBecomeActive, applicationWillResignActive, applicationDidEnterBackground et applicationWillTerminate.

Dans Android, l'équivalent est le Application Lifecycle, suivi via l'interface Application.ActivityLifecycleCallbacks. Cependant, Android se concentre davantage sur le cycle de vie d'une Activity — un écran individuel de l'application. En effet, une application Android peut être composée de plusieurs Activities, chacune avec son propre cycle.

L'approche moderne dans Android est d'utiliser ProcessLifecycleOwner de la bibliothèque lifecycle-process. Il permet de suivre l'état de l'ensemble du processus sans être lié à une Activity spécifique. Dans iOS, UISceneDelegate (depuis iOS 13) ou AppDelegate est utilisé pour suivre l'état de l'application. SceneDelegate gère plusieurs fenêtres (multifenêtres) sur iPad. Comprendre le App Lifecycle est particulièrement important pour IT Sectr lors du développement d'applications avec synchronisation en arrière-plan, streaming et appels VoIP.

Activity Lifecycle dans Android

Activity est le composant de base d'une application Android, représentant un écran. L'Activity a un cycle de vie clairement défini géré par le système d'exploitation en réponse aux actions de l'utilisateur et aux événements système (rotation de l'écran, appel entrant, faible mémoire).

Important : onSaveInstanceState est appelé avant onStop pour sauvegarder l'état temporaire. La restauration se fait dans onCreate via Bundle savedInstanceState ou via SavedStateHandle dans ViewModel. Sans un traitement approprié du cycle de vie, l'application perdra toutes les données non sauvegardées lors de la rotation de l'écran.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("draft", draftText)
    }
    override fun onDestroy() {
        super.onDestroy()
        // Отписка от всех подписок
    }
}

Activity Lifecycle dans Jetpack Compose

Dans Jetpack Compose, le cycle de vie de l'Activity reste inchangé, mais Compose fournit des outils supplémentaires : Composition consciente du cycle de vie via LifecycleOwner, les effets LifecycleEventEffect et DisposableEffect pour le nettoyage automatique des ressources à la destruction.

Fragment Lifecycle en détail

Fragment dans Android vit à l'intérieur d'une Activity et a son propre cycle de vie, qui chevauche partiellement celui de l'Activity mais ajoute de nouvelles méthodes. Les Fragments peuvent être ajoutés, remplacés, supprimés sans détruire l'Activity, ce qui les rend plus flexibles mais aussi plus complexes.

Méthodes clés du Fragment Lifecycle : onAttach — Fragment attaché à l'Activity (premier appel) ; onCreate — initialisation des données ; onCreateView — création de la View ; onViewCreated — View créée, l'UI peut être configurée ; onStart — Fragment visible ; onResume — Fragment en focus ; onPause — Fragment perd le focus ; onStop — Fragment non visible ; onDestroyView — View détruite ; onDestroy — Fragment détruit ; onDetach — Fragment détaché de l'Activity.

Différence clé avec l'Activity : onCreateView et onDestroyView peuvent être appelés plusieurs fois (par exemple, lors du changement de TabLayout), tandis que onCreate est appelé une fois. Par conséquent, l'initialisation de la View doit être faite dans onViewCreated, pas dans onCreateView. Les ressources liées à la View (comme les adaptateurs RecyclerView) doivent être nettoyées dans onDestroyView.

ViewController Lifecycle dans iOS

UIViewController est la classe de base pour la gestion des écrans dans iOS. Son cycle de vie consiste en une séquence de méthodes que UIKit appelle automatiquement. Comprendre ce cycle est essentiel pour une initialisation correcte de l'UI, la gestion des données et de la mémoire.

Important : viewDidLoad n'est appelé qu'une fois dans la vie du View Controller. Pour mettre à jour les données à chaque apparition, utilisez viewWillAppear. Si vous vous abonnez à NotificationCenter dans viewWillAppear, assurez-vous de vous désabonner dans viewDidDisappear pour éviter les fuites de mémoire.

SwiftUI Lifecycle

SwiftUI gère le cycle de vie des Views via des structures View. Au lieu de méthodes de callback, SwiftUI utilise les modificateurs onAppear et onDisappear. Pour les états globaux de l'application, le App Lifecycle est utilisé via les protocoles App et Scene. SwiftUI gère automatiquement la création et la destruction des Views en fonction de l'état, ce qui simplifie le développement mais nécessite de comprendre l'identité et la durée de vie des Views.

struct ContentView: View {
    var body: some View {
        Text("Hello")
            .onAppear {
                print("View появилась")
            }
            .onDisappear {
                print("View исчезла")
            }
    }
}

LifecycleOwner et LifecycleObserver dans Android

LifecycleOwner est une interface d'Android Architecture Components qui marque un objet ayant un cycle de vie (Activity, Fragment). LifecycleObserver est une interface qui permet à un objet de s'abonner aux événements du LifecycleOwner. Ensemble, ils forment la base de la gestion réactive du cycle de vie dans le développement Android moderne.

Au lieu d'appeler explicitement des méthodes dans onStart/onStop, il est recommandé d'utiliser DefaultLifecycleObserver (remplacement de l'ancien LifecycleObserver avec annotations @OnLifecycleEvent). C'est l'approche promue par Google pour ViewModel et d'autres composants qui doivent réagir au cycle de vie sans avoir de références directes à Activity ou Fragment.

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // Подписка на обновления
    }
    override fun onStop(owner: LifecycleOwner) {
        // Отписка
    }
}

Chez IT Sectr, nous utilisons LifecycleOwner dans tous les projets Android. ViewModel s'abonne au LifecycleOwner de l'Activity via viewModelScope et lifecycleScope, garantissant l'annulation automatique des coroutines lors de la destruction de l'Activity. Cela évite les fuites de mémoire et rend le code plus propre et plus sûr.