Penyesuaian

Inti dari library ExoPlayer adalah antarmuka Player. Player mengekspos fungsi pemutar media tingkat tinggi tradisional seperti kemampuan untuk mengosongkan media, memutar, menjeda, dan mencari. Implementasi default ExoPlayer dirancang untuk membuat beberapa asumsi tentang (dan karenanya memberlakukan beberapa batasan pada) jenis media yang diputar, cara dan tempat media disimpan, serta cara dirender. Daripada menerapkan pemuatan dan rendering media secara langsung, implementasi ExoPlayer mendelegasikan tugas ini ke komponen yang dimasukkan saat pemutar dibuat atau saat sumber media baru diteruskan ke pemutar. Komponen yang umum untuk semua implementasi ExoPlayer adalah:

• Instance MediaSource yang menentukan media yang akan diputar, memuat media, dan tempat media yang dimuat dapat dibaca. Instance MediaSource dibuat dari MediaItem oleh MediaSource.Factory di dalam pemutar. Data ini juga dapat diteruskan langsung ke pemutar menggunakan API playlist berbasis sumber media.
• Instance MediaSource.Factory yang mengonversi MediaItem menjadi MediaSource. MediaSource.Factory dimasukkan saat pemutar dibuat.
• Instance Renderer yang merender setiap komponen media. Input ini dimasukkan saat pemutar dibuat.
• TrackSelector yang memilih jalur yang disediakan oleh MediaSource untuk digunakan oleh setiap Renderer yang tersedia. TrackSelector dimasukkan saat pemutar dibuat.
• LoadControl yang mengontrol kapan MediaSource melakukan buffering pada lebih banyak media, dan jumlah media yang di-buffer. LoadControl dimasukkan saat pemutar dibuat.
• LivePlaybackSpeedControl yang mengontrol kecepatan pemutaran selama pemutaran live untuk memungkinkan pemutar tetap dekat dengan offset live yang dikonfigurasi. LivePlaybackSpeedControl diinjeksi saat pemutar dibuat.

Konsep memasukkan komponen yang mengimplementasikan bagian fungsi pemutar tersedia di seluruh library. Implementasi default beberapa komponen mendelegasikan pekerjaan ke komponen yang dimasukkan lebih lanjut. Hal ini memungkinkan banyak sub-komponen diganti satu per satu dengan implementasi yang dikonfigurasi dengan cara kustom.

Penyesuaian pemutar

Beberapa contoh umum penyesuaian pemutar dengan memasukkan komponen dijelaskan di bawah.

Mengonfigurasi stack jaringan

Kami memiliki halaman tentang menyesuaikan stack jaringan yang digunakan oleh ExoPlayer.

Menyimpan data ke dalam cache yang dimuat dari jaringan

Lihat panduan untuk cache sambil menjalankan proses sementara dan mendownload media.

Menyesuaikan interaksi server

Beberapa aplikasi mungkin ingin mencegat permintaan dan respons HTTP. Anda mungkin ingin memasukkan header permintaan kustom, membaca header respons server, mengubah URI permintaan, dll. Misalnya, aplikasi Anda dapat mengautentikasi dirinya sendiri dengan memasukkan token sebagai header saat meminta segmen media.

Contoh berikut menunjukkan cara menerapkan perilaku ini dengan memasukkan DataSource.Factory kustom ke dalam DefaultMediaSourceFactory:

val dataSourceFactory =
  DataSource.Factory {
    val dataSource = httpDataSourceFactory.createDataSource()
    // Set a custom authentication request header.
    dataSource.setRequestProperty("Header", "Value")
    dataSource
  }
val player =
  ExoPlayer.Builder(context)
    .setMediaSourceFactory(
      DefaultMediaSourceFactory(context).setDataSourceFactory(dataSourceFactory)
    )
    .build()

DataSource.Factory dataSourceFactory =
    () -> {
      HttpDataSource dataSource = httpDataSourceFactory.createDataSource();
      // Set a custom authentication request header.
      dataSource.setRequestProperty("Header", "Value");
      return dataSource;
    };

ExoPlayer player =
    new ExoPlayer.Builder(context)
        .setMediaSourceFactory(
            new DefaultMediaSourceFactory(context).setDataSourceFactory(dataSourceFactory))
        .build();

