Fonctionnalités audio

Android TV est compatible avec plusieurs sorties audio simultanées : enceintes du téléviseur, home cinéma HDMI, Bluetooth, etc. Ces appareils sont compatibles avec différents encodages (comme Dolby Digital+, DTS, PCM), taux d'échantillonnage et canaux. Les téléviseurs connectés en HDMI sont compatibles avec de nombreux formats, mais le Bluetooth n'est compatible qu'avec le PCM.

Les appareils audio disponibles et le routage peuvent changer pendant la lecture : les utilisateurs peuvent brancher à chaud un câble HDMI, connecter le Bluetooth ou modifier les paramètres. Les applications doivent s'adapter de manière fluide pour assurer une lecture continue en utilisant les capacités du nouvel appareil. Les formats non compatibles peuvent entraîner des erreurs ou des silences.

Proposez plusieurs encodages pour offrir une expérience optimale en fonction des capacités de l'appareil. Par exemple, Dolby Digital est utilisé s'il est compatible. Sinon, l'application utilise PCM. Consultez Formats multimédias compatibles pour connaître les décodeurs Android qui transforment les flux en PCM.

Au moment de la lecture, votre application de streaming doit créer un AudioTrack avec le meilleur AudioFormat compatible avec l'appareil audio de sortie.

Créer une piste au bon format

Les applications doivent créer un AudioTrack, lancer sa lecture et appeler getRoutedDevice() pour déterminer l'appareil audio par défaut sur lequel lire le son. Il peut s'agir, par exemple, d'une piste PCM sécurisée avec un court silence, utilisée uniquement pour déterminer l'appareil routé et ses capacités audio.

Obtenir les encodages compatibles

Utilisez getAudioProfiles() (niveau d'API 31 ou supérieur) ou getEncodings() (niveau d'API 23 ou supérieur) pour déterminer les formats audio disponibles sur l'appareil audio par défaut.

Vérifier les profils et formats audio compatibles

Utilisez AudioProfile (niveau d'API 31 ou supérieur) ou isDirectPlaybackSupported() (niveau d'API 29 ou supérieur) pour vérifier les combinaisons de format, de nombre de canaux et de taux d'échantillonnage compatibles.

Certains appareils Android sont capables de prendre en charge des encodages au-delà de ceux compatibles avec l'appareil audio de sortie. Ces formats supplémentaires doivent être détectés via isDirectPlaybackSupported(). Dans ce cas, les données audio sont réencodées dans un format compatible avec l'appareil audio de sortie. Utilisez isDirectPlaybackSupported() pour vérifier correctement la compatibilité avec le format choisi, même s'il n'est pas présent dans la liste renvoyée par getEncodings().

Acheminement audio anticipé

