Android Academy · Leçon

Lire des fichiers audio et vidéo

Lecture multimédia simple dans Android.

Leçon 4 sur 413 étapes

Lire des fichiers audio et vidéo est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. 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 4 leçons au total.

Au-delà des images : lecture multimédia

Coil affiche très bien les images, mais les applications lisent également du son et des vidéos : son de notification, podcast, clip en arrière-plan ou fil vidéo. Android dispose d'API dédiées aux contenus multimédias.

La bibliothèque moderne recommandée est Media3 (ExoPlayer). Elle gère bien mieux la diffusion en continu, les formats, la mise en mémoire tampon et les commandes de lecture que l'ancien MediaPlayer. Dans cette leçon, vous lirez de l'audio et de la vidéo simples dans une application Compose.

Ajouter les dépendances Media3

Media3 est réparti en modules. Pour la plupart des applications, vous aurez besoin de media3-exoplayer (le moteur de lecture) et de media3-ui (des vues de lecteur prêtes à l'emploi). Pour la vidéo Compose, vous pouvez également utiliser PlayerView via AndroidView.

// build.gradle.kts (module level)
dependencies {
    implementation("androidx.media3:media3-exoplayer:1.5.0")
    implementation("androidx.media3:media3-ui:1.5.0")
}

Créer un ExoPlayer

Un ExoPlayer est créé à partir d'un Context. Vous lui fournissez un MediaItem (une URL ou un fichier local), appelez prepare(), puis démarrez la lecture. Il utilise ses propres fils d'exécution et ne bloque donc pas l'interface utilisateur.

Point essentiel : un lecteur conserve des ressources système et doit être libéré. Nous y reviendrons bientôt.

import android.content.Context
import androidx.media3.common.MediaItem
import androidx.media3.exoplayer.ExoPlayer

fun createPlayer(context: Context, url: String): ExoPlayer {
    val player = ExoPlayer.Builder(context).build()
    player.setMediaItem(MediaItem.fromUri(url))
    player.prepare()
    player.playWhenReady = true
    return player
}

Lire de l'audio

Pour une lecture audio uniquement, la configuration est identique : il suffit de faire pointer MediaItem vers une URL audio (mp3, aac, etc.). Il n'y a aucune vue à afficher, vous le contrôlez donc via l'objet lecteur : play(), pause(), seekTo().

Cela suffit pour créer un lecteur de podcasts ou de musique.

import androidx.media3.common.MediaItem
import androidx.media3.exoplayer.ExoPlayer

fun playPodcast(player: ExoPlayer, audioUrl: String) {
    player.setMediaItem(MediaItem.fromUri(audioUrl))
    player.prepare()
    player.play()
}

fun togglePause(player: ExoPlayer) {
    if (player.isPlaying) player.pause() else player.play()
}

Mémoriser le lecteur dans Compose

Dans Compose, vous devez créer le lecteur une seule fois et le conserver entre les recompositions. Utilisez remember afin de ne pas créer un nouveau lecteur à chaque recomposition.

Associez cette approche à un nettoyage correct (scène suivante) pour éviter les fuites de ressources.

import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.platform.LocalContext
import androidx.media3.common.MediaItem
import androidx.media3.exoplayer.ExoPlayer

@Composable
fun rememberPlayer(url: String): ExoPlayer {
    val context = LocalContext.current
    return remember {
        ExoPlayer.Builder(context).build().apply {
            setMediaItem(MediaItem.fromUri(url))
            prepare()
        }
    }
}

Libérer le lecteur

Un lecteur maintient actifs les codecs, les tampons et le focus audio. Si vous oubliez de le libérer, vous provoquez une fuite de mémoire et la lecture peut continuer après la disparition de l'écran. Dans Compose, DisposableEffect effectue le nettoyage lorsque le composable quitte la composition.

Appelez toujours player.release() à cet endroit.

import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.media3.exoplayer.ExoPlayer

@Composable
fun ManagedPlayer(player: ExoPlayer) {
    DisposableEffect(player) {
        onDispose {
            player.release()
        }
    }
    // ... use player here
}

Afficher une vidéo avec PlayerView

Media3 fournit un PlayerView prêt à l'emploi avec des commandes. Compose ne possède pas de composable vidéo natif ; vous intégrez donc la vue à l'aide de AndroidView et lui associez le lecteur.

Vous bénéficiez ainsi gratuitement des commandes lecture/pause, d'une barre de progression et du plein écran.

import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.viewinterop.AndroidView
import androidx.media3.exoplayer.ExoPlayer
import androidx.media3.ui.PlayerView

@Composable
fun VideoPlayer(player: ExoPlayer, modifier: Modifier = Modifier) {
    AndroidView(
        factory = { context ->
            PlayerView(context).apply {
                this.player = player
            }
        },
        modifier = modifier
    )
}

Un écran vidéo complet

Rassemblons tout cela : créez le lecteur, mémorisez-le, associez-le à un PlayerView et libérez-le lors de la suppression. Vous obtenez un écran vidéo autonome et réutilisable.

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.media3.common.MediaItem
import androidx.media3.exoplayer.ExoPlayer
import androidx.media3.ui.PlayerView

@Composable
fun VideoScreen(videoUrl: String) {
    val context = LocalContext.current
    val player = remember {
        ExoPlayer.Builder(context).build().apply {
            setMediaItem(MediaItem.fromUri(videoUrl))
            prepare()
            playWhenReady = true
        }
    }
    DisposableEffect(Unit) { onDispose { player.release() } }

    AndroidView(
        factory = { PlayerView(it).apply { this.player = player } },
        modifier = Modifier.fillMaxWidth().height(220.dp)
    )
}

Suivre l'état de lecture

Pour mettre à jour votre interface (une icône de lecture/pause ou une barre de progression), écoutez le lecteur avec un Player.Listener. Celui-ci signale les changements d'état, comme la mise en mémoire tampon, l'état prêt et la fin de la lecture, ainsi que l'activation ou non de la lecture.

Ajoutez l'écouteur lorsque l'écran apparaît et supprimez-le lors de sa suppression.

import androidx.media3.common.Player
import androidx.media3.exoplayer.ExoPlayer

fun observe(player: ExoPlayer, onPlaying: (Boolean) -> Unit): Player.Listener {
    val listener = object : Player.Listener {
        override fun onIsPlayingChanged(isPlaying: Boolean) {
            onPlaying(isPlaying)
        }
        override fun onPlaybackStateChanged(state: Int) {
            when (state) {
                Player.STATE_BUFFERING -> { /* show spinner */ }
                Player.STATE_READY -> { /* ready */ }
                Player.STATE_ENDED -> { /* finished */ }
            }
        }
    }
    player.addListener(listener)
    return listener
}

Mettre en pause lorsque l'application passe en arrière-plan

Pour une vidéo intégrée (et non une application musicale), vous souhaitez généralement mettre la lecture en pause lorsque l'utilisateur quitte l'écran, puis la reprendre à son retour. Vous pouvez associer la lecture au cycle de vie de Compose en observant Lifecycle et en mettant la lecture en pause sur ON_PAUSE.

Cela évite de lire une vidéo que l'utilisateur ne peut pas voir et économise la batterie.

import androidx.compose.runtime.*
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.media3.exoplayer.ExoPlayer

@Composable
fun PauseWithLifecycle(player: ExoPlayer) {
    val lifecycleOwner = LocalLifecycleOwner.current
    DisposableEffect(lifecycleOwner) {
        val observer = LifecycleEventObserver { _, event ->
            when (event) {
                Lifecycle.Event.ON_PAUSE -> player.pause()
                Lifecycle.Event.ON_RESUME -> player.play()
                else -> {}
            }
        }
        lifecycleOwner.lifecycle.addObserver(observer)
        onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
    }
}

Audio en arrière-plan avec MediaSession

Pour un contenu audio qui doit continuer à être lu lorsque l'application passe en arrière-plan (musique, podcasts), encapsulez la lecture dans un MediaSessionService. Cela l'intègre aux commandes système, à l'écran de verrouillage et aux boutons Bluetooth.

La mise en place est plus complexe, mais l'idée centrale consiste à exposer votre lecteur via une MediaSession.

import androidx.media3.exoplayer.ExoPlayer
import androidx.media3.session.MediaSession
import androidx.media3.session.MediaSessionService

class PlaybackService : MediaSessionService() {
    private var session: MediaSession? = null

    override fun onCreate() {
        super.onCreate()
        val player = ExoPlayer.Builder(this).build()
        session = MediaSession.Builder(this, player).build()
    }

    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo) = session

    override fun onDestroy() {
        session?.run { player.release(); release() }
        session = null
        super.onDestroy()
    }
}

Vérification rapide

Dans un écran Compose qui contient un ExoPlayer, quelle API Compose devez-vous utiliser pour libérer le lecteur lorsque l'écran quitte la composition ?

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez ajouté la lecture audio et vidéo :

Utilisez Media3 ExoPlayer, le remplacement moderne de MediaPlayer.
Créez un lecteur, définissez un MediaItem, appelez prepare(), puis play().
Dans Compose, mémorisez le lecteur avec remember et libérez-le dans DisposableEffect, via onDispose.
Affichez la vidéo en intégrant PlayerView avec AndroidView.
Suivez l'état avec un Player.Listener et utilisez un MediaSessionService pour l'audio en arrière-plan.

Le cours Images et chargement multimédia avec Coil est terminé. Vous pouvez maintenant charger des images fluidement et lire des contenus multimédias avec les approches Android modernes.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 36
Leçons: 152

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Lire des fichiers audio et vidéo » est-elle gratuite ?

Oui — le texte complet de « Lire des fichiers audio et vidéo » 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Lire des fichiers audio et vidéo » ?

Lecture multimédia simple dans Android. 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 4 sur 4.

Combien de temps prend la leçon « Lire des fichiers audio et vidéo » ?

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