Fragment : qu'est-ce que c'est, fragments et FragmentManager dans Android

Qu'est-ce que Fragment ?

Fragment est un composant d'interface utilisateur modulaire d'Android qui représente une partie de l'écran à l'intérieur d'une Activity. Fragment peut gérer son propre layout, traiter les événements du cycle de vie et sauvegarder son état. Grâce à la modularité, un même fragment peut être utilisé dans différentes Activities et sur différents appareils.

L'API Fragment est apparue dans Android 3.0 (Honeycomb, API 11) en 2011 pour prendre en charge les tablettes. Avant cela, les développeurs devaient créer des Activities séparées pour le téléphone et la tablette. Fragment a permis d'assembler un écran à partir de blocs indépendants. En 2019, Google a publié la bibliothèque Jetpack Fragment avec une rétrocompatibilité jusqu'à l'API 4.

Selon Google (2026), 80% des applications sur Google Play utilisent Fragment sous une forme ou une autre. La bibliothèque Jetpack Fragment a été téléchargée plus de 10 milliards de fois via Google Play Services. Fragment reste un composant clé de l'architecture Android même à l'ère de Jetpack Compose.

Cycle de vie de Fragment

Le cycle de vie de Fragment est plus complexe que celui d'Activity car il dépend de l'état de l'Activity hôte. Fragment passe par les mêmes états qu'Activity mais ajoute ses propres callbacks : onAttach, onCreateView, onViewCreated, onActivityCreated, onDestroyView, onDetach.

Comparaison du cycle de vie Fragment et Activity

La principale différence du cycle de vie de Fragment est l'appel de onCreateView et onDestroyView entre onCreate et onDestroy. Fragment peut exister sans UI (si onCreateView retourne null). Après la recréation de l'Activity, FragmentManager restaure automatiquement les fragments.

FragmentManager et transactions

FragmentManager est la classe centrale pour gérer les fragments dans une Activity. Il s'occupe d'ajouter, supprimer, remplacer des fragments, gérer la pile de retour et restaurer l'état. FragmentManager est disponible via supportFragmentManager (AndroidX) ou fragmentManager (ancienne API).

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Fragment pas encore ajouté — création
        if (savedInstanceState == null) {
            val transaction = this.supportFragmentManager
                .beginTransaction()
            transaction.add(R.id.fragment_container, ListFragment())
            transaction.addToBackStack(null)
            transaction.commit()
        }
    }

    fun replaceFragment(fragment: Fragment) {
        supportFragmentManager.beginTransaction()
            .replace(R.id.fragment_container, fragment)
            .addToBackStack(null)
            .commit()
    }
}

Les transactions FragmentTransaction sont atomiques. commit() planifie l'exécution pour le prochain cycle de Looper. Pour une exécution immédiate, utilisez commitNow(). addToBackStack(null) ajoute la transaction à la pile de retour — le bouton retour annulera l'opération.

Méthodes du cycle de vie de Fragment

Examinons les méthodes clés du cycle de vie de Fragment avec un exemple en Kotlin. onCreateView crée un layout — contrairement à Activity, la méthode doit retourner une View. onViewCreated est appelé immédiatement après, ici il est sûr de trouver des éléments par id. onDestroyView est le dernier moment pour nettoyer les références de vue.

class DetailFragment : Fragment() {

    private var _binding: FragmentDetailBinding? = null
    private val binding get() = _binding!!

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

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.textTitle.setText("Détails")
    }

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

Le modèle View Binding avec _binding/binding garantit qu'après onDestroyView la référence au layout est nullifiée. Accéder à binding après la destruction de la vue provoquera une NullPointerException. Ce modèle est recommandé par Google pour tous les fragments.

Transfert de données entre fragments

Pour le transfert de données entre fragments, Android propose plusieurs mécanismes. Le plus fiable est un ViewModel partagé entre fragments d'une même Activity. Fragment Result API est adapté pour les événements uniques. Les arguments Bundle sont pour les données lors de la création d'un fragment.

// ViewModel partagé pour deux fragments
class SharedViewModel : ViewModel() {
    private val _selectedItem = MutableLiveData<Item>()
    val selectedItem: LiveData<Item> = _selectedItem

    fun select(item: Item) { _selectedItem.setValue(item) }
}

// Fragment A : envoie un événement via Fragment Result API
setFragmentResult("request_key", bundleOf("key" to "value"))

// Fragment B : reçoit l'événement
childFragmentManager.setFragmentResultListener("request_key", this) { requestKey, bundle ->
    val value = bundle.getString("key")
}

Fragment Result API (ajouté dans Fragment 1.3.0) remplace les obsolètes setTargetFragment/onActivityResult. L'API est type-safe, utilise Bundle et ne nécessite pas de connaître le destinataire. Parent FragmentManager agit comme intermédiaire entre les fragments.

Fragment vs Activity : quand choisir quoi

Le choix entre Fragment et Activity dépend de l'architecture de l'application. Fragment est obligatoire pour les layouts adaptatifs (téléphone + tablette), pour les animations de transition personnalisées et pour utiliser Jetpack Navigation. Activity est préférable pour les applications simples avec un ou deux écrans.

Jetpack Fragment et Jetpack Navigation

L'approche moderne pour travailler avec Fragment est Jetpack Navigation Component, qui remplace la gestion manuelle de FragmentManager. La bibliothèque fournit NavGraph (graphe de navigation XML), NavHostFragment et Safe Args pour un transfert de données type-safe.

Jetpack Fragment library (androidx.fragment:fragment-ktx) inclut FragmentResult API, DialogFragment, BottomSheetDialogFragment et l'intégration avec des composants Lifecycle-aware. Depuis 2026, Google recommande d'utiliser Fragment uniquement via Jetpack Navigation, pas directement.

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    app:startDestination="@+id/listFragment">

    <fragment
        android:id="@+id/listFragment"
        android:name=".ListFragment"
        android:label="Liste">
        <action
            android:id="@+id/action_list_to_detail"
            app:destination="@+id/detailFragment" />
    </fragment>

    <fragment
        android:id="@+id/detailFragment"
        android:name=".DetailFragment"
        android:label="Détails" />
</navigation>