(jContext);
+ if (context->libgav1_status_code != kLibgav1StatusOk ||
+ context->jni_status_code != kJniStatusOk) {
+ return kStatusError;
+ }
+ return kStatusOk;
+}
+
+// TODO(b/139902005): Add functions for getting libgav1 version and build
+// configuration once libgav1 ABI provides this information.
diff --git a/extensions/cast/README.md b/extensions/cast/README.md
new file mode 100644
index 0000000000..1c0d7ac56f
--- /dev/null
+++ b/extensions/cast/README.md
@@ -0,0 +1,30 @@
+# ExoPlayer Cast extension #
+
+## Description ##
+
+The cast extension is a [Player][] implementation that controls playback on a
+Cast receiver app.
+
+[Player]: https://exoplayer.dev/doc/reference/index.html?com/google/android/exoplayer2/Player.html
+
+## Getting the extension ##
+
+The easiest way to use the extension is to add it as a gradle dependency:
+
+```gradle
+implementation 'com.google.android.exoplayer:extension-cast:2.X.X'
+```
+
+where `2.X.X` is the version, which must match the version of the ExoPlayer
+library being used.
+
+Alternatively, you can clone the ExoPlayer repository and depend on the module
+locally. Instructions for doing this can be found in ExoPlayer's
+[top level README][].
+
+[top level README]: https://github.com/google/ExoPlayer/blob/release-v2/README.md
+
+## Using the extension ##
+
+Create a `CastPlayer` and use it to integrate Cast into your app using
+ExoPlayer's common `Player` interface.
diff --git a/extensions/cast/build.gradle b/extensions/cast/build.gradle
new file mode 100644
index 0000000000..0d7d96db4c
--- /dev/null
+++ b/extensions/cast/build.gradle
@@ -0,0 +1,53 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+apply from: '../../constants.gradle'
+apply plugin: 'com.android.library'
+
+android {
+ compileSdkVersion project.ext.compileSdkVersion
+
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_8
+ targetCompatibility JavaVersion.VERSION_1_8
+ }
+
+ defaultConfig {
+ minSdkVersion project.ext.minSdkVersion
+ targetSdkVersion project.ext.targetSdkVersion
+ }
+
+ testOptions.unitTests.includeAndroidResources = true
+}
+
+dependencies {
+ api 'com.google.android.gms:play-services-cast-framework:17.0.0'
+ implementation 'androidx.annotation:annotation:' + androidxAnnotationVersion
+ implementation project(modulePrefix + 'library-core')
+ implementation project(modulePrefix + 'library-ui')
+ compileOnly 'org.checkerframework:checker-qual:' + checkerframeworkVersion
+ compileOnly 'org.checkerframework:checker-compat-qual:' + checkerframeworkVersion
+ testImplementation project(modulePrefix + 'testutils')
+ testImplementation 'org.robolectric:robolectric:' + robolectricVersion
+}
+
+ext {
+ javadocTitle = 'Cast extension'
+}
+apply from: '../../javadoc_library.gradle'
+
+ext {
+ releaseArtifact = 'extension-cast'
+ releaseDescription = 'Cast extension for ExoPlayer.'
+}
+apply from: '../../publish.gradle'
diff --git a/extensions/cast/src/main/AndroidManifest.xml b/extensions/cast/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..c12fc1289f
--- /dev/null
+++ b/extensions/cast/src/main/AndroidManifest.xml
@@ -0,0 +1,16 @@
+
+
+
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastPlayer.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastPlayer.java
new file mode 100644
index 0000000000..5b91410ff9
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastPlayer.java
@@ -0,0 +1,1007 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import android.os.Looper;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.BasePlayer;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.ExoPlaybackException;
+import com.google.android.exoplayer2.ExoPlayerLibraryInfo;
+import com.google.android.exoplayer2.PlaybackParameters;
+import com.google.android.exoplayer2.Player;
+import com.google.android.exoplayer2.Timeline;
+import com.google.android.exoplayer2.source.TrackGroup;
+import com.google.android.exoplayer2.source.TrackGroupArray;
+import com.google.android.exoplayer2.trackselection.FixedTrackSelection;
+import com.google.android.exoplayer2.trackselection.TrackSelection;
+import com.google.android.exoplayer2.trackselection.TrackSelectionArray;
+import com.google.android.exoplayer2.util.Assertions;
+import com.google.android.exoplayer2.util.Log;
+import com.google.android.exoplayer2.util.MimeTypes;
+import com.google.android.gms.cast.CastStatusCodes;
+import com.google.android.gms.cast.MediaInfo;
+import com.google.android.gms.cast.MediaQueueItem;
+import com.google.android.gms.cast.MediaStatus;
+import com.google.android.gms.cast.MediaTrack;
+import com.google.android.gms.cast.framework.CastContext;
+import com.google.android.gms.cast.framework.CastSession;
+import com.google.android.gms.cast.framework.SessionManager;
+import com.google.android.gms.cast.framework.SessionManagerListener;
+import com.google.android.gms.cast.framework.media.RemoteMediaClient;
+import com.google.android.gms.cast.framework.media.RemoteMediaClient.MediaChannelResult;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.ResultCallback;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import org.checkerframework.checker.nullness.qual.RequiresNonNull;
+
+/**
+ * {@link Player} implementation that communicates with a Cast receiver app.
+ *
+ * The behavior of this class depends on the underlying Cast session, which is obtained from the
+ * injected {@link CastContext}. To keep track of the session, {@link #isCastSessionAvailable()} can
+ * be queried and {@link SessionAvailabilityListener} can be implemented and attached to the player.
+ *
+ *
If no session is available, the player state will remain unchanged and calls to methods that
+ * alter it will be ignored. Querying the player state is possible even when no session is
+ * available, in which case, the last observed receiver app state is reported.
+ *
+ *
Methods should be called on the application's main thread.
+ */
+public final class CastPlayer extends BasePlayer {
+
+ static {
+ ExoPlayerLibraryInfo.registerModule("goog.exo.cast");
+ }
+
+ private static final String TAG = "CastPlayer";
+
+ private static final int RENDERER_COUNT = 3;
+ private static final int RENDERER_INDEX_VIDEO = 0;
+ private static final int RENDERER_INDEX_AUDIO = 1;
+ private static final int RENDERER_INDEX_TEXT = 2;
+ private static final long PROGRESS_REPORT_PERIOD_MS = 1000;
+ private static final TrackSelectionArray EMPTY_TRACK_SELECTION_ARRAY =
+ new TrackSelectionArray(null, null, null);
+ private static final long[] EMPTY_TRACK_ID_ARRAY = new long[0];
+
+ private final CastContext castContext;
+ // TODO: Allow custom implementations of CastTimelineTracker.
+ private final CastTimelineTracker timelineTracker;
+ private final Timeline.Period period;
+
+ // Result callbacks.
+ private final StatusListener statusListener;
+ private final SeekResultCallback seekResultCallback;
+
+ // Listeners and notification.
+ private final CopyOnWriteArrayList listeners;
+ private final ArrayList notificationsBatch;
+ private final ArrayDeque ongoingNotificationsTasks;
+ @Nullable private SessionAvailabilityListener sessionAvailabilityListener;
+
+ // Internal state.
+ private final StateHolder playWhenReady;
+ private final StateHolder repeatMode;
+ @Nullable private RemoteMediaClient remoteMediaClient;
+ private CastTimeline currentTimeline;
+ private TrackGroupArray currentTrackGroups;
+ private TrackSelectionArray currentTrackSelection;
+ @Player.State private int playbackState;
+ private int currentWindowIndex;
+ private long lastReportedPositionMs;
+ private int pendingSeekCount;
+ private int pendingSeekWindowIndex;
+ private long pendingSeekPositionMs;
+
+ /**
+ * @param castContext The context from which the cast session is obtained.
+ */
+ public CastPlayer(CastContext castContext) {
+ this.castContext = castContext;
+ timelineTracker = new CastTimelineTracker();
+ period = new Timeline.Period();
+ statusListener = new StatusListener();
+ seekResultCallback = new SeekResultCallback();
+ listeners = new CopyOnWriteArrayList<>();
+ notificationsBatch = new ArrayList<>();
+ ongoingNotificationsTasks = new ArrayDeque<>();
+
+ playWhenReady = new StateHolder<>(false);
+ repeatMode = new StateHolder<>(REPEAT_MODE_OFF);
+ playbackState = STATE_IDLE;
+ currentTimeline = CastTimeline.EMPTY_CAST_TIMELINE;
+ currentTrackGroups = TrackGroupArray.EMPTY;
+ currentTrackSelection = EMPTY_TRACK_SELECTION_ARRAY;
+ pendingSeekWindowIndex = C.INDEX_UNSET;
+ pendingSeekPositionMs = C.TIME_UNSET;
+
+ SessionManager sessionManager = castContext.getSessionManager();
+ sessionManager.addSessionManagerListener(statusListener, CastSession.class);
+ CastSession session = sessionManager.getCurrentCastSession();
+ setRemoteMediaClient(session != null ? session.getRemoteMediaClient() : null);
+ updateInternalStateAndNotifyIfChanged();
+ }
+
+ // Media Queue manipulation methods.
+
+ /**
+ * Loads a single item media queue. If no session is available, does nothing.
+ *
+ * @param item The item to load.
+ * @param positionMs The position at which the playback should start in milliseconds relative to
+ * the start of the item at {@code startIndex}. If {@link C#TIME_UNSET} is passed, playback
+ * starts at position 0.
+ * @return The Cast {@code PendingResult}, or null if no session is available.
+ */
+ @Nullable
+ public PendingResult loadItem(MediaQueueItem item, long positionMs) {
+ return loadItems(new MediaQueueItem[] {item}, 0, positionMs, REPEAT_MODE_OFF);
+ }
+
+ /**
+ * Loads a media queue. If no session is available, does nothing.
+ *
+ * @param items The items to load.
+ * @param startIndex The index of the item at which playback should start.
+ * @param positionMs The position at which the playback should start in milliseconds relative to
+ * the start of the item at {@code startIndex}. If {@link C#TIME_UNSET} is passed, playback
+ * starts at position 0.
+ * @param repeatMode The repeat mode for the created media queue.
+ * @return The Cast {@code PendingResult}, or null if no session is available.
+ */
+ @Nullable
+ public PendingResult loadItems(
+ MediaQueueItem[] items, int startIndex, long positionMs, @RepeatMode int repeatMode) {
+ if (remoteMediaClient != null) {
+ positionMs = positionMs != C.TIME_UNSET ? positionMs : 0;
+ return remoteMediaClient.queueLoad(items, startIndex, getCastRepeatMode(repeatMode),
+ positionMs, null);
+ }
+ return null;
+ }
+
+ /**
+ * Appends a sequence of items to the media queue. If no media queue exists, does nothing.
+ *
+ * @param items The items to append.
+ * @return The Cast {@code PendingResult}, or null if no media queue exists.
+ */
+ @Nullable
+ public PendingResult addItems(MediaQueueItem... items) {
+ return addItems(MediaQueueItem.INVALID_ITEM_ID, items);
+ }
+
+ /**
+ * Inserts a sequence of items into the media queue. If no media queue or period with id {@code
+ * periodId} exist, does nothing.
+ *
+ * @param periodId The id of the period ({@link #getCurrentTimeline}) that corresponds to the item
+ * that will follow immediately after the inserted items.
+ * @param items The items to insert.
+ * @return The Cast {@code PendingResult}, or null if no media queue or no period with id {@code
+ * periodId} exist.
+ */
+ @Nullable
+ public PendingResult addItems(int periodId, MediaQueueItem... items) {
+ if (getMediaStatus() != null && (periodId == MediaQueueItem.INVALID_ITEM_ID
+ || currentTimeline.getIndexOfPeriod(periodId) != C.INDEX_UNSET)) {
+ return remoteMediaClient.queueInsertItems(items, periodId, null);
+ }
+ return null;
+ }
+
+ /**
+ * Removes an item from the media queue. If no media queue or period with id {@code periodId}
+ * exist, does nothing.
+ *
+ * @param periodId The id of the period ({@link #getCurrentTimeline}) that corresponds to the item
+ * to remove.
+ * @return The Cast {@code PendingResult}, or null if no media queue or no period with id {@code
+ * periodId} exist.
+ */
+ @Nullable
+ public PendingResult removeItem(int periodId) {
+ if (getMediaStatus() != null && currentTimeline.getIndexOfPeriod(periodId) != C.INDEX_UNSET) {
+ return remoteMediaClient.queueRemoveItem(periodId, null);
+ }
+ return null;
+ }
+
+ /**
+ * Moves an existing item within the media queue. If no media queue or period with id {@code
+ * periodId} exist, does nothing.
+ *
+ * @param periodId The id of the period ({@link #getCurrentTimeline}) that corresponds to the item
+ * to move.
+ * @param newIndex The target index of the item in the media queue. Must be in the range 0 <=
+ * index < {@link Timeline#getPeriodCount()}, as provided by {@link #getCurrentTimeline()}.
+ * @return The Cast {@code PendingResult}, or null if no media queue or no period with id {@code
+ * periodId} exist.
+ */
+ @Nullable
+ public PendingResult moveItem(int periodId, int newIndex) {
+ Assertions.checkArgument(newIndex >= 0 && newIndex < currentTimeline.getPeriodCount());
+ if (getMediaStatus() != null && currentTimeline.getIndexOfPeriod(periodId) != C.INDEX_UNSET) {
+ return remoteMediaClient.queueMoveItemToNewIndex(periodId, newIndex, null);
+ }
+ return null;
+ }
+
+ /**
+ * Returns the item that corresponds to the period with the given id, or null if no media queue or
+ * period with id {@code periodId} exist.
+ *
+ * @param periodId The id of the period ({@link #getCurrentTimeline}) that corresponds to the item
+ * to get.
+ * @return The item that corresponds to the period with the given id, or null if no media queue or
+ * period with id {@code periodId} exist.
+ */
+ @Nullable
+ public MediaQueueItem getItem(int periodId) {
+ MediaStatus mediaStatus = getMediaStatus();
+ return mediaStatus != null && currentTimeline.getIndexOfPeriod(periodId) != C.INDEX_UNSET
+ ? mediaStatus.getItemById(periodId) : null;
+ }
+
+ // CastSession methods.
+
+ /**
+ * Returns whether a cast session is available.
+ */
+ public boolean isCastSessionAvailable() {
+ return remoteMediaClient != null;
+ }
+
+ /**
+ * Sets a listener for updates on the cast session availability.
+ *
+ * @param listener The {@link SessionAvailabilityListener}, or null to clear the listener.
+ */
+ public void setSessionAvailabilityListener(@Nullable SessionAvailabilityListener listener) {
+ sessionAvailabilityListener = listener;
+ }
+
+ // Player implementation.
+
+ @Override
+ @Nullable
+ public AudioComponent getAudioComponent() {
+ return null;
+ }
+
+ @Override
+ @Nullable
+ public VideoComponent getVideoComponent() {
+ return null;
+ }
+
+ @Override
+ @Nullable
+ public TextComponent getTextComponent() {
+ return null;
+ }
+
+ @Override
+ @Nullable
+ public MetadataComponent getMetadataComponent() {
+ return null;
+ }
+
+ @Override
+ public Looper getApplicationLooper() {
+ return Looper.getMainLooper();
+ }
+
+ @Override
+ public void addListener(EventListener listener) {
+ listeners.addIfAbsent(new ListenerHolder(listener));
+ }
+
+ @Override
+ public void removeListener(EventListener listener) {
+ for (ListenerHolder listenerHolder : listeners) {
+ if (listenerHolder.listener.equals(listener)) {
+ listenerHolder.release();
+ listeners.remove(listenerHolder);
+ }
+ }
+ }
+
+ @Override
+ @Player.State
+ public int getPlaybackState() {
+ return playbackState;
+ }
+
+ @Override
+ @PlaybackSuppressionReason
+ public int getPlaybackSuppressionReason() {
+ return Player.PLAYBACK_SUPPRESSION_REASON_NONE;
+ }
+
+ @Override
+ @Nullable
+ public ExoPlaybackException getPlaybackError() {
+ return null;
+ }
+
+ @Override
+ public void setPlayWhenReady(boolean playWhenReady) {
+ if (remoteMediaClient == null) {
+ return;
+ }
+ // We update the local state and send the message to the receiver app, which will cause the
+ // operation to be perceived as synchronous by the user. When the operation reports a result,
+ // the local state will be updated to reflect the state reported by the Cast SDK.
+ setPlayerStateAndNotifyIfChanged(playWhenReady, playbackState);
+ flushNotifications();
+ PendingResult pendingResult =
+ playWhenReady ? remoteMediaClient.play() : remoteMediaClient.pause();
+ this.playWhenReady.pendingResultCallback =
+ new ResultCallback() {
+ @Override
+ public void onResult(MediaChannelResult mediaChannelResult) {
+ if (remoteMediaClient != null) {
+ updatePlayerStateAndNotifyIfChanged(this);
+ flushNotifications();
+ }
+ }
+ };
+ pendingResult.setResultCallback(this.playWhenReady.pendingResultCallback);
+ }
+
+ @Override
+ public boolean getPlayWhenReady() {
+ return playWhenReady.value;
+ }
+
+ @Override
+ public void seekTo(int windowIndex, long positionMs) {
+ MediaStatus mediaStatus = getMediaStatus();
+ // We assume the default position is 0. There is no support for seeking to the default position
+ // in RemoteMediaClient.
+ positionMs = positionMs != C.TIME_UNSET ? positionMs : 0;
+ if (mediaStatus != null) {
+ if (getCurrentWindowIndex() != windowIndex) {
+ remoteMediaClient.queueJumpToItem((int) currentTimeline.getPeriod(windowIndex, period).uid,
+ positionMs, null).setResultCallback(seekResultCallback);
+ } else {
+ remoteMediaClient.seek(positionMs).setResultCallback(seekResultCallback);
+ }
+ pendingSeekCount++;
+ pendingSeekWindowIndex = windowIndex;
+ pendingSeekPositionMs = positionMs;
+ notificationsBatch.add(
+ new ListenerNotificationTask(
+ listener -> listener.onPositionDiscontinuity(DISCONTINUITY_REASON_SEEK)));
+ } else if (pendingSeekCount == 0) {
+ notificationsBatch.add(new ListenerNotificationTask(EventListener::onSeekProcessed));
+ }
+ flushNotifications();
+ }
+
+ @Override
+ public void setPlaybackParameters(@Nullable PlaybackParameters playbackParameters) {
+ // Unsupported by the RemoteMediaClient API. Do nothing.
+ }
+
+ @Override
+ public PlaybackParameters getPlaybackParameters() {
+ return PlaybackParameters.DEFAULT;
+ }
+
+ @Override
+ public void stop(boolean reset) {
+ playbackState = STATE_IDLE;
+ if (remoteMediaClient != null) {
+ // TODO(b/69792021): Support or emulate stop without position reset.
+ remoteMediaClient.stop();
+ }
+ }
+
+ @Override
+ public void release() {
+ SessionManager sessionManager = castContext.getSessionManager();
+ sessionManager.removeSessionManagerListener(statusListener, CastSession.class);
+ sessionManager.endCurrentSession(false);
+ }
+
+ @Override
+ public int getRendererCount() {
+ // We assume there are three renderers: video, audio, and text.
+ return RENDERER_COUNT;
+ }
+
+ @Override
+ public int getRendererType(int index) {
+ switch (index) {
+ case RENDERER_INDEX_VIDEO:
+ return C.TRACK_TYPE_VIDEO;
+ case RENDERER_INDEX_AUDIO:
+ return C.TRACK_TYPE_AUDIO;
+ case RENDERER_INDEX_TEXT:
+ return C.TRACK_TYPE_TEXT;
+ default:
+ throw new IndexOutOfBoundsException();
+ }
+ }
+
+ @Override
+ public void setRepeatMode(@RepeatMode int repeatMode) {
+ if (remoteMediaClient == null) {
+ return;
+ }
+ // We update the local state and send the message to the receiver app, which will cause the
+ // operation to be perceived as synchronous by the user. When the operation reports a result,
+ // the local state will be updated to reflect the state reported by the Cast SDK.
+ setRepeatModeAndNotifyIfChanged(repeatMode);
+ flushNotifications();
+ PendingResult pendingResult =
+ remoteMediaClient.queueSetRepeatMode(getCastRepeatMode(repeatMode), /* jsonObject= */ null);
+ this.repeatMode.pendingResultCallback =
+ new ResultCallback() {
+ @Override
+ public void onResult(MediaChannelResult mediaChannelResult) {
+ if (remoteMediaClient != null) {
+ updateRepeatModeAndNotifyIfChanged(this);
+ flushNotifications();
+ }
+ }
+ };
+ pendingResult.setResultCallback(this.repeatMode.pendingResultCallback);
+ }
+
+ @Override
+ @RepeatMode public int getRepeatMode() {
+ return repeatMode.value;
+ }
+
+ @Override
+ public void setShuffleModeEnabled(boolean shuffleModeEnabled) {
+ // TODO: Support shuffle mode.
+ }
+
+ @Override
+ public boolean getShuffleModeEnabled() {
+ // TODO: Support shuffle mode.
+ return false;
+ }
+
+ @Override
+ public TrackSelectionArray getCurrentTrackSelections() {
+ return currentTrackSelection;
+ }
+
+ @Override
+ public TrackGroupArray getCurrentTrackGroups() {
+ return currentTrackGroups;
+ }
+
+ @Override
+ public Timeline getCurrentTimeline() {
+ return currentTimeline;
+ }
+
+ @Override
+ public int getCurrentPeriodIndex() {
+ return getCurrentWindowIndex();
+ }
+
+ @Override
+ public int getCurrentWindowIndex() {
+ return pendingSeekWindowIndex != C.INDEX_UNSET ? pendingSeekWindowIndex : currentWindowIndex;
+ }
+
+ // TODO: Fill the cast timeline information with ProgressListener's duration updates.
+ // See [Internal: b/65152553].
+ @Override
+ public long getDuration() {
+ return getContentDuration();
+ }
+
+ @Override
+ public long getCurrentPosition() {
+ return pendingSeekPositionMs != C.TIME_UNSET
+ ? pendingSeekPositionMs
+ : remoteMediaClient != null
+ ? remoteMediaClient.getApproximateStreamPosition()
+ : lastReportedPositionMs;
+ }
+
+ @Override
+ public long getBufferedPosition() {
+ return getCurrentPosition();
+ }
+
+ @Override
+ public long getTotalBufferedDuration() {
+ long bufferedPosition = getBufferedPosition();
+ long currentPosition = getCurrentPosition();
+ return bufferedPosition == C.TIME_UNSET || currentPosition == C.TIME_UNSET
+ ? 0
+ : bufferedPosition - currentPosition;
+ }
+
+ @Override
+ public boolean isPlayingAd() {
+ return false;
+ }
+
+ @Override
+ public int getCurrentAdGroupIndex() {
+ return C.INDEX_UNSET;
+ }
+
+ @Override
+ public int getCurrentAdIndexInAdGroup() {
+ return C.INDEX_UNSET;
+ }
+
+ @Override
+ public boolean isLoading() {
+ return false;
+ }
+
+ @Override
+ public long getContentPosition() {
+ return getCurrentPosition();
+ }
+
+ @Override
+ public long getContentBufferedPosition() {
+ return getBufferedPosition();
+ }
+
+ // Internal methods.
+
+ private void updateInternalStateAndNotifyIfChanged() {
+ if (remoteMediaClient == null) {
+ // There is no session. We leave the state of the player as it is now.
+ return;
+ }
+ boolean wasPlaying = playbackState == Player.STATE_READY && playWhenReady.value;
+ updatePlayerStateAndNotifyIfChanged(/* resultCallback= */ null);
+ boolean isPlaying = playbackState == Player.STATE_READY && playWhenReady.value;
+ if (wasPlaying != isPlaying) {
+ notificationsBatch.add(
+ new ListenerNotificationTask(listener -> listener.onIsPlayingChanged(isPlaying)));
+ }
+ updateRepeatModeAndNotifyIfChanged(/* resultCallback= */ null);
+ updateTimelineAndNotifyIfChanged();
+
+ int currentWindowIndex = C.INDEX_UNSET;
+ MediaQueueItem currentItem = remoteMediaClient.getCurrentItem();
+ if (currentItem != null) {
+ currentWindowIndex = currentTimeline.getIndexOfPeriod(currentItem.getItemId());
+ }
+ if (currentWindowIndex == C.INDEX_UNSET) {
+ // The timeline is empty. Fall back to index 0, which is what ExoPlayer would do.
+ currentWindowIndex = 0;
+ }
+ if (this.currentWindowIndex != currentWindowIndex && pendingSeekCount == 0) {
+ this.currentWindowIndex = currentWindowIndex;
+ notificationsBatch.add(
+ new ListenerNotificationTask(
+ listener ->
+ listener.onPositionDiscontinuity(DISCONTINUITY_REASON_PERIOD_TRANSITION)));
+ }
+ if (updateTracksAndSelectionsAndNotifyIfChanged()) {
+ notificationsBatch.add(
+ new ListenerNotificationTask(
+ listener -> listener.onTracksChanged(currentTrackGroups, currentTrackSelection)));
+ }
+ flushNotifications();
+ }
+
+ /**
+ * Updates {@link #playWhenReady} and {@link #playbackState} to match the Cast {@code
+ * remoteMediaClient} state, and notifies listeners of any state changes.
+ *
+ * This method will only update values whose {@link StateHolder#pendingResultCallback} matches
+ * the given {@code resultCallback}.
+ */
+ @RequiresNonNull("remoteMediaClient")
+ private void updatePlayerStateAndNotifyIfChanged(@Nullable ResultCallback resultCallback) {
+ boolean newPlayWhenReadyValue = playWhenReady.value;
+ if (playWhenReady.acceptsUpdate(resultCallback)) {
+ newPlayWhenReadyValue = !remoteMediaClient.isPaused();
+ playWhenReady.clearPendingResultCallback();
+ }
+ // We do not mask the playback state, so try setting it regardless of the playWhenReady masking.
+ setPlayerStateAndNotifyIfChanged(newPlayWhenReadyValue, fetchPlaybackState(remoteMediaClient));
+ }
+
+ @RequiresNonNull("remoteMediaClient")
+ private void updateRepeatModeAndNotifyIfChanged(@Nullable ResultCallback resultCallback) {
+ if (repeatMode.acceptsUpdate(resultCallback)) {
+ setRepeatModeAndNotifyIfChanged(fetchRepeatMode(remoteMediaClient));
+ repeatMode.clearPendingResultCallback();
+ }
+ }
+
+ private void updateTimelineAndNotifyIfChanged() {
+ if (updateTimeline()) {
+ // TODO: Differentiate TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED and
+ // TIMELINE_CHANGE_REASON_SOURCE_UPDATE [see internal: b/65152553].
+ notificationsBatch.add(
+ new ListenerNotificationTask(
+ listener ->
+ listener.onTimelineChanged(
+ currentTimeline, Player.TIMELINE_CHANGE_REASON_SOURCE_UPDATE)));
+ }
+ }
+
+ /**
+ * Updates the current timeline and returns whether it has changed.
+ */
+ private boolean updateTimeline() {
+ CastTimeline oldTimeline = currentTimeline;
+ MediaStatus status = getMediaStatus();
+ currentTimeline =
+ status != null
+ ? timelineTracker.getCastTimeline(remoteMediaClient)
+ : CastTimeline.EMPTY_CAST_TIMELINE;
+ return !oldTimeline.equals(currentTimeline);
+ }
+
+ /** Updates the internal tracks and selection and returns whether they have changed. */
+ private boolean updateTracksAndSelectionsAndNotifyIfChanged() {
+ if (remoteMediaClient == null) {
+ // There is no session. We leave the state of the player as it is now.
+ return false;
+ }
+
+ MediaStatus mediaStatus = getMediaStatus();
+ MediaInfo mediaInfo = mediaStatus != null ? mediaStatus.getMediaInfo() : null;
+ List castMediaTracks = mediaInfo != null ? mediaInfo.getMediaTracks() : null;
+ if (castMediaTracks == null || castMediaTracks.isEmpty()) {
+ boolean hasChanged = !currentTrackGroups.isEmpty();
+ currentTrackGroups = TrackGroupArray.EMPTY;
+ currentTrackSelection = EMPTY_TRACK_SELECTION_ARRAY;
+ return hasChanged;
+ }
+ long[] activeTrackIds = mediaStatus.getActiveTrackIds();
+ if (activeTrackIds == null) {
+ activeTrackIds = EMPTY_TRACK_ID_ARRAY;
+ }
+
+ TrackGroup[] trackGroups = new TrackGroup[castMediaTracks.size()];
+ TrackSelection[] trackSelections = new TrackSelection[RENDERER_COUNT];
+ for (int i = 0; i < castMediaTracks.size(); i++) {
+ MediaTrack mediaTrack = castMediaTracks.get(i);
+ trackGroups[i] = new TrackGroup(CastUtils.mediaTrackToFormat(mediaTrack));
+
+ long id = mediaTrack.getId();
+ int trackType = MimeTypes.getTrackType(mediaTrack.getContentType());
+ int rendererIndex = getRendererIndexForTrackType(trackType);
+ if (isTrackActive(id, activeTrackIds) && rendererIndex != C.INDEX_UNSET
+ && trackSelections[rendererIndex] == null) {
+ trackSelections[rendererIndex] = new FixedTrackSelection(trackGroups[i], 0);
+ }
+ }
+ TrackGroupArray newTrackGroups = new TrackGroupArray(trackGroups);
+ TrackSelectionArray newTrackSelections = new TrackSelectionArray(trackSelections);
+
+ if (!newTrackGroups.equals(currentTrackGroups)
+ || !newTrackSelections.equals(currentTrackSelection)) {
+ currentTrackSelection = new TrackSelectionArray(trackSelections);
+ currentTrackGroups = new TrackGroupArray(trackGroups);
+ return true;
+ }
+ return false;
+ }
+
+ private void setRepeatModeAndNotifyIfChanged(@Player.RepeatMode int repeatMode) {
+ if (this.repeatMode.value != repeatMode) {
+ this.repeatMode.value = repeatMode;
+ notificationsBatch.add(
+ new ListenerNotificationTask(listener -> listener.onRepeatModeChanged(repeatMode)));
+ }
+ }
+
+ private void setPlayerStateAndNotifyIfChanged(
+ boolean playWhenReady, @Player.State int playbackState) {
+ if (this.playWhenReady.value != playWhenReady || this.playbackState != playbackState) {
+ this.playWhenReady.value = playWhenReady;
+ this.playbackState = playbackState;
+ notificationsBatch.add(
+ new ListenerNotificationTask(
+ listener -> listener.onPlayerStateChanged(playWhenReady, playbackState)));
+ }
+ }
+
+ private void setRemoteMediaClient(@Nullable RemoteMediaClient remoteMediaClient) {
+ if (this.remoteMediaClient == remoteMediaClient) {
+ // Do nothing.
+ return;
+ }
+ if (this.remoteMediaClient != null) {
+ this.remoteMediaClient.removeListener(statusListener);
+ this.remoteMediaClient.removeProgressListener(statusListener);
+ }
+ this.remoteMediaClient = remoteMediaClient;
+ if (remoteMediaClient != null) {
+ if (sessionAvailabilityListener != null) {
+ sessionAvailabilityListener.onCastSessionAvailable();
+ }
+ remoteMediaClient.addListener(statusListener);
+ remoteMediaClient.addProgressListener(statusListener, PROGRESS_REPORT_PERIOD_MS);
+ updateInternalStateAndNotifyIfChanged();
+ } else {
+ if (sessionAvailabilityListener != null) {
+ sessionAvailabilityListener.onCastSessionUnavailable();
+ }
+ }
+ }
+
+ @Nullable
+ private MediaStatus getMediaStatus() {
+ return remoteMediaClient != null ? remoteMediaClient.getMediaStatus() : null;
+ }
+
+ /**
+ * Retrieves the playback state from {@code remoteMediaClient} and maps it into a {@link Player}
+ * state
+ */
+ private static int fetchPlaybackState(RemoteMediaClient remoteMediaClient) {
+ int receiverAppStatus = remoteMediaClient.getPlayerState();
+ switch (receiverAppStatus) {
+ case MediaStatus.PLAYER_STATE_BUFFERING:
+ return STATE_BUFFERING;
+ case MediaStatus.PLAYER_STATE_PLAYING:
+ case MediaStatus.PLAYER_STATE_PAUSED:
+ return STATE_READY;
+ case MediaStatus.PLAYER_STATE_IDLE:
+ case MediaStatus.PLAYER_STATE_UNKNOWN:
+ default:
+ return STATE_IDLE;
+ }
+ }
+
+ /**
+ * Retrieves the repeat mode from {@code remoteMediaClient} and maps it into a
+ * {@link Player.RepeatMode}.
+ */
+ @RepeatMode
+ private static int fetchRepeatMode(RemoteMediaClient remoteMediaClient) {
+ MediaStatus mediaStatus = remoteMediaClient.getMediaStatus();
+ if (mediaStatus == null) {
+ // No media session active, yet.
+ return REPEAT_MODE_OFF;
+ }
+ int castRepeatMode = mediaStatus.getQueueRepeatMode();
+ switch (castRepeatMode) {
+ case MediaStatus.REPEAT_MODE_REPEAT_SINGLE:
+ return REPEAT_MODE_ONE;
+ case MediaStatus.REPEAT_MODE_REPEAT_ALL:
+ case MediaStatus.REPEAT_MODE_REPEAT_ALL_AND_SHUFFLE:
+ return REPEAT_MODE_ALL;
+ case MediaStatus.REPEAT_MODE_REPEAT_OFF:
+ return REPEAT_MODE_OFF;
+ default:
+ throw new IllegalStateException();
+ }
+ }
+
+ private static boolean isTrackActive(long id, long[] activeTrackIds) {
+ for (long activeTrackId : activeTrackIds) {
+ if (activeTrackId == id) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static int getRendererIndexForTrackType(int trackType) {
+ return trackType == C.TRACK_TYPE_VIDEO
+ ? RENDERER_INDEX_VIDEO
+ : trackType == C.TRACK_TYPE_AUDIO
+ ? RENDERER_INDEX_AUDIO
+ : trackType == C.TRACK_TYPE_TEXT ? RENDERER_INDEX_TEXT : C.INDEX_UNSET;
+ }
+
+ private static int getCastRepeatMode(@RepeatMode int repeatMode) {
+ switch (repeatMode) {
+ case REPEAT_MODE_ONE:
+ return MediaStatus.REPEAT_MODE_REPEAT_SINGLE;
+ case REPEAT_MODE_ALL:
+ return MediaStatus.REPEAT_MODE_REPEAT_ALL;
+ case REPEAT_MODE_OFF:
+ return MediaStatus.REPEAT_MODE_REPEAT_OFF;
+ default:
+ throw new IllegalArgumentException();
+ }
+ }
+
+ private void flushNotifications() {
+ boolean recursiveNotification = !ongoingNotificationsTasks.isEmpty();
+ ongoingNotificationsTasks.addAll(notificationsBatch);
+ notificationsBatch.clear();
+ if (recursiveNotification) {
+ // This will be handled once the current notification task is finished.
+ return;
+ }
+ while (!ongoingNotificationsTasks.isEmpty()) {
+ ongoingNotificationsTasks.peekFirst().execute();
+ ongoingNotificationsTasks.removeFirst();
+ }
+ }
+
+ // Internal classes.
+
+ private final class StatusListener
+ implements RemoteMediaClient.Listener,
+ SessionManagerListener,
+ RemoteMediaClient.ProgressListener {
+
+ // RemoteMediaClient.ProgressListener implementation.
+
+ @Override
+ public void onProgressUpdated(long progressMs, long unusedDurationMs) {
+ lastReportedPositionMs = progressMs;
+ }
+
+ // RemoteMediaClient.Listener implementation.
+
+ @Override
+ public void onStatusUpdated() {
+ updateInternalStateAndNotifyIfChanged();
+ }
+
+ @Override
+ public void onMetadataUpdated() {}
+
+ @Override
+ public void onQueueStatusUpdated() {
+ updateTimelineAndNotifyIfChanged();
+ }
+
+ @Override
+ public void onPreloadStatusUpdated() {}
+
+ @Override
+ public void onSendingRemoteMediaRequest() {}
+
+ @Override
+ public void onAdBreakStatusUpdated() {}
+
+ // SessionManagerListener implementation.
+
+ @Override
+ public void onSessionStarted(CastSession castSession, String s) {
+ setRemoteMediaClient(castSession.getRemoteMediaClient());
+ }
+
+ @Override
+ public void onSessionResumed(CastSession castSession, boolean b) {
+ setRemoteMediaClient(castSession.getRemoteMediaClient());
+ }
+
+ @Override
+ public void onSessionEnded(CastSession castSession, int i) {
+ setRemoteMediaClient(null);
+ }
+
+ @Override
+ public void onSessionSuspended(CastSession castSession, int i) {
+ setRemoteMediaClient(null);
+ }
+
+ @Override
+ public void onSessionResumeFailed(CastSession castSession, int statusCode) {
+ Log.e(TAG, "Session resume failed. Error code " + statusCode + ": "
+ + CastUtils.getLogString(statusCode));
+ }
+
+ @Override
+ public void onSessionStarting(CastSession castSession) {
+ // Do nothing.
+ }
+
+ @Override
+ public void onSessionStartFailed(CastSession castSession, int statusCode) {
+ Log.e(TAG, "Session start failed. Error code " + statusCode + ": "
+ + CastUtils.getLogString(statusCode));
+ }
+
+ @Override
+ public void onSessionEnding(CastSession castSession) {
+ // Do nothing.
+ }
+
+ @Override
+ public void onSessionResuming(CastSession castSession, String s) {
+ // Do nothing.
+ }
+
+ }
+
+ private final class SeekResultCallback implements ResultCallback {
+
+ @Override
+ public void onResult(MediaChannelResult result) {
+ int statusCode = result.getStatus().getStatusCode();
+ if (statusCode != CastStatusCodes.SUCCESS && statusCode != CastStatusCodes.REPLACED) {
+ Log.e(TAG, "Seek failed. Error code " + statusCode + ": "
+ + CastUtils.getLogString(statusCode));
+ }
+ if (--pendingSeekCount == 0) {
+ pendingSeekWindowIndex = C.INDEX_UNSET;
+ pendingSeekPositionMs = C.TIME_UNSET;
+ notificationsBatch.add(new ListenerNotificationTask(EventListener::onSeekProcessed));
+ flushNotifications();
+ }
+ }
+ }
+
+ /** Holds the value and the masking status of a specific part of the {@link CastPlayer} state. */
+ private static final class StateHolder {
+
+ /** The user-facing value of a specific part of the {@link CastPlayer} state. */
+ public T value;
+
+ /**
+ * If {@link #value} is being masked, holds the result callback for the operation that triggered
+ * the masking. Or null if {@link #value} is not being masked.
+ */
+ @Nullable public ResultCallback pendingResultCallback;
+
+ public StateHolder(T initialValue) {
+ value = initialValue;
+ }
+
+ public void clearPendingResultCallback() {
+ pendingResultCallback = null;
+ }
+
+ /**
+ * Returns whether this state holder accepts updates coming from the given result callback.
+ *
+ * A null {@code resultCallback} means that the update is a regular receiver state update, in
+ * which case the update will only be accepted if {@link #value} is not being masked. If {@link
+ * #value} is being masked, the update will only be accepted if {@code resultCallback} is the
+ * same as the {@link #pendingResultCallback}.
+ *
+ * @param resultCallback A result callback. May be null if the update comes from a regular
+ * receiver status update.
+ */
+ public boolean acceptsUpdate(@Nullable ResultCallback resultCallback) {
+ return pendingResultCallback == resultCallback;
+ }
+ }
+
+ private final class ListenerNotificationTask {
+
+ private final Iterator listenersSnapshot;
+ private final ListenerInvocation listenerInvocation;
+
+ private ListenerNotificationTask(ListenerInvocation listenerInvocation) {
+ this.listenersSnapshot = listeners.iterator();
+ this.listenerInvocation = listenerInvocation;
+ }
+
+ public void execute() {
+ while (listenersSnapshot.hasNext()) {
+ listenersSnapshot.next().invoke(listenerInvocation);
+ }
+ }
+ }
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastTimeline.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastTimeline.java
new file mode 100644
index 0000000000..38a7a692b2
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastTimeline.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import android.util.SparseArray;
+import android.util.SparseIntArray;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.Timeline;
+import java.util.Arrays;
+
+/**
+ * A {@link Timeline} for Cast media queues.
+ */
+/* package */ final class CastTimeline extends Timeline {
+
+ /** Holds {@link Timeline} related data for a Cast media item. */
+ public static final class ItemData {
+
+ /** Holds no media information. */
+ public static final ItemData EMPTY = new ItemData();
+
+ /** The duration of the item in microseconds, or {@link C#TIME_UNSET} if unknown. */
+ public final long durationUs;
+ /**
+ * The default start position of the item in microseconds, or {@link C#TIME_UNSET} if unknown.
+ */
+ public final long defaultPositionUs;
+ /** Whether the item is live content, or {@code false} if unknown. */
+ public final boolean isLive;
+
+ private ItemData() {
+ this(
+ /* durationUs= */ C.TIME_UNSET, /* defaultPositionUs */
+ C.TIME_UNSET,
+ /* isLive= */ false);
+ }
+
+ /**
+ * Creates an instance.
+ *
+ * @param durationUs See {@link #durationsUs}.
+ * @param defaultPositionUs See {@link #defaultPositionUs}.
+ * @param isLive See {@link #isLive}.
+ */
+ public ItemData(long durationUs, long defaultPositionUs, boolean isLive) {
+ this.durationUs = durationUs;
+ this.defaultPositionUs = defaultPositionUs;
+ this.isLive = isLive;
+ }
+
+ /**
+ * Returns a copy of this instance with the given values.
+ *
+ * @param durationUs The duration in microseconds, or {@link C#TIME_UNSET} if unknown.
+ * @param defaultPositionUs The default start position in microseconds, or {@link C#TIME_UNSET}
+ * if unknown.
+ * @param isLive Whether the item is live, or {@code false} if unknown.
+ */
+ public ItemData copyWithNewValues(long durationUs, long defaultPositionUs, boolean isLive) {
+ if (durationUs == this.durationUs
+ && defaultPositionUs == this.defaultPositionUs
+ && isLive == this.isLive) {
+ return this;
+ }
+ return new ItemData(durationUs, defaultPositionUs, isLive);
+ }
+ }
+
+ /** {@link Timeline} for a cast queue that has no items. */
+ public static final CastTimeline EMPTY_CAST_TIMELINE =
+ new CastTimeline(new int[0], new SparseArray<>());
+
+ private final SparseIntArray idsToIndex;
+ private final int[] ids;
+ private final long[] durationsUs;
+ private final long[] defaultPositionsUs;
+ private final boolean[] isLive;
+
+ /**
+ * Creates a Cast timeline from the given data.
+ *
+ * @param itemIds The ids of the items in the timeline.
+ * @param itemIdToData Maps item ids to {@link ItemData}.
+ */
+ public CastTimeline(int[] itemIds, SparseArray itemIdToData) {
+ int itemCount = itemIds.length;
+ idsToIndex = new SparseIntArray(itemCount);
+ ids = Arrays.copyOf(itemIds, itemCount);
+ durationsUs = new long[itemCount];
+ defaultPositionsUs = new long[itemCount];
+ isLive = new boolean[itemCount];
+ for (int i = 0; i < ids.length; i++) {
+ int id = ids[i];
+ idsToIndex.put(id, i);
+ ItemData data = itemIdToData.get(id, ItemData.EMPTY);
+ durationsUs[i] = data.durationUs;
+ defaultPositionsUs[i] = data.defaultPositionUs == C.TIME_UNSET ? 0 : data.defaultPositionUs;
+ isLive[i] = data.isLive;
+ }
+ }
+
+ // Timeline implementation.
+
+ @Override
+ public int getWindowCount() {
+ return ids.length;
+ }
+
+ @Override
+ public Window getWindow(int windowIndex, Window window, long defaultPositionProjectionUs) {
+ long durationUs = durationsUs[windowIndex];
+ boolean isDynamic = durationUs == C.TIME_UNSET;
+ return window.set(
+ /* uid= */ ids[windowIndex],
+ /* tag= */ ids[windowIndex],
+ /* manifest= */ null,
+ /* presentationStartTimeMs= */ C.TIME_UNSET,
+ /* windowStartTimeMs= */ C.TIME_UNSET,
+ /* elapsedRealtimeEpochOffsetMs= */ C.TIME_UNSET,
+ /* isSeekable= */ !isDynamic,
+ isDynamic,
+ isLive[windowIndex],
+ defaultPositionsUs[windowIndex],
+ durationUs,
+ /* firstPeriodIndex= */ windowIndex,
+ /* lastPeriodIndex= */ windowIndex,
+ /* positionInFirstPeriodUs= */ 0);
+ }
+
+ @Override
+ public int getPeriodCount() {
+ return ids.length;
+ }
+
+ @Override
+ public Period getPeriod(int periodIndex, Period period, boolean setIds) {
+ int id = ids[periodIndex];
+ return period.set(id, id, periodIndex, durationsUs[periodIndex], 0);
+ }
+
+ @Override
+ public int getIndexOfPeriod(Object uid) {
+ return uid instanceof Integer ? idsToIndex.get((int) uid, C.INDEX_UNSET) : C.INDEX_UNSET;
+ }
+
+ @Override
+ public Integer getUidOfPeriod(int periodIndex) {
+ return ids[periodIndex];
+ }
+
+ // equals and hashCode implementations.
+
+ @Override
+ public boolean equals(@Nullable Object other) {
+ if (this == other) {
+ return true;
+ } else if (!(other instanceof CastTimeline)) {
+ return false;
+ }
+ CastTimeline that = (CastTimeline) other;
+ return Arrays.equals(ids, that.ids)
+ && Arrays.equals(durationsUs, that.durationsUs)
+ && Arrays.equals(defaultPositionsUs, that.defaultPositionsUs)
+ && Arrays.equals(isLive, that.isLive);
+ }
+
+ @Override
+ public int hashCode() {
+ int result = Arrays.hashCode(ids);
+ result = 31 * result + Arrays.hashCode(durationsUs);
+ result = 31 * result + Arrays.hashCode(defaultPositionsUs);
+ result = 31 * result + Arrays.hashCode(isLive);
+ return result;
+ }
+
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastTimelineTracker.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastTimelineTracker.java
new file mode 100644
index 0000000000..3ebd89c8fc
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastTimelineTracker.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import android.util.SparseArray;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.gms.cast.MediaInfo;
+import com.google.android.gms.cast.MediaQueueItem;
+import com.google.android.gms.cast.MediaStatus;
+import com.google.android.gms.cast.framework.media.RemoteMediaClient;
+import java.util.HashSet;
+
+/**
+ * Creates {@link CastTimeline CastTimelines} from cast receiver app status updates.
+ *
+ * This class keeps track of the duration reported by the current item to fill any missing
+ * durations in the media queue items [See internal: b/65152553].
+ */
+/* package */ final class CastTimelineTracker {
+
+ private final SparseArray itemIdToData;
+
+ public CastTimelineTracker() {
+ itemIdToData = new SparseArray<>();
+ }
+
+ /**
+ * Returns a {@link CastTimeline} that represents the state of the given {@code
+ * remoteMediaClient}.
+ *
+ * Returned timelines may contain values obtained from {@code remoteMediaClient} in previous
+ * invocations of this method.
+ *
+ * @param remoteMediaClient The Cast media client.
+ * @return A {@link CastTimeline} that represents the given {@code remoteMediaClient} status.
+ */
+ public CastTimeline getCastTimeline(RemoteMediaClient remoteMediaClient) {
+ int[] itemIds = remoteMediaClient.getMediaQueue().getItemIds();
+ if (itemIds.length > 0) {
+ // Only remove unused items when there is something in the queue to avoid removing all entries
+ // if the remote media client clears the queue temporarily. See [Internal ref: b/128825216].
+ removeUnusedItemDataEntries(itemIds);
+ }
+
+ // TODO: Reset state when the app instance changes [Internal ref: b/129672468].
+ MediaStatus mediaStatus = remoteMediaClient.getMediaStatus();
+ if (mediaStatus == null) {
+ return CastTimeline.EMPTY_CAST_TIMELINE;
+ }
+
+ int currentItemId = mediaStatus.getCurrentItemId();
+ updateItemData(
+ currentItemId, mediaStatus.getMediaInfo(), /* defaultPositionUs= */ C.TIME_UNSET);
+
+ for (MediaQueueItem item : mediaStatus.getQueueItems()) {
+ long defaultPositionUs = (long) (item.getStartTime() * C.MICROS_PER_SECOND);
+ updateItemData(item.getItemId(), item.getMedia(), defaultPositionUs);
+ }
+
+ return new CastTimeline(itemIds, itemIdToData);
+ }
+
+ private void updateItemData(int itemId, @Nullable MediaInfo mediaInfo, long defaultPositionUs) {
+ CastTimeline.ItemData previousData = itemIdToData.get(itemId, CastTimeline.ItemData.EMPTY);
+ long durationUs = CastUtils.getStreamDurationUs(mediaInfo);
+ if (durationUs == C.TIME_UNSET) {
+ durationUs = previousData.durationUs;
+ }
+ boolean isLive =
+ mediaInfo == null
+ ? previousData.isLive
+ : mediaInfo.getStreamType() == MediaInfo.STREAM_TYPE_LIVE;
+ if (defaultPositionUs == C.TIME_UNSET) {
+ defaultPositionUs = previousData.defaultPositionUs;
+ }
+ itemIdToData.put(itemId, previousData.copyWithNewValues(durationUs, defaultPositionUs, isLive));
+ }
+
+ private void removeUnusedItemDataEntries(int[] itemIds) {
+ HashSet scratchItemIds = new HashSet<>(/* initialCapacity= */ itemIds.length * 2);
+ for (int id : itemIds) {
+ scratchItemIds.add(id);
+ }
+
+ int index = 0;
+ while (index < itemIdToData.size()) {
+ if (!scratchItemIds.contains(itemIdToData.keyAt(index))) {
+ itemIdToData.removeAt(index);
+ } else {
+ index++;
+ }
+ }
+ }
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastUtils.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastUtils.java
new file mode 100644
index 0000000000..1dc25576a0
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/CastUtils.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.Format;
+import com.google.android.gms.cast.CastStatusCodes;
+import com.google.android.gms.cast.MediaInfo;
+import com.google.android.gms.cast.MediaTrack;
+
+/**
+ * Utility methods for ExoPlayer/Cast integration.
+ */
+/* package */ final class CastUtils {
+
+ /**
+ * Returns the duration in microseconds advertised by a media info, or {@link C#TIME_UNSET} if
+ * unknown or not applicable.
+ *
+ * @param mediaInfo The media info to get the duration from.
+ * @return The duration in microseconds, or {@link C#TIME_UNSET} if unknown or not applicable.
+ */
+ public static long getStreamDurationUs(@Nullable MediaInfo mediaInfo) {
+ if (mediaInfo == null) {
+ return C.TIME_UNSET;
+ }
+ long durationMs = mediaInfo.getStreamDuration();
+ return durationMs != MediaInfo.UNKNOWN_DURATION ? C.msToUs(durationMs) : C.TIME_UNSET;
+ }
+
+ /**
+ * Returns a descriptive log string for the given {@code statusCode}, or "Unknown." if not one of
+ * {@link CastStatusCodes}.
+ *
+ * @param statusCode A Cast API status code.
+ * @return A descriptive log string for the given {@code statusCode}, or "Unknown." if not one of
+ * {@link CastStatusCodes}.
+ */
+ public static String getLogString(int statusCode) {
+ switch (statusCode) {
+ case CastStatusCodes.APPLICATION_NOT_FOUND:
+ return "A requested application could not be found.";
+ case CastStatusCodes.APPLICATION_NOT_RUNNING:
+ return "A requested application is not currently running.";
+ case CastStatusCodes.AUTHENTICATION_FAILED:
+ return "Authentication failure.";
+ case CastStatusCodes.CANCELED:
+ return "An in-progress request has been canceled, most likely because another action has "
+ + "preempted it.";
+ case CastStatusCodes.ERROR_SERVICE_CREATION_FAILED:
+ return "The Cast Remote Display service could not be created.";
+ case CastStatusCodes.ERROR_SERVICE_DISCONNECTED:
+ return "The Cast Remote Display service was disconnected.";
+ case CastStatusCodes.FAILED:
+ return "The in-progress request failed.";
+ case CastStatusCodes.INTERNAL_ERROR:
+ return "An internal error has occurred.";
+ case CastStatusCodes.INTERRUPTED:
+ return "A blocking call was interrupted while waiting and did not run to completion.";
+ case CastStatusCodes.INVALID_REQUEST:
+ return "An invalid request was made.";
+ case CastStatusCodes.MESSAGE_SEND_BUFFER_TOO_FULL:
+ return "A message could not be sent because there is not enough room in the send buffer at "
+ + "this time.";
+ case CastStatusCodes.MESSAGE_TOO_LARGE:
+ return "A message could not be sent because it is too large.";
+ case CastStatusCodes.NETWORK_ERROR:
+ return "Network I/O error.";
+ case CastStatusCodes.NOT_ALLOWED:
+ return "The request was disallowed and could not be completed.";
+ case CastStatusCodes.REPLACED:
+ return "The request's progress is no longer being tracked because another request of the "
+ + "same type has been made before the first request completed.";
+ case CastStatusCodes.SUCCESS:
+ return "Success.";
+ case CastStatusCodes.TIMEOUT:
+ return "An operation has timed out.";
+ case CastStatusCodes.UNKNOWN_ERROR:
+ return "An unknown, unexpected error has occurred.";
+ default:
+ return CastStatusCodes.getStatusCodeString(statusCode);
+ }
+ }
+
+ /**
+ * Creates a {@link Format} instance containing all information contained in the given
+ * {@link MediaTrack} object.
+ *
+ * @param mediaTrack The {@link MediaTrack}.
+ * @return The equivalent {@link Format}.
+ */
+ public static Format mediaTrackToFormat(MediaTrack mediaTrack) {
+ return Format.createContainerFormat(
+ mediaTrack.getContentId(),
+ /* label= */ null,
+ mediaTrack.getContentType(),
+ /* sampleMimeType= */ null,
+ /* codecs= */ null,
+ /* bitrate= */ Format.NO_VALUE,
+ /* selectionFlags= */ 0,
+ /* roleFlags= */ 0,
+ mediaTrack.getLanguage());
+ }
+
+ private CastUtils() {}
+
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/DefaultCastOptionsProvider.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/DefaultCastOptionsProvider.java
new file mode 100644
index 0000000000..ebadb0a08a
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/DefaultCastOptionsProvider.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import android.content.Context;
+import com.google.android.gms.cast.CastMediaControlIntent;
+import com.google.android.gms.cast.framework.CastOptions;
+import com.google.android.gms.cast.framework.OptionsProvider;
+import com.google.android.gms.cast.framework.SessionProvider;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A convenience {@link OptionsProvider} to target the default cast receiver app.
+ */
+public final class DefaultCastOptionsProvider implements OptionsProvider {
+
+ /**
+ * App id of the Default Media Receiver app. Apps that do not require DRM support may use this
+ * receiver receiver app ID.
+ *
+ * See https://developers.google.com/cast/docs/caf_receiver/#default_media_receiver.
+ */
+ public static final String APP_ID_DEFAULT_RECEIVER =
+ CastMediaControlIntent.DEFAULT_MEDIA_RECEIVER_APPLICATION_ID;
+
+ /**
+ * App id for receiver app with rudimentary support for DRM.
+ *
+ *
This app id is only suitable for ExoPlayer's Cast Demo app, and it is not intended for
+ * production use. In order to use DRM, custom receiver apps should be used. For environments that
+ * do not require DRM, the default receiver app should be used (see {@link
+ * #APP_ID_DEFAULT_RECEIVER}).
+ */
+ // TODO: Add a documentation resource link for DRM support in the receiver app [Internal ref:
+ // b/128603245].
+ public static final String APP_ID_DEFAULT_RECEIVER_WITH_DRM = "A12D4273";
+
+ @Override
+ public CastOptions getCastOptions(Context context) {
+ return new CastOptions.Builder()
+ .setReceiverApplicationId(APP_ID_DEFAULT_RECEIVER_WITH_DRM)
+ .setStopReceiverApplicationWhenEndingSession(true)
+ .build();
+ }
+
+ @Override
+ public List getAdditionalSessionProviders(Context context) {
+ return Collections.emptyList();
+ }
+
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/DefaultMediaItemConverter.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/DefaultMediaItemConverter.java
new file mode 100644
index 0000000000..098803a512
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/DefaultMediaItemConverter.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import android.net.Uri;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.ext.cast.MediaItem.DrmConfiguration;
+import com.google.android.gms.cast.MediaInfo;
+import com.google.android.gms.cast.MediaMetadata;
+import com.google.android.gms.cast.MediaQueueItem;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.UUID;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Default {@link MediaItemConverter} implementation. */
+public final class DefaultMediaItemConverter implements MediaItemConverter {
+
+ private static final String KEY_MEDIA_ITEM = "mediaItem";
+ private static final String KEY_PLAYER_CONFIG = "exoPlayerConfig";
+ private static final String KEY_URI = "uri";
+ private static final String KEY_TITLE = "title";
+ private static final String KEY_MIME_TYPE = "mimeType";
+ private static final String KEY_DRM_CONFIGURATION = "drmConfiguration";
+ private static final String KEY_UUID = "uuid";
+ private static final String KEY_LICENSE_URI = "licenseUri";
+ private static final String KEY_REQUEST_HEADERS = "requestHeaders";
+
+ @Override
+ public MediaItem toMediaItem(MediaQueueItem item) {
+ return getMediaItem(item.getMedia().getCustomData());
+ }
+
+ @Override
+ public MediaQueueItem toMediaQueueItem(MediaItem item) {
+ if (item.mimeType == null) {
+ throw new IllegalArgumentException("The item must specify its mimeType");
+ }
+ MediaMetadata metadata = new MediaMetadata(MediaMetadata.MEDIA_TYPE_MOVIE);
+ if (item.title != null) {
+ metadata.putString(MediaMetadata.KEY_TITLE, item.title);
+ }
+ MediaInfo mediaInfo =
+ new MediaInfo.Builder(item.uri.toString())
+ .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
+ .setContentType(item.mimeType)
+ .setMetadata(metadata)
+ .setCustomData(getCustomData(item))
+ .build();
+ return new MediaQueueItem.Builder(mediaInfo).build();
+ }
+
+ // Deserialization.
+
+ private static MediaItem getMediaItem(JSONObject customData) {
+ try {
+ JSONObject mediaItemJson = customData.getJSONObject(KEY_MEDIA_ITEM);
+ MediaItem.Builder builder = new MediaItem.Builder();
+ builder.setUri(Uri.parse(mediaItemJson.getString(KEY_URI)));
+ if (mediaItemJson.has(KEY_TITLE)) {
+ builder.setTitle(mediaItemJson.getString(KEY_TITLE));
+ }
+ if (mediaItemJson.has(KEY_MIME_TYPE)) {
+ builder.setMimeType(mediaItemJson.getString(KEY_MIME_TYPE));
+ }
+ if (mediaItemJson.has(KEY_DRM_CONFIGURATION)) {
+ builder.setDrmConfiguration(
+ getDrmConfiguration(mediaItemJson.getJSONObject(KEY_DRM_CONFIGURATION)));
+ }
+ return builder.build();
+ } catch (JSONException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static DrmConfiguration getDrmConfiguration(JSONObject json) throws JSONException {
+ UUID uuid = UUID.fromString(json.getString(KEY_UUID));
+ Uri licenseUri = Uri.parse(json.getString(KEY_LICENSE_URI));
+ JSONObject requestHeadersJson = json.getJSONObject(KEY_REQUEST_HEADERS);
+ HashMap requestHeaders = new HashMap<>();
+ for (Iterator iterator = requestHeadersJson.keys(); iterator.hasNext(); ) {
+ String key = iterator.next();
+ requestHeaders.put(key, requestHeadersJson.getString(key));
+ }
+ return new DrmConfiguration(uuid, licenseUri, requestHeaders);
+ }
+
+ // Serialization.
+
+ private static JSONObject getCustomData(MediaItem item) {
+ JSONObject json = new JSONObject();
+ try {
+ json.put(KEY_MEDIA_ITEM, getMediaItemJson(item));
+ JSONObject playerConfigJson = getPlayerConfigJson(item);
+ if (playerConfigJson != null) {
+ json.put(KEY_PLAYER_CONFIG, playerConfigJson);
+ }
+ } catch (JSONException e) {
+ throw new RuntimeException(e);
+ }
+ return json;
+ }
+
+ private static JSONObject getMediaItemJson(MediaItem item) throws JSONException {
+ JSONObject json = new JSONObject();
+ json.put(KEY_URI, item.uri.toString());
+ json.put(KEY_TITLE, item.title);
+ json.put(KEY_MIME_TYPE, item.mimeType);
+ if (item.drmConfiguration != null) {
+ json.put(KEY_DRM_CONFIGURATION, getDrmConfigurationJson(item.drmConfiguration));
+ }
+ return json;
+ }
+
+ private static JSONObject getDrmConfigurationJson(DrmConfiguration drmConfiguration)
+ throws JSONException {
+ JSONObject json = new JSONObject();
+ json.put(KEY_UUID, drmConfiguration.uuid);
+ json.put(KEY_LICENSE_URI, drmConfiguration.licenseUri);
+ json.put(KEY_REQUEST_HEADERS, new JSONObject(drmConfiguration.requestHeaders));
+ return json;
+ }
+
+ @Nullable
+ private static JSONObject getPlayerConfigJson(MediaItem item) throws JSONException {
+ DrmConfiguration drmConfiguration = item.drmConfiguration;
+ if (drmConfiguration == null) {
+ return null;
+ }
+
+ String drmScheme;
+ if (C.WIDEVINE_UUID.equals(drmConfiguration.uuid)) {
+ drmScheme = "widevine";
+ } else if (C.PLAYREADY_UUID.equals(drmConfiguration.uuid)) {
+ drmScheme = "playready";
+ } else {
+ return null;
+ }
+
+ JSONObject exoPlayerConfigJson = new JSONObject();
+ exoPlayerConfigJson.put("withCredentials", false);
+ exoPlayerConfigJson.put("protectionSystem", drmScheme);
+ if (drmConfiguration.licenseUri != null) {
+ exoPlayerConfigJson.put("licenseUrl", drmConfiguration.licenseUri);
+ }
+ if (!drmConfiguration.requestHeaders.isEmpty()) {
+ exoPlayerConfigJson.put("headers", new JSONObject(drmConfiguration.requestHeaders));
+ }
+
+ return exoPlayerConfigJson;
+ }
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/MediaItem.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/MediaItem.java
new file mode 100644
index 0000000000..7ac0da7078
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/MediaItem.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import android.net.Uri;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.util.Assertions;
+import com.google.android.exoplayer2.util.Util;
+import java.util.Collections;
+import java.util.Map;
+import java.util.UUID;
+
+/** Representation of a media item. */
+public final class MediaItem {
+
+ /** A builder for {@link MediaItem} instances. */
+ public static final class Builder {
+
+ @Nullable private Uri uri;
+ @Nullable private String title;
+ @Nullable private String mimeType;
+ @Nullable private DrmConfiguration drmConfiguration;
+
+ /** See {@link MediaItem#uri}. */
+ public Builder setUri(String uri) {
+ return setUri(Uri.parse(uri));
+ }
+
+ /** See {@link MediaItem#uri}. */
+ public Builder setUri(Uri uri) {
+ this.uri = uri;
+ return this;
+ }
+
+ /** See {@link MediaItem#title}. */
+ public Builder setTitle(String title) {
+ this.title = title;
+ return this;
+ }
+
+ /** See {@link MediaItem#mimeType}. */
+ public Builder setMimeType(String mimeType) {
+ this.mimeType = mimeType;
+ return this;
+ }
+
+ /** See {@link MediaItem#drmConfiguration}. */
+ public Builder setDrmConfiguration(DrmConfiguration drmConfiguration) {
+ this.drmConfiguration = drmConfiguration;
+ return this;
+ }
+
+ /** Returns a new {@link MediaItem} instance with the current builder values. */
+ public MediaItem build() {
+ Assertions.checkNotNull(uri);
+ return new MediaItem(uri, title, mimeType, drmConfiguration);
+ }
+ }
+
+ /** DRM configuration for a media item. */
+ public static final class DrmConfiguration {
+
+ /** The UUID of the protection scheme. */
+ public final UUID uuid;
+
+ /**
+ * Optional license server {@link Uri}. If {@code null} then the license server must be
+ * specified by the media.
+ */
+ @Nullable public final Uri licenseUri;
+
+ /** Headers that should be attached to any license requests. */
+ public final Map requestHeaders;
+
+ /**
+ * Creates an instance.
+ *
+ * @param uuid See {@link #uuid}.
+ * @param licenseUri See {@link #licenseUri}.
+ * @param requestHeaders See {@link #requestHeaders}.
+ */
+ public DrmConfiguration(
+ UUID uuid, @Nullable Uri licenseUri, @Nullable Map requestHeaders) {
+ this.uuid = uuid;
+ this.licenseUri = licenseUri;
+ this.requestHeaders =
+ requestHeaders == null
+ ? Collections.emptyMap()
+ : Collections.unmodifiableMap(requestHeaders);
+ }
+
+ @Override
+ public boolean equals(@Nullable Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null || getClass() != obj.getClass()) {
+ return false;
+ }
+
+ DrmConfiguration other = (DrmConfiguration) obj;
+ return uuid.equals(other.uuid)
+ && Util.areEqual(licenseUri, other.licenseUri)
+ && requestHeaders.equals(other.requestHeaders);
+ }
+
+ @Override
+ public int hashCode() {
+ int result = uuid.hashCode();
+ result = 31 * result + (licenseUri != null ? licenseUri.hashCode() : 0);
+ result = 31 * result + requestHeaders.hashCode();
+ return result;
+ }
+ }
+
+ /** The media {@link Uri}. */
+ public final Uri uri;
+
+ /** The title of the item, or {@code null} if unspecified. */
+ @Nullable public final String title;
+
+ /** The mime type for the media, or {@code null} if unspecified. */
+ @Nullable public final String mimeType;
+
+ /** Optional {@link DrmConfiguration} for the media. */
+ @Nullable public final DrmConfiguration drmConfiguration;
+
+ private MediaItem(
+ Uri uri,
+ @Nullable String title,
+ @Nullable String mimeType,
+ @Nullable DrmConfiguration drmConfiguration) {
+ this.uri = uri;
+ this.title = title;
+ this.mimeType = mimeType;
+ this.drmConfiguration = drmConfiguration;
+ }
+
+ @Override
+ public boolean equals(@Nullable Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null || getClass() != obj.getClass()) {
+ return false;
+ }
+ MediaItem other = (MediaItem) obj;
+ return uri.equals(other.uri)
+ && Util.areEqual(title, other.title)
+ && Util.areEqual(mimeType, other.mimeType)
+ && Util.areEqual(drmConfiguration, other.drmConfiguration);
+ }
+
+ @Override
+ public int hashCode() {
+ int result = uri.hashCode();
+ result = 31 * result + (title == null ? 0 : title.hashCode());
+ result = 31 * result + (drmConfiguration == null ? 0 : drmConfiguration.hashCode());
+ result = 31 * result + (mimeType == null ? 0 : mimeType.hashCode());
+ return result;
+ }
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/MediaItemConverter.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/MediaItemConverter.java
new file mode 100644
index 0000000000..23633aa4d2
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/MediaItemConverter.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import com.google.android.gms.cast.MediaQueueItem;
+
+/** Converts between {@link MediaItem} and the Cast SDK's {@link MediaQueueItem}. */
+public interface MediaItemConverter {
+
+ /**
+ * Converts a {@link MediaItem} to a {@link MediaQueueItem}.
+ *
+ * @param mediaItem The {@link MediaItem}.
+ * @return An equivalent {@link MediaQueueItem}.
+ */
+ MediaQueueItem toMediaQueueItem(MediaItem mediaItem);
+
+ /**
+ * Converts a {@link MediaQueueItem} to a {@link MediaItem}.
+ *
+ * @param mediaQueueItem The {@link MediaQueueItem}.
+ * @return The equivalent {@link MediaItem}.
+ */
+ MediaItem toMediaItem(MediaQueueItem mediaQueueItem);
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/SessionAvailabilityListener.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/SessionAvailabilityListener.java
new file mode 100644
index 0000000000..c686c496c6
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/SessionAvailabilityListener.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+/** Listener of changes in the cast session availability. */
+public interface SessionAvailabilityListener {
+
+ /** Called when a cast session becomes available to the player. */
+ void onCastSessionAvailable();
+
+ /** Called when the cast session becomes unavailable. */
+ void onCastSessionUnavailable();
+}
diff --git a/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/package-info.java b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/package-info.java
new file mode 100644
index 0000000000..07055905a6
--- /dev/null
+++ b/extensions/cast/src/main/java/com/google/android/exoplayer2/ext/cast/package-info.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@NonNullApi
+package com.google.android.exoplayer2.ext.cast;
+
+import com.google.android.exoplayer2.util.NonNullApi;
diff --git a/extensions/cast/src/test/AndroidManifest.xml b/extensions/cast/src/test/AndroidManifest.xml
new file mode 100644
index 0000000000..35a5150a47
--- /dev/null
+++ b/extensions/cast/src/test/AndroidManifest.xml
@@ -0,0 +1,19 @@
+
+
+
+
+
+
diff --git a/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/CastPlayerTest.java b/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/CastPlayerTest.java
new file mode 100644
index 0000000000..1346c1f842
--- /dev/null
+++ b/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/CastPlayerTest.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.exoplayer2.Player;
+import com.google.android.gms.cast.MediaStatus;
+import com.google.android.gms.cast.framework.CastContext;
+import com.google.android.gms.cast.framework.CastSession;
+import com.google.android.gms.cast.framework.SessionManager;
+import com.google.android.gms.cast.framework.media.MediaQueue;
+import com.google.android.gms.cast.framework.media.RemoteMediaClient;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.ResultCallback;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+
+/** Tests for {@link CastPlayer}. */
+@RunWith(AndroidJUnit4.class)
+public class CastPlayerTest {
+
+ private CastPlayer castPlayer;
+ private RemoteMediaClient.Listener remoteMediaClientListener;
+ @Mock private RemoteMediaClient mockRemoteMediaClient;
+ @Mock private MediaStatus mockMediaStatus;
+ @Mock private MediaQueue mockMediaQueue;
+ @Mock private CastContext mockCastContext;
+ @Mock private SessionManager mockSessionManager;
+ @Mock private CastSession mockCastSession;
+ @Mock private Player.EventListener mockListener;
+ @Mock private PendingResult mockPendingResult;
+
+ @Captor
+ private ArgumentCaptor>
+ setResultCallbackArgumentCaptor;
+
+ @Captor private ArgumentCaptor listenerArgumentCaptor;
+
+ @Before
+ public void setUp() {
+ initMocks(this);
+ when(mockCastContext.getSessionManager()).thenReturn(mockSessionManager);
+ when(mockSessionManager.getCurrentCastSession()).thenReturn(mockCastSession);
+ when(mockCastSession.getRemoteMediaClient()).thenReturn(mockRemoteMediaClient);
+ when(mockRemoteMediaClient.getMediaStatus()).thenReturn(mockMediaStatus);
+ when(mockRemoteMediaClient.getMediaQueue()).thenReturn(mockMediaQueue);
+ when(mockMediaQueue.getItemIds()).thenReturn(new int[0]);
+ // Make the remote media client present the same default values as ExoPlayer:
+ when(mockRemoteMediaClient.isPaused()).thenReturn(true);
+ when(mockMediaStatus.getQueueRepeatMode()).thenReturn(MediaStatus.REPEAT_MODE_REPEAT_OFF);
+ castPlayer = new CastPlayer(mockCastContext);
+ castPlayer.addListener(mockListener);
+ verify(mockRemoteMediaClient).addListener(listenerArgumentCaptor.capture());
+ remoteMediaClientListener = listenerArgumentCaptor.getValue();
+ }
+
+ @Test
+ public void testSetPlayWhenReady_masksRemoteState() {
+ when(mockRemoteMediaClient.play()).thenReturn(mockPendingResult);
+ assertThat(castPlayer.getPlayWhenReady()).isFalse();
+
+ castPlayer.play();
+ verify(mockPendingResult).setResultCallback(setResultCallbackArgumentCaptor.capture());
+ assertThat(castPlayer.getPlayWhenReady()).isTrue();
+ verify(mockListener).onPlayerStateChanged(true, Player.STATE_IDLE);
+
+ // There is a status update in the middle, which should be hidden by masking.
+ remoteMediaClientListener.onStatusUpdated();
+ verifyNoMoreInteractions(mockListener);
+
+ // Upon result, the remoteMediaClient has updated its state according to the play() call.
+ when(mockRemoteMediaClient.isPaused()).thenReturn(false);
+ setResultCallbackArgumentCaptor
+ .getValue()
+ .onResult(Mockito.mock(RemoteMediaClient.MediaChannelResult.class));
+ verifyNoMoreInteractions(mockListener);
+ }
+
+ @Test
+ public void testSetPlayWhenReadyMasking_updatesUponResultChange() {
+ when(mockRemoteMediaClient.play()).thenReturn(mockPendingResult);
+ assertThat(castPlayer.getPlayWhenReady()).isFalse();
+
+ castPlayer.play();
+ verify(mockPendingResult).setResultCallback(setResultCallbackArgumentCaptor.capture());
+ assertThat(castPlayer.getPlayWhenReady()).isTrue();
+ verify(mockListener).onPlayerStateChanged(true, Player.STATE_IDLE);
+
+ // Upon result, the remote media client is still paused. The state should reflect that.
+ setResultCallbackArgumentCaptor
+ .getValue()
+ .onResult(Mockito.mock(RemoteMediaClient.MediaChannelResult.class));
+ verify(mockListener).onPlayerStateChanged(false, Player.STATE_IDLE);
+ assertThat(castPlayer.getPlayWhenReady()).isFalse();
+ }
+
+ @Test
+ public void testPlayWhenReady_changesOnStatusUpdates() {
+ assertThat(castPlayer.getPlayWhenReady()).isFalse();
+ when(mockRemoteMediaClient.isPaused()).thenReturn(false);
+ remoteMediaClientListener.onStatusUpdated();
+ verify(mockListener).onPlayerStateChanged(true, Player.STATE_IDLE);
+ assertThat(castPlayer.getPlayWhenReady()).isTrue();
+ }
+
+ @Test
+ public void testSetRepeatMode_masksRemoteState() {
+ when(mockRemoteMediaClient.queueSetRepeatMode(anyInt(), any())).thenReturn(mockPendingResult);
+ assertThat(castPlayer.getRepeatMode()).isEqualTo(Player.REPEAT_MODE_OFF);
+
+ castPlayer.setRepeatMode(Player.REPEAT_MODE_ONE);
+ verify(mockPendingResult).setResultCallback(setResultCallbackArgumentCaptor.capture());
+ assertThat(castPlayer.getRepeatMode()).isEqualTo(Player.REPEAT_MODE_ONE);
+ verify(mockListener).onRepeatModeChanged(Player.REPEAT_MODE_ONE);
+
+ // There is a status update in the middle, which should be hidden by masking.
+ when(mockMediaStatus.getQueueRepeatMode()).thenReturn(MediaStatus.REPEAT_MODE_REPEAT_ALL);
+ remoteMediaClientListener.onStatusUpdated();
+ verifyNoMoreInteractions(mockListener);
+
+ // Upon result, the mediaStatus now exposes the new repeat mode.
+ when(mockMediaStatus.getQueueRepeatMode()).thenReturn(MediaStatus.REPEAT_MODE_REPEAT_SINGLE);
+ setResultCallbackArgumentCaptor
+ .getValue()
+ .onResult(Mockito.mock(RemoteMediaClient.MediaChannelResult.class));
+ verifyNoMoreInteractions(mockListener);
+ }
+
+ @Test
+ public void testSetRepeatMode_updatesUponResultChange() {
+ when(mockRemoteMediaClient.queueSetRepeatMode(anyInt(), any())).thenReturn(mockPendingResult);
+
+ castPlayer.setRepeatMode(Player.REPEAT_MODE_ONE);
+ verify(mockPendingResult).setResultCallback(setResultCallbackArgumentCaptor.capture());
+ assertThat(castPlayer.getRepeatMode()).isEqualTo(Player.REPEAT_MODE_ONE);
+ verify(mockListener).onRepeatModeChanged(Player.REPEAT_MODE_ONE);
+
+ // There is a status update in the middle, which should be hidden by masking.
+ when(mockMediaStatus.getQueueRepeatMode()).thenReturn(MediaStatus.REPEAT_MODE_REPEAT_ALL);
+ remoteMediaClientListener.onStatusUpdated();
+ verifyNoMoreInteractions(mockListener);
+
+ // Upon result, the repeat mode is ALL. The state should reflect that.
+ setResultCallbackArgumentCaptor
+ .getValue()
+ .onResult(Mockito.mock(RemoteMediaClient.MediaChannelResult.class));
+ verify(mockListener).onRepeatModeChanged(Player.REPEAT_MODE_ALL);
+ assertThat(castPlayer.getRepeatMode()).isEqualTo(Player.REPEAT_MODE_ALL);
+ }
+
+ @Test
+ public void testRepeatMode_changesOnStatusUpdates() {
+ assertThat(castPlayer.getRepeatMode()).isEqualTo(Player.REPEAT_MODE_OFF);
+ when(mockMediaStatus.getQueueRepeatMode()).thenReturn(MediaStatus.REPEAT_MODE_REPEAT_SINGLE);
+ remoteMediaClientListener.onStatusUpdated();
+ verify(mockListener).onRepeatModeChanged(Player.REPEAT_MODE_ONE);
+ assertThat(castPlayer.getRepeatMode()).isEqualTo(Player.REPEAT_MODE_ONE);
+ }
+}
diff --git a/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/CastTimelineTrackerTest.java b/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/CastTimelineTrackerTest.java
new file mode 100644
index 0000000000..69b25e4456
--- /dev/null
+++ b/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/CastTimelineTrackerTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.testutil.TimelineAsserts;
+import com.google.android.exoplayer2.util.MimeTypes;
+import com.google.android.gms.cast.MediaInfo;
+import com.google.android.gms.cast.MediaStatus;
+import com.google.android.gms.cast.framework.media.MediaQueue;
+import com.google.android.gms.cast.framework.media.RemoteMediaClient;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+
+/** Tests for {@link CastTimelineTracker}. */
+@RunWith(AndroidJUnit4.class)
+public class CastTimelineTrackerTest {
+
+ private static final long DURATION_2_MS = 2000;
+ private static final long DURATION_3_MS = 3000;
+ private static final long DURATION_4_MS = 4000;
+ private static final long DURATION_5_MS = 5000;
+
+ /** Tests that duration of the current media info is correctly propagated to the timeline. */
+ @Test
+ public void testGetCastTimelinePersistsDuration() {
+ CastTimelineTracker tracker = new CastTimelineTracker();
+
+ RemoteMediaClient remoteMediaClient =
+ mockRemoteMediaClient(
+ /* itemIds= */ new int[] {1, 2, 3, 4, 5},
+ /* currentItemId= */ 2,
+ /* currentDurationMs= */ DURATION_2_MS);
+ TimelineAsserts.assertPeriodDurations(
+ tracker.getCastTimeline(remoteMediaClient),
+ C.TIME_UNSET,
+ C.msToUs(DURATION_2_MS),
+ C.TIME_UNSET,
+ C.TIME_UNSET,
+ C.TIME_UNSET);
+
+ remoteMediaClient =
+ mockRemoteMediaClient(
+ /* itemIds= */ new int[] {1, 2, 3},
+ /* currentItemId= */ 3,
+ /* currentDurationMs= */ DURATION_3_MS);
+ TimelineAsserts.assertPeriodDurations(
+ tracker.getCastTimeline(remoteMediaClient),
+ C.TIME_UNSET,
+ C.msToUs(DURATION_2_MS),
+ C.msToUs(DURATION_3_MS));
+
+ remoteMediaClient =
+ mockRemoteMediaClient(
+ /* itemIds= */ new int[] {1, 3},
+ /* currentItemId= */ 3,
+ /* currentDurationMs= */ DURATION_3_MS);
+ TimelineAsserts.assertPeriodDurations(
+ tracker.getCastTimeline(remoteMediaClient), C.TIME_UNSET, C.msToUs(DURATION_3_MS));
+
+ remoteMediaClient =
+ mockRemoteMediaClient(
+ /* itemIds= */ new int[] {1, 2, 3, 4, 5},
+ /* currentItemId= */ 4,
+ /* currentDurationMs= */ DURATION_4_MS);
+ TimelineAsserts.assertPeriodDurations(
+ tracker.getCastTimeline(remoteMediaClient),
+ C.TIME_UNSET,
+ C.TIME_UNSET,
+ C.msToUs(DURATION_3_MS),
+ C.msToUs(DURATION_4_MS),
+ C.TIME_UNSET);
+
+ remoteMediaClient =
+ mockRemoteMediaClient(
+ /* itemIds= */ new int[] {1, 2, 3, 4, 5},
+ /* currentItemId= */ 5,
+ /* currentDurationMs= */ DURATION_5_MS);
+ TimelineAsserts.assertPeriodDurations(
+ tracker.getCastTimeline(remoteMediaClient),
+ C.TIME_UNSET,
+ C.TIME_UNSET,
+ C.msToUs(DURATION_3_MS),
+ C.msToUs(DURATION_4_MS),
+ C.msToUs(DURATION_5_MS));
+ }
+
+ private static RemoteMediaClient mockRemoteMediaClient(
+ int[] itemIds, int currentItemId, long currentDurationMs) {
+ RemoteMediaClient remoteMediaClient = Mockito.mock(RemoteMediaClient.class);
+ MediaStatus status = Mockito.mock(MediaStatus.class);
+ Mockito.when(status.getQueueItems()).thenReturn(Collections.emptyList());
+ Mockito.when(remoteMediaClient.getMediaStatus()).thenReturn(status);
+ Mockito.when(status.getMediaInfo()).thenReturn(getMediaInfo(currentDurationMs));
+ Mockito.when(status.getCurrentItemId()).thenReturn(currentItemId);
+ MediaQueue mediaQueue = mockMediaQueue(itemIds);
+ Mockito.when(remoteMediaClient.getMediaQueue()).thenReturn(mediaQueue);
+ return remoteMediaClient;
+ }
+
+ private static MediaQueue mockMediaQueue(int[] itemIds) {
+ MediaQueue mediaQueue = Mockito.mock(MediaQueue.class);
+ Mockito.when(mediaQueue.getItemIds()).thenReturn(itemIds);
+ return mediaQueue;
+ }
+
+ private static MediaInfo getMediaInfo(long durationMs) {
+ return new MediaInfo.Builder(/*contentId= */ "")
+ .setStreamDuration(durationMs)
+ .setContentType(MimeTypes.APPLICATION_MP4)
+ .setStreamType(MediaInfo.STREAM_TYPE_NONE)
+ .build();
+ }
+}
diff --git a/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/DefaultMediaItemConverterTest.java b/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/DefaultMediaItemConverterTest.java
new file mode 100644
index 0000000000..cf9b9d3496
--- /dev/null
+++ b/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/DefaultMediaItemConverterTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.net.Uri;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.ext.cast.MediaItem.DrmConfiguration;
+import com.google.android.gms.cast.MediaQueueItem;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Test for {@link DefaultMediaItemConverter}. */
+@RunWith(AndroidJUnit4.class)
+public class DefaultMediaItemConverterTest {
+
+ @Test
+ public void serialize_deserialize_minimal() {
+ MediaItem.Builder builder = new MediaItem.Builder();
+ MediaItem item = builder.setUri(Uri.parse("http://example.com")).setMimeType("mime").build();
+
+ DefaultMediaItemConverter converter = new DefaultMediaItemConverter();
+ MediaQueueItem queueItem = converter.toMediaQueueItem(item);
+ MediaItem reconstructedItem = converter.toMediaItem(queueItem);
+
+ assertThat(reconstructedItem).isEqualTo(item);
+ }
+
+ @Test
+ public void serialize_deserialize_complete() {
+ MediaItem.Builder builder = new MediaItem.Builder();
+ MediaItem item =
+ builder
+ .setUri(Uri.parse("http://example.com"))
+ .setTitle("title")
+ .setMimeType("mime")
+ .setDrmConfiguration(
+ new DrmConfiguration(
+ C.WIDEVINE_UUID,
+ Uri.parse("http://license.com"),
+ Collections.singletonMap("key", "value")))
+ .build();
+
+ DefaultMediaItemConverter converter = new DefaultMediaItemConverter();
+ MediaQueueItem queueItem = converter.toMediaQueueItem(item);
+ MediaItem reconstructedItem = converter.toMediaItem(queueItem);
+
+ assertThat(reconstructedItem).isEqualTo(item);
+ }
+}
diff --git a/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/MediaItemTest.java b/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/MediaItemTest.java
new file mode 100644
index 0000000000..7b410a8fbc
--- /dev/null
+++ b/extensions/cast/src/test/java/com/google/android/exoplayer2/ext/cast/MediaItemTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.ext.cast;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.net.Uri;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.util.MimeTypes;
+import java.util.HashMap;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Test for {@link MediaItem}. */
+@RunWith(AndroidJUnit4.class)
+public class MediaItemTest {
+
+ @Test
+ public void buildMediaItem_doesNotChangeState() {
+ MediaItem.Builder builder = new MediaItem.Builder();
+ MediaItem item1 =
+ builder
+ .setUri(Uri.parse("http://example.com"))
+ .setTitle("title")
+ .setMimeType(MimeTypes.AUDIO_MP4)
+ .build();
+ MediaItem item2 = builder.build();
+ assertThat(item1).isEqualTo(item2);
+ }
+
+ @Test
+ public void equals_withEqualDrmSchemes_returnsTrue() {
+ MediaItem.Builder builder1 = new MediaItem.Builder();
+ MediaItem mediaItem1 =
+ builder1
+ .setUri(Uri.parse("www.google.com"))
+ .setDrmConfiguration(buildDrmConfiguration(1))
+ .build();
+ MediaItem.Builder builder2 = new MediaItem.Builder();
+ MediaItem mediaItem2 =
+ builder2
+ .setUri(Uri.parse("www.google.com"))
+ .setDrmConfiguration(buildDrmConfiguration(1))
+ .build();
+ assertThat(mediaItem1).isEqualTo(mediaItem2);
+ }
+
+ @Test
+ public void equals_withDifferentDrmRequestHeaders_returnsFalse() {
+ MediaItem.Builder builder1 = new MediaItem.Builder();
+ MediaItem mediaItem1 =
+ builder1
+ .setUri(Uri.parse("www.google.com"))
+ .setDrmConfiguration(buildDrmConfiguration(1))
+ .build();
+ MediaItem.Builder builder2 = new MediaItem.Builder();
+ MediaItem mediaItem2 =
+ builder2
+ .setUri(Uri.parse("www.google.com"))
+ .setDrmConfiguration(buildDrmConfiguration(2))
+ .build();
+ assertThat(mediaItem1).isNotEqualTo(mediaItem2);
+ }
+
+ private static MediaItem.DrmConfiguration buildDrmConfiguration(int seed) {
+ HashMap requestHeaders = new HashMap<>();
+ requestHeaders.put("key1", "value1");
+ requestHeaders.put("key2", "value2" + seed);
+ return new MediaItem.DrmConfiguration(
+ C.WIDEVINE_UUID, Uri.parse("www.uri1.com"), requestHeaders);
+ }
+}
diff --git a/extensions/cronet/README.md b/extensions/cronet/README.md
index a570385a52..dc64b862b6 100644
--- a/extensions/cronet/README.md
+++ b/extensions/cronet/README.md
@@ -1,32 +1,55 @@
-# ExoPlayer Cronet Extension #
+# ExoPlayer Cronet extension #
-## Description ##
+The Cronet extension is an [HttpDataSource][] implementation using [Cronet][].
-[Cronet][] is Chromium's Networking stack packaged as a library.
-
-The Cronet Extension is an [HttpDataSource][] implementation using [Cronet][].
-
-[HttpDataSource]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer/upstream/HttpDataSource.html
+[HttpDataSource]: https://exoplayer.dev/doc/reference/com/google/android/exoplayer2/upstream/HttpDataSource.html
[Cronet]: https://chromium.googlesource.com/chromium/src/+/master/components/cronet?autodive=0%2F%2F
-## Build Instructions ##
+## Getting the extension ##
-* Checkout ExoPlayer along with Extensions:
+The easiest way to use the extension is to add it as a gradle dependency:
-```
-git clone https://github.com/google/ExoPlayer.git
+```gradle
+implementation 'com.google.android.exoplayer:extension-cronet:2.X.X'
```
-* Get the Cronet libraries:
+where `2.X.X` is the version, which must match the version of the ExoPlayer
+library being used.
-1. Find the latest Cronet release [here][] and navigate to its `Release/cronet`
- directory
-1. Download `cronet_api.jar`, `cronet_impl_common_java.jar`,
- `cronet_impl_native_java.jar` and the `libs` directory
-1. Copy the three jar files into the `libs` directory of this extension
-1. Copy the content of the downloaded `libs` directory into the `jniLibs`
- directory of this extension
+Alternatively, you can clone the ExoPlayer repository and depend on the module
+locally. Instructions for doing this can be found in ExoPlayer's
+[top level README][].
-* In ExoPlayer's `settings.gradle` file, uncomment the Cronet extension
+[top level README]: https://github.com/google/ExoPlayer/blob/release-v2/README.md
-[here]: https://console.cloud.google.com/storage/browser/chromium-cronet/android
+## Using the extension ##
+
+ExoPlayer requests data through `DataSource` instances. These instances are
+either instantiated and injected from application code, or obtained from
+instances of `DataSource.Factory` that are instantiated and injected from
+application code.
+
+If your application only needs to play http(s) content, using the Cronet
+extension is as simple as updating any `DataSource`s and `DataSource.Factory`
+instantiations in your application code to use `CronetDataSource` and
+`CronetDataSourceFactory` respectively. If your application also needs to play
+non-http(s) content such as local files, use
+```
+new DefaultDataSource(
+ ...
+ new CronetDataSource(...) /* baseDataSource argument */);
+```
+and
+```
+new DefaultDataSourceFactory(
+ ...
+ new CronetDataSourceFactory(...) /* baseDataSourceFactory argument */);
+```
+respectively.
+
+## Links ##
+
+* [Javadoc][]: Classes matching `com.google.android.exoplayer2.ext.cronet.*`
+ belong to this module.
+
+[Javadoc]: https://exoplayer.dev/doc/reference/index.html
diff --git a/extensions/cronet/build.gradle b/extensions/cronet/build.gradle
index 5611817b2e..d5b7a99f96 100644
--- a/extensions/cronet/build.gradle
+++ b/extensions/cronet/build.gradle
@@ -11,36 +11,42 @@
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
+apply from: '../../constants.gradle'
apply plugin: 'com.android.library'
android {
compileSdkVersion project.ext.compileSdkVersion
- buildToolsVersion project.ext.buildToolsVersion
defaultConfig {
minSdkVersion project.ext.minSdkVersion
targetSdkVersion project.ext.targetSdkVersion
- testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
- sourceSets.main {
- jniLibs.srcDirs = ['jniLibs']
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_8
+ targetCompatibility JavaVersion.VERSION_1_8
}
+
+ testOptions.unitTests.includeAndroidResources = true
}
dependencies {
- compile project(':library-core')
- compile files('libs/cronet_api.jar')
- compile files('libs/cronet_impl_common_java.jar')
- compile files('libs/cronet_impl_native_java.jar')
- androidTestCompile project(':library')
- androidTestCompile 'com.google.dexmaker:dexmaker:' + dexmakerVersion
- androidTestCompile 'com.google.dexmaker:dexmaker-mockito:' + dexmakerVersion
- androidTestCompile 'org.mockito:mockito-core:' + mockitoVersion
- androidTestCompile 'com.android.support.test:runner:' + testSupportLibraryVersion
+ api 'org.chromium.net:cronet-embedded:76.3809.111'
+ implementation project(modulePrefix + 'library-core')
+ implementation 'androidx.annotation:annotation:' + androidxAnnotationVersion
+ compileOnly 'org.checkerframework:checker-qual:' + checkerframeworkVersion
+ testImplementation project(modulePrefix + 'library')
+ testImplementation project(modulePrefix + 'testutils')
+ testImplementation 'org.robolectric:robolectric:' + robolectricVersion
}
ext {
javadocTitle = 'Cronet extension'
}
apply from: '../../javadoc_library.gradle'
+
+ext {
+ releaseArtifact = 'extension-cronet'
+ releaseDescription = 'Cronet extension for ExoPlayer.'
+}
+apply from: '../../publish.gradle'
diff --git a/extensions/cronet/jniLibs/README.md b/extensions/cronet/jniLibs/README.md
deleted file mode 100644
index e9f0717ae6..0000000000
--- a/extensions/cronet/jniLibs/README.md
+++ /dev/null
@@ -1 +0,0 @@
-Copy folders containing architecture specific .so files here.
diff --git a/extensions/cronet/libs/README.md b/extensions/cronet/libs/README.md
deleted file mode 100644
index 641a80db18..0000000000
--- a/extensions/cronet/libs/README.md
+++ /dev/null
@@ -1 +0,0 @@
-Copy cronet.jar and cronet_api.jar here.
diff --git a/extensions/cronet/src/androidTest/java/com/google/android/exoplayer2/ext/cronet/CronetDataSourceTest.java b/extensions/cronet/src/androidTest/java/com/google/android/exoplayer2/ext/cronet/CronetDataSourceTest.java
deleted file mode 100644
index 246e23e172..0000000000
--- a/extensions/cronet/src/androidTest/java/com/google/android/exoplayer2/ext/cronet/CronetDataSourceTest.java
+++ /dev/null
@@ -1,809 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.android.exoplayer2.ext.cronet;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import android.net.Uri;
-import android.os.ConditionVariable;
-import android.support.test.InstrumentationRegistry;
-import android.support.test.runner.AndroidJUnit4;
-import com.google.android.exoplayer2.C;
-import com.google.android.exoplayer2.upstream.DataSpec;
-import com.google.android.exoplayer2.upstream.HttpDataSource;
-import com.google.android.exoplayer2.upstream.HttpDataSource.HttpDataSourceException;
-import com.google.android.exoplayer2.upstream.TransferListener;
-import com.google.android.exoplayer2.util.Clock;
-import com.google.android.exoplayer2.util.Predicate;
-import java.io.IOException;
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.Executor;
-import java.util.concurrent.atomic.AtomicInteger;
-import org.chromium.net.CronetEngine;
-import org.chromium.net.NetworkException;
-import org.chromium.net.UrlRequest;
-import org.chromium.net.UrlResponseInfo;
-import org.chromium.net.impl.UrlResponseInfoImpl;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/**
- * Tests for {@link CronetDataSource}.
- */
-@RunWith(AndroidJUnit4.class)
-public final class CronetDataSourceTest {
-
- private static final int TEST_CONNECT_TIMEOUT_MS = 100;
- private static final int TEST_READ_TIMEOUT_MS = 50;
- private static final String TEST_URL = "http://google.com";
- private static final String TEST_CONTENT_TYPE = "test/test";
- private static final byte[] TEST_POST_BODY = "test post body".getBytes();
- private static final long TEST_CONTENT_LENGTH = 16000L;
- private static final int TEST_CONNECTION_STATUS = 5;
-
- private DataSpec testDataSpec;
- private DataSpec testPostDataSpec;
- private Map testResponseHeader;
- private UrlResponseInfo testUrlResponseInfo;
-
- @Mock private UrlRequest.Builder mockUrlRequestBuilder;
- @Mock
- private UrlRequest mockUrlRequest;
- @Mock
- private Predicate mockContentTypePredicate;
- @Mock
- private TransferListener mockTransferListener;
- @Mock
- private Clock mockClock;
- @Mock
- private Executor mockExecutor;
- @Mock
- private NetworkException mockNetworkException;
- @Mock private CronetEngine mockCronetEngine;
-
- private CronetDataSource dataSourceUnderTest;
-
- @Before
- public void setUp() throws Exception {
- System.setProperty("dexmaker.dexcache",
- InstrumentationRegistry.getTargetContext().getCacheDir().getPath());
- initMocks(this);
- dataSourceUnderTest = spy(
- new CronetDataSource(
- mockCronetEngine,
- mockExecutor,
- mockContentTypePredicate,
- mockTransferListener,
- TEST_CONNECT_TIMEOUT_MS,
- TEST_READ_TIMEOUT_MS,
- true, // resetTimeoutOnRedirects
- mockClock,
- null));
- when(mockContentTypePredicate.evaluate(anyString())).thenReturn(true);
- when(mockCronetEngine.newUrlRequestBuilder(
- anyString(), any(UrlRequest.Callback.class), any(Executor.class)))
- .thenReturn(mockUrlRequestBuilder);
- when(mockUrlRequestBuilder.build()).thenReturn(mockUrlRequest);
- mockStatusResponse();
-
- testDataSpec = new DataSpec(Uri.parse(TEST_URL), 0, C.LENGTH_UNSET, null);
- testPostDataSpec = new DataSpec(
- Uri.parse(TEST_URL), TEST_POST_BODY, 0, 0, C.LENGTH_UNSET, null, 0);
- testResponseHeader = new HashMap<>();
- testResponseHeader.put("Content-Type", TEST_CONTENT_TYPE);
- // This value can be anything since the DataSpec is unset.
- testResponseHeader.put("Content-Length", Long.toString(TEST_CONTENT_LENGTH));
- testUrlResponseInfo = createUrlResponseInfo(200); // statusCode
- }
-
- private UrlResponseInfo createUrlResponseInfo(int statusCode) {
- ArrayList> responseHeaderList = new ArrayList<>();
- responseHeaderList.addAll(testResponseHeader.entrySet());
- return new UrlResponseInfoImpl(
- Collections.singletonList(TEST_URL),
- statusCode,
- null, // httpStatusText
- responseHeaderList,
- false, // wasCached
- null, // negotiatedProtocol
- null); // proxyServer
- }
-
- @Test(expected = IllegalStateException.class)
- public void testOpeningTwiceThrows() throws HttpDataSourceException {
- mockResponseStartSuccess();
- dataSourceUnderTest.open(testDataSpec);
- dataSourceUnderTest.open(testDataSpec);
- }
-
- @Test
- public void testCallbackFromPreviousRequest() throws HttpDataSourceException {
- mockResponseStartSuccess();
-
- dataSourceUnderTest.open(testDataSpec);
- dataSourceUnderTest.close();
- // Prepare a mock UrlRequest to be used in the second open() call.
- final UrlRequest mockUrlRequest2 = mock(UrlRequest.class);
- when(mockUrlRequestBuilder.build()).thenReturn(mockUrlRequest2);
- doAnswer(new Answer