Diese Seite wurde von der Cloud Translation API übersetzt.

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 Unterstützung für Extractor
JPEG	JA
JPEG-Fotos mit bewegtem Motiv	JA	Standbilder und Videos werden unterstützt
JPEG Ultra HDR	JA	Rückfall auf SDR vor Android 14 oder auf Nicht-HDR-Displays
PNG	JA
WebP	JA
HEIF/HEIC	JA
HEIC-Fotos mit Bewegtbild	Teilweise	Nur Standbilder werden unterstützt*
AVIF (ursprüngliche Variante)	JA	Nur unter Android 14 und höher decodiert

* Der Videoteil von HEIC-Fotos mit Bewegtbild kann mit MetadataRetriever abgerufen und als eigenständige Datei wiedergegeben werden.

MediaItem verwenden

Wenn du ein Bild als Teil einer Playlist abspielen möchtest, erstelle eine MediaItem mit dem Bild-URI und leite sie an den Player weiter. Die MediaItem muss eine 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

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

ProgressiveMediaSource verwenden

Wenn du mehr Anpassungsoptionen benötigst, kannst du eine ProgressiveMediaSource erstellen und sie direkt an den Player übergeben, anstatt eine MediaItem zu verwenden.

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

Wiedergabe anpassen

Mit ExoPlayer hast du mehrere Möglichkeiten, die Wiedergabe an die Anforderungen deiner App anzupassen. Beispiele finden Sie auf der Seite „Anpassen“.

Bibliotheken zum Laden von Bildern

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

Die Integration dieser Bibliotheken in die Wiedergabepipeline umfasst drei Schritte:

Definiere eine MediaItem mit dem MIME-Typ APPLICATION_EXTERNALLY_LOADED_IMAGE.
Geben Sie einen Bilddekoder an, um ein Bitmap aus der Bildladebibliothek abzurufen.
Bieten Sie einen externen Loader an, um Caching und Vorabladen auszulösen.

MediaItem mit extern geladenem Bild-MIME-Typ

Die MediaItem, die der Player hinzugefügt wird, muss den MIME-Typ APPLICATION_EXTERNALLY_LOADED_IMAGE explizit definieren, 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();

Bilddecoder mit einer Bildladebibliothek

Der Bild-Renderer benötigt eine ExternallyLoadedImageDecoder, um die Bitmap aus der Uri abzurufen. Dieser Decoder kann bereitgestellt werden, indem DefaultRenderersFactory.getImageDecoderFactory überschrieben wird.

Im folgenden Beispiel wird Glide verwendet, um ein Bild zu laden:

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

Bildvorabladen mit einer Bildladebibliothek

Während der Wiedergabe fordert der Player das Vorladen des nächsten Bildes an, sobald der vorherige Artikel in der Playlist vollständig geladen ist. Wenn Sie eine externe Bildladebibliothek verwenden, müssen Sie ein ExternalLoader angeben, um dieses Vorladen auszulösen. Wenn kein Vorabladen möglich oder erforderlich ist, muss dieser Lader trotzdem bereitgestellt werden, kann aber nichts tun.

Im folgenden Beispiel wird Glide verwendet, um dafür zu sorgen, dass das angeforderte Bild vorab auf das Laufwerk 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)
  )
}

Java

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