Pilas de red

ExoPlayer se suele usar para transmitir contenido multimedia por Internet. Admite varias pilas de red para realizar sus solicitudes de red subyacentes. La 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 que use la pila de red que elijas, se enumeran las opciones disponibles, se proporcionan algunas pautas para elegir una pila de red para tu app y se explica cómo habilitar el almacenamiento en caché para el contenido multimedia transmitido.

Configura ExoPlayer para que use 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 cualquier instancia de DataSource.Factory que tu app inserte para que sean instancias de HttpDataSource.Factory que correspondan a la pila de red que quieras usar. Si tu app también necesita reproducir contenido que no sea HTTP(S), como archivos locales, usa DefaultDataSource.Factory:

DefaultDataSource.Factory(
  context,
  /* baseDataSourceFactory= */ PreferredHttpDataSource.Factory(context),
)
NetworkStacks.kt

new DefaultDataSource.Factory(
    context, /* baseDataSourceFactory= */ new PreferredHttpDataSource.Factory(context));
NetworkStacks.java

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

En el siguiente ejemplo, se muestra cómo compilar un ExoPlayer que usará la pila de red 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()
NetworkStacks.kt

// 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();
NetworkStacks.java

Pilas de red compatibles

ExoPlayer proporciona compatibilidad directa con HttpEngine, Cronet, OkHttp y la pila de red integrada predeterminada 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 de la API 34 (o las extensiones 7 de S). En la mayoría de los casos, usa la pila de red de Cronet de forma interna, lo que admite los protocolos HTTP, HTTP/2 y HTTP/3 sobre QUIC.

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

Cronet

Cronet es la pila de red de Chromium que está disponible para las apps para 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 sobre QUIC. Algunas de las apps de transmisión más grandes del mundo, como YouTube, usan Cronet.

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

1. Servicios de Google Play: Te recomendamos que uses esta implementación en la mayoría de los casos y que recurras 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 en los que los Servicios de Google Play no están ampliamente disponibles o si quieres controlar la versión exacta de la implementación de Cronet que se usa. La principal desventaja de Cronet Embedded 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 un wrapper alrededor de la pila de red integrada de Android. No se debe usar con ExoPlayer, ya que es más eficiente usar directamente la pila de red integrada de Android (con DefaultHttpDataSource).

OkHttp

OkHttp es otra pila de red moderna que usan muchas apps para Android populares. Admite HTTP y HTTP/2, pero aún no admite HTTP/3 sobre QUIC.

ExoPlayer admite OkHttp a través de su biblioteca de OkHttp. Consulta el archivo README.md de la biblioteca para obtener instrucciones detalladas sobre cómo usarla. Cuando se usa la biblioteca de OkHttp, la pila de red se incorpora en la app. Esto es similar a Cronet Embedded, pero OkHttp es mucho más pequeña, ya que 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 sobre QUIC).

Otras pilas de red

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

Cuando se integra con una pila de red de Java pura, se recomienda implementar un DataSourceContractTest para verificar que la implementación de HttpDataSource se comporte correctamente. OkHttpDataSourceContractTest en la biblioteca de OkHttp es un buen ejemplo de cómo hacerlo.

Elige 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 sobre QUIC pueden mejorar significativamente el rendimiento de la transmisión de contenido multimedia. En particular, cuando se transmite contenido multimedia adaptable que se distribuye con 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 en QUIC (y la compatibilidad de OkHttp con HTTP/2) es un gran beneficio en comparación con el uso de la pila de red integrada de Android, siempre que los servidores en los que se aloja el contenido también admitan estos protocolos.

Cuando consideres la transmisión de contenido multimedia de forma aislada, te recomendamos que uses HttpEngine o Cronet proporcionado por los Servicios de Google Play, y que recurras a DefaultHttpDataSource si los Servicios de Google Play no están disponibles. Esta recomendación logra un buen equilibrio entre habilitar el uso de HTTP/2 y HTTP/3 sobre QUIC en la mayoría de los dispositivos y evitar un aumento significativo en el tamaño del APK. Existen excepciones a esta recomendación. En los casos en 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, puede ser más apropiado usar Cronet Embedded u OkHttp. El uso de la pila de red integrada puede ser aceptable si el tamaño del APK es un problema crítico o si la transmisión de contenido multimedia es solo una parte menor de la funcionalidad de tu app.

Más allá de los medios, suele ser una buena idea elegir una sola pila de red para todas las redes que realiza tu app. Esto permite que los recursos (como los sockets) se agrupen y compartan de manera eficiente entre ExoPlayer y otros componentes de la app.

Dado que es muy probable que tu app deba realizar tareas de red no relacionadas con la reproducción de contenido multimedia, la elección de la pila de red debe tener en cuenta nuestras recomendaciones anteriores para la transmisión de contenido multimedia de forma aislada, los requisitos de cualquier otro componente que realice tareas de red y su importancia relativa para tu app.

Almacena contenido multimedia en caché

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

El almacenamiento en caché requiere una instancia de SimpleCache que apunte a un directorio de caché dedicado 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()
NetworkStacks.kt

// 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();
NetworkStacks.java