Gambar

ExoPlayer mendukung format gambar berikut. Lihat Library Pemuatan Gambar untuk mengetahui cara berintegrasi dengan library eksternal yang dapat memberikan dukungan untuk serangkaian format yang berbeda.

Format gambar Didukung Catatan
BMP YA
GIF TIDAK Tidak ada dukungan Extractor
JPEG YA
Foto Gerak JPEG YA Gambar diam dan video yang didukung
JPEG Ultra HDR YA Kembali ke SDR sebelum Android 14 atau di layar non-HDR
PNG YA
WebP YA
HEIF/HEIC YA
Foto Motion HEIC Sebagian Hanya gambar diam yang didukung*
AVIF (dasar) YA Hanya didekode di Android 14+

* Bagian video dari foto bergerak HEIC dapat diperoleh dengan MetadataRetriever dan diputar sebagai file mandiri.

Menggunakan MediaItem

Untuk memutar gambar sebagai bagian dari playlist, buat MediaItem dengan URI gambar dan teruskan ke pemutar. MediaItem harus memiliki imageDurationMs untuk menentukan durasi gambar harus ditampilkan.

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

Foto Motion

Foto motion adalah file yang menggabungkan gambar diam dengan video singkat.

  • Jika durasi gambar ditentukan dengan setImageDuration, foto motion akan ditampilkan selama durasi yang dinyatakan sebagai gambar diam.
  • Jika durasi gambar tidak ditentukan, foto motion akan diputar sebagai video.

Menggunakan ProgressiveMediaSource

Untuk opsi penyesuaian lainnya, Anda dapat membuat ProgressiveMediaSource dan meneruskannya langsung ke pemutar, bukan 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();

Menyesuaikan pemutaran

ExoPlayer menyediakan beberapa cara bagi Anda untuk menyesuaikan pengalaman pemutaran dengan kebutuhan aplikasi Anda. Lihat Halaman penyesuaian untuk melihat contohnya.

Library Pemuatan Gambar

Gambar sering kali dikelola oleh library pemuatan gambar eksternal, misalnya Glide atau Coil.

Mengintegrasikan library ini ke dalam pipeline pemutaran memerlukan 3 langkah:

  1. Tentukan MediaItem dengan jenis MIME APPLICATION_EXTERNALLY_LOADED_IMAGE.
  2. Menyediakan dekoder gambar untuk mengambil Bitmap dari library pemuatan gambar.
  3. Menyediakan loader eksternal untuk memicu penyimpanan dalam cache dan pemuatan awal.

MediaItem dengan jenis MIME gambar yang dimuat secara eksternal

MediaItem yang ditambahkan ke Player harus menentukan jenis MIME APPLICATION_EXTERNALLY_LOADED_IMAGE secara eksplisit untuk menggunakan jalur kode library pemuatan gambar:

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

Decoder gambar menggunakan library pemuatan gambar

Perender gambar memerlukan ExternallyLoadedImageDecoder untuk mengambil Bitmap dari Uri. Decoder ini dapat disediakan dengan mengganti DefaultRenderersFactory.getImageDecoderFactory.

Contoh berikut menggunakan Glide untuk memuat gambar, membatasi output ke ukuran tampilan untuk menghindari pembuatan objek Bitmap yang sangat besar:

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

Pemuatan awal gambar dengan library pemuatan gambar

Selama pemutaran, pemutar meminta untuk memuat ulang gambar berikutnya setelah item sebelumnya dalam playlist dimuat sepenuhnya. Saat menggunakan library pemuatan gambar eksternal, Anda harus menentukan ExternalLoader untuk memicu pra-pemuatan ini. Jika tidak ada pemuatan awal yang memungkinkan atau diperlukan, pemuat ini tetap harus disediakan, tetapi tidak dapat melakukan apa pun.

Contoh berikut menggunakan Glide untuk memastikan bahwa gambar yang diminta telah dimuat sebelumnya ke disk:

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