Stack jaringan

ExoPlayer biasanya digunakan untuk streaming media melalui internet. Mendukung beberapa tumpukan jaringan untuk membuat permintaan jaringan yang mendasarinya. Pilihanmu dari tumpukan jaringan dapat berdampak signifikan terhadap performa streaming.

Halaman ini menguraikan cara mengonfigurasi ExoPlayer untuk menggunakan stack jaringan pilihan Anda, mencantumkan opsi yang tersedia, memberikan beberapa panduan tentang cara memilih stack jaringan untuk aplikasi Anda, dan menjelaskan cara mengaktifkan penyimpanan dalam cache untuk media yang di-streaming.

Mengonfigurasi ExoPlayer untuk menggunakan stack jaringan tertentu

ExoPlayer memuat data melalui komponen DataSource, yang diperoleh dari instance DataSource.Factory yang dimasukkan dari kode aplikasi.

Jika aplikasi Anda hanya perlu memutar konten http(s), memilih stack jaringan semudah memperbarui instance DataSource.Factory apa pun yang dimasukkan aplikasi Anda menjadi instance HttpDataSource.Factory yang sesuai dengan stack jaringan yang ingin Anda gunakan. Jika aplikasi Anda juga perlu memutar konten non-http, seperti file lokal, gunakan DefaultDataSource.Factory:

DefaultDataSource.Factory(
  ...
  /* baseDataSourceFactory= */ PreferredHttpDataSource.Factory(...))

new DefaultDataSource.Factory(
    ...
    /* baseDataSourceFactory= */ new PreferredHttpDataSource.Factory(...));

Dalam contoh ini, PreferredHttpDataSource.Factory adalah factory yang sesuai dengan tumpukan jaringan pilihan Anda. Lapisan DefaultDataSource.Factory menambahkan dukungan untuk sumber non-http seperti file lokal.

Contoh berikut menunjukkan cara mem-build ExoPlayer yang akan menggunakan stack jaringan Cronet dan juga mendukung pemutaran konten non-http(s).

// Given a CronetEngine and Executor, build a CronetDataSource.Factory.
val cronetDataSourceFactory = CronetDataSource.Factory(cronetEngine, executor)

// Wrap the CronetDataSource.Factory in a DefaultDataSource.Factory, which adds
// in support for requesting data from other sources (such as files, resources,
// etc).
val dataSourceFactory =
  DefaultDataSource.Factory(context, /* baseDataSourceFactory= */ cronetDataSourceFactory)

// Inject the DefaultDataSource.Factory when creating the player.
val player =
  ExoPlayer.Builder(context)
    .setMediaSourceFactory(
      DefaultMediaSourceFactory(context).setDataSourceFactory(dataSourceFactory)
    )
    .build()

// Given a CronetEngine and Executor, build a CronetDataSource.Factory.
CronetDataSource.Factory cronetDataSourceFactory =
    new CronetDataSource.Factory(cronetEngine, executor);

// Wrap the CronetDataSource.Factory in a DefaultDataSource.Factory, which adds
// in support for requesting data from other sources (such as files, resources,
// etc).
DefaultDataSource.Factory dataSourceFactory =
    new DefaultDataSource.Factory(
        context, /* baseDataSourceFactory= */ cronetDataSourceFactory);

// Inject the DefaultDataSource.Factory when creating the player.
ExoPlayer player =
    new ExoPlayer.Builder(context)
        .setMediaSourceFactory(
            new DefaultMediaSourceFactory(context).setDataSourceFactory(dataSourceFactory))
        .build();

Stack jaringan yang didukung

ExoPlayer memberikan dukungan langsung untuk HttpEngine, Cronet, OkHttp, dan Android {i>built-in <i}jaringan secara {i> default<i}. ExoPlayer juga dapat diperluas untuk mendukung tumpukan jaringan lain yang bekerja di Android.

HTTPEngine

HttpEngine adalah stack jaringan default yang direkomendasikan di Android dari API 34 (atau ekstensi S 7). Pada umumnya, aplikasi ini menggunakan stack jaringan Cronet secara internal, yang mendukung HTTP, HTTP/2, dan HTTP/3 melalui protokol QUIC.

