diff options
Diffstat (limited to 'core/src/play/java')
11 files changed, 3619 insertions, 0 deletions
diff --git a/core/src/play/java/de/danoeh/antennapod/core/CastCallbacks.java b/core/src/play/java/de/danoeh/antennapod/core/CastCallbacks.java new file mode 100644 index 000000000..770fee9b9 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/CastCallbacks.java @@ -0,0 +1,12 @@ +package de.danoeh.antennapod.core; + +import android.support.annotation.Nullable; +import android.support.v7.app.MediaRouteDialogFactory; + +/** + * Callbacks for Chromecast support on the core module + */ +public interface CastCallbacks { + + @Nullable MediaRouteDialogFactory getMediaRouterDialogFactory(); +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/ClientConfig.java b/core/src/play/java/de/danoeh/antennapod/core/ClientConfig.java new file mode 100644 index 000000000..9af76cf86 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/ClientConfig.java @@ -0,0 +1,54 @@ +package de.danoeh.antennapod.core; + +import android.content.Context; + +import de.danoeh.antennapod.core.cast.CastManager; +import de.danoeh.antennapod.core.preferences.PlaybackPreferences; +import de.danoeh.antennapod.core.preferences.SleepTimerPreferences; +import de.danoeh.antennapod.core.preferences.UserPreferences; +import de.danoeh.antennapod.core.storage.PodDBAdapter; +import de.danoeh.antennapod.core.util.NetworkUtils; + +/** + * Stores callbacks for core classes like Services, DB classes etc. and other configuration variables. + * Apps using the core module of AntennaPod should register implementations of all interfaces here. + */ +public class ClientConfig { + private ClientConfig(){} + + /** + * Should be used when setting User-Agent header for HTTP-requests. + */ + public static String USER_AGENT; + + public static ApplicationCallbacks applicationCallbacks; + + public static DownloadServiceCallbacks downloadServiceCallbacks; + + public static PlaybackServiceCallbacks playbackServiceCallbacks; + + public static GpodnetCallbacks gpodnetCallbacks; + + public static FlattrCallbacks flattrCallbacks; + + public static DBTasksCallbacks dbTasksCallbacks; + + public static CastCallbacks castCallbacks; + + private static boolean initialized = false; + + public static synchronized void initialize(Context context) { + if(initialized) { + return; + } + PodDBAdapter.init(context); + UserPreferences.init(context); + UpdateManager.init(context); + PlaybackPreferences.init(context); + NetworkUtils.init(context); + CastManager.init(context); + SleepTimerPreferences.init(context); + initialized = true; + } + +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/cast/CastConsumer.java b/core/src/play/java/de/danoeh/antennapod/core/cast/CastConsumer.java new file mode 100644 index 000000000..213dd1875 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/cast/CastConsumer.java @@ -0,0 +1,11 @@ +package de.danoeh.antennapod.core.cast; + +import com.google.android.libraries.cast.companionlibrary.cast.callbacks.VideoCastConsumer; + +public interface CastConsumer extends VideoCastConsumer{ + + /** + * Called when the stream's volume is changed. + */ + void onStreamVolumeChanged(double value, boolean isMute); +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/cast/CastManager.java b/core/src/play/java/de/danoeh/antennapod/core/cast/CastManager.java new file mode 100644 index 000000000..27fb7344d --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/cast/CastManager.java @@ -0,0 +1,1776 @@ +/* + * Copyright (C) 2015 Google Inc. All Rights Reserved. + * + * 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. + * + * ------------------------------------------------------------------------ + * + * Changes made by Domingos Lopes <domingos86lopes@gmail.com> + * + * original can be found at http://www.github.com/googlecast/CastCompanionLibrary-android + */ + +package de.danoeh.antennapod.core.cast; + +import android.content.Context; +import android.os.Build; +import android.support.annotation.NonNull; +import android.support.v4.view.ActionProvider; +import android.support.v4.view.MenuItemCompat; +import android.support.v7.media.MediaRouter; +import android.util.Log; +import android.view.KeyEvent; +import android.view.MenuItem; + +import com.google.android.gms.cast.ApplicationMetadata; +import com.google.android.gms.cast.Cast; +import com.google.android.gms.cast.CastDevice; +import com.google.android.gms.cast.CastMediaControlIntent; +import com.google.android.gms.cast.CastStatusCodes; +import com.google.android.gms.cast.MediaInfo; +import com.google.android.gms.cast.MediaMetadata; +import com.google.android.gms.cast.MediaQueueItem; +import com.google.android.gms.cast.MediaStatus; +import com.google.android.gms.cast.RemoteMediaPlayer; +import com.google.android.gms.common.ConnectionResult; +import com.google.android.gms.common.GoogleApiAvailability; +import com.google.android.libraries.cast.companionlibrary.cast.BaseCastManager; +import com.google.android.libraries.cast.companionlibrary.cast.CastConfiguration; +import com.google.android.libraries.cast.companionlibrary.cast.MediaQueue; +import com.google.android.libraries.cast.companionlibrary.cast.exceptions.CastException; +import com.google.android.libraries.cast.companionlibrary.cast.exceptions.NoConnectionException; +import com.google.android.libraries.cast.companionlibrary.cast.exceptions.OnFailedListener; +import com.google.android.libraries.cast.companionlibrary.cast.exceptions.TransientNetworkDisconnectionException; + +import org.json.JSONObject; + +import java.io.IOException; +import java.util.List; +import java.util.Locale; +import java.util.Set; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.CopyOnWriteArraySet; +import java.util.concurrent.TimeUnit; + +import de.danoeh.antennapod.core.ClientConfig; +import de.danoeh.antennapod.core.R; + +import static com.google.android.gms.cast.RemoteMediaPlayer.RESUME_STATE_PLAY; +import static com.google.android.gms.cast.RemoteMediaPlayer.RESUME_STATE_UNCHANGED; + +/** + * A subclass of {@link BaseCastManager} that is suitable for casting video contents (it + * also provides a single custom data channel/namespace if an out-of-band communication is + * needed). + * <p> + * Clients need to initialize this class by calling + * {@link #init(android.content.Context)} in the Application's + * {@code onCreate()} method. To access the (singleton) instance of this class, clients + * need to call {@link #getInstance()}. + * <p>This + * class manages various states of the remote cast device. Client applications, however, can + * complement the default behavior of this class by hooking into various callbacks that it provides + * (see {@link CastConsumer}). + * Since the number of these callbacks is usually much larger than what a single application might + * be interested in, there is a no-op implementation of this interface (see + * {@link DefaultCastConsumer}) that applications can subclass to override only those methods that + * they are interested in. Since this library depends on the cast functionalities provided by the + * Google Play services, the library checks to ensure that the right version of that service is + * installed. It also provides a simple static method {@code checkGooglePlayServices()} that clients + * can call at an early stage of their applications to provide a dialog for users if they need to + * update/activate their Google Play Services library. + * + * @see CastConfiguration + */ +public class CastManager extends BaseCastManager implements OnFailedListener { + public static final String TAG = "CastManager"; + + public static final String CAST_APP_ID = CastMediaControlIntent.DEFAULT_MEDIA_RECEIVER_APPLICATION_ID; + + public static final double DEFAULT_VOLUME_STEP = 0.05; + public static final long DEFAULT_LIVE_STREAM_DURATION_MS = TimeUnit.HOURS.toMillis(2); + private double volumeStep = DEFAULT_VOLUME_STEP; + private MediaQueue mediaQueue; + private MediaStatus mediaStatus; + + private static CastManager INSTANCE; + private RemoteMediaPlayer remoteMediaPlayer; + private int state = MediaStatus.PLAYER_STATE_IDLE; + private int idleReason; + private final Set<CastConsumer> castConsumers = new CopyOnWriteArraySet<>(); + private long liveStreamDuration = DEFAULT_LIVE_STREAM_DURATION_MS; + private MediaQueueItem preLoadingItem; + + public static final int QUEUE_OPERATION_LOAD = 1; + public static final int QUEUE_OPERATION_INSERT_ITEMS = 2; + public static final int QUEUE_OPERATION_UPDATE_ITEMS = 3; + public static final int QUEUE_OPERATION_JUMP = 4; + public static final int QUEUE_OPERATION_REMOVE_ITEM = 5; + public static final int QUEUE_OPERATION_REMOVE_ITEMS = 6; + public static final int QUEUE_OPERATION_REORDER = 7; + public static final int QUEUE_OPERATION_MOVE = 8; + public static final int QUEUE_OPERATION_APPEND = 9; + public static final int QUEUE_OPERATION_NEXT = 10; + public static final int QUEUE_OPERATION_PREV = 11; + public static final int QUEUE_OPERATION_SET_REPEAT = 12; + + private CastManager(Context context, CastConfiguration castConfiguration) { + super(context, castConfiguration); + Log.d(TAG, "CastManager is instantiated"); + } + + public static synchronized CastManager init(Context context) { + if (INSTANCE == null) { + CastConfiguration castConfiguration = new CastConfiguration.Builder(CAST_APP_ID) + .enableDebug() + .enableAutoReconnect() + .enableWifiReconnection() + .setLaunchOptions(true, Locale.getDefault()) + .setMediaRouteDialogFactory(ClientConfig.castCallbacks.getMediaRouterDialogFactory()) + .build(); + Log.d(TAG, "New instance of CastManager is created"); + if (ConnectionResult.SUCCESS != GoogleApiAvailability.getInstance() + .isGooglePlayServicesAvailable(context)) { + Log.e(TAG, "Couldn't find the appropriate version of Google Play Services"); + } + INSTANCE = new CastManager(context, castConfiguration); + } + return INSTANCE; + } + + /** + * Returns a (singleton) instance of this class. Clients should call this method in order to + * get a hold of this singleton instance, only after it is initialized. If it is not initialized + * yet, an {@link IllegalStateException} will be thrown. + * + */ + public static CastManager getInstance() { + if (INSTANCE == null) { + String msg = "No CastManager instance was found, did you forget to initialize it?"; + Log.e(TAG, msg); + throw new IllegalStateException(msg); + } + return INSTANCE; + } + + /** + * Returns the active {@link RemoteMediaPlayer} instance. Since there are a number of media + * control APIs that this library do not provide a wrapper for, client applications can call + * those methods directly after obtaining an instance of the active {@link RemoteMediaPlayer}. + */ + public final RemoteMediaPlayer getRemoteMediaPlayer() { + return remoteMediaPlayer; + } + + /** + * Determines if the media that is loaded remotely is a live stream or not. + * + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public final boolean isRemoteStreamLive() throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + MediaInfo info = getRemoteMediaInformation(); + return (info != null) && (info.getStreamType() == MediaInfo.STREAM_TYPE_LIVE); + } + + /* + * A simple check to make sure remoteMediaPlayer is not null + */ + private void checkRemoteMediaPlayerAvailable() throws NoConnectionException { + if (remoteMediaPlayer == null) { + throw new NoConnectionException(); + } + } + + /** + * Returns the url for the media that is currently playing on the remote device. If there is no + * connection, this will return <code>null</code>. + * + * @throws NoConnectionException If no connectivity to the device exists + * @throws TransientNetworkDisconnectionException If framework is still trying to recover from + * a possibly transient loss of network + */ + public String getRemoteMediaUrl() throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + if (remoteMediaPlayer != null && remoteMediaPlayer.getMediaInfo() != null) { + MediaInfo info = remoteMediaPlayer.getMediaInfo(); + remoteMediaPlayer.getMediaStatus().getPlayerState(); + return info.getContentId(); + } + throw new NoConnectionException(); + } + + /** + * Indicates if the remote media is currently playing (or buffering). + * + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public boolean isRemoteMediaPlaying() throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + return state == MediaStatus.PLAYER_STATE_BUFFERING + || state == MediaStatus.PLAYER_STATE_PLAYING; + } + + /** + * Returns <code>true</code> if the remote connected device is playing a movie. + * + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public boolean isRemoteMediaPaused() throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + return state == MediaStatus.PLAYER_STATE_PAUSED; + } + + /** + * Returns <code>true</code> only if there is a media on the remote being played, paused or + * buffered. + * + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public boolean isRemoteMediaLoaded() throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + return isRemoteMediaPaused() || isRemoteMediaPlaying(); + } + + /** + * Returns the {@link MediaInfo} for the current media + * + * @throws NoConnectionException If no connectivity to the device exists + * @throws TransientNetworkDisconnectionException If framework is still trying to recover from + * a possibly transient loss of network + */ + public MediaInfo getRemoteMediaInformation() throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + checkRemoteMediaPlayerAvailable(); + return remoteMediaPlayer.getMediaInfo(); + } + + /** + * Gets the remote's system volume. It internally detects what type of volume is used. + * + * @throws NoConnectionException If no connectivity to the device exists + * @throws TransientNetworkDisconnectionException If framework is still trying to recover from + * a possibly transient loss of network + */ + public double getStreamVolume() throws TransientNetworkDisconnectionException, NoConnectionException { + checkConnectivity(); + checkRemoteMediaPlayerAvailable(); + return remoteMediaPlayer.getMediaStatus().getStreamVolume(); + } + + /** + * Sets the stream volume. + * + * @param volume Should be a value between 0 and 1, inclusive. + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + * @throws CastException If setting system volume fails + */ + public void setStreamVolume(double volume) throws CastException, + TransientNetworkDisconnectionException, NoConnectionException { + checkConnectivity(); + if (volume > 1.0) { + volume = 1.0; + } else if (volume < 0) { + volume = 0.0; + } + + RemoteMediaPlayer mediaPlayer = getRemoteMediaPlayer(); + if (mediaPlayer == null) { + throw new NoConnectionException(); + } + mediaPlayer.setStreamVolume(mApiClient, volume).setResultCallback( + (result) -> { + if (!result.getStatus().isSuccess()) { + onFailed(R.string.cast_failed_setting_volume, + result.getStatus().getStatusCode()); + } else { + CastManager.this.onStreamVolumeChanged(); + } + }); + } + + /** + * Returns <code>true</code> if remote Stream is muted. + * + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public boolean isStreamMute() throws TransientNetworkDisconnectionException, NoConnectionException { + checkConnectivity(); + checkRemoteMediaPlayerAvailable(); + return remoteMediaPlayer.getMediaStatus().isMute(); + } + + /** + * Returns <code>true</code> if remote device is muted. + * + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public boolean isMute() throws TransientNetworkDisconnectionException, NoConnectionException { + return isStreamMute() || isDeviceMute(); + } + + /** + * Mutes or un-mutes the stream volume. + * + * @throws CastException + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void setStreamMute(boolean mute) throws CastException, TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + checkRemoteMediaPlayerAvailable(); + remoteMediaPlayer.setStreamMute(mApiClient, mute); + } + + /** + * Returns the duration of the media that is loaded, in milliseconds. + * + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public long getMediaDuration() throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + checkRemoteMediaPlayerAvailable(); + return remoteMediaPlayer.getStreamDuration(); + } + + /** + * Returns the time left (in milliseconds) of the current media. If there is no + * {@code RemoteMediaPlayer}, it returns -1. + * + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public long getMediaTimeRemaining() + throws TransientNetworkDisconnectionException, NoConnectionException { + checkConnectivity(); + if (remoteMediaPlayer == null) { + return -1; + } + return isRemoteStreamLive() ? liveStreamDuration : remoteMediaPlayer.getStreamDuration() + - remoteMediaPlayer.getApproximateStreamPosition(); + } + + /** + * Returns the current (approximate) position of the current media, in milliseconds. + * + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public long getCurrentMediaPosition() throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + checkRemoteMediaPlayerAvailable(); + return remoteMediaPlayer.getApproximateStreamPosition(); + } + + public int getApplicationStandbyState() throws IllegalStateException { + Log.d(TAG, "getApplicationStandbyState()"); + return Cast.CastApi.getStandbyState(mApiClient); + } + + private void onApplicationDisconnected(int errorCode) { + Log.d(TAG, "onApplicationDisconnected() reached with error code: " + errorCode); + mApplicationErrorCode = errorCode; + for (CastConsumer consumer : castConsumers) { + consumer.onApplicationDisconnected(errorCode); + } + if (mMediaRouter != null) { + Log.d(TAG, "onApplicationDisconnected(): Cached RouteInfo: " + getRouteInfo()); + Log.d(TAG, "onApplicationDisconnected(): Selected RouteInfo: " + + mMediaRouter.getSelectedRoute()); + if (getRouteInfo() == null || mMediaRouter.getSelectedRoute().equals(getRouteInfo())) { + Log.d(TAG, "onApplicationDisconnected(): Setting route to default"); + mMediaRouter.selectRoute(mMediaRouter.getDefaultRoute()); + } + } + onDeviceSelected(null /* CastDevice */, null /* RouteInfo */); + } + + private void onApplicationStatusChanged() { + if (!isConnected()) { + return; + } + try { + String appStatus = Cast.CastApi.getApplicationStatus(mApiClient); + Log.d(TAG, "onApplicationStatusChanged() reached: " + appStatus); + for (CastConsumer consumer : castConsumers) { + consumer.onApplicationStatusChanged(appStatus); + } + } catch (IllegalStateException e) { + Log.e(TAG, "onApplicationStatusChanged()", e); + } + } + + private void onDeviceVolumeChanged() { + Log.d(TAG, "onDeviceVolumeChanged() reached"); + double volume; + try { + volume = getDeviceVolume(); + boolean isMute = isDeviceMute(); + for (CastConsumer consumer : castConsumers) { + consumer.onVolumeChanged(volume, isMute); + } + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Failed to get volume", e); + } + + } + + private void onStreamVolumeChanged() { + Log.d(TAG, "onStreamVolumeChanged() reached"); + double volume; + try { + volume = getStreamVolume(); + boolean isMute = isStreamMute(); + for (CastConsumer consumer : castConsumers) { + consumer.onStreamVolumeChanged(volume, isMute); + } + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Failed to get volume", e); + } + } + + @Override + protected void onApplicationConnected(ApplicationMetadata appMetadata, + String applicationStatus, String sessionId, boolean wasLaunched) { + Log.d(TAG, "onApplicationConnected() reached with sessionId: " + sessionId + + ", and mReconnectionStatus=" + mReconnectionStatus); + mApplicationErrorCode = NO_APPLICATION_ERROR; + if (mReconnectionStatus == RECONNECTION_STATUS_IN_PROGRESS) { + // we have tried to reconnect and successfully launched the app, so + // it is time to select the route and make the cast icon happy :-) + List<MediaRouter.RouteInfo> routes = mMediaRouter.getRoutes(); + if (routes != null) { + String routeId = mPreferenceAccessor.getStringFromPreference(PREFS_KEY_ROUTE_ID); + for (MediaRouter.RouteInfo routeInfo : routes) { + if (routeId.equals(routeInfo.getId())) { + // found the right route + Log.d(TAG, "Found the correct route during reconnection attempt"); + mReconnectionStatus = RECONNECTION_STATUS_FINALIZED; + mMediaRouter.selectRoute(routeInfo); + break; + } + } + } + } + try { + //attachDataChannel(); + attachMediaChannel(); + mSessionId = sessionId; + // saving device for future retrieval; we only save the last session info + mPreferenceAccessor.saveStringToPreference(PREFS_KEY_SESSION_ID, mSessionId); + remoteMediaPlayer.requestStatus(mApiClient).setResultCallback(result -> { + if (!result.getStatus().isSuccess()) { + onFailed(R.string.cast_failed_status_request, + result.getStatus().getStatusCode()); + } + }); + for (CastConsumer consumer : castConsumers) { + consumer.onApplicationConnected(appMetadata, mSessionId, wasLaunched); + } + } catch (TransientNetworkDisconnectionException e) { + Log.e(TAG, "Failed to attach media/data channel due to network issues", e); + onFailed(R.string.cast_failed_no_connection_trans, NO_STATUS_CODE); + } catch (NoConnectionException e) { + Log.e(TAG, "Failed to attach media/data channel due to network issues", e); + onFailed(R.string.cast_failed_no_connection, NO_STATUS_CODE); + } + } + + /* + * (non-Javadoc) + * @see com.google.android.libraries.cast.companionlibrary.cast.BaseCastManager + * #onConnectivityRecovered() + */ + @Override + public void onConnectivityRecovered() { + reattachMediaChannel(); + //reattachDataChannel(); + super.onConnectivityRecovered(); + } + + /* + * (non-Javadoc) + * @see com.google.android.gms.cast.CastClient.Listener#onApplicationStopFailed (int) + */ + @Override + public void onApplicationStopFailed(int errorCode) { + for (CastConsumer consumer : castConsumers) { + consumer.onApplicationStopFailed(errorCode); + } + } + + @Override + public void onApplicationConnectionFailed(int errorCode) { + Log.d(TAG, "onApplicationConnectionFailed() reached with errorCode: " + errorCode); + mApplicationErrorCode = errorCode; + if (mReconnectionStatus == RECONNECTION_STATUS_IN_PROGRESS) { + if (errorCode == CastStatusCodes.APPLICATION_NOT_RUNNING) { + // while trying to re-establish session, we found out that the app is not running + // so we need to disconnect + mReconnectionStatus = RECONNECTION_STATUS_INACTIVE; + onDeviceSelected(null /* CastDevice */, null /* RouteInfo */); + } + } else { + for (CastConsumer consumer : castConsumers) { + consumer.onApplicationConnectionFailed(errorCode); + } + onDeviceSelected(null /* CastDevice */, null /* RouteInfo */); + if (mMediaRouter != null) { + Log.d(TAG, "onApplicationConnectionFailed(): Setting route to default"); + mMediaRouter.selectRoute(mMediaRouter.getDefaultRoute()); + } + } + } + + /** + * Loads a media. For this to succeed, you need to have successfully launched the application. + * + * @param media The media to be loaded + * @param autoPlay If <code>true</code>, playback starts after load + * @param position Where to start the playback (only used if autoPlay is <code>true</code>. + * Units is milliseconds. + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void loadMedia(MediaInfo media, boolean autoPlay, int position) + throws TransientNetworkDisconnectionException, NoConnectionException { + loadMedia(media, autoPlay, position, null); + } + + /** + * Loads a media. For this to succeed, you need to have successfully launched the application. + * + * @param media The media to be loaded + * @param autoPlay If <code>true</code>, playback starts after load + * @param position Where to start the playback (only used if autoPlay is <code>true</code>). + * Units is milliseconds. + * @param customData Optional {@link JSONObject} data to be passed to the cast device + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void loadMedia(MediaInfo media, boolean autoPlay, int position, JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + loadMedia(media, null, autoPlay, position, customData); + } + + /** + * Loads a media. For this to succeed, you need to have successfully launched the application. + * + * @param media The media to be loaded + * @param activeTracks An array containing the list of track IDs to be set active for this + * media upon a successful load + * @param autoPlay If <code>true</code>, playback starts after load + * @param position Where to start the playback (only used if autoPlay is <code>true</code>). + * Units is milliseconds. + * @param customData Optional {@link JSONObject} data to be passed to the cast device + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void loadMedia(MediaInfo media, final long[] activeTracks, boolean autoPlay, + int position, JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "loadMedia"); + checkConnectivity(); + if (media == null) { + return; + } + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to load a video with no active media session"); + throw new NoConnectionException(); + } + + Log.d(TAG, "remoteMediaPlayer.load() with media=" + media.getMetadata().getString(MediaMetadata.KEY_TITLE) + + ", position=" + position + ", autoplay=" + autoPlay); + remoteMediaPlayer.load(mApiClient, media, autoPlay, position, activeTracks, customData) + .setResultCallback(result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaLoadResult(result.getStatus().getStatusCode()); + } + }); + } + + /** + * Loads and optionally starts playback of a new queue of media items. + * + * @param items Array of items to load, in the order that they should be played. Must not be + * {@code null} or empty. + * @param startIndex The array index of the item in the {@code items} array that should be + * played first (i.e., it will become the currentItem).If {@code repeatMode} + * is {@link MediaStatus#REPEAT_MODE_REPEAT_OFF} playback will end when the + * last item in the array is played. + * <p> + * This may be useful for continuation scenarios where the user was already + * using the sender application and in the middle decides to cast. This lets + * the sender application avoid mapping between the local and remote queue + * positions and/or avoid issuing an extra request to update the queue. + * <p> + * This value must be less than the length of {@code items}. + * @param repeatMode The repeat playback mode for the queue. One of + * {@link MediaStatus#REPEAT_MODE_REPEAT_OFF}, + * {@link MediaStatus#REPEAT_MODE_REPEAT_ALL}, + * {@link MediaStatus#REPEAT_MODE_REPEAT_SINGLE} and + * {@link MediaStatus#REPEAT_MODE_REPEAT_ALL_AND_SHUFFLE}. + * @param customData Custom application-specific data to pass along with the request, may be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void queueLoad(final MediaQueueItem[] items, final int startIndex, final int repeatMode, + final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "queueLoad"); + checkConnectivity(); + if (items == null || items.length == 0) { + return; + } + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to queue one or more videos with no active media session"); + throw new NoConnectionException(); + } + Log.d(TAG, "remoteMediaPlayer.queueLoad() with " + items.length + "items, starting at " + + startIndex); + remoteMediaPlayer + .queueLoad(mApiClient, items, startIndex, repeatMode, customData) + .setResultCallback(result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_LOAD, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Inserts a list of new media items into the queue. + * + * @param itemsToInsert List of items to insert into the queue, in the order that they should be + * played. The itemId field of the items should be unassigned or the + * request will fail with an INVALID_PARAMS error. Must not be {@code null} + * or empty. + * @param insertBeforeItemId ID of the item that will be located immediately after the inserted + * list. If the value is {@link MediaQueueItem#INVALID_ITEM_ID} or + * invalid, the inserted list will be appended to the end of the + * queue. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + * @throws IllegalArgumentException + */ + public void queueInsertItems(final MediaQueueItem[] itemsToInsert, final int insertBeforeItemId, + final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "queueInsertItems"); + checkConnectivity(); + if (itemsToInsert == null || itemsToInsert.length == 0) { + throw new IllegalArgumentException("items cannot be empty or null"); + } + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to insert into queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueInsertItems(mApiClient, itemsToInsert, insertBeforeItemId, customData) + .setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult( + QUEUE_OPERATION_INSERT_ITEMS, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Updates properties of a subset of the existing items in the media queue. + * + * @param itemsToUpdate List of queue items to be updated. The items will retain the existing + * order and will be fully replaced with the ones provided, including the + * media information. Any other items currently in the queue will remain + * unchanged. The tracks information can not change once the item is loaded + * (if the item is the currentItem). If any of the items does not exist it + * will be ignored. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void queueUpdateItems(final MediaQueueItem[] itemsToUpdate, final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to update the queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueUpdateItems(mApiClient, itemsToUpdate, customData).setResultCallback( + result -> { + Log.d(TAG, "queueUpdateItems() " + result.getStatus() + result.getStatus() + .isSuccess()); + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_UPDATE_ITEMS, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Plays the item with {@code itemId} in the queue. + * <p> + * If {@code itemId} is not found in the queue, this method will report success without sending + * a request to the receiver. + * + * @param itemId The ID of the item to which to jump. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + * @throws IllegalArgumentException + */ + public void queueJumpToItem(int itemId, final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException, + IllegalArgumentException { + checkConnectivity(); + if (itemId == MediaQueueItem.INVALID_ITEM_ID) { + throw new IllegalArgumentException("itemId is not valid"); + } + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to jump in a queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueJumpToItem(mApiClient, itemId, customData).setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_JUMP, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Removes a list of items from the queue. If the remaining queue is empty, the media session + * will be terminated. + * + * @param itemIdsToRemove The list of media item IDs to remove. Must not be {@code null} or + * empty. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + * @throws IllegalArgumentException + */ + public void queueRemoveItems(final int[] itemIdsToRemove, final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException, + IllegalArgumentException { + Log.d(TAG, "queueRemoveItems"); + checkConnectivity(); + if (itemIdsToRemove == null || itemIdsToRemove.length == 0) { + throw new IllegalArgumentException("itemIds cannot be empty or null"); + } + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to remove items from queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueRemoveItems(mApiClient, itemIdsToRemove, customData).setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_REMOVE_ITEMS, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Removes the item with {@code itemId} from the queue. + * <p> + * If {@code itemId} is not found in the queue, this method will silently return without sending + * a request to the receiver. A {@code itemId} may not be in the queue because it wasn't + * originally in the queue, or it was removed by another sender. + * + * @param itemId The ID of the item to be removed. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + * @throws IllegalArgumentException + */ + public void queueRemoveItem(final int itemId, final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException, + IllegalArgumentException { + Log.d(TAG, "queueRemoveItem"); + checkConnectivity(); + if (itemId == MediaQueueItem.INVALID_ITEM_ID) { + throw new IllegalArgumentException("itemId is invalid"); + } + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to remove an item from queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueRemoveItem(mApiClient, itemId, customData).setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_REMOVE_ITEM, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Reorder a list of media items in the queue. + * + * @param itemIdsToReorder The list of media item IDs to reorder, in the new order. Any other + * items currently in the queue will maintain their existing order. The + * list will be inserted just before the item specified by + * {@code insertBeforeItemId}, or at the end of the queue if + * {@code insertBeforeItemId} is {@link MediaQueueItem#INVALID_ITEM_ID}. + * <p> + * For example: + * <p> + * If insertBeforeItemId is not specified <br> + * Existing queue: "A","D","G","H","B","E" <br> + * itemIds: "D","H","B" <br> + * New Order: "A","G","E","D","H","B" <br> + * <p> + * If insertBeforeItemId is "A" <br> + * Existing queue: "A","D","G","H","B" <br> + * itemIds: "D","H","B" <br> + * New Order: "D","H","B","A","G","E" <br> + * <p> + * If insertBeforeItemId is "G" <br> + * Existing queue: "A","D","G","H","B" <br> + * itemIds: "D","H","B" <br> + * New Order: "A","D","H","B","G","E" <br> + * <p> + * If any of the items does not exist it will be ignored. + * Must not be {@code null} or empty. + * @param insertBeforeItemId ID of the item that will be located immediately after the reordered + * list. If set to {@link MediaQueueItem#INVALID_ITEM_ID}, the + * reordered list will be appended at the end of the queue. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void queueReorderItems(final int[] itemIdsToReorder, final int insertBeforeItemId, + final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException, + IllegalArgumentException { + Log.d(TAG, "queueReorderItems"); + checkConnectivity(); + if (itemIdsToReorder == null || itemIdsToReorder.length == 0) { + throw new IllegalArgumentException("itemIdsToReorder cannot be empty or null"); + } + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to reorder items in a queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueReorderItems(mApiClient, itemIdsToReorder, insertBeforeItemId, customData) + .setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_REORDER, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Moves the item with {@code itemId} to a new position in the queue. + * <p> + * If {@code itemId} is not found in the queue, either because it wasn't there originally or it + * was removed by another sender before calling this function, this function will silently + * return without sending a request to the receiver. + * + * @param itemId The ID of the item to be moved. + * @param newIndex The new index of the item. If the value is negative, an error will be + * returned. If the value is out of bounds, or becomes out of bounds because the + * queue was shortened by another sender while this request is in progress, the + * item will be moved to the end of the queue. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void queueMoveItemToNewIndex(int itemId, int newIndex, final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "queueMoveItemToNewIndex"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to mote item to new index with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueMoveItemToNewIndex(mApiClient, itemId, newIndex, customData) + .setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_MOVE, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Appends a new media item to the end of the queue. + * + * @param item The item to append. Must not be {@code null}. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void queueAppendItem(MediaQueueItem item, final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "queueAppendItem"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to append item with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueAppendItem(mApiClient, item, customData) + .setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_APPEND, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Jumps to the next item in the queue. + * + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void queueNext(final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "queueNext"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to update the queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueNext(mApiClient, customData).setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_NEXT, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Jumps to the previous item in the queue. + * + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void queuePrev(final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "queuePrev"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to update the queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queuePrev(mApiClient, customData).setResultCallback( + result -> { + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_PREV, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Inserts an item in the queue and starts the playback of that newly inserted item. It is + * assumed that we are inserting before the "current item" + * + * @param item The item to be inserted + * @param insertBeforeItemId ID of the item that will be located immediately after the inserted + * and is assumed to be the "current item" + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + * @throws IllegalArgumentException + */ + public void queueInsertBeforeCurrentAndPlay(MediaQueueItem item, int insertBeforeItemId, + final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "queueInsertBeforeCurrentAndPlay"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to insert into queue with no active media session"); + throw new NoConnectionException(); + } + if (item == null || insertBeforeItemId == MediaQueueItem.INVALID_ITEM_ID) { + throw new IllegalArgumentException( + "item cannot be empty or insertBeforeItemId cannot be invalid"); + } + remoteMediaPlayer.queueInsertItems(mApiClient, new MediaQueueItem[]{item}, + insertBeforeItemId, customData).setResultCallback( + result -> { + if (result.getStatus().isSuccess()) { + + try { + queuePrev(customData); + } catch (TransientNetworkDisconnectionException | + NoConnectionException e) { + Log.e(TAG, "queuePrev() Failed to skip to previous", e); + } + } + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_INSERT_ITEMS, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Sets the repeat mode of the queue. + * + * @param repeatMode The repeat playback mode for the queue. + * @param customData Custom application-specific data to pass along with the request. May be + * {@code null}. + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void queueSetRepeatMode(final int repeatMode, final JSONObject customData) + throws TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "queueSetRepeatMode"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to update the queue with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer + .queueSetRepeatMode(mApiClient, repeatMode, customData).setResultCallback( + result -> { + if (!result.getStatus().isSuccess()) { + Log.d(TAG, "Failed with status: " + result.getStatus()); + } + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueOperationResult(QUEUE_OPERATION_SET_REPEAT, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Plays the loaded media. + * + * @param position Where to start the playback. Units is milliseconds. + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void play(int position) throws TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + Log.d(TAG, "attempting to play media at position " + position + " seconds"); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to play a video with no active media session"); + throw new NoConnectionException(); + } + seekAndPlay(position); + } + + /** + * Resumes the playback from where it was left (can be the beginning). + * + * @param customData Optional {@link JSONObject} data to be passed to the cast device + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void play(JSONObject customData) throws + TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "play(customData)"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to play a video with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer.play(mApiClient, customData) + .setResultCallback(result -> { + if (!result.getStatus().isSuccess()) { + onFailed(R.string.cast_failed_to_play, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Resumes the playback from where it was left (can be the beginning). + * + * @throws CastException + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void play() throws CastException, TransientNetworkDisconnectionException, + NoConnectionException { + play(null); + } + + /** + * Stops the playback of media/stream + * + * @param customData Optional {@link JSONObject} + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void stop(JSONObject customData) throws + TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "stop()"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to stop a stream with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer.stop(mApiClient, customData).setResultCallback( + result -> { + if (!result.getStatus().isSuccess()) { + onFailed(R.string.cast_failed_to_stop, + result.getStatus().getStatusCode()); + } + } + ); + } + + /** + * Stops the playback of media/stream + * + * @throws CastException + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void stop() throws CastException, + TransientNetworkDisconnectionException, NoConnectionException { + stop(null); + } + + /** + * Pauses the playback. + * + * @throws CastException + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void pause() throws CastException, TransientNetworkDisconnectionException, + NoConnectionException { + pause(null); + } + + /** + * Pauses the playback. + * + * @param customData Optional {@link JSONObject} data to be passed to the cast device + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void pause(JSONObject customData) throws + TransientNetworkDisconnectionException, NoConnectionException { + Log.d(TAG, "attempting to pause media"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to pause a video with no active media session"); + throw new NoConnectionException(); + } + remoteMediaPlayer.pause(mApiClient, customData) + .setResultCallback(result -> { + if (!result.getStatus().isSuccess()) { + onFailed(R.string.cast_failed_to_pause, + result.getStatus().getStatusCode()); + } + }); + } + + /** + * Seeks to the given point without changing the state of the player, i.e. after seek is + * completed, it resumes what it was doing before the start of seek. + * + * @param position in milliseconds + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void seek(int position) throws TransientNetworkDisconnectionException, + NoConnectionException { + Log.d(TAG, "attempting to seek media"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to seek a video with no active media session"); + throw new NoConnectionException(); + } + Log.d(TAG, "remoteMediaPlayer.seek() to position " + position); + remoteMediaPlayer.seek(mApiClient, + position, + RESUME_STATE_UNCHANGED). + setResultCallback(result -> { + if (!result.getStatus().isSuccess()) { + onFailed(R.string.cast_failed_seek, result.getStatus().getStatusCode()); + } + }); + } + + /** + * Fast forwards the media by the given amount. If {@code lengthInMillis} is negative, it + * rewinds the media. + * + * @param lengthInMillis The amount to fast forward the media, given in milliseconds + * @throws TransientNetworkDisconnectionException + * @throws NoConnectionException + */ + public void forward(int lengthInMillis) throws TransientNetworkDisconnectionException, + NoConnectionException { + Log.d(TAG, "forward(): attempting to forward media by " + lengthInMillis); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to seek a video with no active media session"); + throw new NoConnectionException(); + } + long position = remoteMediaPlayer.getApproximateStreamPosition() + lengthInMillis; + seek((int) position); + } + + /** + * Seeks to the given point and starts playback regardless of the starting state. + * + * @param position in milliseconds + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void seekAndPlay(int position) throws TransientNetworkDisconnectionException, + NoConnectionException { + Log.d(TAG, "attempting to seek media"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + Log.e(TAG, "Trying to seekAndPlay a video with no active media session"); + throw new NoConnectionException(); + } + Log.d(TAG, "remoteMediaPlayer.seek() to position " + position + "and play"); + remoteMediaPlayer.seek(mApiClient, position, RESUME_STATE_PLAY) + .setResultCallback(result -> { + if (!result.getStatus().isSuccess()) { + onFailed(R.string.cast_failed_seek, result.getStatus().getStatusCode()); + } + }); + } + + /** + * Toggles the playback of the media. + * + * @throws CastException + * @throws NoConnectionException + * @throws TransientNetworkDisconnectionException + */ + public void togglePlayback() throws CastException, TransientNetworkDisconnectionException, + NoConnectionException { + checkConnectivity(); + boolean isPlaying = isRemoteMediaPlaying(); + if (isPlaying) { + pause(); + } else { + if (state == MediaStatus.PLAYER_STATE_IDLE + && idleReason == MediaStatus.IDLE_REASON_FINISHED) { + loadMedia(getRemoteMediaInformation(), true, 0); + } else { + play(); + } + } + } + + private void attachMediaChannel() throws TransientNetworkDisconnectionException, + NoConnectionException { + Log.d(TAG, "attachMediaChannel()"); + checkConnectivity(); + if (remoteMediaPlayer == null) { + remoteMediaPlayer = new RemoteMediaPlayer(); + + remoteMediaPlayer.setOnStatusUpdatedListener( + () -> { + Log.d(TAG, "RemoteMediaPlayer::onStatusUpdated() is reached"); + CastManager.this.onRemoteMediaPlayerStatusUpdated(); + } + ); + + remoteMediaPlayer.setOnPreloadStatusUpdatedListener( + () -> { + Log.d(TAG, "RemoteMediaPlayer::onPreloadStatusUpdated() is reached"); + CastManager.this.onRemoteMediaPreloadStatusUpdated(); + }); + + + remoteMediaPlayer.setOnMetadataUpdatedListener( + () -> { + Log.d(TAG, "RemoteMediaPlayer::onMetadataUpdated() is reached"); + CastManager.this.onRemoteMediaPlayerMetadataUpdated(); + } + ); + + remoteMediaPlayer.setOnQueueStatusUpdatedListener( + () -> { + Log.d(TAG, "RemoteMediaPlayer::onQueueStatusUpdated() is reached"); + mediaStatus = remoteMediaPlayer.getMediaStatus(); + if (mediaStatus != null + && mediaStatus.getQueueItems() != null) { + List<MediaQueueItem> queueItems = mediaStatus + .getQueueItems(); + int itemId = mediaStatus.getCurrentItemId(); + MediaQueueItem item = mediaStatus + .getQueueItemById(itemId); + int repeatMode = mediaStatus.getQueueRepeatMode(); + onQueueUpdated(queueItems, item, repeatMode, false); + } else { + onQueueUpdated(null, null, + MediaStatus.REPEAT_MODE_REPEAT_OFF, false); + } + }); + + } + try { + Log.d(TAG, "Registering MediaChannel namespace"); + Cast.CastApi.setMessageReceivedCallbacks(mApiClient, remoteMediaPlayer.getNamespace(), + remoteMediaPlayer); + } catch (IOException | IllegalStateException e) { + Log.e(TAG, "attachMediaChannel()", e); + } + } + + private void reattachMediaChannel() { + if (remoteMediaPlayer != null && mApiClient != null) { + try { + Log.d(TAG, "Registering MediaChannel namespace"); + Cast.CastApi.setMessageReceivedCallbacks(mApiClient, + remoteMediaPlayer.getNamespace(), remoteMediaPlayer); + } catch (IOException | IllegalStateException e) { + Log.e(TAG, "reattachMediaChannel()", e); + } + } + } + + private void detachMediaChannel() { + Log.d(TAG, "trying to detach media channel"); + if (remoteMediaPlayer != null) { + try { + Cast.CastApi.removeMessageReceivedCallbacks(mApiClient, + remoteMediaPlayer.getNamespace()); + } catch (IOException | IllegalStateException e) { + Log.e(TAG, "detachMediaChannel()", e); + } + remoteMediaPlayer = null; + } + } + + /** + * Returns the playback status of the remote device. + * + * @return Returns one of the values + * <ul> + * <li> <code>MediaStatus.PLAYER_STATE_UNKNOWN</code></li> + * <li> <code>MediaStatus.PLAYER_STATE_IDLE</code></li> + * <li> <code>MediaStatus.PLAYER_STATE_PLAYING</code></li> + * <li> <code>MediaStatus.PLAYER_STATE_PAUSED</code></li> + * <li> <code>MediaStatus.PLAYER_STATE_BUFFERING</code></li> + * </ul> + */ + public int getPlaybackStatus() { + return state; + } + + /** + * Returns the latest retrieved value for the {@link MediaStatus}. This value is updated + * whenever the onStatusUpdated callback is called. + */ + public final MediaStatus getMediaStatus() { + return mediaStatus; + } + + /** + * Returns the Idle reason, defined in <code>MediaStatus.IDLE_*</code>. Note that the returned + * value is only meaningful if the status is truly <code>MediaStatus.PLAYER_STATE_IDLE + * </code> + * + * <p>Possible values are: + * <ul> + * <li>IDLE_REASON_NONE</li> + * <li>IDLE_REASON_FINISHED</li> + * <li>IDLE_REASON_CANCELED</li> + * <li>IDLE_REASON_INTERRUPTED</li> + * <li>IDLE_REASON_ERROR</li> + * </ul> + */ + public int getIdleReason() { + return idleReason; + } + + private void onMessageSendFailed(int errorCode) { + for (CastConsumer consumer : castConsumers) { + consumer.onDataMessageSendFailed(errorCode); + } + } + + /* + * This is called by onStatusUpdated() of the RemoteMediaPlayer + */ + private void onRemoteMediaPlayerStatusUpdated() { + Log.d(TAG, "onRemoteMediaPlayerStatusUpdated() reached"); + if (mApiClient == null || remoteMediaPlayer == null) { + Log.d(TAG, "mApiClient or remoteMediaPlayer is null, so will not proceed"); + return; + } + mediaStatus = remoteMediaPlayer.getMediaStatus(); + if (mediaStatus == null) { + Log.d(TAG, "MediaStatus is null, so will not proceed"); + return; + } else { + List<MediaQueueItem> queueItems = mediaStatus.getQueueItems(); + if (queueItems != null) { + int itemId = mediaStatus.getCurrentItemId(); + MediaQueueItem item = mediaStatus.getQueueItemById(itemId); + int repeatMode = mediaStatus.getQueueRepeatMode(); + onQueueUpdated(queueItems, item, repeatMode, false); + } else { + onQueueUpdated(null, null, MediaStatus.REPEAT_MODE_REPEAT_OFF, false); + } + state = mediaStatus.getPlayerState(); + idleReason = mediaStatus.getIdleReason(); + + if (state == MediaStatus.PLAYER_STATE_PLAYING) { + Log.d(TAG, "onRemoteMediaPlayerStatusUpdated(): Player status = playing"); + } else if (state == MediaStatus.PLAYER_STATE_PAUSED) { + Log.d(TAG, "onRemoteMediaPlayerStatusUpdated(): Player status = paused"); + } else if (state == MediaStatus.PLAYER_STATE_IDLE) { + Log.d(TAG, "onRemoteMediaPlayerStatusUpdated(): Player status = IDLE with reason: " + + idleReason); + if (idleReason == MediaStatus.IDLE_REASON_ERROR) { + // something bad happened on the cast device + Log.d(TAG, "onRemoteMediaPlayerStatusUpdated(): IDLE reason = ERROR"); + onFailed(R.string.cast_failed_receiver_player_error, NO_STATUS_CODE); + } + } else if (state == MediaStatus.PLAYER_STATE_BUFFERING) { + Log.d(TAG, "onRemoteMediaPlayerStatusUpdated(): Player status = buffering"); + } else { + Log.d(TAG, "onRemoteMediaPlayerStatusUpdated(): Player status = unknown"); + } + } + for (CastConsumer consumer : castConsumers) { + consumer.onRemoteMediaPlayerStatusUpdated(); + } + if (mediaStatus != null) { + double volume = mediaStatus.getStreamVolume(); + boolean isMute = mediaStatus.isMute(); + for (CastConsumer consumer : castConsumers) { + consumer.onStreamVolumeChanged(volume, isMute); + } + } + } + + private void onRemoteMediaPreloadStatusUpdated() { + MediaQueueItem item = null; + mediaStatus = remoteMediaPlayer.getMediaStatus(); + if (mediaStatus != null) { + item = mediaStatus.getQueueItemById(mediaStatus.getPreloadedItemId()); + } + preLoadingItem = item; + Log.d(TAG, "onRemoteMediaPreloadStatusUpdated() " + item); + for (CastConsumer consumer : castConsumers) { + consumer.onRemoteMediaPreloadStatusUpdated(item); + } + } + + public MediaQueueItem getPreLoadingItem() { + return preLoadingItem; + } + + /* + * This is called by onQueueStatusUpdated() of RemoteMediaPlayer + */ + private void onQueueUpdated(List<MediaQueueItem> queueItems, MediaQueueItem item, + int repeatMode, boolean shuffle) { + Log.d(TAG, "onQueueUpdated() reached"); + Log.d(TAG, String.format("Queue Items size: %d, Item: %s, Repeat Mode: %d, Shuffle: %s", + queueItems == null ? 0 : queueItems.size(), item, repeatMode, shuffle)); + if (queueItems != null) { + mediaQueue = new MediaQueue(new CopyOnWriteArrayList<>(queueItems), item, shuffle, + repeatMode); + } else { + mediaQueue = new MediaQueue(new CopyOnWriteArrayList<>(), null, false, + MediaStatus.REPEAT_MODE_REPEAT_OFF); + } + for (CastConsumer consumer : castConsumers) { + consumer.onMediaQueueUpdated(queueItems, item, repeatMode, shuffle); + } + } + + /* + * This is called by onMetadataUpdated() of RemoteMediaPlayer + */ + public void onRemoteMediaPlayerMetadataUpdated() { + Log.d(TAG, "onRemoteMediaPlayerMetadataUpdated() reached"); + for (CastConsumer consumer : castConsumers) { + consumer.onRemoteMediaPlayerMetadataUpdated(); + } + } + + /** + * Registers a {@link CastConsumer} interface with this class. + * Registered listeners will be notified of changes to a variety of + * lifecycle and media status changes through the callbacks that the interface provides. + * + * @see DefaultCastConsumer + */ + public synchronized void addCastConsumer(CastConsumer listener) { + if (listener != null) { + addBaseCastConsumer(listener); + castConsumers.add(listener); + Log.d(TAG, "Successfully added the new CastConsumer listener " + listener); + } + } + + /** + * Unregisters a {@link CastConsumer}. + */ + public synchronized void removeCastConsumer(CastConsumer listener) { + if (listener != null) { + removeBaseCastConsumer(listener); + castConsumers.remove(listener); + } + } + + @Override + protected void onDeviceUnselected() { + detachMediaChannel(); + //removeDataChannel(); + state = MediaStatus.PLAYER_STATE_IDLE; + mediaStatus = null; + } + + @Override + protected Cast.CastOptions.Builder getCastOptionBuilder(CastDevice device) { + Cast.CastOptions.Builder builder = new Cast.CastOptions.Builder(mSelectedCastDevice, new CastListener()); + if (isFeatureEnabled(CastConfiguration.FEATURE_DEBUGGING)) { + builder.setVerboseLoggingEnabled(true); + } + return builder; + } + + @Override + public void onConnectionFailed(ConnectionResult result) { + super.onConnectionFailed(result); + state = MediaStatus.PLAYER_STATE_IDLE; + mediaStatus = null; + } + + @Override + public void onDisconnected(boolean stopAppOnExit, boolean clearPersistedConnectionData, + boolean setDefaultRoute) { + super.onDisconnected(stopAppOnExit, clearPersistedConnectionData, setDefaultRoute); + state = MediaStatus.PLAYER_STATE_IDLE; + mediaStatus = null; + mediaQueue = null; + } + + class CastListener extends Cast.Listener { + + /* + * (non-Javadoc) + * @see com.google.android.gms.cast.Cast.Listener#onApplicationDisconnected (int) + */ + @Override + public void onApplicationDisconnected(int statusCode) { + CastManager.this.onApplicationDisconnected(statusCode); + } + + /* + * (non-Javadoc) + * @see com.google.android.gms.cast.Cast.Listener#onApplicationStatusChanged () + */ + @Override + public void onApplicationStatusChanged() { + CastManager.this.onApplicationStatusChanged(); + } + + @Override + public void onVolumeChanged() { + CastManager.this.onDeviceVolumeChanged(); + } + } + + @Override + public void onFailed(int resourceId, int statusCode) { + Log.d(TAG, "onFailed: " + mContext.getString(resourceId) + ", code: " + statusCode); + super.onFailed(resourceId, statusCode); + } + + /** + * Clients can call this method to delegate handling of the volume. Clients should override + * {@code dispatchEvent} and call this method: + * <pre> + public boolean dispatchKeyEvent(KeyEvent event) { + if (mCastManager.onDispatchVolumeKeyEvent(event, VOLUME_DELTA)) { + return true; + } + return super.dispatchKeyEvent(event); + } + * </pre> + * @param event The dispatched event. + * @param volumeDelta The amount by which volume should be increased or decreased in each step + * @return <code>true</code> if volume is handled by the library, <code>false</code> otherwise. + */ + public boolean onDispatchVolumeKeyEvent(KeyEvent event, double volumeDelta) { + if (isConnected()) { + boolean isKeyDown = event.getAction() == KeyEvent.ACTION_DOWN; + switch (event.getKeyCode()) { + case KeyEvent.KEYCODE_VOLUME_UP: + return changeVolume(volumeDelta, isKeyDown); + case KeyEvent.KEYCODE_VOLUME_DOWN: + return changeVolume(-volumeDelta, isKeyDown); + } + } + return false; + } + + private boolean changeVolume(double volumeIncrement, boolean isKeyDown) { + if ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) + && getPlaybackStatus() == MediaStatus.PLAYER_STATE_PLAYING + && isFeatureEnabled(CastConfiguration.FEATURE_LOCKSCREEN)) { + return false; + } + + if (isKeyDown) { + try { + adjustDeviceVolume(volumeIncrement); + } catch (CastException | TransientNetworkDisconnectionException | + NoConnectionException e) { + Log.e(TAG, "Failed to change volume", e); + } + } + return true; + } + + /** + * Sets the volume step, i.e. the fraction by which volume will increase or decrease each time + * user presses the hard volume buttons on the device. + * + * @param volumeStep Should be a double between 0 and 1, inclusive. + */ + public CastManager setVolumeStep(double volumeStep) { + if ((volumeStep > 1) || (volumeStep < 0)) { + throw new IllegalArgumentException("Volume Step should be between 0 and 1, inclusive"); + } + this.volumeStep = volumeStep; + return this; + } + + /** + * Returns the volume step. The default value is {@code DEFAULT_VOLUME_STEP}. + */ + public double getVolumeStep() { + return volumeStep; + } + + public final MediaQueue getMediaQueue() { + return mediaQueue; + } + + /** + * Checks whether the selected Cast Device has the specified audio or video capabilities. + * + * @param capability capability from: + * <ul> + * <li>{@link CastDevice#CAPABILITY_AUDIO_IN}</li> + * <li>{@link CastDevice#CAPABILITY_AUDIO_OUT}</li> + * <li>{@link CastDevice#CAPABILITY_VIDEO_IN}</li> + * <li>{@link CastDevice#CAPABILITY_VIDEO_OUT}</li> + * </ul> + * @param defaultVal value to return whenever there's no device selected. + * @return {@code true} if the selected device has the specified capability, + * {@code false} otherwise. + */ + public boolean hasCapability(final int capability, final boolean defaultVal) { + if (mSelectedCastDevice != null) { + return mSelectedCastDevice.hasCapability(capability); + } else { + return defaultVal; + } + } + + /** + * Adds and wires up the Switchable Media Router cast button. It returns a reference to the + * {@link SwitchableMediaRouteActionProvider} associated with the button if the caller needs + * such reference. It is assumed that the enclosing + * {@link android.app.Activity} inherits (directly or indirectly) from + * {@link android.support.v7.app.AppCompatActivity}. + * + * @param menuItem MenuItem of the Media Router cast button. + */ + public final SwitchableMediaRouteActionProvider addMediaRouterButton(@NonNull MenuItem menuItem) { + ActionProvider actionProvider = MenuItemCompat.getActionProvider(menuItem); + if (!(actionProvider instanceof SwitchableMediaRouteActionProvider)) { + Log.wtf(TAG, "MenuItem provided to addMediaRouterButton() is not compatible with " + + "SwitchableMediaRouteActionProvider." + + ((actionProvider == null) ? " Its action provider is null!" : ""), + new ClassCastException()); + return null; + } + SwitchableMediaRouteActionProvider mediaRouteActionProvider = + (SwitchableMediaRouteActionProvider) actionProvider; + mediaRouteActionProvider.setRouteSelector(mMediaRouteSelector); + if (mCastConfiguration.getMediaRouteDialogFactory() != null) { + mediaRouteActionProvider.setDialogFactory(mCastConfiguration.getMediaRouteDialogFactory()); + } + return mediaRouteActionProvider; + } + + /* (non-Javadoc) + * These methods startReconnectionService and stopReconnectionService simply override the ones + * from BaseCastManager with empty implementations because we handle the service ourselves, but + * need to allow BaseCastManager to save current network information. + */ + @Override + protected void startReconnectionService(long mediaDurationLeft) { + // Do nothing + } + + @Override + protected void stopReconnectionService() { + // Do nothing + } +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/cast/CastUtils.java b/core/src/play/java/de/danoeh/antennapod/core/cast/CastUtils.java new file mode 100644 index 000000000..305f93e43 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/cast/CastUtils.java @@ -0,0 +1,319 @@ +package de.danoeh.antennapod.core.cast; + +import android.net.Uri; +import android.text.TextUtils; +import android.util.Log; + +import com.google.android.gms.cast.CastDevice; +import com.google.android.gms.cast.MediaInfo; +import com.google.android.gms.cast.MediaMetadata; +import com.google.android.gms.common.images.WebImage; + +import java.util.Calendar; +import java.util.List; + +import de.danoeh.antennapod.core.feed.Feed; +import de.danoeh.antennapod.core.feed.FeedImage; +import de.danoeh.antennapod.core.feed.FeedItem; +import de.danoeh.antennapod.core.feed.FeedMedia; +import de.danoeh.antennapod.core.storage.DBReader; +import de.danoeh.antennapod.core.util.playback.ExternalMedia; +import de.danoeh.antennapod.core.util.playback.Playable; + +/** + * Helper functions for Cast support. + */ +public class CastUtils { + private CastUtils(){} + + private static final String TAG = "CastUtils"; + + public static final String KEY_MEDIA_ID = "de.danoeh.antennapod.core.cast.MediaId"; + + public static final String KEY_EPISODE_IDENTIFIER = "de.danoeh.antennapod.core.cast.EpisodeId"; + public static final String KEY_EPISODE_LINK = "de.danoeh.antennapod.core.cast.EpisodeLink"; + public static final String KEY_FEED_URL = "de.danoeh.antennapod.core.cast.FeedUrl"; + public static final String KEY_FEED_WEBSITE = "de.danoeh.antennapod.core.cast.FeedWebsite"; + public static final String KEY_EPISODE_NOTES = "de.danoeh.antennapod.core.cast.EpisodeNotes"; + public static final int EPISODE_NOTES_MAX_LENGTH = Integer.MAX_VALUE; + + /** + * The field <code>AntennaPod.FormatVersion</code> specifies which version of MediaMetaData + * fields we're using. Future implementations should try to be backwards compatible with earlier + * versions, and earlier versions should be forward compatible until the version indicated by + * <code>MAX_VERSION_FORWARD_COMPATIBILITY</code>. If an update makes the format unreadable for + * an earlier version, then its version number should be greater than the + * <code>MAX_VERSION_FORWARD_COMPATIBILITY</code> value set on the earlier one, so that it + * doesn't try to parse the object. + */ + public static final String KEY_FORMAT_VERSION = "de.danoeh.antennapod.core.cast.FormatVersion"; + public static final int FORMAT_VERSION_VALUE = 1; + public static final int MAX_VERSION_FORWARD_COMPATIBILITY = 9999; + + public static boolean isCastable(Playable media){ + if (media == null || media instanceof ExternalMedia) { + return false; + } + if (media instanceof FeedMedia || media instanceof RemoteMedia){ + String url = media.getStreamUrl(); + if(url == null || url.isEmpty()){ + return false; + } + switch (media.getMediaType()) { + case UNKNOWN: + return false; + case AUDIO: + return CastManager.getInstance().hasCapability(CastDevice.CAPABILITY_AUDIO_OUT, true); + case VIDEO: + return CastManager.getInstance().hasCapability(CastDevice.CAPABILITY_VIDEO_OUT, true); + } + } + return false; + } + + /** + * Converts {@link FeedMedia} objects into a format suitable for sending to a Cast Device. + * Before using this method, one should make sure {@link #isCastable(Playable)} returns + * {@code true}. + * + * Unless media.{@link FeedMedia#loadMetadata() loadMetadata()} has already been called, + * this method should not run on the main thread. + * + * @param media The {@link FeedMedia} object to be converted. + * @return {@link MediaInfo} object in a format proper for casting. + */ + public static MediaInfo convertFromFeedMedia(FeedMedia media){ + if(media == null) { + return null; + } + MediaMetadata metadata = new MediaMetadata(MediaMetadata.MEDIA_TYPE_GENERIC); + try{ + media.loadMetadata(); + } catch (Playable.PlayableException e) { + Log.e(TAG, "Unable to load FeedMedia metadata", e); + } + FeedItem feedItem = media.getItem(); + if (feedItem != null) { + metadata.putString(MediaMetadata.KEY_TITLE, media.getEpisodeTitle()); + String subtitle = media.getFeedTitle(); + if (subtitle != null) { + metadata.putString(MediaMetadata.KEY_SUBTITLE, subtitle); + } + FeedImage image = feedItem.getImage(); + if (image != null && !TextUtils.isEmpty(image.getDownload_url())) { + metadata.addImage(new WebImage(Uri.parse(image.getDownload_url()))); + } + Calendar calendar = Calendar.getInstance(); + calendar.setTime(media.getItem().getPubDate()); + metadata.putDate(MediaMetadata.KEY_RELEASE_DATE, calendar); + Feed feed = feedItem.getFeed(); + if (feed != null) { + if (!TextUtils.isEmpty(feed.getAuthor())) { + metadata.putString(MediaMetadata.KEY_ARTIST, feed.getAuthor()); + } + if (!TextUtils.isEmpty(feed.getDownload_url())) { + metadata.putString(KEY_FEED_URL, feed.getDownload_url()); + } + if (!TextUtils.isEmpty(feed.getLink())) { + metadata.putString(KEY_FEED_WEBSITE, feed.getLink()); + } + } + if (!TextUtils.isEmpty(feedItem.getItemIdentifier())) { + metadata.putString(KEY_EPISODE_IDENTIFIER, feedItem.getItemIdentifier()); + } else { + metadata.putString(KEY_EPISODE_IDENTIFIER, media.getStreamUrl()); + } + if (!TextUtils.isEmpty(feedItem.getLink())) { + metadata.putString(KEY_EPISODE_LINK, feedItem.getLink()); + } + } + String notes = null; + try { + notes = media.loadShownotes().call(); + } catch (Exception e) { + Log.e(TAG, "Unable to load FeedMedia notes", e); + } + if (notes != null) { + if (notes.length() > EPISODE_NOTES_MAX_LENGTH) { + notes = notes.substring(0, EPISODE_NOTES_MAX_LENGTH); + } + metadata.putString(KEY_EPISODE_NOTES, notes); + } + // This field only identifies the id on the device that has the original version. + // Idea is to perhaps, on a first approach, check if the version on the local DB with the + // same id matches the remote object, and if not then search for episode and feed identifiers. + // This at least should make media recognition for a single device much quicker. + metadata.putInt(KEY_MEDIA_ID, ((Long) media.getIdentifier()).intValue()); + // A way to identify different casting media formats in case we change it in the future and + // senders with different versions share a casting device. + metadata.putInt(KEY_FORMAT_VERSION, FORMAT_VERSION_VALUE); + + MediaInfo.Builder builder = new MediaInfo.Builder(media.getStreamUrl()) + .setContentType(media.getMime_type()) + .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED) + .setMetadata(metadata); + if (media.getDuration() > 0) { + builder.setStreamDuration(media.getDuration()); + } + return builder.build(); + } + + //TODO make unit tests for all the conversion methods + /** + * Converts {@link MediaInfo} objects into the appropriate implementation of {@link Playable}. + * + * Unless <code>searchFeedMedia</code> is set to <code>false</code>, this method should not run + * on the GUI thread. + * + * @param media The {@link MediaInfo} object to be converted. + * @param searchFeedMedia If set to <code>true</code>, the database will be queried to find a + * {@link FeedMedia} instance that matches {@param media}. + * @return {@link Playable} object in a format proper for casting. + */ + public static Playable getPlayable(MediaInfo media, boolean searchFeedMedia) { + Log.d(TAG, "getPlayable called with searchFeedMedia=" + searchFeedMedia); + if (media == null) { + Log.d(TAG, "MediaInfo object provided is null, not converting to any Playable instance"); + return null; + } + MediaMetadata metadata = media.getMetadata(); + int version = metadata.getInt(KEY_FORMAT_VERSION); + if (version <= 0 || version > MAX_VERSION_FORWARD_COMPATIBILITY) { + Log.w(TAG, "MediaInfo object obtained from the cast device is not compatible with this" + + "version of AntennaPod CastUtils, curVer=" + FORMAT_VERSION_VALUE + + ", object version=" + version); + return null; + } + Playable result = null; + if (searchFeedMedia) { + long mediaId = metadata.getInt(KEY_MEDIA_ID); + if (mediaId > 0) { + FeedMedia fMedia = DBReader.getFeedMedia(mediaId); + if (fMedia != null) { + try { + fMedia.loadMetadata(); + if (matches(media, fMedia)) { + result = fMedia; + Log.d(TAG, "FeedMedia object obtained matches the MediaInfo provided. id=" + mediaId); + } else { + Log.d(TAG, "FeedMedia object obtained does NOT match the MediaInfo provided. id=" + mediaId); + } + } catch (Playable.PlayableException e) { + Log.e(TAG, "Unable to load FeedMedia metadata to compare with MediaInfo", e); + } + } else { + Log.d(TAG, "Unable to find in database a FeedMedia with id=" + mediaId); + } + } + if (result == null) { + FeedItem feedItem = DBReader.getFeedItem(metadata.getString(KEY_FEED_URL), + metadata.getString(KEY_EPISODE_IDENTIFIER)); + if (feedItem != null) { + result = feedItem.getMedia(); + Log.d(TAG, "Found episode that matches the MediaInfo provided. Using its media, if existing."); + } + } + } + if (result == null) { + List<WebImage> imageList = metadata.getImages(); + String imageUrl = null; + if (!imageList.isEmpty()) { + imageUrl = imageList.get(0).getUrl().toString(); + } + result = new RemoteMedia(media.getContentId(), + metadata.getString(KEY_EPISODE_IDENTIFIER), + metadata.getString(KEY_FEED_URL), + metadata.getString(MediaMetadata.KEY_SUBTITLE), + metadata.getString(MediaMetadata.KEY_TITLE), + metadata.getString(KEY_EPISODE_LINK), + metadata.getString(MediaMetadata.KEY_ARTIST), + imageUrl, + metadata.getString(KEY_FEED_WEBSITE), + media.getContentType(), + metadata.getDate(MediaMetadata.KEY_RELEASE_DATE).getTime()); + String notes = metadata.getString(KEY_EPISODE_NOTES); + if (!TextUtils.isEmpty(notes)) { + ((RemoteMedia) result).setNotes(notes); + } + Log.d(TAG, "Converted MediaInfo into RemoteMedia"); + } + if (result.getDuration() == 0 && media.getStreamDuration() > 0) { + result.setDuration((int) media.getStreamDuration()); + } + return result; + } + + /** + * Compares a {@link MediaInfo} instance with a {@link FeedMedia} one and evaluates whether they + * represent the same podcast episode. + * + * @param info the {@link MediaInfo} object to be compared. + * @param media the {@link FeedMedia} object to be compared. + * @return <true>true</true> if there's a match, <code>false</code> otherwise. + * + * @see RemoteMedia#equals(Object) + */ + public static boolean matches(MediaInfo info, FeedMedia media) { + if (info == null || media == null) { + return false; + } + if (!TextUtils.equals(info.getContentId(), media.getStreamUrl())) { + return false; + } + MediaMetadata metadata = info.getMetadata(); + FeedItem fi = media.getItem(); + if (fi == null || metadata == null || + !TextUtils.equals(metadata.getString(KEY_EPISODE_IDENTIFIER), fi.getItemIdentifier())) { + return false; + } + Feed feed = fi.getFeed(); + return feed != null && TextUtils.equals(metadata.getString(KEY_FEED_URL), feed.getDownload_url()); + } + + /** + * Compares a {@link MediaInfo} instance with a {@link RemoteMedia} one and evaluates whether they + * represent the same podcast episode. + * + * @param info the {@link MediaInfo} object to be compared. + * @param media the {@link RemoteMedia} object to be compared. + * @return <true>true</true> if there's a match, <code>false</code> otherwise. + * + * @see RemoteMedia#equals(Object) + */ + public static boolean matches(MediaInfo info, RemoteMedia media) { + if (info == null || media == null) { + return false; + } + if (!TextUtils.equals(info.getContentId(), media.getStreamUrl())) { + return false; + } + MediaMetadata metadata = info.getMetadata(); + return metadata != null && + TextUtils.equals(metadata.getString(KEY_EPISODE_IDENTIFIER), media.getEpisodeIdentifier()) && + TextUtils.equals(metadata.getString(KEY_FEED_URL), media.getFeedUrl()); + } + + /** + * Compares a {@link MediaInfo} instance with a {@link Playable} and evaluates whether they + * represent the same podcast episode. Useful every time we get a MediaInfo from the Cast Device + * and want to avoid unnecessary conversions. + * + * @param info the {@link MediaInfo} object to be compared. + * @param media the {@link Playable} object to be compared. + * @return <true>true</true> if there's a match, <code>false</code> otherwise. + * + * @see RemoteMedia#equals(Object) + */ + public static boolean matches(MediaInfo info, Playable media) { + if (info == null || media == null) { + return false; + } + if (media instanceof RemoteMedia) { + return matches(info, (RemoteMedia) media); + } + return media instanceof FeedMedia && matches(info, (FeedMedia) media); + } + + + //TODO Queue handling perhaps +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/cast/DefaultCastConsumer.java b/core/src/play/java/de/danoeh/antennapod/core/cast/DefaultCastConsumer.java new file mode 100644 index 000000000..fe4183d54 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/cast/DefaultCastConsumer.java @@ -0,0 +1,10 @@ +package de.danoeh.antennapod.core.cast; + +import com.google.android.libraries.cast.companionlibrary.cast.callbacks.VideoCastConsumerImpl; + +public class DefaultCastConsumer extends VideoCastConsumerImpl implements CastConsumer { + @Override + public void onStreamVolumeChanged(double value, boolean isMute) { + // no-op + } +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/cast/RemoteMedia.java b/core/src/play/java/de/danoeh/antennapod/core/cast/RemoteMedia.java new file mode 100644 index 000000000..a3ac87062 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/cast/RemoteMedia.java @@ -0,0 +1,363 @@ +package de.danoeh.antennapod.core.cast; + +import android.content.Context; +import android.content.SharedPreferences; +import android.net.Uri; +import android.os.Parcel; +import android.os.Parcelable; +import android.support.annotation.Nullable; +import android.text.TextUtils; + +import com.google.android.gms.cast.MediaInfo; +import com.google.android.gms.cast.MediaMetadata; +import com.google.android.gms.common.images.WebImage; + +import java.util.Calendar; +import java.util.Date; +import java.util.List; +import java.util.concurrent.Callable; + +import de.danoeh.antennapod.core.feed.Chapter; +import de.danoeh.antennapod.core.feed.Feed; +import de.danoeh.antennapod.core.feed.FeedItem; +import de.danoeh.antennapod.core.feed.FeedMedia; +import de.danoeh.antennapod.core.feed.MediaType; +import de.danoeh.antennapod.core.storage.DBReader; +import de.danoeh.antennapod.core.util.ChapterUtils; +import de.danoeh.antennapod.core.util.playback.Playable; + +import org.apache.commons.lang3.builder.HashCodeBuilder; + +/** + * Playable implementation for media on a Cast Device for which a local version of + * {@link de.danoeh.antennapod.core.feed.FeedMedia} hasn't been found. + */ +public class RemoteMedia implements Playable { + public static final String TAG = "RemoteMedia"; + + public static final int PLAYABLE_TYPE_REMOTE_MEDIA = 3; + + private String downloadUrl; + private String itemIdentifier; + private String feedUrl; + private String feedTitle; + private String episodeTitle; + private String episodeLink; + private String feedAuthor; + private String imageUrl; + private String feedLink; + private String mime_type; + private Date pubDate; + private String notes; + private List<Chapter> chapters; + private int duration; + private int position; + private long lastPlayedTime; + + public RemoteMedia(String downloadUrl, String itemId, String feedUrl, String feedTitle, + String episodeTitle, String episodeLink, String feedAuthor, + String imageUrl, String feedLink, String mime_type, Date pubDate) { + this.downloadUrl = downloadUrl; + this.itemIdentifier = itemId; + this.feedUrl = feedUrl; + this.feedTitle = feedTitle; + this.episodeTitle = episodeTitle; + this.episodeLink = episodeLink; + this.feedAuthor = feedAuthor; + this.imageUrl = imageUrl; + this.feedLink = feedLink; + this.mime_type = mime_type; + this.pubDate = pubDate; + } + + public void setNotes(String notes) { + this.notes = notes; + } + + public MediaInfo extractMediaInfo() { + MediaMetadata metadata = new MediaMetadata(MediaMetadata.MEDIA_TYPE_GENERIC); + + metadata.putString(MediaMetadata.KEY_TITLE, episodeTitle); + metadata.putString(MediaMetadata.KEY_SUBTITLE, feedTitle); + if (!TextUtils.isEmpty(imageUrl)) { + metadata.addImage(new WebImage(Uri.parse(imageUrl))); + } + Calendar calendar = Calendar.getInstance(); + calendar.setTime(pubDate); + metadata.putDate(MediaMetadata.KEY_RELEASE_DATE, calendar); + if (!TextUtils.isEmpty(feedAuthor)) { + metadata.putString(MediaMetadata.KEY_ARTIST, feedAuthor); + } + if (!TextUtils.isEmpty(feedUrl)) { + metadata.putString(CastUtils.KEY_FEED_URL, feedUrl); + } + if (!TextUtils.isEmpty(feedLink)) { + metadata.putString(CastUtils.KEY_FEED_WEBSITE, feedLink); + } + if (!TextUtils.isEmpty(itemIdentifier)) { + metadata.putString(CastUtils.KEY_EPISODE_IDENTIFIER, itemIdentifier); + } else { + metadata.putString(CastUtils.KEY_EPISODE_IDENTIFIER, downloadUrl); + } + if (!TextUtils.isEmpty(episodeLink)) { + metadata.putString(CastUtils.KEY_EPISODE_LINK, episodeLink); + } + String notes = this.notes; + if (notes != null) { + if (notes.length() > CastUtils.EPISODE_NOTES_MAX_LENGTH) { + notes = notes.substring(0, CastUtils.EPISODE_NOTES_MAX_LENGTH); + } + metadata.putString(CastUtils.KEY_EPISODE_NOTES, notes); + } + // Default id value + metadata.putInt(CastUtils.KEY_MEDIA_ID, 0); + metadata.putInt(CastUtils.KEY_FORMAT_VERSION, CastUtils.FORMAT_VERSION_VALUE); + + MediaInfo.Builder builder = new MediaInfo.Builder(downloadUrl) + .setContentType(mime_type) + .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED) + .setMetadata(metadata); + if (duration > 0) { + builder.setStreamDuration(duration); + } + return builder.build(); + } + + public String getEpisodeIdentifier() { + return itemIdentifier; + } + + public String getFeedUrl() { + return feedUrl; + } + + public FeedMedia lookForFeedMedia() { + FeedItem feedItem = DBReader.getFeedItem(feedUrl, itemIdentifier); + if (feedItem == null) { + return null; + } + return feedItem.getMedia(); + } + + @Override + public void writeToPreferences(SharedPreferences.Editor prefEditor) { + //it seems pointless to do it, since the session should be kept by the remote device. + } + + @Override + public void loadMetadata() throws PlayableException { + //Already loaded + } + + @Override + public void loadChapterMarks() { + ChapterUtils.loadChaptersFromStreamUrl(this); + } + + @Override + public String getEpisodeTitle() { + return episodeTitle; + } + + @Override + public List<Chapter> getChapters() { + return chapters; + } + + @Override + public String getWebsiteLink() { + if (episodeLink != null) { + return episodeLink; + } else { + return feedUrl; + } + } + + @Override + public String getPaymentLink() { + return null; + } + + @Override + public String getFeedTitle() { + return feedTitle; + } + + @Override + public Object getIdentifier() { + return itemIdentifier + "@" + feedUrl; + } + + @Override + public int getDuration() { + return duration; + } + + @Override + public int getPosition() { + return position; + } + + @Override + public long getLastPlayedTime() { + return lastPlayedTime; + } + + @Override + public MediaType getMediaType() { + return MediaType.fromMimeType(mime_type); + } + + @Override + public String getLocalMediaUrl() { + return null; + } + + @Override + public String getStreamUrl() { + return downloadUrl; + } + + @Override + public boolean localFileAvailable() { + return false; + } + + @Override + public boolean streamAvailable() { + return true; + } + + @Override + public void saveCurrentPosition(SharedPreferences pref, int newPosition, long timestamp) { + //we're not saving playback information for this kind of items on preferences + setPosition(newPosition); + setLastPlayedTime(timestamp); + } + + @Override + public void setPosition(int newPosition) { + position = newPosition; + } + + @Override + public void setDuration(int newDuration) { + duration = newDuration; + } + + @Override + public void setLastPlayedTime(long lastPlayedTimestamp) { + lastPlayedTime = lastPlayedTimestamp; + } + + @Override + public void onPlaybackStart() { + // no-op + } + + @Override + public void onPlaybackPause(Context context) { + // no-op + } + + @Override + public void onPlaybackCompleted(Context context) { + // no-op + } + + @Override + public int getPlayableType() { + return PLAYABLE_TYPE_REMOTE_MEDIA; + } + + @Override + public void setChapters(List<Chapter> chapters) { + this.chapters = chapters; + } + + @Override + @Nullable + public String getImageLocation() { + return imageUrl; + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public Callable<String> loadShownotes() { + return () -> (notes != null) ? notes : ""; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(downloadUrl); + dest.writeString(itemIdentifier); + dest.writeString(feedUrl); + dest.writeString(feedTitle); + dest.writeString(episodeTitle); + dest.writeString(episodeLink); + dest.writeString(feedAuthor); + dest.writeString(imageUrl); + dest.writeString(feedLink); + dest.writeString(mime_type); + dest.writeLong(pubDate.getTime()); + dest.writeString(notes); + dest.writeInt(duration); + dest.writeInt(position); + dest.writeLong(lastPlayedTime); + } + + public static final Parcelable.Creator<RemoteMedia> CREATOR = new Parcelable.Creator<RemoteMedia>() { + @Override + public RemoteMedia createFromParcel(Parcel in) { + RemoteMedia result = new RemoteMedia(in.readString(), in.readString(), in.readString(), + in.readString(), in.readString(), in.readString(), in.readString(), in.readString(), + in.readString(), in.readString(), new Date(in.readLong())); + result.setNotes(in.readString()); + result.setDuration(in.readInt()); + result.setPosition(in.readInt()); + result.setLastPlayedTime(in.readLong()); + return result; + } + + @Override + public RemoteMedia[] newArray(int size) { + return new RemoteMedia[size]; + } + }; + + @Override + public boolean equals(Object other) { + if (other instanceof RemoteMedia) { + RemoteMedia rm = (RemoteMedia) other; + return TextUtils.equals(downloadUrl, rm.downloadUrl) && + TextUtils.equals(feedUrl, rm.feedUrl) && + TextUtils.equals(itemIdentifier, rm.itemIdentifier); + } + if (other instanceof FeedMedia) { + FeedMedia fm = (FeedMedia) other; + if (!TextUtils.equals(downloadUrl, fm.getStreamUrl())) { + return false; + } + FeedItem fi = fm.getItem(); + if (fi == null || !TextUtils.equals(itemIdentifier, fi.getItemIdentifier())) { + return false; + } + Feed feed = fi.getFeed(); + return feed != null && TextUtils.equals(feedUrl, feed.getDownload_url()); + } + return false; + } + + @Override + public int hashCode() { + return new HashCodeBuilder() + .append(downloadUrl) + .append(feedUrl) + .append(itemIdentifier) + .toHashCode(); + } +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/cast/SwitchableMediaRouteActionProvider.java b/core/src/play/java/de/danoeh/antennapod/core/cast/SwitchableMediaRouteActionProvider.java new file mode 100644 index 000000000..f063cf5e3 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/cast/SwitchableMediaRouteActionProvider.java @@ -0,0 +1,106 @@ +package de.danoeh.antennapod.core.cast; + +import android.app.Activity; +import android.content.Context; +import android.content.ContextWrapper; +import android.support.v4.app.FragmentActivity; +import android.support.v4.app.FragmentManager; +import android.support.v7.app.MediaRouteActionProvider; +import android.support.v7.app.MediaRouteChooserDialogFragment; +import android.support.v7.app.MediaRouteControllerDialogFragment; +import android.support.v7.media.MediaRouter; +import android.util.Log; + +/** + * <p>Action Provider that extends {@link MediaRouteActionProvider} and allows the client to + * disable completely the button by calling {@link #setEnabled(boolean)}.</p> + * + * <p>It is disabled by default, so if a client wants to initially have it enabled it must call + * <code>setEnabled(true)</code>.</p> + */ +public class SwitchableMediaRouteActionProvider extends MediaRouteActionProvider { + public static final String TAG = "SwitchblMediaRtActProv"; + + private static final String CHOOSER_FRAGMENT_TAG = + "android.support.v7.mediarouter:MediaRouteChooserDialogFragment"; + private static final String CONTROLLER_FRAGMENT_TAG = + "android.support.v7.mediarouter:MediaRouteControllerDialogFragment"; + private boolean enabled; + + public SwitchableMediaRouteActionProvider(Context context) { + super(context); + enabled = false; + } + + /** + * <p>Sets whether the Media Router button should be allowed to become visible or not.</p> + * + * <p>It's invisible by default.</p> + */ + public void setEnabled(boolean newVal) { + enabled = newVal; + refreshVisibility(); + } + + @Override + public boolean isVisible() { + return enabled && super.isVisible(); + } + + @Override + public boolean onPerformDefaultAction() { + if (!super.onPerformDefaultAction()) { + // there is no button, but we should still show the dialog if it's the case. + if (!isVisible()) { + return false; + } + FragmentManager fm = getFragmentManager(); + if (fm == null) { + return false; + } + MediaRouter.RouteInfo route = MediaRouter.getInstance(getContext()).getSelectedRoute(); + if (route.isDefault() || !route.matchesSelector(getRouteSelector())) { + if (fm.findFragmentByTag(CHOOSER_FRAGMENT_TAG) != null) { + Log.w(TAG, "showDialog(): Route chooser dialog already showing!"); + return false; + } + MediaRouteChooserDialogFragment f = + getDialogFactory().onCreateChooserDialogFragment(); + f.setRouteSelector(getRouteSelector()); + f.show(fm, CHOOSER_FRAGMENT_TAG); + } else { + if (fm.findFragmentByTag(CONTROLLER_FRAGMENT_TAG) != null) { + Log.w(TAG, "showDialog(): Route controller dialog already showing!"); + return false; + } + MediaRouteControllerDialogFragment f = + getDialogFactory().onCreateControllerDialogFragment(); + f.show(fm, CONTROLLER_FRAGMENT_TAG); + } + return true; + + } else { + return true; + } + } + + private FragmentManager getFragmentManager() { + Activity activity = getActivity(); + if (activity instanceof FragmentActivity) { + return ((FragmentActivity)activity).getSupportFragmentManager(); + } + return null; + } + + private Activity getActivity() { + // Gross way of unwrapping the Activity so we can get the FragmentManager + Context context = getContext(); + while (context instanceof ContextWrapper) { + if (context instanceof Activity) { + return (Activity)context; + } + context = ((ContextWrapper)context).getBaseContext(); + } + return null; + } +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/feed/FeedMediaFlavorHelper.java b/core/src/play/java/de/danoeh/antennapod/core/feed/FeedMediaFlavorHelper.java new file mode 100644 index 000000000..fe0f771d6 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/feed/FeedMediaFlavorHelper.java @@ -0,0 +1,13 @@ +package de.danoeh.antennapod.core.feed; + +import de.danoeh.antennapod.core.cast.RemoteMedia; + +/** + * Implements methods for FeedMedia that are flavor dependent. + */ +public class FeedMediaFlavorHelper { + private FeedMediaFlavorHelper(){} + static boolean instanceOfRemoteMedia(Object o) { + return o instanceof RemoteMedia; + } +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/service/playback/PlaybackServiceFlavorHelper.java b/core/src/play/java/de/danoeh/antennapod/core/service/playback/PlaybackServiceFlavorHelper.java new file mode 100644 index 000000000..0cca2ffa4 --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/service/playback/PlaybackServiceFlavorHelper.java @@ -0,0 +1,279 @@ +package de.danoeh.antennapod.core.service.playback; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.net.NetworkInfo; +import android.net.wifi.WifiManager; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.annotation.StringRes; +import android.support.v4.media.session.MediaSessionCompat; +import android.support.v4.media.session.PlaybackStateCompat; +import android.support.v7.media.MediaRouter; +import android.support.wearable.media.MediaControlConstants; +import android.util.Log; +import android.widget.Toast; + +import com.google.android.gms.cast.ApplicationMetadata; +import com.google.android.libraries.cast.companionlibrary.cast.BaseCastManager; + +import java.util.concurrent.ExecutionException; + +import de.danoeh.antennapod.core.cast.CastConsumer; +import de.danoeh.antennapod.core.cast.CastManager; +import de.danoeh.antennapod.core.cast.DefaultCastConsumer; +import de.danoeh.antennapod.core.feed.MediaType; +import de.danoeh.antennapod.core.preferences.UserPreferences; +import de.danoeh.antennapod.core.util.NetworkUtils; + +/** + * Class intended to work along PlaybackService and provide support for different flavors. + */ +public class PlaybackServiceFlavorHelper { + public static final String TAG = "PlaybackSrvFlavorHelper"; + + /** + * Time in seconds during which the CastManager will try to reconnect to the Cast Device after + * the Wifi Connection is regained. + */ + private static final int RECONNECTION_ATTEMPT_PERIOD_S = 15; + /** + * Stores the state of the cast playback just before it disconnects. + */ + private volatile PlaybackServiceMediaPlayer.PSMPInfo infoBeforeCastDisconnection; + + private boolean wifiConnectivity = true; + private BroadcastReceiver wifiBroadcastReceiver; + + private CastManager castManager; + private MediaRouter mediaRouter; + private PlaybackService.FlavorHelperCallback callback; + private CastConsumer castConsumer; + + PlaybackServiceFlavorHelper(Context context, PlaybackService.FlavorHelperCallback callback) { + this.callback = callback; + mediaRouter = MediaRouter.getInstance(context.getApplicationContext()); + setCastConsumer(context); + } + + void initializeMediaPlayer(Context context) { + castManager = CastManager.getInstance(); + castManager.addCastConsumer(castConsumer); + boolean isCasting = castManager.isConnected(); + callback.setIsCasting(isCasting); + if (isCasting) { + if (UserPreferences.isCastEnabled()) { + onCastAppConnected(context, false); + } else { + castManager.disconnect(); + } + } else { + callback.setMediaPlayer(new LocalPSMP(context, callback.getMediaPlayerCallback())); + } + } + + void removeCastConsumer() { + castManager.removeCastConsumer(castConsumer); + } + + boolean castDisconnect(boolean castDisconnect) { + if (castDisconnect) { + castManager.disconnect(); + } + return castDisconnect; + } + + boolean onMediaPlayerInfo(Context context, int code, @StringRes int resourceId) { + switch (code) { + case RemotePSMP.CAST_ERROR: + callback.sendNotificationBroadcast(PlaybackService.NOTIFICATION_TYPE_SHOW_TOAST, resourceId); + return true; + case RemotePSMP.CAST_ERROR_PRIORITY_HIGH: + Toast.makeText(context, resourceId, Toast.LENGTH_SHORT).show(); + return true; + default: + return false; + } + } + + private void setCastConsumer(Context context) { + castConsumer = new DefaultCastConsumer() { + @Override + public void onApplicationConnected(ApplicationMetadata appMetadata, String sessionId, boolean wasLaunched) { + onCastAppConnected(context, wasLaunched); + } + + @Override + public void onDisconnectionReason(int reason) { + Log.d(TAG, "onDisconnectionReason() with code " + reason); + // This is our final chance to update the underlying stream position + // In onDisconnected(), the underlying CastPlayback#mVideoCastConsumer + // is disconnected and hence we update our local value of stream position + // to the latest position. + PlaybackServiceMediaPlayer mediaPlayer = callback.getMediaPlayer(); + if (mediaPlayer != null) { + callback.saveCurrentPosition(true, null, PlaybackServiceMediaPlayer.INVALID_TIME); + infoBeforeCastDisconnection = mediaPlayer.getPSMPInfo(); + if (reason != BaseCastManager.DISCONNECT_REASON_EXPLICIT && + infoBeforeCastDisconnection.playerStatus == PlayerStatus.PLAYING) { + // If it's NOT based on user action, we shouldn't automatically resume local playback + infoBeforeCastDisconnection.playerStatus = PlayerStatus.PAUSED; + } + } + } + + @Override + public void onDisconnected() { + Log.d(TAG, "onDisconnected()"); + callback.setIsCasting(false); + PlaybackServiceMediaPlayer.PSMPInfo info = infoBeforeCastDisconnection; + infoBeforeCastDisconnection = null; + PlaybackServiceMediaPlayer mediaPlayer = callback.getMediaPlayer(); + if (info == null && mediaPlayer != null) { + info = mediaPlayer.getPSMPInfo(); + } + if (info == null) { + info = new PlaybackServiceMediaPlayer.PSMPInfo(PlayerStatus.INDETERMINATE, + PlayerStatus.STOPPED, null); + } + switchMediaPlayer(new LocalPSMP(context, callback.getMediaPlayerCallback()), + info, true); + if (info.playable != null) { + callback.sendNotificationBroadcast(PlaybackService.NOTIFICATION_TYPE_RELOAD, + info.playable.getMediaType() == MediaType.AUDIO ? + PlaybackService.EXTRA_CODE_AUDIO : PlaybackService.EXTRA_CODE_VIDEO); + } else { + Log.d(TAG, "Cast session disconnected, but no current media"); + callback.sendNotificationBroadcast(PlaybackService.NOTIFICATION_TYPE_PLAYBACK_END, 0); + } + // hardware volume buttons control the local device volume + mediaRouter.setMediaSessionCompat(null); + unregisterWifiBroadcastReceiver(); + callback.setupNotification(false, info); + } + }; + } + + private void onCastAppConnected(Context context, boolean wasLaunched) { + Log.d(TAG, "A cast device application was " + (wasLaunched ? "launched" : "joined")); + callback.setIsCasting(true); + PlaybackServiceMediaPlayer.PSMPInfo info = null; + PlaybackServiceMediaPlayer mediaPlayer = callback.getMediaPlayer(); + if (mediaPlayer != null) { + info = mediaPlayer.getPSMPInfo(); + if (info.playerStatus == PlayerStatus.PLAYING) { + // could be pause, but this way we make sure the new player will get the correct position, + // since pause runs asynchronously and we could be directing the new player to play even before + // the old player gives us back the position. + callback.saveCurrentPosition(true, null, PlaybackServiceMediaPlayer.INVALID_TIME); + } + } + if (info == null) { + info = new PlaybackServiceMediaPlayer.PSMPInfo(PlayerStatus.INDETERMINATE, PlayerStatus.STOPPED, null); + } + callback.sendNotificationBroadcast(PlaybackService.NOTIFICATION_TYPE_RELOAD, + PlaybackService.EXTRA_CODE_CAST); + switchMediaPlayer(new RemotePSMP(context, callback.getMediaPlayerCallback()), + info, + wasLaunched); + // hardware volume buttons control the remote device volume + mediaRouter.setMediaSessionCompat(callback.getMediaSession()); + registerWifiBroadcastReceiver(); + callback.setupNotification(true, info); + } + + private void switchMediaPlayer(@NonNull PlaybackServiceMediaPlayer newPlayer, + @NonNull PlaybackServiceMediaPlayer.PSMPInfo info, + boolean wasLaunched) { + PlaybackServiceMediaPlayer mediaPlayer = callback.getMediaPlayer(); + if (mediaPlayer != null) { + try { + mediaPlayer.stopPlayback(false).get(); + } catch (InterruptedException | ExecutionException e) { + Log.e(TAG, "There was a problem stopping playback while switching media players", e); + } + mediaPlayer.shutdownQuietly(); + } + mediaPlayer = newPlayer; + callback.setMediaPlayer(mediaPlayer); + Log.d(TAG, "switched to " + mediaPlayer.getClass().getSimpleName()); + if (!wasLaunched) { + PlaybackServiceMediaPlayer.PSMPInfo candidate = mediaPlayer.getPSMPInfo(); + if (candidate.playable != null && + candidate.playerStatus.isAtLeast(PlayerStatus.PREPARING)) { + // do not automatically send new media to cast device + info.playable = null; + } + } + if (info.playable != null) { + mediaPlayer.playMediaObject(info.playable, + !info.playable.localFileAvailable(), + info.playerStatus == PlayerStatus.PLAYING, + info.playerStatus.isAtLeast(PlayerStatus.PREPARING)); + } + } + + void registerWifiBroadcastReceiver() { + if (wifiBroadcastReceiver != null) { + return; + } + wifiBroadcastReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + if (intent.getAction().equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) { + NetworkInfo info = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO); + boolean isConnected = info.isConnected(); + //apparently this method gets called twice when a change happens, but one run is enough. + if (isConnected && !wifiConnectivity) { + wifiConnectivity = true; + castManager.startCastDiscovery(); + castManager.reconnectSessionIfPossible(RECONNECTION_ATTEMPT_PERIOD_S, NetworkUtils.getWifiSsid()); + } else { + wifiConnectivity = isConnected; + } + } + } + }; + callback.registerReceiver(wifiBroadcastReceiver, + new IntentFilter(WifiManager.NETWORK_STATE_CHANGED_ACTION)); + } + + void unregisterWifiBroadcastReceiver() { + if (wifiBroadcastReceiver != null) { + callback.unregisterReceiver(wifiBroadcastReceiver); + wifiBroadcastReceiver = null; + } + } + + boolean onSharedPreference(String key) { + if (UserPreferences.PREF_CAST_ENABLED.equals(key)) { + if (!UserPreferences.isCastEnabled()) { + if (castManager.isConnecting() || castManager.isConnected()) { + Log.d(TAG, "Disconnecting cast device due to a change in user preferences"); + castManager.disconnect(); + } + } + return true; + } + return false; + } + + void sessionStateAddActionForWear(PlaybackStateCompat.Builder sessionState, String actionName, CharSequence name, int icon) { + PlaybackStateCompat.CustomAction.Builder actionBuilder = + new PlaybackStateCompat.CustomAction.Builder(actionName, name, icon); + Bundle actionExtras = new Bundle(); + actionExtras.putBoolean(MediaControlConstants.EXTRA_CUSTOM_ACTION_SHOW_ON_WEAR, true); + actionBuilder.setExtras(actionExtras); + + sessionState.addCustomAction(actionBuilder.build()); + } + + void mediaSessionSetExtraForWear(MediaSessionCompat mediaSession) { + Bundle sessionExtras = new Bundle(); + sessionExtras.putBoolean(MediaControlConstants.EXTRA_RESERVE_SLOT_SKIP_TO_PREVIOUS, true); + sessionExtras.putBoolean(MediaControlConstants.EXTRA_RESERVE_SLOT_SKIP_TO_NEXT, true); + mediaSession.setExtras(sessionExtras); + } +} diff --git a/core/src/play/java/de/danoeh/antennapod/core/service/playback/RemotePSMP.java b/core/src/play/java/de/danoeh/antennapod/core/service/playback/RemotePSMP.java new file mode 100644 index 000000000..79e058d0c --- /dev/null +++ b/core/src/play/java/de/danoeh/antennapod/core/service/playback/RemotePSMP.java @@ -0,0 +1,676 @@ +package de.danoeh.antennapod.core.service.playback; + +import android.content.Context; +import android.media.MediaPlayer; +import android.support.annotation.NonNull; +import android.util.Log; +import android.util.Pair; +import android.view.SurfaceHolder; + +import com.google.android.gms.cast.Cast; +import com.google.android.gms.cast.CastStatusCodes; +import com.google.android.gms.cast.MediaInfo; +import com.google.android.gms.cast.MediaStatus; +import com.google.android.libraries.cast.companionlibrary.cast.exceptions.CastException; +import com.google.android.libraries.cast.companionlibrary.cast.exceptions.NoConnectionException; +import com.google.android.libraries.cast.companionlibrary.cast.exceptions.TransientNetworkDisconnectionException; + +import java.util.concurrent.Future; +import java.util.concurrent.FutureTask; +import java.util.concurrent.atomic.AtomicBoolean; + +import de.danoeh.antennapod.core.R; +import de.danoeh.antennapod.core.cast.CastConsumer; +import de.danoeh.antennapod.core.cast.CastManager; +import de.danoeh.antennapod.core.cast.CastUtils; +import de.danoeh.antennapod.core.cast.DefaultCastConsumer; +import de.danoeh.antennapod.core.cast.RemoteMedia; +import de.danoeh.antennapod.core.feed.FeedMedia; +import de.danoeh.antennapod.core.feed.MediaType; +import de.danoeh.antennapod.core.preferences.UserPreferences; +import de.danoeh.antennapod.core.util.RewindAfterPauseUtils; +import de.danoeh.antennapod.core.util.playback.Playable; + +/** + * Implementation of PlaybackServiceMediaPlayer suitable for remote playback on Cast Devices. + */ +public class RemotePSMP extends PlaybackServiceMediaPlayer { + + public static final String TAG = "RemotePSMP"; + + public static final int CAST_ERROR = 3001; + + public static final int CAST_ERROR_PRIORITY_HIGH = 3005; + + private final CastManager castMgr; + + private volatile Playable media; + private volatile MediaType mediaType; + private volatile MediaInfo remoteMedia; + private volatile int remoteState; + + private final AtomicBoolean isBuffering; + + private final AtomicBoolean startWhenPrepared; + + public RemotePSMP(@NonNull Context context, @NonNull PSMPCallback callback) { + super(context, callback); + + castMgr = CastManager.getInstance(); + media = null; + mediaType = null; + startWhenPrepared = new AtomicBoolean(false); + isBuffering = new AtomicBoolean(false); + remoteState = MediaStatus.PLAYER_STATE_UNKNOWN; + + try { + if (castMgr.isConnected() && castMgr.isRemoteMediaLoaded()) { + onRemoteMediaPlayerStatusUpdated(); + } + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to do initial check for loaded media", e); + } + + castMgr.addCastConsumer(castConsumer); + } + + private CastConsumer castConsumer = new DefaultCastConsumer() { + @Override + public void onRemoteMediaPlayerMetadataUpdated() { + RemotePSMP.this.onRemoteMediaPlayerStatusUpdated(); + } + + @Override + public void onRemoteMediaPlayerStatusUpdated() { + RemotePSMP.this.onRemoteMediaPlayerStatusUpdated(); + } + + @Override + public void onMediaLoadResult(int statusCode) { + if (playerStatus == PlayerStatus.PREPARING) { + if (statusCode == CastStatusCodes.SUCCESS) { + setPlayerStatus(PlayerStatus.PREPARED, media); + if (media.getDuration() == 0) { + Log.d(TAG, "Setting duration of media"); + try { + media.setDuration((int) castMgr.getMediaDuration()); + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to get remote media's duration"); + } + } + } else if (statusCode != CastStatusCodes.REPLACED){ + Log.d(TAG, "Remote media failed to load"); + setPlayerStatus(PlayerStatus.INITIALIZED, media); + } + } else { + Log.d(TAG, "onMediaLoadResult called, but Player Status wasn't in preparing state, so we ignore the result"); + } + } + + @Override + public void onApplicationStatusChanged(String appStatus) { + if (playerStatus != PlayerStatus.PLAYING) { + Log.d(TAG, "onApplicationStatusChanged, but no media was playing"); + return; + } + boolean playbackEnded = false; + try { + int standbyState = castMgr.getApplicationStandbyState(); + Log.d(TAG, "standbyState: " + standbyState); + playbackEnded = standbyState == Cast.STANDBY_STATE_YES; + } catch (IllegalStateException e) { + Log.d(TAG, "unable to get standbyState on onApplicationStatusChanged()"); + } + if (playbackEnded) { + // This is an unconventional thing to occur... + Log.w(TAG, "Somehow, Chromecast went from playing directly to standby mode"); + endPlayback(false, false, true, true); + } + } + + @Override + public void onFailed(int resourceId, int statusCode) { + callback.onMediaPlayerInfo(CAST_ERROR, resourceId); + } + }; + + private void setBuffering(boolean buffering) { + if (buffering && isBuffering.compareAndSet(false, true)) { + callback.onMediaPlayerInfo(MediaPlayer.MEDIA_INFO_BUFFERING_START, 0); + } else if (!buffering && isBuffering.compareAndSet(true, false)) { + callback.onMediaPlayerInfo(MediaPlayer.MEDIA_INFO_BUFFERING_END, 0); + } + } + + private Playable localVersion(MediaInfo info){ + if (info == null) { + return null; + } + if (CastUtils.matches(info, media)) { + return media; + } + return CastUtils.getPlayable(info, true); + } + + private MediaInfo remoteVersion(Playable playable) { + if (playable == null) { + return null; + } + if (CastUtils.matches(remoteMedia, playable)) { + return remoteMedia; + } + if (playable instanceof FeedMedia) { + return CastUtils.convertFromFeedMedia((FeedMedia) playable); + } + if (playable instanceof RemoteMedia) { + return ((RemoteMedia) playable).extractMediaInfo(); + } + return null; + } + + private void onRemoteMediaPlayerStatusUpdated() { + MediaStatus status = castMgr.getMediaStatus(); + if (status == null) { + Log.d(TAG, "Received null MediaStatus"); + return; + } else { + Log.d(TAG, "Received remote status/media update. New state=" + status.getPlayerState()); + } + int state = status.getPlayerState(); + int oldState = remoteState; + remoteMedia = status.getMediaInfo(); + boolean mediaChanged = !CastUtils.matches(remoteMedia, media); + boolean stateChanged = state != oldState; + if (!mediaChanged && !stateChanged) { + Log.d(TAG, "Both media and state haven't changed, so nothing to do"); + return; + } + Playable currentMedia = mediaChanged ? localVersion(remoteMedia) : media; + Playable oldMedia = media; + int position = (int) status.getStreamPosition(); + // check for incompatible states + if ((state == MediaStatus.PLAYER_STATE_PLAYING || state == MediaStatus.PLAYER_STATE_PAUSED) + && currentMedia == null) { + Log.w(TAG, "RemoteMediaPlayer returned playing or pausing state, but with no media"); + state = MediaStatus.PLAYER_STATE_UNKNOWN; + stateChanged = oldState != MediaStatus.PLAYER_STATE_UNKNOWN; + } + + if (stateChanged) { + remoteState = state; + } + + if (mediaChanged && stateChanged && oldState == MediaStatus.PLAYER_STATE_PLAYING && + state != MediaStatus.PLAYER_STATE_IDLE) { + callback.onPlaybackPause(null, INVALID_TIME); + // We don't want setPlayerStatus to handle the onPlaybackPause callback + setPlayerStatus(PlayerStatus.INDETERMINATE, currentMedia); + } + + setBuffering(state == MediaStatus.PLAYER_STATE_BUFFERING); + + switch (state) { + case MediaStatus.PLAYER_STATE_PLAYING: + if (!stateChanged) { + //These steps are necessary because they won't be performed by setPlayerStatus() + if (position >= 0) { + currentMedia.setPosition(position); + } + currentMedia.onPlaybackStart(); + } + setPlayerStatus(PlayerStatus.PLAYING, currentMedia, position); + break; + case MediaStatus.PLAYER_STATE_PAUSED: + setPlayerStatus(PlayerStatus.PAUSED, currentMedia, position); + break; + case MediaStatus.PLAYER_STATE_BUFFERING: + setPlayerStatus((mediaChanged || playerStatus == PlayerStatus.PREPARING) ? + PlayerStatus.PREPARING : PlayerStatus.SEEKING, + currentMedia, + currentMedia != null ? currentMedia.getPosition() : INVALID_TIME); + break; + case MediaStatus.PLAYER_STATE_IDLE: + int reason = status.getIdleReason(); + switch (reason) { + case MediaStatus.IDLE_REASON_CANCELED: + // Essentially means stopped at the request of a user + callback.onPlaybackEnded(null, true); + setPlayerStatus(PlayerStatus.STOPPED, currentMedia); + if (oldMedia != null) { + if (position >= 0) { + oldMedia.setPosition(position); + } + callback.onPostPlayback(oldMedia, false, false, false); + } + // onPlaybackEnded pretty much takes care of updating the UI + return; + case MediaStatus.IDLE_REASON_INTERRUPTED: + // Means that a request to load a different media was sent + // Not sure if currentMedia already reflects the to be loaded one + if (mediaChanged && oldState == MediaStatus.PLAYER_STATE_PLAYING) { + callback.onPlaybackPause(null, INVALID_TIME); + setPlayerStatus(PlayerStatus.INDETERMINATE, currentMedia); + } + setPlayerStatus(PlayerStatus.PREPARING, currentMedia); + break; + case MediaStatus.IDLE_REASON_NONE: + // This probably only happens when we connected but no command has been sent yet. + setPlayerStatus(PlayerStatus.INITIALIZED, currentMedia); + break; + case MediaStatus.IDLE_REASON_FINISHED: + // This is our onCompletionListener... + if (mediaChanged && currentMedia != null) { + media = currentMedia; + } + endPlayback(true, false, true, true); + return; + case MediaStatus.IDLE_REASON_ERROR: + Log.w(TAG, "Got an error status from the Chromecast. Skipping, if possible, to the next episode..."); + callback.onMediaPlayerInfo(CAST_ERROR_PRIORITY_HIGH, + R.string.cast_failed_media_error_skipping); + endPlayback(false, false, true, true); + return; + } + break; + case MediaStatus.PLAYER_STATE_UNKNOWN: + if (playerStatus != PlayerStatus.INDETERMINATE || media != currentMedia) { + setPlayerStatus(PlayerStatus.INDETERMINATE, currentMedia); + } + break; + default: + Log.wtf(TAG, "Remote media state undetermined!"); + } + if (mediaChanged) { + callback.onMediaChanged(true); + if (oldMedia != null) { + callback.onPostPlayback(oldMedia, false, false, currentMedia != null); + } + } + } + + @Override + public void playMediaObject(@NonNull final Playable playable, final boolean stream, final boolean startWhenPrepared, final boolean prepareImmediately) { + Log.d(TAG, "playMediaObject() called"); + playMediaObject(playable, false, stream, startWhenPrepared, prepareImmediately); + } + + /** + * Internal implementation of playMediaObject. This method has an additional parameter that allows the caller to force a media player reset even if + * the given playable parameter is the same object as the currently playing media. + * + * @see #playMediaObject(de.danoeh.antennapod.core.util.playback.Playable, boolean, boolean, boolean) + */ + private void playMediaObject(@NonNull final Playable playable, final boolean forceReset, final boolean stream, final boolean startWhenPrepared, final boolean prepareImmediately) { + if (!CastUtils.isCastable(playable)) { + Log.d(TAG, "media provided is not compatible with cast device"); + callback.onMediaPlayerInfo(CAST_ERROR_PRIORITY_HIGH, R.string.cast_not_castable); + Playable nextPlayable = playable; + do { + nextPlayable = callback.getNextInQueue(nextPlayable); + } while (nextPlayable != null && !CastUtils.isCastable(nextPlayable)); + if (nextPlayable != null) { + playMediaObject(nextPlayable, forceReset, stream, startWhenPrepared, prepareImmediately); + } + return; + } + + if (media != null) { + if (!forceReset && media.getIdentifier().equals(playable.getIdentifier()) + && playerStatus == PlayerStatus.PLAYING) { + // episode is already playing -> ignore method call + Log.d(TAG, "Method call to playMediaObject was ignored: media file already playing."); + return; + } else { + // set temporarily to pause in order to update list with current position + boolean isPlaying = playerStatus == PlayerStatus.PLAYING; + int position = media.getPosition(); + try { + isPlaying = castMgr.isRemoteMediaPlaying(); + position = (int) castMgr.getCurrentMediaPosition(); + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to determine whether media was playing, falling back to stored player status", e); + } + if (isPlaying) { + callback.onPlaybackPause(media, position); + } + if (!media.getIdentifier().equals(playable.getIdentifier())) { + final Playable oldMedia = media; + callback.onPostPlayback(oldMedia, false, false, true); + } + + setPlayerStatus(PlayerStatus.INDETERMINATE, null); + } + } + + this.media = playable; + remoteMedia = remoteVersion(playable); + this.mediaType = media.getMediaType(); + this.startWhenPrepared.set(startWhenPrepared); + setPlayerStatus(PlayerStatus.INITIALIZING, media); + try { + media.loadMetadata(); + callback.onMediaChanged(true); + setPlayerStatus(PlayerStatus.INITIALIZED, media); + if (prepareImmediately) { + prepare(); + } + } catch (Playable.PlayableException e) { + Log.e(TAG, "Error while loading media metadata", e); + setPlayerStatus(PlayerStatus.STOPPED, null); + } + } + + @Override + public void resume() { + try { + // TODO see comment on prepare() + // setVolume(UserPreferences.getLeftVolume(), UserPreferences.getRightVolume()); + if (playerStatus == PlayerStatus.PREPARED && media.getPosition() > 0) { + int newPosition = RewindAfterPauseUtils.calculatePositionWithRewind( + media.getPosition(), + media.getLastPlayedTime()); + castMgr.play(newPosition); + } else { + castMgr.play(); + } + } catch (CastException | TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to resume remote playback", e); + } + } + + @Override + public void pause(boolean abandonFocus, boolean reinit) { + try { + if (castMgr.isRemoteMediaPlaying()) { + castMgr.pause(); + } + } catch (CastException | TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to pause", e); + } + } + + @Override + public void prepare() { + if (playerStatus == PlayerStatus.INITIALIZED) { + Log.d(TAG, "Preparing media player"); + setPlayerStatus(PlayerStatus.PREPARING, media); + try { + int position = media.getPosition(); + if (position > 0) { + position = RewindAfterPauseUtils.calculatePositionWithRewind( + position, + media.getLastPlayedTime()); + } + // TODO We're not supporting user set stream volume yet, as we need to make a UI + // that doesn't allow changing playback speed or have different values for left/right + //setVolume(UserPreferences.getLeftVolume(), UserPreferences.getRightVolume()); + castMgr.loadMedia(remoteMedia, startWhenPrepared.get(), position); + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Error loading media", e); + setPlayerStatus(PlayerStatus.INITIALIZED, media); + } + } + } + + @Override + public void reinit() { + Log.d(TAG, "reinit() called"); + if (media != null) { + playMediaObject(media, true, false, startWhenPrepared.get(), false); + } else { + Log.d(TAG, "Call to reinit was ignored: media was null"); + } + } + + @Override + public void seekTo(int t) { + //TODO check other seek implementations and see if there's no issue with sending too many seek commands to the remote media player + try { + if (castMgr.isRemoteMediaLoaded()) { + setPlayerStatus(PlayerStatus.SEEKING, media); + castMgr.seek(t); + } else if (media != null && playerStatus == PlayerStatus.INITIALIZED){ + media.setPosition(t); + startWhenPrepared.set(false); + prepare(); + } + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to seek", e); + } + } + + @Override + public void seekDelta(int d) { + int position = getPosition(); + if (position != INVALID_TIME) { + seekTo(position + d); + } else { + Log.e(TAG, "getPosition() returned INVALID_TIME in seekDelta"); + } + } + + @Override + public int getDuration() { + int retVal = INVALID_TIME; + boolean prepared; + try { + prepared = castMgr.isRemoteMediaLoaded(); + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to check if remote media is loaded", e); + prepared = playerStatus.isAtLeast(PlayerStatus.PREPARED); + } + if (prepared) { + try { + retVal = (int) castMgr.getMediaDuration(); + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to determine remote media's duration", e); + } + } + if(retVal == INVALID_TIME && media != null && media.getDuration() > 0) { + retVal = media.getDuration(); + } + Log.d(TAG, "getDuration() -> " + retVal); + return retVal; + } + + @Override + public int getPosition() { + int retVal = INVALID_TIME; + boolean prepared; + try { + prepared = castMgr.isRemoteMediaLoaded(); + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to check if remote media is loaded", e); + prepared = playerStatus.isAtLeast(PlayerStatus.PREPARED); + } + if (prepared) { + try { + retVal = (int) castMgr.getCurrentMediaPosition(); + } catch (TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to determine remote media's position", e); + } + } + if(retVal <= 0 && media != null && media.getPosition() >= 0) { + retVal = media.getPosition(); + } + Log.d(TAG, "getPosition() -> " + retVal); + return retVal; + } + + @Override + public boolean isStartWhenPrepared() { + return startWhenPrepared.get(); + } + + @Override + public void setStartWhenPrepared(boolean startWhenPrepared) { + this.startWhenPrepared.set(startWhenPrepared); + } + + // As things are right now, changing the return value of this function is not enough to ensure + // all other components recognize it. + @Override + public boolean canSetSpeed() { + return false; + } + + @Override + public void setSpeed(float speed) { + throw new UnsupportedOperationException("Setting playback speed unsupported for Remote Playback"); + } + + @Override + public float getPlaybackSpeed() { + return 1; + } + + @Override + public void setVolume(float volumeLeft, float volumeRight) { + Log.d(TAG, "Setting the Stream volume on Remote Media Player"); + double volume = (volumeLeft+volumeRight)/2; + if (volume > 1.0) { + volume = 1.0; + } + if (volume < 0.0) { + volume = 0.0; + } + try { + castMgr.setStreamVolume(volume); + } catch (TransientNetworkDisconnectionException | NoConnectionException | CastException e) { + Log.e(TAG, "Unable to set the volume", e); + } + } + + @Override + public boolean canDownmix() { + return false; + } + + @Override + public void setDownmix(boolean enable) { + throw new UnsupportedOperationException("Setting downmix unsupported in Remote Media Player"); + } + + @Override + public MediaType getCurrentMediaType() { + return mediaType; + } + + @Override + public boolean isStreaming() { + return true; + } + + @Override + public void shutdown() { + castMgr.removeCastConsumer(castConsumer); + } + + @Override + public void shutdownQuietly() { + shutdown(); + } + + @Override + public void setVideoSurface(SurfaceHolder surface) { + throw new UnsupportedOperationException("Setting Video Surface unsupported in Remote Media Player"); + } + + @Override + public void resetVideoSurface() { + Log.e(TAG, "Resetting Video Surface unsupported in Remote Media Player"); + } + + @Override + public Pair<Integer, Integer> getVideoSize() { + return null; + } + + @Override + public Playable getPlayable() { + return media; + } + + @Override + protected void setPlayable(Playable playable) { + if (playable != media) { + media = playable; + remoteMedia = remoteVersion(playable); + } + } + + @Override + protected Future<?> endPlayback(boolean hasEnded, boolean wasSkipped, boolean shouldContinue, + boolean toStoppedState) { + Log.d(TAG, "endPlayback() called"); + boolean isPlaying = playerStatus == PlayerStatus.PLAYING; + if (playerStatus != PlayerStatus.INDETERMINATE) { + setPlayerStatus(PlayerStatus.INDETERMINATE, media); + } + if (media != null && wasSkipped) { + // current position only really matters when we skip + int position = getPosition(); + if (position >= 0) { + media.setPosition(position); + } + } + final Playable currentMedia = media; + Playable nextMedia = null; + if (shouldContinue) { + nextMedia = callback.getNextInQueue(currentMedia); + + boolean playNextEpisode = isPlaying && nextMedia != null && UserPreferences.isFollowQueue(); + if (playNextEpisode) { + Log.d(TAG, "Playback of next episode will start immediately."); + } else if (nextMedia == null){ + Log.d(TAG, "No more episodes available to play"); + } else { + Log.d(TAG, "Loading next episode, but not playing automatically."); + } + + if (nextMedia != null) { + callback.onPlaybackEnded(nextMedia.getMediaType(), !playNextEpisode); + // setting media to null signals to playMediaObject() that we're taking care of post-playback processing + media = null; + playMediaObject(nextMedia, false, true /*TODO for now we always stream*/, playNextEpisode, playNextEpisode); + } + } + if (shouldContinue || toStoppedState) { + boolean shouldPostProcess = true; + if (nextMedia == null) { + try { + castMgr.stop(); + shouldPostProcess = false; + } catch (CastException | TransientNetworkDisconnectionException | NoConnectionException e) { + Log.e(TAG, "Unable to stop playback", e); + callback.onPlaybackEnded(null, true); + stop(); + } + } + if (shouldPostProcess) { + // Otherwise we rely on the chromecast callback to tell us the playback has stopped. + callback.onPostPlayback(currentMedia, hasEnded, wasSkipped, nextMedia != null); + } + } else if (isPlaying) { + callback.onPlaybackPause(currentMedia, + currentMedia != null ? currentMedia.getPosition() : INVALID_TIME); + } + + FutureTask<?> future = new FutureTask<>(() -> {}, null); + future.run(); + return future; + } + + private void stop() { + if (playerStatus == PlayerStatus.INDETERMINATE) { + setPlayerStatus(PlayerStatus.STOPPED, null); + } else { + Log.d(TAG, "Ignored call to stop: Current player state is: " + playerStatus); + } + } + + @Override + protected boolean shouldLockWifi() { + return false; + } +} |