Dalam cuplikan kode di atas, HttpDataSource yang dimasukkan menyertakan header "Header: Value" dalam setiap permintaan HTTP. Perilaku ini tetap untuk setiap interaksi dengan sumber HTTP.

Untuk pendekatan yang lebih terperinci, Anda dapat memasukkan perilaku tepat waktu menggunakan ResolvingDataSource. Cuplikan kode berikut menunjukkan cara memasukkan header permintaan tepat sebelum berinteraksi dengan sumber HTTP:

val dataSourceFactory: DataSource.Factory =
  ResolvingDataSource.Factory(httpDataSourceFactory) { dataSpec: DataSpec ->
    // Provide just-in-time request headers.
    dataSpec.withRequestHeaders(getCustomHeaders(dataSpec.uri))
  }

    DataSource.Factory dataSourceFactory =
        new ResolvingDataSource.Factory(
            httpDataSourceFactory,
            // Provide just-in-time request headers.
            dataSpec -> dataSpec.withRequestHeaders(getCustomHeaders(dataSpec.uri)));

Anda juga dapat menggunakan ResolvingDataSource untuk melakukan perubahan URI tepat waktu, seperti yang ditunjukkan dalam cuplikan berikut:

val dataSourceFactory: DataSource.Factory =
  ResolvingDataSource.Factory(httpDataSourceFactory) { dataSpec: DataSpec ->
    // Provide just-in-time URI resolution logic.
    dataSpec.withUri(resolveUri(dataSpec.uri))
  }

DataSource.Factory dataSourceFactory =
    new ResolvingDataSource.Factory(
        httpDataSourceFactory,
        // Provide just-in-time URI resolution logic.
        dataSpec -> dataSpec.withUri(resolveUri(dataSpec.uri)));

Menyesuaikan penanganan error

Mengimplementasikan LoadErrorHandlingPolicy kustom memungkinkan aplikasi menyesuaikan cara ExoPlayer bereaksi terhadap error pemuatan. Misalnya, aplikasi mungkin ingin gagal dengan cepat, bukan mencoba ulang berkali-kali, atau mungkin ingin menyesuaikan logika back-off yang mengontrol berapa lama pemain menunggu di antara setiap percobaan ulang. Cuplikan berikut menunjukkan cara menerapkan logika back-off kustom:

val loadErrorHandlingPolicy: LoadErrorHandlingPolicy =
  object : DefaultLoadErrorHandlingPolicy() {
    override fun getRetryDelayMsFor(loadErrorInfo: LoadErrorInfo): Long {
      // Implement custom back-off logic here.
      return 0
    }
  }
val player =
  ExoPlayer.Builder(context)
    .setMediaSourceFactory(
      DefaultMediaSourceFactory(context).setLoadErrorHandlingPolicy(loadErrorHandlingPolicy)
    )
    .build()

LoadErrorHandlingPolicy loadErrorHandlingPolicy =
    new DefaultLoadErrorHandlingPolicy() {
      @Override
      public long getRetryDelayMsFor(LoadErrorInfo loadErrorInfo) {
        // Implement custom back-off logic here.
        return 0;
      }
    };

ExoPlayer player =
    new ExoPlayer.Builder(context)
        .setMediaSourceFactory(
            new DefaultMediaSourceFactory(context)
                .setLoadErrorHandlingPolicy(loadErrorHandlingPolicy))
        .build();

Argumen LoadErrorInfo berisi informasi selengkapnya tentang pemuatan yang gagal untuk menyesuaikan logika berdasarkan jenis error atau permintaan yang gagal.

Menyesuaikan flag ekstraktor

Flag pengekstrak dapat digunakan untuk menyesuaikan cara mengekstrak setiap format dari media progresif. Parameter ini dapat ditetapkan di DefaultExtractorsFactory yang disediakan ke DefaultMediaSourceFactory. Contoh berikut meneruskan flag yang memungkinkan pencarian berbasis indeks untuk streaming MP3.

val extractorsFactory =
  DefaultExtractorsFactory().setMp3ExtractorFlags(Mp3Extractor.FLAG_ENABLE_INDEX_SEEKING)
val player =
  ExoPlayer.Builder(context)
    .setMediaSourceFactory(DefaultMediaSourceFactory(context, extractorsFactory))
    .build()

DefaultExtractorsFactory extractorsFactory =
    new DefaultExtractorsFactory().setMp3ExtractorFlags(Mp3Extractor.FLAG_ENABLE_INDEX_SEEKING);

