sjs/media
1
0
Fork 0
mirror of https://github.com/samsonjs/media.git synced 2026-04-27 15:07:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename Playlist to MediaSourceList

Browse source 
This CL is a renaming only. It's mostly about finding a decent naming for the internal Playlist class. The plan is to have a public Playlist class in the converged Player API, so we need to rename the internal one.

PiperOrigin-RevId: 305266196
This commit is contained in:
bachinger 2020-04-07 16:46:37 +01:00 committed by Oliver Woodman
parent 74a9d8f680
commit 8f24db73f1
7 changed files with 219 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java
View file

@ -68,7 +68,7 @@ import java.util.concurrent.TimeoutException;
private final CopyOnWriteArrayList<ListenerHolder> listeners; private final CopyOnWriteArrayList<ListenerHolder> listeners;
private final Timeline.Period period; private final Timeline.Period period;
private final ArrayDeque<Runnable> pendingListenerNotifications; private final ArrayDeque<Runnable> pendingListenerNotifications;
private final List<Playlist.MediaSourceHolder> mediaSourceHolders; private final List<MediaSourceList.MediaSourceHolder> mediaSourceHolders;
private final boolean useLazyPreparation; private final boolean useLazyPreparation;
private final MediaSourceFactory mediaSourceFactory; private final MediaSourceFactory mediaSourceFactory;
@ -401,7 +401,7 @@ import java.util.concurrent.TimeoutException;
long currentPositionMs = getCurrentPosition(); long currentPositionMs = getCurrentPosition();
Timeline oldTimeline = getCurrentTimeline(); Timeline oldTimeline = getCurrentTimeline();
pendingOperationAcks++; pendingOperationAcks++;
List<Playlist.MediaSourceHolder> holders = addMediaSourceHolders(index, mediaSources); List<MediaSourceList.MediaSourceHolder> holders = addMediaSourceHolders(index, mediaSources);
PlaybackInfo playbackInfo = PlaybackInfo playbackInfo =
maskTimelineAndWindowIndex(currentWindowIndex, currentPositionMs, oldTimeline); maskTimelineAndWindowIndex(currentWindowIndex, currentPositionMs, oldTimeline);
internalPlayer.addMediaSources(index, holders, shuffleOrder); internalPlayer.addMediaSources(index, holders, shuffleOrder);
@ -432,7 +432,7 @@ import java.util.concurrent.TimeoutException;
Timeline oldTimeline = getCurrentTimeline(); Timeline oldTimeline = getCurrentTimeline();
pendingOperationAcks++; pendingOperationAcks++;
newFromIndex = Math.min(newFromIndex, mediaSourceHolders.size() - (toIndex - fromIndex)); newFromIndex = Math.min(newFromIndex, mediaSourceHolders.size() - (toIndex - fromIndex));
Playlist.moveMediaSourceHolders(mediaSourceHolders, fromIndex, toIndex, newFromIndex); MediaSourceList.moveMediaSourceHolders(mediaSourceHolders, fromIndex, toIndex, newFromIndex);
PlaybackInfo playbackInfo = PlaybackInfo playbackInfo =
maskTimelineAndWindowIndex(currentWindowIndex, currentPositionMs, oldTimeline); maskTimelineAndWindowIndex(currentWindowIndex, currentPositionMs, oldTimeline);
internalPlayer.moveMediaSources(fromIndex, toIndex, newFromIndex, shuffleOrder); internalPlayer.moveMediaSources(fromIndex, toIndex, newFromIndex, shuffleOrder);
@ -977,7 +977,8 @@ import java.util.concurrent.TimeoutException;
removeMediaSourceHolders( removeMediaSourceHolders(
/* fromIndex= */ 0, /* toIndexExclusive= */ mediaSourceHolders.size()); /* fromIndex= */ 0, /* toIndexExclusive= */ mediaSourceHolders.size());
} }
List<Playlist.MediaSourceHolder> holders = addMediaSourceHolders(/* index= */ 0, mediaItems); List<MediaSourceList.MediaSourceHolder> holders =
addMediaSourceHolders(/* index= */ 0, mediaItems);
PlaybackInfo playbackInfo = maskTimeline(); PlaybackInfo playbackInfo = maskTimeline();
Timeline timeline = playbackInfo.timeline; Timeline timeline = playbackInfo.timeline;
if (!timeline.isEmpty() && startWindowIndex >= timeline.getWindowCount()) { if (!timeline.isEmpty() && startWindowIndex >= timeline.getWindowCount()) {
@ -1016,12 +1017,12 @@ import java.util.concurrent.TimeoutException;
/* seekProcessed= */ false); /* seekProcessed= */ false);
} }
private List<Playlist.MediaSourceHolder> addMediaSourceHolders( private List<MediaSourceList.MediaSourceHolder> addMediaSourceHolders(
int index, List<MediaSource> mediaSources) { int index, List<MediaSource> mediaSources) {
List<Playlist.MediaSourceHolder> holders = new ArrayList<>(); List<MediaSourceList.MediaSourceHolder> holders = new ArrayList<>();
for (int i = 0; i < mediaSources.size(); i++) { for (int i = 0; i < mediaSources.size(); i++) {
Playlist.MediaSourceHolder holder = MediaSourceList.MediaSourceHolder holder =
new Playlist.MediaSourceHolder(mediaSources.get(i), useLazyPreparation); new MediaSourceList.MediaSourceHolder(mediaSources.get(i), useLazyPreparation);
holders.add(holder); holders.add(holder);
mediaSourceHolders.add(i + index, holder); mediaSourceHolders.add(i + index, holder);
} }
@ -1062,9 +1063,9 @@ import java.util.concurrent.TimeoutException;
/* seekProcessed= */ false); /* seekProcessed= */ false);
} }
private List<Playlist.MediaSourceHolder> removeMediaSourceHolders( private List<MediaSourceList.MediaSourceHolder> removeMediaSourceHolders(
int fromIndex, int toIndexExclusive) { int fromIndex, int toIndexExclusive) {
List<Playlist.MediaSourceHolder> removed = new ArrayList<>(); List<MediaSourceList.MediaSourceHolder> removed = new ArrayList<>();
for (int i = toIndexExclusive - 1; i >= fromIndex; i--) { for (int i = toIndexExclusive - 1; i >= fromIndex; i--) {
removed.add(mediaSourceHolders.remove(i)); removed.add(mediaSourceHolders.remove(i));
} }
@ -1076,7 +1077,7 @@ import java.util.concurrent.TimeoutException;
return playbackInfo.copyWithTimeline( return playbackInfo.copyWithTimeline(
mediaSourceHolders.isEmpty() mediaSourceHolders.isEmpty()
? Timeline.EMPTY ? Timeline.EMPTY
: new Playlist.PlaylistTimeline(mediaSourceHolders, shuffleOrder)); : new MediaSourceList.PlaylistTimeline(mediaSourceHolders, shuffleOrder));
} }
private PlaybackInfo maskTimelineAndWindowIndex( private PlaybackInfo maskTimelineAndWindowIndex(

122
library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java
View file

@ -56,7 +56,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
implements Handler.Callback, implements Handler.Callback,
MediaPeriod.Callback, MediaPeriod.Callback,
TrackSelector.InvalidationListener, TrackSelector.InvalidationListener,
Playlist.PlaylistInfoRefreshListener, MediaSourceList.MediaSourceListInfoRefreshListener,
PlaybackSpeedListener, PlaybackSpeedListener,
PlayerMessage.Sender { PlayerMessage.Sender {
@ -112,7 +112,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
private final ArrayList<PendingMessageInfo> pendingMessages; private final ArrayList<PendingMessageInfo> pendingMessages;
private final Clock clock; private final Clock clock;
private final MediaPeriodQueue queue; private final MediaPeriodQueue queue;
private final Playlist playlist; private final MediaSourceList mediaSourceList;
@SuppressWarnings("unused") @SuppressWarnings("unused")
private SeekParameters seekParameters; private SeekParameters seekParameters;
@ -182,9 +182,9 @@ import java.util.concurrent.atomic.AtomicBoolean;
internalPlaybackThread.start(); internalPlaybackThread.start();
handler = clock.createHandler(internalPlaybackThread.getLooper(), this); handler = clock.createHandler(internalPlaybackThread.getLooper(), this);
deliverPendingMessageAtStartPositionRequired = true; deliverPendingMessageAtStartPositionRequired = true;
playlist = new Playlist(this); mediaSourceList = new MediaSourceList(this);
if (analyticsCollector != null) { if (analyticsCollector != null) {
playlist.setAnalyticsCollector(eventHandler, analyticsCollector); mediaSourceList.setAnalyticsCollector(eventHandler, analyticsCollector);
} }
} }
@ -240,25 +240,25 @@ import java.util.concurrent.atomic.AtomicBoolean;
} }
public void setMediaSources( public void setMediaSources(
List<Playlist.MediaSourceHolder> mediaSources, List<MediaSourceList.MediaSourceHolder> mediaSources,
int windowIndex, int windowIndex,
long positionUs, long positionUs,
ShuffleOrder shuffleOrder) { ShuffleOrder shuffleOrder) {
handler handler
.obtainMessage( .obtainMessage(
MSG_SET_MEDIA_SOURCES, MSG_SET_MEDIA_SOURCES,
new PlaylistUpdateMessage(mediaSources, shuffleOrder, windowIndex, positionUs)) new MediaSourceListUpdateMessage(mediaSources, shuffleOrder, windowIndex, positionUs))
.sendToTarget(); .sendToTarget();
} }
public void addMediaSources( public void addMediaSources(
int index, List<Playlist.MediaSourceHolder> mediaSources, ShuffleOrder shuffleOrder) { int index, List<MediaSourceList.MediaSourceHolder> mediaSources, ShuffleOrder shuffleOrder) {
handler handler
.obtainMessage( .obtainMessage(
MSG_ADD_MEDIA_SOURCES, MSG_ADD_MEDIA_SOURCES,
index, index,
/* ignored */ 0, /* ignored */ 0,
new PlaylistUpdateMessage( new MediaSourceListUpdateMessage(
mediaSources, mediaSources,
shuffleOrder, shuffleOrder,
/* windowIndex= */ C.INDEX_UNSET, /* windowIndex= */ C.INDEX_UNSET,
@ -438,10 +438,10 @@ import java.util.concurrent.atomic.AtomicBoolean;
sendMessageToTargetThread((PlayerMessage) msg.obj); sendMessageToTargetThread((PlayerMessage) msg.obj);
break; break;
case MSG_SET_MEDIA_SOURCES: case MSG_SET_MEDIA_SOURCES:
setMediaItemsInternal((PlaylistUpdateMessage) msg.obj); setMediaItemsInternal((MediaSourceListUpdateMessage) msg.obj);
break; break;
case MSG_ADD_MEDIA_SOURCES: case MSG_ADD_MEDIA_SOURCES:
addMediaItemsInternal((PlaylistUpdateMessage) msg.obj, msg.arg1); addMediaItemsInternal((MediaSourceListUpdateMessage) msg.obj, msg.arg1);
break; break;
case MSG_MOVE_MEDIA_SOURCES: case MSG_MOVE_MEDIA_SOURCES:
moveMediaItemsInternal((MoveMediaItemsMessage) msg.obj); moveMediaItemsInternal((MoveMediaItemsMessage) msg.obj);
@ -453,7 +453,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
setShuffleOrderInternal((ShuffleOrder) msg.obj); setShuffleOrderInternal((ShuffleOrder) msg.obj);
break; break;
case MSG_PLAYLIST_UPDATE_REQUESTED: case MSG_PLAYLIST_UPDATE_REQUESTED:
playlistUpdateRequestedInternal(); mediaSourceListUpdateRequestedInternal();
break; break;
case MSG_SET_PAUSE_AT_END_OF_WINDOW: case MSG_SET_PAUSE_AT_END_OF_WINDOW:
setPauseAtEndOfWindowInternal(msg.arg1 != 0); setPauseAtEndOfWindowInternal(msg.arg1 != 0);
@ -577,70 +577,72 @@ import java.util.concurrent.atomic.AtomicBoolean;
resetInternal( resetInternal(
/* resetRenderers= */ false, /* resetRenderers= */ false,
/* resetPosition= */ false, /* resetPosition= */ false,
/* releasePlaylist= */ false, /* releaseMediaSourceList= */ false,
/* clearPlaylist= */ false, /* clearMediaSourceList= */ false,
/* resetError= */ true); /* resetError= */ true);
loadControl.onPrepared(); loadControl.onPrepared();
setState(playbackInfo.timeline.isEmpty() ? Player.STATE_ENDED : Player.STATE_BUFFERING); setState(playbackInfo.timeline.isEmpty() ? Player.STATE_ENDED : Player.STATE_BUFFERING);
playlist.prepare(bandwidthMeter.getTransferListener()); mediaSourceList.prepare(bandwidthMeter.getTransferListener());
handler.sendEmptyMessage(MSG_DO_SOME_WORK); handler.sendEmptyMessage(MSG_DO_SOME_WORK);
} }
private void setMediaItemsInternal(PlaylistUpdateMessage playlistUpdateMessage) private void setMediaItemsInternal(MediaSourceListUpdateMessage mediaSourceListUpdateMessage)
throws ExoPlaybackException { throws ExoPlaybackException {
playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1);
if (playlistUpdateMessage.windowIndex != C.INDEX_UNSET) { if (mediaSourceListUpdateMessage.windowIndex != C.INDEX_UNSET) {
pendingInitialSeekPosition = pendingInitialSeekPosition =
new SeekPosition( new SeekPosition(
new Playlist.PlaylistTimeline( new MediaSourceList.PlaylistTimeline(
playlistUpdateMessage.mediaSourceHolders, playlistUpdateMessage.shuffleOrder), mediaSourceListUpdateMessage.mediaSourceHolders,
playlistUpdateMessage.windowIndex, mediaSourceListUpdateMessage.shuffleOrder),
playlistUpdateMessage.positionUs); mediaSourceListUpdateMessage.windowIndex,
mediaSourceListUpdateMessage.positionUs);
} }
Timeline timeline = Timeline timeline =
playlist.setMediaSources( mediaSourceList.setMediaSources(
playlistUpdateMessage.mediaSourceHolders, playlistUpdateMessage.shuffleOrder); mediaSourceListUpdateMessage.mediaSourceHolders,
handlePlaylistInfoRefreshed(timeline); mediaSourceListUpdateMessage.shuffleOrder);
handleMediaSourceListInfoRefreshed(timeline);
} }
private void addMediaItemsInternal(PlaylistUpdateMessage addMessage, int insertionIndex) private void addMediaItemsInternal(MediaSourceListUpdateMessage addMessage, int insertionIndex)
throws ExoPlaybackException { throws ExoPlaybackException {
playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1);
Timeline timeline = Timeline timeline =
playlist.addMediaSources( mediaSourceList.addMediaSources(
insertionIndex == C.INDEX_UNSET ? playlist.getSize() : insertionIndex, insertionIndex == C.INDEX_UNSET ? mediaSourceList.getSize() : insertionIndex,
addMessage.mediaSourceHolders, addMessage.mediaSourceHolders,
addMessage.shuffleOrder); addMessage.shuffleOrder);
handlePlaylistInfoRefreshed(timeline); handleMediaSourceListInfoRefreshed(timeline);
} }
private void moveMediaItemsInternal(MoveMediaItemsMessage moveMediaItemsMessage) private void moveMediaItemsInternal(MoveMediaItemsMessage moveMediaItemsMessage)
throws ExoPlaybackException { throws ExoPlaybackException {
playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1);
Timeline timeline = Timeline timeline =
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
moveMediaItemsMessage.fromIndex, moveMediaItemsMessage.fromIndex,
moveMediaItemsMessage.toIndex, moveMediaItemsMessage.toIndex,
moveMediaItemsMessage.newFromIndex, moveMediaItemsMessage.newFromIndex,
moveMediaItemsMessage.shuffleOrder); moveMediaItemsMessage.shuffleOrder);
handlePlaylistInfoRefreshed(timeline); handleMediaSourceListInfoRefreshed(timeline);
} }
private void removeMediaItemsInternal(int fromIndex, int toIndex, ShuffleOrder shuffleOrder) private void removeMediaItemsInternal(int fromIndex, int toIndex, ShuffleOrder shuffleOrder)
throws ExoPlaybackException { throws ExoPlaybackException {
playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1);
Timeline timeline = playlist.removeMediaSourceRange(fromIndex, toIndex, shuffleOrder); Timeline timeline = mediaSourceList.removeMediaSourceRange(fromIndex, toIndex, shuffleOrder);
handlePlaylistInfoRefreshed(timeline); handleMediaSourceListInfoRefreshed(timeline);
} }
private void playlistUpdateRequestedInternal() throws ExoPlaybackException { private void mediaSourceListUpdateRequestedInternal() throws ExoPlaybackException {
handlePlaylistInfoRefreshed(playlist.createTimeline()); handleMediaSourceListInfoRefreshed(mediaSourceList.createTimeline());
} }
private void setShuffleOrderInternal(ShuffleOrder shuffleOrder) throws ExoPlaybackException { private void setShuffleOrderInternal(ShuffleOrder shuffleOrder) throws ExoPlaybackException {
playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1);
Timeline timeline = playlist.setShuffleOrder(shuffleOrder); Timeline timeline = mediaSourceList.setShuffleOrder(shuffleOrder);
handlePlaylistInfoRefreshed(timeline); handleMediaSourceListInfoRefreshed(timeline);
} }
private void setPlayWhenReadyInternal( private void setPlayWhenReadyInternal(
@ -955,8 +957,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
resetInternal( resetInternal(
/* resetRenderers= */ false, /* resetRenderers= */ false,
/* resetPosition= */ true, /* resetPosition= */ true,
/* releasePlaylist= */ false, /* releaseMediaSourceList= */ false,
/* clearPlaylist= */ false, /* clearMediaSourceList= */ false,
/* resetError= */ true); /* resetError= */ true);
} else { } else {
// Execute the seek in the current media periods. // Execute the seek in the current media periods.
@ -1128,8 +1130,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
resetInternal( resetInternal(
/* resetRenderers= */ forceResetRenderers || !foregroundMode, /* resetRenderers= */ forceResetRenderers || !foregroundMode,
/* resetPosition= */ resetPositionAndState, /* resetPosition= */ resetPositionAndState,
/* releasePlaylist= */ true, /* releaseMediaSourceList= */ true,
/* clearPlaylist= */ resetPositionAndState, /* clearMediaSourceList= */ resetPositionAndState,
/* resetError= */ resetPositionAndState); /* resetError= */ resetPositionAndState);
playbackInfoUpdate.incrementPendingOperationAcks(acknowledgeStop ? 1 : 0); playbackInfoUpdate.incrementPendingOperationAcks(acknowledgeStop ? 1 : 0);
loadControl.onStopped(); loadControl.onStopped();
@ -1140,8 +1142,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
resetInternal( resetInternal(
/* resetRenderers= */ true, /* resetRenderers= */ true,
/* resetPosition= */ true, /* resetPosition= */ true,
/* releasePlaylist= */ true, /* releaseMediaSourceList= */ true,
/* clearPlaylist= */ true, /* clearMediaSourceList= */ true,
/* resetError= */ false); /* resetError= */ false);
loadControl.onReleased(); loadControl.onReleased();
setState(Player.STATE_IDLE); setState(Player.STATE_IDLE);
@ -1155,8 +1157,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
private void resetInternal( private void resetInternal(
boolean resetRenderers, boolean resetRenderers,
boolean resetPosition, boolean resetPosition,
boolean releasePlaylist, boolean releaseMediaSourceList,
boolean clearPlaylist, boolean clearMediaSourceList,
boolean resetError) { boolean resetError) {
handler.removeMessages(MSG_DO_SOME_WORK); handler.removeMessages(MSG_DO_SOME_WORK);
rebuffering = false; rebuffering = false;
@ -1183,8 +1185,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
enabledRendererCount = 0; enabledRendererCount = 0;
Timeline timeline = playbackInfo.timeline; Timeline timeline = playbackInfo.timeline;
if (clearPlaylist) { if (clearMediaSourceList) {
timeline = playlist.clear(/* shuffleOrder= */ null); timeline = mediaSourceList.clear(/* shuffleOrder= */ null);
for (PendingMessageInfo pendingMessageInfo : pendingMessages) { for (PendingMessageInfo pendingMessageInfo : pendingMessages) {
pendingMessageInfo.message.markAsProcessed(/* isDelivered= */ false); pendingMessageInfo.message.markAsProcessed(/* isDelivered= */ false);
} }
@ -1198,7 +1200,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
shouldUseRequestedContentPosition(playbackInfo, period, window) shouldUseRequestedContentPosition(playbackInfo, period, window)
? playbackInfo.requestedContentPositionUs ? playbackInfo.requestedContentPositionUs
: playbackInfo.positionUs; : playbackInfo.positionUs;
boolean resetTrackInfo = clearPlaylist; boolean resetTrackInfo = clearMediaSourceList;
if (resetPosition) { if (resetPosition) {
pendingInitialSeekPosition = null; pendingInitialSeekPosition = null;
Pair<MediaPeriodId, Long> firstPeriodAndPosition = getDummyFirstMediaPeriodPosition(timeline); Pair<MediaPeriodId, Long> firstPeriodAndPosition = getDummyFirstMediaPeriodPosition(timeline);
@ -1229,8 +1231,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
startPositionUs, startPositionUs,
/* totalBufferedDurationUs= */ 0, /* totalBufferedDurationUs= */ 0,
startPositionUs); startPositionUs);
if (releasePlaylist) { if (releaseMediaSourceList) {
playlist.release(); mediaSourceList.release();
} }
} }
@ -1568,10 +1570,10 @@ import java.util.concurrent.atomic.AtomicBoolean;
} }
} }
} }
playlist.maybeThrowSourceInfoRefreshError(); mediaSourceList.maybeThrowSourceInfoRefreshError();
} }
private void handlePlaylistInfoRefreshed(Timeline timeline) throws ExoPlaybackException { private void handleMediaSourceListInfoRefreshed(Timeline timeline) throws ExoPlaybackException {
PositionUpdateForPlaylistChange positionUpdate = PositionUpdateForPlaylistChange positionUpdate =
resolvePositionForPlaylistChange( resolvePositionForPlaylistChange(
timeline, timeline,
@ -1597,8 +1599,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
resetInternal( resetInternal(
/* resetRenderers= */ false, /* resetRenderers= */ false,
/* resetPosition= */ false, /* resetPosition= */ false,
/* releasePlaylist= */ false, /* releaseMediaSourceList= */ false,
/* clearPlaylist= */ false, /* clearMediaSourceList= */ false,
/* resetError= */ true); /* resetError= */ true);
} }
if (!periodPositionChanged) { if (!periodPositionChanged) {
@ -1663,9 +1665,9 @@ import java.util.concurrent.atomic.AtomicBoolean;
} }
private void updatePeriods() throws ExoPlaybackException, IOException { private void updatePeriods() throws ExoPlaybackException, IOException {
if (playbackInfo.timeline.isEmpty() || !playlist.isPrepared()) { if (playbackInfo.timeline.isEmpty() || !mediaSourceList.isPrepared()) {
// We're waiting to get information about periods. // We're waiting to get information about periods.
playlist.maybeThrowSourceInfoRefreshError(); mediaSourceList.maybeThrowSourceInfoRefreshError();
return; return;
} }
maybeUpdateLoadingPeriod(); maybeUpdateLoadingPeriod();
@ -1686,7 +1688,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
rendererCapabilities, rendererCapabilities,
trackSelector, trackSelector,
loadControl.getAllocator(), loadControl.getAllocator(),
playlist, mediaSourceList,
info, info,
emptyTrackSelectorResult); emptyTrackSelectorResult);
mediaPeriodHolder.mediaPeriod.prepare(this, info.startPositionUs); mediaPeriodHolder.mediaPeriod.prepare(this, info.startPositionUs);
@ -1988,7 +1990,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
resetPendingPauseAtEndOfPeriod(); resetPendingPauseAtEndOfPeriod();
TrackGroupArray trackGroupArray = playbackInfo.trackGroups; TrackGroupArray trackGroupArray = playbackInfo.trackGroups;
TrackSelectorResult trackSelectorResult = playbackInfo.trackSelectorResult; TrackSelectorResult trackSelectorResult = playbackInfo.trackSelectorResult;
if (playlist.isPrepared()) { if (mediaSourceList.isPrepared()) {
@Nullable MediaPeriodHolder playingPeriodHolder = queue.getPlayingPeriod(); @Nullable MediaPeriodHolder playingPeriodHolder = queue.getPlayingPeriod();
trackGroupArray = trackGroupArray =
playingPeriodHolder == null playingPeriodHolder == null
@ -2577,15 +2579,15 @@ import java.util.concurrent.atomic.AtomicBoolean;
} }
} }
private static final class PlaylistUpdateMessage { private static final class MediaSourceListUpdateMessage {
private final List<Playlist.MediaSourceHolder> mediaSourceHolders; private final List<MediaSourceList.MediaSourceHolder> mediaSourceHolders;
private final ShuffleOrder shuffleOrder; private final ShuffleOrder shuffleOrder;
private final int windowIndex; private final int windowIndex;
private final long positionUs; private final long positionUs;
private PlaylistUpdateMessage( private MediaSourceListUpdateMessage(
List<Playlist.MediaSourceHolder> mediaSourceHolders, List<MediaSourceList.MediaSourceHolder> mediaSourceHolders,
ShuffleOrder shuffleOrder, ShuffleOrder shuffleOrder,
int windowIndex, int windowIndex,
long positionUs) { long positionUs) {

23
library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodHolder.java
View file

@ -62,7 +62,7 @@ import org.checkerframework.checker.nullness.compatqual.NullableType;
private final boolean[] mayRetainStreamFlags; private final boolean[] mayRetainStreamFlags;
private final RendererCapabilities[] rendererCapabilities; private final RendererCapabilities[] rendererCapabilities;
private final TrackSelector trackSelector; private final TrackSelector trackSelector;
private final Playlist playlist; private final MediaSourceList mediaSourceList;
@Nullable private MediaPeriodHolder next; @Nullable private MediaPeriodHolder next;
private TrackGroupArray trackGroups; private TrackGroupArray trackGroups;
@ -76,7 +76,7 @@ import org.checkerframework.checker.nullness.compatqual.NullableType;
* @param rendererPositionOffsetUs The renderer time of the start of the period, in microseconds. * @param rendererPositionOffsetUs The renderer time of the start of the period, in microseconds.
* @param trackSelector The track selector. * @param trackSelector The track selector.
* @param allocator The allocator. * @param allocator The allocator.
* @param playlist The playlist. * @param mediaSourceList The playlist.
* @param info Information used to identify this media period in its timeline period. * @param info Information used to identify this media period in its timeline period.
* @param emptyTrackSelectorResult A {@link TrackSelectorResult} with empty selections for each * @param emptyTrackSelectorResult A {@link TrackSelectorResult} with empty selections for each
* renderer. * renderer.
@ -86,13 +86,13 @@ import org.checkerframework.checker.nullness.compatqual.NullableType;
long rendererPositionOffsetUs, long rendererPositionOffsetUs,
TrackSelector trackSelector, TrackSelector trackSelector,
Allocator allocator, Allocator allocator,
Playlist playlist, MediaSourceList mediaSourceList,
MediaPeriodInfo info, MediaPeriodInfo info,
TrackSelectorResult emptyTrackSelectorResult) { TrackSelectorResult emptyTrackSelectorResult) {
this.rendererCapabilities = rendererCapabilities; this.rendererCapabilities = rendererCapabilities;
this.rendererPositionOffsetUs = rendererPositionOffsetUs; this.rendererPositionOffsetUs = rendererPositionOffsetUs;
this.trackSelector = trackSelector; this.trackSelector = trackSelector;
this.playlist = playlist; this.mediaSourceList = mediaSourceList;
this.uid = info.id.periodUid; this.uid = info.id.periodUid;
this.info = info; this.info = info;
this.trackGroups = TrackGroupArray.EMPTY; this.trackGroups = TrackGroupArray.EMPTY;
@ -100,7 +100,8 @@ import org.checkerframework.checker.nullness.compatqual.NullableType;
sampleStreams = new SampleStream[rendererCapabilities.length]; sampleStreams = new SampleStream[rendererCapabilities.length];
mayRetainStreamFlags = new boolean[rendererCapabilities.length]; mayRetainStreamFlags = new boolean[rendererCapabilities.length];
mediaPeriod = mediaPeriod =
createMediaPeriod(info.id, playlist, allocator, info.startPositionUs, info.endPositionUs); createMediaPeriod(
info.id, mediaSourceList, allocator, info.startPositionUs, info.endPositionUs);
} }
/** /**
@ -315,7 +316,7 @@ import org.checkerframework.checker.nullness.compatqual.NullableType;
/** Releases the media period. No other method should be called after the release. */ /** Releases the media period. No other method should be called after the release. */
public void release() { public void release() {
disableTrackSelectionsInResult(); disableTrackSelectionsInResult();
releaseMediaPeriod(info.endPositionUs, playlist, mediaPeriod); releaseMediaPeriod(info.endPositionUs, mediaSourceList, mediaPeriod);
} }
/** /**
@ -412,11 +413,11 @@ import org.checkerframework.checker.nullness.compatqual.NullableType;
/** Returns a media period corresponding to the given {@code id}. */ /** Returns a media period corresponding to the given {@code id}. */
private static MediaPeriod createMediaPeriod( private static MediaPeriod createMediaPeriod(
MediaPeriodId id, MediaPeriodId id,
Playlist playlist, MediaSourceList mediaSourceList,
Allocator allocator, Allocator allocator,
long startPositionUs, long startPositionUs,
long endPositionUs) { long endPositionUs) {
MediaPeriod mediaPeriod = playlist.createPeriod(id, allocator, startPositionUs); MediaPeriod mediaPeriod = mediaSourceList.createPeriod(id, allocator, startPositionUs);
if (endPositionUs != C.TIME_UNSET && endPositionUs != C.TIME_END_OF_SOURCE) { if (endPositionUs != C.TIME_UNSET && endPositionUs != C.TIME_END_OF_SOURCE) {
mediaPeriod = mediaPeriod =
new ClippingMediaPeriod( new ClippingMediaPeriod(
@ -427,12 +428,12 @@ import org.checkerframework.checker.nullness.compatqual.NullableType;
/** Releases the given {@code mediaPeriod}, logging and suppressing any errors. */ /** Releases the given {@code mediaPeriod}, logging and suppressing any errors. */
private static void releaseMediaPeriod( private static void releaseMediaPeriod(
long endPositionUs, Playlist playlist, MediaPeriod mediaPeriod) { long endPositionUs, MediaSourceList mediaSourceList, MediaPeriod mediaPeriod) {
try { try {
if (endPositionUs != C.TIME_UNSET && endPositionUs != C.TIME_END_OF_SOURCE) { if (endPositionUs != C.TIME_UNSET && endPositionUs != C.TIME_END_OF_SOURCE) {
playlist.releasePeriod(((ClippingMediaPeriod) mediaPeriod).mediaPeriod); mediaSourceList.releasePeriod(((ClippingMediaPeriod) mediaPeriod).mediaPeriod);
} else { } else {
playlist.releasePeriod(mediaPeriod); mediaSourceList.releasePeriod(mediaPeriod);
} }
} catch (RuntimeException e) { } catch (RuntimeException e) {
// There's nothing we can do. // There's nothing we can do.

6
library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodQueue.java
View file

@ -132,7 +132,7 @@ import com.google.android.exoplayer2.util.Assertions;
* @param rendererCapabilities The renderer capabilities. * @param rendererCapabilities The renderer capabilities.
* @param trackSelector The track selector. * @param trackSelector The track selector.
* @param allocator The allocator. * @param allocator The allocator.
* @param playlist The playlist. * @param mediaSourceList The list of media sources.
* @param info Information used to identify this media period in its timeline period. * @param info Information used to identify this media period in its timeline period.
* @param emptyTrackSelectorResult A {@link TrackSelectorResult} with empty selections for each * @param emptyTrackSelectorResult A {@link TrackSelectorResult} with empty selections for each
* renderer. * renderer.
@ -141,7 +141,7 @@ import com.google.android.exoplayer2.util.Assertions;
RendererCapabilities[] rendererCapabilities, RendererCapabilities[] rendererCapabilities,
TrackSelector trackSelector, TrackSelector trackSelector,
Allocator allocator, Allocator allocator,
Playlist playlist, MediaSourceList mediaSourceList,
MediaPeriodInfo info, MediaPeriodInfo info,
TrackSelectorResult emptyTrackSelectorResult) { TrackSelectorResult emptyTrackSelectorResult) {
long rendererPositionOffsetUs = long rendererPositionOffsetUs =
@ -156,7 +156,7 @@ import com.google.android.exoplayer2.util.Assertions;
rendererPositionOffsetUs, rendererPositionOffsetUs,
trackSelector, trackSelector,
allocator, allocator,
playlist, mediaSourceList,
info, info,
emptyTrackSelectorResult); emptyTrackSelectorResult);
if (loading != null) { if (loading != null) {

22
library/core/src/main/java/com/google/android/exoplayer2/Playlist.java → library/core/src/main/java/com/google/android/exoplayer2/MediaSourceList.java
View file

@ -51,10 +51,10 @@ import java.util.Set;
* *
* <p>With the exception of the constructor, all methods are called on the playback thread. * <p>With the exception of the constructor, all methods are called on the playback thread.
*/ */
/* package */ class Playlist { /* package */ class MediaSourceList {
/** Listener for source events. */ /** Listener for source events. */
public interface PlaylistInfoRefreshListener { public interface MediaSourceListInfoRefreshListener {
/** /**
* Called when the timeline of a media item has changed and a new timeline that reflects the * Called when the timeline of a media item has changed and a new timeline that reflects the
@ -68,9 +68,9 @@ import java.util.Set;
private final List<MediaSourceHolder> mediaSourceHolders; private final List<MediaSourceHolder> mediaSourceHolders;
private final Map<MediaPeriod, MediaSourceHolder> mediaSourceByMediaPeriod; private final Map<MediaPeriod, MediaSourceHolder> mediaSourceByMediaPeriod;
private final Map<Object, MediaSourceHolder> mediaSourceByUid; private final Map<Object, MediaSourceHolder> mediaSourceByUid;
private final PlaylistInfoRefreshListener playlistInfoListener; private final MediaSourceListInfoRefreshListener mediaSourceListInfoListener;
private final MediaSourceEventListener.EventDispatcher eventDispatcher; private final MediaSourceEventListener.EventDispatcher eventDispatcher;
private final HashMap<Playlist.MediaSourceHolder, MediaSourceAndListener> childSources; private final HashMap<MediaSourceList.MediaSourceHolder, MediaSourceAndListener> childSources;
private final Set<MediaSourceHolder> enabledMediaSourceHolders; private final Set<MediaSourceHolder> enabledMediaSourceHolders;
private ShuffleOrder shuffleOrder; private ShuffleOrder shuffleOrder;
@ -79,8 +79,8 @@ import java.util.Set;
@Nullable private TransferListener mediaTransferListener; @Nullable private TransferListener mediaTransferListener;
@SuppressWarnings("initialization") @SuppressWarnings("initialization")
public Playlist(PlaylistInfoRefreshListener listener) { public MediaSourceList(MediaSourceListInfoRefreshListener listener) {
playlistInfoListener = listener; mediaSourceListInfoListener = listener;
shuffleOrder = new DefaultShuffleOrder(0); shuffleOrder = new DefaultShuffleOrder(0);
mediaSourceByMediaPeriod = new IdentityHashMap<>(); mediaSourceByMediaPeriod = new IdentityHashMap<>();
mediaSourceByUid = new HashMap<>(); mediaSourceByUid = new HashMap<>();
@ -426,7 +426,7 @@ import java.util.Set;
private void prepareChildSource(MediaSourceHolder holder) { private void prepareChildSource(MediaSourceHolder holder) {
MediaSource mediaSource = holder.mediaSource; MediaSource mediaSource = holder.mediaSource;
MediaSource.MediaSourceCaller caller = MediaSource.MediaSourceCaller caller =
(source, timeline) -> playlistInfoListener.onPlaylistUpdateRequested(); (source, timeline) -> mediaSourceListInfoListener.onPlaylistUpdateRequested();
ForwardingEventListener eventListener = new ForwardingEventListener(holder); ForwardingEventListener eventListener = new ForwardingEventListener(holder);
childSources.put(holder, new MediaSourceAndListener(mediaSource, caller, eventListener)); childSources.put(holder, new MediaSourceAndListener(mediaSource, caller, eventListener));
mediaSource.addEventListener(Util.createHandler(), eventListener); mediaSource.addEventListener(Util.createHandler(), eventListener);
@ -594,11 +594,11 @@ import java.util.Set;
private final class ForwardingEventListener private final class ForwardingEventListener
implements MediaSourceEventListener, DrmSessionEventListener { implements MediaSourceEventListener, DrmSessionEventListener {
private final Playlist.MediaSourceHolder id; private final MediaSourceList.MediaSourceHolder id;
private EventDispatcher eventDispatcher; private EventDispatcher eventDispatcher;
public ForwardingEventListener(Playlist.MediaSourceHolder id) { public ForwardingEventListener(MediaSourceList.MediaSourceHolder id) {
eventDispatcher = Playlist.this.eventDispatcher; eventDispatcher = MediaSourceList.this.eventDispatcher;
this.id = id; this.id = id;
} }
@ -750,7 +750,7 @@ import java.util.Set;
if (eventDispatcher.windowIndex != windowIndex if (eventDispatcher.windowIndex != windowIndex
|| !Util.areEqual(eventDispatcher.mediaPeriodId, mediaPeriodId)) { || !Util.areEqual(eventDispatcher.mediaPeriodId, mediaPeriodId)) {
eventDispatcher = eventDispatcher =
Playlist.this.eventDispatcher.withParameters( MediaSourceList.this.eventDispatcher.withParameters(
windowIndex, mediaPeriodId, /* mediaTimeOffsetMs= */ 0L); windowIndex, mediaPeriodId, /* mediaTimeOffsetMs= */ 0L);
} }
return true; return true;

14
library/core/src/test/java/com/google/android/exoplayer2/MediaPeriodQueueTest.java
View file

@ -63,14 +63,14 @@ public final class MediaPeriodQueueTest {
private RendererCapabilities[] rendererCapabilities; private RendererCapabilities[] rendererCapabilities;
private TrackSelector trackSelector; private TrackSelector trackSelector;
private Allocator allocator; private Allocator allocator;
private Playlist playlist; private MediaSourceList mediaSourceList;
private FakeMediaSource fakeMediaSource; private FakeMediaSource fakeMediaSource;
private Playlist.MediaSourceHolder mediaSourceHolder; private MediaSourceList.MediaSourceHolder mediaSourceHolder;
@Before @Before
public void setUp() { public void setUp() {
mediaPeriodQueue = new MediaPeriodQueue(); mediaPeriodQueue = new MediaPeriodQueue();
playlist = mock(Playlist.class); mediaSourceList = mock(MediaSourceList.class);
rendererCapabilities = new RendererCapabilities[0]; rendererCapabilities = new RendererCapabilities[0];
trackSelector = mock(TrackSelector.class); trackSelector = mock(TrackSelector.class);
allocator = mock(Allocator.class); allocator = mock(Allocator.class);
@ -403,7 +403,7 @@ public final class MediaPeriodQueueTest {
private void setupTimeline(Timeline timeline) { private void setupTimeline(Timeline timeline) {
fakeMediaSource = new FakeMediaSource(timeline); fakeMediaSource = new FakeMediaSource(timeline);
mediaSourceHolder = new Playlist.MediaSourceHolder(fakeMediaSource, false); mediaSourceHolder = new MediaSourceList.MediaSourceHolder(fakeMediaSource, false);
mediaSourceHolder.mediaSource.prepareSourceInternal(/* mediaTransferListener */ null); mediaSourceHolder.mediaSource.prepareSourceInternal(/* mediaTransferListener */ null);
Timeline playlistTimeline = createPlaylistTimeline(); Timeline playlistTimeline = createPlaylistTimeline();
@ -441,8 +441,8 @@ public final class MediaPeriodQueueTest {
playbackInfo = playbackInfo.copyWithTimeline(createPlaylistTimeline()); playbackInfo = playbackInfo.copyWithTimeline(createPlaylistTimeline());
} }
private Playlist.PlaylistTimeline createPlaylistTimeline() { private MediaSourceList.PlaylistTimeline createPlaylistTimeline() {
return new Playlist.PlaylistTimeline( return new MediaSourceList.PlaylistTimeline(
Collections.singleton(mediaSourceHolder), Collections.singleton(mediaSourceHolder),
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1)); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1));
} }
@ -467,7 +467,7 @@ public final class MediaPeriodQueueTest {
rendererCapabilities, rendererCapabilities,
trackSelector, trackSelector,
allocator, allocator,
playlist, mediaSourceList,
getNextMediaPeriodInfo(), getNextMediaPeriodInfo(),
new TrackSelectorResult( new TrackSelectorResult(
new RendererConfiguration[0], new TrackSelection[0], /* info= */ null)); new RendererConfiguration[0], new TrackSelection[0], /* info= */ null));

217
library/core/src/test/java/com/google/android/exoplayer2/PlaylistTest.java → library/core/src/test/java/com/google/android/exoplayer2/MediaSourceListTest.java
View file

@ -37,46 +37,47 @@ import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
/** Unit test for {@link Playlist}. */ /** Unit test for {@link MediaSourceList}. */
@RunWith(AndroidJUnit4.class) @RunWith(AndroidJUnit4.class)
public class PlaylistTest { public class MediaSourceListTest {
private static final int PLAYLIST_SIZE = 4; private static final int MEDIA_SOURCE_LIST_SIZE = 4;
private Playlist playlist; private MediaSourceList mediaSourceList;
@Before @Before
public void setUp() { public void setUp() {
playlist = new Playlist(mock(Playlist.PlaylistInfoRefreshListener.class)); mediaSourceList =
new MediaSourceList(mock(MediaSourceList.MediaSourceListInfoRefreshListener.class));
} }
@Test @Test
public void emptyPlaylist_expectConstantTimelineInstanceEMPTY() { public void emptyMediaSourceList_expectConstantTimelineInstanceEMPTY() {
ShuffleOrder.DefaultShuffleOrder shuffleOrder = ShuffleOrder.DefaultShuffleOrder shuffleOrder =
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 0); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 0);
List<Playlist.MediaSourceHolder> fakeHolders = createFakeHolders(); List<MediaSourceList.MediaSourceHolder> fakeHolders = createFakeHolders();
Timeline timeline = playlist.setMediaSources(fakeHolders, shuffleOrder); Timeline timeline = mediaSourceList.setMediaSources(fakeHolders, shuffleOrder);
assertNotSame(timeline, Timeline.EMPTY); assertNotSame(timeline, Timeline.EMPTY);
// Remove all media sources. // Remove all media sources.
timeline = timeline =
playlist.removeMediaSourceRange( mediaSourceList.removeMediaSourceRange(
/* fromIndex= */ 0, /* toIndex= */ timeline.getWindowCount(), shuffleOrder); /* fromIndex= */ 0, /* toIndex= */ timeline.getWindowCount(), shuffleOrder);
assertSame(timeline, Timeline.EMPTY); assertSame(timeline, Timeline.EMPTY);
timeline = playlist.setMediaSources(fakeHolders, shuffleOrder); timeline = mediaSourceList.setMediaSources(fakeHolders, shuffleOrder);
assertNotSame(timeline, Timeline.EMPTY); assertNotSame(timeline, Timeline.EMPTY);
// Clear. // Clear.
timeline = playlist.clear(shuffleOrder); timeline = mediaSourceList.clear(shuffleOrder);
assertSame(timeline, Timeline.EMPTY); assertSame(timeline, Timeline.EMPTY);
} }
@Test @Test
public void prepareAndReprepareAfterRelease_expectSourcePreparationAfterPlaylistPrepare() { public void prepareAndReprepareAfterRelease_expectSourcePreparationAfterMediaSourceListPrepare() {
MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource1 = mock(MediaSource.class);
MediaSource mockMediaSource2 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class);
playlist.setMediaSources( mediaSourceList.setMediaSources(
createFakeHoldersWithSources( createFakeHoldersWithSources(
/* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2), /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2),
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2)); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2));
@ -88,8 +89,8 @@ public class PlaylistTest {
.prepareSource( .prepareSource(
any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull());
playlist.prepare(/* mediaTransferListener= */ null); mediaSourceList.prepare(/* mediaTransferListener= */ null);
assertThat(playlist.isPrepared()).isTrue(); assertThat(mediaSourceList.isPrepared()).isTrue();
// Verify prepare is called once on prepare. // Verify prepare is called once on prepare.
verify(mockMediaSource1, times(1)) verify(mockMediaSource1, times(1))
.prepareSource( .prepareSource(
@ -98,8 +99,8 @@ public class PlaylistTest {
.prepareSource( .prepareSource(
any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull());
playlist.release(); mediaSourceList.release();
playlist.prepare(/* mediaTransferListener= */ null); mediaSourceList.prepare(/* mediaTransferListener= */ null);
// Verify prepare is called a second time on re-prepare. // Verify prepare is called a second time on re-prepare.
verify(mockMediaSource1, times(2)) verify(mockMediaSource1, times(2))
.prepareSource( .prepareSource(
@ -110,36 +111,36 @@ public class PlaylistTest {
} }
@Test @Test
public void setMediaSources_playlistUnprepared_notUsingLazyPreparation() { public void setMediaSources_mediaSourceListUnprepared_notUsingLazyPreparation() {
ShuffleOrder.DefaultShuffleOrder shuffleOrder = ShuffleOrder.DefaultShuffleOrder shuffleOrder =
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2);
MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource1 = mock(MediaSource.class);
MediaSource mockMediaSource2 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class);
List<Playlist.MediaSourceHolder> mediaSources = List<MediaSourceList.MediaSourceHolder> mediaSources =
createFakeHoldersWithSources( createFakeHoldersWithSources(
/* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2); /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2);
Timeline timeline = playlist.setMediaSources(mediaSources, shuffleOrder); Timeline timeline = mediaSourceList.setMediaSources(mediaSources, shuffleOrder);
assertThat(timeline.getWindowCount()).isEqualTo(2); assertThat(timeline.getWindowCount()).isEqualTo(2);
assertThat(playlist.getSize()).isEqualTo(2); assertThat(mediaSourceList.getSize()).isEqualTo(2);
// Assert holder offsets have been set properly // Assert holder offsets have been set properly
for (int i = 0; i < mediaSources.size(); i++) { for (int i = 0; i < mediaSources.size(); i++) {
Playlist.MediaSourceHolder mediaSourceHolder = mediaSources.get(i); MediaSourceList.MediaSourceHolder mediaSourceHolder = mediaSources.get(i);
assertThat(mediaSourceHolder.isRemoved).isFalse(); assertThat(mediaSourceHolder.isRemoved).isFalse();
assertThat(mediaSourceHolder.firstWindowIndexInChild).isEqualTo(i); assertThat(mediaSourceHolder.firstWindowIndexInChild).isEqualTo(i);
} }
// Set media items again. The second holder is re-used. // Set media items again. The second holder is re-used.
List<Playlist.MediaSourceHolder> moreMediaSources = List<MediaSourceList.MediaSourceHolder> moreMediaSources =
createFakeHoldersWithSources(/* useLazyPreparation= */ false, mock(MediaSource.class)); createFakeHoldersWithSources(/* useLazyPreparation= */ false, mock(MediaSource.class));
moreMediaSources.add(mediaSources.get(1)); moreMediaSources.add(mediaSources.get(1));
timeline = playlist.setMediaSources(moreMediaSources, shuffleOrder); timeline = mediaSourceList.setMediaSources(moreMediaSources, shuffleOrder);
assertThat(playlist.getSize()).isEqualTo(2); assertThat(mediaSourceList.getSize()).isEqualTo(2);
assertThat(timeline.getWindowCount()).isEqualTo(2); assertThat(timeline.getWindowCount()).isEqualTo(2);
for (int i = 0; i < moreMediaSources.size(); i++) { for (int i = 0; i < moreMediaSources.size(); i++) {
Playlist.MediaSourceHolder mediaSourceHolder = moreMediaSources.get(i); MediaSourceList.MediaSourceHolder mediaSourceHolder = moreMediaSources.get(i);
assertThat(mediaSourceHolder.isRemoved).isFalse(); assertThat(mediaSourceHolder.isRemoved).isFalse();
assertThat(mediaSourceHolder.firstWindowIndexInChild).isEqualTo(i); assertThat(mediaSourceHolder.firstWindowIndexInChild).isEqualTo(i);
} }
@ -152,17 +153,17 @@ public class PlaylistTest {
} }
@Test @Test
public void setMediaSources_playlistPrepared_notUsingLazyPreparation() { public void setMediaSources_mediaSourceListPrepared_notUsingLazyPreparation() {
ShuffleOrder.DefaultShuffleOrder shuffleOrder = ShuffleOrder.DefaultShuffleOrder shuffleOrder =
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2);
MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource1 = mock(MediaSource.class);
MediaSource mockMediaSource2 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class);
List<Playlist.MediaSourceHolder> mediaSources = List<MediaSourceList.MediaSourceHolder> mediaSources =
createFakeHoldersWithSources( createFakeHoldersWithSources(
/* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2); /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2);
playlist.prepare(/* mediaTransferListener= */ null); mediaSourceList.prepare(/* mediaTransferListener= */ null);
playlist.setMediaSources(mediaSources, shuffleOrder); mediaSourceList.setMediaSources(mediaSources, shuffleOrder);
// Verify sources are prepared. // Verify sources are prepared.
verify(mockMediaSource1, times(1)) verify(mockMediaSource1, times(1))
@ -173,10 +174,10 @@ public class PlaylistTest {
any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull());
// Set media items again. The second holder is re-used. // Set media items again. The second holder is re-used.
List<Playlist.MediaSourceHolder> moreMediaSources = List<MediaSourceList.MediaSourceHolder> moreMediaSources =
createFakeHoldersWithSources(/* useLazyPreparation= */ false, mock(MediaSource.class)); createFakeHoldersWithSources(/* useLazyPreparation= */ false, mock(MediaSource.class));
moreMediaSources.add(mediaSources.get(1)); moreMediaSources.add(mediaSources.get(1));
playlist.setMediaSources(moreMediaSources, shuffleOrder); mediaSourceList.setMediaSources(moreMediaSources, shuffleOrder);
// Expect removed holders and sources to be removed and released. // Expect removed holders and sources to be removed and released.
verify(mockMediaSource1, times(1)).releaseSource(any(MediaSource.MediaSourceCaller.class)); verify(mockMediaSource1, times(1)).releaseSource(any(MediaSource.MediaSourceCaller.class));
@ -190,15 +191,16 @@ public class PlaylistTest {
} }
@Test @Test
public void addMediaSources_playlistUnprepared_notUsingLazyPreparation_expectUnprepared() { public void addMediaSources_mediaSourceListUnprepared_notUsingLazyPreparation_expectUnprepared() {
MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource1 = mock(MediaSource.class);
MediaSource mockMediaSource2 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class);
List<Playlist.MediaSourceHolder> mediaSources = List<MediaSourceList.MediaSourceHolder> mediaSources =
createFakeHoldersWithSources( createFakeHoldersWithSources(
/* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2); /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2);
playlist.addMediaSources(/* index= */ 0, mediaSources, new ShuffleOrder.DefaultShuffleOrder(2)); mediaSourceList.addMediaSources(
/* index= */ 0, mediaSources, new ShuffleOrder.DefaultShuffleOrder(2));
assertThat(playlist.getSize()).isEqualTo(2); assertThat(mediaSourceList.getSize()).isEqualTo(2);
// Verify lazy initialization does not call prepare on sources. // Verify lazy initialization does not call prepare on sources.
verify(mockMediaSource1, times(0)) verify(mockMediaSource1, times(0))
.prepareSource( .prepareSource(
@ -213,8 +215,8 @@ public class PlaylistTest {
} }
// Add for more sources in between. // Add for more sources in between.
List<Playlist.MediaSourceHolder> moreMediaSources = createFakeHolders(); List<MediaSourceList.MediaSourceHolder> moreMediaSources = createFakeHolders();
playlist.addMediaSources( mediaSourceList.addMediaSources(
/* index= */ 1, moreMediaSources, new ShuffleOrder.DefaultShuffleOrder(/* length= */ 3)); /* index= */ 1, moreMediaSources, new ShuffleOrder.DefaultShuffleOrder(/* length= */ 3));
assertThat(mediaSources.get(0).firstWindowIndexInChild).isEqualTo(0); assertThat(mediaSources.get(0).firstWindowIndexInChild).isEqualTo(0);
@ -224,11 +226,11 @@ public class PlaylistTest {
} }
@Test @Test
public void addMediaSources_playlistPrepared_notUsingLazyPreparation_expectPrepared() { public void addMediaSources_mediaSourceListPrepared_notUsingLazyPreparation_expectPrepared() {
MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource1 = mock(MediaSource.class);
MediaSource mockMediaSource2 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class);
playlist.prepare(/* mediaTransferListener= */ null); mediaSourceList.prepare(/* mediaTransferListener= */ null);
playlist.addMediaSources( mediaSourceList.addMediaSources(
/* index= */ 0, /* index= */ 0,
createFakeHoldersWithSources( createFakeHoldersWithSources(
/* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2), /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2),
@ -247,37 +249,37 @@ public class PlaylistTest {
public void moveMediaSources() { public void moveMediaSources() {
ShuffleOrder.DefaultShuffleOrder shuffleOrder = ShuffleOrder.DefaultShuffleOrder shuffleOrder =
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4);
List<Playlist.MediaSourceHolder> holders = createFakeHolders(); List<MediaSourceList.MediaSourceHolder> holders = createFakeHolders();
playlist.addMediaSources(/* index= */ 0, holders, shuffleOrder); mediaSourceList.addMediaSources(/* index= */ 0, holders, shuffleOrder);
assertDefaultFirstWindowInChildIndexOrder(holders); assertDefaultFirstWindowInChildIndexOrder(holders);
playlist.moveMediaSource(/* currentIndex= */ 0, /* newIndex= */ 3, shuffleOrder); mediaSourceList.moveMediaSource(/* currentIndex= */ 0, /* newIndex= */ 3, shuffleOrder);
assertFirstWindowInChildIndices(holders, 3, 0, 1, 2); assertFirstWindowInChildIndices(holders, 3, 0, 1, 2);
playlist.moveMediaSource(/* currentIndex= */ 3, /* newIndex= */ 0, shuffleOrder); mediaSourceList.moveMediaSource(/* currentIndex= */ 3, /* newIndex= */ 0, shuffleOrder);
assertDefaultFirstWindowInChildIndexOrder(holders); assertDefaultFirstWindowInChildIndexOrder(holders);
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
/* fromIndex= */ 0, /* toIndex= */ 2, /* newFromIndex= */ 2, shuffleOrder); /* fromIndex= */ 0, /* toIndex= */ 2, /* newFromIndex= */ 2, shuffleOrder);
assertFirstWindowInChildIndices(holders, 2, 3, 0, 1); assertFirstWindowInChildIndices(holders, 2, 3, 0, 1);
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
/* fromIndex= */ 2, /* toIndex= */ 4, /* newFromIndex= */ 0, shuffleOrder); /* fromIndex= */ 2, /* toIndex= */ 4, /* newFromIndex= */ 0, shuffleOrder);
assertDefaultFirstWindowInChildIndexOrder(holders); assertDefaultFirstWindowInChildIndexOrder(holders);
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
/* fromIndex= */ 0, /* toIndex= */ 2, /* newFromIndex= */ 2, shuffleOrder); /* fromIndex= */ 0, /* toIndex= */ 2, /* newFromIndex= */ 2, shuffleOrder);
assertFirstWindowInChildIndices(holders, 2, 3, 0, 1); assertFirstWindowInChildIndices(holders, 2, 3, 0, 1);
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
/* fromIndex= */ 2, /* toIndex= */ 3, /* newFromIndex= */ 0, shuffleOrder); /* fromIndex= */ 2, /* toIndex= */ 3, /* newFromIndex= */ 0, shuffleOrder);
assertFirstWindowInChildIndices(holders, 0, 3, 1, 2); assertFirstWindowInChildIndices(holders, 0, 3, 1, 2);
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
/* fromIndex= */ 3, /* toIndex= */ 4, /* newFromIndex= */ 1, shuffleOrder); /* fromIndex= */ 3, /* toIndex= */ 4, /* newFromIndex= */ 1, shuffleOrder);
assertDefaultFirstWindowInChildIndexOrder(holders); assertDefaultFirstWindowInChildIndexOrder(holders);
// No-ops. // No-ops.
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
/* fromIndex= */ 0, /* toIndex= */ 4, /* newFromIndex= */ 0, shuffleOrder); /* fromIndex= */ 0, /* toIndex= */ 4, /* newFromIndex= */ 0, shuffleOrder);
assertDefaultFirstWindowInChildIndexOrder(holders); assertDefaultFirstWindowInChildIndexOrder(holders);
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
/* fromIndex= */ 0, /* toIndex= */ 0, /* newFromIndex= */ 3, shuffleOrder); /* fromIndex= */ 0, /* toIndex= */ 0, /* newFromIndex= */ 3, shuffleOrder);
assertDefaultFirstWindowInChildIndexOrder(holders); assertDefaultFirstWindowInChildIndexOrder(holders);
} }
@ -291,19 +293,19 @@ public class PlaylistTest {
ShuffleOrder.DefaultShuffleOrder shuffleOrder = ShuffleOrder.DefaultShuffleOrder shuffleOrder =
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4);
List<Playlist.MediaSourceHolder> holders = List<MediaSourceList.MediaSourceHolder> holders =
createFakeHoldersWithSources( createFakeHoldersWithSources(
/* useLazyPreparation= */ false, /* useLazyPreparation= */ false,
mockMediaSource1, mockMediaSource1,
mockMediaSource2, mockMediaSource2,
mockMediaSource3, mockMediaSource3,
mockMediaSource4); mockMediaSource4);
playlist.addMediaSources(/* index= */ 0, holders, shuffleOrder); mediaSourceList.addMediaSources(/* index= */ 0, holders, shuffleOrder);
playlist.removeMediaSourceRange(/* fromIndex= */ 1, /* toIndex= */ 3, shuffleOrder); mediaSourceList.removeMediaSourceRange(/* fromIndex= */ 1, /* toIndex= */ 3, shuffleOrder);
assertThat(playlist.getSize()).isEqualTo(2); assertThat(mediaSourceList.getSize()).isEqualTo(2);
Playlist.MediaSourceHolder removedHolder1 = holders.remove(1); MediaSourceList.MediaSourceHolder removedHolder1 = holders.remove(1);
Playlist.MediaSourceHolder removedHolder2 = holders.remove(1); MediaSourceList.MediaSourceHolder removedHolder2 = holders.remove(1);
assertDefaultFirstWindowInChildIndexOrder(holders); assertDefaultFirstWindowInChildIndexOrder(holders);
assertThat(removedHolder1.isRemoved).isTrue(); assertThat(removedHolder1.isRemoved).isTrue();
@ -323,18 +325,18 @@ public class PlaylistTest {
ShuffleOrder.DefaultShuffleOrder shuffleOrder = ShuffleOrder.DefaultShuffleOrder shuffleOrder =
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4);
List<Playlist.MediaSourceHolder> holders = List<MediaSourceList.MediaSourceHolder> holders =
createFakeHoldersWithSources( createFakeHoldersWithSources(
/* useLazyPreparation= */ false, /* useLazyPreparation= */ false,
mockMediaSource1, mockMediaSource1,
mockMediaSource2, mockMediaSource2,
mockMediaSource3, mockMediaSource3,
mockMediaSource4); mockMediaSource4);
playlist.prepare(/* mediaTransferListener */ null); mediaSourceList.prepare(/* mediaTransferListener */ null);
playlist.addMediaSources(/* index= */ 0, holders, shuffleOrder); mediaSourceList.addMediaSources(/* index= */ 0, holders, shuffleOrder);
playlist.removeMediaSourceRange(/* fromIndex= */ 1, /* toIndex= */ 3, shuffleOrder); mediaSourceList.removeMediaSourceRange(/* fromIndex= */ 1, /* toIndex= */ 3, shuffleOrder);
assertThat(playlist.getSize()).isEqualTo(2); assertThat(mediaSourceList.getSize()).isEqualTo(2);
holders.remove(2); holders.remove(2);
holders.remove(1); holders.remove(1);
@ -346,53 +348,53 @@ public class PlaylistTest {
} }
@Test @Test
public void release_playlistUnprepared_expectSourcesNotReleased() { public void release_mediaSourceListUnprepared_expectSourcesNotReleased() {
MediaSource mockMediaSource = mock(MediaSource.class); MediaSource mockMediaSource = mock(MediaSource.class);
Playlist.MediaSourceHolder mediaSourceHolder = MediaSourceList.MediaSourceHolder mediaSourceHolder =
new Playlist.MediaSourceHolder(mockMediaSource, /* useLazyPreparation= */ false); new MediaSourceList.MediaSourceHolder(mockMediaSource, /* useLazyPreparation= */ false);
playlist.setMediaSources( mediaSourceList.setMediaSources(
Collections.singletonList(mediaSourceHolder), Collections.singletonList(mediaSourceHolder),
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1)); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1));
verify(mockMediaSource, times(0)) verify(mockMediaSource, times(0))
.prepareSource( .prepareSource(
any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull());
playlist.release(); mediaSourceList.release();
verify(mockMediaSource, times(0)).releaseSource(any(MediaSource.MediaSourceCaller.class)); verify(mockMediaSource, times(0)).releaseSource(any(MediaSource.MediaSourceCaller.class));
assertThat(mediaSourceHolder.isRemoved).isFalse(); assertThat(mediaSourceHolder.isRemoved).isFalse();
} }
@Test @Test
public void release_playlistPrepared_expectSourcesReleasedNotRemoved() { public void release_mediaSourceListPrepared_expectSourcesReleasedNotRemoved() {
MediaSource mockMediaSource = mock(MediaSource.class); MediaSource mockMediaSource = mock(MediaSource.class);
Playlist.MediaSourceHolder mediaSourceHolder = MediaSourceList.MediaSourceHolder mediaSourceHolder =
new Playlist.MediaSourceHolder(mockMediaSource, /* useLazyPreparation= */ false); new MediaSourceList.MediaSourceHolder(mockMediaSource, /* useLazyPreparation= */ false);
playlist.prepare(/* mediaTransferListener= */ null); mediaSourceList.prepare(/* mediaTransferListener= */ null);
playlist.setMediaSources( mediaSourceList.setMediaSources(
Collections.singletonList(mediaSourceHolder), Collections.singletonList(mediaSourceHolder),
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1)); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1));
verify(mockMediaSource, times(1)) verify(mockMediaSource, times(1))
.prepareSource( .prepareSource(
any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull());
playlist.release(); mediaSourceList.release();
verify(mockMediaSource, times(1)).releaseSource(any(MediaSource.MediaSourceCaller.class)); verify(mockMediaSource, times(1)).releaseSource(any(MediaSource.MediaSourceCaller.class));
assertThat(mediaSourceHolder.isRemoved).isFalse(); assertThat(mediaSourceHolder.isRemoved).isFalse();
} }
@Test @Test
public void clearPlaylist_expectSourcesReleasedAndRemoved() { public void clearMediaSourceList_expectSourcesReleasedAndRemoved() {
ShuffleOrder.DefaultShuffleOrder shuffleOrder = ShuffleOrder.DefaultShuffleOrder shuffleOrder =
new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4); new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4);
MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource1 = mock(MediaSource.class);
MediaSource mockMediaSource2 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class);
List<Playlist.MediaSourceHolder> holders = List<MediaSourceList.MediaSourceHolder> holders =
createFakeHoldersWithSources( createFakeHoldersWithSources(
/* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2); /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2);
playlist.setMediaSources(holders, shuffleOrder); mediaSourceList.setMediaSources(holders, shuffleOrder);
playlist.prepare(/* mediaTransferListener= */ null); mediaSourceList.prepare(/* mediaTransferListener= */ null);
Timeline timeline = playlist.clear(shuffleOrder); Timeline timeline = mediaSourceList.clear(shuffleOrder);
assertThat(timeline.isEmpty()).isTrue(); assertThat(timeline.isEmpty()).isTrue();
assertThat(holders.get(0).isRemoved).isTrue(); assertThat(holders.get(0).isRemoved).isTrue();
assertThat(holders.get(1).isRemoved).isTrue(); assertThat(holders.get(1).isRemoved).isTrue();
@ -403,57 +405,61 @@ public class PlaylistTest {
@Test @Test
public void setMediaSources_expectTimelineUsesCustomShuffleOrder() { public void setMediaSources_expectTimelineUsesCustomShuffleOrder() {
Timeline timeline = Timeline timeline =
playlist.setMediaSources(createFakeHolders(), new FakeShuffleOrder(/* length=*/ 4)); mediaSourceList.setMediaSources(createFakeHolders(), new FakeShuffleOrder(/* length=*/ 4));
assertTimelineUsesFakeShuffleOrder(timeline); assertTimelineUsesFakeShuffleOrder(timeline);
} }
@Test @Test
public void addMediaSources_expectTimelineUsesCustomShuffleOrder() { public void addMediaSources_expectTimelineUsesCustomShuffleOrder() {
Timeline timeline = Timeline timeline =
playlist.addMediaSources( mediaSourceList.addMediaSources(
/* index= */ 0, createFakeHolders(), new FakeShuffleOrder(PLAYLIST_SIZE)); /* index= */ 0, createFakeHolders(), new FakeShuffleOrder(MEDIA_SOURCE_LIST_SIZE));
assertTimelineUsesFakeShuffleOrder(timeline); assertTimelineUsesFakeShuffleOrder(timeline);
} }
@Test @Test
public void moveMediaSources_expectTimelineUsesCustomShuffleOrder() { public void moveMediaSources_expectTimelineUsesCustomShuffleOrder() {
ShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ PLAYLIST_SIZE); ShuffleOrder shuffleOrder =
playlist.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); new ShuffleOrder.DefaultShuffleOrder(/* length= */ MEDIA_SOURCE_LIST_SIZE);
mediaSourceList.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder);
Timeline timeline = Timeline timeline =
playlist.moveMediaSource( mediaSourceList.moveMediaSource(
/* currentIndex= */ 0, /* newIndex= */ 1, new FakeShuffleOrder(PLAYLIST_SIZE)); /* currentIndex= */ 0, /* newIndex= */ 1, new FakeShuffleOrder(MEDIA_SOURCE_LIST_SIZE));
assertTimelineUsesFakeShuffleOrder(timeline); assertTimelineUsesFakeShuffleOrder(timeline);
} }
@Test @Test
public void moveMediaSourceRange_expectTimelineUsesCustomShuffleOrder() { public void moveMediaSourceRange_expectTimelineUsesCustomShuffleOrder() {
ShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ PLAYLIST_SIZE); ShuffleOrder shuffleOrder =
playlist.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); new ShuffleOrder.DefaultShuffleOrder(/* length= */ MEDIA_SOURCE_LIST_SIZE);
mediaSourceList.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder);
Timeline timeline = Timeline timeline =
playlist.moveMediaSourceRange( mediaSourceList.moveMediaSourceRange(
/* fromIndex= */ 0, /* fromIndex= */ 0,
/* toIndex= */ 2, /* toIndex= */ 2,
/* newFromIndex= */ 2, /* newFromIndex= */ 2,
new FakeShuffleOrder(PLAYLIST_SIZE)); new FakeShuffleOrder(MEDIA_SOURCE_LIST_SIZE));
assertTimelineUsesFakeShuffleOrder(timeline); assertTimelineUsesFakeShuffleOrder(timeline);
} }
@Test @Test
public void removeMediaSourceRange_expectTimelineUsesCustomShuffleOrder() { public void removeMediaSourceRange_expectTimelineUsesCustomShuffleOrder() {
ShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ PLAYLIST_SIZE); ShuffleOrder shuffleOrder =
playlist.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); new ShuffleOrder.DefaultShuffleOrder(/* length= */ MEDIA_SOURCE_LIST_SIZE);
mediaSourceList.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder);
Timeline timeline = Timeline timeline =
playlist.removeMediaSourceRange( mediaSourceList.removeMediaSourceRange(
/* fromIndex= */ 0, /* toIndex= */ 2, new FakeShuffleOrder(/* length= */ 2)); /* fromIndex= */ 0, /* toIndex= */ 2, new FakeShuffleOrder(/* length= */ 2));
assertTimelineUsesFakeShuffleOrder(timeline); assertTimelineUsesFakeShuffleOrder(timeline);
} }
@Test @Test
public void setShuffleOrder_expectTimelineUsesCustomShuffleOrder() { public void setShuffleOrder_expectTimelineUsesCustomShuffleOrder() {
playlist.setMediaSources( mediaSourceList.setMediaSources(
createFakeHolders(), new ShuffleOrder.DefaultShuffleOrder(/* length= */ PLAYLIST_SIZE)); createFakeHolders(),
new ShuffleOrder.DefaultShuffleOrder(/* length= */ MEDIA_SOURCE_LIST_SIZE));
assertTimelineUsesFakeShuffleOrder( assertTimelineUsesFakeShuffleOrder(
playlist.setShuffleOrder(new FakeShuffleOrder(PLAYLIST_SIZE))); mediaSourceList.setShuffleOrder(new FakeShuffleOrder(MEDIA_SOURCE_LIST_SIZE)));
} }
// Internal methods. // Internal methods.
@ -472,7 +478,7 @@ public class PlaylistTest {
} }
private static void assertDefaultFirstWindowInChildIndexOrder( private static void assertDefaultFirstWindowInChildIndexOrder(
List<Playlist.MediaSourceHolder> holders) { List<MediaSourceList.MediaSourceHolder> holders) {
int[] indices = new int[holders.size()]; int[] indices = new int[holders.size()];
for (int i = 0; i < indices.length; i++) { for (int i = 0; i < indices.length; i++) {
indices[i] = i; indices[i] = i;
@ -481,28 +487,29 @@ public class PlaylistTest {
} }
private static void assertFirstWindowInChildIndices( private static void assertFirstWindowInChildIndices(
List<Playlist.MediaSourceHolder> holders, int... firstWindowInChildIndices) { List<MediaSourceList.MediaSourceHolder> holders, int... firstWindowInChildIndices) {
assertThat(holders).hasSize(firstWindowInChildIndices.length); assertThat(holders).hasSize(firstWindowInChildIndices.length);
for (int i = 0; i < holders.size(); i++) { for (int i = 0; i < holders.size(); i++) {
assertThat(holders.get(i).firstWindowIndexInChild).isEqualTo(firstWindowInChildIndices[i]); assertThat(holders.get(i).firstWindowIndexInChild).isEqualTo(firstWindowInChildIndices[i]);
} }
} }
private static List<Playlist.MediaSourceHolder> createFakeHolders() { private static List<MediaSourceList.MediaSourceHolder> createFakeHolders() {
MediaSource fakeMediaSource = new FakeMediaSource(new FakeTimeline(1)); MediaSource fakeMediaSource = new FakeMediaSource(new FakeTimeline(1));
List<Playlist.MediaSourceHolder> holders = new ArrayList<>(); List<MediaSourceList.MediaSourceHolder> holders = new ArrayList<>();
for (int i = 0; i < PLAYLIST_SIZE; i++) { for (int i = 0; i < MEDIA_SOURCE_LIST_SIZE; i++) {
holders.add(new Playlist.MediaSourceHolder(fakeMediaSource, /* useLazyPreparation= */ true)); holders.add(
new MediaSourceList.MediaSourceHolder(fakeMediaSource, /* useLazyPreparation= */ true));
} }
return holders; return holders;
} }
private static List<Playlist.MediaSourceHolder> createFakeHoldersWithSources( private static List<MediaSourceList.MediaSourceHolder> createFakeHoldersWithSources(
boolean useLazyPreparation, MediaSource... sources) { boolean useLazyPreparation, MediaSource... sources) {
List<Playlist.MediaSourceHolder> holders = new ArrayList<>(); List<MediaSourceList.MediaSourceHolder> holders = new ArrayList<>();
for (MediaSource mediaSource : sources) { for (MediaSource mediaSource : sources) {
holders.add( holders.add(
new Playlist.MediaSourceHolder( new MediaSourceList.MediaSourceHolder(
mediaSource, /* useLazyPreparation= */ useLazyPreparation)); mediaSource, /* useLazyPreparation= */ useLazyPreparation));
} }
return holders; return holders;