ExoPlayer mendukung HttpEngine dengan HttpEngineDataSource.Factory-nya. Anda dapat menginjeksikan factory sumber data ini seperti yang dijelaskan dalam Mengonfigurasi ExoPlayer untuk menggunakan di stack jaringan tertentu.

Cronet

Cronet adalah Stack jaringan Chromium disediakan untuk aplikasi Android sebagai library. Cronet memanfaatkan beberapa teknologi yang mengurangi latensi dan meningkatkan throughput permintaan jaringan yang diperlukan aplikasi agar dapat berfungsi, termasuk yang dibuat oleh ExoPlayer. Secara native, API ini mendukung protokol HTTP, HTTP/2, dan HTTP/3 melalui protokol QUIC. Cronet digunakan oleh beberapa aplikasi streaming terbesar di dunia, termasuk YouTube.

ExoPlayer mendukung Cronet melalui Library Crnet. Lihat README.md library untuk petunjuk mendetail tentang cara menggunakan anotasi. Perhatikan bahwa library Cronet dapat menggunakan tiga implementasi Cronet yang mendasarinya:

1. Layanan Google Play: Sebaiknya gunakan penerapan ini di sebagian besar aplikasi kasus, dan penggantian ke stack jaringan bawaan Android (DefaultHttpDataSource) jika Layanan Google Play tidak tersedia.
2. Cronet Embedded: Mungkin merupakan pilihan yang bagus jika sejumlah besar pengguna Anda berada di pasar yang tidak menyediakan Layanan Google Play secara luas, atau jika Anda ingin mengontrol versi implementasi Cronet yang digunakan. Tujuan kelemahan utama dari Cronet Embedded adalah penggunaannya kurang lebih 8 MB untuk aplikasi Anda.
3. Penggantian Cronet: Implementasi penggantian Cronet mengimplementasikan API Cronet sebagai wrapper di sekitar stack jaringan bawaan Android. Seharusnya tidak digunakan dengan ExoPlayer, karena menggunakan stack jaringan bawaan Android secara langsung (dengan menggunakan DefaultHttpDataSource) menjadi lebih efisien.

OkHttp

OkHttp adalah stack jaringan modern lainnya yang banyak digunakan oleh banyak aplikasi Android populer. OpenVPN mendukung HTTP dan HTTP/2, tetapi belum mendukung HTTP/3 melalui QUIC.

ExoPlayer mendukung OkHttp melalui Library OkHttp. Lihat README.md library untuk petunjuk mendetail tentang cara menggunakan anotasi. Saat menggunakan library OkHttp, tumpukan jaringan disematkan di dalam . Ini mirip dengan Cronet Embedded, tetapi OkHttp secara signifikan lebih kecil, dengan menambah kurang dari 1 MB ke aplikasi Anda.

Stack jaringan bawaan Android

ExoPlayer mendukung penggunaan stack jaringan bawaan Android dengan DefaultHttpDataSource dan DefaultHttpDataSource.Factory, yang merupakan bagian dari library inti ExoPlayer.

Implementasi tumpukan jaringan yang tepat tergantung pada perangkat lunak yang berjalan pada perangkat dasar. Pada sebagian besar perangkat, hanya HTTP yang didukung (yaitu, HTTP/2 dan HTTP/3 melalui QUIC tidak didukung).

Stack jaringan lainnya

Aplikasi juga dapat mengintegrasikan stack jaringan lain dengan ExoPlayer. Untuk melakukannya, implementasikan HttpDataSource yang menggabungkan stack jaringan, bersama dengan HttpDataSource.Factory yang sesuai. Library Cronet dan OkHttp ExoPlayer adalah contoh yang baik tentang cara melakukannya.

Saat mengintegrasikan dengan tumpukan jaringan Java murni, sebaiknya implementasikan DataSourceContractTest untuk memeriksa apakah implementasi HttpDataSource Anda berperilaku dengan benar. OkHttpDataSourceContractTest di library OkHttp adalah contoh yang baik tentang bagaimana melakukan ini.

Memilih stack jaringan

Tabel berikut menguraikan kelebihan dan kekurangan stack jaringan yang didukung oleh ExoPlayer.

