HLS

ExoPlayer unterstützt HLS mit mehreren Containerformaten. Außerdem müssen die enthaltenen Audio- und Video-Sample-Formate unterstützt werden. Weitere Informationen finden Sie im Abschnitt Sample-Formate. Wir empfehlen HLS-Inhaltsanbietern dringend, HLS-Streams hoher Qualität zu generieren, wie in diesem Blogpost beschrieben.

Funktion Unterstützt Kommentare
Container
MPEG-TS JA
FMP4/CMAF JA
ADTS (AAC) JA
MP3 JA
Untertitel
CEA-608 JA
CEA-708 JA
WebVTT JA
Metadaten
ID3 JA
SCTE-35 NEIN
Inhaltsschutz
AES-128 JA
Beispiel AES-128 NEIN
Widevine JA API 19+ („cenc“-Schema) und 25+ („cbcs“-Schema)
PlayReady SL2000 JA Nur Android TV
Serversteuerung
Delta-Aktualisierungen JA
Playlist-Neustart blockieren JA
Laden von Hinweisen zum Vorabladen blockieren JA Außer für Bytebereiche mit nicht definierter Länge
Anzeigenbereitstellung
Servergestützte Anzeigenbereitstellung (Interstitials) Teilweise Nur VOD mit X-ASSET-URI. Livestreams und X-ASSET-LIST werden später hinzugefügt.
IMA-Anzeigen (server- und clientseitig) JA Leitfaden für die Anzeigenbereitstellung
Livewiedergabe
Regelmäßige Livewiedergabe JA
HLS mit niedriger Latenz (Apple) JA
HLS mit niedriger Latenz (Community) NEIN
Common Media Client Data CMCD JA CMCD-Integrationsleitfaden

MediaItem verwenden

Wenn du einen HLS-Stream wiedergeben möchtest, benötigst du das HLS-Modul.

Kotlin

implementation("androidx.media3:media3-exoplayer-hls:1.6.0")

Groovy

implementation "androidx.media3:media3-exoplayer-hls:1.6.0"

Du kannst dann eine MediaItem für einen HLS-Playlist-URI erstellen und an den Player übergeben.

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();

Wenn dein URI nicht auf .m3u8 endet, kannst du MimeTypes.APPLICATION_M3U8 an setMimeType von MediaItem.Builder übergeben, um den Inhaltstyp explizit anzugeben.

Der URI des Medienelements kann entweder auf eine Medienplaylist oder eine mehrvariantige Playlist verweisen. Wenn der URI auf eine mehrvariantige Playlist verweist, die mehrere #EXT-X-STREAM-INF-Tags deklariert, passt sich ExoPlayer automatisch zwischen den Varianten an. Dabei werden sowohl die verfügbare Bandbreite als auch die Gerätefunktionen berücksichtigt.

HlsMediaSource verwenden

Wenn du mehr Anpassungsoptionen benötigst, kannst du statt einer MediaItem eine HlsMediaSource erstellen und direkt an den Player übergeben.

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();

Auf das Manifest zugreifen

Sie können das aktuelle Manifest durch Aufrufen von Player.getCurrentManifest abrufen. Bei HLS solltest du das zurückgegebene Objekt in HlsManifest umwandeln. Der onTimelineChanged-Callback von Player.Listener wird auch jedes Mal aufgerufen, wenn das Manifest geladen wird. Bei On-Demand-Inhalten geschieht dies einmal, bei Livestreams möglicherweise mehrmals. Das folgende Code-Snippet zeigt, wie eine App etwas tun kann, wenn das Manifest geladen wird.

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.
        }
      }
    });

HLS-Streams mit Interstitials abspielen

Die HLS-Spezifikation definiert HLS-Interstitials, mit denen Interstitial-Informationen in eine Medienplaylist aufgenommen werden können. ExoPlayer ignoriert diese Interstitials standardmäßig. Sie können Support mit HlsInterstitialsAdsLoader hinzufügen. Nicht alle Funktionen der Spezifikation werden von Anfang an unterstützt. Wenn du Unterstützung für deinen Stream benötigst, melde ein Problem auf GitHub und sende uns deine Stream-URI, damit wir Unterstützung für deinen Stream hinzufügen können.

MediaItem mit der Playlist API verwenden

Die einfachste Möglichkeit, HLS-Streams mit Interstitials abzuspielen, besteht darin, eine ExoPlayer-Instanz mit einer HlsInterstitialsAdsLoader.AdsMediaSourceFactory zu erstellen. So kannst du die MediaItem-basierte Playlist API der Player-Benutzeroberfläche zum Abspielen von HLS-Interstitials verwenden.

Die MediaSource.Factory von ExoPlayer kann beim Erstellen der Playerinstanz in den Builder eingefügt werden:

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);

Bei einer solchen Playerkonfiguration musst du zum Abspielen von HLS-Interstitials nur ein Medienelement mit einem AdsConfiguration im Player einrichten:

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();

API auf Grundlage der Medienquelle verwenden

