Cette page a été traduite par l'API Cloud Translation.

Playlists

L'API de la playlist est définie par l'interface Player, qui est implémentée par toutes les implémentations ExoPlayer. Les playlists permettent la lecture séquentielle de plusieurs éléments multimédias. L'exemple suivant montre comment lancer la lecture d'une playlist. contenant deux vidéos:

Kotlin

// Build the media items.
val firstItem = MediaItem.fromUri(firstVideoUri)
val secondItem = MediaItem.fromUri(secondVideoUri)
// Add the media items to be played.
player.addMediaItem(firstItem)
player.addMediaItem(secondItem)
// Prepare the player.
player.prepare()
// Start the playback.
player.play()

Java

// Build the media items.
MediaItem firstItem = MediaItem.fromUri(firstVideoUri);
MediaItem secondItem = MediaItem.fromUri(secondVideoUri);
// Add the media items to be played.
player.addMediaItem(firstItem);
player.addMediaItem(secondItem);
// Prepare the player.
player.prepare();
// Start the playback.
player.play();

Les transitions entre les éléments d'une playlist sont fluides. Il n'y a aucune exigence qu'ils sont du même format (par exemple, une playlist peut contenir les deux H264 et VP9). Ils peuvent même être de différents types (c'est-à-dire qu'un contenant des vidéos, des images et des flux audio uniquement). Vous pouvez utiliser le même MediaItem à plusieurs reprises dans une playlist.

Modifier la playlist

Vous pouvez modifier une playlist de façon dynamique en ajoutant, déplaçant, supprimant ou remplaçant éléments multimédias. Vous pouvez le faire avant et pendant la lecture en appelant la méthode méthodes de l'API des playlists correspondantes:

Kotlin

// Adds a media item at position 1 in the playlist.
player.addMediaItem(/* index= */ 1, MediaItem.fromUri(thirdUri))
// Moves the third media item from position 2 to the start of the playlist.
player.moveMediaItem(/* currentIndex= */ 2, /* newIndex= */ 0)
// Removes the first item from the playlist.
player.removeMediaItem(/* index= */ 0)
// Replace the second item in the playlist.
player.replaceMediaItem(/* index= */ 1, MediaItem.fromUri(newUri))

Java

// Adds a media item at position 1 in the playlist.
player.addMediaItem(/* index= */ 1, MediaItem.fromUri(thirdUri));
// Moves the third media item from position 2 to the start of the playlist.
player.moveMediaItem(/* currentIndex= */ 2, /* newIndex= */ 0);
// Removes the first item from the playlist.
player.removeMediaItem(/* index= */ 0);
// Replace the second item in the playlist.
player.replaceMediaItem(/* index= */ 1, MediaItem.fromUri(newUri));

Vous pouvez également remplacer et effacer toute la playlist:

Kotlin

// Replaces the playlist with a new one.
val newItems: List<MediaItem> = listOf(MediaItem.fromUri(fourthUri), MediaItem.fromUri(fifthUri))
player.setMediaItems(newItems, /* resetPosition= */ true)
// Clears the playlist. If prepared, the player transitions to the ended state.
player.clearMediaItems()

Java

// Replaces the playlist with a new one.
ImmutableList<MediaItem> newItems =
    ImmutableList.of(MediaItem.fromUri(fourthUri), MediaItem.fromUri(fifthUri));
player.setMediaItems(newItems, /* resetPosition= */ true);
// Clears the playlist. If prepared, the player transitions to the ended state.
player.clearMediaItems();

Le lecteur gère automatiquement les modifications lors de la lecture méthode:

Si l'MediaItem en cours de lecture est déplacé, la lecture n'est pas interrompue et et son nouveau successeur sera joué une fois l'opération terminée.
Si l'MediaItem en cours de lecture est supprimé, le lecteur lance automatiquement lire le premier successeur restant ou passer à l'état "terminé" un autre successeur existe.
Si l'MediaItem en cours de lecture est remplacé, la lecture n'est pas interrompue si aucune des propriétés du MediaItem pertinent pour la lecture modifié. Par exemple, il est possible de mettre à jour MediaItem.MediaMetadata dans la plupart des cas sans affecter la lecture.

Interroger la playlist

Vous pouvez interroger la playlist à l'aide de Player.getMediaItemCount et Player.getMediaItemAt L'élément multimédia en cours de lecture peut être interrogé en appelant Player.getCurrentMediaItem. D'autres options sont également des méthodes telles que Player.hasNextMediaItem ou Player.getNextMediaItemIndex pour simplifier la navigation dans la playlist.

Modes de répétition

Le lecteur prend en charge trois modes de répétition pouvant être définis à tout moment avec Player.setRepeatMode:

Player.REPEAT_MODE_OFF: la playlist n'est pas répétée et le lecteur passer à Player.STATE_ENDED une fois que le dernier élément de la playlist a déjà été lu.
Player.REPEAT_MODE_ONE: l'élément actuel est répété dans une boucle sans fin. Les méthodes telles que Player.seekToNextMediaItem ignorent cela et recherchent le prochain élément de la liste, qui est ensuite répété dans une boucle sans fin.
Player.REPEAT_MODE_ALL: la playlist est répétée dans une boucle sans fin.

Mode aléatoire

Vous pouvez activer ou désactiver le mode aléatoire à tout moment Player.setShuffleModeEnabled En mode aléatoire, dans un ordre aléatoire précalculé. Tous les éléments seront lus une fois et le mode aléatoire peut également être associé à Player.REPEAT_MODE_ALL pour répéter le même ordre aléatoire dans une boucle sans fin. Lorsque le mode aléatoire est désactivé, la lecture reprend à partir de l'élément actuel à sa position d'origine dans la playlist.