Protokol HTTP/2 dan HTTP/3 melalui QUIC dapat meningkatkan performa streaming media secara signifikan. Secara khusus, saat melakukan streaming media adaptif yang didistribusikan menggunakan jaringan penayangan konten (CDN), ada kasus saat penggunaan protokol ini dapat memungkinkan CDN beroperasi jauh lebih efisien. Karena alasan ini, dukungan HttpEngine dan Cronet untuk HTTP/2 dan HTTP/3 melalui QUIC (dan dukungan OkHttp untuk HTTP/2), adalah manfaat utama dibandingkan dengan menggunakan stack jaringan bawaan Android, asalkan server tempat konten dihosting juga mendukung protokol ini.

Saat mempertimbangkan streaming media secara terpisah, sebaiknya gunakan HttpEngine atau Cronet yang disediakan oleh Layanan Google Play akan kembali ke DefaultHttpDataSource jika Layanan Google Play tidak tersedia. Rekomendasi ini memberikan teguran keseimbangan antara mengaktifkan penggunaan HTTP/2 dan HTTP/3 melalui QUIC di sebagian besar perangkat, dan agar tidak terjadi peningkatan ukuran APK yang signifikan. Ada pengecualian untuk rekomendasi. Jika Layanan Google Play kemungkinan tidak tersedia di sebagian besar perangkat yang akan menjalankan aplikasi Anda, menggunakan Cronet Embedded atau OkHttp mungkin lebih sesuai. Penggunaan layanan bawaan tumpukan jaringan mungkin dapat diterima jika ukuran APK menjadi masalah penting, atau jika jenis streaming hanyalah sebagian kecil dari fungsi aplikasi Anda.

Selain media, sebaiknya pilih satu stack jaringan untuk semua jaringan yang dilakukan oleh aplikasi Anda. Hal ini memungkinkan resource (seperti soket) digabungkan dan dibagikan secara efisien antara ExoPlayer dan komponen aplikasi lainnya.

Karena aplikasi Anda kemungkinan besar perlu menjalankan jaringan yang tidak terkait ke pemutaran media, pilihan tumpukan jaringan Anda pada akhirnya harus mempertimbangkan rekomendasi di atas untuk streaming media secara terpisah, persyaratan dari komponen lain yang menjalankan jaringan, dan kepentingan relatifnya terhadap .

Menyimpan media ke dalam cache

ExoPlayer mendukung penyimpanan dalam cache byte yang dimuat ke disk untuk mencegah pemuatan berulang byte yang sama dari jaringan. Hal ini berguna saat mencari kembali di media saat ini atau mengulangi item yang sama.

Penyimpanan dalam cache memerlukan instance SimpleCache yang mengarah ke direktori cache khusus dan CacheDataSource.Factory:

// Note: This should be a singleton in your app.
val databaseProvider = StandaloneDatabaseProvider(context)

// An on-the-fly cache should evict media when reaching a maximum disk space limit.
val cache =
    SimpleCache(
        downloadDirectory, LeastRecentlyUsedCacheEvictor(maxBytes), databaseProvider)

// Configure the DataSource.Factory with the cache and factory for the desired HTTP stack.
val cacheDataSourceFactory =
    CacheDataSource.Factory()
        .setCache(cache)
        .setUpstreamDataSourceFactory(httpDataSourceFactory)

// Inject the DefaultDataSource.Factory when creating the player.
val player =
    ExoPlayer.Builder(context)
        .setMediaSourceFactory(
            DefaultMediaSourceFactory(context).setDataSourceFactory(cacheDataSourceFactory))
        .build()

// Note: This should be a singleton in your app.
DatabaseProvider databaseProvider = new StandaloneDatabaseProvider(context);

// An on-the-fly cache should evict media when reaching a maximum disk space limit.
Cache cache =
    new SimpleCache(
        downloadDirectory, new LeastRecentlyUsedCacheEvictor(maxBytes), databaseProvider);

// Configure the DataSource.Factory with the cache and factory for the desired HTTP stack.
DataSource.Factory cacheDataSourceFactory =
    new CacheDataSource.Factory()
        .setCache(cache)
        .setUpstreamDataSourceFactory(httpDataSourceFactory);

// Inject the DefaultDataSource.Factory when creating the player.
ExoPlayer player =
    new ExoPlayer.Builder(context)
        .setMediaSourceFactory(
            new DefaultMediaSourceFactory(context).setDataSourceFactory(cacheDataSourceFactory))
        .build();