Immagini

ExoPlayer supporta i seguenti formati di immagini. Per informazioni su come eseguire l'integrazione con librerie esterne che potrebbero fornire supporto per un insieme diverso di formati, consulta Librerie di caricamento delle immagini.

Formato immagine Supportato Note
BMP SÌ
GIF NO Nessun supporto per l'estrattore
JPEG SÌ
Foto in movimento JPEG SÌ Immagine statica 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 SÌ
AVIF (baseline) SÌ Decodificato solo su Android 14 e versioni successive

Riprodurre immagini in una playlist

Per riprodurre un'immagine come parte di una playlist, crea un MediaItem con l'URI dell'immagine e passalo al player. Il 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();

Riprodurre 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.

Personalizzare il caricamento delle immagini con un'origine media

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

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.

Integrare librerie di caricamento delle immagini esterne

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

L'integrazione di queste librerie nella pipeline di riproduzione richiede 3 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.

Configurare gli elementi multimediali per il caricamento esterno

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:

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

Decodificare le immagini utilizzando una libreria esterna

Il renderer delle immagini richiede un ExternallyLoadedImageDecoder per recuperare il Bitmap dall'Uri. Questo decodificatore può essere fornito sostituendo DefaultRenderersFactory.getImageDecoderFactory.

L'esempio seguente utilizza Glide per caricare un'immagine, limitando l'output alle dimensioni di visualizzazione 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();

Precaricare le immagini utilizzando una libreria esterna

Durante la riproduzione, il player richiede di precaricare l'immagine successiva una volta che l'elemento precedente nella playlist è stato caricato completamente. Quando utilizzi una libreria di caricamento delle immagini esterna, devi specificare un ExternalLoader per attivare questo precaricamento. Se il precaricamento non è possibile o necessario, è comunque necessario fornire questo caricatore, 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: 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();