Pilas de red

ExoPlayer se usa comúnmente para transmitir contenido multimedia por Internet. Admite varias pilas de red para realizar sus solicitudes de red subyacentes. Tu elección de la pila de red puede tener un impacto significativo en el rendimiento de la transmisión.

En esta página, se describe cómo configurar ExoPlayer para usar la pila de red que elijas, se enumeran las opciones disponibles, se proporciona orientación para elegir una pila de red para tu app y se explica cómo habilitar el almacenamiento en caché para el contenido multimedia transmitido.

Cómo configurar ExoPlayer para usar una pila de red específica

ExoPlayer carga datos a través de componentes DataSource, que obtiene de Instancias DataSource.Factory que se insertan desde el código de la app.

Si tu app solo necesita reproducir contenido HTTP(s), seleccionar una pila de red es tan simple como actualizar las instancias de DataSource.Factory que tu app inserta para que sean instancias del HttpDataSource.Factory que corresponde a la pila de red que deseas usar. Si tu app también necesita reproducir contenido que no es HTTP(s), como archivos locales, usa DefaultDataSource.Factory:

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

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

En este ejemplo, PreferredHttpDataSource.Factory es la fábrica que corresponde a tu en la pila de red preferida. La capa DefaultDataSource.Factory agrega compatibilidad. para fuentes que no son HTTP, como archivos locales.

En el siguiente ejemplo, se muestra cómo compilar un ExoPlayer que usará la pila de redes de Cronet y también admitirá la reproducción de contenido que no sea 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();

Pilas de red compatibles

ExoPlayer proporciona compatibilidad directa con HttpEngine, Cronet, OkHttp y la pila de red predeterminada integrada de Android. ExoPlayer también se puede extender para admitir cualquier otra pila de red que funcione en Android.

HttpEngine

HttpEngine es la pila de red predeterminada recomendada en Android a partir del nivel de API 34 (o S extensiones 7). En la mayoría de los casos, usa la pila de red de Cronet de forma interna y admite HTTP, HTTP/2 y HTTP/3 a través de protocolos QUIC.

ExoPlayer admite HttpEngine con su HttpEngineDataSource.Factory. Puedes insertar esta fábrica de fuentes de datos como se describe en Cómo configurar ExoPlayer para usar una pila de red específica.

Cronet

Cronet es la pila de red de Chromium que está disponible para las apps de Android como una biblioteca. Cronet aprovecha las múltiples tecnologías que reducen la latencia y aumentan la capacidad de procesamiento de las solicitudes de red que tu app necesita para funcionar, incluidas las que realiza ExoPlayer. Admite de forma nativa los protocolos HTTP, HTTP/2 y HTTP/3 a través de QUIC. Cronet es usado por algunas de las apps de streaming más grandes del mundo, incluido YouTube.

ExoPlayer admite Cronet a través de su biblioteca de Cronet. Consulta el README.md de la biblioteca para obtener instrucciones detalladas sobre cómo usarlo. Ten en cuenta que la biblioteca Cronet puede usar tres Cronet subyacentes implementaciones:

1. Servicios de Google Play: Recomendamos usar esta implementación en la mayoría de y recurrir a la pila de red integrada de Android (DefaultHttpDataSource) si los Servicios de Google Play no están disponibles.
2. Cronet incorporado: Puede ser una buena opción si un gran porcentaje de tus usuarios se encuentra en mercados donde los Servicios de Google Play no están disponibles en general, o si deseas controlar la versión exacta de la implementación de Cronet que se usa. La principal desventaja de Cronet incorporado es que agrega aproximadamente 8 MB a tu app.
3. Resguardo de Cronet: La implementación de resguardo de Cronet implementa La API de Cronet como wrapper de la pila de red integrada de Android. Debe no debe usarse con ExoPlayer, ya que usar la pila de red integrada de Android directamente (mediante DefaultHttpDataSource) es más eficiente.

OkHttp

OkHttp es otra pila de redes moderna que muchas apps populares de Android usan ampliamente. Admite HTTP y HTTP/2, pero aún no admite HTTP/3 a través de QUIC.

