Notícias sobre produtos

Melhorando a reprodução de mídia: introdução ao pré-carregamento com o Media3 – Parte 1

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

Nos apps atuais, que são focados em mídia, oferecer uma experiência de reprodução tranquila e sem interrupções é fundamental para uma experiência do usuário agradável. Os usuários esperam que os vídeos comecem instantaneamente e sejam reproduzidos sem interrupções.

O principal desafio é a latência. Tradicionalmente, um player de vídeo só começa a funcionar (conectar, baixar, analisar, armazenar em buffer) depois que o usuário escolhe um item para reprodução. Essa abordagem reativa é lenta para o contexto atual de vídeos mais curtos. A solução é ser proativo. Precisamos prever o que o usuário vai assistir em seguida e preparar o conteúdo com antecedência. Essa é a essência do pré-carregamento.

Os principais benefícios do pré-carregamento incluem:

  • 🚀 Início de reprodução mais rápido: os vídeos já estão prontos para serem reproduzidos, o que resulta em transições mais rápidas entre os itens e um início mais imediato.
  • 📉 Menos armazenamento em buffer: ao carregar dados de forma proativa, a reprodução tem muito menos chances de travar, por exemplo, devido a problemas de rede.
  • ✨ Experiência do usuário mais tranquila: a combinação de inicializações mais rápidas e menos armazenamento em buffer cria uma interação mais fluida e integrada para os usuários.

Nesta série de três partes, vamos apresentar e fazer uma investigação aprofundada sobre os utilitários avançados do Media3 para (pré-)carregar componentes.

  • Na Parte 1, vamos abordar os conceitos básicos: entender as diferentes estratégias de pré-carregamento disponíveis no Media3, ativar a PreloadConfiguration e configurar o DefaultPreloadManager, permitindo que o app pré-carregue itens. Ao final deste blog, você vai conseguir pré-carregar e reproduzir itens de mídia com a classificação e a duração configuradas.
  • Na Parte 2, vamos abordar tópicos mais avançados do DefaultPreloadManager: uso de listeners para análise, práticas recomendadas prontas para produção, como o padrão de janela deslizante, e componentes compartilhados personalizados do DefaultPreloadManager e do ExoPlayer.
  • Na Parte 3, vamos falar sobre o armazenamento em cache em disco com o DefaultPreloadManager.

O pré-carregamento ao resgate! 🦸‍♀️

A ideia principal por trás do pré-carregamento é simples: carregar o conteúdo de mídia antes de precisar dele. Quando o usuário desliza para o próximo vídeo, os primeiros segmentos já estão disponíveis para download e prontos para reprodução imediata.

Pense nisso como um restaurante. Uma cozinha movimentada não espera um pedido para começar a picar cebolas. 🧅 Eles fazem o trabalho de preparação com antecedência. O pré-carregamento é o trabalho de preparação para o player de vídeo.

Quando ativado, o pré-carregamento pode ajudar a minimizar a latência de junção quando um usuário pula para o próximo item antes que o buffer de reprodução o alcance. O primeiro período da próxima janela é preparado, e as amostras de vídeo, áudio e texto são armazenadas em buffer. O período pré-carregado é colocado em fila no player com amostras em buffer imediatamente disponíveis e prontas para serem enviadas ao codec para renderização.

No Media3, há duas APIs principais para pré-carregamento, cada uma adequada para diferentes casos de uso. Escolher a API certa é o primeiro passo.

1. Pré-carregar itens de playlist com PreloadConfiguration

Essa é a abordagem simples, útil para mídias lineares e sequenciais, como playlists em que a ordem de reprodução é previsível (como uma série de episódios). Você fornece ao player a lista completa de itens de mídia usando as APIs de playlist do ExoPlayer e define a PreloadConfiguration para o player. Em seguida, ele pré-carrega automaticamente os próximos itens na sequência, conforme configurado. Essa API tenta otimizar a latência de mesclagem quando um usuário pula para o próximo item antes que o buffer de reprodução já se sobreponha ao próximo item.

O pré-carregamento só é iniciado quando nenhuma mídia está sendo carregada para a reprodução em andamento, o que evita que ele concorra por largura de banda com a reprodução principal.

Se você ainda não tiver certeza se precisa de pré-carregamento, essa API é uma ótima opção de baixo custo para testar.

player.preloadConfiguration =
    PreloadConfiguration(/* targetPreloadDurationUs= */ 5_000_000L)

Com a PreloadConfiguration acima, o player tenta pré-carregar cinco segundos de mídia para o próximo item na playlist.

Depois de ativar, o pré-carregamento de playlists pode ser desativado novamente usando PreloadConfiguration.DEFAULT:

player.preloadConfiguration = PreloadConfiguration.DEFAULT

2. Pré-carregar listas dinâmicas com o PreloadManager

Para interfaces dinâmicas, como feeds verticais ou carrosséis, em que o item "seguinte" é determinado pela interação do usuário, a API PreloadManager é adequada. Esse é um novo componente independente e eficiente na biblioteca ExoPlayer do Media3, projetado especificamente para pré-carregar de forma proativa. Ele gerencia uma coleção de possíveis MediaSources, priorizando-as com base na proximidade da posição atual do usuário, e oferece controle granular sobre o que pré-carregar, adequado para cenários complexos, como feeds dinâmicos de vídeos mais curtos.

Como configurar o PreloadManager

O DefaultPreloadManager é a implementação canônica do PreloadManager.

O builder de DefaultPreloadManager pode criar o DefaultPreloadManager e qualquer instância do ExoPlayer que vai reproduzir o conteúdo pré-carregado. Para criar um DefaultPreloadManager, você precisa transmitir um TargetPreloadStatusControl, que o gerenciador de pré-carregamento pode consultar para descobrir quanto carregar para um item. Vamos explicar e definir um exemplo de TargetPreloadStatusControl na seção abaixo.

val preloadManagerBuilder =
DefaultPreloadManager.Builder(context, targetPreloadStatusControl)
val preloadManager = val preloadManagerBuilder.build()

// Build ExoPlayer with DefaultPreloadManager.Builder
val player = preloadManagerBuilder.buildExoPlayer()

É necessário usar o mesmo builder para o ExoPlayer e o DefaultPreloadManager, o que garante que os componentes internos sejam compartilhados corretamente.

Pronto. Agora você tem um gerente pronto para receber instruções.

Como configurar a duração e a classificação com TargetPreloadStatusControl

E se você quiser pré-carregar, digamos, 10 segundos de vídeo? Você pode informar a posição dos itens de mídia no carrossel, e o DefaultPreloadManager prioriza o carregamento dos itens com base na proximidade do item que o usuário está reproduzindo no momento.

Se você quiser controlar a duração do item a ser pré-carregado, use o DefaultPreloadManager.PreloadStatus que você retornar.

Por exemplo,

  • O item "A" é a prioridade mais alta, carregue 5 segundos de vídeo.
  • O item "B" tem prioridade média, mas, quando você chegar nele, carregue 3 segundos de vídeo.
  • O item "C" tem prioridade menor, então carregue apenas as faixas.
  • O item "D" é ainda menos prioritário, basta se preparar.
  • Os outros itens estão distantes, então não pré-carregue nada.

Esse controle granular pode ajudar a otimizar o uso de recursos, o que é recomendado para uma reprodução sem interrupções.

import androidx.media3.exoplayer.DefaultPreloadManager.PreloadStatus


class MyTargetPreloadStatusControl(
    currentPlayingIndex: Int = C.INDEX_UNSET
) : TargetPreloadStatusControl<Int,PreloadStatus> {


    // The app is responsible for updating this based on UI state
    override fun getTargetPreloadStatus(index: Int): PreloadStatus? {

        val distance = index - currentPlayingIndex

        // Adjacent items (Next): preload 5 seconds
        if (distance == 1) { 
        // Return a PreloadStatus that is labelled by STAGE_SPECIFIED_RANGE_LOADED and suggest loading // 5000ms from the default start position
                    return PreloadStatus.specifiedRangeLoaded(5000L)
                } 

        // Adjacent items (Previous): preload 3 seconds
        else if (distance == -1) { 
        // Return a PreloadStatus that is labelled by STAGE_SPECIFIED_RANGE_LOADED //and suggest loading 3000ms from the default start position
                    return PreloadStatus.specifiedRangeLoaded(3000L)
                } 

        // Items two positions away: just select tracks
        else if (distance) == 2) {
        // Return a PreloadStatus that is labelled by STAGE_TRACKS_SELECTED
                    return PreloadStatus.TRACKS_SELECTED
                } 

        // Items four positions away: just select prepare
        else if (abs(distance) <= 4) {
        // Return a PreloadStatus that is labelled by STAGE_SOURCE_PREPARED
                    return PreloadStatus.SOURCE_PREPARED
                }

             // All other items are too far away
             return null
            }
}

Dica: o PreloadManager pode manter os itens anteriores e seguintes pré-carregados, enquanto o PreloadConfiguration só vai analisar os próximos itens.

Gerenciar itens de pré-carregamento

Depois de criar o gerenciador, você pode começar a dizer o que ele deve fazer. Conforme o usuário rola um feed, você identifica os próximos vídeos e os adiciona ao gerenciador. A interação com o PreloadManager é uma conversa orientada por estado entre a interface e o mecanismo de pré-carregamento.

1. Adicionar itens de mídia

Ao preencher o feed, informe ao gerenciador a mídia que ele precisa rastrear. Se você estiver começando, adicione a lista inteira que quer pré-carregar. Depois, você pode continuar adicionando um único item à lista conforme necessário. Você tem controle total sobre os itens na lista de pré-carregamento, o que significa que também precisa gerenciar o que é adicionado e removido do gerenciador.

val initialMediaItems = pullMediaItemsFromService(/* count= */ 20)
for (index in 0 until initialMediaItems.size) {
    preloadManager.add(
        initialMediaItems.get(index),index)
    )
}

O gerenciador vai começar a buscar dados para este MediaItem em segundo plano.

Depois de adicionar, peça ao gerenciador para reavaliar a nova lista (indicando que algo mudou, como a adição/remoção de um item ou que o usuário mudou para reproduzir um novo item).

preloadManager.invalidate()

2. Recuperar e reproduzir um item

Aqui vem a lógica de reprodução principal. Quando o usuário decide assistir esse vídeo, não é necessário criar um novo MediaSource. Em vez disso, você pede ao PreloadManager o que ele já preparou. É possível recuperar o MediaSource do gerenciador de pré-carregamento usando o MediaItem.

Se o item recuperado do PreloadManager for nulo, isso significa que o mediaItem ainda não foi pré-carregado ou adicionado ao PreloadManager. Portanto, você pode definir o mediaItem diretamente.

// When a media item is about to displ​​ay on the screen
val mediaSource = preloadManager.getMediaSource(mediaItem)
if (mediaSource!= null) {
  player.setMediaSource(mediaSource)
} else {
  // If mediaSource is null, that mediaItem hasn't been added yet.
  // So, send it directly to the player.
  player.setMediaItem(mediaItem)
}
player.prepare()
// When the media item is displaying at the center of the screen
player.play()

Ao preparar o MediaSource recuperado do PreloadManager, você faz a transição do pré-carregamento para a reprodução usando os dados que já estão na memória. Isso é o que torna o horário de início mais rápido.

3. Manter o índice atual sincronizado com a interface

Como nosso feed / lista pode ser dinâmico, é importante notificar o PreloadManager sobre o índice de reprodução atual para que ele possa sempre priorizar os itens mais próximos do índice atual para pré-carregamento.

preloadManager.setCurrentPlayingIndex(currentIndex)
// Need to call invalidate() to update the priorities
preloadManager.invalidate()

4. Remover um item

Para manter o gerenciador eficiente, remova os itens que não precisam mais ser rastreados, como aqueles que estão longe da posição atual do usuário.

// When an item is too far from the current playing index
preloadManager.remove(mediaItem)

Se você precisar limpar todos os itens de uma vez, chame preloadManager.reset().

5. Liberar o gerenciador

Quando você não precisar mais do PreloadManager (por exemplo, quando a interface for destruída), libere-o para liberar os recursos. Um bom lugar para fazer isso é onde você já está liberando os recursos do Player. Recomendamos liberar o gerenciador antes do player, porque ele pode continuar a reprodução se você não precisar de mais pré-carregamento.

// In your Activity's onDestroy() or Composable's onDispose
preloadManager.release()

Demonstração

Confira ao vivo 👍

Na demonstração abaixo, vemos o impacto do PreloadManager no lado direito, que tem tempos de carregamento mais rápidos, enquanto o lado esquerdo mostra a experiência atual. Você também pode conferir o exemplo de código da demonstração. (Bônus: ele também mostra a latência de inicialização de cada vídeo)

Demo-PreloadManager_2.webp

A seguir

E chegamos ao fim da Parte 1. Agora você tem as ferramentas para criar um sistema de pré-carregamento dinâmico. Você pode usar PreloadConfiguration para pré-carregar o próximo item de uma playlist no ExoPlayer ou configurar um DefaultPreloadManager, adicionar e remover itens em tempo real, configurar o status de pré-carregamento de destino e recuperar corretamente o conteúdo pré-carregado para reprodução.

Na Parte 2, vamos nos aprofundar no DefaultPreloadManager. Vamos mostrar como detectar eventos de pré-carregamento, discutir práticas recomendadas, como usar uma janela deslizante para evitar problemas de memória, e analisar os componentes compartilhados personalizados do ExoPlayer e do DefaultPreloadManager.

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

Fique de olho e deixe seu app mais rápido. 🚀

Escrito por:
Continue lendo