MediaSession — concepts clés, intégration et mécanisme de fonctionnement dans Android

Qu'est-ce que MediaSession ?

MediaSession est un composant système Android qui permet à une application de déclarer son activité multimédia et de recevoir des commandes de contrôle depuis des sources externes. Lorsque l'utilisateur appuie sur le bouton Play d'un casque Bluetooth, le système transmet cet événement à la MediaSession active, et l'application répond via son Callback.

Avant Android 5.0, RemoteControlClient était utilisé à cette fin, mais il n'offrait pas assez de flexibilité et ne prenait pas en charge les scénarios modernes — Android Auto, montres connectées, enceintes intelligentes. MediaSession a été introduit dans l'API 21 et est devenu le standard de facto pour toutes les applications Android avec lecture audio et vidéo.

Selon la documentation développeur Android (2026), une application doit créer une MediaSession pour chaque source de lecture indépendante. À tout moment, une seule session peut être active — toute nouvelle session désactive automatiquement la précédente.

MediaSession et MediaBrowserService

La combinaison de MediaSession avec MediaBrowserService fournit un cycle complet de gestion multimédia : le service propose une arborescence de contenu (playlists, catalogues) et la session accepte les commandes de navigation et de lecture. C'est l'architecture recommandée par Google pour les lecteurs de musique, podcasts et livres audio.

MediaBrowserService s'exécute en tant que service au premier plan avec une notification, garantissant que l'application continue de fonctionner même lorsque l'Activity est détruite. C'est essentiel pour les lecteurs audio qui doivent continuer à jouer lorsque l'application est réduite.

Comment fonctionne MediaSession

La session prend en charge deux types d'interaction : elle reçoit des commandes de MediaController (le côté client) et diffuse l'état via PlaybackState. MediaController peut être dans le même processus ou dans une application distincte — le système achemine les requêtes via SessionToken.

Lorsque l'utilisateur appelle l'assistant vocal Android et dit « Lecture du morceau suivant », le système trouve la MediaSession active via sa connexion à MediaBrowserService et envoie la commande ACTION_SKIP_TO_NEXT. Le Callback de l'application reçoit l'appel onSkipToNext() et met à jour PlaybackState.

La mise à jour de PlaybackState via setPlaybackState() notifie immédiatement toutes les instances MediaController connectées. Le centre multimédia système, le périphérique Bluetooth et Android Auto reçoivent la mise à jour simultanément — le délai ne dépasse pas 50 ms dans des conditions normales.

PlaybackState et ses métadonnées

PlaybackState contient les indicateurs d'état clés : isPlaying, position, vitesse, actions disponibles (play, pause, seek, stop). Sans PlaybackState correctement renseigné, le système ne sait pas quelles commandes l'application prend en charge et n'envoie pas les événements correspondants.

Les métadonnées (MediaMetadata) complètent l'état avec des informations sur le morceau en cours — titre, artiste, URI de la pochette. Android Auto et les montres connectées utilisent MediaMetadata pour afficher les informations à l'écran. Selon Google I/O 2024, un remplissage correct de MediaMetadata augmente la visibilité de l'application dans les lanceurs tiers de 40 %.

Composants clés de MediaSession

L'architecture MediaSession se compose de quatre composants interconnectés, chacun ayant son propre rôle. Le développeur doit implémenter les quatre pour une intégration complète avec le système.

• MediaSessionCompat — la classe principale de la session, créée avec une balise d'application et acceptant un PendingIntent pour les boutons multimédia.
• MediaSession.Callback — le gestionnaire de commandes. Implémente onPlay, onPause, onSkipToNext, onSeekTo et d'autres méthodes.
• PlaybackStateCompat — l'état actuel du lecteur. Contient les indicateurs, la position, la vitesse et la liste des actions disponibles.
• MediaMetadataCompat — les métadonnées du média en cours : titre, artiste, album, pochette, durée.

Cycle de vie de MediaSession

La session est créée dans la méthode onCreate d'un service ou d'une Activity en appelant MediaSessionCompat(context, tag). Après la création, setFlags(FLAG_HANDLES_MEDIA_BUTTONS | FLAG_HANDLES_TRANSPORT_CONTROLS) doit être appelé. Dans onDestroy, release() est appelé pour libérer les ressources système.

Une mauvaise gestion du cycle de vie est l'une des erreurs les plus courantes. Si release() n'est pas appelé, la session reste dans le système et l'application suivante peut recevoir un état obsolète. Android 13+ affiche un avertissement Logcat en cas de fuite de session.

Intégration de MediaSession dans l'application

L'intégration de base commence par la création d'une session et l'implémentation d'un Callback. Il est recommandé d'utiliser MediaSessionCompat de la bibliothèque AndroidX media, qui fournit une API unifiée pour toutes les versions d'Android — de l'API 14 à 35.

Création de MediaSession et du Callback

class MusicService : Service() {

    private lateinit var mediaSession: MediaSessionCompat
    private lateinit var stateBuilder: PlaybackStateCompat.Builder

    override fun onCreate() {
        super.onCreate()

        mediaSession = MediaSessionCompat(this, "MusicService")
        mediaSession.setFlags(
            MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS
                or MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS
        )
        mediaSession.setCallback(MediaSessionCallback())
        updatePlaybackState(false)
    }

