Grafika

ExoPlayer obsługuje te formaty obrazów: Więcej informacji o integracji z bibliotekami zewnętrznymi, które mogą obsługiwać inne formaty, znajdziesz w artykule Biblioteki wczytywania obrazów.

Format obrazu	Obsługiwane	Uwagi
BMP	TAK
GIF	NIE	Brak obsługi narzędzia Extractor
JPEG	TAK
JPEG Motion Photo	TAK	Obsługa obrazów i filmów
JPEG Ultra HDR	TAK	W przypadku wersji Androida wcześniejszej niż 14 lub wyświetlaczy bez HDR obraz jest konwertowany na SDR.
PNG	TAK
WebP	TAK
HEIF/HEIC	TAK
Zdjęcie ruchome HEIC	Częściowo	Obsługiwane są tylko obrazy statyczne*
AVIF (wartość domyślna)	TAK	dekodowane tylko w Androidzie 14 lub nowszym,

* Część wideo zdjęć z ruchu w formacie HEIC można uzyskać za pomocą narzędzia MetadataRetriever i odtworzyć jako samodzielny plik.

Korzystanie z MediaItem

Aby odtworzyć obraz jako część playlisty, utwórz MediaItem z URI obrazu i przekaż go odtwarzaczowi. MediaItem musi mieć imageDurationMs, aby określić, jak długo obraz ma być wyświetlany.

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

Zdjęcia ruchome

Zdjęcia ruchome to pliki łączące zdjęcie z krótkim filmem.

• Jeśli czas trwania obrazu jest zdefiniowany za pomocą elementu setImageDuration, zdjęcie ruchome jest wyświetlane przez zadeklarowany czas trwania jako zdjęcie nieruchome.
• Jeśli czas trwania obrazu nie jest zdefiniowany, zdjęcie ruchome jest odtwarzane jako film.

Korzystanie z ProgressiveMediaSource

Aby uzyskać więcej opcji dostosowywania, możesz utworzyć ProgressiveMediaSource i przekazać go bezpośrednio odtwarzaczowi zamiast 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();

Dostosowywanie odtwarzania

ExoPlayer oferuje wiele sposobów dostosowywania odtwarzania do potrzeb aplikacji. Przykłady znajdziesz na stronie personalizacji.

Biblioteki wczytywania obrazów

Obrazami często zarządzają zewnętrzne biblioteki do wczytywania obrazów, na przykład Glide lub Coil.

Aby zintegrować te biblioteki z potokiem odtwarzania, wykonaj 3 kroki:

1. Zdefiniuj MediaItem z typem MIME APPLICATION_EXTERNALLY_LOADED_IMAGE.
2. Podaj dekoder obrazu, aby pobrać Bitmap z biblioteki ładowania obrazu.
3. Udostępnij zewnętrzny ładownik, aby wywołać buforowanie i wstępne wczytywanie.

MediaItem z załadowanym z zewnątrz typem MIME obrazu

Aby móc używać ścieżek kodu biblioteki do wczytywania obrazów, MediaItem dodany do Player musi definiować typ MIME APPLICATION_EXTERNALLY_LOADED_IMAGE w sposób jawny:

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

Dekoder obrazu korzystający z biblioteki ładowania obrazu

Do przetwarzania obrazu potrzebny jest ExternallyLoadedImageDecoder, aby pobrać Bitmap z Uri. Ten dekoder może być dostarczony przez zastąpienie DefaultRenderersFactory.getImageDecoderFactory.

W tym przykładzie do wczytania obrazu użyto biblioteki Glide:

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

Wczytywanie wstępnie obrazów za pomocą biblioteki wczytywania obrazów

Podczas odtwarzania odtwarzacz prosi o wstępne załadowanie następnego obrazu, gdy poprzedni element na liście został w pełni załadowany. Jeśli używasz zewnętrznej biblioteki do wczytywania obrazów, musisz określić ExternalLoader, aby wywołać wstępne wczytywanie. Jeśli wstępne wczytywanie nie jest możliwe ani wymagane, ten ładowarkę nadal musi być dostarczony, ale nie może nic zrobić.

W tym przykładzie używamy Glide, aby upewnić się, że żądany obraz jest wstępnie załadowany na dysk:

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