Imagens

O ExoPlayer é compatível com os seguintes formatos de imagem. Consulte Bibliotecas de carregamento de imagens para saber como fazer a integração com bibliotecas externas que podem oferecer suporte a um conjunto diferente de formatos.

Formato da imagem Compatível Observações
BMP SIM
GIF NÃO Sem suporte ao Extractor
JPEG SIM
Foto com movimento JPEG SIM Compatível com imagens estáticas e vídeos
JPEG Ultra HDR SIM Volta para SDR antes do Android 14 ou em telas não HDR
PNG SIM
WebP SIM
HEIF/HEIC SIM
Foto com movimento HEIC SIM
AVIF (valor de referência) SIM Decodificado apenas no Android 14 ou mais recente

Reproduzir imagens em uma playlist

Para reproduzir uma imagem como parte de uma playlist, crie um MediaItem com o URI da imagem e transmita-o ao player. O MediaItem precisa ter um imageDurationMs para especificar por quanto tempo a imagem deve ser exibida.

Kotlin

// Create a player instance.
val player = ExoPlayer.Builder(context).build()
// Set the media item to be played with the desired duration.
player.setMediaItem(MediaItem.Builder().setUri(imageUri).setImageDurationMs(2000).build())
// Prepare the player.
player.prepare()

Java

// Create a player instance.
ExoPlayer player = new ExoPlayer.Builder(context).build();
// Set the media item to be played with the desired duration.
player.setMediaItem(new MediaItem.Builder().setUri(imageUri).setImageDurationMs(2000).build());
// Prepare the player.
player.prepare();

Reproduzir fotos com movimento

As fotos com movimento são arquivos que combinam uma imagem estática com um vídeo curto.

  • Se a duração da imagem for definida com setImageDuration, a foto com movimento será mostrada como uma imagem estática durante o tempo declarado.
  • Se a duração da imagem não for definida, a foto com movimento será reproduzida como um vídeo.

Personalizar o carregamento de imagens com uma fonte de mídia

Para mais opções de personalização, crie um ProgressiveMediaSource e transmita-o diretamente ao player em vez de um MediaItem.

Kotlin

// Create a data source factory.
val dataSourceFactory: DataSource.Factory = DefaultHttpDataSource.Factory()
// Create a media item with the image URI and the desired duration.
val mediaItem = MediaItem.Builder().setUri(imageUri).setImageDurationMs(2000).build()
// Create a progressive media source for this media item.
val mediaSource = ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(mediaItem)
// Create a player instance.
val player = ExoPlayer.Builder(context).build()
// Set the media source to be played.
player.setMediaSource(mediaSource)
// Prepare the player.
player.prepare()

Java

// Create a data source factory.
DataSource.Factory dataSourceFactory = new DefaultHttpDataSource.Factory();
// Create a media item with the image URI and the desired duration.
MediaItem mediaItem = new MediaItem.Builder().setUri(imageUri).setImageDurationMs(2000).build();
// Create a progressive media source for this media item.
MediaSource mediaSource =
    new ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(mediaItem);
// Create a player instance.
ExoPlayer player = new ExoPlayer.Builder(context).build();
// Set the media source to be played.
player.setMediaSource(mediaSource);
// Prepare the player.
player.prepare();

Personalizar reprodução

O ExoPlayer oferece várias maneiras de personalizar a experiência de reprodução de acordo com as necessidades do seu app. Consulte a página de personalização para ver exemplos.

Integrar bibliotecas de carregamento de imagens externas

As imagens geralmente são gerenciadas por bibliotecas externas de carregamento de imagens, como Glide ou Coil.

A integração dessas bibliotecas ao pipeline de reprodução requer três etapas:

  1. Defina um MediaItem com o tipo MIME APPLICATION_EXTERNALLY_LOADED_IMAGE.
  2. Forneça um decodificador de imagem para recuperar um Bitmap da biblioteca de carregamento de imagens.
  3. Forneça um carregador externo para acionar o armazenamento em cache e o pré-carregamento.

Configurar itens de mídia para carregamento externo

O MediaItem adicionado ao Player precisa definir o tipo MIME APPLICATION_EXTERNALLY_LOADED_IMAGE explicitamente para usar os caminhos de código da biblioteca de carregamento de imagens:

Kotlin

val mediaItem =
  MediaItem.Builder()
    .setUri(imageUri)
    .setMimeType(MimeTypes.APPLICATION_EXTERNALLY_LOADED_IMAGE)
    .build()

Java

MediaItem mediaItem =
    new MediaItem.Builder()
        .setUri(imageUri)
        .setMimeType(MimeTypes.APPLICATION_EXTERNALLY_LOADED_IMAGE)
        .build();

Decodificar imagens usando uma biblioteca externa

O renderizador de imagens precisa de um ExternallyLoadedImageDecoder para recuperar o Bitmap do Uri. Esse decodificador pode ser fornecido substituindo DefaultRenderersFactory.getImageDecoderFactory.

O exemplo a seguir usa o Glide para carregar uma imagem, limitando a saída ao tamanho da tela para evitar a criação de objetos Bitmap muito grandes:

Kotlin

val glideImageDecoderFactory: ImageDecoder.Factory =
  ExternallyLoadedImageDecoder.Factory { request: ExternalImageRequest ->
    val displaySize = Util.getCurrentDisplayModeSize(context)
    GlideFutures.submit(
      Glide.with(context)
        .asBitmap()
        .load(request.uri)
        .override(max(displaySize.x, displaySize.y))
    )
  }
val player: Player =
  ExoPlayer.Builder(context)
    .setRenderersFactory(
      object : DefaultRenderersFactory(context) {
        override fun getImageDecoderFactory(context: Context): ImageDecoder.Factory {
          return glideImageDecoderFactory
        }
      }
    )
    .build()

Java

ImageDecoder.Factory glideImageDecoderFactory =
    new ExternallyLoadedImageDecoder.Factory(
        request -> {
          Point displaySize = Util.getCurrentDisplayModeSize(context);
          return GlideFutures.submit(
              Glide.with(context)
                  .asBitmap()
                  .load(request.uri)
                  .override(max(displaySize.x, displaySize.y)));
        });
Player player =
    new ExoPlayer.Builder(context)
        .setRenderersFactory(
            new DefaultRenderersFactory(context) {
              @Override
              protected ImageDecoder.Factory getImageDecoderFactory(Context context) {
                return glideImageDecoderFactory;
              }
            })
        .build();

Pré-carregar imagens usando uma biblioteca externa

Durante a reprodução, o player solicita o pré-carregamento da próxima imagem assim que o item anterior na playlist é totalmente carregado. Ao usar uma biblioteca externa de carregamento de imagens, especifique um ExternalLoader para acionar esse pré-carregamento. Se nenhum pré-carregamento for possível ou necessário, esse carregador ainda precisará ser fornecido, mas não poderá fazer nada.

O exemplo a seguir usa o Glide para garantir que a imagem solicitada seja pré-carregada no disco:

Kotlin

val glidePreloader = ExternalLoader { request: LoadRequest ->
  GlideFutures.submit(
    Glide.with(context)
      .asFile()
      .apply(
        RequestOptions.diskCacheStrategyOf(DiskCacheStrategy.DATA)
          .priority(Priority.HIGH)
          .skipMemoryCache(true)
      )
      .load(request.uri)
  )
}
val player: Player =
  ExoPlayer.Builder(context)
    .setMediaSourceFactory(
      DefaultMediaSourceFactory(context).setExternalImageLoader(glidePreloader)
    )
    .build()

Java

ExternalLoader glidePreloader =
    request ->
        GlideFutures.submit(
            Glide.with(context)
                .asFile()
                .apply(
                    diskCacheStrategyOf(DiskCacheStrategy.DATA)
                        .priority(Priority.HIGH)
                        .skipMemoryCache(true))
                .load(request.uri));
Player player =
    new ExoPlayer.Builder(context)
        .setMediaSourceFactory(
            new DefaultMediaSourceFactory(context).setExternalImageLoader(glidePreloader))
        .build();