Cette page a été traduite par l'API Cloud Translation.

Images

ExoPlayer est compatible avec les formats d'image suivants. Consultez la section Bibliothèques de chargement d'images pour découvrir comment intégrer des bibliothèques externes pouvant prendre en charge un autre ensemble de formats.

Format d'image	Compatible	Notes
BMP	OUI
GIF	NON	Aucune compatibilité avec l'extracteur
JPEG	OUI
Photo animée JPEG	OUI	Images fixes et vidéos compatibles
JPEG Ultra HDR	OUI	Retourne à la SDR avant Android 14 ou sur les écrans non HDR
PNG	OUI
WebP	OUI
HEIF/HEIC	OUI
Photo animée HEIC	En partie	Seules les images fixes sont acceptées*
AVIF (référence)	OUI	Décodé sur Android 14 ou version ultérieure uniquement

* La partie vidéo des photos animées HEIC peut être obtenue avec MetadataRetriever et lue en tant que fichier autonome.

Utiliser MediaItem

Pour lire une image dans une playlist, créez un MediaItem avec l'URI de l'image et transmettez-le au lecteur. MediaItem doit comporter un imageDurationMs pour spécifier la durée d'affichage de l'image.

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

Photos animées

Les photos animées sont des fichiers combinant une image fixe et une courte vidéo.

Si la durée de l'image est définie avec setImageDuration, la photo animée s'affiche pendant la durée déclarée en tant qu'image fixe.
Si la durée de l'image n'est pas définie, la photo animée est lue en tant que vidéo.

Utiliser ProgressiveMediaSource

Pour plus d'options de personnalisation, vous pouvez créer un ProgressiveMediaSource et le transmettre directement au lecteur au lieu d'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();

Personnaliser la lecture

ExoPlayer vous permet de personnaliser l'expérience de lecture en fonction des besoins de votre application de plusieurs façons. Pour en savoir plus, consultez la page Personnalisation.

Bibliothèques de chargement d'images

Les images sont souvent gérées par des bibliothèques de chargement d'images externes, par exemple Glide ou Coil.

L'intégration de ces bibliothèques dans le pipeline de lecture nécessite trois étapes:

Définissez un MediaItem avec le type MIME APPLICATION_EXTERNALLY_LOADED_IMAGE.
Fournissez un décodeur d'image pour récupérer un Bitmap à partir de la bibliothèque de chargement d'images.
Fournissez un chargeur externe pour déclencher le stockage en cache et le préchargement.

MediaItem avec type MIME d'image chargé en externe

Le MediaItem ajouté au Player doit définir explicitement le type MIME APPLICATION_EXTERNALLY_LOADED_IMAGE pour utiliser les chemins de code de la bibliothèque de chargement d'images:

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

Décodeur d'images à l'aide d'une bibliothèque de chargement d'images

Le moteur de rendu d'images a besoin d'un ExternallyLoadedImageDecoder pour récupérer le Bitmap à partir du Uri. Ce décodeur peut être fourni en remplaçant DefaultRenderersFactory.getImageDecoderFactory.

L'exemple suivant utilise Glide pour charger une image:

Kotlin

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

Java

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

Préchargement d'images avec une bibliothèque de chargement d'images

Lors de la lecture, le lecteur demande à précharger l'image suivante une fois l'élément précédent de la playlist entièrement chargé. Lorsque vous utilisez une bibliothèque de chargement d'images externe, vous devez spécifier un ExternalLoader pour déclencher ce préchargement. Si aucun préchargement n'est possible ni requis, ce chargeur doit toujours être fourni, mais ne peut rien faire.

L'exemple suivant utilise Glide pour s'assurer que l'image demandée est préchargée sur le disque:

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)
  )
}

Java

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