Immagini

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

* 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 all'interno di una playlist, crea un MediaItem con l'URI dell'immagine e passalo al player. MediaItem deve avere un imageDurationMs per indicare la durata della visualizzazione dell'immagine.

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

// 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 fissa con un breve video.

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

Utilizzo di ProgressiveMediaSource

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

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

// 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 sono 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 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 caricato esternamente

Il MediaItem aggiunto al Player deve definire esplicitamente il tipo MIME APPLICATION_EXTERNALLY_LOADED_IMAGE per utilizzare i percorsi del codice della libreria di caricamento delle immagini:

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

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

Decodificatore di immagini che utilizza una libreria di caricamento di immagini

Il visualizzatore di immagini ha bisogno di un ExternallyLoadedImageDecoder per recuperare il Bitmap dal Uri. Questo decodificatore può essere fornito sostituendo DefaultRenderersFactory.getImageDecoderFactory.

L'esempio seguente utilizza Glide per caricare un'immagine:

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

ImageDecoder.Factory glideImageDecoderFactory =
    new ExternallyLoadedImageDecoder.Factory(
        request -> GlideFutures.submit(
            Glide.with(context).asBitmap().load(request.uri)));
Player player =
    new ExoPlayer.Builder(context)
        .setRenderersFactory(
            new DefaultRenderersFactory(context) {
              @Override
              protected ImageDecoder.Factory getImageDecoderFactory() {
                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 di immagini esterna, devi specificare un ExternalLoader per attivare questo precaricamento. Se non è possibile o necessario alcun precaricamento, questo caricatore deve comunque essere fornito, ma non può fare nulla.

L'esempio seguente utilizza Glide per assicurarsi che l'immagine richiesta venga precaricata sul disco:

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

ExternalLoader glidePreloader =
    request ->
        GlideFutures.submit(
            Glide.with(context)
                .asFile()
                .apply(
                    diskCacheStrategyOf(DiskCacheStrategy.DATA)
                        .priority(Priority.HIGH)
                        .skipMemoryCache(true))
                .load(request.uri));