Bilder

ExoPlayer unterstützt die folgenden Bildformate. Unter Bibliotheken zum Laden von Bildern erfahren Sie, wie Sie externe Bibliotheken einbinden, die möglicherweise eine andere Reihe von Formaten unterstützen.

Bildformat Unterstützt Hinweise
BMP JA
GIF NEIN Keine Extractor-Unterstützung
JPEG JA
JPEG-Foto mit Bewegtbild JA Standbild und Video werden unterstützt
JPEG Ultra HDR JA Fällt vor Android 14 oder auf Nicht-HDR-Displays auf SDR zurück
PNG JA
WebP JA
HEIF/HEIC JA
HEIC-Foto mit Bewegtbild JA
AVIF (Baseline) JA Nur unter Android 14 und höher decodiert

Bilder in einer Playlist abspielen

Wenn Sie ein Bild als Teil einer Playlist abspielen möchten, erstellen Sie ein MediaItem mit dem Bild-URI und übergeben Sie es an den Player. Das MediaItem muss ein imageDurationMs haben, um anzugeben, wie lange das Bild angezeigt werden soll.

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

Fotos mit Bewegtbild abspielen

Fotos mit Bewegtbild sind Dateien, die ein Standbild mit einem kurzen Video kombinieren.

  • Wenn die Bilddauer mit setImageDuration definiert ist, wird das Foto mit Bewegtbild für die angegebene Dauer als Standbild angezeigt.
  • Wenn die Bilddauer nicht definiert ist, wird das Foto mit Bewegtbild als Video abgespielt.

Laden von Bildern mit einer MediaSource anpassen

Für weitere Anpassungsoptionen können Sie eine ProgressiveMediaSource erstellen und sie anstelle eines MediaItem direkt an den Player übergeben.

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

Wiedergabe anpassen

ExoPlayer bietet mehrere Möglichkeiten, die Wiedergabe an die Anforderungen Ihrer App anzupassen. Beispiele finden Sie auf der Seite „Anpassung“.

Externe Bibliotheken zum Laden von Bildern einbinden

Bilder werden häufig von externen Bibliotheken zum Laden von Bildern verwaltet, z. B. Glide oder Coil.

Die Einbindung dieser Bibliotheken in die Wiedergabepipeline erfordert drei Schritte:

  1. Definieren Sie ein MediaItem mit dem MIME-Typ APPLICATION_EXTERNALLY_LOADED_IMAGE.
  2. Geben Sie einen Bilddecoder an, um ein Bitmap aus der Bibliothek zum Laden von Bildern abzurufen.
  3. Geben Sie einen externen Loader an, um das Caching und das Vorabladen auszulösen.

MediaItems für das externe Laden konfigurieren

Für das MediaItem, das dem Player hinzugefügt wird, muss der MIME-Typ APPLICATION_EXTERNALLY_LOADED_IMAGE explizit definiert werden, um die Codepfade der Bibliothek zum Laden von Bildern zu verwenden:

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

Bilder mit einer externen Bibliothek decodieren

Der Bild-Renderer benötigt einen ExternallyLoadedImageDecoder, um das Bitmap aus dem Uri abzurufen. Dieser Decoder kann durch Überschreiben von DefaultRenderersFactory.getImageDecoderFactory bereitgestellt werden.

Im folgenden Beispiel wird Glide verwendet, um ein Bild zu laden. Die Ausgabe wird auf die Anzeigegröße beschränkt, um zu vermeiden, dass sehr große Bitmap-Objekte erstellt werden:

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

Bilder mit einer externen Bibliothek vorab laden

Während der Wiedergabe fordert der Player an, das nächste Bild vorab zu laden, sobald das vorherige Element in der Playlist vollständig geladen wurde. Wenn Sie eine externe Bibliothek zum Laden von Bildern verwenden, müssen Sie einen ExternalLoader angeben, um dieses Vorabladen auszulösen. Wenn kein Vorabladen möglich oder erforderlich ist, muss dieser Loader trotzdem bereitgestellt werden, kann aber nichts tun.

Im folgenden Beispiel wird Glide verwendet, um sicherzustellen, dass das angeforderte Bild vorab auf die Festplatte geladen wird:

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