mirror of
https://github.com/androidx/media.git
synced 2025-05-15 19:49:50 +08:00
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
This commit is contained in:
bachinger
Oliver Woodman
parent
74a9d8f680
commit
8f24db73f1
@ -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(
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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.
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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;
|
||||
@ -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));
|
||||
|
||||
@ -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;
|
||||
Loading…
x
Reference in New Issue
Block a user