| /* |
| * 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.tv.dvr.ui.list; |
| |
| import android.animation.Animator; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.ValueAnimator; |
| import android.annotation.TargetApi; |
| import android.app.Activity; |
| import android.content.Context; |
| import android.content.res.Resources; |
| import android.os.Build; |
| import android.support.annotation.IntDef; |
| import android.support.v17.leanback.widget.RowPresenter; |
| import android.text.TextUtils; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.View.OnFocusChangeListener; |
| import android.view.ViewGroup; |
| import android.view.animation.DecelerateInterpolator; |
| import android.widget.ImageView; |
| import android.widget.LinearLayout; |
| import android.widget.RelativeLayout; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import com.android.tv.R; |
| import com.android.tv.TvApplication; |
| import com.android.tv.common.SoftPreconditions; |
| import com.android.tv.data.Channel; |
| import com.android.tv.dialog.HalfSizedDialogFragment; |
| import com.android.tv.dvr.DvrManager; |
| import com.android.tv.dvr.DvrScheduleManager; |
| 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.util.ToastUtils; |
| import com.android.tv.util.Utils; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.List; |
| |
| /** |
| * A RowPresenter for {@link ScheduleRow}. |
| */ |
| @TargetApi(Build.VERSION_CODES.N) |
| class ScheduleRowPresenter extends RowPresenter { |
| private static final String TAG = "ScheduleRowPresenter"; |
| |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef({ACTION_START_RECORDING, ACTION_STOP_RECORDING, ACTION_CREATE_SCHEDULE, |
| ACTION_REMOVE_SCHEDULE}) |
| public @interface ScheduleRowAction {} |
| /** An action to start recording. */ |
| public static final int ACTION_START_RECORDING = 1; |
| /** An action to stop recording. */ |
| public static final int ACTION_STOP_RECORDING = 2; |
| /** An action to create schedule for the row. */ |
| public static final int ACTION_CREATE_SCHEDULE = 3; |
| /** An action to remove the schedule. */ |
| public static final int ACTION_REMOVE_SCHEDULE = 4; |
| |
| private final Context mContext; |
| private final DvrManager mDvrManager; |
| private final DvrScheduleManager mDvrScheduleManager; |
| |
| private final String mTunerConflictWillNotBeRecordedInfo; |
| private final String mTunerConflictWillBePartiallyRecordedInfo; |
| private final int mAnimationDuration; |
| |
| private int mLastFocusedViewId; |
| |
| /** |
| * A ViewHolder for {@link ScheduleRow} |
| */ |
| public static class ScheduleRowViewHolder extends RowPresenter.ViewHolder { |
| private ScheduleRowPresenter mPresenter; |
| @ScheduleRowAction private int[] mActions; |
| private boolean mLtr; |
| private LinearLayout mInfoContainer; |
| // The first action is on the right of the second action. |
| private RelativeLayout mSecondActionContainer; |
| private RelativeLayout mFirstActionContainer; |
| private View mSelectorView; |
| private TextView mTimeView; |
| private TextView mProgramTitleView; |
| private TextView mInfoSeparatorView; |
| private TextView mChannelNameView; |
| private TextView mConflictInfoView; |
| private ImageView mSecondActionView; |
| private ImageView mFirstActionView; |
| |
| private Runnable mPendingAnimationRunnable; |
| |
| private final int mSelectorTranslationDelta; |
| private final int mSelectorWidthDelta; |
| private final int mInfoContainerTargetWidthWithNoAction; |
| private final int mInfoContainerTargetWidthWithOneAction; |
| private final int mInfoContainerTargetWidthWithTwoAction; |
| private final int mRoundRectRadius; |
| |
| private final OnFocusChangeListener mOnFocusChangeListener = |
| new View.OnFocusChangeListener() { |
| @Override |
| public void onFocusChange(View view, boolean focused) { |
| view.post(new Runnable() { |
| @Override |
| public void run() { |
| if (view.isFocused()) { |
| mPresenter.mLastFocusedViewId = view.getId(); |
| } |
| updateSelector(); |
| } |
| }); |
| } |
| }; |
| |
| public ScheduleRowViewHolder(View view, ScheduleRowPresenter presenter) { |
| super(view); |
| mPresenter = presenter; |
| mLtr = view.getContext().getResources().getConfiguration().getLayoutDirection() |
| == View.LAYOUT_DIRECTION_LTR; |
| mInfoContainer = (LinearLayout) view.findViewById(R.id.info_container); |
| mSecondActionContainer = (RelativeLayout) view.findViewById( |
| R.id.action_second_container); |
| mSecondActionView = (ImageView) view.findViewById(R.id.action_second); |
| mFirstActionContainer = (RelativeLayout) view.findViewById( |
| R.id.action_first_container); |
| mFirstActionView = (ImageView) view.findViewById(R.id.action_first); |
| mSelectorView = view.findViewById(R.id.selector); |
| mTimeView = (TextView) view.findViewById(R.id.time); |
| mProgramTitleView = (TextView) view.findViewById(R.id.program_title); |
| mInfoSeparatorView = (TextView) view.findViewById(R.id.info_separator); |
| mChannelNameView = (TextView) view.findViewById(R.id.channel_name); |
| mConflictInfoView = (TextView) view.findViewById(R.id.conflict_info); |
| Resources res = view.getResources(); |
| mSelectorTranslationDelta = |
| res.getDimensionPixelSize(R.dimen.dvr_schedules_item_section_margin) |
| - res.getDimensionPixelSize(R.dimen.dvr_schedules_item_focus_translation_delta); |
| mSelectorWidthDelta = res.getDimensionPixelSize( |
| R.dimen.dvr_schedules_item_focus_width_delta); |
| mRoundRectRadius = res.getDimensionPixelSize(R.dimen.dvr_schedules_selector_radius); |
| int fullWidth = res.getDimensionPixelSize( |
| R.dimen.dvr_schedules_item_width) |
| - 2 * res.getDimensionPixelSize(R.dimen.dvr_schedules_layout_padding); |
| mInfoContainerTargetWidthWithNoAction = fullWidth + 2 * mRoundRectRadius; |
| mInfoContainerTargetWidthWithOneAction = fullWidth |
| - res.getDimensionPixelSize(R.dimen.dvr_schedules_item_section_margin) |
| - res.getDimensionPixelSize(R.dimen.dvr_schedules_item_delete_width) |
| + mRoundRectRadius + mSelectorWidthDelta; |
| mInfoContainerTargetWidthWithTwoAction = mInfoContainerTargetWidthWithOneAction |
| - res.getDimensionPixelSize(R.dimen.dvr_schedules_item_section_margin) |
| - res.getDimensionPixelSize(R.dimen.dvr_schedules_item_icon_size); |
| |
| mInfoContainer.setOnFocusChangeListener(mOnFocusChangeListener); |
| mFirstActionContainer.setOnFocusChangeListener(mOnFocusChangeListener); |
| mSecondActionContainer.setOnFocusChangeListener(mOnFocusChangeListener); |
| } |
| |
| /** |
| * Returns time view. |
| */ |
| public TextView getTimeView() { |
| return mTimeView; |
| } |
| |
| /** |
| * Returns title view. |
| */ |
| public TextView getProgramTitleView() { |
| return mProgramTitleView; |
| } |
| |
| private void updateSelector() { |
| int animationDuration = mSelectorView.getResources().getInteger( |
| android.R.integer.config_shortAnimTime); |
| DecelerateInterpolator interpolator = new DecelerateInterpolator(); |
| |
| if (mInfoContainer.isFocused() || mSecondActionContainer.isFocused() |
| || mFirstActionContainer.isFocused()) { |
| final ViewGroup.LayoutParams lp = mSelectorView.getLayoutParams(); |
| final int targetWidth; |
| if (mInfoContainer.isFocused()) { |
| // Use actions to check the visibility of the actions instead of calling |
| // View.getVisibility() because the view could be on the hiding animation. |
| if (mActions == null || mActions.length == 0) { |
| targetWidth = mInfoContainerTargetWidthWithNoAction; |
| } else if (mActions.length == 1) { |
| targetWidth = mInfoContainerTargetWidthWithOneAction; |
| } else { |
| targetWidth = mInfoContainerTargetWidthWithTwoAction; |
| } |
| } else if (mSecondActionContainer.isFocused()) { |
| targetWidth = Math.max(mSecondActionContainer.getWidth(), 2 * mRoundRectRadius); |
| } else { |
| targetWidth = mFirstActionContainer.getWidth() + mRoundRectRadius |
| + mSelectorTranslationDelta; |
| } |
| |
| float targetTranslationX; |
| if (mInfoContainer.isFocused()) { |
| targetTranslationX = mLtr ? mInfoContainer.getLeft() - mRoundRectRadius |
| - mSelectorView.getLeft() : |
| mInfoContainer.getRight() + mRoundRectRadius - mSelectorView.getRight(); |
| } else if (mSecondActionContainer.isFocused()) { |
| if (mSecondActionContainer.getWidth() > 2 * mRoundRectRadius) { |
| targetTranslationX = mLtr ? mSecondActionContainer.getLeft() - |
| mSelectorView.getLeft() |
| : mSecondActionContainer.getRight() - mSelectorView.getRight(); |
| } else { |
| targetTranslationX = mLtr ? mSecondActionContainer.getLeft() - |
| (mRoundRectRadius - mSecondActionContainer.getWidth() / 2) - |
| mSelectorView.getLeft() |
| : mSecondActionContainer.getRight() + |
| (mRoundRectRadius - mSecondActionContainer.getWidth() / 2) - |
| mSelectorView.getRight(); |
| } |
| } else { |
| targetTranslationX = mLtr ? mFirstActionContainer.getLeft() |
| - mSelectorTranslationDelta - mSelectorView.getLeft() |
| : mFirstActionContainer.getRight() + mSelectorTranslationDelta |
| - mSelectorView.getRight(); |
| } |
| |
| if (mSelectorView.getAlpha() == 0) { |
| mSelectorView.setTranslationX(targetTranslationX); |
| lp.width = targetWidth; |
| mSelectorView.requestLayout(); |
| } |
| |
| // animate the selector in and to the proper width and translation X. |
| final float deltaWidth = lp.width - targetWidth; |
| mSelectorView.animate().cancel(); |
| mSelectorView.animate().translationX(targetTranslationX).alpha(1f) |
| .setUpdateListener(new ValueAnimator.AnimatorUpdateListener() { |
| @Override |
| public void onAnimationUpdate(ValueAnimator animation) { |
| // Set width to the proper width for this animation step. |
| lp.width = targetWidth + Math.round( |
| deltaWidth * (1f - animation.getAnimatedFraction())); |
| mSelectorView.requestLayout(); |
| } |
| }).setDuration(animationDuration).setInterpolator(interpolator).start(); |
| if (mPendingAnimationRunnable != null) { |
| mPendingAnimationRunnable.run(); |
| mPendingAnimationRunnable = null; |
| } |
| } else { |
| mSelectorView.animate().cancel(); |
| mSelectorView.animate().alpha(0f).setDuration(animationDuration) |
| .setInterpolator(interpolator).setUpdateListener(null).start(); |
| } |
| } |
| |
| /** |
| * Grey out the information body. |
| */ |
| public void greyOutInfo() { |
| mTimeView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info_grey, null)); |
| mProgramTitleView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info_grey, null)); |
| mInfoSeparatorView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info_grey, null)); |
| mChannelNameView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info_grey, null)); |
| mConflictInfoView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info_grey, null)); |
| } |
| |
| /** |
| * Reverse grey out operation. |
| */ |
| public void whiteBackInfo() { |
| mTimeView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info, null)); |
| mProgramTitleView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_main, null)); |
| mInfoSeparatorView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info, null)); |
| mChannelNameView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info, null)); |
| mConflictInfoView.setTextColor(mInfoContainer.getResources().getColor(R.color |
| .dvr_schedules_item_info, null)); |
| } |
| } |
| |
| public ScheduleRowPresenter(Context context) { |
| setHeaderPresenter(null); |
| setSelectEffectEnabled(false); |
| mContext = context; |
| mDvrManager = TvApplication.getSingletons(context).getDvrManager(); |
| mDvrScheduleManager = TvApplication.getSingletons(context).getDvrScheduleManager(); |
| mTunerConflictWillNotBeRecordedInfo = mContext.getString( |
| R.string.dvr_schedules_tuner_conflict_will_not_be_recorded_info); |
| mTunerConflictWillBePartiallyRecordedInfo = mContext.getString( |
| R.string.dvr_schedules_tuner_conflict_will_be_partially_recorded); |
| mAnimationDuration = mContext.getResources().getInteger( |
| android.R.integer.config_shortAnimTime); |
| } |
| |
| @Override |
| public ViewHolder createRowViewHolder(ViewGroup parent) { |
| return onGetScheduleRowViewHolder(LayoutInflater.from(mContext) |
| .inflate(R.layout.dvr_schedules_item, parent, false)); |
| } |
| |
| /** |
| * Returns context. |
| */ |
| protected Context getContext() { |
| return mContext; |
| } |
| |
| /** |
| * Returns DVR manager. |
| */ |
| protected DvrManager getDvrManager() { |
| return mDvrManager; |
| } |
| |
| @Override |
| protected void onBindRowViewHolder(RowPresenter.ViewHolder vh, Object item) { |
| super.onBindRowViewHolder(vh, item); |
| ScheduleRowViewHolder viewHolder = (ScheduleRowViewHolder) vh; |
| ScheduleRow row = (ScheduleRow) item; |
| @ScheduleRowAction int[] actions = getAvailableActions(row); |
| viewHolder.mActions = actions; |
| viewHolder.mInfoContainer.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| if (isInfoClickable(row)) { |
| onInfoClicked(row); |
| } |
| } |
| }); |
| |
| viewHolder.mFirstActionContainer.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| onActionClicked(actions[0], row); |
| } |
| }); |
| |
| viewHolder.mSecondActionContainer.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| onActionClicked(actions[1], row); |
| } |
| }); |
| |
| viewHolder.mTimeView.setText(onGetRecordingTimeText(row)); |
| String programInfoText = onGetProgramInfoText(row); |
| if (TextUtils.isEmpty(programInfoText)) { |
| int durationMins = Math.max(1, Utils.getRoundOffMinsFromMs(row.getDuration())); |
| programInfoText = mContext.getResources().getQuantityString( |
| R.plurals.dvr_schedules_recording_duration, durationMins, durationMins); |
| } |
| String channelName = getChannelNameText(row); |
| viewHolder.mProgramTitleView.setText(programInfoText); |
| viewHolder.mInfoSeparatorView.setVisibility((!TextUtils.isEmpty(programInfoText) |
| && !TextUtils.isEmpty(channelName)) ? View.VISIBLE : View.GONE); |
| viewHolder.mChannelNameView.setText(channelName); |
| if (actions != null) { |
| switch (actions.length) { |
| case 2: |
| viewHolder.mSecondActionView.setImageResource(getImageForAction(actions[1])); |
| // pass through |
| case 1: |
| viewHolder.mFirstActionView.setImageResource(getImageForAction(actions[0])); |
| break; |
| } |
| } |
| if (mDvrManager.isConflicting(row.getSchedule())) { |
| String conflictInfo; |
| if (mDvrScheduleManager.isPartiallyConflicting(row.getSchedule())) { |
| conflictInfo = mTunerConflictWillBePartiallyRecordedInfo; |
| } else { |
| conflictInfo = mTunerConflictWillNotBeRecordedInfo; |
| } |
| viewHolder.mConflictInfoView.setText(conflictInfo); |
| viewHolder.mConflictInfoView.setVisibility(View.VISIBLE); |
| } else { |
| viewHolder.mConflictInfoView.setVisibility(View.GONE); |
| } |
| if (shouldBeGrayedOut(row)) { |
| viewHolder.greyOutInfo(); |
| } else { |
| viewHolder.whiteBackInfo(); |
| } |
| viewHolder.mInfoContainer.setFocusable(isInfoClickable(row)); |
| updateActionContainer(viewHolder, viewHolder.isSelected()); |
| } |
| |
| private int getImageForAction(@ScheduleRowAction int action) { |
| switch (action) { |
| case ACTION_START_RECORDING: |
| return R.drawable.ic_record_start; |
| case ACTION_STOP_RECORDING: |
| return R.drawable.ic_record_stop; |
| case ACTION_CREATE_SCHEDULE: |
| return R.drawable.ic_scheduled_recording; |
| case ACTION_REMOVE_SCHEDULE: |
| return R.drawable.ic_dvr_cancel; |
| default: |
| return 0; |
| } |
| } |
| |
| /** |
| * Returns view holder for schedule row. |
| */ |
| protected ScheduleRowViewHolder onGetScheduleRowViewHolder(View view) { |
| return new ScheduleRowViewHolder(view, this); |
| } |
| |
| /** |
| * Returns time text for time view from scheduled recording. |
| */ |
| protected String onGetRecordingTimeText(ScheduleRow row) { |
| return Utils.getDurationString(mContext, row.getStartTimeMs(), row.getEndTimeMs(), true, |
| false, true, 0); |
| } |
| |
| /** |
| * Returns program info text for program title view. |
| */ |
| protected String onGetProgramInfoText(ScheduleRow row) { |
| return row.getProgramTitleWithEpisodeNumber(mContext); |
| } |
| |
| private String getChannelNameText(ScheduleRow row) { |
| Channel channel = TvApplication.getSingletons(mContext).getChannelDataManager() |
| .getChannel(row.getChannelId()); |
| return channel == null ? null : |
| TextUtils.isEmpty(channel.getDisplayName()) ? channel.getDisplayNumber() : |
| channel.getDisplayName().trim() + " " + channel.getDisplayNumber(); |
| } |
| |
| /** |
| * Called when user click Info in {@link ScheduleRow}. |
| */ |
| protected void onInfoClicked(ScheduleRow row) { |
| DvrUiHelper.startDetailsActivity((Activity) mContext, row.getSchedule(), null, true); |
| } |
| |
| private boolean isInfoClickable(ScheduleRow row) { |
| return row.getSchedule() != null |
| && (row.getSchedule().isNotStarted() || row.getSchedule().isInProgress()); |
| } |
| |
| /** |
| * Called when the button in a row is clicked. |
| */ |
| protected void onActionClicked(@ScheduleRowAction final int action, ScheduleRow row) { |
| switch (action) { |
| case ACTION_START_RECORDING: |
| onStartRecording(row); |
| break; |
| case ACTION_STOP_RECORDING: |
| onStopRecording(row); |
| break; |
| case ACTION_CREATE_SCHEDULE: |
| onCreateSchedule(row); |
| break; |
| case ACTION_REMOVE_SCHEDULE: |
| onRemoveSchedule(row); |
| break; |
| } |
| } |
| |
| /** |
| * Action handler for {@link #ACTION_START_RECORDING}. |
| */ |
| protected void onStartRecording(ScheduleRow row) { |
| ScheduledRecording schedule = row.getSchedule(); |
| if (schedule == null) { |
| // This row has been deleted. |
| return; |
| } |
| // Checks if there are current recordings that will be stopped by schedule this program. |
| // If so, shows confirmation dialog to users. |
| List<ScheduledRecording> conflictSchedules = mDvrScheduleManager.getConflictingSchedules( |
| schedule.getChannelId(), System.currentTimeMillis(), schedule.getEndTimeMs()); |
| for (int i = conflictSchedules.size() - 1; i >= 0; i--) { |
| ScheduledRecording conflictSchedule = conflictSchedules.get(i); |
| if (conflictSchedule.isInProgress()) { |
| DvrUiHelper.showStopRecordingDialog((Activity) mContext, |
| conflictSchedule.getChannelId(), |
| DvrStopRecordingFragment.REASON_ON_CONFLICT, |
| new HalfSizedDialogFragment.OnActionClickListener() { |
| @Override |
| public void onActionClick(long actionId) { |
| if (actionId == DvrStopRecordingFragment.ACTION_STOP) { |
| onStartRecordingInternal(row); |
| } |
| } |
| }); |
| return; |
| } |
| } |
| onStartRecordingInternal(row); |
| } |
| |
| private void onStartRecordingInternal(ScheduleRow row) { |
| if (row.isOnAir() && !row.isRecordingInProgress() && !row.isStartRecordingRequested()) { |
| row.setStartRecordingRequested(true); |
| if (row.isRecordingNotStarted()) { |
| mDvrManager.setHighestPriority(row.getSchedule()); |
| } else if (row.isRecordingFinished()) { |
| mDvrManager.addSchedule(ScheduledRecording.buildFrom(row.getSchedule()) |
| .setId(ScheduledRecording.ID_NOT_SET) |
| .setState(ScheduledRecording.STATE_RECORDING_NOT_STARTED) |
| .setPriority(mDvrManager.suggestHighestPriority(row.getSchedule())) |
| .build()); |
| } else { |
| SoftPreconditions.checkState(false, TAG, "Invalid row state to start recording: " |
| + row); |
| return; |
| } |
| String msg = mContext.getString(R.string.dvr_msg_current_program_scheduled, |
| row.getSchedule().getProgramTitle(), |
| Utils.toTimeString(row.getEndTimeMs(), false)); |
| ToastUtils.show(mContext, msg, Toast.LENGTH_SHORT); |
| } |
| } |
| |
| /** |
| * Action handler for {@link #ACTION_STOP_RECORDING}. |
| */ |
| protected void onStopRecording(ScheduleRow row) { |
| if (row.getSchedule() == null) { |
| // This row has been deleted. |
| return; |
| } |
| if (row.isRecordingInProgress() && !row.isStopRecordingRequested()) { |
| row.setStopRecordingRequested(true); |
| mDvrManager.stopRecording(row.getSchedule()); |
| CharSequence deletedInfo = onGetProgramInfoText(row); |
| if (TextUtils.isEmpty(deletedInfo)) { |
| deletedInfo = getChannelNameText(row); |
| } |
| ToastUtils.show(mContext, mContext.getResources() |
| .getString(R.string.dvr_schedules_deletion_info, deletedInfo), |
| Toast.LENGTH_SHORT); |
| } |
| } |
| |
| /** |
| * Action handler for {@link #ACTION_CREATE_SCHEDULE}. |
| */ |
| protected void onCreateSchedule(ScheduleRow row) { |
| if (row.getSchedule() == null) { |
| // This row has been deleted. |
| return; |
| } |
| if (!row.isOnAir()) { |
| if (row.isScheduleCanceled()) { |
| mDvrManager.updateScheduledRecording(ScheduledRecording.buildFrom(row.getSchedule()) |
| .setState(ScheduledRecording.STATE_RECORDING_NOT_STARTED) |
| .setPriority(mDvrManager.suggestHighestPriority(row.getSchedule())) |
| .build()); |
| String msg = mContext.getString(R.string.dvr_msg_program_scheduled, |
| row.getSchedule().getProgramTitle()); |
| ToastUtils.show(mContext, msg, Toast.LENGTH_SHORT); |
| } else if (mDvrManager.isConflicting(row.getSchedule())) { |
| mDvrManager.setHighestPriority(row.getSchedule()); |
| } |
| } |
| } |
| |
| /** |
| * Action handler for {@link #ACTION_REMOVE_SCHEDULE}. |
| */ |
| protected void onRemoveSchedule(ScheduleRow row) { |
| if (row.getSchedule() == null) { |
| // This row has been deleted. |
| return; |
| } |
| CharSequence deletedInfo = null; |
| if (row.isOnAir()) { |
| if (row.isRecordingNotStarted()) { |
| deletedInfo = getDeletedInfo(row); |
| mDvrManager.removeScheduledRecording(row.getSchedule()); |
| } |
| } else { |
| if (mDvrManager.isConflicting(row.getSchedule()) |
| && !shouldKeepScheduleAfterRemoving()) { |
| deletedInfo = getDeletedInfo(row); |
| mDvrManager.removeScheduledRecording(row.getSchedule()); |
| } else if (row.isRecordingNotStarted()) { |
| deletedInfo = getDeletedInfo(row); |
| mDvrManager.updateScheduledRecording(ScheduledRecording.buildFrom(row.getSchedule()) |
| .setState(ScheduledRecording.STATE_RECORDING_CANCELED) |
| .build()); |
| } |
| } |
| if (deletedInfo != null) { |
| ToastUtils.show(mContext, mContext.getResources() |
| .getString(R.string.dvr_schedules_deletion_info, deletedInfo), |
| Toast.LENGTH_SHORT); |
| } |
| } |
| |
| private CharSequence getDeletedInfo(ScheduleRow row) { |
| CharSequence deletedInfo = onGetProgramInfoText(row); |
| if (TextUtils.isEmpty(deletedInfo)) { |
| return getChannelNameText(row); |
| } |
| return deletedInfo; |
| } |
| |
| @Override |
| protected void onRowViewSelected(ViewHolder vh, boolean selected) { |
| super.onRowViewSelected(vh, selected); |
| updateActionContainer(vh, selected); |
| } |
| |
| /** |
| * Internal method for onRowViewSelected, can be customized by subclass. |
| */ |
| private void updateActionContainer(ViewHolder vh, boolean selected) { |
| ScheduleRowViewHolder viewHolder = (ScheduleRowViewHolder) vh; |
| viewHolder.mSecondActionContainer.animate().setListener(null).cancel(); |
| viewHolder.mFirstActionContainer.animate().setListener(null).cancel(); |
| if (selected && viewHolder.mActions != null) { |
| switch (viewHolder.mActions.length) { |
| case 2: |
| prepareShowActionView(viewHolder.mSecondActionContainer); |
| prepareShowActionView(viewHolder.mFirstActionContainer); |
| viewHolder.mPendingAnimationRunnable = new Runnable() { |
| @Override |
| public void run() { |
| showActionView(viewHolder.mSecondActionContainer); |
| showActionView(viewHolder.mFirstActionContainer); |
| } |
| }; |
| break; |
| case 1: |
| prepareShowActionView(viewHolder.mFirstActionContainer); |
| viewHolder.mPendingAnimationRunnable = new Runnable() { |
| @Override |
| public void run() { |
| hideActionView(viewHolder.mSecondActionContainer, View.GONE); |
| showActionView(viewHolder.mFirstActionContainer); |
| } |
| }; |
| if (mLastFocusedViewId == R.id.action_second_container) { |
| mLastFocusedViewId = R.id.info_container; |
| } |
| break; |
| case 0: |
| default: |
| viewHolder.mPendingAnimationRunnable = new Runnable() { |
| @Override |
| public void run() { |
| hideActionView(viewHolder.mSecondActionContainer, View.GONE); |
| hideActionView(viewHolder.mFirstActionContainer, View.GONE); |
| } |
| }; |
| mLastFocusedViewId = R.id.info_container; |
| SoftPreconditions.checkState(viewHolder.mInfoContainer.isFocusable(), TAG, |
| "No focusable view in this row: " + viewHolder); |
| break; |
| } |
| View view = viewHolder.view.findViewById(mLastFocusedViewId); |
| if (view != null && view.getVisibility() == View.VISIBLE) { |
| // When the row is selected, information container gets the initial focus. |
| // To give the focus to the same control as the previous row, we need to call |
| // requestFocus() explicitly. |
| if (view.hasFocus()) { |
| viewHolder.mPendingAnimationRunnable.run(); |
| } else if (view.isFocusable()){ |
| view.requestFocus(); |
| } else { |
| viewHolder.view.requestFocus(); |
| } |
| } |
| } else { |
| viewHolder.mPendingAnimationRunnable = null; |
| hideActionView(viewHolder.mFirstActionContainer, View.GONE); |
| hideActionView(viewHolder.mSecondActionContainer, View.GONE); |
| } |
| } |
| |
| private void prepareShowActionView(View view) { |
| if (view.getVisibility() != View.VISIBLE) { |
| view.setAlpha(0.0f); |
| } |
| view.setVisibility(View.VISIBLE); |
| } |
| |
| /** |
| * Add animation when view is visible. |
| */ |
| private void showActionView(View view) { |
| view.animate().alpha(1.0f).setInterpolator(new DecelerateInterpolator()) |
| .setDuration(mAnimationDuration).start(); |
| } |
| |
| /** |
| * Add animation when view change to invisible. |
| */ |
| private void hideActionView(View view, int visibility) { |
| if (view.getVisibility() != View.VISIBLE) { |
| if (view.getVisibility() != visibility) { |
| view.setVisibility(visibility); |
| } |
| return; |
| } |
| view.animate().alpha(0.0f).setInterpolator(new DecelerateInterpolator()) |
| .setDuration(mAnimationDuration) |
| .setListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| view.setVisibility(visibility); |
| view.animate().setListener(null); |
| } |
| }).start(); |
| } |
| |
| /** |
| * Returns the available actions according to the row's state. It should be the reverse order |
| * with that in the screen. |
| */ |
| @ScheduleRowAction |
| protected int[] getAvailableActions(ScheduleRow row) { |
| if (row.getSchedule() != null) { |
| if (row.isRecordingInProgress()) { |
| return new int[]{ACTION_STOP_RECORDING}; |
| } else if (row.isOnAir()) { |
| if (row.isRecordingNotStarted()) { |
| if (canResolveConflict()) { |
| // The "START" action can change the conflict states. |
| return new int[] {ACTION_REMOVE_SCHEDULE, ACTION_START_RECORDING}; |
| } else { |
| return new int[] {ACTION_REMOVE_SCHEDULE}; |
| } |
| } else if (row.isRecordingFinished()) { |
| return new int[] {ACTION_START_RECORDING}; |
| } else { |
| SoftPreconditions.checkState(false, TAG, "Invalid row state in checking the" |
| + " available actions(on air): " + row); |
| } |
| } else { |
| if (row.isScheduleCanceled()) { |
| return new int[] {ACTION_CREATE_SCHEDULE}; |
| } else if (mDvrManager.isConflicting(row.getSchedule()) && canResolveConflict()) { |
| return new int[] {ACTION_REMOVE_SCHEDULE, ACTION_CREATE_SCHEDULE}; |
| } else if (row.isRecordingNotStarted()) { |
| return new int[] {ACTION_REMOVE_SCHEDULE}; |
| } else { |
| SoftPreconditions.checkState(false, TAG, "Invalid row state in checking the" |
| + " available actions(future schedule): " + row); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Check if the conflict can be resolved in this screen. |
| */ |
| protected boolean canResolveConflict() { |
| return true; |
| } |
| |
| /** |
| * Check if the schedule should be kept after removing it. |
| */ |
| protected boolean shouldKeepScheduleAfterRemoving() { |
| return false; |
| } |
| |
| /** |
| * Checks if the row should be grayed out. |
| */ |
| protected boolean shouldBeGrayedOut(ScheduleRow row) { |
| return row.getSchedule() == null |
| || (row.isOnAir() && !row.isRecordingInProgress()) |
| || mDvrManager.isConflicting(row.getSchedule()) |
| || row.isScheduleCanceled(); |
| } |
| } |
