path: root/com/android/widget/MediaControlView2Impl.java

/*
 * Copyright 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.widget;

import android.content.res.Resources;
import android.media.MediaMetadata;
import android.media.session.MediaController;
import android.media.session.PlaybackState;
import android.media.update.MediaControlView2Provider;
import android.media.update.ViewProvider;
import android.os.Bundle;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityManager;
import android.widget.ImageButton;
import android.widget.MediaControlView2;
import android.widget.ProgressBar;
import android.widget.SeekBar;
import android.widget.SeekBar.OnSeekBarChangeListener;
import android.widget.TextView;

import com.android.media.update.ApiHelper;
import com.android.media.update.R;

import java.util.Formatter;
import java.util.Locale;

public class MediaControlView2Impl implements MediaControlView2Provider {
    private static final String TAG = "MediaControlView2";

    private final MediaControlView2 mInstance;
    private final ViewProvider mSuperProvider;

    static final String COMMAND_SHOW_SUBTITLE = "showSubtitle";
    static final String COMMAND_HIDE_SUBTITLE = "hideSubtitle";
    static final String COMMAND_SET_FULLSCREEN = "setFullscreen";

    static final String ARGUMENT_KEY_FULLSCREEN = "fullScreen";

    static final String KEY_STATE_CONTAINS_SUBTITLE = "StateContainsSubtitle";
    static final String EVENT_UPDATE_SUBTITLE_STATUS = "UpdateSubtitleStatus";

    private static final int MAX_PROGRESS = 1000;
    private static final int DEFAULT_PROGRESS_UPDATE_TIME_MS = 1000;
    private static final int DEFAULT_TIMEOUT_MS = 2000;

    private static final int REWIND_TIME_MS = 10000;
    private static final int FORWARD_TIME_MS = 30000;

    private final AccessibilityManager mAccessibilityManager;

    private MediaController mController;
    private MediaController.TransportControls mControls;
    private PlaybackState mPlaybackState;
    private MediaMetadata mMetadata;
    private ProgressBar mProgress;
    private TextView mEndTime, mCurrentTime;
    private TextView mTitleView;
    private int mDuration;
    private int mPrevState;
    private long mPlaybackActions;
    private boolean mShowing;
    private boolean mDragging;
    private boolean mIsFullScreen;
    private boolean mOverflowExpanded;
    private boolean mIsStopped;
    private boolean mSubtitleIsEnabled;
    private boolean mContainsSubtitle;
    private boolean mSeekAvailable;
    private View.OnClickListener mNextListener, mPrevListener;
    private ImageButton mPlayPauseButton;
    private ImageButton mFfwdButton;
    private ImageButton mRewButton;
    private ImageButton mNextButton;
    private ImageButton mPrevButton;

    private ViewGroup mBasicControls;
    private ImageButton mSubtitleButton;
    private ImageButton mFullScreenButton;
    private ImageButton mOverflowButtonRight;

    private ViewGroup mExtraControls;
    private ImageButton mOverflowButtonLeft;
    private ImageButton mMuteButton;
    private ImageButton mAspectRationButton;
    private ImageButton mSettingsButton;

    private CharSequence mPlayDescription;
    private CharSequence mPauseDescription;
    private CharSequence mReplayDescription;

    private StringBuilder mFormatBuilder;
    private Formatter mFormatter;

    public MediaControlView2Impl(
            MediaControlView2 instance, ViewProvider superProvider) {
        mInstance = instance;
        mSuperProvider = superProvider;
        mAccessibilityManager = AccessibilityManager.getInstance(mInstance.getContext());

        // Inflate MediaControlView2 from XML
        View root = makeControllerView();
        mInstance.addView(root);
    }

    @Override
    public void setController_impl(MediaController controller) {
        mController = controller;
        if (controller != null) {
            mControls = controller.getTransportControls();
            // Set mMetadata and mPlaybackState to existing MediaSession variables since they may
            // be called before the callback is called
            mPlaybackState = mController.getPlaybackState();
            mMetadata = mController.getMetadata();
            updateDuration();
            updateTitle();

            mController.registerCallback(new MediaControllerCallback());
        }
    }

    @Override
    public void show_impl() {
        mInstance.show(DEFAULT_TIMEOUT_MS);
    }

    @Override
    public void show_impl(int timeout) {
        if (!mShowing) {
            setProgress();
            if (mPlayPauseButton != null) {
                mPlayPauseButton.requestFocus();
            }
            disableUnsupportedButtons();
            mInstance.setVisibility(View.VISIBLE);
            mShowing = true;
        }
        // cause the progress bar to be updated even if mShowing
        // was already true.  This happens, for example, if we're
        // paused with the progress bar showing the user hits play.
        mInstance.post(mShowProgress);

        if (timeout != 0 && !mAccessibilityManager.isTouchExplorationEnabled()) {
            mInstance.removeCallbacks(mFadeOut);
            mInstance.postDelayed(mFadeOut, timeout);
        }
    }

    @Override
    public boolean isShowing_impl() {
        return mShowing;
    }

    @Override
    public void hide_impl() {
        if (mShowing) {
            try {
                mInstance.removeCallbacks(mShowProgress);
                // Remove existing call to mFadeOut to avoid from being called later.
                mInstance.removeCallbacks(mFadeOut);
                mInstance.setVisibility(View.GONE);
            } catch (IllegalArgumentException ex) {
                Log.w(TAG, "already removed");
            }
            mShowing = false;
        }
    }

    @Override
    public void showSubtitle_impl() {
        mController.sendCommand(COMMAND_SHOW_SUBTITLE, null, null);
    }

    @Override
    public void hideSubtitle_impl() {
        mController.sendCommand(COMMAND_HIDE_SUBTITLE, null, null);
    }

    @Override
    public void setPrevNextListeners_impl(View.OnClickListener next, View.OnClickListener prev) {
        mNextListener = next;
        mPrevListener = prev;

        if (mNextButton != null) {
            mNextButton.setOnClickListener(mNextListener);
            mNextButton.setEnabled(mNextListener != null);
            mNextButton.setVisibility(View.VISIBLE);
        }
        if (mPrevButton != null) {
            mPrevButton.setOnClickListener(mPrevListener);
            mPrevButton.setEnabled(mPrevListener != null);
            mPrevButton.setVisibility(View.VISIBLE);
        }
    }

    @Override
    public void setButtonVisibility_impl(int button, boolean visible) {
        switch (button) {
            case MediaControlView2.BUTTON_PLAY_PAUSE:
                if (mPlayPauseButton != null && canPause()) {
                    mPlayPauseButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_FFWD:
                if (mFfwdButton != null && canSeekForward()) {
                    mFfwdButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_REW:
                if (mRewButton != null && canSeekBackward()) {
                    mRewButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_NEXT:
                // TODO: this button is not visible unless its listener is manually set. Should this
                // function still be provided?
                if (mNextButton != null) {
                    mNextButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_PREV:
                // TODO: this button is not visible unless its listener is manually set. Should this
                // function still be provided?
                if (mPrevButton != null) {
                    mPrevButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_SUBTITLE:
                if (mSubtitleButton != null && mContainsSubtitle) {
                    mSubtitleButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_FULL_SCREEN:
                if (mFullScreenButton != null) {
                    mFullScreenButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_OVERFLOW:
                if (mOverflowButtonRight != null) {
                    mOverflowButtonRight.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_MUTE:
                if (mMuteButton != null) {
                    mMuteButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_ASPECT_RATIO:
                if (mAspectRationButton != null) {
                    mAspectRationButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            case MediaControlView2.BUTTON_SETTINGS:
                if (mSettingsButton != null) {
                    mSettingsButton.setVisibility((visible) ? View.VISIBLE : View.GONE);
                }
                break;
            default:
                break;
        }
    }

    @Override
    public void onAttachedToWindow_impl() {
        mSuperProvider.onAttachedToWindow_impl();
    }

    @Override
    public void onDetachedFromWindow_impl() {
        mSuperProvider.onDetachedFromWindow_impl();
    }

    @Override
    public CharSequence getAccessibilityClassName_impl() {
        return MediaControlView2.class.getName();
    }

    @Override
    public boolean onTouchEvent_impl(MotionEvent ev) {
        return false;
    }

    // TODO: Should this function be removed?
    @Override
    public boolean onTrackballEvent_impl(MotionEvent ev) {
        mInstance.show(DEFAULT_TIMEOUT_MS);
        return false;
    }

    @Override
    public boolean onKeyDown_impl(int keyCode, KeyEvent event) {
        return mSuperProvider.onKeyDown_impl(keyCode, event);
    }

    @Override
    public void onFinishInflate_impl() {
        mSuperProvider.onFinishInflate_impl();
    }

    @Override
    public boolean dispatchKeyEvent_impl(KeyEvent event) {
        int keyCode = event.getKeyCode();
        final boolean uniqueDown = event.getRepeatCount() == 0
                && event.getAction() == KeyEvent.ACTION_DOWN;
        if (keyCode == KeyEvent.KEYCODE_HEADSETHOOK
                || keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE
                || keyCode == KeyEvent.KEYCODE_SPACE) {
            if (uniqueDown) {
                togglePausePlayState();
                mInstance.show(DEFAULT_TIMEOUT_MS);
                if (mPlayPauseButton != null) {
                    mPlayPauseButton.requestFocus();
                }
            }
            return true;
        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_PLAY) {
            if (uniqueDown && !isPlaying()) {
                togglePausePlayState();
                mInstance.show(DEFAULT_TIMEOUT_MS);
            }
            return true;
        } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP
                || keyCode == KeyEvent.KEYCODE_MEDIA_PAUSE) {
            if (uniqueDown && isPlaying()) {
                togglePausePlayState();
                mInstance.show(DEFAULT_TIMEOUT_MS);
            }
            return true;
        } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
                || keyCode == KeyEvent.KEYCODE_VOLUME_UP
                || keyCode == KeyEvent.KEYCODE_VOLUME_MUTE
                || keyCode == KeyEvent.KEYCODE_CAMERA) {
            // don't show the controls for volume adjustment
            return mSuperProvider.dispatchKeyEvent_impl(event);
        } else if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU) {
            if (uniqueDown) {
                mInstance.hide();
            }
            return true;
        }

        mInstance.show(DEFAULT_TIMEOUT_MS);
        return mSuperProvider.dispatchKeyEvent_impl(event);
    }

    @Override
    public void setEnabled_impl(boolean enabled) {
        if (mPlayPauseButton != null) {
            mPlayPauseButton.setEnabled(enabled);
        }
        if (mFfwdButton != null) {
            mFfwdButton.setEnabled(enabled);
        }
        if (mRewButton != null) {
            mRewButton.setEnabled(enabled);
        }
        if (mNextButton != null) {
            mNextButton.setEnabled(enabled);
        }
        if (mPrevButton != null) {
            mPrevButton.setEnabled(enabled);
        }
        if (mProgress != null) {
            mProgress.setEnabled(enabled);
        }
        disableUnsupportedButtons();
        mSuperProvider.setEnabled_impl(enabled);
    }

    ///////////////////////////////////////////////////
    // Protected or private methods
    ///////////////////////////////////////////////////

    private boolean isPlaying() {
        if (mPlaybackState != null) {
            return mPlaybackState.getState() == PlaybackState.STATE_PLAYING;
        }
        return false;
    }

    private int getCurrentPosition() {
        mPlaybackState = mController.getPlaybackState();
        if (mPlaybackState != null) {
            return (int) mPlaybackState.getPosition();
        }
        return 0;
    }

    private int getBufferPercentage() {
        if (mDuration == 0) {
            return 0;
        }
        mPlaybackState = mController.getPlaybackState();
        if (mPlaybackState != null) {
            return (int) (mPlaybackState.getBufferedPosition() * 100) / mDuration;
        }
        return 0;
    }

    private boolean canPause() {
        if (mPlaybackState != null) {
            return (mPlaybackState.getActions() & PlaybackState.ACTION_PAUSE) != 0;
        }
        return true;
    }

    private boolean canSeekBackward() {
        if (mPlaybackState != null) {
            return (mPlaybackState.getActions() & PlaybackState.ACTION_REWIND) != 0;
        }
        return true;
    }

    private boolean canSeekForward() {
        if (mPlaybackState != null) {
            return (mPlaybackState.getActions() & PlaybackState.ACTION_FAST_FORWARD) != 0;
        }
        return true;
    }

    /**
     * Create the view that holds the widgets that control playback.
     * Derived classes can override this to create their own.
     *
     * @return The controller view.
     * @hide This doesn't work as advertised
     */
    protected View makeControllerView() {
        View root = ApiHelper.inflateLibLayout(mInstance.getContext(), R.layout.media_controller);
        initControllerView(root);
        return root;
    }

    private void initControllerView(View v) {
        Resources res = ApiHelper.getLibResources();
        mPlayDescription = res.getText(R.string.lockscreen_play_button_content_description);
        mPauseDescription = res.getText(R.string.lockscreen_pause_button_content_description);
        mReplayDescription = res.getText(R.string.lockscreen_replay_button_content_description);

        mPlayPauseButton = v.findViewById(R.id.pause);
        if (mPlayPauseButton != null) {
            mPlayPauseButton.requestFocus();
            mPlayPauseButton.setOnClickListener(mPlayPauseListener);
            mPlayPauseButton.setColorFilter(R.integer.gray);
            mPlayPauseButton.setEnabled(false);
        }
        mFfwdButton = v.findViewById(R.id.ffwd);
        if (mFfwdButton != null) {
            mFfwdButton.setOnClickListener(mFfwdListener);
            mFfwdButton.setColorFilter(R.integer.gray);
            mFfwdButton.setEnabled(false);
        }
        mRewButton = v.findViewById(R.id.rew);
        if (mRewButton != null) {
            mRewButton.setOnClickListener(mRewListener);
            mRewButton.setColorFilter(R.integer.gray);
            mRewButton.setEnabled(false);
        }
        mNextButton = v.findViewById(R.id.next);
        if (mNextButton != null) {
            mNextButton.setVisibility(View.GONE);
        }
        mPrevButton = v.findViewById(R.id.prev);
        if (mPrevButton != null) {
            mPrevButton.setVisibility(View.GONE);
        }

        mBasicControls = v.findViewById(R.id.basic_controls);
        mSubtitleButton = v.findViewById(R.id.subtitle);
        if (mSubtitleButton != null) {
            mSubtitleButton.setOnClickListener(mSubtitleListener);
            mSubtitleButton.setColorFilter(R.integer.gray);
            mSubtitleButton.setEnabled(false);
        }
        mFullScreenButton = v.findViewById(R.id.fullscreen);
        if (mFullScreenButton != null) {
            mFullScreenButton.setOnClickListener(mFullScreenListener);
            // TODO: Show Fullscreen button when only it is possible.
        }
        mOverflowButtonRight = v.findViewById(R.id.overflow_right);
        if (mOverflowButtonRight != null) {
            mOverflowButtonRight.setOnClickListener(mOverflowRightListener);
        }

        // TODO: should these buttons be shown as default?
        mExtraControls = v.findViewById(R.id.extra_controls);
        mOverflowButtonLeft = v.findViewById(R.id.overflow_left);
        if (mOverflowButtonLeft != null) {
            mOverflowButtonLeft.setOnClickListener(mOverflowLeftListener);
        }
        mMuteButton = v.findViewById(R.id.mute);
        mAspectRationButton = v.findViewById(R.id.aspect_ratio);
        mSettingsButton = v.findViewById(R.id.settings);

        mProgress = v.findViewById(R.id.mediacontroller_progress);
        if (mProgress != null) {
            if (mProgress instanceof SeekBar) {
                SeekBar seeker = (SeekBar) mProgress;
                seeker.setOnSeekBarChangeListener(mSeekListener);
            }
            mProgress.setMax(MAX_PROGRESS);
        }

        mTitleView = v.findViewById(R.id.title_text);

        mEndTime = v.findViewById(R.id.time);
        mCurrentTime = v.findViewById(R.id.time_current);
        mFormatBuilder = new StringBuilder();
        mFormatter = new Formatter(mFormatBuilder, Locale.getDefault());
    }

    /**
     * Disable pause or seek buttons if the stream cannot be paused or seeked.
     * This requires the control interface to be a MediaPlayerControlExt
     */
    private void disableUnsupportedButtons() {
        try {
            if (mPlayPauseButton != null && !canPause()) {
                mPlayPauseButton.setEnabled(false);
            }
            if (mRewButton != null && !canSeekBackward()) {
                mRewButton.setEnabled(false);
            }
            if (mFfwdButton != null && !canSeekForward()) {
                mFfwdButton.setEnabled(false);
            }
            // TODO What we really should do is add a canSeek to the MediaPlayerControl interface;
            // this scheme can break the case when applications want to allow seek through the
            // progress bar but disable forward/backward buttons.
            //
            // However, currently the flags SEEK_BACKWARD_AVAILABLE, SEEK_FORWARD_AVAILABLE,
            // and SEEK_AVAILABLE are all (un)set together; as such the aforementioned issue
            // shouldn't arise in existing applications.
            if (mProgress != null && !canSeekBackward() && !canSeekForward()) {
                mProgress.setEnabled(false);
            }
        } catch (IncompatibleClassChangeError ex) {
            // We were given an old version of the interface, that doesn't have
            // the canPause/canSeekXYZ methods. This is OK, it just means we
            // assume the media can be paused and seeked, and so we don't disable
            // the buttons.
        }
    }

    private final Runnable mFadeOut = new Runnable() {
        @Override
        public void run() {
            if (isPlaying()) {
                mInstance.hide();
            }
        }
    };

    private final Runnable mShowProgress = new Runnable() {
        @Override
        public void run() {
            int pos = setProgress();
            if (!mDragging && mShowing && isPlaying()) {
                mInstance.postDelayed(mShowProgress,
                        DEFAULT_PROGRESS_UPDATE_TIME_MS - (pos % DEFAULT_PROGRESS_UPDATE_TIME_MS));
            }
        }
    };

    private String stringForTime(int timeMs) {
        int totalSeconds = timeMs / 1000;

        int seconds = totalSeconds % 60;
        int minutes = (totalSeconds / 60) % 60;
        int hours = totalSeconds / 3600;

        mFormatBuilder.setLength(0);
        if (hours > 0) {
            return mFormatter.format("%d:%02d:%02d", hours, minutes, seconds).toString();
        } else {
            return mFormatter.format("%02d:%02d", minutes, seconds).toString();
        }
    }

    private int setProgress() {
        if (mController == null || mDragging) {
            return 0;
        }
        int positionOnProgressBar = 0;
        int currentPosition = getCurrentPosition();
        if (mDuration > 0) {
            positionOnProgressBar = (int) (MAX_PROGRESS * (long) currentPosition / mDuration);
        }
        if (mProgress != null && currentPosition != mDuration) {
            mProgress.setProgress(positionOnProgressBar);
            mProgress.setSecondaryProgress(getBufferPercentage() * 10);
        }

        if (mEndTime != null) {
            mEndTime.setText(stringForTime(mDuration));

        }
        if (mCurrentTime != null) {
            mCurrentTime.setText(stringForTime(currentPosition));
        }

        return currentPosition;
    }

    private void togglePausePlayState() {
        if (isPlaying()) {
            mControls.pause();
            mPlayPauseButton.setImageDrawable(
                    ApiHelper.getLibResources().getDrawable(
                            R.drawable.ic_play_circle_filled, null));
            mPlayPauseButton.setContentDescription(mPlayDescription);
        } else {
            mControls.play();
            mPlayPauseButton.setImageDrawable(
                    ApiHelper.getLibResources().getDrawable(
                            R.drawable.ic_pause_circle_filled, null));
            mPlayPauseButton.setContentDescription(mPauseDescription);
        }
    }

    // There are two scenarios that can trigger the seekbar listener to trigger:
    //
    // The first is the user using the touchpad to adjust the posititon of the
    // seekbar's thumb. In this case onStartTrackingTouch is called followed by
    // a number of onProgressChanged notifications, concluded by onStopTrackingTouch.
    // We're setting the field "mDragging" to true for the duration of the dragging
    // session to avoid jumps in the position in case of ongoing playback.
    //
    // The second scenario involves the user operating the scroll ball, in this
    // case there WON'T BE onStartTrackingTouch/onStopTrackingTouch notifications,
    // we will simply apply the updated position without suspending regular updates.
    private final OnSeekBarChangeListener mSeekListener = new OnSeekBarChangeListener() {
        @Override
        public void onStartTrackingTouch(SeekBar bar) {
            if (!mSeekAvailable) {
                return;
            }
            mInstance.show(3600000);

            mDragging = true;

            // By removing these pending progress messages we make sure
            // that a) we won't update the progress while the user adjusts
            // the seekbar and b) once the user is done dragging the thumb
            // we will post one of these messages to the queue again and
            // this ensures that there will be exactly one message queued up.
            mInstance.removeCallbacks(mShowProgress);

            // Check if playback is currently stopped. In this case, update the pause button to
            // show the play image instead of the replay image.
            if (mIsStopped) {
                mPlayPauseButton.setImageDrawable(
                        ApiHelper.getLibResources().getDrawable(
                                R.drawable.ic_play_circle_filled, null));
                mPlayPauseButton.setContentDescription(mPlayDescription);
                mIsStopped = false;
            }
        }

        @Override
        public void onProgressChanged(SeekBar bar, int progress, boolean fromUser) {
            if (!mSeekAvailable) {
                return;
            }
            if (!fromUser) {
                // We're not interested in programmatically generated changes to
                // the progress bar's position.
                return;
            }
            if (mDuration > 0) {
                int newPosition = (int) (((long) mDuration * progress) / MAX_PROGRESS);
                mControls.seekTo(newPosition);

                if (mCurrentTime != null) {
                    mCurrentTime.setText(stringForTime(newPosition));
                }
            }
        }

        @Override
        public void onStopTrackingTouch(SeekBar bar) {
            if (!mSeekAvailable) {
                return;
            }
            mDragging = false;

            setProgress();
            mInstance.show(DEFAULT_TIMEOUT_MS);

            // Ensure that progress is properly updated in the future,
            // the call to show() does not guarantee this because it is a
            // no-op if we are already showing.
            mInstance.post(mShowProgress);
        }
    };

    private final View.OnClickListener mPlayPauseListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            togglePausePlayState();
            mInstance.show(DEFAULT_TIMEOUT_MS);
        }
    };

    private final View.OnClickListener mRewListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            int pos = getCurrentPosition() - REWIND_TIME_MS;
            mControls.seekTo(pos);
            setProgress();

            mInstance.show(DEFAULT_TIMEOUT_MS);
        }
    };

    private final View.OnClickListener mFfwdListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            int pos = getCurrentPosition() + FORWARD_TIME_MS;
            mControls.seekTo(pos);
            setProgress();

            mInstance.show(DEFAULT_TIMEOUT_MS);
        }
    };

    private final View.OnClickListener mSubtitleListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (!mSubtitleIsEnabled) {
                mSubtitleButton.setImageDrawable(
                        ApiHelper.getLibResources().getDrawable(
                                R.drawable.ic_media_subtitle_enabled, null));
                mInstance.showSubtitle();
                mSubtitleIsEnabled = true;
            } else {
                mSubtitleButton.setImageDrawable(
                        ApiHelper.getLibResources().getDrawable(
                                R.drawable.ic_media_subtitle_disabled, null));
                mInstance.hideSubtitle();
                mSubtitleIsEnabled = false;
            }
            mInstance.show(DEFAULT_TIMEOUT_MS);
        }
    };

    private final View.OnClickListener mFullScreenListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            final boolean isEnteringFullScreen = !mIsFullScreen;
            // TODO: Re-arrange the button layouts according to the UX.
            if (isEnteringFullScreen) {
                mFullScreenButton.setImageDrawable(
                        ApiHelper.getLibResources().getDrawable(
                                R.drawable.ic_fullscreen_exit, null));
            } else {
                mFullScreenButton.setImageDrawable(
                        ApiHelper.getLibResources().getDrawable(R.drawable.ic_fullscreen, null));
            }
            Bundle args = new Bundle();
            args.putBoolean(ARGUMENT_KEY_FULLSCREEN, isEnteringFullScreen);
            mController.sendCommand(COMMAND_SET_FULLSCREEN, args, null);

            mIsFullScreen = isEnteringFullScreen;
            mInstance.show(DEFAULT_TIMEOUT_MS);
        }
    };

    private final View.OnClickListener mOverflowRightListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            mBasicControls.setVisibility(View.GONE);
            mExtraControls.setVisibility(View.VISIBLE);
            mInstance.show(DEFAULT_TIMEOUT_MS);
        }
    };

    private final View.OnClickListener mOverflowLeftListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            mBasicControls.setVisibility(View.VISIBLE);
            mExtraControls.setVisibility(View.GONE);
        }
    };

    private void updateDuration() {
        if (mMetadata != null) {
            if (mMetadata.containsKey(MediaMetadata.METADATA_KEY_DURATION)) {
                mDuration = (int) mMetadata.getLong(MediaMetadata.METADATA_KEY_DURATION);
                // update progress bar
                setProgress();
            }
        }
    }

    private void updateTitle() {
        if (mMetadata != null) {
            if (mMetadata.containsKey(MediaMetadata.METADATA_KEY_TITLE)) {
                mTitleView.setText(mMetadata.getString(MediaMetadata.METADATA_KEY_TITLE));
            }
        }
    }

    private class MediaControllerCallback extends MediaController.Callback {
        @Override
        public void onPlaybackStateChanged(PlaybackState state) {
            mPlaybackState = state;

            // Update pause button depending on playback state for the following two reasons:
            //   1) Need to handle case where app customizes playback state behavior when app
            //      activity is resumed.
            //   2) Need to handle case where the media file reaches end of duration.
            if (mPlaybackState.getState() != mPrevState) {
                switch (mPlaybackState.getState()) {
                    case PlaybackState.STATE_PLAYING:
                        mPlayPauseButton.setImageDrawable(
                                ApiHelper.getLibResources().getDrawable(
                                        R.drawable.ic_pause_circle_filled, null));
                        mPlayPauseButton.setContentDescription(mPauseDescription);
                        break;
                    case PlaybackState.STATE_PAUSED:
                        mPlayPauseButton.setImageDrawable(
                                ApiHelper.getLibResources().getDrawable(
                                        R.drawable.ic_play_circle_filled, null));
                        mPlayPauseButton.setContentDescription(mPlayDescription);
                        break;
                    case PlaybackState.STATE_STOPPED:
                        mPlayPauseButton.setImageDrawable(
                                ApiHelper.getLibResources().getDrawable(
                                        R.drawable.ic_replay, null));
                        mPlayPauseButton.setContentDescription(mReplayDescription);
                        mIsStopped = true;
                        break;
                    default:
                        break;
                }
                mPrevState = mPlaybackState.getState();
            }

            if (mPlaybackActions != mPlaybackState.getActions()) {
                long newActions = mPlaybackState.getActions();
                if ((newActions & PlaybackState.ACTION_PAUSE) != 0) {
                    mPlayPauseButton.clearColorFilter();
                    mPlayPauseButton.setEnabled(true);
                }
                if ((newActions & PlaybackState.ACTION_REWIND) != 0) {
                    mRewButton.clearColorFilter();
                    mRewButton.setEnabled(true);
                }
                if ((newActions & PlaybackState.ACTION_FAST_FORWARD) != 0) {
                    mFfwdButton.clearColorFilter();
                    mFfwdButton.setEnabled(true);
                }
                if ((newActions & PlaybackState.ACTION_SEEK_TO) != 0) {
                    mSeekAvailable = true;
                } else {
                    mSeekAvailable = false;
                }
                mPlaybackActions = newActions;
            }
        }

        @Override
        public void onMetadataChanged(MediaMetadata metadata) {
            mMetadata = metadata;
            updateDuration();
            updateTitle();
        }

        @Override
        public void onSessionEvent(String event, Bundle extras) {
            if (event.equals(EVENT_UPDATE_SUBTITLE_STATUS)) {
                boolean newSubtitleStatus = extras.getBoolean(KEY_STATE_CONTAINS_SUBTITLE);
                if (newSubtitleStatus != mContainsSubtitle) {
                    if (newSubtitleStatus) {
                        mSubtitleButton.clearColorFilter();
                        mSubtitleButton.setEnabled(true);
                    } else {
                        mSubtitleButton.setColorFilter(R.integer.gray);
                        mSubtitleButton.setEnabled(false);
                    }
                    mContainsSubtitle = newSubtitleStatus;
                }
            }
        }
    }
}