Activity — qu'est-ce que c'est, écran d'application Android et son Lifecycle

Qu'est-ce que Activity ?

Activity — un composant clé d'une application Android qui fournit une fenêtre pour l'interaction avec l'utilisateur. Chaque Activity gère un écran séparé : liste de tâches, formulaire de connexion, visualiseur de photos. Le système Android crée une Activity à la demande et la détruit lorsque d'autres applications ont besoin de mémoire.

Activity est apparue pour la première fois dans Android 1.0 (2008) et reste le principal bloc de construction de l'interface. Selon Google (2026), 98% des applications sur Google Play contiennent au moins une Activity. Dans l'architecture moderne, Google recommande une Activity avec plusieurs Fragments, cependant l'application classique multi-écrans reste une pratique courante.

Activity stack (back stack) — une pile de tâches qui stocke l'historique de navigation. Lorsque l'utilisateur appuie sur "Retour", l'Activity actuelle est détruite et la précédente est restaurée. Le système gère la pile automatiquement, mais le développeur peut contrôler le comportement via launchMode et les indicateurs Intent.

Cycle de vie d'Activity

Le cycle de vie de Activity est un ensemble d'états et de callbacks par lesquels un écran passe de la création à la destruction. Comprendre le Lifecycle est d'une importance critique : une mauvaise gestion des états entraîne des fuites de mémoire, une perte de données et des plantages de l'application.

Le système Android appelle les callbacks dans un ordre strict. Le développeur surcharge les méthodes nécessaires pour initialiser les ressources, sauvegarder les données et libérer la mémoire. Chaque callback a une paire correspondante : onCreate ↔ onDestroy, onStart ↔ onStop, onResume ↔ onPause.

États d'Activity

Il existe quatre états de Activity : Running (onResume actif), Paused (visible mais sans focus), Stopped (non visible), Destroyed (détruit). Le système peut tuer une Activity à l'état Stopped en cas de manque de mémoire — les données doivent être sauvegardées dans onSaveInstanceState.

Méthodes du cycle de vie : onCreate, onStart, onResume

Examinons trois méthodes clés du cycle de vie d'Activity avec un exemple en Kotlin. onCreate — le point d'entrée, appelé une fois. Ici se produisent la liaison du layout via setContentView, l'initialisation de RecyclerView, l'abonnement à LiveData. onStart — l'Activity devient visible pour l'utilisateur. onResume — l'Activity obtient le focus et est prête pour l'interaction.

class MainActivity : AppCompatActivity() {

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

        val recyclerView = findViewById<RecyclerView>(R.id.rv_items)
        recyclerView.layoutManager = LinearLayoutManager(this)
        loadItems()
    }

    override fun onStart() {
        super.onStart()
        startLocationUpdates()
    }

    override fun onResume() {
        super.onResume()
        resumeVideoPlayer()
    }
}

Dans l'exemple, onCreate initialise RecyclerView et charge les données. onStart démarre les mises à jour de géolocalisation — une ressource qui ne devrait fonctionner que lorsque l'écran est visible. onResume reprend la vidéo qui a été mise en pause dans onPause. Cette séparation évite le travail inutile en arrière-plan.

Déclaration d'Activity dans AndroidManifest.xml

Chaque Activity doit être déclarée dans le fichier AndroidManifest.xml. Sans enregistrement, le système ne trouvera pas l'écran et lancera une exception ActivityNotFoundException. Le manifeste spécifie le nom de la classe, le thème, l'orientation, launchMode et les filtres Intent.

<application
    android:allowBackup="true"
    android:label="@string/app_name"
    android:theme="@style/Theme.MyApp">

    <activity
        android:name=".MainActivity"
        android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <activity
        android:name=".DetailActivity"
        android:parentActivityName=".MainActivity" />
</application>

Le flag exported détermine si d'autres applications peuvent lancer l'Activity. Pour l'écran principal exported=true, pour les écrans internes — false. L'attribut parentActivityName active la navigation standard "Vers le haut" (Up Navigation).

Lancer Activity via Intent

Intent — un objet qui décrit une action à effectuer. Dans le contexte d'Activity, Intent est utilisé pour lancer un autre écran avec transfert de données. Intent peut être explicite (spécifie une classe concrète) et implicite (spécifie une action, le système sélectionne un composant approprié).

// Intent explicite — lancer DetailActivity avec données
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", itemId)
    putExtra("item_name", itemName)
}
startActivity(intent)

// Obtenir des données dans DetailActivity
val itemId = intent.getLongExtra("item_id", 0L)
val itemName = intent.getStringExtra("item_name") ?: ""

Pour obtenir un résultat d'une Activity lancée, on utilise Activity Result API, qui a remplacé l'obsolète startActivityForResult. La nouvelle API est type-safe, déclarative et fonctionne avec Jetpack Compose.

private val getResult = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult()
) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        val data = result.data?.getStringExtra("result_key")
    }
}

fun openPicker() {
    val intent = Intent(this, PickerActivity::class.java)
    getResult.launch(intent)
}

Sauvegarder l'état lors de la recréation

Lors de la rotation de l'écran ou du changement de configuration, Android recrée l'Activity — appelle séquentiellement onDestroy et onCreate. Sans sauvegarde d'état, l'utilisateur perd les données saisies, la position de défilement et les éléments sélectionnés. Android fournit deux mécanismes pour résoudre ce problème : onSaveInstanceState et ViewModel.

onSaveInstanceState sauvegarde les données simples dans Bundle avant l'appel à onDestroy. ViewModel de Jetpack survit à la recréation d'Activity et stocke les données en mémoire, ce qui est plus efficace pour les objets complexes et les requêtes réseau.

class MainActivity : AppCompatActivity() {

    private val viewModel: MainViewModel by viewModels()

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

        // ViewModel sauvegarde automatiquement les données
        viewModel.items.observe(this) { items ->
            updateAdapter(items)
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("scroll_position", recyclerView.computeVerticalScrollOffset())
    }
}

Architecture Single Activity et Jetpack

L'approche moderne de Google est l'architecture Single Activity avec une Activity et plusieurs Fragments. L'application utilise une MainActivity, et toute la navigation est gérée par Navigation Component via NavHostFragment. Avantages : navigation centralisée, ViewModel partagé par écran, gestion correcte des Deep Links.

Jetpack Navigation Component automatise la gestion de la back stack, les animations de transition et le passage d'arguments. NavHostFragment est placé dans le layout de l'Activity, et le graphe de navigation (NavGraph) décrit tous les écrans et les connexions entre eux. Cette approche est recommandée par Google pour les nouveaux projets et suit les principes de Material Design.

class MainActivity : AppCompatActivity() {

    private val navController by lazy {
        findViewById<NavHostFragment>(R.id.nav_host_fragment)
            .navController
    }

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

        // Configuration de NavigationUI pour AppBar
        setupActionBarWithNavController(navController)
    }

    override fun onSupportNavigateUp() = 
        navController.navigateUp() || super.onSupportNavigateUp()
}