Notícias sobre produtos

Melhorando a reprodução de mídia: uma investigação detalhada do PreloadManager do Media3 – Parte 2

Leitura de 9 min
Ver o perfil de Mayuri Khinvasara Khabya
Mayuri Khinvasara Khabya Engenheiro de relações com desenvolvedores

Esta é a segunda parte da nossa série de três partes sobre pré-carregamento de mídia com o Media3. Esta série foi criada para orientar você no processo de criação de experiências de mídia altamente responsivas e de baixa latência nos seus apps Android.

  • A Parte 1: Introdução ao pré-carregamento com o Media3 abordou os conceitos básicos. Analisamos a diferença entre PreloadConfiguration para playlists simples e o DefaultPreloadManager, que é mais eficiente para interfaces do usuário dinâmicas. Você aprendeu a implementar o ciclo de vida básico da API: adicionar mídia com add(), recuperar uma MediaSource preparada com getMediaSource(), gerenciar prioridades com setCurrentPlayingIndex() e invalidate() e liberar recursos com remove() e release().
  • Parte 2 (esta postagem): neste blog, vamos conhecer os recursos avançados do DefaultPreloadManager. Vamos mostrar como receber insights com o PreloadManagerListener, implementar práticas recomendadas prontas para produção, como compartilhar componentes principais com o ExoPlayer, e dominar o padrão de janela deslizante para gerenciar a memória de forma eficaz.
  • Parte 3: a parte final desta série vai abordar a integração do PreloadManager com um cache em disco persistente, permitindo reduzir o consumo de dados com o gerenciamento de recursos e oferecer uma experiência integrada.

Se você não conhece o pré-carregamento no Media3, recomendamos ler a Parte 1 antes de continuar. Para quem já domina o básico, vamos descobrir como melhorar a implementação da reprodução de mídia.

Como ouvir: buscar análises com o PreloadManagerListener

Quando você quer lançar um recurso na produção, como desenvolvedor de apps, também quer entender e capturar as análises por trás dele. Como ter certeza de que sua estratégia de pré-carregamento é eficaz em um ambiente real? Para responder a isso, é preciso ter dados sobre taxas de sucesso, falhas e desempenho. A interface PreloadManagerListener é o principal mecanismo para coletar esses dados.

O PreloadManagerListener fornece dois callbacks essenciais que oferecem insights críticos sobre o processo e o status do pré-carregamento.

  • onCompleted(MediaItem mediaItem): esse callback é invocado após a conclusão de uma solicitação de pré-carregamento, conforme definido pelo TargetPreloadStatusControl.
  • onError(PreloadException error): esse callback pode ser útil para depuração e monitoramento. É invocado quando um pré-carregamento falha, fornecendo a exceção associada.

É possível registrar um listener com uma única chamada de método, conforme mostrado no exemplo de código a seguir:

val preloadManagerListener = object : PreloadManagerListener {
    override fun onCompleted(mediaItem: MediaItem) {
        // Log success for analytics. 
        Log.d("PreloadAnalytics", "Preload completed for $mediaItem")
    }

    override fun onError( preloadError: PreloadException) {
        // Log the specific error for debugging and monitoring.
        Log.e("PreloadAnalytics", "Preload error ", preloadError)
    }
}

preloadManager.addListener(preloadManagerListener)

Extração de insights do ouvinte 

Esses callbacks de listener podem ser conectados ao seu pipeline de análise. Ao encaminhar esses eventos para seu mecanismo de análise, você pode responder a perguntas importantes, como:

  • Qual é nossa taxa de sucesso de pré-carregamento? (proporção de eventos onCompleted em relação ao total de tentativas de pré-carregamento)
  • Quais CDNs ou formatos de vídeo apresentam as maiores taxas de erro? (analisando as exceções de onError)
  • Qual é nossa taxa de erro de pré-carregamento? (proporção de eventos onError em relação ao total de tentativas de pré-carregamento)

Esses dados podem fornecer feedback quantitativo sobre sua estratégia de pré-carregamento, permitindo testes A/B e melhorias baseadas em dados na experiência do usuário. Esses dados também podem ajudar você a ajustar de forma inteligente o pré-carregamento, as durações e o número de vídeos que você quer pré-carregar, além dos buffers que você aloca.

Além da depuração: como usar onError para um substituto de interface otimizado