ExoPlayer player =
    new ExoPlayer.Builder(context)
        .setMediaSourceFactory(new DefaultMediaSourceFactory(context, extractorsFactory))
        .build();

Mengaktifkan pencarian kecepatan bit konstan

Untuk streaming MP3, ADTS, dan AMR, Anda dapat mengaktifkan pencarian perkiraan menggunakan asumsi kecepatan bit konstan dengan tanda FLAG_ENABLE_CONSTANT_BITRATE_SEEKING. Flag ini dapat ditetapkan untuk setiap ekstraktor menggunakan metode DefaultExtractorsFactory.setXyzExtractorFlags individual seperti yang dijelaskan di atas. Untuk mengaktifkan pencarian kecepatan bit konstan untuk semua ekstraktor yang mendukungnya, gunakan DefaultExtractorsFactory.setConstantBitrateSeekingEnabled.

val extractorsFactory = DefaultExtractorsFactory().setConstantBitrateSeekingEnabled(true)

DefaultExtractorsFactory extractorsFactory =
    new DefaultExtractorsFactory().setConstantBitrateSeekingEnabled(true);

ExtractorsFactory kemudian dapat dimasukkan melalui DefaultMediaSourceFactory seperti yang dijelaskan untuk menyesuaikan tanda ekstrak di atas.

Mengaktifkan antrean buffering asinkron

Antrean buffering asinkron adalah peningkatan dalam pipeline rendering ExoPlayer, yang mengoperasikan instance MediaCodec dalam mode asinkron dan menggunakan thread tambahan untuk menjadwalkan decoding dan rendering data. Mengaktifkannya dapat mengurangi frame yang terputus dan underrun audio.

Antrean buffer asinkron diaktifkan secara default di perangkat yang menjalankan Android 12 (API level 31) dan yang lebih baru, serta dapat diaktifkan secara manual mulai dari Android 6.0 (API level 23). Pertimbangkan untuk mengaktifkan fitur tersebut untuk perangkat tertentu tempat Anda mengamati penurunan frame atau underrun audio, terutama saat memutar konten yang dilindungi DRM atau dengan kecepatan frame tinggi.

Dalam kasus yang paling sederhana, Anda perlu memasukkan DefaultRenderersFactory ke pemutar sebagai berikut:

val renderersFactory = 
  DefaultRenderersFactory(context).forceEnableMediaCodecAsynchronousQueueing()
val exoPlayer = ExoPlayer.Builder(context, renderersFactory).build()

DefaultRenderersFactory renderersFactory =
    new DefaultRenderersFactory(context).forceEnableMediaCodecAsynchronousQueueing();
ExoPlayer exoPlayer = new ExoPlayer.Builder(context, renderersFactory).build();

Jika Anda membuat instance perender secara langsung, teruskan AsynchronousMediaCodecAdapter.Factory ke konstruktor MediaCodecVideoRenderer dan MediaCodecAudioRenderer.

Mencegat panggilan metode dengan ForwardingPlayer

Anda dapat menyesuaikan beberapa perilaku instance Player dengan menggabungkannya dalam subclass ForwardingPlayer dan mengganti metode untuk melakukan salah satu hal berikut:

• Akses parameter sebelum meneruskannya ke delegasi Player.
• Akses nilai yang ditampilkan dari Player delegasi sebelum menampilkannya.
• Mengimplementasikan kembali metode ini sepenuhnya.

Saat mengganti metode ForwardingPlayer, penting untuk memastikan implementasi tetap konsisten dan mematuhi antarmuka Player, terutama saat menangani metode yang dimaksudkan untuk memiliki perilaku yang identik atau terkait. Contoh:

• Jika ingin mengganti setiap operasi 'play', Anda harus mengganti ForwardingPlayer.play dan ForwardingPlayer.setPlayWhenReady, karena pemanggil akan mengharapkan perilaku metode ini identik saat playWhenReady = true.
• Jika ingin mengubah inkremen pencarian maju, Anda harus mengganti ForwardingPlayer.seekForward untuk melakukan pencarian dengan inkremen kustom, dan ForwardingPlayer.getSeekForwardIncrement untuk melaporkan inkremen kustom yang benar kembali ke pemanggil.
• Jika ingin mengontrol Player.Commands yang diiklankan oleh instance pemain, Anda harus mengganti Player.getAvailableCommands() dan Player.isCommandAvailable(), serta memproses callback Player.Listener.onAvailableCommandsChanged() untuk mendapatkan notifikasi tentang perubahan yang berasal dari pemain yang mendasarinya.

