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

import android.annotation.TargetApi;
import android.content.ComponentName;
import android.content.Context;
import android.content.res.ColorStateList;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.PorterDuff;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.InsetDrawable;
import android.media.MediaDescription;
import android.media.MediaMetadata;
import android.media.session.MediaController;
import android.media.session.MediaSession;
import android.media.session.PlaybackState;
import android.net.Uri;
import android.os.BadParcelableException;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.support.annotation.Nullable;
import android.support.car.ui.ColorChecker;
import android.support.v4.app.Fragment;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;
import android.util.Pair;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.SeekBar;
import android.widget.TextView;

import com.android.car.apps.common.BitmapDownloader;
import com.android.car.apps.common.BitmapWorkerOptions;
import com.android.car.apps.common.util.Assert;
import com.android.car.media.util.widgets.MusicPanelLayout;
import com.android.car.media.util.widgets.PlayPauseStopImageView;

import java.util.List;
import java.util.Objects;

/**
 * Fragment that displays the media playback UI.
 */
public class MediaPlaybackFragment extends Fragment implements MediaPlaybackModel.Listener {
    private static final String TAG = "MediaPlayback";

    private static final String[] PREFERRED_BITMAP_ORDER = {
            MediaMetadata.METADATA_KEY_ALBUM_ART,
            MediaMetadata.METADATA_KEY_ART,
            MediaMetadata.METADATA_KEY_DISPLAY_ICON
    };

    private static final String[] PREFERRED_URI_ORDER = {
            MediaMetadata.METADATA_KEY_ALBUM_ART_URI,
            MediaMetadata.METADATA_KEY_ART_URI,
            MediaMetadata.METADATA_KEY_DISPLAY_ICON_URI
    };

    private static final long SEEK_BAR_UPDATE_TIME_INTERVAL_MS = 500;
    private static final long DELAY_CLOSE_OVERFLOW_MS = 3500;
    // delay showing the no content view for 3 second -- when the media app cold starts, it
    // usually takes a moment to load the last played song from database. So we will wait for
    // 3 sec, before we show the no content view, instead of showing it and immediately
    // switch to playback view when the metadata loads.
    private static final long DELAY_SHOW_NO_CONTENT_VIEW_MS = 3000;
    private static final long FEEDBACK_MESSAGE_DISPLAY_TIME_MS = 6000;

    private MediaActivity mActivity;
    private MediaPlaybackModel mMediaPlaybackModel;
    private final Handler mHandler = new Handler();

    private TextView mTitleView;
    private TextView mArtistView;
    private ImageButton mPrevButton;
    private PlayPauseStopImageView mPlayPauseStopButton;
    private ImageButton mNextButton;
    private ImageButton mPlayQueueButton;
    private MusicPanelLayout mMusicPanel;
    private LinearLayout mControlsView;
    private LinearLayout mOverflowView;
    private ImageButton mOverflowOnButton;
    private ImageButton mOverflowOffButton;
    private final ImageButton[] mCustomActionButtons = new ImageButton[4];
    private SeekBar mSeekBar;
    private ProgressBar mSpinner;
    private boolean mOverflowVisibility;
    private long mStartProgress;
    private long mStartTime;
    private MediaDescription mCurrentTrack;
    private boolean mShowingMessage;
    private View mInitialNoContentView;
    private View mMetadata;
    private ImageView mMusicErrorIcon;
    private TextView mTapToSelectText;
    private ProgressBar mAppConnectingSpinner;
    private boolean mDelayedResetTitleInProgress;
    private int mAlbumArtWidth = 800;
    private int mAlbumArtHeight = 400;
    private int mShowTitleDelayMs = 250;
    private TelephonyManager mTelephonyManager;
    private boolean mInCall = false;
    private BitmapDownloader mDownloader;
    private boolean mReturnFromOnStop = false;

    private enum ViewType {
        NO_CONTENT_VIEW,
        PLAYBACK_CONTROLS_VIEW,
        LOADING_VIEW,
    }

    private ViewType mCurrentView;