Uma falha no pré-carregamento é um forte indicador de um evento de armazenamento em buffer para o usuário. O callback onError permite que você responda de forma reativa. Em vez de apenas registrar o erro, você pode adaptar a interface. Por exemplo, se o próximo vídeo não for pré-carregado, o aplicativo poderá desativar a reprodução automática para o próximo deslize, exigindo que o usuário toque para iniciar a reprodução.

Além disso, ao inspecionar o tipo PreloadException, é possível definir uma estratégia de nova tentativa mais inteligente. Um app pode remover imediatamente uma fonte com falha do gerenciador com base na mensagem de erro ou no código de status HTTP. O item precisaria ser removido do fluxo da interface para que os problemas de carregamento não afetassem a experiência do usuário. Você também pode receber dados mais granulares de PreloadException, como HttpDataSourceException, para investigar melhor os erros. Leia mais sobre a solução de problemas do ExoPlayer.

O sistema de parceria: por que é necessário compartilhar componentes com o ExoPlayer?

O DefaultPreloadManager e o ExoPlayer foram criados para funcionar juntos. Para garantir estabilidade e eficiência, eles precisam compartilhar vários componentes principais. Se eles operarem com componentes separados e não coordenados, isso poderá afetar a concorrência segura e a usabilidade das músicas pré-carregadas no player, já que precisamos garantir que as músicas pré-carregadas sejam tocadas no player correto. Os componentes separados também podem competir por recursos limitados, como largura de banda de rede e memória, o que pode levar à degradação do desempenho. Uma parte importante do ciclo de vida é lidar com o descarte adequado. A ordem recomendada é liberar o PreloadManager primeiro, seguido pelo ExoPlayer.

O DefaultPreloadManager.Builder foi projetado para facilitar esse compartilhamento e tem APIs para instanciar o PreloadManager e uma instância de player vinculada. Vamos entender por que componentes como BandwidthMeter, LoadControl, TrackSelector e Looper precisam ser compartilhados. Confira a representação visual de como esses componentes interagem com a reprodução do ExoPlayer.

preloadManager2.png

Como evitar conflitos de largura de banda com um BandwidthMeter compartilhado

O BandwidthMeter fornece uma estimativa da largura de banda de rede disponível com base nas taxas de transferência históricas. Se o PreloadManager e o player usarem instâncias separadas, eles não vão estar cientes da atividade da rede um do outro, o que pode levar a cenários de falha. Por exemplo, considere o cenário em que um usuário está assistindo um vídeo, a conexão de rede dele fica instável e o MediaSource de pré-carregamento inicia simultaneamente um download agressivo para um vídeo futuro. A atividade do MediaSource de pré-carregamento consumiria a largura de banda necessária para o player ativo, fazendo com que o vídeo atual fosse interrompido. Uma interrupção durante a reprodução é uma falha significativa na experiência do usuário.

Ao compartilhar um único BandwidthMeter, o TrackSelector pode selecionar faixas de maior qualidade de acordo com as condições atuais da rede e o estado do buffer durante o pré-carregamento ou a reprodução. Em seguida, ele pode tomar decisões inteligentes para proteger a sessão de reprodução ativa e garantir uma experiência tranquila.

preloadManagerBuilder.setBandwidthMeter(customBandwidthMeter)

Garantir a consistência com os componentes compartilhados LoadControl, TrackSelector e Renderer do ExoPlayer

  • LoadControl: esse componente dita a política de armazenamento em buffer, como a quantidade de dados a serem armazenados em buffer antes de iniciar a reprodução e quando iniciar ou interromper o carregamento de mais dados. O compartilhamento do LoadControl garante que o consumo de memória do player e do PreloadManager seja guiado por uma única estratégia de armazenamento em buffer coordenada em mídias pré-carregadas e em reprodução ativa, evitando a contenção de recursos. Você precisará alocar de forma inteligente o tamanho do buffer, coordenando com quantos itens você está pré-carregando e com qual duração, para garantir a consistência. Em momentos de contenção, o player prioriza a reprodução do item atual exibido na tela. Com um LoadControl compartilhado, o gerenciador de pré-carregamento vai continuar pré-carregando enquanto os bytes de buffer de destino alocados para o pré-carregamento não atingirem o limite máximo, sem esperar que o carregamento para reprodução seja concluído.

Observação: o compartilhamento de LoadControl na versão mais recente do Media3 (1.8) garante que o Allocator seja compartilhado corretamente com o PreloadManager e o player. O uso do LoadControl para controlar o pré-carregamento de forma eficaz é um recurso que estará disponível na próxima versão 1.9 do Media3.

