Recursos de áudio

O Android TV oferece suporte a várias saídas de áudio simultâneas: alto-falantes da TV, home cinema HDMI, Bluetooth e muito mais. Esses dispositivos oferecem suporte a várias codificações (como Dolby Digital+, DTS, PCM), taxas de amostragem e canais. As TVs conectadas por HDMI oferecem suporte a muitos formatos, mas o Bluetooth só oferece suporte a PCM.

Os dispositivos de áudio e o roteamento disponíveis podem mudar durante a reprodução: os usuários podem conectar HDMI, Bluetooth ou modificar as configurações. Os apps precisam se adaptar normalmente para garantir a reprodução contínua usando os recursos do novo dispositivo. Formatos não compatíveis podem causar erros ou silêncio.

Ofereça várias codificações para a melhor experiência com base nos recursos do dispositivo. Por exemplo, o Dolby Digital é usado se houver suporte. Caso contrário, o app volta para o PCM. Consulte Formatos de mídia com suporte para decodificadores do Android que transformam streams em PCM.

No momento da reprodução, o app de streaming precisa criar um AudioTrack com o melhor AudioFormat compatível com o dispositivo de áudio de saída.

Criar uma faixa com o formato certo

Os apps precisam criar um AudioTrack, começar a reproduzi-lo e chamar getRoutedDevice() para determinar o dispositivo de áudio padrão em que o som será reproduzido. Isso pode ser, por exemplo, uma faixa codificada em PCM de silêncio curto e seguro usada apenas para determinar o dispositivo roteado e os recursos de áudio dele.

Receber codificações com suporte

Use getAudioProfiles() (nível 31 da API e mais recentes) ou getEncodings() (nível 23 da API e mais recentes) para determinar os formatos de áudio disponíveis no dispositivo de áudio padrão.

Verificar os formatos e perfis de áudio com suporte

Use AudioProfile (nível 31 da API e mais recentes) ou isDirectPlaybackSupported() (nível 29 da API e mais recentes) para verificar as combinações compatíveis de formato, número de canais e taxa de amostragem.

Alguns dispositivos Android são capazes de oferecer suporte a codificações além daquelas compatíveis com o dispositivo de áudio de saída. Esses formatos extras precisam ser detectados usando isDirectPlaybackSupported(). Nesses casos, os dados de áudio são recodificados para um formato compatível com o dispositivo de áudio de saída. Use isDirectPlaybackSupported() para verificar corretamente o suporte ao formato escolhido, mesmo que ele não esteja presente na lista retornada por getEncodings().

Observação: antes do nível 33 da API, isDirectPlaybackSupported() considera todos os caminhos de saída de áudio disponíveis, mesmo aqueles que não estão roteados no momento. Por exemplo, considere o que ocorre quando você conecta um HDMI que oferece suporte à reprodução direta e fones de ouvido com Bluetooth que não oferecem. Nesse caso, a função retorna "true", mesmo que o áudio seja reproduzido apenas nos fones de ouvido com Bluetooth e a criação de um AudioTrack direto falhe. É possível criar um AudioTrack direto definindo o FLAG_HW_AV_SYNC. Para o nível 33 da API e mais recentes, isso só considera o roteamento de áudio ativo no momento.

Rota de áudio antecipada

O Android 13 (nível da API 33) introduziu rotas de áudio antecipadas. É possível antecipar o suporte a atributos de áudio do dispositivo e preparar faixas para o dispositivo de áudio ativo. Use getDirectPlaybackSupport() para verificar se a reprodução direta é compatível com o dispositivo de áudio roteado no momento para um determinado formato e atributos:

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
}
AudioCapabilities.kt

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
}

Como alternativa, você pode consultar quais perfis são compatíveis com a reprodução de mídia direta pelo dispositivo de áudio roteado no momento. Isso exclui todos os perfis que não são compatíveis ou que, por exemplo, seriam transcodificados pelo framework do 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()
}
AudioCapabilities.kt

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();
}

Neste exemplo, preferredFormats é uma lista de instâncias de AudioFormat. Ela é ordenada com o mais preferido primeiro na lista e o menos preferido por último. getDirectProfilesForAttributes() retorna uma lista de objetos AudioProfile com suporte para o dispositivo de áudio roteado no momento com os AudioAttributes fornecidos. A lista de itens AudioFormat preferidos é iterada até que um AudioProfile compatível seja encontrado. Este AudioProfile é armazenado como bestAudioProfile. As taxas de amostragem e as máscaras de canal ideais são determinadas em bestAudioProfile. Por fim, uma instância apropriada AudioFormat é criada.

Criar faixa de áudio

Os apps precisam usar essas informações para criar um AudioTrack para o AudioFormat de maior qualidade com suporte pelo dispositivo de áudio padrão (e disponível para o conteúdo selecionado).

Interceptar mudanças no dispositivo de áudio

Para interceptar e reagir a mudanças no dispositivo de áudio, os apps precisam:

• Para níveis 24 da API ou mais recentes, adicione um OnRoutingChangedListener para monitorar mudanças no dispositivo de áudio (HDMI, Bluetooth etc.).
• Para o nível 23 da API, registre um AudioDeviceCallback para receber mudanças na lista de dispositivos de áudio disponíveis.
• Para os níveis 21 e 22 da API, monitore eventos de plug-in HDMI e use os dados extras das transmissões.
• Registre também um BroadcastReceiver para monitorar BluetoothDevice mudanças de estado para dispositivos anteriores à API 23, já que AudioDeviceCallback ainda não tem suporte.

Quando uma mudança no dispositivo de áudio for detectada para o AudioTrack, o app precisará verificar os recursos de áudio atualizados e, se necessário, recriar o AudioTrack com um AudioFormat diferente. Faça isso se uma codificação de maior qualidade for compatível ou se a codificação usada anteriormente não tiver mais suporte.

Observação: a gravação de dados em um AudioTrack em um formato sem suporte pode acionar erros do framework (como "Erro -32 durante a leitura nativa do AudioTrack"). Isso pode acontecer mesmo antes de a callback de roteamento de áudio em mudança ser chamada. Intercepte-os e recrie o AudioTrack de acordo com os recursos do novo dispositivo roteado.

Exemplo de código

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)
AudioCapabilities.kt

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);