Penyesuaian MediaSource

Contoh di atas memasukkan komponen yang disesuaikan untuk digunakan selama pemutaran semua objek MediaItem yang diteruskan ke pemutar. Jika penyesuaian terperinci diperlukan, Anda juga dapat memasukkan komponen yang disesuaikan ke dalam setiap instance MediaSource, yang dapat diteruskan langsung ke pemutar. Contoh di bawah menunjukkan cara menyesuaikan ProgressiveMediaSource untuk menggunakan DataSource.Factory, ExtractorsFactory, dan LoadErrorHandlingPolicy kustom:

val mediaSource =
  ProgressiveMediaSource.Factory(customDataSourceFactory, customExtractorsFactory)
    .setLoadErrorHandlingPolicy(customLoadErrorHandlingPolicy)
    .createMediaSource(MediaItem.fromUri(streamUri))

ProgressiveMediaSource mediaSource =
    new ProgressiveMediaSource.Factory(customDataSourceFactory, customExtractorsFactory)
        .setLoadErrorHandlingPolicy(customLoadErrorHandlingPolicy)
        .createMediaSource(MediaItem.fromUri(streamUri));

Membuat komponen kustom

Library menyediakan implementasi default komponen yang tercantum di bagian atas halaman ini untuk kasus penggunaan umum. ExoPlayer dapat menggunakan komponen ini, tetapi juga dapat dibuat untuk menggunakan implementasi kustom jika perilaku non-standar diperlukan. Beberapa kasus penggunaan untuk implementasi kustom adalah:

• Renderer – Anda dapat menerapkan Renderer kustom untuk menangani jenis media yang tidak didukung oleh penerapan default yang disediakan oleh library.
• TrackSelector – Mengimplementasikan TrackSelector kustom memungkinkan developer aplikasi mengubah cara trek yang diekspos oleh MediaSource dipilih untuk digunakan oleh setiap Renderer yang tersedia.
• LoadControl – Dengan menerapkan LoadControl kustom, developer aplikasi dapat mengubah kebijakan buffering pemutar.
• Extractor – Jika Anda perlu mendukung format penampung yang saat ini tidak didukung oleh library, pertimbangkan untuk menerapkan class Extractor kustom.
• MediaSource – Penerapan class MediaSource kustom mungkin sesuai jika Anda ingin mendapatkan contoh media untuk dimasukkan ke perender dengan cara kustom, atau jika Anda ingin menerapkan perilaku pengomposisian MediaSource kustom.
• MediaSource.Factory – Menerapkan MediaSource.Factory kustom memungkinkan aplikasi menyesuaikan cara pembuatan MediaSource dari MediaItem.
• DataSource – Paket upstream ExoPlayer sudah berisi sejumlah implementasi DataSource untuk berbagai kasus penggunaan. Sebaiknya implementasikan class DataSource Anda sendiri untuk memuat data dengan cara lain, seperti melalui protokol kustom, menggunakan stack HTTP kustom, atau dari cache persisten kustom.

Saat mem-build komponen kustom, sebaiknya lakukan hal berikut:

• Jika komponen kustom perlu melaporkan peristiwa kembali ke aplikasi, sebaiknya Anda melakukannya menggunakan model yang sama dengan komponen ExoPlayer yang ada, misalnya menggunakan class EventDispatcher atau meneruskan Handler bersama dengan pemroses ke konstruktor komponen.
• Sebaiknya komponen kustom menggunakan model yang sama dengan komponen ExoPlayer yang ada untuk memungkinkan konfigurasi ulang oleh aplikasi selama pemutaran. Untuk melakukannya, komponen kustom harus menerapkan PlayerMessage.Target dan menerima perubahan konfigurasi dalam metode handleMessage. Kode aplikasi harus meneruskan perubahan konfigurasi dengan memanggil metode createMessage ExoPlayer, mengonfigurasi pesan, dan mengirimkannya ke komponen menggunakan PlayerMessage.send. Mengirim pesan untuk dikirim di thread pemutaran memastikan bahwa pesan tersebut dieksekusi secara berurutan dengan operasi lain yang dilakukan di pemutar.