/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.onemedia.playback; import org.apache.http.Header; import org.apache.http.HttpResponse; import org.apache.http.client.methods.HttpGet; import android.content.Context; import android.media.AudioManager; import android.media.AudioManager.OnAudioFocusChangeListener; import android.media.MediaPlayer; import android.media.MediaPlayer.OnBufferingUpdateListener; import android.media.MediaPlayer.OnCompletionListener; import android.media.MediaPlayer.OnErrorListener; import android.media.MediaPlayer.OnPreparedListener; import android.net.Uri; import android.net.http.AndroidHttpClient; import android.os.AsyncTask; import android.os.Bundle; import android.os.Handler; import android.util.Log; import android.view.SurfaceHolder; import java.io.IOException; import java.util.Map; /** * Helper class for wrapping a MediaPlayer and doing a lot of the default work * to play audio. This class is not currently thread safe and all calls to it * should be made on the same thread. */ public class LocalRenderer extends Renderer implements OnPreparedListener, OnBufferingUpdateListener, OnCompletionListener, OnErrorListener, OnAudioFocusChangeListener { private static final String TAG = "MediaPlayerManager"; private static final boolean DEBUG = true; private static long sDebugInstanceId = 0; private static final String[] SUPPORTED_FEATURES = { FEATURE_SET_CONTENT, FEATURE_SET_NEXT_CONTENT, FEATURE_PLAY, FEATURE_PAUSE, FEATURE_NEXT, FEATURE_PREVIOUS, FEATURE_SEEK_TO, FEATURE_STOP }; /** * These are the states where it is valid to call play directly on the * MediaPlayer. */ private static final int CAN_PLAY = STATE_READY | STATE_PAUSED | STATE_ENDED; /** * These are the states where we expect the MediaPlayer to be ready in the * future, so we can set a flag to start playing when it is. */ private static final int CAN_READY_PLAY = STATE_INIT | STATE_PREPARING; /** * The states when it is valid to call pause on the MediaPlayer. */ private static final int CAN_PAUSE = STATE_PLAYING; /** * The states where it is valid to call seek on the MediaPlayer. */ private static final int CAN_SEEK = STATE_READY | STATE_PLAYING | STATE_PAUSED | STATE_ENDED; /** * The states where we expect the MediaPlayer to be ready in the future and * can store a seek position to set later. */ private static final int CAN_READY_SEEK = STATE_INIT | STATE_PREPARING; /** * The states where it is valid to call stop on the MediaPlayer. */ private static final int CAN_STOP = STATE_READY | STATE_PLAYING | STATE_PAUSED | STATE_ENDED; /** * The states where it is valid to get the current play position and the * duration from the MediaPlayer. */ private static final int CAN_GET_POSITION = STATE_READY | STATE_PLAYING | STATE_PAUSED; private class PlayerContent { public final String source; public final Map<String, String> headers; public PlayerContent(String source, Map<String, String> headers) { this.source = source; this.headers = headers; } } private class AsyncErrorRetriever extends AsyncTask<HttpGet, Void, Void> { private final long errorId; private boolean closeHttpClient; public AsyncErrorRetriever(long errorId) { this.errorId = errorId; closeHttpClient = false; } public boolean cancelRequestLocked(boolean closeHttp) { closeHttpClient = closeHttp; return this.cancel(false); } @Override protected Void doInBackground(HttpGet[] params) { synchronized (mErrorLock) { if (isCancelled() || mHttpClient == null) { if (mErrorRetriever == this) { mErrorRetriever = null; } return null; } mSafeToCloseClient = false; } final PlaybackError error = new PlaybackError(); try { HttpResponse response = mHttpClient.execute(params[0]); synchronized (mErrorLock) { if (mErrorId != errorId || mError == null) { // A new error has occurred, abort return null; } error.type = mError.type; error.extra = mError.extra; error.errorMessage = mError.errorMessage; } final int code = response.getStatusLine().getStatusCode(); if (code >= 300) { error.extra = code; } final Bundle errorExtras = new Bundle(); Header[] headers = response.getAllHeaders(); if (headers != null && headers.length > 0) { for (Header header : headers) { errorExtras.putString(header.getName(), header.getValue()); } error.errorExtras = errorExtras; } } catch (IOException e) { Log.e(TAG, "IOException requesting from server, unable to get more exact error"); } finally { synchronized (mErrorLock) { mSafeToCloseClient = true; if (mErrorRetriever == this) { mErrorRetriever = null; } if (isCancelled()) { if (closeHttpClient) { mHttpClient.close(); mHttpClient = null; } return null; } } } mHandler.post(new Runnable() { @Override public void run() { synchronized (mErrorLock) { if (mErrorId == errorId) { setError(error.type, error.extra, error.errorExtras, null); } } } }); return null; } } private int mState = STATE_INIT; private AudioManager mAudioManager; private MediaPlayer mPlayer; private PlayerContent mContent; private MediaPlayer mNextPlayer; private PlayerContent mNextContent; private SurfaceHolder mHolder; private SurfaceHolder.Callback mHolderCB; private Context mContext; private Handler mHandler = new Handler(); private AndroidHttpClient mHttpClient = AndroidHttpClient.newInstance("TUQ"); // The ongoing error request thread if there is one. This should only be // modified while mErrorLock is held. private AsyncErrorRetriever mErrorRetriever; // This is set to false while a server request is being made to retrieve // the current error. It should only be set while mErrorLock is held. private boolean mSafeToCloseClient = true; private final Object mErrorLock = new Object(); // A tracking id for the current error. This should only be modified while // mErrorLock is held. private long mErrorId = 0; // The current error state of this player. This is cleared when the state // leaves an error state and set when it enters one. This should only be // modified when mErrorLock is held. private PlaybackError mError; private boolean mPlayOnReady; private int mSeekOnReady; private boolean mHasAudioFocus; private long mDebugId = sDebugInstanceId++; public LocalRenderer(Context context, Bundle params) { super(context, params); mContext = context; mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); } @Override protected void initFeatures(Bundle params) { for (String feature : SUPPORTED_FEATURES) { mFeatures.add(feature); } } /** * Call this when completely finished with the MediaPlayerManager to have it * clean up. The instance may not be used again after this is called. */ @Override public void onDestroy() { synchronized (mErrorLock) { if (DEBUG) { Log.d(TAG, "onDestroy, error retriever? " + mErrorRetriever + " safe to close? " + mSafeToCloseClient + " client? " + mHttpClient); } if (mErrorRetriever != null) { mErrorRetriever.cancelRequestLocked(true); mErrorRetriever = null; } // Increment the error id to ensure no errors are sent after this // point. mErrorId++; if (mSafeToCloseClient) { mHttpClient.close(); mHttpClient = null; } } } @Override public void onPrepared(MediaPlayer player) { if (!isCurrentPlayer(player)) { return; } setState(STATE_READY); if (DEBUG) { Log.d(TAG, mDebugId + ": Finished preparing, seekOnReady is " + mSeekOnReady); } if (mSeekOnReady >= 0) { onSeekTo(mSeekOnReady); mSeekOnReady = -1; } if (mPlayOnReady) { player.start(); setState(STATE_PLAYING); } } @Override public void onBufferingUpdate(MediaPlayer player, int percent) { if (!isCurrentPlayer(player)) { return; } pushOnBufferingUpdate(percent); } @Override public void onCompletion(MediaPlayer player) { if (!isCurrentPlayer(player)) { return; } if (DEBUG) { Log.d(TAG, mDebugId + ": Completed item. Have next item? " + (mNextPlayer != null)); } if (mNextPlayer != null) { if (mPlayer != null) { mPlayer.release(); } mPlayer = mNextPlayer; mContent = mNextContent; mNextPlayer = null; mNextContent = null; pushOnNextStarted(); return; } setState(STATE_ENDED); } @Override public boolean onError(MediaPlayer player, int what, int extra) { if (!isCurrentPlayer(player)) { return false; } if (DEBUG) { Log.d(TAG, mDebugId + ": Entered error state, what: " + what + " extra: " + extra); } synchronized (mErrorLock) { ++mErrorId; mError = new PlaybackError(); mError.type = what; mError.extra = extra; } if (what == MediaPlayer.MEDIA_ERROR_UNKNOWN && extra == MediaPlayer.MEDIA_ERROR_IO && mContent != null && mContent.source.startsWith("http")) { HttpGet request = new HttpGet(mContent.source); if (mContent.headers != null) { for (String key : mContent.headers.keySet()) { request.addHeader(key, mContent.headers.get(key)); } } synchronized (mErrorLock) { if (mErrorRetriever != null) { mErrorRetriever.cancelRequestLocked(false); } mErrorRetriever = new AsyncErrorRetriever(mErrorId); mErrorRetriever.execute(request); } } else { setError(what, extra, null, null); } return true; } @Override public void onAudioFocusChange(int focusChange) { // TODO figure out appropriate logic for handling focus loss at the TUQ // level. switch (focusChange) { case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT: case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: if (mState == STATE_PLAYING) { onPause(); mPlayOnReady = true; } mHasAudioFocus = false; break; case AudioManager.AUDIOFOCUS_LOSS: if (mState == STATE_PLAYING) { onPause(); mPlayOnReady = false; } pushOnFocusLost(); mHasAudioFocus = false; break; case AudioManager.AUDIOFOCUS_GAIN: mHasAudioFocus = true; if (mPlayOnReady) { onPlay(); } break; default: Log.d(TAG, "Unknown focus change event " + focusChange); break; } } @Override public void setContent(Bundle request) { setContent(request, null); } /** * Prepares the player for the given playback request. If the holder is null * it is assumed this is an audio only source. If playOnReady is set to true * the media will begin playing as soon as it can. * * @see RequestUtils for the set of valid keys. */ public void setContent(Bundle request, SurfaceHolder holder) { String source = request.getString(RequestUtils.EXTRA_KEY_SOURCE); Map<String, String> headers = null; // request.mHeaders; boolean playOnReady = true; // request.mPlayOnReady; if (DEBUG) { Log.d(TAG, mDebugId + ": Settings new content. Have a player? " + (mPlayer != null) + " have a next player? " + (mNextPlayer != null)); } cleanUpPlayer(); setState(STATE_PREPARING); mPlayOnReady = playOnReady; mSeekOnReady = -1; final MediaPlayer newPlayer = new MediaPlayer(); requestAudioFocus(); mPlayer = newPlayer; mContent = new PlayerContent(source, headers); try { if (headers != null) { Uri sourceUri = Uri.parse(source); newPlayer.setDataSource(mContext, sourceUri, headers); } else { newPlayer.setDataSource(source); } } catch (Exception e) { setError(Listener.ERROR_LOAD_FAILED, 0, null, e); return; } if (isHolderReady(holder, newPlayer)) { preparePlayer(newPlayer, true); } } @Override public void setNextContent(Bundle request) { String source = request.getString(RequestUtils.EXTRA_KEY_SOURCE); Map<String, String> headers = null; // request.mHeaders; // TODO support video if (DEBUG) { Log.d(TAG, mDebugId + ": Setting next content. Have player? " + (mPlayer != null) + " have next player? " + (mNextPlayer != null)); } if (mPlayer == null) { // The manager isn't being used to play anything, don't try to // set a next. return; } if (mNextPlayer != null) { // Before setting up the new one clear out the old one and release // it to ensure it doesn't play. mPlayer.setNextMediaPlayer(null); mNextPlayer.release(); mNextPlayer = null; mNextContent = null; } if (source == null) { // If there's no new content we're done return; } final MediaPlayer newPlayer = new MediaPlayer(); try { if (headers != null) { Uri sourceUri = Uri.parse(source); newPlayer.setDataSource(mContext, sourceUri, headers); } else { newPlayer.setDataSource(source); } } catch (Exception e) { newPlayer.release(); // Don't return an error until we get to this item in playback return; } if (preparePlayer(newPlayer, false)) { mPlayer.setNextMediaPlayer(newPlayer); mNextPlayer = newPlayer; mNextContent = new PlayerContent(source, headers); } } private void requestAudioFocus() { int result = mAudioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN); mHasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED; } /** * Start the player if possible or queue it to play when ready. If the * player is in a state where it will never be ready returns false. * * @return true if the content was started or will be started later */ @Override public boolean onPlay() { MediaPlayer player = mPlayer; if (player != null && mState == STATE_PLAYING) { // already playing, just return return true; } if (!mHasAudioFocus) { requestAudioFocus(); } if (player != null && canPlay()) { player.start(); setState(STATE_PLAYING); } else if (canReadyPlay()) { mPlayOnReady = true; } else if (!isPlaying()) { return false; } return true; } /** * Pause the player if possible or set it to not play when ready. If the * player is in a state where it will never be ready returns false. * * @return true if the content was paused or will wait to play when ready * later */ @Override public boolean onPause() { MediaPlayer player = mPlayer; // If the user paused us make sure we won't start playing again until // asked to mPlayOnReady = false; if (player != null && (mState & CAN_PAUSE) != 0) { player.pause(); setState(STATE_PAUSED); } else if (!isPaused()) { return false; } return true; } /** * Seek to a given position in the media. If the seek succeeded or will be * performed when loading is complete returns true. If the position is not * in range or the player will never be ready returns false. * * @param position The position to seek to in milliseconds * @return true if playback was moved or will be moved when ready */ @Override public boolean onSeekTo(int position) { MediaPlayer player = mPlayer; if (player != null && (mState & CAN_SEEK) != 0) { if (position < 0 || position >= getDuration()) { return false; } else { if (mState == STATE_ENDED) { player.start(); player.pause(); setState(STATE_PAUSED); } player.seekTo(position); } } else if ((mState & CAN_READY_SEEK) != 0) { mSeekOnReady = position; } else { return false; } return true; } /** * Stop the player. It cannot be used again until * {@link #setContent(String, boolean)} is called. * * @return true if stopping the player succeeded */ @Override public boolean onStop() { cleanUpPlayer(); setState(STATE_STOPPED); return true; } public boolean isPlaying() { return mState == STATE_PLAYING; } public boolean isPaused() { return mState == STATE_PAUSED; } @Override public long getSeekPosition() { return ((mState & CAN_GET_POSITION) == 0) ? -1 : mPlayer.getCurrentPosition(); } @Override public long getDuration() { return ((mState & CAN_GET_POSITION) == 0) ? -1 : mPlayer.getDuration(); } private boolean canPlay() { return ((mState & CAN_PLAY) != 0) && mHasAudioFocus; } private boolean canReadyPlay() { return (mState & CAN_PLAY) != 0 || (mState & CAN_READY_PLAY) != 0; } /** * Sends a state update if the listener exists */ private void setState(int state) { if (state == mState) { return; } Log.d(TAG, "Entering state " + state + " from state " + mState); mState = state; if (state != STATE_ERROR) { // Don't notify error here, it'll get sent via onError pushOnStateChanged(state); } } private boolean preparePlayer(final MediaPlayer player, boolean current) { player.setOnPreparedListener(this); player.setOnBufferingUpdateListener(this); player.setOnCompletionListener(this); player.setOnErrorListener(this); try { player.prepareAsync(); if (current) { setState(STATE_PREPARING); } } catch (IllegalStateException e) { if (current) { setError(Listener.ERROR_PREPARE_ERROR, 0, null, e); } return false; } return true; } /** * @param extra * @param e */ private void setError(int type, int extra, Bundle extras, Exception e) { setState(STATE_ERROR); pushOnError(type, extra, extras, e); cleanUpPlayer(); return; } /** * Checks if the holder is ready and either sets up a callback to wait for * it or sets it directly. If * * @param holder * @param player * @return */ private boolean isHolderReady(final SurfaceHolder holder, final MediaPlayer player) { mHolder = holder; if (holder != null) { if (holder.getSurface() != null && holder.getSurface().isValid()) { player.setDisplay(holder); return true; } else { Log.w(TAG, "Holder not null, waiting for it to be ready"); // If the holder isn't ready yet add a callback to set the // holder when it's ready. SurfaceHolder.Callback cb = new SurfaceHolder.Callback() { @Override public void surfaceDestroyed(SurfaceHolder arg0) { } @Override public void surfaceCreated(SurfaceHolder arg0) { if (player.equals(mPlayer)) { player.setDisplay(arg0); preparePlayer(player, true); } } @Override public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) { } }; mHolderCB = cb; holder.addCallback(cb); return false; } } return true; } private void cleanUpPlayer() { if (DEBUG) { Log.d(TAG, mDebugId + ": Cleaning up current player"); } synchronized (mErrorLock) { mError = null; if (mErrorRetriever != null) { mErrorRetriever.cancelRequestLocked(false); // Don't set to null as we may need to cancel again with true if // the object gets destroyed. } } mAudioManager.abandonAudioFocus(this); SurfaceHolder.Callback cb = mHolderCB; mHolderCB = null; SurfaceHolder holder = mHolder; mHolder = null; if (holder != null && cb != null) { holder.removeCallback(cb); } MediaPlayer player = mPlayer; mPlayer = null; if (player != null) { player.reset(); player.release(); } } private boolean isCurrentPlayer(MediaPlayer player) { return player.equals(mPlayer); } }