ExoPlayer admite HLS con varios formatos de contenedor. Los formatos de muestra de audio y video contenidos también deben ser compatibles (consulta la sección Formatos de muestra para obtener más información). Recomendamos a los productores de contenido HLS que generen transmisiones HLS de alta calidad, como se describe en esta entrada de blog.
Función | Compatible | Comentarios |
---|---|---|
Contenedores | ||
MPEG-TS | SÍ | |
FMP4/CMAF | SÍ | |
ADTS (AAC) | SÍ | |
MP3 | SÍ | |
Subtítulos (closed captions) | ||
CEA-608 | SÍ | |
CEA-708 | SÍ | |
WebVTT | SÍ | |
Metadatos | ||
ID3 | SÍ | |
SCTE-35 | NO | |
Protección del contenido | ||
AES-128 | SÍ | |
Muestra de AES-128 | NO | |
Widevine | SÍ | Niveles de API 19 y superiores ("cenc") y 25 y superiores ("cbcs") |
PlayReady SL2000 | SÍ | Únicamente para Android TV |
Control de servidores | ||
Actualizaciones delta | SÍ | |
Cómo bloquear la recarga de una playlist | SÍ | |
Bloquea la carga de sugerencias de carga previa | SÍ | Excepto para los rangos de bytes con longitudes no definidas |
Inserción de anuncios | ||
Inserción de anuncios guiada por el servidor (anuncios intersticiales) | Parcialmente | Solo VOD con X-ASSET-URI .
Las transmisiones en vivo y X-ASSET-LIST se agregarán más adelante. |
Anuncios del servidor y del cliente de IMA | SÍ | Guía de inserción de anuncios |
Reproducción en vivo | ||
Reproducción en vivo normal | SÍ | |
HLS de baja latencia (Apple) | SÍ | |
HLS de baja latencia (comunitario) | NO | |
Datos comunes de clientes multimedia CMCD | SÍ | Guía de integración de CMCD |
Cómo usar MediaItem
Para reproducir una transmisión HLS, debes depender del módulo HLS.
Kotlin
implementation("androidx.media3:media3-exoplayer-hls:1.6.0")
Groovy
implementation "androidx.media3:media3-exoplayer-hls:1.6.0"
Luego, puedes crear un MediaItem
para un URI de playlist HLS y pasarlo al reproductor.
Kotlin
// Create a player instance.
val player = ExoPlayer.Builder(context).build()
// Set the media item to be played.
player.setMediaItem(MediaItem.fromUri(hlsUri))
// Prepare the player.
player.prepare()
Java
// Create a player instance.
ExoPlayer player = new ExoPlayer.Builder(context).build();
// Set the media item to be played.
player.setMediaItem(MediaItem.fromUri(hlsUri));
// Prepare the player.
player.prepare();
Si tu URI no termina con .m3u8
, puedes pasar MimeTypes.APPLICATION_M3U8
a setMimeType
de MediaItem.Builder
para indicar de forma explícita el tipo de contenido.
El URI del elemento multimedia puede apuntar a una playlist multimedia o a una playlist multivariante. Si el URI apunta a una playlist multivariante que declara varias etiquetas #EXT-X-STREAM-INF
, ExoPlayer se adaptará automáticamente entre las variantes, teniendo en cuenta el ancho de banda disponible y las capacidades del dispositivo.
Cómo usar HlsMediaSource
Para obtener más opciones de personalización, puedes crear un HlsMediaSource
y pasarlo directamente al reproductor en lugar de un MediaItem
.
Kotlin
// Create a data source factory.
val dataSourceFactory: DataSource.Factory = DefaultHttpDataSource.Factory()
// Create a HLS media source pointing to a playlist uri.
val hlsMediaSource =
HlsMediaSource.Factory(dataSourceFactory).createMediaSource(MediaItem.fromUri(hlsUri))
// Create a player instance.
val player = ExoPlayer.Builder(context).build()
// Set the HLS media source as the playlist with a single media item.
player.setMediaSource(hlsMediaSource)
// Prepare the player.
player.prepare()
Java
// Create a data source factory.
DataSource.Factory dataSourceFactory = new DefaultHttpDataSource.Factory();
// Create a HLS media source pointing to a playlist uri.
HlsMediaSource hlsMediaSource =
new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(MediaItem.fromUri(hlsUri));
// Create a player instance.
ExoPlayer player = new ExoPlayer.Builder(context).build();
// Set the HLS media source as the playlist with a single media item.
player.setMediaSource(hlsMediaSource);
// Prepare the player.
player.prepare();
Cómo acceder al manifiesto
Para recuperar el manifiesto actual, llama a Player.getCurrentManifest
.
Para HLS, debes transmitir el objeto que se muestra a HlsManifest
. También se llama a la devolución de llamada onTimelineChanged
de Player.Listener
cada vez que se carga el manifiesto. Esto sucederá una vez para el contenido on demand y, posiblemente, muchas veces para el contenido en vivo. En el siguiente fragmento de código, se muestra cómo una app puede hacer algo cada vez que se carga el manifiesto.
Kotlin
player.addListener(
object : Player.Listener {
override fun onTimelineChanged(timeline: Timeline, @TimelineChangeReason reason: Int) {
val manifest = player.currentManifest
if (manifest is HlsManifest) {
// Do something with the manifest.
}
}
}
)
Java
player.addListener(
new Player.Listener() {
@Override
public void onTimelineChanged(
Timeline timeline, @Player.TimelineChangeReason int reason) {
Object manifest = player.getCurrentManifest();
if (manifest != null) {
HlsManifest hlsManifest = (HlsManifest) manifest;
// Do something with the manifest.
}
}
});
Cómo reproducir transmisiones HLS con anuncios intersticiales
La especificación de HLS define los anuncios intersticiales de HLS que se pueden usar para incluir información intersticial en una playlist multimedia. De forma predeterminada, ExoPlayer ignora estos anuncios intersticiales. Se puede agregar compatibilidad con HlsInterstitialsAdsLoader
. No admitimos todas las funciones de la especificación desde el principio. Si no tienes compatibilidad con tu transmisión, informa un problema en GitHub y envíanos el URI de la transmisión para que podamos agregar compatibilidad.
Usa un MediaItem
con la API de playlist
La forma más conveniente de reproducir transmisiones HLS con anuncios intersticiales es compilar una instancia de ExoPlayer con un HlsInterstitialsAdsLoader.AdsMediaSourceFactory
.
Esto permite usar la API de playlist basada en MediaItem
de la interfaz Player
para reproducir anuncios intersticiales HLS.
El MediaSource.Factory
de ExoPlayer
se puede insertar en el compilador cuando se compila la instancia del reproductor:
Kotlin
hlsInterstitialsAdsLoader = HlsInterstitialsAdsLoader(context)
// Create a MediaSource.Factory for HLS streams with interstitials.
var hlsMediaSourceFactory =
HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
hlsInterstitialsAdsLoader,
playerView,
DefaultMediaSourceFactory(context),
)
// Build player with interstitials media source factory
player =
ExoPlayer.Builder(context)
.setMediaSourceFactory(hlsMediaSourceFactory)
.build()
// Set the player on the ads loader.
hlsInterstitialsAdsLoader.setPlayer(player)
playerView.setPlayer(player)
Java
hlsInterstitialsAdsLoader = new HlsInterstitialsAdsLoader(context);
// Create a MediaSource.Factory for HLS streams with interstitials.
MediaSource.Factory hlsMediaSourceFactory =
new HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
hlsInterstitialsAdsLoader, playerView, new DefaultMediaSourceFactory(context));
// Build player with interstitials media source factory
player =
new ExoPlayer.Builder(context)
.setMediaSourceFactory(hlsMediaSourceFactory)
.build();
// Set the player on the ads loader.
hlsInterstitialsAdsLoader.setPlayer(player);
playerView.setPlayer(player);
Con esa configuración del reproductor, reproducir anuncios intersticiales HLS es solo cuestión de configurar un elemento multimedia con un AdsConfiguration
en el reproductor:
Kotlin
player.setMediaItem(
MediaItem.Builder()
.setUri("https://www.example.com/media.m3u8")
.setAdsConfiguration(
AdsConfiguration.Builder(Uri.parse("hls://interstitials"))
.setAdsId("ad-tag-0") // must be unique within playlist
.build())
.build())
player.prepare();
player.play();
Java
player.setMediaItem(
new MediaItem.Builder()
.setUri("https://www.example.com/media.m3u8")
.setAdsConfiguration(
new AdsConfiguration.Builder(Uri.parse("hls://interstitials"))
.setAdsId("ad-tag-0") // must be unique within playlist
.build())
.build());
player.prepare();
player.play();
Usa la API basada en la fuente de medios
Como alternativa, la instancia de ExoPlayer se puede compilar sin anular la fábrica de fuentes de contenido multimedia predeterminada. Para admitir anuncios intersticiales, una app puede usar HlsInterstitialsAdsLoader.AdsMediaSourceFactory
directamente para crear un MediaSource
y proporcionarlo a ExoPlayer con la API de playlist basada en la fuente de medios:
Kotlin
hlsInterstitialsAdsLoader = HlsInterstitialsAdsLoader(context)
// Create a MediaSource.Factory for HLS streams with interstitials.
var hlsMediaSourceFactory =
HlsInterstitialsAdsLoader.AdsMediaSourceFactory(hlsInterstitialsAdsLoader, playerView, context)
// Build player with default media source factory.
player = new ExoPlayer.Builder(context).build();
// Create an media source from an HLS media item with ads configuration.
val mediaSource =
hlsMediaSourceFactory.createMediaSource(
MediaItem.Builder()
.setUri("https://www.example.com/media.m3u8")
.setAdsConfiguration(
MediaItem.AdsConfiguration.Builder(Uri.parse("hls://interstitials"))
.setAdsId("ad-tag-0")
.build()
)
.build()
)
// Set the media source on the player.
player.setMediaSource(mediaSource)
player.prepare()
player.play()
Java
HlsInterstitialsAdsLoader hlsInterstitialsAdsLoader = new HlsInterstitialsAdsLoader(context);
// Create a MediaSource.Factory for HLS streams with interstitials.
MediaSource.Factory hlsMediaSourceFactory =
new HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
hlsInterstitialsAdsLoader, playerView, context);
// Build player with default media source factory.
player = new ExoPlayer.Builder(context).build();
// Create an media source from an HLS media item with ads configuration.
MediaSource mediaSource =
hlsMediaSourceFactory.createMediaSource(
new MediaItem.Builder()
.setUri("https://www.example.com/media.m3u8")
.setAdsConfiguration(
new MediaItem.AdsConfiguration.Builder(Uri.parse("hls://interstitials"))
.setAdsId("ad-tag-0")
.build())
.build());
// Set the media source on the player.
exoPlayer.setMediaSource(mediaSource);
exoPlayer.prepare();
exoPlayer.play();
Cómo escuchar eventos de anuncios
Se puede agregar un Listener
a HlsInterstitialsAdsLoader
para supervisar los eventos relacionados con los cambios de estado relacionados con la reproducción de anuncios intersticiales HLS. Esto permite que una app o un SDK hagan un seguimiento de los anuncios que se reproducen, las listas de recursos que se cargan, las fuentes de medios de anuncios que se preparan o detecten errores de carga de la lista de recursos y de preparación de anuncios. Además, los metadatos que emiten las fuentes de medios de anuncios se pueden recibir para verificar la reproducción de anuncios detallada o hacer un seguimiento del progreso de la reproducción de anuncios.
Kotlin
class AdsLoaderListener : HlsInterstitialsAdsLoader.Listener {
override fun onStart(mediaItem: MediaItem, adsId: Any, adViewProvider: AdViewProvider) {
// Do something when HLS media item with interstitials is started.
}
override fun onMetadata(
mediaItem: MediaItem,
adsId: Any,
adGroupIndex: Int,
adIndexInAdGroup: Int,
metadata: Metadata,
) {
// Do something with metadata that is emitted by the ad media source of the given ad.
}
override fun onAdCompleted(
mediaItem: MediaItem,
adsId: Any,
adGroupIndex: Int,
adIndexInAdGroup: Int,
) {
// Do something when ad completed playback.
}
// ... See JavaDoc for further callbacks of HlsInterstitialsAdsLoader.Listener.
override fun onStop(mediaItem: MediaItem, adsId: Any, adPlaybackState: AdPlaybackState) {
// Do something with the resulting ad playback state when stopped.
}
}
Java
private class AdsLoaderListener
implements HlsInterstitialsAdsLoader.Listener {
// implement HlsInterstitialsAdsLoader.Listener
@Override
public void onStart(MediaItem mediaItem, Object adsId, AdViewProvider adViewProvider) {
// Do something when HLS media item with interstitials is started.
}
@Override
public void onMetadata(
MediaItem mediaItem,
Object adsId,
int adGroupIndex,
int adIndexInAdGroup,
Metadata metadata) {
// Do something with metadata that is emitted by the ad media source of the given ad.
}
@Override
public void onAdCompleted(
MediaItem mediaItem, Object adsId, int adGroupIndex, int adIndexInAdGroup) {
// Do something when ad completed playback.
}
// ... See JavaDoc for further callbacks
@Override
public void onStop(MediaItem mediaItem, Object adsId, AdPlaybackState adPlaybackState) {
// Do something with the resulting ad playback state when stopped.
}
}
Consulta el JavaDoc de HlsInterstitialsAdsLoader.Listener
para obtener la documentación detallada de todas las devoluciones de llamada disponibles.
Luego, se puede agregar el objeto de escucha al cargador de anuncios:
Kotlin
var listener = AdsLoaderListener();
// Add the listener to the ads loader to receive ad loader events.
hlsInterstitialsAdsLoader.addListener(listener);
Java
AdsLoaderListener listener = new AdsLoaderListener();
// Add the listener to the ads loader to receive ad loader events.
hlsInterstitialsAdsLoader.addListener(listener);
Ciclo de vida de HlsInterstitialsAdsLoader
Una instancia de HlsInterstitialsAdsLoader
o HlsInterstitialsAdsLoader.AdsMediaSourceFactory
se puede reutilizar para varias instancias de reproductores que crean varias fuentes de contenido multimedia para las que se deben cargar anuncios.
Por ejemplo, se puede crear una instancia en el método onCreate
de un Activity
y, luego, reutilizarla para varias instancias de jugadores. Esto funciona siempre que una sola instancia de jugador la use al mismo tiempo. Esto es útil para el caso de uso común cuando la app se pasa a segundo plano, se destruye la instancia del reproductor y, luego, se crea una instancia nueva cuando la app vuelve a estar en primer plano.
Kotlin
// Create the ads loader instance (for example onCreate).
hlsInterstitialsAdsLoader = HlsInterstitialsAdsLoader(context);
// Build a player and set it on the ads loader (for example onStart).
player = ExoPlayer.Builder(context).build();
hlsInterstitialsAdsLoader.setPlayer(player);
// Release the player and unset it on the ads loader (for example onStop).
player.release();
hlsInterstitialsAdsLoader.setPlayer(null);
// Build another player and set it on the ads loader (for example onStart).
player = ExoPlayer.Builder(context).build();
hlsInterstitialsAdsLoader.setPlayer(player);
// Release the player and unset it on the ads loader (for example onStop).
player.release();
hlsInterstitialsAdsLoader.setPlayer(null);
// Release the ads loader when not used anymore (for example onDestroy).
hlsInterstitialsAdsLoader.release();
Java
// Create the ads loader instance (for example onCreate).
hlsInterstitialsAdsLoader = new HlsInterstitialsAdsLoader(context);
// Build a player and set it on the ads loader (for example onStart).
player = new ExoPlayer.Builder(context).build();
hlsInterstitialsAdsLoader.setPlayer(player);
// Release the player and unset it on the ads loader (for example onStop).
player.release();
hlsInterstitialsAdsLoader.setPlayer(null);
// Build another player and set it on the ads loader (for example onStart).
player = new ExoPlayer.Builder(context).build();
hlsInterstitialsAdsLoader.setPlayer(player);
// Release the player and unset it on the ads loader (for example onStop).
player.release();
hlsInterstitialsAdsLoader.setPlayer(null);
// Release the ads loader when not used anymore (for example onDestroy).
hlsInterstitialsAdsLoader.release();
Por lo general, asegúrate de liberar la instancia de jugador anterior antes de configurar la siguiente instancia de jugador en el cargador de anuncios. Una vez que se lanza el cargador de anuncios, este ya no se puede usar.
Cómo personalizar la reproducción
ExoPlayer ofrece varias formas de personalizar la experiencia de reproducción según las necesidades de tu app. Consulta la página Personalización para ver ejemplos.
Inhabilita la preparación sin fragmentos
De forma predeterminada, ExoPlayer usará la preparación sin fragmentos. Esto significa que ExoPlayer solo usará la información de la playlist multivariante para preparar la transmisión, lo que funciona si las etiquetas #EXT-X-STREAM-INF
contienen el atributo CODECS
.
Es posible que debas inhabilitar esta función si tus segmentos multimedia contienen pistas de subtítulos multiplexadas que no se declararon en la playlist multivariante con una etiqueta #EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS
. De lo contrario, no se detectarán ni reproducirán estas pistas de subtítulos. Puedes inhabilitar la preparación sin fragmentos en HlsMediaSource.Factory
, como se muestra en el siguiente fragmento. Ten en cuenta que esto aumentará el tiempo de inicio, ya que ExoPlayer necesita descargar un segmento de contenido multimedia para descubrir estas pistas adicionales. En su lugar, es preferible declarar las pistas de subtítulos en la playlist multivariante.
Kotlin
val hlsMediaSource =
HlsMediaSource.Factory(dataSourceFactory)
.setAllowChunklessPreparation(false)
.createMediaSource(MediaItem.fromUri(hlsUri))
Java
HlsMediaSource hlsMediaSource =
new HlsMediaSource.Factory(dataSourceFactory)
.setAllowChunklessPreparation(false)
.createMediaSource(MediaItem.fromUri(hlsUri));
Crea contenido HLS de alta calidad
Para aprovechar al máximo ExoPlayer, hay ciertos lineamientos que puedes seguir para mejorar tu contenido HLS. Lee nuestra entrada de Medium sobre la reproducción de HLS en ExoPlayer para obtener una explicación completa. Los puntos principales son los siguientes:
- Usa duraciones de segmentos precisas.
- Usa un flujo de contenido multimedia continuo y evita los cambios en la estructura del contenido multimedia en los segmentos.
- Usa la etiqueta
#EXT-X-INDEPENDENT-SEGMENTS
. - Se prefieren las transmisiones demuxadas, en lugar de los archivos que incluyen video y audio.
- Incluye toda la información que puedas en la playlist multivariante.
Los siguientes lineamientos se aplican específicamente a las transmisiones en vivo:
- Usa la etiqueta
#EXT-X-PROGRAM-DATE-TIME
. - Usa la etiqueta
#EXT-X-DISCONTINUITY-SEQUENCE
. - Proporciona una ventana de publicación activa prolongada. Un minuto o más es ideal.