Android 13 (niveau d'API 33) a introduit les routes audio anticipées. Vous pouvez anticiper la compatibilité des attributs audio de l'appareil et préparer des pistes pour l'appareil audio actif. Vous pouvez utiliser getDirectPlaybackSupport() pour vérifier si la lecture directe est compatible avec l'appareil audio actuellement routé pour un format et des attributs donnés :

Kotlin

val format = AudioFormat.Builder()
    .setEncoding(AudioFormat.ENCODING_E_AC3)
    .setChannelMask(AudioFormat.CHANNEL_OUT_5POINT1)
    .setSampleRate(48000)
    .build()
val attributes = AudioAttributes.Builder()
    .setUsage(AudioAttributes.USAGE_MEDIA)
    .build()

if (AudioManager.getDirectPlaybackSupport(format, attributes) !=
    AudioManager.DIRECT_PLAYBACK_NOT_SUPPORTED
) {
    // The format and attributes are supported for direct playback
    // on the currently active routed audio path
} else {
    // The format and attributes are NOT supported for direct playback
    // on the currently active routed audio path
}

Java

AudioFormat format = new AudioFormat.Builder()
        .setEncoding(AudioFormat.ENCODING_E_AC3)
        .setChannelMask(AudioFormat.CHANNEL_OUT_5POINT1)
        .setSampleRate(48000)
        .build();
AudioAttributes attributes = new AudioAttributes.Builder()
        .setUsage(AudioAttributes.USAGE_MEDIA)
        .build();

if (AudioManager.getDirectPlaybackSupport(format, attributes) !=
        AudioManager.DIRECT_PLAYBACK_NOT_SUPPORTED) {
    // The format and attributes are supported for direct playback
    // on the currently active routed audio path
} else {
    // The format and attributes are NOT supported for direct playback
    // on the currently active routed audio path
}

Vous pouvez également interroger les profils compatibles avec la lecture multimédia directe via l'appareil audio actuellement routé. Cela exclut tous les profils non compatibles ou, par exemple, qui seraient transcodés par le framework Android :

Kotlin

private fun findBestAudioFormat(audioAttributes: AudioAttributes): AudioFormat {
    val preferredFormats = listOf(
        AudioFormat.ENCODING_E_AC3,
        AudioFormat.ENCODING_AC3,
        AudioFormat.ENCODING_PCM_16BIT,
        AudioFormat.ENCODING_DEFAULT
    )
    val audioProfiles = audioManager.getDirectProfilesForAttributes(audioAttributes)
    val bestAudioProfile = preferredFormats.firstNotNullOf { format ->
        audioProfiles.firstOrNull { it.format == format }
    }
    val sampleRate = findBestSampleRate(bestAudioProfile)
    val channelMask = findBestChannelMask(bestAudioProfile)
    return AudioFormat.Builder()
        .setEncoding(bestAudioProfile.format)
        .setSampleRate(sampleRate)
        .setChannelMask(channelMask)
        .build()
}

Java

private AudioFormat findBestAudioFormat(AudioAttributes audioAttributes) {
    Stream<Integer> preferredFormats = Stream.<Integer>builder()
            .add(AudioFormat.ENCODING_E_AC3)
            .add(AudioFormat.ENCODING_AC3)
            .add(AudioFormat.ENCODING_PCM_16BIT)
            .add(AudioFormat.ENCODING_DEFAULT)
            .build();
    Stream<AudioProfile> audioProfiles =
            audioManager.getDirectProfilesForAttributes(audioAttributes).stream();
    AudioProfile bestAudioProfile = (AudioProfile) preferredFormats.map(format ->
            audioProfiles.filter(profile -> profile.getFormat() == format)
                    .findFirst()
                    .orElseThrow(NoSuchElementException::new)
    );
    Integer sampleRate = findBestSampleRate(bestAudioProfile);
    Integer channelMask = findBestChannelMask(bestAudioProfile);
    return new AudioFormat.Builder()
            .setEncoding(bestAudioProfile.getFormat())
            .setSampleRate(sampleRate)
            .setChannelMask(channelMask)
            .build();
}

Dans cet exemple, preferredFormats est une liste d'instances AudioFormat. La liste est classée par ordre de préférence, du plus préféré au moins préféré. getDirectProfilesForAttributes() renvoie une liste d'objets AudioProfile compatibles pour l'appareil audio actuellement routé avec l'AudioAttributes fourni. La liste des éléments AudioFormat préférés est parcourue jusqu'à ce qu'un élément AudioProfile compatible soit trouvé. Ce AudioProfile est stocké sous la forme bestAudioProfile. Les taux d'échantillonnage et les masques de canaux optimaux sont déterminés à partir de bestAudioProfile. Enfin, une instance AudioFormat appropriée est créée.

Créer une piste audio

Les applications doivent utiliser ces informations pour créer un AudioTrack pour le AudioFormat de la plus haute qualité compatible avec l'appareil audio par défaut (et disponible pour le contenu sélectionné).

Intercepter les modifications apportées aux appareils audio

Pour intercepter les changements d'appareil audio et y réagir, les applications doivent :

  • Pour les niveaux d'API supérieurs ou égaux à 24, ajoutez un OnRoutingChangedListener pour surveiller les modifications apportées aux appareils audio (HDMI, Bluetooth, etc.).
  • Pour le niveau d'API 23, enregistrez un AudioDeviceCallback pour recevoir les modifications apportées à la liste des appareils audio disponibles.
  • Pour les niveaux d'API 21 et 22, surveillez les événements de branchement HDMI et utilisez les données supplémentaires des diffusions.
  • Enregistrez également un BroadcastReceiver pour surveiller les changements d'état de BluetoothDevice pour les appareils inférieurs à l'API 23, car AudioDeviceCallback n'est pas encore pris en charge.

Lorsqu'un changement d'appareil audio est détecté pour l'AudioTrack, l'application doit vérifier les fonctionnalités audio mises à jour et, si nécessaire, recréer l'AudioTrack avec un AudioFormat différent. Effectuez cette opération si un encodage de meilleure qualité est désormais pris en charge ou si l'encodage précédemment utilisé n'est plus pris en charge.

Exemple de code

Kotlin

// audioPlayer is a wrapper around an AudioTrack
// which calls a callback for an AudioTrack write error
audioPlayer.addAudioTrackWriteErrorListener {
    // error code can be checked here,
    // in case of write error try to recreate the audio track
    restartAudioTrack(findDefaultAudioDeviceInfo())
}

audioPlayer.audioTrack.addOnRoutingChangedListener({ audioRouting ->
    audioRouting?.routedDevice?.let { audioDeviceInfo ->
        // use the updated audio routed device to determine
        // what audio format should be used
        if (needsAudioFormatChange(audioDeviceInfo)) {
            restartAudioTrack(audioDeviceInfo)
        }
    }
}, handler)

Java

// audioPlayer is a wrapper around an AudioTrack
// which calls a callback for an AudioTrack write error
audioPlayer.addAudioTrackWriteErrorListener(new AudioTrackPlayer.AudioTrackWriteError() {
    @Override
    public void audioTrackWriteError(int errorCode) {
        // error code can be checked here,
        // in case of write error try to recreate the audio track
        restartAudioTrack(findDefaultAudioDeviceInfo());
    }
});

audioPlayer.getAudioTrack().addOnRoutingChangedListener(new AudioRouting.OnRoutingChangedListener() {
    @Override
    public void onRoutingChanged(AudioRouting audioRouting) {
        if (audioRouting != null && audioRouting.getRoutedDevice() != null) {
            AudioDeviceInfo audioDeviceInfo = audioRouting.getRoutedDevice();
            // use the updated audio routed device to determine
            // what audio format should be used
            if (needsAudioFormatChange(audioDeviceInfo)) {
                restartAudioTrack(audioDeviceInfo);
            }
        }
    }
}, handler);
Précédent
Lecture en arrière-plan dans une vignette "En écoute"
Suivant
Ajuster les paramètres d'affichage