Fragment Lifecycle : notions de base, méthodes onCreateView et onViewCreated

Fragment Lifecycle : notions de base du cycle de vie

Fragment Lifecycle est un ensemble d'états et de méthodes interconnectés par lesquels chaque instance de Fragment passe de la création à la destruction. Contrairement à Activity, le cycle de vie de Fragment est lié à deux contextes : le Fragment lui-même (vit de onAttach à onDetach) et sa View (vit de onCreateView à onDestroyView). Cette séparation est une caractéristique clé de Fragment, lui permettant de survivre à la destruction de la View lors de la rotation de l'écran sans détruire le Fragment lui-même.

Séquence complète des rappels de Fragment :

• onAttach(Context) — Fragment s'attache à l'Activity. Appelé en premier. Context est l'Activity hôte.
• onCreate(Bundle) — Fragment est initialisé. Ici, ViewModel est créé, les adaptateurs sont configurés.
• onCreateView(LayoutInflater, ViewGroup, Bundle) — la hiérarchie View de Fragment est créée. Retourne la View racine.
• onViewCreated(View, Bundle) — la View a été créée. Ici, les éléments d'UI sont configurés, les abonnements LiveData sont établis.
• onStart() — Fragment devient visible. Les animations démarrent, les capteurs sont enregistrés.
• onResume() — Fragment est actif, interagit avec l'utilisateur.
• onPause() — Fragment perd le focus. Les animations sont arrêtées.
• onStop() — Fragment n'est pas visible. Les ressources non critiques sont libérées.
• onDestroyView() — la hiérarchie View est détruite. Les références à View sont mises à null.
• onDestroy() — Fragment est détruit. Les coroutines qui ne sont pas dans viewModelScope sont annulées.
• onDetach() — Fragment se détache de l'Activity. Nettoyage final.

