| /* |
| * 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.ui; |
| |
| import android.animation.Animator; |
| import android.animation.AnimatorInflater; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.AnimatorSet; |
| import android.animation.ValueAnimator; |
| import android.content.Context; |
| import android.content.res.Resources; |
| import android.database.ContentObserver; |
| import android.graphics.Bitmap; |
| import android.media.tv.TvContract; |
| import android.media.tv.TvInputInfo; |
| import android.net.Uri; |
| import android.os.Handler; |
| import android.support.annotation.Nullable; |
| import android.text.Spannable; |
| import android.text.SpannableString; |
| import android.text.TextUtils; |
| import android.text.format.DateUtils; |
| import android.text.style.TextAppearanceSpan; |
| import android.util.AttributeSet; |
| import android.util.Log; |
| import android.util.TypedValue; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.animation.AnimationUtils; |
| import android.view.animation.Interpolator; |
| import android.widget.FrameLayout; |
| import android.widget.ImageView; |
| import android.widget.ProgressBar; |
| import android.widget.RelativeLayout; |
| import android.widget.TextView; |
| |
| import com.android.tv.MainActivity; |
| import com.android.tv.R; |
| import com.android.tv.common.recording.RecordedProgram; |
| import com.android.tv.data.Channel; |
| import com.android.tv.data.Program; |
| import com.android.tv.data.StreamInfo; |
| import com.android.tv.util.ImageCache; |
| import com.android.tv.util.ImageLoader; |
| import com.android.tv.util.ImageLoader.ImageLoaderCallback; |
| import com.android.tv.util.ImageLoader.LoadTvInputLogoTask; |
| import com.android.tv.util.Utils; |
| |
| import junit.framework.Assert; |
| |
| import java.util.Objects; |
| |
| /** |
| * A view to render channel banner. |
| */ |
| public class ChannelBannerView extends FrameLayout implements TvTransitionManager.TransitionLayout { |
| private static final String TAG = "ChannelBannerView"; |
| private static final boolean DEBUG = false; |
| |
| /** |
| * Show all information at the channel banner. |
| */ |
| public static final int LOCK_NONE = 0; |
| |
| /** |
| * Lock program details at the channel banner. |
| * This is used when a content is locked so we don't want to show program details |
| * including program description text and poster art. |
| */ |
| public static final int LOCK_PROGRAM_DETAIL = 1; |
| |
| /** |
| * Lock channel information at the channel banner. |
| * This is used when a channel is locked so we only want to show input information. |
| */ |
| public static final int LOCK_CHANNEL_INFO = 2; |
| |
| private static final String EMPTY_STRING = ""; |
| |
| private static Program sNoProgram; |
| private static Program sLockedChannelProgram; |
| private static String sClosedCaptionMark; |
| |
| private final MainActivity mMainActivity; |
| private final Resources mResources; |
| private View mChannelView; |
| |
| private TextView mChannelNumberTextView; |
| private ImageView mChannelLogoImageView; |
| private TextView mProgramTextView; |
| private ImageView mTvInputLogoImageView; |
| private TextView mChannelNameTextView; |
| private TextView mProgramTimeTextView; |
| private ProgressBar mRemainingTimeView; |
| private TextView mClosedCaptionTextView; |
| private TextView mAspectRatioTextView; |
| private TextView mResolutionTextView; |
| private TextView mAudioChannelTextView; |
| private TextView mProgramDescriptionTextView; |
| private String mProgramDescriptionText; |
| private View mAnchorView; |
| private Channel mCurrentChannel; |
| private Program mLastUpdatedProgram; |
| private RecordedProgram mLastUpdatedRecordedProgram; |
| private final Handler mHandler = new Handler(); |
| |
| private int mLockType; |
| |
| private Animator mResizeAnimator; |
| private int mCurrentHeight; |
| private boolean mProgramInfoUpdatePendingByResizing; |
| |
| private final Animator mProgramDescriptionFadeInAnimator; |
| private final Animator mProgramDescriptionFadeOutAnimator; |
| |
| private final Runnable mHideRunnable = new Runnable() { |
| @Override |
| public void run() { |
| mCurrentHeight = 0; |
| mMainActivity.getOverlayManager().hideOverlays( |
| TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_DIALOG |
| | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_SIDE_PANELS |
| | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_PROGRAM_GUIDE |
| | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_MENU |
| | TvOverlayManager.FLAG_HIDE_OVERLAYS_KEEP_FRAGMENT); |
| } |
| }; |
| private final long mShowDurationMillis; |
| private final int mChannelLogoImageViewWidth; |
| private final int mChannelLogoImageViewHeight; |
| private final int mChannelLogoImageViewMarginStart; |
| private final int mProgramDescriptionTextViewWidth; |
| private final int mChannelBannerTextColor; |
| private final int mChannelBannerDimTextColor; |
| private final int mResizeAnimDuration; |
| private final Interpolator mResizeInterpolator; |
| |
| private final AnimatorListenerAdapter mResizeAnimatorListener = new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animator) { |
| mProgramInfoUpdatePendingByResizing = false; |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animator) { |
| mProgramDescriptionTextView.setAlpha(1f); |
| mResizeAnimator = null; |
| if (mProgramInfoUpdatePendingByResizing) { |
| mProgramInfoUpdatePendingByResizing = false; |
| updateProgramInfo(mLastUpdatedProgram); |
| } |
| } |
| }; |
| |
| private final ContentObserver mProgramUpdateObserver = new ContentObserver(mHandler) { |
| @Override |
| public void onChange(boolean selfChange, Uri uri) { |
| // TODO: This {@code uri} argument may be a program which is not related to this |
| // channel. Consider adding channel id as a parameter of program URI to avoid |
| // unnecessary update. |
| mHandler.post(mProgramUpdateRunnable); |
| } |
| }; |
| |
| private final Runnable mProgramUpdateRunnable = new Runnable() { |
| @Override |
| public void run() { |
| removeCallbacks(this); |
| updateViews(null); |
| } |
| }; |
| |
| public ChannelBannerView(Context context) { |
| this(context, null); |
| } |
| |
| public ChannelBannerView(Context context, AttributeSet attrs) { |
| this(context, attrs, 0); |
| } |
| |
| public ChannelBannerView(Context context, AttributeSet attrs, int defStyle) { |
| super(context, attrs, defStyle); |
| mResources = getResources(); |
| |
| mMainActivity = (MainActivity) context; |
| |
| mShowDurationMillis = mResources.getInteger( |
| R.integer.channel_banner_show_duration); |
| mChannelLogoImageViewWidth = mResources.getDimensionPixelSize( |
| R.dimen.channel_banner_channel_logo_width); |
| mChannelLogoImageViewHeight = mResources.getDimensionPixelSize( |
| R.dimen.channel_banner_channel_logo_height); |
| mChannelLogoImageViewMarginStart = mResources.getDimensionPixelSize( |
| R.dimen.channel_banner_channel_logo_margin_start); |
| mProgramDescriptionTextViewWidth = mResources.getDimensionPixelSize( |
| R.dimen.channel_banner_program_description_width); |
| mChannelBannerTextColor = Utils.getColor(mResources, R.color.channel_banner_text_color); |
| mChannelBannerDimTextColor = Utils.getColor(mResources, |
| R.color.channel_banner_dim_text_color); |
| mResizeAnimDuration = mResources.getInteger(R.integer.channel_banner_fast_anim_duration); |
| |
| mResizeInterpolator = AnimationUtils.loadInterpolator(context, |
| android.R.interpolator.linear_out_slow_in); |
| |
| mProgramDescriptionFadeInAnimator = AnimatorInflater.loadAnimator(mMainActivity, |
| R.animator.channel_banner_program_description_fade_in); |
| mProgramDescriptionFadeOutAnimator = AnimatorInflater.loadAnimator(mMainActivity, |
| R.animator.channel_banner_program_description_fade_out); |
| |
| if (sNoProgram == null) { |
| sNoProgram = new Program.Builder() |
| .setTitle(context.getString(R.string.channel_banner_no_title)) |
| .setDescription(EMPTY_STRING) |
| .build(); |
| } |
| if (sLockedChannelProgram == null){ |
| sLockedChannelProgram = new Program.Builder() |
| .setTitle(context.getString(R.string.channel_banner_locked_channel_title)) |
| .setDescription(EMPTY_STRING) |
| .build(); |
| } |
| if (sClosedCaptionMark == null) { |
| sClosedCaptionMark = context.getString(R.string.closed_caption); |
| } |
| } |
| |
| @Override |
| protected void onAttachedToWindow() { |
| if (DEBUG) Log.d(TAG, "onAttachedToWindow"); |
| super.onAttachedToWindow(); |
| getContext().getContentResolver().registerContentObserver(TvContract.Programs.CONTENT_URI, |
| true, mProgramUpdateObserver); |
| } |
| |
| @Override |
| protected void onDetachedFromWindow() { |
| if (DEBUG) Log.d(TAG, "onDetachedToWindow"); |
| getContext().getContentResolver().unregisterContentObserver(mProgramUpdateObserver); |
| super.onDetachedFromWindow(); |
| } |
| |
| @Override |
| protected void onFinishInflate() { |
| super.onFinishInflate(); |
| |
| mChannelView = findViewById(R.id.channel_banner_view); |
| |
| mChannelNumberTextView = (TextView) findViewById(R.id.channel_number); |
| mChannelLogoImageView = (ImageView) findViewById(R.id.channel_logo); |
| mProgramTextView = (TextView) findViewById(R.id.program_text); |
| mTvInputLogoImageView = (ImageView) findViewById(R.id.tvinput_logo); |
| mChannelNameTextView = (TextView) findViewById(R.id.channel_name); |
| mProgramTimeTextView = (TextView) findViewById(R.id.program_time_text); |
| mRemainingTimeView = (ProgressBar) findViewById(R.id.remaining_time); |
| mClosedCaptionTextView = (TextView) findViewById(R.id.closed_caption); |
| mAspectRatioTextView = (TextView) findViewById(R.id.aspect_ratio); |
| mResolutionTextView = (TextView) findViewById(R.id.resolution); |
| mAudioChannelTextView = (TextView) findViewById(R.id.audio_channel); |
| mProgramDescriptionTextView = (TextView) findViewById(R.id.program_description); |
| mAnchorView = findViewById(R.id.anchor); |
| |
| mProgramDescriptionFadeInAnimator.setTarget(mProgramDescriptionTextView); |
| mProgramDescriptionFadeOutAnimator.setTarget(mProgramDescriptionTextView); |
| mProgramDescriptionFadeOutAnimator.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animator) { |
| mProgramDescriptionTextView.setText(mProgramDescriptionText); |
| } |
| }); |
| } |
| |
| @Override |
| public void onEnterAction(boolean fromEmptyScene) { |
| resetAnimationEffects(); |
| if (fromEmptyScene) { |
| ViewUtils.setTransitionAlpha(mChannelView, 1f); |
| } |
| scheduleHide(); |
| } |
| |
| @Override |
| public void onExitAction() { |
| mCurrentHeight = 0; |
| cancelHide(); |
| } |
| |
| private void scheduleHide() { |
| cancelHide(); |
| mHandler.postDelayed(mHideRunnable, mShowDurationMillis); |
| } |
| |
| private void cancelHide() { |
| mHandler.removeCallbacks(mHideRunnable); |
| } |
| |
| private void resetAnimationEffects() { |
| setAlpha(1f); |
| setScaleX(1f); |
| setScaleY(1f); |
| setTranslationX(0); |
| setTranslationY(0); |
| } |
| |
| /** |
| * Set new lock type. |
| * |
| * @param lockType Any of LOCK_NONE, LOCK_PROGRAM_DETAIL, or LOCK_CHANNEL_INFO. |
| * @return {@code true} only if lock type is changed |
| * @throws IllegalArgumentException if lockType is invalid. |
| */ |
| public boolean setLockType(int lockType) { |
| if (lockType != LOCK_NONE && lockType != LOCK_CHANNEL_INFO |
| && lockType != LOCK_PROGRAM_DETAIL) { |
| throw new IllegalArgumentException("No such lock type " + lockType); |
| } |
| if (mLockType != lockType) { |
| mLockType = lockType; |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Update channel banner view. |
| * |
| * @param info A StreamInfo that includes stream information. |
| * If it's {@code null}, only program information will be updated. |
| */ |
| public void updateViews(StreamInfo info) { |
| resetAnimationEffects(); |
| Channel channel = mMainActivity.getCurrentChannel(); |
| if (!Objects.equals(mCurrentChannel, channel) && isShown()) { |
| scheduleHide(); |
| } |
| mCurrentChannel = channel; |
| mChannelView.setVisibility(VISIBLE); |
| if (info != null) { |
| // If the current channels between ChannelTuner and TvView are different, |
| // the stream information should not be seen. |
| updateStreamInfo(channel != null && channel.equals(info.getCurrentChannel()) ? info |
| : null); |
| updateChannelInfo(); |
| } |
| if (mMainActivity.isRecordingPlayback()) { |
| updateProgramInfo(mMainActivity.getPlayingRecordedProgram()); |
| } else { |
| updateProgramInfo(mMainActivity.getCurrentProgram()); |
| } |
| } |
| |
| private void updateStreamInfo(StreamInfo info) { |
| // Update stream information in a channel. |
| if (mLockType != LOCK_CHANNEL_INFO && info != null) { |
| updateText(mClosedCaptionTextView, info.hasClosedCaption() ? sClosedCaptionMark |
| : EMPTY_STRING); |
| updateText(mAspectRatioTextView, |
| Utils.getAspectRatioString(info.getVideoDisplayAspectRatio())); |
| updateText(mResolutionTextView, |
| Utils.getVideoDefinitionLevelString( |
| mMainActivity, info.getVideoDefinitionLevel())); |
| updateText(mAudioChannelTextView, |
| Utils.getAudioChannelString(mMainActivity, info.getAudioChannelCount())); |
| } else { |
| // Channel change has been requested. But, StreamInfo hasn't been updated yet. |
| mClosedCaptionTextView.setVisibility(View.GONE); |
| mAspectRatioTextView.setVisibility(View.GONE); |
| mResolutionTextView.setVisibility(View.GONE); |
| mAudioChannelTextView.setVisibility(View.GONE); |
| } |
| } |
| |
| private void updateChannelInfo() { |
| // Update static information for a channel. |
| String displayNumber = EMPTY_STRING; |
| String displayName = EMPTY_STRING; |
| if (mCurrentChannel != null) { |
| displayNumber = mCurrentChannel.getDisplayNumber(); |
| if (displayNumber == null) { |
| displayNumber = EMPTY_STRING; |
| } |
| displayName = mCurrentChannel.getDisplayName(); |
| if (displayName == null) { |
| displayName = EMPTY_STRING; |
| } |
| } |
| |
| if (displayNumber.isEmpty()) { |
| mChannelNumberTextView.setVisibility(GONE); |
| } else { |
| mChannelNumberTextView.setVisibility(VISIBLE); |
| } |
| if (displayNumber.length() <= 3) { |
| updateTextView( |
| mChannelNumberTextView, |
| R.dimen.channel_banner_channel_number_large_text_size, |
| R.dimen.channel_banner_channel_number_large_margin_top); |
| } else if (displayNumber.length() <= 4) { |
| updateTextView( |
| mChannelNumberTextView, |
| R.dimen.channel_banner_channel_number_medium_text_size, |
| R.dimen.channel_banner_channel_number_medium_margin_top); |
| } else { |
| updateTextView( |
| mChannelNumberTextView, |
| R.dimen.channel_banner_channel_number_small_text_size, |
| R.dimen.channel_banner_channel_number_small_margin_top); |
| } |
| mChannelNumberTextView.setText(displayNumber); |
| mChannelNameTextView.setText(displayName); |
| TvInputInfo info = mMainActivity.getTvInputManagerHelper().getTvInputInfo( |
| getCurrentInputId()); |
| if (info == null || !ImageLoader.loadBitmap(createTvInputLogoLoaderCallback(info, this), |
| new LoadTvInputLogoTask(getContext(), ImageCache.getInstance(), info))) { |
| mTvInputLogoImageView.setVisibility(View.GONE); |
| mTvInputLogoImageView.setImageDrawable(null); |
| } |
| mChannelLogoImageView.setImageBitmap(null); |
| mChannelLogoImageView.setVisibility(View.GONE); |
| if (mCurrentChannel != null) { |
| mCurrentChannel.loadBitmap(getContext(), Channel.LOAD_IMAGE_TYPE_CHANNEL_LOGO, |
| mChannelLogoImageViewWidth, mChannelLogoImageViewHeight, |
| createChannelLogoCallback(this, mCurrentChannel)); |
| } |
| } |
| |
| private String getCurrentInputId() { |
| Channel channel = mMainActivity.getCurrentChannel(); |
| if (channel != null) { |
| return channel.getInputId(); |
| } else if (mMainActivity.isRecordingPlayback()) { |
| RecordedProgram recordedProgram = mMainActivity.getPlayingRecordedProgram(); |
| if (recordedProgram != null) { |
| return recordedProgram.getInputId(); |
| } |
| } |
| return null; |
| } |
| |
| private void updateTvInputLogo(Bitmap bitmap) { |
| mTvInputLogoImageView.setVisibility(View.VISIBLE); |
| mTvInputLogoImageView.setImageBitmap(bitmap); |
| } |
| |
| private static ImageLoaderCallback<ChannelBannerView> createTvInputLogoLoaderCallback( |
| final TvInputInfo info, ChannelBannerView channelBannerView) { |
| return new ImageLoaderCallback<ChannelBannerView>(channelBannerView) { |
| @Override |
| public void onBitmapLoaded(ChannelBannerView channelBannerView, Bitmap bitmap) { |
| if (bitmap != null && channelBannerView.mCurrentChannel != null |
| && info.getId().equals(channelBannerView.mCurrentChannel.getInputId())) { |
| channelBannerView.updateTvInputLogo(bitmap); |
| } |
| } |
| }; |
| } |
| |
| private void updateText(TextView view, String text) { |
| if (TextUtils.isEmpty(text)) { |
| view.setVisibility(View.GONE); |
| } else { |
| view.setVisibility(View.VISIBLE); |
| view.setText(text); |
| } |
| } |
| |
| private void updateTextView(TextView textView, int sizeRes, int marginTopRes) { |
| float textSize = mResources.getDimension(sizeRes); |
| if (textView.getTextSize() != textSize) { |
| textView.setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize); |
| } |
| updateTopMargin(textView, marginTopRes); |
| } |
| |
| private void updateTopMargin(View view, int marginTopRes) { |
| RelativeLayout.LayoutParams lp = (RelativeLayout.LayoutParams) view.getLayoutParams(); |
| int topMargin = (int) mResources.getDimension(marginTopRes); |
| if (lp.topMargin != topMargin) { |
| lp.topMargin = topMargin; |
| view.setLayoutParams(lp); |
| } |
| } |
| |
| private static ImageLoaderCallback<ChannelBannerView> createChannelLogoCallback( |
| ChannelBannerView channelBannerView, final Channel channel) { |
| return new ImageLoaderCallback<ChannelBannerView>(channelBannerView) { |
| @Override |
| public void onBitmapLoaded(ChannelBannerView view, @Nullable Bitmap logo) { |
| if (channel != view.mCurrentChannel) { |
| // The logo is obsolete. |
| return; |
| } |
| view.updateLogo(logo); |
| } |
| }; |
| } |
| |
| private void updateLogo(@Nullable Bitmap logo) { |
| if (logo == null) { |
| // Need to update the text size of the program text view depending on the channel logo. |
| updateProgramTextView(mLastUpdatedProgram); |
| return; |
| } |
| |
| mChannelLogoImageView.setImageBitmap(logo); |
| mChannelLogoImageView.setVisibility(View.VISIBLE); |
| updateProgramTextView(mLastUpdatedProgram); |
| |
| if (mResizeAnimator == null) { |
| String description = mProgramDescriptionTextView.getText().toString(); |
| boolean needFadeAnimation = !description.equals(mProgramDescriptionText); |
| updateBannerHeight(needFadeAnimation); |
| } else { |
| mProgramInfoUpdatePendingByResizing = true; |
| } |
| } |
| |
| private void updateProgramInfo(Program program) { |
| if (mLockType == LOCK_CHANNEL_INFO) { |
| program = sLockedChannelProgram; |
| } else if (!Program.isValid(program) || TextUtils.isEmpty(program.getTitle())) { |
| program = sNoProgram; |
| } |
| |
| if (mLastUpdatedProgram == null |
| || !TextUtils.equals(program.getTitle(), mLastUpdatedProgram.getTitle()) |
| || !TextUtils.equals(program.getEpisodeDisplayTitle(getContext()), |
| mLastUpdatedProgram.getEpisodeDisplayTitle(getContext()))) { |
| updateProgramTextView(program); |
| } |
| updateProgramTimeInfo(program); |
| |
| // When the program is changed, but the previous resize animation has not ended yet, |
| // cancel the animation. |
| boolean isProgramChanged = !Objects.equals(mLastUpdatedProgram, program); |
| if (mResizeAnimator != null && isProgramChanged) { |
| setLastUpdatedProgram(program); |
| mProgramInfoUpdatePendingByResizing = true; |
| mResizeAnimator.cancel(); |
| } else if (mResizeAnimator == null) { |
| if (mLockType != LOCK_NONE || TextUtils.isEmpty(program.getDescription())) { |
| mProgramDescriptionTextView.setVisibility(GONE); |
| mProgramDescriptionText = ""; |
| } else { |
| mProgramDescriptionTextView.setVisibility(VISIBLE); |
| mProgramDescriptionText = program.getDescription(); |
| } |
| String description = mProgramDescriptionTextView.getText().toString(); |
| boolean needFadeAnimation = isProgramChanged |
| || !description.equals(mProgramDescriptionText); |
| updateBannerHeight(needFadeAnimation); |
| } else { |
| mProgramInfoUpdatePendingByResizing = true; |
| } |
| setLastUpdatedProgram(program); |
| } |
| |
| private void updateProgramInfo(RecordedProgram recordedProgram) { |
| if (mLockType == LOCK_CHANNEL_INFO) { |
| updateProgramInfo(sLockedChannelProgram); |
| return; |
| } else if (recordedProgram == null) { |
| updateProgramInfo(sNoProgram); |
| return; |
| } |
| |
| if (mLastUpdatedRecordedProgram == null |
| || !TextUtils.equals(recordedProgram.getTitle(), |
| mLastUpdatedRecordedProgram.getTitle()) |
| || !TextUtils.equals(recordedProgram.getEpisodeDisplayTitle(getContext()), |
| mLastUpdatedRecordedProgram.getEpisodeDisplayTitle(getContext()))) { |
| updateProgramTextView(recordedProgram); |
| } |
| updateProgramTimeInfo(recordedProgram); |
| |
| // When the program is changed, but the previous resize animation has not ended yet, |
| // cancel the animation. |
| boolean isProgramChanged = !Objects.equals(mLastUpdatedRecordedProgram, recordedProgram); |
| if (mResizeAnimator != null && isProgramChanged) { |
| setLastUpdatedRecordedProgram(recordedProgram); |
| mProgramInfoUpdatePendingByResizing = true; |
| mResizeAnimator.cancel(); |
| } else if (mResizeAnimator == null) { |
| if (mLockType != LOCK_NONE |
| || TextUtils.isEmpty(recordedProgram.getShortDescription())) { |
| mProgramDescriptionTextView.setVisibility(GONE); |
| mProgramDescriptionText = ""; |
| } else { |
| mProgramDescriptionTextView.setVisibility(VISIBLE); |
| mProgramDescriptionText = recordedProgram.getShortDescription(); |
| } |
| String description = mProgramDescriptionTextView.getText().toString(); |
| boolean needFadeAnimation = isProgramChanged |
| || !description.equals(mProgramDescriptionText); |
| updateBannerHeight(needFadeAnimation); |
| } else { |
| mProgramInfoUpdatePendingByResizing = true; |
| } |
| setLastUpdatedRecordedProgram(recordedProgram); |
| } |
| |
| private void updateProgramTextView(Program program) { |
| if (program == null) { |
| return; |
| } |
| updateProgramTextView(program == sLockedChannelProgram, program.getTitle(), |
| program.getEpisodeTitle(), program.getEpisodeDisplayTitle(getContext())); |
| } |
| |
| private void updateProgramTextView(RecordedProgram recordedProgram) { |
| if (recordedProgram == null) { |
| return; |
| } |
| updateProgramTextView(false, recordedProgram.getTitle(), recordedProgram.getEpisodeTitle(), |
| recordedProgram.getEpisodeDisplayTitle(getContext())); |
| } |
| |
| private void updateProgramTextView(boolean dimText, String title, String episodeTitle, |
| String episodeDisplayTitle) { |
| mProgramTextView.setVisibility(View.VISIBLE); |
| if (dimText) { |
| mProgramTextView.setTextColor(mChannelBannerDimTextColor); |
| } else { |
| mProgramTextView.setTextColor(mChannelBannerTextColor); |
| } |
| updateTextView(mProgramTextView, |
| R.dimen.channel_banner_program_large_text_size, |
| R.dimen.channel_banner_program_large_margin_top); |
| if (TextUtils.isEmpty(episodeTitle)) { |
| mProgramTextView.setText(title); |
| } else { |
| String fullTitle = title + " " + episodeDisplayTitle; |
| |
| SpannableString text = new SpannableString(fullTitle); |
| text.setSpan(new TextAppearanceSpan(getContext(), |
| R.style.text_appearance_channel_banner_episode_title), |
| fullTitle.length() - episodeDisplayTitle.length(), fullTitle.length(), |
| Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| mProgramTextView.setText(text); |
| } |
| int width = mProgramDescriptionTextViewWidth |
| - ((mChannelLogoImageView.getVisibility() != View.VISIBLE) |
| ? 0 : mChannelLogoImageViewWidth + mChannelLogoImageViewMarginStart); |
| ViewGroup.LayoutParams lp = mProgramTextView.getLayoutParams(); |
| lp.width = width; |
| mProgramTextView.setLayoutParams(lp); |
| mProgramTextView.measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), |
| MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)); |
| |
| boolean oneline = (mProgramTextView.getLineCount() == 1); |
| if (!oneline) { |
| updateTextView( |
| mProgramTextView, |
| R.dimen.channel_banner_program_medium_text_size, |
| R.dimen.channel_banner_program_medium_margin_top); |
| mProgramTextView.measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), |
| MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)); |
| oneline = (mProgramTextView.getLineCount() == 1); |
| } |
| updateTopMargin(mAnchorView, oneline |
| ? R.dimen.channel_banner_anchor_one_line_y |
| : R.dimen.channel_banner_anchor_two_line_y); |
| } |
| |
| private void updateProgramTimeInfo(Program program) { |
| long startTime = program.getStartTimeUtcMillis(); |
| long endTime = program.getEndTimeUtcMillis(); |
| if (mLockType != LOCK_CHANNEL_INFO && startTime > 0 && endTime > startTime) { |
| mProgramTimeTextView.setVisibility(View.VISIBLE); |
| mRemainingTimeView.setVisibility(View.VISIBLE); |
| |
| mProgramTimeTextView.setText(Utils.getDurationString( |
| getContext(), startTime, endTime, true)); |
| |
| long currTime = mMainActivity.getCurrentPlayingPosition(); |
| if (currTime <= startTime) { |
| mRemainingTimeView.setProgress(0); |
| } else if (currTime >= endTime) { |
| mRemainingTimeView.setProgress(100); |
| } else { |
| mRemainingTimeView.setProgress( |
| (int) (100 * (currTime - startTime) / (endTime - startTime))); |
| } |
| } else { |
| mProgramTimeTextView.setVisibility(View.GONE); |
| mRemainingTimeView.setVisibility(View.GONE); |
| } |
| } |
| |
| private void updateProgramTimeInfo(RecordedProgram recordedProgram) { |
| long durationMs = recordedProgram.getDurationMillis(); |
| if (mLockType != LOCK_CHANNEL_INFO && durationMs > 0) { |
| mProgramTimeTextView.setVisibility(View.VISIBLE); |
| mRemainingTimeView.setVisibility(View.VISIBLE); |
| |
| mProgramTimeTextView.setText(DateUtils.formatElapsedTime(durationMs / 1000)); |
| |
| long currTimeMs = mMainActivity.getCurrentPlayingPosition(); |
| if (currTimeMs <= 0) { |
| mRemainingTimeView.setProgress(0); |
| } else if (currTimeMs >= durationMs) { |
| mRemainingTimeView.setProgress(100); |
| } else { |
| mRemainingTimeView.setProgress((int) (100 * currTimeMs / durationMs)); |
| } |
| } else { |
| mProgramTimeTextView.setVisibility(View.GONE); |
| mRemainingTimeView.setVisibility(View.GONE); |
| } |
| } |
| |
| private void setLastUpdatedProgram(Program program) { |
| mLastUpdatedProgram = program; |
| mLastUpdatedRecordedProgram = null; |
| } |
| |
| private void setLastUpdatedRecordedProgram(RecordedProgram recordedProgram) { |
| mLastUpdatedProgram = null; |
| mLastUpdatedRecordedProgram = recordedProgram; |
| } |
| |
| private void updateBannerHeight(boolean needFadeAnimation) { |
| Assert.assertNull(mResizeAnimator); |
| // Need to measure the layout height with the new description text. |
| CharSequence oldDescription = mProgramDescriptionTextView.getText(); |
| mProgramDescriptionTextView.setText(mProgramDescriptionText); |
| measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED); |
| int targetHeight = getMeasuredHeight(); |
| |
| if (mCurrentHeight == 0 || !isShown()) { |
| // Do not add the resize animation when the banner has not been shown before. |
| mCurrentHeight = targetHeight; |
| LayoutParams layoutParams = (LayoutParams) getLayoutParams(); |
| if (targetHeight != layoutParams.height) { |
| layoutParams.height = targetHeight; |
| setLayoutParams(layoutParams); |
| } |
| } else if (mCurrentHeight != targetHeight || needFadeAnimation) { |
| // Restore description text for fade in/out animation. |
| if (needFadeAnimation) { |
| mProgramDescriptionTextView.setText(oldDescription); |
| } |
| mResizeAnimator = createResizeAnimator(targetHeight, needFadeAnimation); |
| mResizeAnimator.start(); |
| } |
| } |
| |
| private Animator createResizeAnimator(int targetHeight, boolean addFadeAnimation) { |
| final ValueAnimator heightAnimator = ValueAnimator.ofInt(mCurrentHeight, targetHeight); |
| heightAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { |
| @Override |
| public void onAnimationUpdate(ValueAnimator animation) { |
| int value = (Integer) animation.getAnimatedValue(); |
| LayoutParams layoutParams = (LayoutParams) ChannelBannerView.this.getLayoutParams(); |
| if (value != layoutParams.height) { |
| layoutParams.height = value; |
| ChannelBannerView.this.setLayoutParams(layoutParams); |
| } |
| mCurrentHeight = value; |
| } |
| }); |
| |
| heightAnimator.setDuration(mResizeAnimDuration); |
| heightAnimator.setInterpolator(mResizeInterpolator); |
| |
| if (!addFadeAnimation) { |
| heightAnimator.addListener(mResizeAnimatorListener); |
| return heightAnimator; |
| } |
| |
| AnimatorSet fadeOutAndHeightAnimator = new AnimatorSet(); |
| fadeOutAndHeightAnimator.playTogether(mProgramDescriptionFadeOutAnimator, heightAnimator); |
| AnimatorSet animator = new AnimatorSet(); |
| animator.playSequentially(fadeOutAndHeightAnimator, mProgramDescriptionFadeInAnimator); |
| animator.addListener(mResizeAnimatorListener); |
| return animator; |
| } |
| } |