Alternativ kann die ExoPlayer-Instanz erstellt werden, ohne die Standard-Media-Quell-Fabrik zu überschreiben. Um Interstitials zu unterstützen, kann eine App dann HlsInterstitialsAdsLoader.AdsMediaSourceFactory direkt verwenden, um eine MediaSource zu erstellen und sie über die API für die playlistbasierte Medienquelle an ExoPlayer weiterzugeben:

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();

Auf Anzeigenereignisse warten

Listener kann HlsInterstitialsAdsLoader hinzugefügt werden, um Ereignisse zu Statusänderungen bei der Wiedergabe von HLS-Interstitials zu überwachen. So können Apps oder SDKs wiedergegebene Anzeigen, geladene Asset-Listen und vorbereitete Anzeigenmedienquellen erfassen oder Fehler beim Laden der Asset-Liste und bei der Anzeigenvorbereitung erkennen. Außerdem können von Anzeigenmedienquellen gesendete Metadaten für eine detaillierte Überprüfung der Anzeigenwiedergabe oder zum Überwachen des Fortschritts der Anzeigenwiedergabe empfangen werden.

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.
  }
}

Eine detaillierte Dokumentation aller verfügbaren Rückrufe findest du in der JavaDoc von HlsInterstitialsAdsLoader.Listener.

Der Listener kann dann dem Anzeigen-Ladeprogramm hinzugefügt werden:

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);

HlsInterstitialsAdsLoader Lebenszyklus

Eine Instanz von HlsInterstitialsAdsLoader oder HlsInterstitialsAdsLoader.AdsMediaSourceFactory kann für mehrere Playerinstanzen wiederverwendet werden, die mehrere Medienquellen erstellen, für die Anzeigen geladen werden müssen.

Eine Instanz kann beispielsweise in der onCreate-Methode einer Activity erstellt und dann für mehrere Spielerinstanzen wiederverwendet werden. Das funktioniert, solange es von einer einzelnen Spielerinstanz gleichzeitig verwendet wird. Das ist nützlich für den häufigen Anwendungsfall, wenn die App in den Hintergrund verschoben wird, die Playerinstanz zerstört wird und dann eine neue Instanz erstellt wird, wenn die App wieder im Vordergrund ist.

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();

Im Allgemeinen solltest du die alte Playerinstanz freigeben, bevor du die nächste Playerinstanz im Anzeigen-Ladeprogramm festlegst. Sobald der Anzeigen-Lademechanismus selbst veröffentlicht wurde, kann er nicht mehr verwendet werden.

Wiedergabe anpassen

Mit ExoPlayer hast du mehrere Möglichkeiten, die Wiedergabe an die Anforderungen deiner App anzupassen. Beispiele finden Sie auf der Seite „Anpassen“.

Vorbereitung ohne Chunks deaktivieren

Standardmäßig verwendet ExoPlayer die chunklose Vorbereitung. Das bedeutet, dass ExoPlayer nur die Informationen in der multivariaten Playlist verwendet, um den Stream vorzubereiten. Das funktioniert, wenn die #EXT-X-STREAM-INF-Tags das CODECS-Attribut enthalten.

Möglicherweise musst du diese Funktion deaktivieren, wenn deine Mediensegmente gemuxte Untertiteltracks enthalten, die in der Playlist mit mehreren Varianten nicht mit einem #EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS-Tag deklariert sind. Andernfalls werden diese Untertitelungstracks nicht erkannt und wiedergegeben. Sie können die chunklose Vorbereitung in HlsMediaSource.Factory deaktivieren, wie im folgenden Snippet gezeigt. Hinweis: Dadurch verlängert sich die Startzeit, da ExoPlayer ein Mediensegment herunterladen muss, um diese zusätzlichen Tracks zu finden. Es ist daher besser, die Untertiteltracks in der mehrvarianten Playlist anzugeben.

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));

HLS-Inhalte in hoher Qualität erstellen

Damit du ExoPlayer optimal nutzen kannst, gibt es bestimmte Richtlinien, mit denen du deine HLS-Inhalte verbessern kannst. Eine ausführliche Erklärung findest du in unserem Medium-Beitrag zur HLS-Wiedergabe in ExoPlayer. Die wichtigsten Punkte:

  • Verwenden Sie genaue Segmentdauern.
  • Verwende einen kontinuierlichen Medienstream und vermeide Änderungen an der Medienstruktur in den einzelnen Segmenten.
  • Verwenden Sie das #EXT-X-INDEPENDENT-SEGMENTS-Tag.
  • Verwende demultiplexierte Streams anstelle von Dateien, die sowohl Video als auch Audio enthalten.
  • Geben Sie in der Playlist mit mehreren Varianten alle Informationen an, die Sie haben.

Die folgenden Richtlinien gelten speziell für Livestreams:

  • Verwenden Sie das #EXT-X-PROGRAM-DATE-TIME-Tag.
  • Verwenden Sie das #EXT-X-DISCONTINUITY-SEQUENCE-Tag.
  • Bieten Sie ein langes Live-Fenster. Eine Minute oder länger ist ideal.