Skip to content

SDK / exoplayer

Go to a project
Commit 8f24db73 by bachinger Committed by Oliver Woodman
Options

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
parent 74a9d8f6
Inline Side-by-side
Showing with 219 additions and 208 deletions
library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java
......@@ -68,7 +68,7 @@ import java.util.concurrent.TimeoutException;
private final CopyOnWriteArrayList<ListenerHolder> listeners;
private final Timeline.Period period;
private final ArrayDeque<Runnable> pendingListenerNotifications;
private final List<Playlist.MediaSourceHolder> mediaSourceHolders;
private final List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> holders = addMediaSourceHolders(index, mediaSources);
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> holders = addMediaSourceHolders(/* index= */ 0, mediaItems);
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> addMediaSourceHolders(
private List<MediaSourceList.MediaSourceHolder> addMediaSourceHolders(
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++) {
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<Playlist.MediaSourceHolder> removeMediaSourceHolders(
private List<MediaSourceList.MediaSourceHolder> removeMediaSourceHolders(
int fromIndex, int toIndexExclusive) {
List<Playlist.MediaSourceHolder> removed = new ArrayList<>();
List<MediaSourceList.MediaSourceHolder> 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(
......
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<PendingMessageInfo> 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<Playlist.MediaSourceHolder> mediaSources,
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> mediaSources, ShuffleOrder shuffleOrder) {
int index, List<MediaSourceList.MediaSourceHolder> 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<MediaPeriodId, Long> 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<Playlist.MediaSourceHolder> mediaSourceHolders;
private final List<MediaSourceList.MediaSourceHolder> mediaSourceHolders;
private final ShuffleOrder shuffleOrder;
private final int windowIndex;
private final long positionUs;
private PlaylistUpdateMessage(
List<Playlist.MediaSourceHolder> mediaSourceHolders,
private MediaSourceListUpdateMessage(
List<MediaSourceList.MediaSourceHolder> mediaSourceHolders,
ShuffleOrder shuffleOrder,
int windowIndex,
long positionUs) {
......
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.
......
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) {
......
library/core/src/main/java/com/google/android/exoplayer2/Playlist.java → library/core/src/main/java/com/google/android/exoplayer2/MediaSourceList.java
......@@ -51,10 +51,10 @@ import java.util.Set;
*
* <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. */
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<MediaSourceHolder> mediaSourceHolders;
private final Map<MediaPeriod, MediaSourceHolder> mediaSourceByMediaPeriod;
private final Map<Object, MediaSourceHolder> mediaSourceByUid;
private final PlaylistInfoRefreshListener playlistInfoListener;
private final MediaSourceListInfoRefreshListener mediaSourceListInfoListener;
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 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;
......
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));
......
library/core/src/test/java/com/google/android/exoplayer2/PlaylistTest.java → 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<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);
// 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<Playlist.MediaSourceHolder> mediaSources =
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> moreMediaSources =
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> mediaSources =
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> moreMediaSources =
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> mediaSources =
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> moreMediaSources = createFakeHolders();
playlist.addMediaSources(
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> holders = createFakeHolders();
playlist.addMediaSources(/* index= */ 0, holders, shuffleOrder);
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> holders =
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> holders =
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> holders =
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> holders) {
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> holders, int... firstWindowInChildIndices) {
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> createFakeHolders() {
private static List<MediaSourceList.MediaSourceHolder> createFakeHolders() {
MediaSource fakeMediaSource = new FakeMediaSource(new FakeTimeline(1));
List<Playlist.MediaSourceHolder> holders = new ArrayList<>();
for (int i = 0; i < PLAYLIST_SIZE; i++) {
holders.add(new Playlist.MediaSourceHolder(fakeMediaSource, /* useLazyPreparation= */ true));
List<MediaSourceList.MediaSourceHolder> 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<Playlist.MediaSourceHolder> createFakeHoldersWithSources(
private static List<MediaSourceList.MediaSourceHolder> createFakeHoldersWithSources(
boolean useLazyPreparation, MediaSource... sources) {
List<Playlist.MediaSourceHolder> holders = new ArrayList<>();
List<MediaSourceList.MediaSourceHolder> holders = new ArrayList<>();
for (MediaSource mediaSource : sources) {
holders.add(
new Playlist.MediaSourceHolder(
new MediaSourceList.MediaSourceHolder(
mediaSource, /* useLazyPreparation= */ useLazyPreparation));
}
return holders;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment