Android Academy · Leçon

Fragments

Fragments est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 6 sur 7. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 7 leçons au total.

Que sont les fragments ?

Un fragment est un module d'interface utilisateur réutilisable qui se trouve à l'intérieur d'une activité. Considérez-le comme une sous-activité avec sa propre mise en page, son propre cycle de vie et sa propre logique.

Pourquoi utiliser des fragments ?

Réutiliser une interface dans plusieurs activités
Gérer différentes mises en page pour les téléphones et les tablettes
Créer des parcours multi-écrans sans multiplier les activités
Fonctionner naturellement avec le composant de navigation

Cycle de vie d'un fragment

Les fragments ont leur propre cycle de vie, qui s'exécute parallèlement à celui de l'activité. Voici les principaux rappels :

onAttach — fragment rattaché à l'activité
onCreate — fragment créé (aucune vue pour le moment)
onCreateView — gonflement de la mise en page
onViewCreated — vue prête, configurez l'interface ici
onDestroyView — vue détruite (effacez les références à la vue)
onDetach — fragment détaché

Créer un fragment

Créez une classe qui étend Fragment et redéfinissez onCreateView pour gonfler la mise en page :

import androidx.fragment.app.Fragment
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup

class HomeFragment : Fragment() {

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

ViewBinding dans les fragments

Utilisez ViewBinding dans les fragments, mais libérez la liaison dans onDestroyView afin d'éviter les fuites de mémoire :

class HomeFragment : Fragment() {

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

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

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.tvTitle.text = "Welcome!"
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null   // prevent memory leak
    }
}

XML de mise en page d'un fragment

Créez res/layout/fragment_home.xml comme vous le feriez pour une mise en page d'activité. La vue racine devient la vue du fragment :

<!-- res/layout/fragment_home.xml -->
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/tvTitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:text="Home" />

</LinearLayout>

Ajouter un fragment à une activité

Il existe deux façons d'ajouter un fragment à une activité :

Statique (XML) — déclarez-le dans la mise en page avec la balise <fragment>. Fixe lors de l'exécution.
Dynamique (code) — utilisez FragmentManager et des transactions. Peut être remplacé lors de l'exécution.

<!-- Static: in activity_main.xml -->
<fragment
    android:id="@+id/homeFragment"
    android:name="com.example.HomeFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Transactions dynamiques de fragments

Utilisez supportFragmentManager pour ajouter, remplacer ou supprimer des fragments lors de l'exécution :

// In Activity:
class MainActivity : AppCompatActivity(R.layout.activity_main) {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        if (savedInstanceState == null) {
            supportFragmentManager.beginTransaction()
                .add(R.id.fragmentContainer, HomeFragment())
                .commit()
        }
    }

    fun showDetail(id: Int) {
        supportFragmentManager.beginTransaction()
            .replace(R.id.fragmentContainer, DetailFragment.newInstance(id))
            .addToBackStack(null)  // allow back navigation
            .commit()
    }
}

Transmettre des arguments aux fragments

Transmettez les données via un Bundle en utilisant le modèle de fabrique de l'objet compagnon. N'utilisez jamais de constructeur de fragment avec des paramètres : Android recrée les fragments avec un constructeur sans argument après les changements de configuration :

class DetailFragment : Fragment() {

    companion object {
        private const val ARG_ID = "item_id"

        fun newInstance(itemId: Int): DetailFragment {
            return DetailFragment().apply {
                arguments = Bundle().apply {
                    putInt(ARG_ID, itemId)
                }
            }
        }
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val itemId = requireArguments().getInt(ARG_ID)
        // use itemId to load data
    }
}

Communication entre un fragment et une activité

Utilisez une interface définie dans le fragment et implémentée par l'activité. Le fragment obtient une référence via onAttach :

class ListFragment : Fragment() {

    interface OnItemSelected {
        fun onItemSelected(id: Int)
    }

    private var listener: OnItemSelected? = null

    override fun onAttach(context: Context) {
        super.onAttach(context)
        listener = context as? OnItemSelected
    }

    private fun handleClick(id: Int) {
        listener?.onItemSelected(id)
    }

    override fun onDetach() {
        super.onDetach()
        listener = null
    }
}

Pile de retour

Lorsque vous appelez addToBackStack(null) dans une transaction, appuyer sur Retour retire le fragment de la pile :

Sans addToBackStack — Retour quitte l'activité
Avec addToBackStack — Retour revient au fragment précédent
Utilisez popBackStack() par programmation pour revenir en arrière

Fragment dans un conteneur

La mise en page de l'activité a simplement besoin d'une vue conteneur — généralement un FrameLayout avec un ID. Le fragment remplit ce conteneur :

<!-- activity_main.xml -->
<FrameLayout
    android:id="@+id/fragmentContainer"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Vérification rapide

Pourquoi ne devez-vous jamais transmettre d'arguments au constructeur d'un fragment et devez-vous utiliser à la place un Bundle via une fabrique d'objet compagnon ?

Récapitulatif : fragments

Les fragments sont les éléments constitutifs des interfaces utilisateur Android modernes :

Étendez Fragment et gonflez la mise en page dans onCreateView
Configurez l'interface dans onViewCreated
Libérez ViewBinding dans onDestroyView
Transmettez les données via Bundle et une fabrique d'objet compagnon (newInstance)
Utilisez addToBackStack pour la navigation arrière
Communiquez avec l'activité via une interface

Ensuite : demandez les autorisations dangereuses lors de l'exécution.

Questions Fréquemment Posées

La leçon « Fragments » est-elle gratuite ?

Oui — le texte complet de « Fragments » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 7 leçons au total.

Qu'est-ce que j'apprendrai dans « Fragments » ?

Construisez des interfaces utilisateur modulaires avec des Fragments. Apprenez le cycle de vie des fragments, ViewBinding dans les fragments, le passage d’arguments, la gestion de la pile de retour e… Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 6 sur 7.

Combien de temps prend la leçon « Fragments » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy