Immagini

ExoPlayer supporta i seguenti formati immagine. Consulta Librerie di caricamento delle immagini per scoprire come eseguire l'integrazione con librerie esterne che potrebbero fornire supporto per un insieme diverso di formati.

Formato dell'immagine Supportato Note
BMP SÌ
GIF NO Nessun supporto per Extractor
JPEG SÌ
Foto in movimento JPEG SÌ Immagini statiche e video supportati
JPEG Ultra HDR SÌ Esegue il fallback a SDR prima di Android 14 o su display non HDR
PNG SÌ
WebP SÌ
HEIF/HEIC SÌ
Foto in movimento HEIC In parte È supportata solo l'immagine statica*
AVIF (base di riferimento) SÌ Decodificato solo su Android 14 e versioni successive

* La parte video delle foto in movimento HEIC può essere ottenuta con MetadataRetriever e riprodotta come file autonomo.

Utilizzo di MediaItem

Per riprodurre un'immagine come parte di una playlist, crea un MediaItem con l'URI dell'immagine e passalo al player. MediaItem deve avere un imageDurationMs per specificare per quanto tempo deve essere visualizzata l'immagine.

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

Foto in movimento

Le foto in movimento sono file che combinano un'immagine statica con un breve video.

  • Se la durata dell'immagine è definita con setImageDuration, la foto in movimento viene visualizzata per la durata dichiarata come immagine statica.
  • Se la durata dell'immagine non è definita, la foto in movimento viene riprodotta come video.

Utilizzo di ProgressiveMediaSource

Per ulteriori opzioni di personalizzazione, puoi creare un ProgressiveMediaSource e passarlo direttamente al player anziché a un MediaItem.

Kotlin

// Create a data source factory.
val dataSourceFactory = 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();

Personalizzare la riproduzione

ExoPlayer offre diversi modi per personalizzare l'esperienza di riproduzione in base alle esigenze della tua app. Per esempi, consulta la pagina Personalizzazione.

Librerie di caricamento delle immagini

Le immagini vengono spesso gestite da librerie di caricamento di immagini esterne, ad esempio Glide o Coil.

L'integrazione di queste librerie nella pipeline di riproduzione richiede tre passaggi:

  1. Definisci un MediaItem con il tipo MIME APPLICATION_EXTERNALLY_LOADED_IMAGE.
  2. Fornisci un decodificatore di immagini per recuperare un Bitmap dalla libreria di caricamento delle immagini.
  3. Fornisci un caricatore esterno per attivare la memorizzazione nella cache e il precaricamento.

MediaItem con tipo MIME immagine caricata esternamente

MediaItem aggiunto a Player deve definire il tipo MIME APPLICATION_EXTERNALLY_LOADED_IMAGE in modo esplicito per utilizzare i percorsi del codice della libreria di caricamento delle immagini:

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

Decodificatore di immagini che utilizza una libreria di caricamento delle immagini

Il renderer di immagini ha bisogno di un ExternallyLoadedImageDecoder per recuperare Bitmap da Uri. Questo decodificatore può essere fornito eseguendo l'override di DefaultRenderersFactory.getImageDecoderFactory.

L'esempio seguente utilizza Glide per caricare un'immagine, limitando l'output alle dimensioni del display per evitare di creare oggetti Bitmap molto grandi:

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

Precaricamento delle immagini con una libreria di caricamento delle immagini

Durante la riproduzione, il player richiede di precaricare l'immagine successiva una volta caricato completamente l'elemento precedente della playlist. Quando utilizzi una libreria di caricamento delle immagini esterne, devi specificare un ExternalLoader per attivare il precaricamento. Se non è possibile o necessario il precaricamento, questo loader deve comunque essere fornito, ma non può fare nulla.

L'esempio seguente utilizza Glide per assicurarsi che l'immagine richiesta venga precaricata sul 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 =
    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();