Selon Google, le fragment moyen dans une application moderne passe par le cycle complet 3 à 5 fois par session utilisateur (en raison des rotations d'écran et de la navigation). Le traitement correct de toutes les phases est le fondement de la stabilité de l'UI.

États de Fragment : de INITIALIZED à DESTROYED

FragmentManager gère Fragment à travers cinq états principaux, définis dans la classe Fragment.State. Chaque état correspond à un ensemble spécifique de rappels qui ont été exécutés.

FragmentManager déplace Fragment entre les états en fonction des actions de l'utilisateur et des événements système. Lors de l'ajout de Fragment à un conteneur, il passe séquentiellement par INITIALIZED → CREATED → STARTED → RESUMED. Lors de la suppression — RESUMED → STARTED → CREATED → DESTROYED.

L'état CREATED est spécial : la View peut être détruite (après onDestroyView), mais le Fragment lui-même reste dans l'état CREATED (après onDestroyView, avant onDestroy). Cela permet à FragmentManager de conserver le Fragment en mémoire sans View, ce qui est nécessaire pour survivre aux rotations d'écran.

Différence entre Fragment Lifecycle et Activity Lifecycle

Fragment Lifecycle et Activity Lifecycle sont étroitement liés mais ont des différences fondamentales. Fragment vit toujours à l'intérieur d'une Activity, et son cycle de vie dépend de l'Activity hôte, mais n'est pas identique à celle-ci.

La principale différence pratique : lors de la rotation de l'écran, l'Activity est complètement détruite (onDestroy) et recréée (onCreate). Fragment lors de la rotation passe par onDestroyView (View détruite) → onCreateView (View recréée), mais le Fragment lui-même et son ViewModel restent vivants. Cela fait de Fragment un conteneur idéal pour la logique d'UI qui doit survivre aux changements de configuration.

Ordre des appels lors de la rotation de l'écran : Activity.onPause → Fragment.onPause → Activity.onStop → Fragment.onStop → Activity.onDestroy → Fragment.onDestroyView → (Activity détruite) → Activity.onCreate → Fragment.onAttach → Fragment.onCreate → Fragment.onCreateView → Fragment.onViewCreated → Activity.onStart → Fragment.onStart → Activity.onResume → Fragment.onResume.

FragmentManager : gestion des états et transactions

FragmentManager est la classe centrale responsable de l'ajout, de la suppression, du remplacement des fragments et de la gestion de leurs états. FragmentManager maintient la BackStack et garantit l'ordre correct des rappels lors des transactions. Chaque Activity et chaque Fragment imbriqué a son propre FragmentManager.

Opérations principales de FragmentManager :

• beginTransaction() — ouvre une transaction pour un groupe d'opérations.
• add() — ajoute un Fragment à un conteneur. Fragment passe par le cycle de vie complet jusqu'à RESUMED.
• replace() — remplace le Fragment actuel par un nouveau. Équivaut à remove() + add().
• remove() — supprime un Fragment. Fragment passe par le cycle de vie de RESUMED à DESTROYED.
• hide()/show() — masque/affiche Fragment sans détruire la View. Fragment passe à STARTED lors du masquage, revient à RESUMED lors de l'affichage.
• detach()/attach() — détache/reattache Fragment. detach détruit la View (onDestroyView), attach la recrée (onCreateView).
• addToBackStack() — ajoute la transaction à la BackStack pour la navigation arrière.

BackStack est la pile de transactions de FragmentManager. Lorsque le bouton Retour système est pressé, la dernière transaction dans la BackStack est annulée (popBackStack()). Un Fragment supprimé via popBackStack est restauré. Si la BackStack est vide, presser Retour termine l'Activity.

Selon Google, 78% des problèmes avec Fragment (duplication, écrans vides, IllegalStateException) sont liés à une mauvaise utilisation de FragmentManager. La règle principale : exécutez les transactions via commit() (de manière asynchrone) ou commitNow() (de manière synchrone) selon le contexte. commit() garantit l'ordre correct sous plusieurs transactions.

Sauvegarde de l'état de Fragment : onSaveInstanceState

Fragment prend en charge son propre mécanisme de sauvegarde d'état via onSaveInstanceState, qui fonctionne indépendamment de l'Activity. Fragment sauvegarde l'état dans un Bundle qui est passé à onCreate et onCreateView lors de la restauration.

Quand Fragment sauvegarde l'état :

• Lors de la rotation de l'écran — la View est détruite, Fragment sauvegarde l'état dans Bundle.
• Lors de la reconnexion de Fragment à l'Activity après la mort du processus.
• Lorsque onSaveInstanceState est appelé depuis l'Activity (le système propage la sauvegarde à tous les fragments enfants).

Approche moderne : utilisez SavedStateHandle dans ViewModel pour sauvegarder l'état de Fragment. SavedStateHandle sauvegarde et restaure automatiquement les données lors de la rotation de l'écran et de la mort du processus, sans nécessiter de onSaveInstanceState manuel. Google recommande SavedStateHandle comme méthode préférée pour sauvegarder l'état de l'UI dans Fragment.

setRetainInstance (obsolète depuis Fragment 1.3) : auparavant, Fragment pouvait être conservé via setRetainInstance(true) lors de la rotation de l'écran. Cette approche a été remplacée par ViewModel + SavedStateHandle, qui fonctionnent de manière plus fiable et ne nécessitent pas de configuration spéciale.

viewLifecycleOwner : cycle de vie séparé de la View

viewLifecycleOwner est un Lifecycle lié à la View de Fragment (de onCreateView à onDestroyView). C'est un concept fondamentalement important : les abonnements LiveData/Flow effectués via viewLifecycleOwner sont automatiquement annulés lorsque la View est détruite (onDestroyView), mais n'affectent pas le Fragment lui-même.

Différence entre viewLifecycleOwner et le lifecycle de Fragment :

• lifecycle (Fragment) — vit de onAttach à onDetach. Les abonnements restent actifs même après la destruction de la View.
• viewLifecycleOwner — vit de onCreateView à onDestroyView. Les abonnements sont annulés lors de la destruction de la View.

Pourquoi c'est important : si vous vous abonnez à LiveData via le lifecycle de Fragment (this), après onDestroyView l'abonnement reste actif et LiveData tentera de mettre à jour une View nulle, provoquant une NPE. S'abonner via viewLifecycleOwner garantit qu'après onDestroyView aucune mise à jour d'UI ne se produira.

Règle : dans Fragment, utilisez toujours viewLifecycleOwner pour les abonnements à LiveData, Flow et aux coroutines liées à l'UI. Pour les coroutines de ViewModel, utilisez viewModelScope — il est lié à ViewModel, pas à Fragment.

Exemples de code Fragment en Kotlin

Exemple 1 : Fragment basique avec onViewCreated et viewLifecycleOwner

Démontre l'initialisation correcte de l'UI et l'abonnement LiveData via viewLifecycleOwner.

class UserListFragment : Fragment() {
    private val viewModel: UserListViewModel by viewModels()

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return inflater.inflate(R.layout.fragment_user_list, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val button: Button = view.findViewById(R.id.load_button)
        button.setOnClickListener { viewModel.loadUsers() }
        viewModel.users.observe(viewLifecycleOwner) { users ->
            Log.d("UserListFragment", "Mise à jour de la liste : ${users.size} utilisateurs")
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        Log.d("UserListFragment", "onDestroyView : View détruite")
    }
}

Fragment gonfle le layout dans onCreateView, configure l'UI et s'abonne à LiveData dans onViewCreated. L'abonnement via viewLifecycleOwner est une exigence obligatoire pour prévenir les fuites mémoire. onDestroyView enregistre la destruction de la View — confirmation que Fragment survit à la rotation de l'écran.

Exemple 2 : Fragment avec FragmentManager et transactions

Démontre l'ajout de Fragment via FragmentManager dans Activity, le remplacement avec BackStack et la restauration.

class HostActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_host)
        if (savedInstanceState == null) {
            supportFragmentManager.beginTransaction()
                .add(R.id.fragment_container, HomeFragment())
                .addToBackStack(null)
                .commit()
        }
    }

    fun openDetail(userId: String) {
        supportFragmentManager.beginTransaction()
            .replace(R.id.fragment_container, DetailFragment.newInstance(userId))
            .addToBackStack(null)
            .commit()
    }

    override fun onBackPressed() {
        if (supportFragmentManager.backStackEntryCount > 0) {
            supportFragmentManager.popBackStack()
        } else {
            super.onBackPressed()
        }
    }
}

