path: root/src/com/android/tv/menu/PlayControlsRowView.java

/*
 * Copyright (C) 2015 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.tv.menu;

import android.content.Context;
import android.content.res.Resources;
import android.text.TextUtils;
import android.text.format.DateFormat;
import android.util.AttributeSet;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import com.android.tv.MainActivity;
import com.android.tv.R;
import com.android.tv.TimeShiftManager;
import com.android.tv.TimeShiftManager.TimeShiftActionId;
import com.android.tv.TvApplication;
import com.android.tv.common.SoftPreconditions;
import com.android.tv.common.feature.CommonFeatures;
import com.android.tv.data.Channel;
import com.android.tv.data.Program;
import com.android.tv.dialog.HalfSizedDialogFragment;
import com.android.tv.dvr.DvrDataManager;
import com.android.tv.dvr.DvrDataManager.OnDvrScheduleLoadFinishedListener;
import com.android.tv.dvr.DvrDataManager.ScheduledRecordingListener;
import com.android.tv.dvr.DvrManager;
import com.android.tv.dvr.data.ScheduledRecording;
import com.android.tv.dvr.ui.DvrStopRecordingFragment;
import com.android.tv.dvr.ui.DvrUiHelper;
import com.android.tv.menu.Menu.MenuShowReason;
import com.android.tv.ui.TunableTvView;

public class PlayControlsRowView extends MenuRowView {
    private static final int NORMAL_WIDTH_MAX_BUTTON_COUNT = 5;
    // Dimensions
    private final int mTimeIndicatorLeftMargin;
    private final int mTimeTextLeftMargin;
    private final int mTimelineWidth;
    // Views
    private TextView mBackgroundView;
    private View mTimeIndicator;
    private TextView mTimeText;
    private PlaybackProgressBar mProgress;
    private PlayControlsButton mJumpPreviousButton;
    private PlayControlsButton mRewindButton;
    private PlayControlsButton mPlayPauseButton;
    private PlayControlsButton mFastForwardButton;
    private PlayControlsButton mJumpNextButton;
    private PlayControlsButton mRecordButton;
    private TextView mProgramStartTimeText;
    private TextView mProgramEndTimeText;
    private TunableTvView mTvView;
    private TimeShiftManager mTimeShiftManager;
    private final DvrDataManager mDvrDataManager;
    private final DvrManager mDvrManager;
    private final MainActivity mMainActivity;

    private final java.text.DateFormat mTimeFormat;
    private long mProgramStartTimeMs;
    private long mProgramEndTimeMs;
    private boolean mUseCompactLayout;
    private final int mNormalButtonMargin;
    private final int mCompactButtonMargin;

    private final String mUnavailableMessage;

    private final ScheduledRecordingListener mScheduledRecordingListener
            = new ScheduledRecordingListener() {
        @Override
        public void onScheduledRecordingAdded(ScheduledRecording... scheduledRecordings) { }

        @Override
        public void onScheduledRecordingRemoved(ScheduledRecording... scheduledRecordings) { }

        @Override
        public void onScheduledRecordingStatusChanged(ScheduledRecording... scheduledRecordings) {
            Channel currentChannel = mMainActivity.getCurrentChannel();
            if (currentChannel != null && isShown()) {
                for (ScheduledRecording schedule : scheduledRecordings) {
                    if (schedule.getChannelId() == currentChannel.getId()) {
                        updateRecordButton();
                        break;
                    }
                }
            }
        }
    };

    public PlayControlsRowView(Context context) {
        this(context, null);
    }

    public PlayControlsRowView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public PlayControlsRowView(Context context, AttributeSet attrs, int defStyleAttr) {
        this(context, attrs, defStyleAttr, 0);
    }

    public PlayControlsRowView(Context context, AttributeSet attrs, int defStyleAttr,
            int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        Resources res = context.getResources();
        mTimeIndicatorLeftMargin =
                - res.getDimensionPixelSize(R.dimen.play_controls_time_indicator_width) / 2;
        mTimeTextLeftMargin =
                - res.getDimensionPixelOffset(R.dimen.play_controls_time_width) / 2;
        mTimelineWidth = res.getDimensionPixelSize(R.dimen.play_controls_width);
        mTimeFormat = DateFormat.getTimeFormat(context);
        mNormalButtonMargin = res.getDimensionPixelSize(R.dimen.play_controls_button_normal_margin);
        mCompactButtonMargin =
                res.getDimensionPixelSize(R.dimen.play_controls_button_compact_margin);
        if (CommonFeatures.DVR.isEnabled(context)) {
            mDvrDataManager = TvApplication.getSingletons(context).getDvrDataManager();
            mDvrManager = TvApplication.getSingletons(context).getDvrManager();
        } else {
            mDvrDataManager = null;
            mDvrManager = null;
        }
        mMainActivity = (MainActivity) context;
        mUnavailableMessage = res.getString(R.string.play_controls_unavailable);
    }

    @Override
    public void onAttachedToWindow() {
        super.onAttachedToWindow();
        if (mDvrDataManager != null) {
            mDvrDataManager.addScheduledRecordingListener(mScheduledRecordingListener);
            if (!mDvrDataManager.isDvrScheduleLoadFinished()) {
                mDvrDataManager.addDvrScheduleLoadFinishedListener(
                        new OnDvrScheduleLoadFinishedListener() {
                            @Override
                            public void onDvrScheduleLoadFinished() {
                                mDvrDataManager.removeDvrScheduleLoadFinishedListener(this);
                                if (isShown()) {
                                    updateRecordButton();
                                }
                            }
                        });
            }

        }
    }

    @Override
    protected int getContentsViewId() {
        return R.id.play_controls;
    }

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
        // Clip the ViewGroup(body) to the rounded rectangle of outline.
        findViewById(R.id.body).setClipToOutline(true);
        mBackgroundView = (TextView) findViewById(R.id.background);
        mTimeIndicator = findViewById(R.id.time_indicator);
        mTimeText = (TextView) findViewById(R.id.time_text);
        mProgress = (PlaybackProgressBar) findViewById(R.id.progress);
        mJumpPreviousButton = (PlayControlsButton) findViewById(R.id.jump_previous);
        mRewindButton = (PlayControlsButton) findViewById(R.id.rewind);
        mPlayPauseButton = (PlayControlsButton) findViewById(R.id.play_pause);
        mFastForwardButton = (PlayControlsButton) findViewById(R.id.fast_forward);
        mJumpNextButton = (PlayControlsButton) findViewById(R.id.jump_next);
        mRecordButton = (PlayControlsButton) findViewById(R.id.record);
        mProgramStartTimeText = (TextView) findViewById(R.id.program_start_time);
        mProgramEndTimeText = (TextView) findViewById(R.id.program_end_time);

        initializeButton(mJumpPreviousButton, R.drawable.lb_ic_skip_previous,
                R.string.play_controls_description_skip_previous, null, new Runnable() {
            @Override
            public void run() {
                if (mTimeShiftManager.isAvailable()) {
                    mTimeShiftManager.jumpToPrevious();
                    updateControls(true);
                }
            }
        });
        initializeButton(mRewindButton, R.drawable.lb_ic_fast_rewind,
                R.string.play_controls_description_fast_rewind, null, new Runnable() {
            @Override
            public void run() {
                if (mTimeShiftManager.isAvailable()) {
                    mTimeShiftManager.rewind();
                    updateButtons();
                }
            }
        });
        initializeButton(mPlayPauseButton, R.drawable.lb_ic_play,
                R.string.play_controls_description_play_pause, null, new Runnable() {
            @Override
            public void run() {
                if (mTimeShiftManager.isAvailable()) {
                    mTimeShiftManager.togglePlayPause();
                    updateButtons();
                }
            }
        });
        initializeButton(mFastForwardButton, R.drawable.lb_ic_fast_forward,
                R.string.play_controls_description_fast_forward, null, new Runnable() {
            @Override
            public void run() {
                if (mTimeShiftManager.isAvailable()) {
                    mTimeShiftManager.fastForward();
                    updateButtons();
                }
            }
        });
        initializeButton(mJumpNextButton, R.drawable.lb_ic_skip_next,
                R.string.play_controls_description_skip_next, null, new Runnable() {
            @Override
            public void run() {
                if (mTimeShiftManager.isAvailable()) {
                    mTimeShiftManager.jumpToNext();
                    updateControls(true);
                }
            }
        });
        int color = getResources().getColor(R.color.play_controls_recording_icon_color_on_focus,
                null);
        initializeButton(mRecordButton, R.drawable.ic_record_start, R.string
                .channels_item_record_start, color, new Runnable() {
            @Override
            public void run() {
                onRecordButtonClicked();
            }
        });
    }

    private boolean isCurrentChannelRecording() {
        Channel currentChannel = mMainActivity.getCurrentChannel();
        return currentChannel != null && mDvrManager != null
                && mDvrManager.getCurrentRecording(currentChannel.getId()) != null;
    }

    private void onRecordButtonClicked() {
        boolean isRecording = isCurrentChannelRecording();
        Channel currentChannel = mMainActivity.getCurrentChannel();
        TvApplication.getSingletons(getContext()).getTracker().sendMenuClicked(isRecording ?
                R.string.channels_item_record_start : R.string.channels_item_record_stop);
        if (!isRecording) {
            if (!(mDvrManager != null && mDvrManager.isChannelRecordable(currentChannel))) {
                Toast.makeText(mMainActivity, R.string.dvr_msg_cannot_record_channel,
                        Toast.LENGTH_SHORT).show();
            } else {
                Program program = TvApplication.getSingletons(mMainActivity).getProgramDataManager()
                        .getCurrentProgram(currentChannel.getId());
                DvrUiHelper.checkStorageStatusAndShowErrorMessage(mMainActivity,
                        currentChannel.getInputId(), new Runnable() {
                            @Override
                            public void run() {
                                DvrUiHelper.requestRecordingCurrentProgram(mMainActivity,
                                        currentChannel, program, true);
                            }
                        });
            }
        } else if (currentChannel != null) {
            DvrUiHelper.showStopRecordingDialog(mMainActivity, currentChannel.getId(),
                    DvrStopRecordingFragment.REASON_USER_STOP,
                    new HalfSizedDialogFragment.OnActionClickListener() {
                        @Override
                        public void onActionClick(long actionId) {
                            if (actionId == DvrStopRecordingFragment.ACTION_STOP) {
                                ScheduledRecording currentRecording =
                                        mDvrManager.getCurrentRecording(
                                                currentChannel.getId());
                                if (currentRecording != null) {
                                    mDvrManager.stopRecording(currentRecording);
                                }
                            }
                        }
                    });
        }
    }

    private void initializeButton(PlayControlsButton button, int imageResId,
            int descriptionId, Integer focusedIconColor, Runnable clickAction) {
        button.setImageResId(imageResId);
        button.setAction(clickAction);
        if (focusedIconColor != null) {
            button.setFocusedIconColor(focusedIconColor);
        }
        button.findViewById(R.id.button)
                .setContentDescription(getResources().getString(descriptionId));
    }

    @Override
    public void onBind(MenuRow row) {
        super.onBind(row);
        PlayControlsRow playControlsRow = (PlayControlsRow) row;
        mTvView = playControlsRow.getTvView();
        mTimeShiftManager = playControlsRow.getTimeShiftManager();
        mTimeShiftManager.setListener(new TimeShiftManager.Listener() {
            @Override
            public void onAvailabilityChanged() {
                updateMenuVisibility();
                PlayControlsRowView.this.updateAll(false);
            }

            @Override
            public void onPlayStatusChanged(int status) {
                updateMenuVisibility();
                if (mTimeShiftManager.isAvailable()) {
                    updateControls(false);
                }
            }

            @Override
            public void onRecordTimeRangeChanged() {
                if (mTimeShiftManager.isAvailable()) {
                    updateControls(false);
                }
            }

            @Override
            public void onCurrentPositionChanged() {
                if (mTimeShiftManager.isAvailable()) {
                    initializeTimeline();
                    updateControls(false);
                }
            }

            @Override
            public void onProgramInfoChanged() {
                if (mTimeShiftManager.isAvailable()) {
                    initializeTimeline();
                    updateControls(false);
                }
            }

            @Override
            public void onActionEnabledChanged(@TimeShiftActionId int actionId, boolean enabled) {
                // Move focus to the play/pause button when the PREVIOUS, NEXT, REWIND or
                // FAST_FORWARD button is clicked and the button becomes disabled.
                // No need to update the UI here because the UI will be updated by other callbacks.
                if (!enabled &&
                        ((actionId == TimeShiftManager.TIME_SHIFT_ACTION_ID_JUMP_TO_PREVIOUS
                                && mJumpPreviousButton.hasFocus())
                        || (actionId == TimeShiftManager.TIME_SHIFT_ACTION_ID_REWIND
                                && mRewindButton.hasFocus())
                        || (actionId == TimeShiftManager.TIME_SHIFT_ACTION_ID_FAST_FORWARD
                                && mFastForwardButton.hasFocus())
                        || (actionId == TimeShiftManager.TIME_SHIFT_ACTION_ID_JUMP_TO_NEXT
                                && mJumpNextButton.hasFocus()))) {
                    mPlayPauseButton.requestFocus();
                }
            }
        });
        // force update to initialize everything
        updateAll(true);
    }

    private void initializeTimeline() {
        Program program = mTimeShiftManager.getProgramAt(
                mTimeShiftManager.getCurrentPositionMs());
        mProgramStartTimeMs = program.getStartTimeUtcMillis();
        mProgramEndTimeMs = program.getEndTimeUtcMillis();
        mProgress.setMax(mProgramEndTimeMs - mProgramStartTimeMs);
        updateRecTimeText();
        SoftPreconditions.checkArgument(mProgramStartTimeMs <= mProgramEndTimeMs);
    }

    private void updateMenuVisibility() {
        boolean keepMenuVisible =
                mTimeShiftManager.isAvailable() && !mTimeShiftManager.isNormalPlaying();
        getMenu().setKeepVisible(keepMenuVisible);
    }

    public void onPreselected() {
        updateControls(true);
    }

    @Override
    public void onSelected(boolean showTitle) {
        super.onSelected(showTitle);
        postHideRippleAnimation();
    }

    @Override
    public void initialize(@MenuShowReason int reason) {
        super.initialize(reason);
        switch (reason) {
            case Menu.REASON_PLAY_CONTROLS_JUMP_TO_PREVIOUS:
                if (mTimeShiftManager.isActionEnabled(
                        TimeShiftManager.TIME_SHIFT_ACTION_ID_JUMP_TO_PREVIOUS)) {
                    setInitialFocusView(mJumpPreviousButton);
                } else {
                    setInitialFocusView(mPlayPauseButton);
                }
                break;
            case Menu.REASON_PLAY_CONTROLS_REWIND:
                if (mTimeShiftManager.isActionEnabled(
                        TimeShiftManager.TIME_SHIFT_ACTION_ID_REWIND)) {
                    setInitialFocusView(mRewindButton);
                } else {
                    setInitialFocusView(mPlayPauseButton);
                }
                break;
            case Menu.REASON_PLAY_CONTROLS_FAST_FORWARD:
                if (mTimeShiftManager.isActionEnabled(
                        TimeShiftManager.TIME_SHIFT_ACTION_ID_FAST_FORWARD)) {
                    setInitialFocusView(mFastForwardButton);
                } else {
                    setInitialFocusView(mPlayPauseButton);
                }
                break;
            case Menu.REASON_PLAY_CONTROLS_JUMP_TO_NEXT:
                if (mTimeShiftManager.isActionEnabled(
                        TimeShiftManager.TIME_SHIFT_ACTION_ID_JUMP_TO_NEXT)) {
                    setInitialFocusView(mJumpNextButton);
                } else {
                    setInitialFocusView(mPlayPauseButton);
                }
                break;
            case Menu.REASON_PLAY_CONTROLS_PLAY_PAUSE:
            case Menu.REASON_PLAY_CONTROLS_PLAY:
            case Menu.REASON_PLAY_CONTROLS_PAUSE:
            default:
                setInitialFocusView(mPlayPauseButton);
                break;
        }
        postHideRippleAnimation();
    }

    private void postHideRippleAnimation() {
        // Focus may be changed in another message if requestFocus is called in this message.
        // After the focus is actually changed, hideRippleAnimation should run
        // to reflect the result of the focus change. To be sure, hideRippleAnimation is posted.
        post(new Runnable() {
            @Override
            public void run() {
                mJumpPreviousButton.hideRippleAnimation();
                mRewindButton.hideRippleAnimation();
                mPlayPauseButton.hideRippleAnimation();
                mFastForwardButton.hideRippleAnimation();
                mJumpNextButton.hideRippleAnimation();
            }
        });
    }

    @Override
    protected void onChildFocusChange(View v, boolean hasFocus) {
        super.onChildFocusChange(v, hasFocus);
        if ((v.getParent().equals(mRewindButton) || v.getParent().equals(mFastForwardButton))
                && !hasFocus) {
            if (mTimeShiftManager.getPlayStatus() == TimeShiftManager.PLAY_STATUS_PLAYING) {
                mTimeShiftManager.play();
                updateButtons();
            }
        }
    }

    /**
     * Updates the view contents. It is called from the PlayControlsRow.
     */
    public void update() {
        updateAll(false);
    }

    private void updateAll(boolean forceUpdate) {
        if (mTimeShiftManager.isAvailable() && !mTvView.isScreenBlocked()) {
            setEnabled(true);
            initializeTimeline();
            mBackgroundView.setEnabled(true);
            setTextIfNeeded(mBackgroundView, null);
        } else {
            setEnabled(false);
            mBackgroundView.setEnabled(false);
            setTextIfNeeded(mBackgroundView, mUnavailableMessage);
        }
        // force the controls be updated no matter it's visible or not.
        updateControls(forceUpdate);
    }

    private void updateControls(boolean forceUpdate) {
        if (forceUpdate || getContentsView().isShown()) {
            updateTime();
            updateProgress();
            updateButtons();
            updateRecordButton();
            updateButtonMargin();
        }
    }

    private void updateTime() {
        if (isEnabled()) {
            mTimeText.setVisibility(View.VISIBLE);
            mTimeIndicator.setVisibility(View.VISIBLE);
        } else {
            mTimeText.setVisibility(View.INVISIBLE);
            mTimeIndicator.setVisibility(View.GONE);
            return;
        }
        long currentPositionMs = mTimeShiftManager.getCurrentPositionMs();
        int currentTimePositionPixel =
                convertDurationToPixel(currentPositionMs - mProgramStartTimeMs);
        mTimeText.setTranslationX(currentTimePositionPixel + mTimeTextLeftMargin);
        setTextIfNeeded(mTimeText, getTimeString(currentPositionMs));
        mTimeIndicator.setTranslationX(currentTimePositionPixel + mTimeIndicatorLeftMargin);
    }

    private void updateProgress() {
        if (isEnabled()) {
            long progressStartTimeMs = Math.min(mProgramEndTimeMs,
                    Math.max(mProgramStartTimeMs, mTimeShiftManager.getRecordStartTimeMs()));
            long currentPlayingTimeMs = Math.min(mProgramEndTimeMs,
                    Math.max(mProgramStartTimeMs, mTimeShiftManager.getCurrentPositionMs()));
            long progressEndTimeMs = Math.min(mProgramEndTimeMs,
                    Math.max(mProgramStartTimeMs, mTimeShiftManager.getRecordEndTimeMs()));
            mProgress.setProgressRange(progressStartTimeMs - mProgramStartTimeMs,
                    progressEndTimeMs - mProgramStartTimeMs);
            mProgress.setProgress(currentPlayingTimeMs - mProgramStartTimeMs);
        } else {
            mProgress.setProgressRange(0, 0);
        }
    }

    private void updateRecTimeText() {
        if (isEnabled()) {
            mProgramStartTimeText.setVisibility(View.VISIBLE);
            setTextIfNeeded(mProgramStartTimeText, getTimeString(mProgramStartTimeMs));
            mProgramEndTimeText.setVisibility(View.VISIBLE);
            setTextIfNeeded(mProgramEndTimeText, getTimeString(mProgramEndTimeMs));
        } else {
            mProgramStartTimeText.setVisibility(View.GONE);
            mProgramEndTimeText.setVisibility(View.GONE);
        }
    }

    private void updateButtons() {
        if (isEnabled()) {
            mPlayPauseButton.setVisibility(View.VISIBLE);
            mJumpPreviousButton.setVisibility(View.VISIBLE);
            mJumpNextButton.setVisibility(View.VISIBLE);
            mRewindButton.setVisibility(View.VISIBLE);
            mFastForwardButton.setVisibility(View.VISIBLE);
        } else {
            mPlayPauseButton.setVisibility(View.GONE);
            mJumpPreviousButton.setVisibility(View.GONE);
            mJumpNextButton.setVisibility(View.GONE);
            mRewindButton.setVisibility(View.GONE);
            mFastForwardButton.setVisibility(View.GONE);
            return;
        }

        if (mTimeShiftManager.getPlayStatus() == TimeShiftManager.PLAY_STATUS_PAUSED) {
            mPlayPauseButton.setImageResId(R.drawable.lb_ic_play);
            mPlayPauseButton.setEnabled(mTimeShiftManager.isActionEnabled(
                    TimeShiftManager.TIME_SHIFT_ACTION_ID_PLAY));
        } else {
            mPlayPauseButton.setImageResId(R.drawable.lb_ic_pause);
            mPlayPauseButton.setEnabled(mTimeShiftManager.isActionEnabled(
                    TimeShiftManager.TIME_SHIFT_ACTION_ID_PAUSE));
        }
        mJumpPreviousButton.setEnabled(mTimeShiftManager.isActionEnabled(
                TimeShiftManager.TIME_SHIFT_ACTION_ID_JUMP_TO_PREVIOUS));
        mRewindButton.setEnabled(mTimeShiftManager.isActionEnabled(
                TimeShiftManager.TIME_SHIFT_ACTION_ID_REWIND));
        mFastForwardButton.setEnabled(mTimeShiftManager.isActionEnabled(
                TimeShiftManager.TIME_SHIFT_ACTION_ID_FAST_FORWARD));
        mJumpNextButton.setEnabled(mTimeShiftManager.isActionEnabled(
                TimeShiftManager.TIME_SHIFT_ACTION_ID_JUMP_TO_NEXT));
        mJumpPreviousButton.setVisibility(VISIBLE);
        mJumpNextButton.setVisibility(VISIBLE);
        updateButtonMargin();

        PlayControlsButton button;
        if (mTimeShiftManager.getPlayDirection() == TimeShiftManager.PLAY_DIRECTION_FORWARD) {
            mRewindButton.setLabel(null);
            button = mFastForwardButton;
        } else {
            mFastForwardButton.setLabel(null);
            button = mRewindButton;
        }
        if (mTimeShiftManager.getDisplayedPlaySpeed() == TimeShiftManager.PLAY_SPEED_1X) {
            button.setLabel(null);
        } else {
            button.setLabel(getResources().getString(R.string.play_controls_speed,
                    mTimeShiftManager.getDisplayedPlaySpeed()));
        }
    }

    private void updateRecordButton() {
        if (isEnabled()) {
            mRecordButton.setVisibility(VISIBLE);
        } else {
            mRecordButton.setVisibility(GONE);
            return;
        }
        if (!(mDvrManager != null
                && mDvrManager.isChannelRecordable(mMainActivity.getCurrentChannel()))) {
            mRecordButton.setVisibility(View.GONE);
            updateButtonMargin();
            return;
        }
        mRecordButton.setVisibility(View.VISIBLE);
        updateButtonMargin();
        if (isCurrentChannelRecording()) {
            mRecordButton.setImageResId(R.drawable.ic_record_stop);
        } else {
            mRecordButton.setImageResId(R.drawable.ic_record_start);
        }
    }

    private void updateButtonMargin() {
        int numOfVisibleButtons = (mJumpPreviousButton.getVisibility() == View.VISIBLE ? 1 : 0)
                + (mRewindButton.getVisibility() == View.VISIBLE ? 1 : 0)
                + (mPlayPauseButton.getVisibility() == View.VISIBLE ? 1 : 0)
                + (mFastForwardButton.getVisibility() == View.VISIBLE ? 1 : 0)
                + (mJumpNextButton.getVisibility() == View.VISIBLE ? 1 : 0)
                + (mRecordButton.getVisibility() == View.VISIBLE ? 1 : 0);
        boolean useCompactLayout = numOfVisibleButtons > NORMAL_WIDTH_MAX_BUTTON_COUNT;
        if (mUseCompactLayout == useCompactLayout) {
            return;
        }
        mUseCompactLayout = useCompactLayout;
        int margin = mUseCompactLayout ? mCompactButtonMargin : mNormalButtonMargin;
        updateButtonMargin(mJumpPreviousButton, margin);
        updateButtonMargin(mRewindButton, margin);
        updateButtonMargin(mPlayPauseButton, margin);
        updateButtonMargin(mFastForwardButton, margin);
        updateButtonMargin(mJumpNextButton, margin);
        updateButtonMargin(mRecordButton, margin);
    }

    private void updateButtonMargin(PlayControlsButton button, int margin) {
        MarginLayoutParams params = (MarginLayoutParams) button.getLayoutParams();
        params.setMargins(margin, 0, margin, 0);
        button.setLayoutParams(params);
    }

    private String getTimeString(long timeMs) {
        return mTimeFormat.format(timeMs);
    }

    private int convertDurationToPixel(long duration) {
        if (mProgramEndTimeMs <= mProgramStartTimeMs) {
            return 0;
        }
        return (int) (duration * mTimelineWidth / (mProgramEndTimeMs - mProgramStartTimeMs));
    }

    @Override
    public void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        if (mDvrDataManager != null) {
            mDvrDataManager.removeScheduledRecordingListener(mScheduledRecordingListener);
        }
    }

    private void setTextIfNeeded(TextView textView, String text) {
        if (!TextUtils.equals(textView.getText(), text)) {
            textView.setText(text);
        }
    }
}