preloadManagerBuilder.setLoadControl(customLoadControl)

  • TrackSelector: esse componente é responsável por selecionar quais faixas (por exemplo, vídeo de uma determinada resolução, áudio em um idioma específico) serão carregadas e reproduzidas. O compartilhamento garante que as faixas selecionadas durante o pré-carregamento sejam as mesmas que o player vai usar. Isso evita um cenário de desperdício em que uma faixa de vídeo de 480p é pré-carregada, mas o player a descarta imediatamente e busca uma faixa de 720p na reprodução.< br /> O gerenciador de pré-carregamento NÃO deve compartilhar a mesma instância de TrackSelector com o player. Em vez disso, eles precisam usar uma instância diferente de TrackSelector, mas da mesma implementação. Por isso, definimos o TrackSelectorFactory em vez de um TrackSelector no DefaultPreloadManager.Builder.

preloadManagerBuilder.setTrackSelectorFactory(customTrackSelectorFactory)

  • Renderer: esse componente é responsável por entender os recursos do player sem criar os renderizadores completos. Ele verifica esse blueprint para saber quais formatos de vídeo, áudio e texto o player final vai aceitar. Isso permite que ele selecione e baixe de forma inteligente apenas a faixa de mídia compatível e evita o desperdício de largura de banda com conteúdo que o player não consegue reproduzir.

preloadManagerBuilder.setRenderersFactory(customRenderersFactory)

Leia mais sobre os componentes do ExoPlayer.

A regra de ouro: um Playback Looper comum para todos os casos

A linha de execução em que uma instância do ExoPlayer pode ser acessada pode ser especificada explicitamente transmitindo um Looper ao criar o player. O Looper da linha de execução em que o player precisa ser acessado pode ser consultado usando Player.getApplicationLooper. Ao manter um Looper compartilhado entre o player e o PreloadManager, é garantido que todas as operações nesses objetos de mídia compartilhados sejam serializadas em uma única fila de mensagens de linha de execução. Isso pode reduzir os bugs de simultaneidade.

Todas as interações entre o PreloadManager e o player com fontes de mídia a serem carregadas ou pré-carregadas precisam acontecer na mesma linha de execução de reprodução. O compartilhamento do Looper é obrigatório para a concorrência segura. Por isso, precisamos compartilhar o PlaybackLooper entre o PreloadManager e o player.

O PreloadManager prepara um objeto MediaSource com estado em segundo plano. Quando o código da interface chama player.setMediaSource(mediaSource), você está transferindo esse objeto complexo e com estado do MediaSource de pré-carregamento para o player. Nesse cenário, todo o PreloadMediaSource é movido do gerenciador para o player. Todas essas interações e transferências precisam ocorrer no mesmo PlaybackLooper.

Se o PreloadManager e o ExoPlayer estivessem operando em linhas de execução diferentes, poderia ocorrer uma disputa. A linha de execução do PreloadManager pode estar modificando o estado interno do MediaSource (por exemplo, gravando novos dados em um buffer) no exato momento em que a linha de execução do player está tentando ler dele. Isso leva a um comportamento imprevisível, uma IllegalStateException que é difícil de depurar.

preloadManagerBuilder.setPreloadLooper(playbackLooper)

Vamos ver como você pode compartilhar todos os componentes acima entre o ExoPlayer e o DefaultPreloadManager na própria configuração.

val preloadManagerBuilder =
DefaultPreloadManager.Builder(context, targetPreloadStatusControl)

// Optional - Share components between ExoPlayer and DefaultPreloadManager
preloadManagerBuilder
     .setBandwidthMeter(customBandwidthMeter)
     .setLoadControl(customLoadControl)
     .setMediaSourceFactory(customMediaSourceFactory)
     .setTrackSelectorFactory(customTrackSelectorFactory)
     .setRenderersFactory(customRenderersFactory)
     .setPreloadLooper(playbackLooper)

val preloadManager = val preloadManagerBuilder.build()

Dica: se você usar os componentes padrão no ExoPlayer, como o DefaultLoadControl etc., não será necessário compartilhá-los explicitamente com o DefaultPreloadManager. Ao criar sua instância do ExoPlayer usando o buildExoPlayer do DefaultPreloadManager.Builder, esses componentes são referenciados automaticamente entre si, se você usar as implementações padrão com as configurações padrão. No entanto, se você usar componentes ou configurações personalizadas, notifique explicitamente o DefaultPreloadManager sobre eles usando as APIs acima.