    private inner class MediaSessionCallback : MediaSessionCompat.Callback() {
        override fun onPlay() {
            updatePlaybackState(true)
        }

        override fun onPause() {
            updatePlaybackState(false)
        }
    }

    private fun updatePlaybackState(isPlaying: Boolean) {
        stateBuilder = PlaybackStateCompat.Builder()
            .setState(
                if (isPlaying) PlaybackStateCompat.STATE_PLAYING
                else PlaybackStateCompat.STATE_PAUSED,
                AudioTrackCompat.CURRENT_POSITION_NOT_SET,
                1.0f
            )
            .setActions(
                PlaybackStateCompat.ACTION_PLAY
                    or PlaybackStateCompat.ACTION_PAUSE
                    or PlaybackStateCompat.ACTION_SKIP_TO_NEXT
                    or PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
            )
        mediaSession.setPlaybackState(stateBuilder.build())
    }

    override fun onDestroy() {
        mediaSession.release()
        super.onDestroy()
    }
}

Dans cet exemple, une MediaSession est créée avec la balise MusicService et des indicateurs pour gérer les boutons multimédia. Le Callback implémente onPlay et onPause, mettant à jour PlaybackState. La méthode setActions déclare les actions disponibles que le système affiche sur l'écran de verrouillage et dans le centre multimédia.

Configuration de MediaMetadata

private fun setMetadata(title: String, artist: String) {
    val metadata = MediaMetadataCompat.Builder()
        .putString(MediaMetadataCompat.METADATA_KEY_TITLE, title)
        .putString(MediaMetadataCompat.METADATA_KEY_ARTIST, artist)
        .putLong(MediaMetadataCompat.METADATA_KEY_DURATION, 300000L)
        .putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, albumArtUrl)
        .build()
    mediaSession.setMetadata(metadata)
}

Les métadonnées doivent être mises à jour à chaque changement de morceau. Le système utilise METADATA_KEY_TITLE et METADATA_KEY_ARTIST pour afficher les informations sur les écrans Bluetooth des voitures et les appareils portables. Si l'URI de la pochette n'est pas défini, le lecteur affichera un espace réservé gris.

Gestion des commandes multimédia depuis Bluetooth et les écouteurs

Les casques Bluetooth envoient des commandes via le profil AVRCP 1.6+. Android diffuse ces commandes sous forme d'intents ACTION_MEDIA_BUTTON, qui sont interceptés par MediaSession lorsque l'indicateur FLAG_HANDLES_MEDIA_BUTTONS est défini.

Lorsque l'utilisateur appuie sur le bouton Play d'écouteurs Bluetooth, le système crée un KeyEvent avec le code KEYCODE_MEDIA_PLAY, qui est distribué à la méthode onMediaButtonEvent du Callback. Si onPlay() est implémenté dans le Callback, le système l'appelle directement. Une simple pression sur le bouton du casque envoie KEYCODE_MEDIA_PLAY_PAUSE — le lecteur doit basculer l'état.

Gestion des scénarios complexes avec plusieurs boutons

Les écouteurs Bluetooth modernes peuvent avoir jusqu'à 5 boutons : volume +/-, play/pause, suivant, précédent. Chaque bouton génère son propre KeyEvent, qui doit être correctement traité par le Callback. Un double appui sur play/pause est généralement interprété comme un passage au morceau suivant (ACTION_SKIP_TO_NEXT) sur de nombreux casques.

Selon le Document de définition de compatibilité Android (2026), toutes les applications avec contenu multimédia doivent gérer correctement KEYCODE_MEDIA_PLAY_PAUSE. Ignorer cette exigence entraîne une diminution automatique de la note de l'application dans Google Play pour la catégorie Musique et Audio.

Synchronisation avec le centre multimédia système

À partir d'Android 11, le centre multimédia système (Panneau de contrôle multimédia) affiche jusqu'à 5 sessions récentes de MediaSession dans le volet de notifications. L'utilisateur peut contrôler le lecteur sans ouvrir l'application. Pour un affichage correct, il est nécessaire d'implémenter MediaBrowserService et de renseigner correctement PlaybackState.

Le Panneau de contrôle multimédia affiche : le titre du morceau, l'artiste, la pochette (depuis MediaMetadata), les boutons de contrôle (depuis les actions disponibles de PlaybackState). Si l'application ne met pas à jour PlaybackState au moins une fois toutes les 10 secondes pendant la lecture active, le centre multimédia masque la session du panneau.

Service au premier plan avec notification

private fun startForegroundService() {
    val notification = NotificationCompat.Builder(this, "media_channel")
        .setSmallIcon(R.drawable.ic_play)
        .setContentTitle("En cours de lecture")
        .setContentText(currentTrackTitle)
        .setPriority(NotificationCompat.PRIORITY_LOW)
        .setStyle(
            androidx.media.app.NotificationCompat.MediaStyle()
                .setMediaSession(mediaSession.sessionToken)
        )
        .build()
    startForeground(1001, notification)
}

La notification MediaStyle se lie à MediaSession via le sessionToken et affiche les boutons multimédia standard. Sans MediaStyle, la notification apparaît comme une alerte ordinaire sans boutons de contrôle. Android 13+ nécessite l'autorisation explicite POST_NOTIFICATIONS pour l'affichage.