Parlez-moi des cycles de vie du contrôleur et comment…

Le cycle de vie de UIViewController comprend des méthodes appelées à des moments précis de son existence : de la création à la destruction.

Méthodes principales du cycle de vie :

viewDidLoad() :
- Appelée après que la vue du contrôleur a été chargée en mémoire, mais avant son affichage à l'écran.
- Utilisée pour initialiser des données, configurer des éléments UI qui ne dépendent pas de la géométrie de la vue.
- Appelée une seule fois durant la vie du contrôleur.
viewWillAppear(_ animated: Bool) :
- Appelée juste avant que la vue du contrôleur n'apparaisse à l'écran.
- Utilisée pour effectuer des tâches qui doivent se produire chaque fois que la vue devient visible (par exemple, mise à jour des données, animations).
- Peut être appelée plusieurs fois.
viewDidAppear(_ animated: Bool) :
- Appelée après que la vue du contrôleur a complètement apparu à l'écran et est visible pour l'utilisateur.
- Convient pour lancer des animations ou d'autres tâches nécessitant que la vue soit entièrement prête.
- Peut être appelée plusieurs fois.
viewWillDisappear(_ animated: Bool) :
- Appelée juste avant que la vue du contrôleur ne soit supprimée de l'écran (par exemple, lors de la navigation vers un autre écran).
- Utilisée pour sauvegarder l'état ou arrêter des tâches qui ne doivent pas continuer tant que la vue n'est pas visible (par exemple, arrêter des temporisateurs).
- Peut être appelée plusieurs fois.
viewDidDisappear(_ animated: Bool) :
- Appelée après que la vue du contrôleur a été complètement supprimée de l'écran.
- Utilisée pour libérer des ressources ou arrêter des tâches qui ne sont pas nécessaires lorsque la vue n'est pas visible.
- Peut être appelée plusieurs fois.
viewWillLayoutSubviews() :
- Appelée avant que le contrôleur ne commence à disposer ses sous-vues.
- Utilisée pour apporter des modifications aux contraintes ou aux cadres avant l'auto-layout.
- Peut être appelée plusieurs fois.
viewDidLayoutSubviews() :
- Appelée après que le contrôleur a terminé de disposer ses sous-vues.
- Utilisée pour effectuer des tâches dépendant des tailles finales des sous-vues (par exemple, configurer des indicateurs de défilement ou des ombres).
- Peut être appelée plusieurs fois.
didReceiveMemoryWarning() :
- Appelée en cas de mémoire RAM faible.
- Utilisée pour libérer des ressources pouvant être recréées plus tard.
deinit :
- Appelée juste avant que l'objet UIViewController ne soit détruit et libéré de la mémoire.
- Utilisée pour effectuer un nettoyage final, comme supprimer des observateurs ou fermer des connexions réseau.

Ordre d'appel :

Ordre typique des méthodes lors de l'apparition du contrôleur :

viewDidLoad()
viewWillAppear(_ animated: Bool)
viewWillLayoutSubviews()
viewDidLayoutSubviews()
viewDidAppear(_ animated: Bool)

Ordre typique des méthodes lors de la disparition du contrôleur :

viewWillDisappear(_ animated: Bool)
viewDidDisappear(_ animated: Bool)
deinit (si le contrôleur n'est plus nécessaire)

Exemple d'implémentation :

import UIKit

class MyViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        // Configuration de l'UI, initialisation des données
        print("viewDidLoad")
    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        // Mise à jour de l'UI avant l'apparition
        print("viewWillAppear")
    }

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        // L'apparition est terminée, démarrer les animations
        print("viewDidAppear")
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        // Préparer la disparition, sauvegarder l'état
        print("viewWillDisappear")
    }

    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        // La disparition est terminée, nettoyage
        print("viewDidDisappear")
    }
    
    override func viewWillLayoutSubviews() {
        super.viewWillLayoutSubviews()
        // Avant l'auto-layout
        print("viewWillLayoutSubviews")
    }
    
    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        // Après l'auto-layout
        print("viewDidLayoutSubviews")
    }

    deinit {
        // Nettoyage des ressources
        print("deinit")
    }
}

Parlez-moi des cycles de vie du contrôleur et comment ils sont appelés.