From 8f24db73f1cd0ba39714242dc207d98d6b39bfc6 Mon Sep 17 00:00:00 2001 From: bachinger Date: Tue, 7 Apr 2020 16:46:37 +0100 Subject: [PATCH] rename Playlist to MediaSourceList 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 --- .../android/exoplayer2/ExoPlayerImpl.java | 23 +- .../exoplayer2/ExoPlayerImplInternal.java | 122 +++++----- .../android/exoplayer2/MediaPeriodHolder.java | 23 +- .../android/exoplayer2/MediaPeriodQueue.java | 6 +- .../{Playlist.java => MediaSourceList.java} | 22 +- .../exoplayer2/MediaPeriodQueueTest.java | 14 +- ...listTest.java => MediaSourceListTest.java} | 217 +++++++++--------- 7 files changed, 219 insertions(+), 208 deletions(-) rename library/core/src/main/java/com/google/android/exoplayer2/{Playlist.java => MediaSourceList.java} (97%) rename library/core/src/test/java/com/google/android/exoplayer2/{PlaylistTest.java => MediaSourceListTest.java} (70%) diff --git a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java index f2c049e731..2242ebf53d 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java @@ -68,7 +68,7 @@ import java.util.concurrent.TimeoutException; private final CopyOnWriteArrayList listeners; private final Timeline.Period period; private final ArrayDeque pendingListenerNotifications; - private final List mediaSourceHolders; + private final List mediaSourceHolders; private final boolean useLazyPreparation; private final MediaSourceFactory mediaSourceFactory; @@ -401,7 +401,7 @@ import java.util.concurrent.TimeoutException; long currentPositionMs = getCurrentPosition(); Timeline oldTimeline = getCurrentTimeline(); pendingOperationAcks++; - List holders = addMediaSourceHolders(index, mediaSources); + List holders = addMediaSourceHolders(index, mediaSources); PlaybackInfo playbackInfo = maskTimelineAndWindowIndex(currentWindowIndex, currentPositionMs, oldTimeline); internalPlayer.addMediaSources(index, holders, shuffleOrder); @@ -432,7 +432,7 @@ import java.util.concurrent.TimeoutException; Timeline oldTimeline = getCurrentTimeline(); pendingOperationAcks++; newFromIndex = Math.min(newFromIndex, mediaSourceHolders.size() - (toIndex - fromIndex)); - Playlist.moveMediaSourceHolders(mediaSourceHolders, fromIndex, toIndex, newFromIndex); + MediaSourceList.moveMediaSourceHolders(mediaSourceHolders, fromIndex, toIndex, newFromIndex); PlaybackInfo playbackInfo = maskTimelineAndWindowIndex(currentWindowIndex, currentPositionMs, oldTimeline); internalPlayer.moveMediaSources(fromIndex, toIndex, newFromIndex, shuffleOrder); @@ -977,7 +977,8 @@ import java.util.concurrent.TimeoutException; removeMediaSourceHolders( /* fromIndex= */ 0, /* toIndexExclusive= */ mediaSourceHolders.size()); } - List holders = addMediaSourceHolders(/* index= */ 0, mediaItems); + List holders = + addMediaSourceHolders(/* index= */ 0, mediaItems); PlaybackInfo playbackInfo = maskTimeline(); Timeline timeline = playbackInfo.timeline; if (!timeline.isEmpty() && startWindowIndex >= timeline.getWindowCount()) { @@ -1016,12 +1017,12 @@ import java.util.concurrent.TimeoutException; /* seekProcessed= */ false); } - private List addMediaSourceHolders( + private List addMediaSourceHolders( int index, List mediaSources) { - List holders = new ArrayList<>(); + List holders = new ArrayList<>(); for (int i = 0; i < mediaSources.size(); i++) { - Playlist.MediaSourceHolder holder = - new Playlist.MediaSourceHolder(mediaSources.get(i), useLazyPreparation); + MediaSourceList.MediaSourceHolder holder = + new MediaSourceList.MediaSourceHolder(mediaSources.get(i), useLazyPreparation); holders.add(holder); mediaSourceHolders.add(i + index, holder); } @@ -1062,9 +1063,9 @@ import java.util.concurrent.TimeoutException; /* seekProcessed= */ false); } - private List removeMediaSourceHolders( + private List removeMediaSourceHolders( int fromIndex, int toIndexExclusive) { - List removed = new ArrayList<>(); + List removed = new ArrayList<>(); for (int i = toIndexExclusive - 1; i >= fromIndex; i--) { removed.add(mediaSourceHolders.remove(i)); } @@ -1076,7 +1077,7 @@ import java.util.concurrent.TimeoutException; return playbackInfo.copyWithTimeline( mediaSourceHolders.isEmpty() ? Timeline.EMPTY - : new Playlist.PlaylistTimeline(mediaSourceHolders, shuffleOrder)); + : new MediaSourceList.PlaylistTimeline(mediaSourceHolders, shuffleOrder)); } private PlaybackInfo maskTimelineAndWindowIndex( diff --git a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java index d217bb1848..56cce6d984 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java @@ -56,7 +56,7 @@ import java.util.concurrent.atomic.AtomicBoolean; implements Handler.Callback, MediaPeriod.Callback, TrackSelector.InvalidationListener, - Playlist.PlaylistInfoRefreshListener, + MediaSourceList.MediaSourceListInfoRefreshListener, PlaybackSpeedListener, PlayerMessage.Sender { @@ -112,7 +112,7 @@ import java.util.concurrent.atomic.AtomicBoolean; private final ArrayList pendingMessages; private final Clock clock; private final MediaPeriodQueue queue; - private final Playlist playlist; + private final MediaSourceList mediaSourceList; @SuppressWarnings("unused") private SeekParameters seekParameters; @@ -182,9 +182,9 @@ import java.util.concurrent.atomic.AtomicBoolean; internalPlaybackThread.start(); handler = clock.createHandler(internalPlaybackThread.getLooper(), this); deliverPendingMessageAtStartPositionRequired = true; - playlist = new Playlist(this); + mediaSourceList = new MediaSourceList(this); if (analyticsCollector != null) { - playlist.setAnalyticsCollector(eventHandler, analyticsCollector); + mediaSourceList.setAnalyticsCollector(eventHandler, analyticsCollector); } } @@ -240,25 +240,25 @@ import java.util.concurrent.atomic.AtomicBoolean; } public void setMediaSources( - List mediaSources, + List mediaSources, int windowIndex, long positionUs, ShuffleOrder shuffleOrder) { handler .obtainMessage( MSG_SET_MEDIA_SOURCES, - new PlaylistUpdateMessage(mediaSources, shuffleOrder, windowIndex, positionUs)) + new MediaSourceListUpdateMessage(mediaSources, shuffleOrder, windowIndex, positionUs)) .sendToTarget(); } public void addMediaSources( - int index, List mediaSources, ShuffleOrder shuffleOrder) { + int index, List mediaSources, ShuffleOrder shuffleOrder) { handler .obtainMessage( MSG_ADD_MEDIA_SOURCES, index, /* ignored */ 0, - new PlaylistUpdateMessage( + new MediaSourceListUpdateMessage( mediaSources, shuffleOrder, /* windowIndex= */ C.INDEX_UNSET, @@ -438,10 +438,10 @@ import java.util.concurrent.atomic.AtomicBoolean; sendMessageToTargetThread((PlayerMessage) msg.obj); break; case MSG_SET_MEDIA_SOURCES: - setMediaItemsInternal((PlaylistUpdateMessage) msg.obj); + setMediaItemsInternal((MediaSourceListUpdateMessage) msg.obj); break; case MSG_ADD_MEDIA_SOURCES: - addMediaItemsInternal((PlaylistUpdateMessage) msg.obj, msg.arg1); + addMediaItemsInternal((MediaSourceListUpdateMessage) msg.obj, msg.arg1); break; case MSG_MOVE_MEDIA_SOURCES: moveMediaItemsInternal((MoveMediaItemsMessage) msg.obj); @@ -453,7 +453,7 @@ import java.util.concurrent.atomic.AtomicBoolean; setShuffleOrderInternal((ShuffleOrder) msg.obj); break; case MSG_PLAYLIST_UPDATE_REQUESTED: - playlistUpdateRequestedInternal(); + mediaSourceListUpdateRequestedInternal(); break; case MSG_SET_PAUSE_AT_END_OF_WINDOW: setPauseAtEndOfWindowInternal(msg.arg1 != 0); @@ -577,70 +577,72 @@ import java.util.concurrent.atomic.AtomicBoolean; resetInternal( /* resetRenderers= */ false, /* resetPosition= */ false, - /* releasePlaylist= */ false, - /* clearPlaylist= */ false, + /* releaseMediaSourceList= */ false, + /* clearMediaSourceList= */ false, /* resetError= */ true); loadControl.onPrepared(); setState(playbackInfo.timeline.isEmpty() ? Player.STATE_ENDED : Player.STATE_BUFFERING); - playlist.prepare(bandwidthMeter.getTransferListener()); + mediaSourceList.prepare(bandwidthMeter.getTransferListener()); handler.sendEmptyMessage(MSG_DO_SOME_WORK); } - private void setMediaItemsInternal(PlaylistUpdateMessage playlistUpdateMessage) + private void setMediaItemsInternal(MediaSourceListUpdateMessage mediaSourceListUpdateMessage) throws ExoPlaybackException { playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); - if (playlistUpdateMessage.windowIndex != C.INDEX_UNSET) { + if (mediaSourceListUpdateMessage.windowIndex != C.INDEX_UNSET) { pendingInitialSeekPosition = new SeekPosition( - new Playlist.PlaylistTimeline( - playlistUpdateMessage.mediaSourceHolders, playlistUpdateMessage.shuffleOrder), - playlistUpdateMessage.windowIndex, - playlistUpdateMessage.positionUs); + new MediaSourceList.PlaylistTimeline( + mediaSourceListUpdateMessage.mediaSourceHolders, + mediaSourceListUpdateMessage.shuffleOrder), + mediaSourceListUpdateMessage.windowIndex, + mediaSourceListUpdateMessage.positionUs); } Timeline timeline = - playlist.setMediaSources( - playlistUpdateMessage.mediaSourceHolders, playlistUpdateMessage.shuffleOrder); - handlePlaylistInfoRefreshed(timeline); + mediaSourceList.setMediaSources( + mediaSourceListUpdateMessage.mediaSourceHolders, + mediaSourceListUpdateMessage.shuffleOrder); + handleMediaSourceListInfoRefreshed(timeline); } - private void addMediaItemsInternal(PlaylistUpdateMessage addMessage, int insertionIndex) + private void addMediaItemsInternal(MediaSourceListUpdateMessage addMessage, int insertionIndex) throws ExoPlaybackException { playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); Timeline timeline = - playlist.addMediaSources( - insertionIndex == C.INDEX_UNSET ? playlist.getSize() : insertionIndex, + mediaSourceList.addMediaSources( + insertionIndex == C.INDEX_UNSET ? mediaSourceList.getSize() : insertionIndex, addMessage.mediaSourceHolders, addMessage.shuffleOrder); - handlePlaylistInfoRefreshed(timeline); + handleMediaSourceListInfoRefreshed(timeline); } private void moveMediaItemsInternal(MoveMediaItemsMessage moveMediaItemsMessage) throws ExoPlaybackException { playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); Timeline timeline = - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( moveMediaItemsMessage.fromIndex, moveMediaItemsMessage.toIndex, moveMediaItemsMessage.newFromIndex, moveMediaItemsMessage.shuffleOrder); - handlePlaylistInfoRefreshed(timeline); + handleMediaSourceListInfoRefreshed(timeline); } private void removeMediaItemsInternal(int fromIndex, int toIndex, ShuffleOrder shuffleOrder) throws ExoPlaybackException { playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); - Timeline timeline = playlist.removeMediaSourceRange(fromIndex, toIndex, shuffleOrder); - handlePlaylistInfoRefreshed(timeline); + Timeline timeline = mediaSourceList.removeMediaSourceRange(fromIndex, toIndex, shuffleOrder); + handleMediaSourceListInfoRefreshed(timeline); } - private void playlistUpdateRequestedInternal() throws ExoPlaybackException { - handlePlaylistInfoRefreshed(playlist.createTimeline()); + private void mediaSourceListUpdateRequestedInternal() throws ExoPlaybackException { + handleMediaSourceListInfoRefreshed(mediaSourceList.createTimeline()); } private void setShuffleOrderInternal(ShuffleOrder shuffleOrder) throws ExoPlaybackException { playbackInfoUpdate.incrementPendingOperationAcks(/* operationAcks= */ 1); - Timeline timeline = playlist.setShuffleOrder(shuffleOrder); - handlePlaylistInfoRefreshed(timeline); + Timeline timeline = mediaSourceList.setShuffleOrder(shuffleOrder); + handleMediaSourceListInfoRefreshed(timeline); } private void setPlayWhenReadyInternal( @@ -955,8 +957,8 @@ import java.util.concurrent.atomic.AtomicBoolean; resetInternal( /* resetRenderers= */ false, /* resetPosition= */ true, - /* releasePlaylist= */ false, - /* clearPlaylist= */ false, + /* releaseMediaSourceList= */ false, + /* clearMediaSourceList= */ false, /* resetError= */ true); } else { // Execute the seek in the current media periods. @@ -1128,8 +1130,8 @@ import java.util.concurrent.atomic.AtomicBoolean; resetInternal( /* resetRenderers= */ forceResetRenderers || !foregroundMode, /* resetPosition= */ resetPositionAndState, - /* releasePlaylist= */ true, - /* clearPlaylist= */ resetPositionAndState, + /* releaseMediaSourceList= */ true, + /* clearMediaSourceList= */ resetPositionAndState, /* resetError= */ resetPositionAndState); playbackInfoUpdate.incrementPendingOperationAcks(acknowledgeStop ? 1 : 0); loadControl.onStopped(); @@ -1140,8 +1142,8 @@ import java.util.concurrent.atomic.AtomicBoolean; resetInternal( /* resetRenderers= */ true, /* resetPosition= */ true, - /* releasePlaylist= */ true, - /* clearPlaylist= */ true, + /* releaseMediaSourceList= */ true, + /* clearMediaSourceList= */ true, /* resetError= */ false); loadControl.onReleased(); setState(Player.STATE_IDLE); @@ -1155,8 +1157,8 @@ import java.util.concurrent.atomic.AtomicBoolean; private void resetInternal( boolean resetRenderers, boolean resetPosition, - boolean releasePlaylist, - boolean clearPlaylist, + boolean releaseMediaSourceList, + boolean clearMediaSourceList, boolean resetError) { handler.removeMessages(MSG_DO_SOME_WORK); rebuffering = false; @@ -1183,8 +1185,8 @@ import java.util.concurrent.atomic.AtomicBoolean; enabledRendererCount = 0; Timeline timeline = playbackInfo.timeline; - if (clearPlaylist) { - timeline = playlist.clear(/* shuffleOrder= */ null); + if (clearMediaSourceList) { + timeline = mediaSourceList.clear(/* shuffleOrder= */ null); for (PendingMessageInfo pendingMessageInfo : pendingMessages) { pendingMessageInfo.message.markAsProcessed(/* isDelivered= */ false); } @@ -1198,7 +1200,7 @@ import java.util.concurrent.atomic.AtomicBoolean; shouldUseRequestedContentPosition(playbackInfo, period, window) ? playbackInfo.requestedContentPositionUs : playbackInfo.positionUs; - boolean resetTrackInfo = clearPlaylist; + boolean resetTrackInfo = clearMediaSourceList; if (resetPosition) { pendingInitialSeekPosition = null; Pair firstPeriodAndPosition = getDummyFirstMediaPeriodPosition(timeline); @@ -1229,8 +1231,8 @@ import java.util.concurrent.atomic.AtomicBoolean; startPositionUs, /* totalBufferedDurationUs= */ 0, startPositionUs); - if (releasePlaylist) { - playlist.release(); + if (releaseMediaSourceList) { + 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 = resolvePositionForPlaylistChange( timeline, @@ -1597,8 +1599,8 @@ import java.util.concurrent.atomic.AtomicBoolean; resetInternal( /* resetRenderers= */ false, /* resetPosition= */ false, - /* releasePlaylist= */ false, - /* clearPlaylist= */ false, + /* releaseMediaSourceList= */ false, + /* clearMediaSourceList= */ false, /* resetError= */ true); } if (!periodPositionChanged) { @@ -1663,9 +1665,9 @@ import java.util.concurrent.atomic.AtomicBoolean; } 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. - playlist.maybeThrowSourceInfoRefreshError(); + mediaSourceList.maybeThrowSourceInfoRefreshError(); return; } maybeUpdateLoadingPeriod(); @@ -1686,7 +1688,7 @@ import java.util.concurrent.atomic.AtomicBoolean; rendererCapabilities, trackSelector, loadControl.getAllocator(), - playlist, + mediaSourceList, info, emptyTrackSelectorResult); mediaPeriodHolder.mediaPeriod.prepare(this, info.startPositionUs); @@ -1988,7 +1990,7 @@ import java.util.concurrent.atomic.AtomicBoolean; resetPendingPauseAtEndOfPeriod(); TrackGroupArray trackGroupArray = playbackInfo.trackGroups; TrackSelectorResult trackSelectorResult = playbackInfo.trackSelectorResult; - if (playlist.isPrepared()) { + if (mediaSourceList.isPrepared()) { @Nullable MediaPeriodHolder playingPeriodHolder = queue.getPlayingPeriod(); trackGroupArray = 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 mediaSourceHolders; + private final List mediaSourceHolders; private final ShuffleOrder shuffleOrder; private final int windowIndex; private final long positionUs; - private PlaylistUpdateMessage( - List mediaSourceHolders, + private MediaSourceListUpdateMessage( + List mediaSourceHolders, ShuffleOrder shuffleOrder, int windowIndex, long positionUs) { diff --git a/library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodHolder.java b/library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodHolder.java index 304636ed41..3c7a41439a 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodHolder.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodHolder.java @@ -62,7 +62,7 @@ import org.checkerframework.checker.nullness.compatqual.NullableType; private final boolean[] mayRetainStreamFlags; private final RendererCapabilities[] rendererCapabilities; private final TrackSelector trackSelector; - private final Playlist playlist; + private final MediaSourceList mediaSourceList; @Nullable private MediaPeriodHolder next; 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 trackSelector The track selector. * @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 emptyTrackSelectorResult A {@link TrackSelectorResult} with empty selections for each * renderer. @@ -86,13 +86,13 @@ import org.checkerframework.checker.nullness.compatqual.NullableType; long rendererPositionOffsetUs, TrackSelector trackSelector, Allocator allocator, - Playlist playlist, + MediaSourceList mediaSourceList, MediaPeriodInfo info, TrackSelectorResult emptyTrackSelectorResult) { this.rendererCapabilities = rendererCapabilities; this.rendererPositionOffsetUs = rendererPositionOffsetUs; this.trackSelector = trackSelector; - this.playlist = playlist; + this.mediaSourceList = mediaSourceList; this.uid = info.id.periodUid; this.info = info; this.trackGroups = TrackGroupArray.EMPTY; @@ -100,7 +100,8 @@ import org.checkerframework.checker.nullness.compatqual.NullableType; sampleStreams = new SampleStream[rendererCapabilities.length]; mayRetainStreamFlags = new boolean[rendererCapabilities.length]; 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. */ public void release() { 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}. */ private static MediaPeriod createMediaPeriod( MediaPeriodId id, - Playlist playlist, + MediaSourceList mediaSourceList, Allocator allocator, long startPositionUs, 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) { mediaPeriod = new ClippingMediaPeriod( @@ -427,12 +428,12 @@ import org.checkerframework.checker.nullness.compatqual.NullableType; /** Releases the given {@code mediaPeriod}, logging and suppressing any errors. */ private static void releaseMediaPeriod( - long endPositionUs, Playlist playlist, MediaPeriod mediaPeriod) { + long endPositionUs, MediaSourceList mediaSourceList, MediaPeriod mediaPeriod) { try { if (endPositionUs != C.TIME_UNSET && endPositionUs != C.TIME_END_OF_SOURCE) { - playlist.releasePeriod(((ClippingMediaPeriod) mediaPeriod).mediaPeriod); + mediaSourceList.releasePeriod(((ClippingMediaPeriod) mediaPeriod).mediaPeriod); } else { - playlist.releasePeriod(mediaPeriod); + mediaSourceList.releasePeriod(mediaPeriod); } } catch (RuntimeException e) { // There's nothing we can do. diff --git a/library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodQueue.java b/library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodQueue.java index 4df879d5d8..a749f09f93 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodQueue.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodQueue.java @@ -132,7 +132,7 @@ import com.google.android.exoplayer2.util.Assertions; * @param rendererCapabilities The renderer capabilities. * @param trackSelector The track selector. * @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 emptyTrackSelectorResult A {@link TrackSelectorResult} with empty selections for each * renderer. @@ -141,7 +141,7 @@ import com.google.android.exoplayer2.util.Assertions; RendererCapabilities[] rendererCapabilities, TrackSelector trackSelector, Allocator allocator, - Playlist playlist, + MediaSourceList mediaSourceList, MediaPeriodInfo info, TrackSelectorResult emptyTrackSelectorResult) { long rendererPositionOffsetUs = @@ -156,7 +156,7 @@ import com.google.android.exoplayer2.util.Assertions; rendererPositionOffsetUs, trackSelector, allocator, - playlist, + mediaSourceList, info, emptyTrackSelectorResult); if (loading != null) { diff --git a/library/core/src/main/java/com/google/android/exoplayer2/Playlist.java b/library/core/src/main/java/com/google/android/exoplayer2/MediaSourceList.java similarity index 97% rename from library/core/src/main/java/com/google/android/exoplayer2/Playlist.java rename to library/core/src/main/java/com/google/android/exoplayer2/MediaSourceList.java index 179c70538d..1ffb8f59c8 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/Playlist.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/MediaSourceList.java @@ -51,10 +51,10 @@ import java.util.Set; * *

With the exception of the constructor, all methods are called on the playback thread. */ -/* package */ class Playlist { +/* package */ class MediaSourceList { /** 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 @@ -68,9 +68,9 @@ import java.util.Set; private final List mediaSourceHolders; private final Map mediaSourceByMediaPeriod; private final Map mediaSourceByUid; - private final PlaylistInfoRefreshListener playlistInfoListener; + private final MediaSourceListInfoRefreshListener mediaSourceListInfoListener; private final MediaSourceEventListener.EventDispatcher eventDispatcher; - private final HashMap childSources; + private final HashMap childSources; private final Set enabledMediaSourceHolders; private ShuffleOrder shuffleOrder; @@ -79,8 +79,8 @@ import java.util.Set; @Nullable private TransferListener mediaTransferListener; @SuppressWarnings("initialization") - public Playlist(PlaylistInfoRefreshListener listener) { - playlistInfoListener = listener; + public MediaSourceList(MediaSourceListInfoRefreshListener listener) { + mediaSourceListInfoListener = listener; shuffleOrder = new DefaultShuffleOrder(0); mediaSourceByMediaPeriod = new IdentityHashMap<>(); mediaSourceByUid = new HashMap<>(); @@ -426,7 +426,7 @@ import java.util.Set; private void prepareChildSource(MediaSourceHolder holder) { MediaSource mediaSource = holder.mediaSource; MediaSource.MediaSourceCaller caller = - (source, timeline) -> playlistInfoListener.onPlaylistUpdateRequested(); + (source, timeline) -> mediaSourceListInfoListener.onPlaylistUpdateRequested(); ForwardingEventListener eventListener = new ForwardingEventListener(holder); childSources.put(holder, new MediaSourceAndListener(mediaSource, caller, eventListener)); mediaSource.addEventListener(Util.createHandler(), eventListener); @@ -594,11 +594,11 @@ import java.util.Set; private final class ForwardingEventListener implements MediaSourceEventListener, DrmSessionEventListener { - private final Playlist.MediaSourceHolder id; + private final MediaSourceList.MediaSourceHolder id; private EventDispatcher eventDispatcher; - public ForwardingEventListener(Playlist.MediaSourceHolder id) { - eventDispatcher = Playlist.this.eventDispatcher; + public ForwardingEventListener(MediaSourceList.MediaSourceHolder id) { + eventDispatcher = MediaSourceList.this.eventDispatcher; this.id = id; } @@ -750,7 +750,7 @@ import java.util.Set; if (eventDispatcher.windowIndex != windowIndex || !Util.areEqual(eventDispatcher.mediaPeriodId, mediaPeriodId)) { eventDispatcher = - Playlist.this.eventDispatcher.withParameters( + MediaSourceList.this.eventDispatcher.withParameters( windowIndex, mediaPeriodId, /* mediaTimeOffsetMs= */ 0L); } return true; diff --git a/library/core/src/test/java/com/google/android/exoplayer2/MediaPeriodQueueTest.java b/library/core/src/test/java/com/google/android/exoplayer2/MediaPeriodQueueTest.java index fb424cc92c..ccc5156015 100644 --- a/library/core/src/test/java/com/google/android/exoplayer2/MediaPeriodQueueTest.java +++ b/library/core/src/test/java/com/google/android/exoplayer2/MediaPeriodQueueTest.java @@ -63,14 +63,14 @@ public final class MediaPeriodQueueTest { private RendererCapabilities[] rendererCapabilities; private TrackSelector trackSelector; private Allocator allocator; - private Playlist playlist; + private MediaSourceList mediaSourceList; private FakeMediaSource fakeMediaSource; - private Playlist.MediaSourceHolder mediaSourceHolder; + private MediaSourceList.MediaSourceHolder mediaSourceHolder; @Before public void setUp() { mediaPeriodQueue = new MediaPeriodQueue(); - playlist = mock(Playlist.class); + mediaSourceList = mock(MediaSourceList.class); rendererCapabilities = new RendererCapabilities[0]; trackSelector = mock(TrackSelector.class); allocator = mock(Allocator.class); @@ -403,7 +403,7 @@ public final class MediaPeriodQueueTest { private void setupTimeline(Timeline timeline) { fakeMediaSource = new FakeMediaSource(timeline); - mediaSourceHolder = new Playlist.MediaSourceHolder(fakeMediaSource, false); + mediaSourceHolder = new MediaSourceList.MediaSourceHolder(fakeMediaSource, false); mediaSourceHolder.mediaSource.prepareSourceInternal(/* mediaTransferListener */ null); Timeline playlistTimeline = createPlaylistTimeline(); @@ -441,8 +441,8 @@ public final class MediaPeriodQueueTest { playbackInfo = playbackInfo.copyWithTimeline(createPlaylistTimeline()); } - private Playlist.PlaylistTimeline createPlaylistTimeline() { - return new Playlist.PlaylistTimeline( + private MediaSourceList.PlaylistTimeline createPlaylistTimeline() { + return new MediaSourceList.PlaylistTimeline( Collections.singleton(mediaSourceHolder), new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1)); } @@ -467,7 +467,7 @@ public final class MediaPeriodQueueTest { rendererCapabilities, trackSelector, allocator, - playlist, + mediaSourceList, getNextMediaPeriodInfo(), new TrackSelectorResult( new RendererConfiguration[0], new TrackSelection[0], /* info= */ null)); diff --git a/library/core/src/test/java/com/google/android/exoplayer2/PlaylistTest.java b/library/core/src/test/java/com/google/android/exoplayer2/MediaSourceListTest.java similarity index 70% rename from library/core/src/test/java/com/google/android/exoplayer2/PlaylistTest.java rename to library/core/src/test/java/com/google/android/exoplayer2/MediaSourceListTest.java index a456c543aa..7ece4f3259 100644 --- a/library/core/src/test/java/com/google/android/exoplayer2/PlaylistTest.java +++ b/library/core/src/test/java/com/google/android/exoplayer2/MediaSourceListTest.java @@ -37,46 +37,47 @@ import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; -/** Unit test for {@link Playlist}. */ +/** Unit test for {@link MediaSourceList}. */ @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 public void setUp() { - playlist = new Playlist(mock(Playlist.PlaylistInfoRefreshListener.class)); + mediaSourceList = + new MediaSourceList(mock(MediaSourceList.MediaSourceListInfoRefreshListener.class)); } @Test - public void emptyPlaylist_expectConstantTimelineInstanceEMPTY() { + public void emptyMediaSourceList_expectConstantTimelineInstanceEMPTY() { ShuffleOrder.DefaultShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ 0); - List fakeHolders = createFakeHolders(); + List fakeHolders = createFakeHolders(); - Timeline timeline = playlist.setMediaSources(fakeHolders, shuffleOrder); + Timeline timeline = mediaSourceList.setMediaSources(fakeHolders, shuffleOrder); assertNotSame(timeline, Timeline.EMPTY); // Remove all media sources. timeline = - playlist.removeMediaSourceRange( + mediaSourceList.removeMediaSourceRange( /* fromIndex= */ 0, /* toIndex= */ timeline.getWindowCount(), shuffleOrder); assertSame(timeline, Timeline.EMPTY); - timeline = playlist.setMediaSources(fakeHolders, shuffleOrder); + timeline = mediaSourceList.setMediaSources(fakeHolders, shuffleOrder); assertNotSame(timeline, Timeline.EMPTY); // Clear. - timeline = playlist.clear(shuffleOrder); + timeline = mediaSourceList.clear(shuffleOrder); assertSame(timeline, Timeline.EMPTY); } @Test - public void prepareAndReprepareAfterRelease_expectSourcePreparationAfterPlaylistPrepare() { + public void prepareAndReprepareAfterRelease_expectSourcePreparationAfterMediaSourceListPrepare() { MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class); - playlist.setMediaSources( + mediaSourceList.setMediaSources( createFakeHoldersWithSources( /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2), new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2)); @@ -88,8 +89,8 @@ public class PlaylistTest { .prepareSource( any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); - playlist.prepare(/* mediaTransferListener= */ null); - assertThat(playlist.isPrepared()).isTrue(); + mediaSourceList.prepare(/* mediaTransferListener= */ null); + assertThat(mediaSourceList.isPrepared()).isTrue(); // Verify prepare is called once on prepare. verify(mockMediaSource1, times(1)) .prepareSource( @@ -98,8 +99,8 @@ public class PlaylistTest { .prepareSource( any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); - playlist.release(); - playlist.prepare(/* mediaTransferListener= */ null); + mediaSourceList.release(); + mediaSourceList.prepare(/* mediaTransferListener= */ null); // Verify prepare is called a second time on re-prepare. verify(mockMediaSource1, times(2)) .prepareSource( @@ -110,36 +111,36 @@ public class PlaylistTest { } @Test - public void setMediaSources_playlistUnprepared_notUsingLazyPreparation() { + public void setMediaSources_mediaSourceListUnprepared_notUsingLazyPreparation() { ShuffleOrder.DefaultShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2); MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class); - List mediaSources = + List mediaSources = createFakeHoldersWithSources( /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2); - Timeline timeline = playlist.setMediaSources(mediaSources, shuffleOrder); + Timeline timeline = mediaSourceList.setMediaSources(mediaSources, shuffleOrder); assertThat(timeline.getWindowCount()).isEqualTo(2); - assertThat(playlist.getSize()).isEqualTo(2); + assertThat(mediaSourceList.getSize()).isEqualTo(2); // Assert holder offsets have been set properly 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.firstWindowIndexInChild).isEqualTo(i); } // Set media items again. The second holder is re-used. - List moreMediaSources = + List moreMediaSources = createFakeHoldersWithSources(/* useLazyPreparation= */ false, mock(MediaSource.class)); 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); 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.firstWindowIndexInChild).isEqualTo(i); } @@ -152,17 +153,17 @@ public class PlaylistTest { } @Test - public void setMediaSources_playlistPrepared_notUsingLazyPreparation() { + public void setMediaSources_mediaSourceListPrepared_notUsingLazyPreparation() { ShuffleOrder.DefaultShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ 2); MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class); - List mediaSources = + List mediaSources = createFakeHoldersWithSources( /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2); - playlist.prepare(/* mediaTransferListener= */ null); - playlist.setMediaSources(mediaSources, shuffleOrder); + mediaSourceList.prepare(/* mediaTransferListener= */ null); + mediaSourceList.setMediaSources(mediaSources, shuffleOrder); // Verify sources are prepared. verify(mockMediaSource1, times(1)) @@ -173,10 +174,10 @@ public class PlaylistTest { any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); // Set media items again. The second holder is re-used. - List moreMediaSources = + List moreMediaSources = createFakeHoldersWithSources(/* useLazyPreparation= */ false, mock(MediaSource.class)); moreMediaSources.add(mediaSources.get(1)); - playlist.setMediaSources(moreMediaSources, shuffleOrder); + mediaSourceList.setMediaSources(moreMediaSources, shuffleOrder); // Expect removed holders and sources to be removed and released. verify(mockMediaSource1, times(1)).releaseSource(any(MediaSource.MediaSourceCaller.class)); @@ -190,15 +191,16 @@ public class PlaylistTest { } @Test - public void addMediaSources_playlistUnprepared_notUsingLazyPreparation_expectUnprepared() { + public void addMediaSources_mediaSourceListUnprepared_notUsingLazyPreparation_expectUnprepared() { MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class); - List mediaSources = + List mediaSources = createFakeHoldersWithSources( /* 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(mockMediaSource1, times(0)) .prepareSource( @@ -213,8 +215,8 @@ public class PlaylistTest { } // Add for more sources in between. - List moreMediaSources = createFakeHolders(); - playlist.addMediaSources( + List moreMediaSources = createFakeHolders(); + mediaSourceList.addMediaSources( /* index= */ 1, moreMediaSources, new ShuffleOrder.DefaultShuffleOrder(/* length= */ 3)); assertThat(mediaSources.get(0).firstWindowIndexInChild).isEqualTo(0); @@ -224,11 +226,11 @@ public class PlaylistTest { } @Test - public void addMediaSources_playlistPrepared_notUsingLazyPreparation_expectPrepared() { + public void addMediaSources_mediaSourceListPrepared_notUsingLazyPreparation_expectPrepared() { MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class); - playlist.prepare(/* mediaTransferListener= */ null); - playlist.addMediaSources( + mediaSourceList.prepare(/* mediaTransferListener= */ null); + mediaSourceList.addMediaSources( /* index= */ 0, createFakeHoldersWithSources( /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2), @@ -247,37 +249,37 @@ public class PlaylistTest { public void moveMediaSources() { ShuffleOrder.DefaultShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4); - List holders = createFakeHolders(); - playlist.addMediaSources(/* index= */ 0, holders, shuffleOrder); + List holders = createFakeHolders(); + mediaSourceList.addMediaSources(/* index= */ 0, holders, shuffleOrder); assertDefaultFirstWindowInChildIndexOrder(holders); - playlist.moveMediaSource(/* currentIndex= */ 0, /* newIndex= */ 3, shuffleOrder); + mediaSourceList.moveMediaSource(/* currentIndex= */ 0, /* newIndex= */ 3, shuffleOrder); assertFirstWindowInChildIndices(holders, 3, 0, 1, 2); - playlist.moveMediaSource(/* currentIndex= */ 3, /* newIndex= */ 0, shuffleOrder); + mediaSourceList.moveMediaSource(/* currentIndex= */ 3, /* newIndex= */ 0, shuffleOrder); assertDefaultFirstWindowInChildIndexOrder(holders); - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( /* fromIndex= */ 0, /* toIndex= */ 2, /* newFromIndex= */ 2, shuffleOrder); assertFirstWindowInChildIndices(holders, 2, 3, 0, 1); - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( /* fromIndex= */ 2, /* toIndex= */ 4, /* newFromIndex= */ 0, shuffleOrder); assertDefaultFirstWindowInChildIndexOrder(holders); - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( /* fromIndex= */ 0, /* toIndex= */ 2, /* newFromIndex= */ 2, shuffleOrder); assertFirstWindowInChildIndices(holders, 2, 3, 0, 1); - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( /* fromIndex= */ 2, /* toIndex= */ 3, /* newFromIndex= */ 0, shuffleOrder); assertFirstWindowInChildIndices(holders, 0, 3, 1, 2); - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( /* fromIndex= */ 3, /* toIndex= */ 4, /* newFromIndex= */ 1, shuffleOrder); assertDefaultFirstWindowInChildIndexOrder(holders); // No-ops. - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( /* fromIndex= */ 0, /* toIndex= */ 4, /* newFromIndex= */ 0, shuffleOrder); assertDefaultFirstWindowInChildIndexOrder(holders); - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( /* fromIndex= */ 0, /* toIndex= */ 0, /* newFromIndex= */ 3, shuffleOrder); assertDefaultFirstWindowInChildIndexOrder(holders); } @@ -291,19 +293,19 @@ public class PlaylistTest { ShuffleOrder.DefaultShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4); - List holders = + List holders = createFakeHoldersWithSources( /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2, mockMediaSource3, mockMediaSource4); - playlist.addMediaSources(/* index= */ 0, holders, shuffleOrder); - playlist.removeMediaSourceRange(/* fromIndex= */ 1, /* toIndex= */ 3, shuffleOrder); + mediaSourceList.addMediaSources(/* index= */ 0, holders, shuffleOrder); + mediaSourceList.removeMediaSourceRange(/* fromIndex= */ 1, /* toIndex= */ 3, shuffleOrder); - assertThat(playlist.getSize()).isEqualTo(2); - Playlist.MediaSourceHolder removedHolder1 = holders.remove(1); - Playlist.MediaSourceHolder removedHolder2 = holders.remove(1); + assertThat(mediaSourceList.getSize()).isEqualTo(2); + MediaSourceList.MediaSourceHolder removedHolder1 = holders.remove(1); + MediaSourceList.MediaSourceHolder removedHolder2 = holders.remove(1); assertDefaultFirstWindowInChildIndexOrder(holders); assertThat(removedHolder1.isRemoved).isTrue(); @@ -323,18 +325,18 @@ public class PlaylistTest { ShuffleOrder.DefaultShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4); - List holders = + List holders = createFakeHoldersWithSources( /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2, mockMediaSource3, mockMediaSource4); - playlist.prepare(/* mediaTransferListener */ null); - playlist.addMediaSources(/* index= */ 0, holders, shuffleOrder); - playlist.removeMediaSourceRange(/* fromIndex= */ 1, /* toIndex= */ 3, shuffleOrder); + mediaSourceList.prepare(/* mediaTransferListener */ null); + mediaSourceList.addMediaSources(/* index= */ 0, holders, shuffleOrder); + mediaSourceList.removeMediaSourceRange(/* fromIndex= */ 1, /* toIndex= */ 3, shuffleOrder); - assertThat(playlist.getSize()).isEqualTo(2); + assertThat(mediaSourceList.getSize()).isEqualTo(2); holders.remove(2); holders.remove(1); @@ -346,53 +348,53 @@ public class PlaylistTest { } @Test - public void release_playlistUnprepared_expectSourcesNotReleased() { + public void release_mediaSourceListUnprepared_expectSourcesNotReleased() { MediaSource mockMediaSource = mock(MediaSource.class); - Playlist.MediaSourceHolder mediaSourceHolder = - new Playlist.MediaSourceHolder(mockMediaSource, /* useLazyPreparation= */ false); + MediaSourceList.MediaSourceHolder mediaSourceHolder = + new MediaSourceList.MediaSourceHolder(mockMediaSource, /* useLazyPreparation= */ false); - playlist.setMediaSources( + mediaSourceList.setMediaSources( Collections.singletonList(mediaSourceHolder), new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1)); verify(mockMediaSource, times(0)) .prepareSource( any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); - playlist.release(); + mediaSourceList.release(); verify(mockMediaSource, times(0)).releaseSource(any(MediaSource.MediaSourceCaller.class)); assertThat(mediaSourceHolder.isRemoved).isFalse(); } @Test - public void release_playlistPrepared_expectSourcesReleasedNotRemoved() { + public void release_mediaSourceListPrepared_expectSourcesReleasedNotRemoved() { MediaSource mockMediaSource = mock(MediaSource.class); - Playlist.MediaSourceHolder mediaSourceHolder = - new Playlist.MediaSourceHolder(mockMediaSource, /* useLazyPreparation= */ false); + MediaSourceList.MediaSourceHolder mediaSourceHolder = + new MediaSourceList.MediaSourceHolder(mockMediaSource, /* useLazyPreparation= */ false); - playlist.prepare(/* mediaTransferListener= */ null); - playlist.setMediaSources( + mediaSourceList.prepare(/* mediaTransferListener= */ null); + mediaSourceList.setMediaSources( Collections.singletonList(mediaSourceHolder), new ShuffleOrder.DefaultShuffleOrder(/* length= */ 1)); verify(mockMediaSource, times(1)) .prepareSource( any(MediaSource.MediaSourceCaller.class), /* mediaTransferListener= */ isNull()); - playlist.release(); + mediaSourceList.release(); verify(mockMediaSource, times(1)).releaseSource(any(MediaSource.MediaSourceCaller.class)); assertThat(mediaSourceHolder.isRemoved).isFalse(); } @Test - public void clearPlaylist_expectSourcesReleasedAndRemoved() { + public void clearMediaSourceList_expectSourcesReleasedAndRemoved() { ShuffleOrder.DefaultShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ 4); MediaSource mockMediaSource1 = mock(MediaSource.class); MediaSource mockMediaSource2 = mock(MediaSource.class); - List holders = + List holders = createFakeHoldersWithSources( /* useLazyPreparation= */ false, mockMediaSource1, mockMediaSource2); - playlist.setMediaSources(holders, shuffleOrder); - playlist.prepare(/* mediaTransferListener= */ null); + mediaSourceList.setMediaSources(holders, shuffleOrder); + mediaSourceList.prepare(/* mediaTransferListener= */ null); - Timeline timeline = playlist.clear(shuffleOrder); + Timeline timeline = mediaSourceList.clear(shuffleOrder); assertThat(timeline.isEmpty()).isTrue(); assertThat(holders.get(0).isRemoved).isTrue(); assertThat(holders.get(1).isRemoved).isTrue(); @@ -403,57 +405,61 @@ public class PlaylistTest { @Test public void setMediaSources_expectTimelineUsesCustomShuffleOrder() { Timeline timeline = - playlist.setMediaSources(createFakeHolders(), new FakeShuffleOrder(/* length=*/ 4)); + mediaSourceList.setMediaSources(createFakeHolders(), new FakeShuffleOrder(/* length=*/ 4)); assertTimelineUsesFakeShuffleOrder(timeline); } @Test public void addMediaSources_expectTimelineUsesCustomShuffleOrder() { Timeline timeline = - playlist.addMediaSources( - /* index= */ 0, createFakeHolders(), new FakeShuffleOrder(PLAYLIST_SIZE)); + mediaSourceList.addMediaSources( + /* index= */ 0, createFakeHolders(), new FakeShuffleOrder(MEDIA_SOURCE_LIST_SIZE)); assertTimelineUsesFakeShuffleOrder(timeline); } @Test public void moveMediaSources_expectTimelineUsesCustomShuffleOrder() { - ShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ PLAYLIST_SIZE); - playlist.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); + ShuffleOrder shuffleOrder = + new ShuffleOrder.DefaultShuffleOrder(/* length= */ MEDIA_SOURCE_LIST_SIZE); + mediaSourceList.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); Timeline timeline = - playlist.moveMediaSource( - /* currentIndex= */ 0, /* newIndex= */ 1, new FakeShuffleOrder(PLAYLIST_SIZE)); + mediaSourceList.moveMediaSource( + /* currentIndex= */ 0, /* newIndex= */ 1, new FakeShuffleOrder(MEDIA_SOURCE_LIST_SIZE)); assertTimelineUsesFakeShuffleOrder(timeline); } @Test public void moveMediaSourceRange_expectTimelineUsesCustomShuffleOrder() { - ShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ PLAYLIST_SIZE); - playlist.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); + ShuffleOrder shuffleOrder = + new ShuffleOrder.DefaultShuffleOrder(/* length= */ MEDIA_SOURCE_LIST_SIZE); + mediaSourceList.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); Timeline timeline = - playlist.moveMediaSourceRange( + mediaSourceList.moveMediaSourceRange( /* fromIndex= */ 0, /* toIndex= */ 2, /* newFromIndex= */ 2, - new FakeShuffleOrder(PLAYLIST_SIZE)); + new FakeShuffleOrder(MEDIA_SOURCE_LIST_SIZE)); assertTimelineUsesFakeShuffleOrder(timeline); } @Test public void removeMediaSourceRange_expectTimelineUsesCustomShuffleOrder() { - ShuffleOrder shuffleOrder = new ShuffleOrder.DefaultShuffleOrder(/* length= */ PLAYLIST_SIZE); - playlist.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); + ShuffleOrder shuffleOrder = + new ShuffleOrder.DefaultShuffleOrder(/* length= */ MEDIA_SOURCE_LIST_SIZE); + mediaSourceList.addMediaSources(/* index= */ 0, createFakeHolders(), shuffleOrder); Timeline timeline = - playlist.removeMediaSourceRange( + mediaSourceList.removeMediaSourceRange( /* fromIndex= */ 0, /* toIndex= */ 2, new FakeShuffleOrder(/* length= */ 2)); assertTimelineUsesFakeShuffleOrder(timeline); } @Test public void setShuffleOrder_expectTimelineUsesCustomShuffleOrder() { - playlist.setMediaSources( - createFakeHolders(), new ShuffleOrder.DefaultShuffleOrder(/* length= */ PLAYLIST_SIZE)); + mediaSourceList.setMediaSources( + createFakeHolders(), + new ShuffleOrder.DefaultShuffleOrder(/* length= */ MEDIA_SOURCE_LIST_SIZE)); assertTimelineUsesFakeShuffleOrder( - playlist.setShuffleOrder(new FakeShuffleOrder(PLAYLIST_SIZE))); + mediaSourceList.setShuffleOrder(new FakeShuffleOrder(MEDIA_SOURCE_LIST_SIZE))); } // Internal methods. @@ -472,7 +478,7 @@ public class PlaylistTest { } private static void assertDefaultFirstWindowInChildIndexOrder( - List holders) { + List holders) { int[] indices = new int[holders.size()]; for (int i = 0; i < indices.length; i++) { indices[i] = i; @@ -481,28 +487,29 @@ public class PlaylistTest { } private static void assertFirstWindowInChildIndices( - List holders, int... firstWindowInChildIndices) { + List holders, int... firstWindowInChildIndices) { assertThat(holders).hasSize(firstWindowInChildIndices.length); for (int i = 0; i < holders.size(); i++) { assertThat(holders.get(i).firstWindowIndexInChild).isEqualTo(firstWindowInChildIndices[i]); } } - private static List createFakeHolders() { + private static List createFakeHolders() { MediaSource fakeMediaSource = new FakeMediaSource(new FakeTimeline(1)); - List holders = new ArrayList<>(); - for (int i = 0; i < PLAYLIST_SIZE; i++) { - holders.add(new Playlist.MediaSourceHolder(fakeMediaSource, /* useLazyPreparation= */ true)); + List holders = new ArrayList<>(); + for (int i = 0; i < MEDIA_SOURCE_LIST_SIZE; i++) { + holders.add( + new MediaSourceList.MediaSourceHolder(fakeMediaSource, /* useLazyPreparation= */ true)); } return holders; } - private static List createFakeHoldersWithSources( + private static List createFakeHoldersWithSources( boolean useLazyPreparation, MediaSource... sources) { - List holders = new ArrayList<>(); + List holders = new ArrayList<>(); for (MediaSource mediaSource : sources) { holders.add( - new Playlist.MediaSourceHolder( + new MediaSourceList.MediaSourceHolder( mediaSource, /* useLazyPreparation= */ useLazyPreparation)); } return holders;