This controls a single {@link com.android.dialer.app.voicemail.VoicemailPlaybackLayout}. A * single instance can be reused for different such layouts, using {@link #setPlaybackView}. This is * to facilitate reuse across different voicemail call log entries. * *
This class is not thread safe. The thread policy for this class is thread-confinement, all * calls into this class from outside must be done from the main UI thread. */ @NotThreadSafe @TargetApi(VERSION_CODES.M) public class VoicemailPlaybackPresenter implements MediaPlayer.OnPreparedListener, MediaPlayer.OnCompletionListener, MediaPlayer.OnErrorListener { public static final int PLAYBACK_REQUEST = 0; private static final int NUMBER_OF_THREADS_IN_POOL = 2; // Time to wait for content to be fetched before timing out. private static final long FETCH_CONTENT_TIMEOUT_MS = 20000; private static final String VOICEMAIL_URI_KEY = VoicemailPlaybackPresenter.class.getName() + ".VOICEMAIL_URI"; private static final String IS_PREPARED_KEY = VoicemailPlaybackPresenter.class.getName() + ".IS_PREPARED"; // If present in the saved instance bundle, we should not resume playback on create. private static final String IS_PLAYING_STATE_KEY = VoicemailPlaybackPresenter.class.getName() + ".IS_PLAYING_STATE_KEY"; // If present in the saved instance bundle, indicates where to set the playback slider. private static final String CLIP_POSITION_KEY = VoicemailPlaybackPresenter.class.getName() + ".CLIP_POSITION_KEY"; private static final String IS_SPEAKERPHONE_ON_KEY = VoicemailPlaybackPresenter.class.getName() + ".IS_SPEAKER_PHONE_ON"; private static final String VOICEMAIL_SHARE_FILE_NAME_DATE_FORMAT = "MM-dd-yy_hhmmaa"; private static final String CONFIG_SHARE_VOICEMAIL_ALLOWED = "share_voicemail_allowed"; private static VoicemailPlaybackPresenter sInstance; private static ScheduledExecutorService mScheduledExecutorService; /** * The most recently cached duration. We cache this since we don't want to keep requesting it from * the player, as this can easily lead to throwing {@link IllegalStateException} (any time the * player is released, it's illegal to ask for the duration). */ private final AtomicInteger mDuration = new AtomicInteger(0); protected Context mContext; private long mRowId; protected Uri mVoicemailUri; protected MediaPlayer mMediaPlayer; // Used to run async tasks that need to interact with the UI. protected AsyncTaskExecutor mAsyncTaskExecutor; private Activity mActivity; private PlaybackView mView; private int mPosition; private boolean mIsPlaying; // MediaPlayer crashes on some method calls if not prepared but does not have a method which // exposes its prepared state. Store this locally, so we can check and prevent crashes. private boolean mIsPrepared; private boolean mIsSpeakerphoneOn; private boolean mShouldResumePlaybackAfterSeeking; /** * Used to handle the result of a successful or time-out fetch result. * *
This variable is thread-contained, accessed only on the ui thread.
*/
private FetchResultHandler mFetchResultHandler;
private PowerManager.WakeLock mProximityWakeLock;
private VoicemailAudioManager mVoicemailAudioManager;
private OnVoicemailDeletedListener mOnVoicemailDeletedListener;
private View shareVoicemailButtonView;
private DialerExecutor Otherwise, after rotation the previous listener will still be active but a new listener will
* be provided to calls to the AudioManager, which is bad. For example, abandoning audio focus
* with the new listeners results in an AUDIO_FOCUS_GAIN callback to the previous listener, which
* is the opposite of the intended behavior.
*/
@MainThread
public static VoicemailPlaybackPresenter getInstance(
Activity activity, Bundle savedInstanceState) {
if (sInstance == null) {
sInstance = new VoicemailPlaybackPresenter(activity);
}
sInstance.init(activity, savedInstanceState);
return sInstance;
}
private static synchronized ScheduledExecutorService getScheduledExecutorServiceInstance() {
if (mScheduledExecutorService == null) {
mScheduledExecutorService = Executors.newScheduledThreadPool(NUMBER_OF_THREADS_IN_POOL);
}
return mScheduledExecutorService;
}
/** Update variables which are activity-dependent or state-dependent. */
@MainThread
protected void init(Activity activity, Bundle savedInstanceState) {
Assert.isMainThread();
mActivity = activity;
mContext = activity;
if (savedInstanceState != null) {
// Restores playback state when activity is recreated, such as after rotation.
mVoicemailUri = savedInstanceState.getParcelable(VOICEMAIL_URI_KEY);
mIsPrepared = savedInstanceState.getBoolean(IS_PREPARED_KEY);
mPosition = savedInstanceState.getInt(CLIP_POSITION_KEY, 0);
mIsPlaying = savedInstanceState.getBoolean(IS_PLAYING_STATE_KEY, false);
mIsSpeakerphoneOn = savedInstanceState.getBoolean(IS_SPEAKERPHONE_ON_KEY, false);
}
if (mMediaPlayer == null) {
mIsPrepared = false;
mIsPlaying = false;
}
if (mActivity != null) {
if (isPlaying()) {
mActivity.getWindow().addFlags(LayoutParams.FLAG_KEEP_SCREEN_ON);
} else {
mActivity.getWindow().clearFlags(LayoutParams.FLAG_KEEP_SCREEN_ON);
}
shareVoicemailExecutor =
DialerExecutors.createUiTaskBuilder(
mActivity.getFragmentManager(), "test", new ShareVoicemailWorker())
.onSuccess(
output -> {
if (output == null) {
LogUtil.e("VoicemailAsyncTaskUtil.shareVoicemail", "failed to get voicemail");
return;
}
mContext.startActivity(
Intent.createChooser(
getShareIntent(mContext, output.first, output.second),
mContext
.getResources()
.getText(R.string.call_log_action_share_voicemail)));
})
.build();
}
}
/** Must be invoked when the parent Activity is saving it state. */
public void onSaveInstanceState(Bundle outState) {
if (mView != null) {
outState.putParcelable(VOICEMAIL_URI_KEY, mVoicemailUri);
outState.putBoolean(IS_PREPARED_KEY, mIsPrepared);
outState.putInt(CLIP_POSITION_KEY, mView.getDesiredClipPosition());
outState.putBoolean(IS_PLAYING_STATE_KEY, mIsPlaying);
outState.putBoolean(IS_SPEAKERPHONE_ON_KEY, mIsSpeakerphoneOn);
}
}
/** Specify the view which this presenter controls and the voicemail to prepare to play. */
public void setPlaybackView(
PlaybackView view,
long rowId,
Uri voicemailUri,
final boolean startPlayingImmediately,
View shareVoicemailButtonView) {
mRowId = rowId;
mView = view;
mView.setPresenter(this, voicemailUri);
mView.onSpeakerphoneOn(mIsSpeakerphoneOn);
this.shareVoicemailButtonView = shareVoicemailButtonView;
showShareVoicemailButton(false);
// Handles cases where the same entry is binded again when scrolling in list, or where
// the MediaPlayer was retained after an orientation change.
if (mMediaPlayer != null && mIsPrepared && voicemailUri.equals(mVoicemailUri)) {
// If the voicemail card was rebinded, we need to set the position to the appropriate
// point. Since we retain the media player, we can just set it to the position of the
// media player.
mPosition = mMediaPlayer.getCurrentPosition();
onPrepared(mMediaPlayer);
showShareVoicemailButton(true);
} else {
if (!voicemailUri.equals(mVoicemailUri)) {
mVoicemailUri = voicemailUri;
mPosition = 0;
}
/*
* Check to see if the content field in the DB is set. If set, we proceed to
* prepareContent() method. We get the duration of the voicemail from the query and set
* it if the content is not available.
*/
checkForContent(
hasContent -> {
if (hasContent) {
showShareVoicemailButton(true);
prepareContent();
} else {
if (startPlayingImmediately) {
requestContent(PLAYBACK_REQUEST);
}
if (mView != null) {
mView.resetSeekBar();
mView.setClipPosition(0, mDuration.get());
}
}
});
if (startPlayingImmediately) {
// Since setPlaybackView can get called during the view binding process, we don't
// want to reset mIsPlaying to false if the user is currently playing the
// voicemail and the view is rebound.
mIsPlaying = startPlayingImmediately;
}
}
}
/** Reset the presenter for playback back to its original state. */
public void resetAll() {
pausePresenter(true);
mView = null;
mVoicemailUri = null;
}
/**
* When navigating away from voicemail playback, we need to release the media player, pause the UI
* and save the position.
*
* @param reset {@code true} if we want to reset the position of the playback, {@code false} if we
* want to retain the current position (in case we return to the voicemail).
*/
public void pausePresenter(boolean reset) {
pausePlayback();
if (mMediaPlayer != null) {
mMediaPlayer.release();
mMediaPlayer = null;
}
disableProximitySensor(false /* waitForFarState */);
mIsPrepared = false;
mIsPlaying = false;
if (reset) {
// We want to reset the position whether or not the view is valid.
mPosition = 0;
}
if (mView != null) {
mView.onPlaybackStopped();
if (reset) {
mView.setClipPosition(0, mDuration.get());
} else {
mPosition = mView.getDesiredClipPosition();
}
}
}
/** Must be invoked when the parent activity is resumed. */
public void onResume() {
mVoicemailAudioManager.registerReceivers();
}
/** Must be invoked when the parent activity is paused. */
public void onPause() {
mVoicemailAudioManager.unregisterReceivers();
if (mActivity != null && mIsPrepared && mActivity.isChangingConfigurations()) {
// If an configuration change triggers the pause, retain the MediaPlayer.
LogUtil.d("VoicemailPlaybackPresenter.onPause", "configuration changed.");
return;
}
// Release the media player, otherwise there may be failures.
pausePresenter(false);
}
/** Must be invoked when the parent activity is destroyed. */
public void onDestroy() {
// Clear references to avoid leaks from the singleton instance.
mActivity = null;
mContext = null;
if (mScheduledExecutorService != null) {
mScheduledExecutorService.shutdown();
mScheduledExecutorService = null;
}
if (mFetchResultHandler != null) {
mFetchResultHandler.destroy();
mFetchResultHandler = null;
}
}
/** Checks to see if we have content available for this voicemail. */
protected void checkForContent(final OnContentCheckedListener callback) {
mAsyncTaskExecutor.submit(
Tasks.CHECK_FOR_CONTENT,
new AsyncTask This method must be called on the ui thread.
*
* This method will be called when we realise that we don't have content for this voicemail. It
* will trigger a broadcast to request that the content be downloaded. It will add a listener to
* the content resolver so that it will be notified when the has_content field changes. It will
* also set a timer. If the has_content field changes to true within the allowed time, we will
* proceed to {@link #prepareContent()}. If the has_content field does not become true within the
* allowed time, we will update the ui to reflect the fact that content was not available.
*
* @return whether issued request to fetch content
*/
protected boolean requestContent(int code) {
if (mContext == null || mVoicemailUri == null) {
return false;
}
FetchResultHandler tempFetchResultHandler =
new FetchResultHandler(new Handler(), mVoicemailUri, code);
switch (code) {
default:
if (mFetchResultHandler != null) {
mFetchResultHandler.destroy();
}
mView.setIsFetchingContent();
mFetchResultHandler = tempFetchResultHandler;
break;
}
mAsyncTaskExecutor.submit(
Tasks.SEND_FETCH_REQUEST,
new AsyncTask This method will be called once we know that our voicemail has content (according to the
* content provider). this method asynchronously tries to prepare the data source through the
* media player. If preparation is successful, the media player will {@link #onPrepared()}, and it
* will call {@link #onError()} otherwise.
*/
protected void prepareContent() {
if (mView == null || mContext == null) {
return;
}
LogUtil.d("VoicemailPlaybackPresenter.prepareContent", null);
// Release the previous media player, otherwise there may be failures.
if (mMediaPlayer != null) {
mMediaPlayer.release();
mMediaPlayer = null;
}
mView.disableUiElements();
mIsPrepared = false;
if (mContext != null && TelecomUtil.isInCall(mContext)) {
handleError(new IllegalStateException("Cannot play voicemail when call is in progress"));
return;
}
try {
mMediaPlayer = new MediaPlayer();
mMediaPlayer.setOnPreparedListener(this);
mMediaPlayer.setOnErrorListener(this);
mMediaPlayer.setOnCompletionListener(this);
mMediaPlayer.reset();
mMediaPlayer.setDataSource(mContext, mVoicemailUri);
mMediaPlayer.setAudioStreamType(VoicemailAudioManager.PLAYBACK_STREAM);
mMediaPlayer.prepareAsync();
} catch (IOException e) {
handleError(e);
}
}
/**
* Once the media player is prepared, enables the UI and adopts the appropriate playback state.
*/
@Override
public void onPrepared(MediaPlayer mp) {
if (mView == null || mContext == null) {
return;
}
LogUtil.d("VoicemailPlaybackPresenter.onPrepared", null);
mIsPrepared = true;
mDuration.set(mMediaPlayer.getDuration());
LogUtil.d("VoicemailPlaybackPresenter.onPrepared", "mPosition=" + mPosition);
mView.setClipPosition(mPosition, mDuration.get());
mView.enableUiElements();
mView.setSuccess();
if (!mp.isPlaying()) {
mMediaPlayer.seekTo(mPosition);
}
if (mIsPlaying) {
resumePlayback();
} else {
pausePlayback();
}
}
/**
* Invoked if preparing the media player fails, for example, if file is missing or the voicemail
* is an unknown file format that can't be played.
*/
@Override
public boolean onError(MediaPlayer mp, int what, int extra) {
handleError(new IllegalStateException("MediaPlayer error listener invoked: " + extra));
return true;
}
protected void handleError(Exception e) {
LogUtil.e("VoicemailPlaybackPresenter.handlerError", "could not play voicemail", e);
if (mIsPrepared) {
mMediaPlayer.release();
mMediaPlayer = null;
mIsPrepared = false;
}
if (mView != null) {
mView.onPlaybackError();
}
mPosition = 0;
mIsPlaying = false;
showShareVoicemailButton(false);
}
/** After done playing the voicemail clip, reset the clip position to the start. */
@Override
public void onCompletion(MediaPlayer mediaPlayer) {
pausePlayback();
// Reset the seekbar position to the beginning.
mPosition = 0;
if (mView != null) {
mediaPlayer.seekTo(0);
mView.setClipPosition(0, mDuration.get());
}
}
/**
* Only play voicemail when audio focus is granted. When it is lost (usually by another
* application requesting focus), pause playback. Audio focus gain/lost only triggers the focus is
* requested. Audio focus is requested when the user pressed play and abandoned when the user
* pressed pause or the audio has finished. Losing focus should not abandon focus as the voicemail
* should resume once the focus is returned.
*
* @param gainedFocus {@code true} if the audio focus was gained, {@code} false otherwise.
*/
public void onAudioFocusChange(boolean gainedFocus) {
if (mIsPlaying == gainedFocus) {
// Nothing new here, just exit.
return;
}
if (gainedFocus) {
resumePlayback();
} else {
pausePlayback(true);
}
}
/**
* Resumes voicemail playback at the clip position stored by the presenter. Null-op if already
* playing.
*/
public void resumePlayback() {
if (mView == null) {
return;
}
if (!mIsPrepared) {
/*
* Check content before requesting content to avoid duplicated requests. It is possible
* that the UI doesn't know content has arrived if the fetch took too long causing a
* timeout, but succeeded.
*/
checkForContent(
hasContent -> {
if (!hasContent) {
// No local content, download from server. Queue playing if the request was
// issued,
mIsPlaying = requestContent(PLAYBACK_REQUEST);
} else {
showShareVoicemailButton(true);
// Queue playing once the media play loaded the content.
mIsPlaying = true;
prepareContent();
}
});
return;
}
mIsPlaying = true;
mActivity.getWindow().addFlags(LayoutParams.FLAG_KEEP_SCREEN_ON);
if (mMediaPlayer != null && !mMediaPlayer.isPlaying()) {
// Clamp the start position between 0 and the duration.
mPosition = Math.max(0, Math.min(mPosition, mDuration.get()));
mMediaPlayer.seekTo(mPosition);
try {
// Grab audio focus.
// Can throw RejectedExecutionException.
mVoicemailAudioManager.requestAudioFocus();
mMediaPlayer.start();
setSpeakerphoneOn(mIsSpeakerphoneOn);
mVoicemailAudioManager.setSpeakerphoneOn(mIsSpeakerphoneOn);
} catch (RejectedExecutionException e) {
handleError(e);
}
}
LogUtil.d("VoicemailPlaybackPresenter.resumePlayback", "resumed playback at %d.", mPosition);
mView.onPlaybackStarted(mDuration.get(), getScheduledExecutorServiceInstance());
}
/** Pauses voicemail playback at the current position. Null-op if already paused. */
public void pausePlayback() {
pausePlayback(false);
}
private void pausePlayback(boolean keepFocus) {
if (!mIsPrepared) {
return;
}
mIsPlaying = false;
if (mMediaPlayer != null && mMediaPlayer.isPlaying()) {
mMediaPlayer.pause();
}
mPosition = mMediaPlayer == null ? 0 : mMediaPlayer.getCurrentPosition();
LogUtil.d("VoicemailPlaybackPresenter.pausePlayback", "paused playback at %d.", mPosition);
if (mView != null) {
mView.onPlaybackStopped();
}
if (!keepFocus) {
mVoicemailAudioManager.abandonAudioFocus();
}
if (mActivity != null) {
mActivity.getWindow().clearFlags(LayoutParams.FLAG_KEEP_SCREEN_ON);
}
disableProximitySensor(true /* waitForFarState */);
}
/**
* Pauses playback when the user starts seeking the position, and notes whether the voicemail is
* playing to know whether to resume playback once the user selects a new position.
*/
public void pausePlaybackForSeeking() {
if (mMediaPlayer != null) {
mShouldResumePlaybackAfterSeeking = mMediaPlayer.isPlaying();
}
pausePlayback(true);
}
public void resumePlaybackAfterSeeking(int desiredPosition) {
mPosition = desiredPosition;
if (mShouldResumePlaybackAfterSeeking) {
mShouldResumePlaybackAfterSeeking = false;
resumePlayback();
}
}
/**
* Seek to position. This is called when user manually seek the playback. It could be either by
* touch or volume button while in talkback mode.
*/
public void seek(int position) {
mPosition = position;
mMediaPlayer.seekTo(mPosition);
}
private void enableProximitySensor() {
if (mProximityWakeLock == null
|| mIsSpeakerphoneOn
|| !mIsPrepared
|| mMediaPlayer == null
|| !mMediaPlayer.isPlaying()) {
return;
}
if (!mProximityWakeLock.isHeld()) {
LogUtil.i(
"VoicemailPlaybackPresenter.enableProximitySensor", "acquiring proximity wake lock");
mProximityWakeLock.acquire();
} else {
LogUtil.i(
"VoicemailPlaybackPresenter.enableProximitySensor",
"proximity wake lock already acquired");
}
}
private void disableProximitySensor(boolean waitForFarState) {
if (mProximityWakeLock == null) {
return;
}
if (mProximityWakeLock.isHeld()) {
LogUtil.i(
"VoicemailPlaybackPresenter.disableProximitySensor", "releasing proximity wake lock");
int flags = waitForFarState ? PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY : 0;
mProximityWakeLock.release(flags);
} else {
LogUtil.i(
"VoicemailPlaybackPresenter.disableProximitySensor",
"proximity wake lock already released");
}
}
/** This is for use by UI interactions only. It simplifies UI logic. */
public void toggleSpeakerphone() {
mVoicemailAudioManager.setSpeakerphoneOn(!mIsSpeakerphoneOn);
setSpeakerphoneOn(!mIsSpeakerphoneOn);
}
public void setOnVoicemailDeletedListener(OnVoicemailDeletedListener listener) {
mOnVoicemailDeletedListener = listener;
}
public int getMediaPlayerPosition() {
return mIsPrepared && mMediaPlayer != null ? mMediaPlayer.getCurrentPosition() : 0;
}
void onVoicemailDeleted(CallLogListItemViewHolder viewHolder) {
if (mOnVoicemailDeletedListener != null) {
mOnVoicemailDeletedListener.onVoicemailDeleted(viewHolder, mVoicemailUri);
}
}
void onVoicemailDeleteUndo(int adapterPosition) {
if (mOnVoicemailDeletedListener != null) {
mOnVoicemailDeletedListener.onVoicemailDeleteUndo(mRowId, adapterPosition, mVoicemailUri);
}
}
void onVoicemailDeletedInDatabase() {
if (mOnVoicemailDeletedListener != null) {
mOnVoicemailDeletedListener.onVoicemailDeletedInDatabase(mRowId, mVoicemailUri);
}
}
@VisibleForTesting
public boolean isPlaying() {
return mIsPlaying;
}
@VisibleForTesting
public boolean isSpeakerphoneOn() {
return mIsSpeakerphoneOn;
}
/**
* This method only handles app-level changes to the speakerphone. Audio layer changes should be
* handled separately. This is so that the VoicemailAudioManager can trigger changes to the
* presenter without the presenter triggering the audio manager and duplicating actions.
*/
public void setSpeakerphoneOn(boolean on) {
if (mView == null) {
return;
}
mView.onSpeakerphoneOn(on);
mIsSpeakerphoneOn = on;
// This should run even if speakerphone is not being toggled because we may be switching
// from earpiece to headphone and vise versa. Also upon initial setup the default audio
// source is the earpiece, so we want to trigger the proximity sensor.
if (mIsPlaying) {
if (on || mVoicemailAudioManager.isWiredHeadsetPluggedIn()) {
disableProximitySensor(false /* waitForFarState */);
} else {
enableProximitySensor();
}
}
}
@VisibleForTesting
public void clearInstance() {
sInstance = null;
}
private void showShareVoicemailButton(boolean show) {
if (mContext == null) {
return;
}
if (isShareVoicemailAllowed(mContext) && shareVoicemailButtonView != null) {
if (show) {
Logger.get(mContext).logImpression(DialerImpression.Type.VVM_SHARE_VISIBLE);
}
LogUtil.d("VoicemailPlaybackPresenter.showShareVoicemailButton", "show: %b", show);
shareVoicemailButtonView.setVisibility(show ? View.VISIBLE : View.GONE);
}
}
private static boolean isShareVoicemailAllowed(Context context) {
return ConfigProviderBindings.get(context).getBoolean(CONFIG_SHARE_VOICEMAIL_ALLOWED, true);
}
private static class ShareVoicemailWorker
implements DialerExecutor.Worker