class DetailFragment : Fragment() {
    companion object {
        fun newInstance(userId: String): DetailFragment {
            return DetailFragment().apply {
                arguments = Bundle().apply { putString("user_id", userId) }
            }
        }
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val userId = arguments?.getString("user_id")
        Log.d("DetailFragment", "Chargement des détails de l'utilisateur : $userId")
    }
}

Activity utilise supportFragmentManager pour gérer les fragments. La transaction add() avec BackStack garantit que lors de l'appui sur Retour, HomeFragment est restauré. openDetail() remplace le Fragment actuel par DetailFragment avec des arguments. La vérification de savedInstanceState == null empêche la duplication de fragments lors de la rotation de l'écran.

Exemple 3 : Fragment avec LifecycleObserver et StateFlow

Utilisation de Flow et StateFlow dans Fragment avec viewLifecycleOwner pour des mises à jour réactives de l'UI.

class SearchFragment : Fragment() {
    private val viewModel: SearchViewModel by viewModels()
    private var binding: FragmentSearchBinding? = null

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = FragmentSearchBinding.inflate(inflater, container, false)
        return binding!!.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding?.searchButton?.setOnClickListener {
            viewModel.search(binding?.queryInput?.text.toString())
        }
        viewLifecycleOwner.lifecycleScope.launch {
            viewModel.searchResults.collectLatest { results ->
                Log.d("SearchFragment", "Résultats de recherche : ${results.size}")
            }
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        binding = null
    }
}

Fragment utilise View Binding pour accéder à la View. La coroutine viewLifecycleOwner.lifecycleScope.launch est automatiquement annulée lorsque la View est détruite. Le binding est mis à null dans onDestroyView pour prévenir les fuites. StateFlow garantit l'actualité des données lors de la recréation de la View.