Notez que les index renvoyés par des méthodes telles que Player.getCurrentMediaItemIndex fait toujours référence à l'original, non lu en mode aléatoire commande. De même, Player.seekToNextMediaItem ne lit pas l'élément à player.getCurrentMediaItemIndex() + 1, mais l'élément suivant ordre de lecture aléatoire. Si vous insérez de nouveaux éléments dans la playlist ou en supprimez, l'ordre de brassage existant inchangé dans la mesure du possible.

Définir un ordre de lecture aléatoire personnalisé

Par défaut, le lecteur accepte la lecture en mode aléatoire à l'aide de DefaultShuffleOrder. Vous pouvez le personnaliser en fournissant une implémentation personnalisée de l'ordre de brassage ou en définir un ordre personnalisé dans le constructeur DefaultShuffleOrder:

Kotlin

// Set a custom shuffle order for the 5 items currently in the playlist:
exoPlayer.setShuffleOrder(DefaultShuffleOrder(intArrayOf(3, 1, 0, 4, 2), randomSeed))
// Enable shuffle mode.
exoPlayer.shuffleModeEnabled = true

Java

// Set a custom shuffle order for the 5 items currently in the playlist:
exoPlayer.setShuffleOrder(new DefaultShuffleOrder(new int[] {3, 1, 0, 4, 2}, randomSeed));
// Enable shuffle mode.
exoPlayer.setShuffleModeEnabled(/* shuffleModeEnabled= */ true);

Identifier les éléments de la playlist

Pour identifier les éléments de la playlist, vous pouvez définir MediaItem.mediaId lors de la création de la élément:

Kotlin

// Build a media item with a media ID.
val mediaItem = MediaItem.Builder().setUri(uri).setMediaId(mediaId).build()

Java

// Build a media item with a media ID.
MediaItem mediaItem = new MediaItem.Builder().setUri(uri).setMediaId(mediaId).build();

Si une application ne définit pas explicitement d'ID multimédia pour un élément multimédia, la chaîne de l'URI est utilisée.

Associer les données de l'application à des éléments de playlist

En plus d'un ID, chaque élément multimédia peut être configuré avec une balise personnalisée, qui peut être n'importe quel objet fourni par l'application. Les tags personnalisés permettent par exemple à chaque élément multimédia:

Kotlin

// Build a media item with a custom tag.
val mediaItem = MediaItem.Builder().setUri(uri).setTag(metadata).build()

Java

// Build a media item with a custom tag.
MediaItem mediaItem = new MediaItem.Builder().setUri(uri).setTag(metadata).build();

Détecter quand la lecture passe à un autre élément multimédia

Lorsque la lecture passe à un autre élément multimédia ou commence à répéter le même contenu élément multimédia, Listener.onMediaItemTransition(MediaItem, @MediaItemTransitionReason) est appelé. Ce rappel reçoit le nouveau contenu avec un élément @MediaItemTransitionReason indiquant pourquoi la transition s'est produit. Un cas d'utilisation courant de onMediaItemTransition consiste à mettre à jour de l'application pour le nouvel élément multimédia:

Kotlin

override fun onMediaItemTransition(
  mediaItem: MediaItem?,
  @MediaItemTransitionReason reason: Int,
) {
  updateUiForPlayingMediaItem(mediaItem)
}

Java

@Override
public void onMediaItemTransition(
    @Nullable MediaItem mediaItem, @MediaItemTransitionReason int reason) {
  updateUiForPlayingMediaItem(mediaItem);
}

Si les métadonnées requises pour la mise à jour de l'interface utilisateur sont associées à chaque élément multimédia à l'aide de balises personnalisées, l'implémentation peut se présenter comme suit:

Kotlin

override fun onMediaItemTransition(
  mediaItem: MediaItem?,
  @MediaItemTransitionReason reason: Int,
) {
  var metadata: CustomMetadata? = null
  mediaItem?.localConfiguration?.let { localConfiguration ->
    metadata = localConfiguration.tag as? CustomMetadata
  }
  updateUiForPlayingMediaItem(metadata)
}

Java

@Override
public void onMediaItemTransition(
    @Nullable MediaItem mediaItem, @MediaItemTransitionReason int reason) {
  @Nullable CustomMetadata metadata = null;
  if (mediaItem != null && mediaItem.localConfiguration != null) {
    metadata = (CustomMetadata) mediaItem.localConfiguration.tag;
  }
  updateUiForPlayingMediaItem(metadata);
}

Détecter les changements dans la playlist

Lorsqu'un élément multimédia est ajouté, supprimé ou déplacé, Listener.onTimelineChanged(Timeline, @TimelineChangeReason) est appelé immédiatement avec TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED. Ce rappel est appelé même lorsque le joueur n'a pas encore été préparé.

Kotlin

override fun onTimelineChanged(timeline: Timeline, @TimelineChangeReason reason: Int) {
  if (reason == Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
    // Update the UI according to the modified playlist (add, move or remove).
    updateUiForPlaylist(timeline)
  }
}

Java

@Override
public void onTimelineChanged(Timeline timeline, @TimelineChangeReason int reason) {
  if (reason == TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
    // Update the UI according to the modified playlist (add, move or remove).
    updateUiForPlaylist(timeline);
  }
}

Lorsque des informations telles que la durée d'un élément multimédia dans la playlist deviennent disponible, Timeline sera mis à jour et onTimelineChanged sera appelé avec TIMELINE_CHANGE_REASON_SOURCE_UPDATE. Les autres raisons pouvant expliquer du calendrier concerné incluent les éléments suivants:

Fichier manifeste disponible après avoir préparé un élément multimédia adaptatif.
Fichier manifeste mis à jour régulièrement pendant la lecture d'une diffusion en direct.