Images

ExoPlayer est compatible avec les formats d'image suivants. Consultez Bibliothèques de chargement d'images pour savoir comment intégrer des bibliothèques externes qui peuvent prendre en charge un ensemble de formats différents.

Format de l'image Compatible Notes
BMP OUI
GIF NON Aucune compatibilité avec l'extracteur
JPEG OUI
Photo animée JPEG OUI Images fixes et vidéos acceptées
JPEG Ultra HDR OUI Rétrogradation vers 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 (de 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. Le 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 qui combinent une image fixe et une courte vidéo.

  • Si la durée de l'image est définie avec setImageDuration, la photo animée est affichée 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 comme une vidéo.

Utiliser ProgressiveMediaSource

Pour obtenir 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 de plusieurs façons en fonction des besoins de votre application. Pour obtenir des exemples, 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 :

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

MediaItem avec type MIME d'image chargée 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'image utilisant 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, en limitant la sortie à la taille de l'écran afin d'éviter de créer des objets Bitmap très volumineux :

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échargement d'images avec une bibliothèque de chargement d'images

Pendant la lecture, le lecteur demande à précharger l'image suivante une fois que l'élément précédent de la playlist est 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 ou requis, ce chargeur doit quand même être fourni, mais il peut ne 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)
  )
}
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();