Pré-carregamento pronto para produção: o padrão de janela deslizante

Em um feed dinâmico, o usuário pode rolar por uma quantidade praticamente infinita de conteúdo. Se você adicionar vídeos continuamente ao DefaultPreloadManager sem uma estratégia de remoção correspondente, inevitavelmente vai causar um OutOfMemoryError. Cada MediaSource pré-carregado contém uma SampleQueue, que aloca buffers de memória. À medida que se acumulam, eles podem esgotar o espaço de heap do aplicativo. A solução é um algoritmo que você talvez já conheça, chamado de janela deslizante. O padrão de janela deslizante mantém um conjunto pequeno e gerenciável de itens na memória que são logicamente adjacentes à posição atual do usuário no feed. Conforme o usuário rola a tela, essa "janela" de itens gerenciados desliza com ele, adicionando novos itens que aparecem e removendo os que estão distantes.

slidingwindow.png

Como implementar o padrão de janela deslizante

É importante entender que o PreloadManager não oferece um método setWindowSize() integrado. A janela deslizante é um padrão de design que você, como desenvolvedor, precisa implementar usando os métodos primitivos add() e remove(). A lógica do aplicativo precisa conectar eventos da interface, como uma rolagem ou mudança de página, a essas chamadas de API. Se você quiser uma referência de código para isso, temos esse padrão de janela deslizante implementado no exemplo socialite, que também inclui um PreloadManagerWrapper que imita uma janela deslizante.

Não se esqueça de adicionar preloadManager.remove(mediaItem) na sua implementação quando o item não tiver mais chances de aparecer em breve na visualização do usuário. Não remover itens que não estão mais próximos do usuário é a principal causa de problemas de memória em implementações de pré-carregamento. A chamada remove() garante que os recursos sejam liberados, o que ajuda a manter o uso da memória do app limitado e estável.

Ajustar uma estratégia de pré-carregamento categorizada com TargetPreloadStatusControl

Agora que definimos o que pré-carregar (os itens na janela), podemos aplicar uma estratégia bem definida para quanto pré-carregar para cada item. Já vimos como alcançar essa granularidade com a configuração de TargetPreloadStatusControl na Parte 1.

Lembre-se de que um item na posição +/- 1 pode ter uma probabilidade maior de ser reproduzido do que um item na posição +/- 4. Você pode alocar mais recursos (rede, CPU, memória) para os itens que o usuário provavelmente vai acessar em seguida. Isso cria uma estratégia de "pré-carregamento" com base na proximidade, que é a chave para equilibrar a reprodução imediata com o uso eficiente de recursos.

Você pode usar dados de análise pelo PreloadManagerListener, conforme discutido nas seções anteriores, para decidir sua estratégia de duração do pré-carregamento.

Conclusão e próximas etapas

Agora você tem o conhecimento avançado para criar feeds de mídia rápidos, estáveis e eficientes em termos de recursos usando o DefaultPreloadManager do Media3.

Vamos recapitular os principais aprendizados:

  • Use o PreloadManagerListener para coletar insights de análise e implementar um tratamento de erros robusto.
  • Sempre use um único DefaultPreloadManager.Builder para criar as instâncias do gerenciador e do player, garantindo que os componentes importantes sejam compartilhados.
  • Implemente o padrão de janela deslizante gerenciando ativamente as chamadas add() e remove() para evitar OutOfMemoryError.
  • Use TargetPreloadStatusControl para criar uma estratégia de pré-carregamento inteligente e em camadas que equilibre o desempenho e o consumo de recursos.

O que vem a seguir na Parte 3: Armazenamento em cache com mídia pré-carregada

O pré-carregamento de dados na memória oferece um benefício imediato de desempenho, mas pode ter desvantagens. Depois que o aplicativo é fechado ou a mídia pré-carregada é removida do gerenciador, os dados são excluídos. Para alcançar um nível mais persistente de otimização, podemos combinar o pré-carregamento com o cache em disco. Esse recurso está em desenvolvimento ativo e estará disponível em breve.

Quer compartilhar algum feedback? Queremos saber sua opinião.

Fique de olho e acelere a reprodução dos seus vídeos! 🚀

Escrito por:
Continue lendo