    public MediaPlaybackFragment() {
      super();
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mActivity = (MediaActivity) getHost();
        mShowTitleDelayMs =
                mActivity.getResources().getInteger(R.integer.new_album_art_fade_in_offset);
        mMediaPlaybackModel = new MediaPlaybackModel(mActivity, null /* browserExtras */);
        mMediaPlaybackModel.addListener(this);
        mTelephonyManager =
                (TelephonyManager) mActivity.getSystemService(Context.TELEPHONY_SERVICE);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mCurrentView = null;
        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
        mMediaPlaybackModel = null;
        mActivity = null;
        // Calling this with null will clear queue of callbacks and message.
        mHandler.removeCallbacksAndMessages(null);
        mDelayedResetTitleInProgress = false;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, final ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.now_playing_screen, container, false);
        mTitleView = (TextView) v.findViewById(R.id.title);
        mArtistView = (TextView) v.findViewById(R.id.artist);
        mSeekBar = (SeekBar) v.findViewById(R.id.seek_bar);
        // In L setEnabled(false) will make the tint color wrong, but not in M.
        mSeekBar.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                // Eat up touch events from users as we set progress programmatically only.
                return true;
            }
        });
        mControlsView = (LinearLayout) v.findViewById(R.id.controls);
        mPlayQueueButton = (ImageButton) v.findViewById(R.id.play_queue);
        mPrevButton = (ImageButton) v.findViewById(R.id.prev);
        mPlayPauseStopButton = (PlayPauseStopImageView) v.findViewById(R.id.play_pause);
        mNextButton = (ImageButton) v.findViewById(R.id.next);
        mOverflowOnButton = (ImageButton) v.findViewById(R.id.overflow_on);
        mOverflowView = (LinearLayout) v.findViewById(R.id.overflow_items);
        mOverflowOffButton = (ImageButton) v.findViewById(R.id.overflow_off);
        setActionDrawable(mOverflowOffButton, R.drawable.ic_overflow_activated, getResources());
        mMusicPanel = (MusicPanelLayout) v.findViewById(R.id.music_panel);
        mMusicPanel.setDefaultFocus(mPlayPauseStopButton);
        mSpinner = (ProgressBar) v.findViewById(R.id.spinner);
        mInitialNoContentView = v.findViewById(R.id.initial_view);
        mMetadata = v.findViewById(R.id.metadata);

        mMusicErrorIcon = (ImageView) v.findViewById(R.id.error_icon);
        mTapToSelectText = (TextView) v.findViewById(R.id.tap_to_select_item);
        mAppConnectingSpinner = (ProgressBar) v.findViewById(R.id.loading_spinner);

        mCustomActionButtons[0] = (ImageButton) v.findViewById(R.id.custom_action_1);
        mCustomActionButtons[1] = (ImageButton) v.findViewById(R.id.custom_action_2);
        mCustomActionButtons[2] = (ImageButton) v.findViewById(R.id.custom_action_3);
        mCustomActionButtons[3] = (ImageButton) v.findViewById(R.id.custom_action_4);

        mPrevButton.setOnClickListener(mControlsClickListener);
        mNextButton.setOnClickListener(mControlsClickListener);
        // Yes they both need it. The layout is not focusable so it will never get the click.
        // You can't make the layout focusable because then the button wont highlight.
        v.findViewById(R.id.play_pause_container).setOnClickListener(mControlsClickListener);
        mPlayPauseStopButton.setOnClickListener(mControlsClickListener);
        mPlayQueueButton.setOnClickListener(mControlsClickListener);
        mOverflowOnButton.setOnClickListener(mControlsClickListener);
        mOverflowOffButton.setOnClickListener(mControlsClickListener);

        // If touch mode is enabled, we disable focus from buttons.
        if (getResources().getBoolean(R.bool.has_touch)) {
            setControlsFocusability(false);
            setOverflowFocusability(false);
        }

        return v;
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        Pair<Integer, Integer> albumArtSize = mActivity.getAlbumArtSize();
        if (albumArtSize != null) {
            if (albumArtSize.first > 0 && albumArtSize.second > 0) {
                mAlbumArtWidth = albumArtSize.first;
                mAlbumArtHeight = albumArtSize.second;
            }
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        mMediaPlaybackModel.stop();
        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
    }

    @Override
    public void onStop() {
        super.onStop();
        // When switch apps, onStop() will be called. Mark it and don't show fade in/out title and
        // background animations when come back.
        mReturnFromOnStop = true;
    }

    @Override
    public void onResume() {
        super.onResume();
        mMediaPlaybackModel.start();
        // Note: at registration, TelephonyManager will invoke the callback with the current state.
        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
    }

    @Override
    public void onMediaAppChanged(@Nullable ComponentName currentName,
            @Nullable ComponentName newName) {
        Assert.isMainThread();
        resetTitle();
        if (Objects.equals(currentName, newName)) {
            return;
        }
        int accentColor = mMediaPlaybackModel.getAccentColor();
        mPlayPauseStopButton.setPrimaryActionColor(accentColor);
        mSeekBar.getProgressDrawable().setColorFilter(accentColor, PorterDuff.Mode.SRC_IN);
        int overflowViewColor = mMediaPlaybackModel.getPrimaryColorDark();
        mOverflowView.getBackground().setColorFilter(overflowViewColor, PorterDuff.Mode.SRC_IN);
        // Tint the overflow actions light or dark depending on contrast.
        int overflowTintColor = ColorChecker.getTintColor(mActivity, overflowViewColor);
        for (ImageView v : mCustomActionButtons) {
            v.setColorFilter(overflowTintColor, PorterDuff.Mode.SRC_IN);
        }
        mOverflowOffButton.setColorFilter(overflowTintColor, PorterDuff.Mode.SRC_IN);
        ColorStateList colorStateList = ColorStateList.valueOf(accentColor);
        mSpinner.setIndeterminateTintList(colorStateList);
        mAppConnectingSpinner.setIndeterminateTintList(ColorStateList.valueOf(accentColor));
        showLoadingView();
        closeOverflowMenu();
    }

    @Override
    public void onMediaAppStatusMessageChanged(@Nullable String message) {
        Assert.isMainThread();
        if (message == null) {
            resetTitle();
        } else {
            showMessage(message);
        }
    }

    @Override
    public void onMediaConnected() {
        Assert.isMainThread();
        onMetadataChanged(mMediaPlaybackModel.getMetadata());
        onQueueChanged(mMediaPlaybackModel.getQueue());
        onPlaybackStateChanged(mMediaPlaybackModel.getPlaybackState());
        mReturnFromOnStop = false;
    }

    @Override
    public void onMediaConnectionSuspended() {
        Assert.isMainThread();
        mReturnFromOnStop = false;
    }

    @Override
    public void onMediaConnectionFailed(CharSequence failedClientName) {
        Assert.isMainThread();
        showInitialNoContentView(getString(R.string.cannot_connect_to_app, failedClientName), true);
        mReturnFromOnStop = false;
    }

    @Override
    @TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
    public void onPlaybackStateChanged(@Nullable PlaybackState state) {
        Assert.isMainThread();
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "onPlaybackStateChanged; state: "
                    + (state == null ? "<< NULL >>" : state.toString()));
        }
        MediaMetadata metadata = mMediaPlaybackModel.getMetadata();
        if (state == null) {
            return;
        }

        if (state.getState() == PlaybackState.STATE_ERROR) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "ERROR: " + state.getErrorMessage());
            }
            showInitialNoContentView(state.getErrorMessage() != null ?
                    state.getErrorMessage().toString() :
                    mActivity.getString(R.string.unknown_error), true);
            return;
        }

        mStartProgress = state.getPosition();
        mStartTime = System.currentTimeMillis();
        mSeekBar.setProgress((int) mStartProgress);
        if (state.getState() == PlaybackState.STATE_PLAYING) {
            mHandler.post(mSeekBarRunnable);
        } else {
            mHandler.removeCallbacks(mSeekBarRunnable);
        }
        if (!mInCall) {
            int playbackState = state.getState();
            mPlayPauseStopButton.setPlayState(playbackState);
            // Due to the action of PlaybackState will be changed when the state of PlaybackState is
            // changed, we set mode every time onPlaybackStateChanged() is called.
            if (playbackState == PlaybackState.STATE_PLAYING ||
                    playbackState == PlaybackState.STATE_BUFFERING) {
                mPlayPauseStopButton.setMode(((state.getActions() & PlaybackState.ACTION_STOP) != 0)
                        ? PlayPauseStopImageView.MODE_STOP : PlayPauseStopImageView.MODE_PAUSE);
            } else {
                mPlayPauseStopButton.setMode(PlayPauseStopImageView.MODE_PAUSE);
            }
            mPlayPauseStopButton.refreshDrawableState();
        }
        if (state.getState() == PlaybackState.STATE_BUFFERING) {
            mSpinner.setVisibility(View.VISIBLE);
        } else {
            mSpinner.setVisibility(View.GONE);
        }

        updateActions(state.getActions(), state.getCustomActions());

        if (metadata == null) {
            return;
        }
        showMediaPlaybackControlsView();
    }

    @Override
    public void onMetadataChanged(@Nullable MediaMetadata metadata) {
        Assert.isMainThread();
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "onMetadataChanged; description: "
                    + (metadata == null ? "<< NULL >>" : metadata.getDescription().toString()));
        }
        if (metadata == null) {
            mHandler.postDelayed(mShowNoContentViewRunnable, DELAY_SHOW_NO_CONTENT_VIEW_MS);
            return;
        } else {
            mHandler.removeCallbacks(mShowNoContentViewRunnable);
        }

        showMediaPlaybackControlsView();
        mCurrentTrack = metadata.getDescription();
        Bitmap icon = getMetadataBitmap(metadata);
        if (!mShowingMessage) {
            mHandler.removeCallbacks(mSetTitleRunnable);
            // Show the title when the new album art starts to fade in, but don't need to show
            // the fade in animation when come back from switching apps.
            mHandler.postDelayed(mSetTitleRunnable,
                    icon == null || mReturnFromOnStop ? 0 : mShowTitleDelayMs);
        }
        Uri iconUri = getMetadataIconUri(metadata);
        if (icon != null) {
            Bitmap scaledIcon = cropAlbumArt(icon);
            if (scaledIcon != icon && !icon.isRecycled()) {
                icon.recycle();
            }
            // Fade out the old background and then fade in the new one when the new album art
            // starts, but don't need to show the fade out and fade in animations when come back
            // from switching apps.
            mActivity.setBackgroundBitmap(scaledIcon, !mReturnFromOnStop /* showAnimation */);
        } else if (iconUri != null) {
            if (mDownloader == null) {
                mDownloader = new BitmapDownloader(mActivity);
            }
            final int flags = BitmapWorkerOptions.CACHE_FLAG_DISK_DISABLED
                    | BitmapWorkerOptions.CACHE_FLAG_MEM_DISABLED;
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                Log.v(TAG, "Album art size " + mAlbumArtWidth + "x" + mAlbumArtHeight);
            }

            mDownloader.getBitmap(new BitmapWorkerOptions.Builder(mActivity).resource(iconUri)
                            .height(mAlbumArtHeight).width(mAlbumArtWidth).cacheFlag(flags).build(),
                    new BitmapDownloader.BitmapCallback() {
                        @Override
                        public void onBitmapRetrieved(Bitmap bitmap) {
                            if (mActivity != null) {
                                mActivity.setBackgroundBitmap(bitmap, true /* showAnimation */);
                            }
                        }
                    });
        } else {
            mActivity.setBackgroundColor(mMediaPlaybackModel.getPrimaryColorDark());
        }

        mSeekBar.setMax((int) metadata.getLong(MediaMetadata.METADATA_KEY_DURATION));
    }

    @Override
    public void onQueueChanged(List<MediaSession.QueueItem> queue) {
        Assert.isMainThread();
        if (queue.isEmpty()) {
            mPlayQueueButton.setVisibility(View.INVISIBLE);
        } else {
            mPlayQueueButton.setVisibility(View.VISIBLE);
        }
    }

    @Override
    public void onSessionDestroyed(CharSequence destroyedMediaClientName) {
        Assert.isMainThread();
        mHandler.removeCallbacks(mSeekBarRunnable);
        if (mActivity != null) {
            showInitialNoContentView(
                    getString(R.string.cannot_connect_to_app, destroyedMediaClientName), true);
        }
    }


    public void showMessage(String msg) {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "showMessage(); msg: " + msg);
        }
        // New messages will always be displayed regardless of if a feedback message is being shown.
        mHandler.removeCallbacks(mResetTitleRunnable);
        mActivity.darkenScrim(true);
        mTitleView.setSingleLine(false);
        mTitleView.setMaxLines(2);
        mArtistView.setVisibility(View.GONE);
        mTitleView.setText(msg);
        mShowingMessage = true;
    }

    boolean isOverflowMenuVisible() {
        return mOverflowVisibility;
    }

    void closeOverflowMenu() {
        mHandler.removeCallbacks(mCloseOverflowRunnable);
        setOverflowMenuVisibility(false);
    }

    void setOverflowMenuVisibility(boolean visibility) {
        if (mOverflowVisibility == visibility) {
            return;
        }
        mOverflowVisibility = visibility;
        if (visibility) {
            // Make the view invisible to let request focus work. Or else it will make b/23679226.
            mOverflowView.setVisibility(View.INVISIBLE);
            if (!getResources().getBoolean(R.bool.has_touch)) {
                setOverflowFocusability(true);
                setControlsFocusability(false);
            }
            mMusicPanel.setDefaultFocus(mOverflowOffButton);
            mOverflowOffButton.requestFocus();
            // After requesting focus is done, make the view to be visible.
            mOverflowView.setVisibility(View.VISIBLE);
            mOverflowView.animate().alpha(1f).setDuration(250)
                    .withEndAction(new Runnable() {
                        @Override
                        public void run() {
                            mControlsView.setVisibility(View.GONE);
                        }
                    });

            int tint = ColorChecker.getTintColor(mActivity,
                    mMediaPlaybackModel.getPrimaryColorDark());
            mSeekBar.getProgressDrawable().setColorFilter(tint, PorterDuff.Mode.SRC_IN);
        } else {
            mControlsView.setVisibility(View.INVISIBLE);
            if (!getResources().getBoolean(R.bool.has_touch)) {
                setControlsFocusability(true);
                setOverflowFocusability(false);
            }
            mMusicPanel.setDefaultFocus(mPlayPauseStopButton);
            mOverflowOnButton.requestFocus();
            mControlsView.setVisibility(View.VISIBLE);
            mOverflowView.animate().alpha(0f).setDuration(250)
                    .withEndAction(new Runnable() {
                        @Override
                        public void run() {
                            mOverflowView.setVisibility(View.GONE);
                        }
                    });
            mSeekBar.getProgressDrawable().setColorFilter(
                    mMediaPlaybackModel.getAccentColor(), PorterDuff.Mode.SRC_IN);
        }
    }

    private void setControlsFocusability(boolean focusable) {
        mPlayQueueButton.setFocusable(focusable);
        mPrevButton.setFocusable(focusable);
        mPlayPauseStopButton.setFocusable(focusable);
        mNextButton.setFocusable(focusable);
        mOverflowOnButton.setFocusable(focusable);
    }

    private void setOverflowFocusability(boolean focusable) {
        mCustomActionButtons[0].setFocusable(focusable);
        mCustomActionButtons[1].setFocusable(focusable);
        mCustomActionButtons[2].setFocusable(focusable);
        mCustomActionButtons[3].setFocusable(focusable);
        mOverflowOffButton.setFocusable(focusable);
    }

    /**
     * For a given drawer slot, set the proper action of the slot's button,
     * based on the slot being reserved and the corresponding action being enabled.
     * If the slot is not reserved and the corresponding action is disabled,
     * then the next available custom action is assigned to the button.
     * @param button The button corresponding to the slot
     * @param originalResId The drawable resource ID for the original button,
     * only used if the original action is not replaced by a custom action.
     * @param slotAlwaysReserved True if the slot should be empty when the
     * corresponding action is disabled. If false, when the action is disabled
     * the slot has its default action replaced by the next custom action, if any.
     * @param isOriginalEnabled True if the original action of this button is
     * enabled.
     * @param customActions A list of custom actions still unassigned to slots.
     */
    private void handleSlot(ImageButton button, int originalResId, boolean slotAlwaysReserved,
            boolean isOriginalEnabled, List<PlaybackState.CustomAction> customActions) {
        if (isOriginalEnabled || slotAlwaysReserved) {
            setActionDrawable(button, originalResId, getResources());
            button.setVisibility(isOriginalEnabled ? View.VISIBLE : View.INVISIBLE);
            button.setTag(null);
        } else {
            if (customActions.isEmpty()) {
                button.setVisibility(View.INVISIBLE);
            } else {
                PlaybackState.CustomAction customAction = customActions.remove(0);
                Bundle extras = customAction.getExtras();
                boolean repeatedAction = false;
                try {
                    repeatedAction = (extras != null && extras.getBoolean(
                            MediaConstants.EXTRA_REPEATED_CUSTOM_ACTION_BUTTON, false));
                } catch (BadParcelableException e) {
                    Log.e(TAG, "custom parcelable in custom action extras.", e);
                }
                if (repeatedAction) {
                    button.setOnTouchListener(mControlsTouchListener);
                } else {
                    button.setOnClickListener(mControlsClickListener);
                }
                setCustomAction(button, customAction);
            }
        }
    }

    /**
     * Takes a list of custom actions and standard actions and displays them in the media
     * controls card (or hides ones that aren't available).
     *
     * @param actions A bit mask of active actions (android.media.session.PlaybackState#ACTION_*).
     * @param customActions A list of custom actions specified by the {@link android.media.session.MediaSession}.
     */
    private void updateActions(long actions, List<PlaybackState.CustomAction> customActions) {
        List<MediaSession.QueueItem> mediaQueue = mMediaPlaybackModel.getQueue();
        handleSlot(
                mPlayQueueButton, R.drawable.ic_tracklist,
                mMediaPlaybackModel.isSlotForActionReserved(
                        MediaConstants.EXTRA_RESERVED_SLOT_QUEUE),
                !mediaQueue.isEmpty(),
                customActions);

        handleSlot(
                mPrevButton, R.drawable.ic_skip_previous,
                mMediaPlaybackModel.isSlotForActionReserved(
                        MediaConstants.EXTRA_RESERVED_SLOT_SKIP_TO_PREVIOUS),
                (actions & PlaybackState.ACTION_SKIP_TO_PREVIOUS) != 0,
                customActions);

        handleSlot(
                mNextButton, R.drawable.ic_skip_next,
                mMediaPlaybackModel.isSlotForActionReserved(
                        MediaConstants.EXTRA_RESERVED_SLOT_SKIP_TO_NEXT),
                (actions & PlaybackState.ACTION_SKIP_TO_NEXT) != 0,
                customActions);

        handleSlot(
                mOverflowOnButton, R.drawable.ic_overflow_normal,
                customActions.size() > 1,
                customActions.size() > 1,
                customActions);

        for (ImageButton button: mCustomActionButtons) {
            handleSlot(button, 0, false, false, customActions);
        }
    }

    private void setCustomAction(ImageButton imageButton, PlaybackState.CustomAction customAction) {
        imageButton.setVisibility(View.VISIBLE);
        setActionDrawable(imageButton, customAction.getIcon(),
                mMediaPlaybackModel.getPackageResources());
        imageButton.setTag(customAction);
    }

    private void showInitialNoContentView(String msg, boolean isError) {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "showInitialNoContentView()");
        }
        if (!needViewChange(ViewType.NO_CONTENT_VIEW)) {
            return;
        }
        mAppConnectingSpinner.setVisibility(View.GONE);
        mActivity.setScrimVisibility(false);
        if (isError) {
            mActivity.setBackgroundColor(getResources().getColor(R.color.car_error_screen));
            mMusicErrorIcon.setVisibility(View.VISIBLE);
        } else {
            mActivity.setBackgroundColor(getResources().getColor(R.color.car_dark_blue_grey_800));
            mMusicErrorIcon.setVisibility(View.INVISIBLE);
        }
        mTapToSelectText.setVisibility(View.VISIBLE);
        mTapToSelectText.setText(msg);
        mInitialNoContentView.setVisibility(View.VISIBLE);
        mMetadata.setVisibility(View.GONE);
        mMusicPanel.setVisibility(View.GONE);
    }

    private void showMediaPlaybackControlsView() {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "showMediaPlaybackControlsView()");
        }
        if (!needViewChange(ViewType.PLAYBACK_CONTROLS_VIEW)) {
            return;
        }
        if (mPlayPauseStopButton != null && getResources().getBoolean(R.bool.has_wheel)) {
            mPlayPauseStopButton.requestFocusFromTouch();
        }

        if (!mShowingMessage) {
            mActivity.setScrimVisibility(true);
        }
        mInitialNoContentView.setVisibility(View.GONE);
        mMetadata.setVisibility(View.VISIBLE);
        mMusicPanel.setVisibility(View.VISIBLE);
    }

    private void showLoadingView() {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "showLoadingView()");
        }
        if (!needViewChange(ViewType.LOADING_VIEW)) {
            return;
        }
        mActivity.setBackgroundColor(
                getResources().getColor(R.color.music_loading_view_background));
        mAppConnectingSpinner.setVisibility(View.VISIBLE);
        mMusicErrorIcon.setVisibility(View.GONE);
        mTapToSelectText.setVisibility(View.GONE);
        mInitialNoContentView.setVisibility(View.VISIBLE);
        mMetadata.setVisibility(View.GONE);
        mMusicPanel.setVisibility(View.GONE);
    }

    private boolean needViewChange(ViewType newView) {
        if (mCurrentView != null && mCurrentView == newView) {
            return false;
        }
        mCurrentView = newView;
        return true;
    }

    private void resetTitle() {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "resetTitle()");
        }
        if (!mShowingMessage) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "message not currently shown, not resetting title");
            }
            return;
        }
        // Feedback message is currently being displayed, reset will automatically take place when
        // the display interval expires.
        if (mDelayedResetTitleInProgress) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "delay reset title is in progress, not resetting title now");
            }
            return;
        }
        // This will set scrim visible and alpha value back to normal.
        mActivity.setScrimVisibility(true);
        mTitleView.setSingleLine(true);
        mArtistView.setVisibility(View.VISIBLE);
        if (mCurrentTrack != null) {
            mTitleView.setText(mCurrentTrack.getTitle());
            mArtistView.setText(mCurrentTrack.getSubtitle());
        }
        mShowingMessage = false;
    }

    private Bitmap cropAlbumArt(Bitmap icon) {
        if (icon == null) {
            return null;
        }
        int width = icon.getWidth();
        int height = icon.getHeight();
        int startX = width > mAlbumArtWidth ? (width - mAlbumArtWidth) / 2 : 0;
        int startY = height > mAlbumArtHeight ? (height - mAlbumArtHeight) / 2 : 0;
        int newWidth = width > mAlbumArtWidth ? mAlbumArtWidth : width;
        int newHeight = height > mAlbumArtHeight ? mAlbumArtHeight : height;
        return Bitmap.createBitmap(icon, startX, startY, newWidth, newHeight);
    }

    private Bitmap getMetadataBitmap(MediaMetadata metadata) {
        // Get the best art bitmap we can find
        for (int i = 0; i < PREFERRED_BITMAP_ORDER.length; i++) {
            Bitmap bitmap = metadata.getBitmap(PREFERRED_BITMAP_ORDER[i]);
            if (bitmap != null) {
                return bitmap;
            }
        }
        return null;
    }

    private Uri getMetadataIconUri(MediaMetadata metadata) {
        // Get the best Uri we can find
        for (int i = 0; i < PREFERRED_URI_ORDER.length; i++) {
            String iconUri = metadata.getString(PREFERRED_URI_ORDER[i]);
            if (!TextUtils.isEmpty(iconUri)) {
                return Uri.parse(iconUri);
            }
        }
        return null;
    }

    private void setActionDrawable(ImageButton button, int resId, Resources resources) {
        if (resources == null) {
            Log.e(TAG, "Resources is null. Icons will not show up.");
            return;
        }

        Resources myResources = getResources();
        // the resources may be from another package. we need to update the configuration using
        // the context from the activity so we get the drawable from the correct DPI bucket.
        resources.updateConfiguration(
                myResources.getConfiguration(), myResources.getDisplayMetrics());
        try {
            Drawable icon = resources.getDrawable(resId, null);
            int inset = myResources.getDimensionPixelSize(R.dimen.music_action_icon_inset);
            InsetDrawable insetIcon = new InsetDrawable(icon, inset);
            button.setImageDrawable(insetIcon);
        } catch (Resources.NotFoundException e) {
            Log.w(TAG, "Resource not found: " + resId);
        }
    }

    private void checkAndDisplayFeedbackMessage(PlaybackState.CustomAction ca) {
        try {
            Bundle extras = ca.getExtras();
            if (extras != null) {
                String feedbackMessage = extras.getString(
                        MediaConstants.EXTRA_CUSTOM_ACTION_STATUS, "");
                if (!TextUtils.isEmpty(feedbackMessage)) {
                    // Show feedback message that appears for a time interval unless a new
                    // message is shown.
                    showMessage(feedbackMessage);
                    mDelayedResetTitleInProgress = true;
                    mHandler.postDelayed(mResetTitleRunnable, FEEDBACK_MESSAGE_DISPLAY_TIME_MS);
                }
            }
        } catch (BadParcelableException e) {
            Log.e(TAG, "Custom parcelable was added to extras, unable " +
                    "to check for feedback message.", e);
        }
    }

    private final View.OnTouchListener mControlsTouchListener = new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            if (!mMediaPlaybackModel.isConnected()) {
                Log.e(TAG, "Unable to send action for " + v
                        + ". The MediaPlaybackModel is not connected.");
                return true;
            }
            boolean onDown;
            switch (event.getAction() & MotionEvent.ACTION_MASK) {
                case MotionEvent.ACTION_DOWN:
                    onDown = true;
                    break;
                case MotionEvent.ACTION_UP:
                    onDown = false;
                    break;
                default:
                    return true;
            }

            if (v.getTag() != null && v.getTag() instanceof PlaybackState.CustomAction) {
                PlaybackState.CustomAction ca = (PlaybackState.CustomAction) v.getTag();
                checkAndDisplayFeedbackMessage(ca);
                Bundle extras = ca.getExtras();
                try {
                    extras.putBoolean(
                            MediaConstants.EXTRA_REPEATED_CUSTOM_ACTION_BUTTON_ON_DOWN, onDown);
                } catch (BadParcelableException e) {
                    Log.e(TAG, "unable to on down notification for custom action.", e);
                }
                MediaController.TransportControls transportControls =
                        mMediaPlaybackModel.getTransportControls();
                transportControls.sendCustomAction(ca, extras);
                mHandler.removeCallbacks(mCloseOverflowRunnable);
                if (!onDown) {
                    mHandler.postDelayed(mCloseOverflowRunnable, DELAY_CLOSE_OVERFLOW_MS);
                }
            }
            return true;
        }
    };

    private final View.OnClickListener mControlsClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (!mMediaPlaybackModel.isConnected()) {
                Log.e(TAG, "Unable to send action for " + v
                        + ". The MediaPlaybackModel is not connected.");
                return;
            }
            MediaController.TransportControls transportControls =
                    mMediaPlaybackModel.getTransportControls();
            if (v.getTag() != null && v.getTag() instanceof PlaybackState.CustomAction) {
                PlaybackState.CustomAction ca = (PlaybackState.CustomAction) v.getTag();
                checkAndDisplayFeedbackMessage(ca);
                transportControls.sendCustomAction(ca, ca.getExtras());
                mHandler.removeCallbacks(mCloseOverflowRunnable);
                mHandler.postDelayed(mCloseOverflowRunnable, DELAY_CLOSE_OVERFLOW_MS);
            } else {
                switch (v.getId()) {
                    case R.id.play_queue:
                        mActivity.showQueueInDrawer();
                        break;
                    case R.id.prev:
                        transportControls.skipToPrevious();
                        break;
                    case R.id.play_pause:
                    case R.id.play_pause_container:
                        PlaybackState playbackState = mMediaPlaybackModel.getPlaybackState();
                        if (playbackState == null) {
                            break;
                        }
                        long transportControlFlags = playbackState.getActions();
                        if (playbackState.getState() == PlaybackState.STATE_PLAYING) {
                            if ((transportControlFlags & PlaybackState.ACTION_PAUSE) != 0) {
                                transportControls.pause();
                            } else if ((transportControlFlags & PlaybackState.ACTION_STOP) != 0) {
                                transportControls.stop();
                            }
                        } else if (playbackState.getState() == PlaybackState.STATE_BUFFERING) {
                            if ((transportControlFlags & PlaybackState.ACTION_STOP) != 0) {
                                transportControls.stop();
                            } else if ((transportControlFlags & PlaybackState.ACTION_PAUSE) != 0) {
                                transportControls.pause();
                            }
                        } else {
                            transportControls.play();
                        }
                        break;
                    case R.id.next:
                        transportControls.skipToNext();
                        break;
                    case R.id.overflow_off:
                        mHandler.removeCallbacks(mCloseOverflowRunnable);
                        setOverflowMenuVisibility(false);
                        break;
                    case R.id.overflow_on:
                        setOverflowMenuVisibility(true);
                        break;
                    default:
                        throw new IllegalStateException("Unknown button press: " + v);
                }
            }
        }
    };

    private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            switch (state) {
                case TelephonyManager.CALL_STATE_RINGING: // falls through
                case TelephonyManager.CALL_STATE_OFFHOOK:
                    mPlayPauseStopButton
                            .setPlayState(PlayPauseStopImageView.PLAYBACKSTATE_DISABLED);
                    mPlayPauseStopButton.setMode(PlayPauseStopImageView.MODE_PAUSE);
                    mPlayPauseStopButton.refreshDrawableState();
                    mInCall = true;
                    break;
                case TelephonyManager.CALL_STATE_IDLE:
                    if (mInCall) {
                        PlaybackState playbackState = mMediaPlaybackModel.getPlaybackState();
                        if (playbackState != null) {
                            mPlayPauseStopButton.setPlayState(playbackState.getState());
                            mPlayPauseStopButton.setMode((
                                    (playbackState.getActions() & PlaybackState.ACTION_STOP) != 0) ?
                                    PlayPauseStopImageView.MODE_STOP :
                                    PlayPauseStopImageView.MODE_PAUSE);
                            mPlayPauseStopButton.refreshDrawableState();
                        }
                        mInCall = false;
                    }
                    break;
                default:
                    Log.w(TAG, "TelephonyManager reports an unknown call state: " + state);
            }
        }
    };

    private final Runnable mSeekBarRunnable = new Runnable() {
        @Override
        public void run() {
            mSeekBar.setProgress((int) (System.currentTimeMillis() - mStartTime + mStartProgress));
            mHandler.postDelayed(this, SEEK_BAR_UPDATE_TIME_INTERVAL_MS);
        }
    };

    private final Runnable mCloseOverflowRunnable = new Runnable() {
        @Override
        public void run() {
            setOverflowMenuVisibility(false);
        }
    };

    private final Runnable mShowNoContentViewRunnable = new Runnable() {
        @Override
        public void run() {
            showInitialNoContentView(getString(R.string.nothing_to_play), false);
        }
    };

    private final Runnable mResetTitleRunnable = new Runnable() {
        @Override
        public void run() {
            mDelayedResetTitleInProgress = false;
            resetTitle();
        }
    };

    private final Runnable mSetTitleRunnable = new Runnable() {
        @Override
        public void run() {
            mTitleView.setText(mCurrentTrack.getTitle());
            mArtistView.setText(mCurrentTrack.getSubtitle());
        }
    };
}