ExoPlayer admite OkHttp a través de su biblioteca de OkHttp. Consulta el README.md de la biblioteca para obtener instrucciones detalladas sobre cómo usarlo. Cuando se usa la biblioteca de OkHttp, la pila de red se incorpora en la app. Esto es similar a Cronet incorporado, sin embargo, OkHttp es mucho más pequeño y agrega menos de 1 MB a tu app.

Pila de red integrada de Android

ExoPlayer admite el uso de la pila de red integrada de Android con DefaultHttpDataSource y DefaultHttpDataSource.Factory, que forman parte de la biblioteca principal de ExoPlayer.

La implementación exacta de la pila de red depende del software que se ejecuta en el dispositivo subyacente. En la mayoría de los dispositivos, solo se admite HTTP (es decir, no se admiten HTTP/2 ni HTTP/3 a través de QUIC).

Otras pilas de red

Las apps también pueden integrar otras pilas de red con ExoPlayer. Para ello, implementa una HttpDataSource que una la pila de red junto con una HttpDataSource.Factory correspondiente. Las bibliotecas de Cronet y OkHttp de ExoPlayer son buenos ejemplos de cómo hacerlo.

Cuando realices la integración con una pila de red Java pura, te recomendamos que implementes un DataSourceContractTest para verificar que tu implementación de HttpDataSource se comporte correctamente. OkHttpDataSourceContractTest en la biblioteca de OkHttp es un buen ejemplo de cómo hacerlo.

Cómo elegir una pila de red

En la siguiente tabla, se describen las ventajas y desventajas de las pilas de red compatibles con ExoPlayer.

Los protocolos HTTP/2 y HTTP/3 a través de QUIC pueden mejorar significativamente los medios y el rendimiento de la transmisión. En particular, cuando se transmite contenido multimedia adaptable que se distribuye a través de una red de distribución de contenido (CDN), hay casos en los que el uso de estos protocolos puede permitir que las CDN funcionen de manera mucho más eficiente. Por este motivo, la compatibilidad de HttpEngine y Cronet con HTTP/2 y HTTP/3 sobre QUIC (y la compatibilidad de OkHttp con HTTP/2), es un beneficio importante en comparación con con la pila de red incorporada de Android, siempre que los servidores en los que el contenido alojado también es compatible con estos protocolos.

Cuando se considera la transmisión de contenido multimedia de forma aislada, recomendamos el uso de HttpEngine o Cronet proporcionada por los Servicios de Google Play volverá a DefaultHttpDataSource si los Servicios de Google Play no están disponibles. Esta recomendación tiene una buena falta Equilibrio entre habilitar el uso de HTTP/2 y HTTP/3 a través de QUIC en la mayoría de los dispositivos y lo que evita un aumento significativo en el tamaño del APK. Existen excepciones a esta recomendación. En los casos en los que es probable que los Servicios de Google Play no estén disponibles en una fracción significativa de los dispositivos que ejecutarán tu app, es posible que sea más apropiado usar Cronet Embedded o OkHttp. Uso de la función la pila de red puede ser aceptable si el tamaño del APK es una preocupación importante la transmisión es solo una parte menor de la funcionalidad de la app.

Más allá de solo los medios, es una buena idea elegir una sola pila de red para todas las redes que realiza tu app. Esto permite que los recursos (como sockets) para agrupar y compartir de manera eficiente entre ExoPlayer y otros componentes de la aplicación.

Porque es probable que tu app necesite establecer redes de contactos para la reproducción de contenido multimedia, la pila de red que elijas recomendaciones anteriores para la transmisión de contenido multimedia aislada, los requisitos de cualquier otros componentes que realizan redes y su importancia relativa para .

Almacenamiento en caché de contenido multimedia

ExoPlayer admite el almacenamiento en caché de bytes cargados en el disco para evitar que se carguen los mismos bytes de la red de forma repetida. Esto es útil cuando se retrocede en el contenido multimedia actual o se repite el mismo elemento.

El almacenamiento en caché requiere una instancia SimpleCache que apunte a una caché dedicada y un 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();