| package com.android.contacts.widget; |
| |
| import com.android.contacts.R; |
| import com.android.contacts.common.compat.CompatUtils; |
| import com.android.contacts.compat.EdgeEffectCompat; |
| import com.android.contacts.quickcontact.ExpandingEntryCardView; |
| import com.android.contacts.test.NeededForReflection; |
| import com.android.contacts.util.SchedulingUtils; |
| |
| import android.animation.Animator; |
| import android.animation.Animator.AnimatorListener; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.ObjectAnimator; |
| import android.animation.ValueAnimator; |
| import android.animation.ValueAnimator.AnimatorUpdateListener; |
| import android.content.Context; |
| import android.content.res.TypedArray; |
| import android.graphics.Canvas; |
| import android.graphics.Color; |
| import android.graphics.ColorMatrix; |
| import android.graphics.ColorMatrixColorFilter; |
| import android.graphics.drawable.GradientDrawable; |
| import android.hardware.display.DisplayManager; |
| import android.os.Trace; |
| import android.support.v4.view.ViewCompat; |
| import android.support.v4.view.animation.PathInterpolatorCompat; |
| import android.util.AttributeSet; |
| import android.util.TypedValue; |
| import android.view.Display; |
| import android.view.Gravity; |
| import android.view.MotionEvent; |
| import android.view.VelocityTracker; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.ViewConfiguration; |
| import android.view.animation.AnimationUtils; |
| import android.view.animation.Interpolator; |
| import android.widget.EdgeEffect; |
| import android.widget.FrameLayout; |
| import android.widget.LinearLayout; |
| import android.widget.Scroller; |
| import android.widget.ScrollView; |
| import android.widget.TextView; |
| import android.widget.Toolbar; |
| |
| /** |
| * A custom {@link ViewGroup} that operates similarly to a {@link ScrollView}, except with multiple |
| * subviews. These subviews are scrolled or shrinked one at a time, until each reaches their |
| * minimum or maximum value. |
| * |
| * MultiShrinkScroller is designed for a specific problem. As such, this class is designed to be |
| * used with a specific layout file: quickcontact_activity.xml. MultiShrinkScroller expects subviews |
| * with specific ID values. |
| * |
| * MultiShrinkScroller's code is heavily influenced by ScrollView. Nonetheless, several ScrollView |
| * features are missing. For example: handling of KEYCODES, OverScroll bounce and saving |
| * scroll state in savedInstanceState bundles. |
| * |
| * Before copying this approach to nested scrolling, consider whether something simpler & less |
| * customized will work for you. For example, see the re-usable StickyHeaderListView used by |
| * WifiSetupActivity (very nice). Alternatively, check out Google+'s cover photo scrolling or |
| * Android L's built in nested scrolling support. I thought I needed a more custom ViewGroup in |
| * order to track velocity, modify EdgeEffect color & perform the originally specified animations. |
| * As a result this ViewGroup has non-standard talkback and keyboard support. |
| */ |
| public class MultiShrinkScroller extends FrameLayout { |
| |
| /** |
| * 1000 pixels per second. Ie, 1 pixel per millisecond. |
| */ |
| private static final int PIXELS_PER_SECOND = 1000; |
| |
| /** |
| * Length of the acceleration animations. This value was taken from ValueAnimator.java. |
| */ |
| private static final int EXIT_FLING_ANIMATION_DURATION_MS = 250; |
| |
| /** |
| * In portrait mode, the height:width ratio of the photo's starting height. |
| */ |
| private static final float INTERMEDIATE_HEADER_HEIGHT_RATIO = 0.6f; |
| |
| /** |
| * Color blending will only be performed on the contact photo once the toolbar is compressed |
| * to this ratio of its full height. |
| */ |
| private static final float COLOR_BLENDING_START_RATIO = 0.5f; |
| |
| private static final float SPRING_DAMPENING_FACTOR = 0.01f; |
| |
| /** |
| * When displaying a letter tile drawable, this alpha value should be used at the intermediate |
| * toolbar height. |
| */ |
| private static final float DESIRED_INTERMEDIATE_LETTER_TILE_ALPHA = 0.8f; |
| |
| private float[] mLastEventPosition = { 0, 0 }; |
| private VelocityTracker mVelocityTracker; |
| private boolean mIsBeingDragged = false; |
| private boolean mReceivedDown = false; |
| /** |
| * Did the current downwards fling/scroll-animation start while we were fullscreen? |
| */ |
| private boolean mIsFullscreenDownwardsFling = false; |
| |
| private ScrollView mScrollView; |
| private View mScrollViewChild; |
| private View mToolbar; |
| private QuickContactImageView mPhotoView; |
| private View mPhotoViewContainer; |
| private View mTransparentView; |
| private MultiShrinkScrollerListener mListener; |
| private TextView mLargeTextView; |
| private TextView mPhoneticNameView; |
| private View mTitleAndPhoneticNameView; |
| private View mPhotoTouchInterceptOverlay; |
| /** Contains desired size & vertical offset of the title, once the header is fully compressed */ |
| private TextView mInvisiblePlaceholderTextView; |
| private View mTitleGradientView; |
| private View mActionBarGradientView; |
| private View mStartColumn; |
| private int mHeaderTintColor; |
| private int mMaximumHeaderHeight; |
| private int mMinimumHeaderHeight; |
| /** |
| * When the contact photo is tapped, it is resized to max size or this size. This value also |
| * sometimes represents the maximum achievable header size achieved by scrolling. To enforce |
| * this maximum in scrolling logic, always access this value via |
| * {@link #getMaximumScrollableHeaderHeight}. |
| */ |
| private int mIntermediateHeaderHeight; |
| /** |
| * If true, regular scrolling can expand the header beyond mIntermediateHeaderHeight. The |
| * header, that contains the contact photo, can expand to a height equal its width. |
| */ |
| private boolean mIsOpenContactSquare; |
| private int mMaximumHeaderTextSize; |
| private int mMaximumPhoneticNameViewHeight; |
| private int mMaximumFullNameViewHeight; |
| private int mCollapsedTitleBottomMargin; |
| private int mCollapsedTitleStartMargin; |
| private int mMinimumPortraitHeaderHeight; |
| private int mMaximumPortraitHeaderHeight; |
| /** |
| * True once the header has touched the top of the screen at least once. |
| */ |
| private boolean mHasEverTouchedTheTop; |
| private boolean mIsTouchDisabledForDismissAnimation; |
| private boolean mIsTouchDisabledForSuppressLayout; |
| |
| private final Scroller mScroller; |
| private final EdgeEffect mEdgeGlowBottom; |
| private final EdgeEffect mEdgeGlowTop; |
| private final int mTouchSlop; |
| private final int mMaximumVelocity; |
| private final int mMinimumVelocity; |
| private final int mDismissDistanceOnScroll; |
| private final int mDismissDistanceOnRelease; |
| private final int mSnapToTopSlopHeight; |
| private final int mTransparentStartHeight; |
| private final int mMaximumTitleMargin; |
| private final float mToolbarElevation; |
| private final boolean mIsTwoPanel; |
| private final float mLandscapePhotoRatio; |
| private final int mActionBarSize; |
| |
| // Objects used to perform color filtering on the header. These are stored as fields for |
| // the sole purpose of avoiding "new" operations inside animation loops. |
| private final ColorMatrix mWhitenessColorMatrix = new ColorMatrix(); |
| private final ColorMatrix mColorMatrix = new ColorMatrix(); |
| private final float[] mAlphaMatrixValues = { |
| 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, |
| 0, 0, 0, 1, 0 |
| }; |
| private final ColorMatrix mMultiplyBlendMatrix = new ColorMatrix(); |
| private final float[] mMultiplyBlendMatrixValues = { |
| 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, |
| 0, 0, 0, 1, 0 |
| }; |
| |
| private final Interpolator mTextSizePathInterpolator = |
| PathInterpolatorCompat.create(0.16f, 0.4f, 0.2f, 1); |
| |
| private final int[] mGradientColors = new int[] {0,0x88000000}; |
| private GradientDrawable mTitleGradientDrawable = new GradientDrawable( |
| GradientDrawable.Orientation.TOP_BOTTOM, mGradientColors); |
| private GradientDrawable mActionBarGradientDrawable = new GradientDrawable( |
| GradientDrawable.Orientation.BOTTOM_TOP, mGradientColors); |
| |
| public interface MultiShrinkScrollerListener { |
| void onScrolledOffBottom(); |
| |
| void onStartScrollOffBottom(); |
| |
| void onTransparentViewHeightChange(float ratio); |
| |
| void onEntranceAnimationDone(); |
| |
| void onEnterFullscreen(); |
| |
| void onExitFullscreen(); |
| } |
| |
| private final AnimatorListener mSnapToBottomListener = new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| if (getScrollUntilOffBottom() > 0 && mListener != null) { |
| // Due to a rounding error, after the animation finished we haven't fully scrolled |
| // off the screen. Lie to the listener: tell it that we did scroll off the screen. |
| mListener.onScrolledOffBottom(); |
| // No other messages need to be sent to the listener. |
| mListener = null; |
| } |
| } |
| }; |
| |
| /** |
| * Interpolator from android.support.v4.view.ViewPager. Snappier and more elastic feeling |
| * than the default interpolator. |
| */ |
| private static final Interpolator sInterpolator = new Interpolator() { |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public float getInterpolation(float t) { |
| t -= 1.0f; |
| return t * t * t * t * t + 1.0f; |
| } |
| }; |
| |
| public MultiShrinkScroller(Context context) { |
| this(context, null); |
| } |
| |
| public MultiShrinkScroller(Context context, AttributeSet attrs) { |
| this(context, attrs, 0); |
| } |
| |
| public MultiShrinkScroller(Context context, AttributeSet attrs, int defStyleAttr) { |
| super(context, attrs, defStyleAttr); |
| |
| final ViewConfiguration configuration = ViewConfiguration.get(context); |
| setFocusable(false); |
| // Drawing must be enabled in order to support EdgeEffect |
| setWillNotDraw(/* willNotDraw = */ false); |
| |
| mEdgeGlowBottom = new EdgeEffect(context); |
| mEdgeGlowTop = new EdgeEffect(context); |
| mScroller = new Scroller(context, sInterpolator); |
| mTouchSlop = configuration.getScaledTouchSlop(); |
| mMinimumVelocity = configuration.getScaledMinimumFlingVelocity(); |
| mMaximumVelocity = configuration.getScaledMaximumFlingVelocity(); |
| mTransparentStartHeight = (int) getResources().getDimension( |
| R.dimen.quickcontact_starting_empty_height); |
| mToolbarElevation = getResources().getDimension( |
| R.dimen.quick_contact_toolbar_elevation); |
| mIsTwoPanel = getResources().getBoolean(R.bool.quickcontact_two_panel); |
| mMaximumTitleMargin = (int) getResources().getDimension( |
| R.dimen.quickcontact_title_initial_margin); |
| |
| mDismissDistanceOnScroll = (int) getResources().getDimension( |
| R.dimen.quickcontact_dismiss_distance_on_scroll); |
| mDismissDistanceOnRelease = (int) getResources().getDimension( |
| R.dimen.quickcontact_dismiss_distance_on_release); |
| mSnapToTopSlopHeight = (int) getResources().getDimension( |
| R.dimen.quickcontact_snap_to_top_slop_height); |
| |
| final TypedValue photoRatio = new TypedValue(); |
| getResources().getValue(R.dimen.quickcontact_landscape_photo_ratio, photoRatio, |
| /* resolveRefs = */ true); |
| mLandscapePhotoRatio = photoRatio.getFloat(); |
| |
| final TypedArray attributeArray = context.obtainStyledAttributes( |
| new int[]{android.R.attr.actionBarSize}); |
| mActionBarSize = attributeArray.getDimensionPixelSize(0, 0); |
| mMinimumHeaderHeight = mActionBarSize; |
| // This value is approximately equal to the portrait ActionBar size. It isn't exactly the |
| // same, since the landscape and portrait ActionBar sizes can be different. |
| mMinimumPortraitHeaderHeight = mMinimumHeaderHeight; |
| attributeArray.recycle(); |
| } |
| |
| /** |
| * This method must be called inside the Activity's OnCreate. |
| */ |
| public void initialize(MultiShrinkScrollerListener listener, boolean isOpenContactSquare, |
| final int maximumHeaderTextSize, final boolean shouldUpdateNameViewHeight) { |
| mScrollView = (ScrollView) findViewById(R.id.content_scroller); |
| mScrollViewChild = findViewById(R.id.card_container); |
| mToolbar = findViewById(R.id.toolbar_parent); |
| mPhotoViewContainer = findViewById(R.id.toolbar_parent); |
| mTransparentView = findViewById(R.id.transparent_view); |
| mLargeTextView = (TextView) findViewById(R.id.large_title); |
| mPhoneticNameView = (TextView) findViewById(R.id.phonetic_name); |
| mTitleAndPhoneticNameView = findViewById(R.id.title_and_phonetic_name); |
| mInvisiblePlaceholderTextView = (TextView) findViewById(R.id.placeholder_textview); |
| mStartColumn = findViewById(R.id.empty_start_column); |
| // Touching the empty space should close the card |
| if (mStartColumn != null) { |
| mStartColumn.setOnClickListener(new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| scrollOffBottom(); |
| } |
| }); |
| findViewById(R.id.empty_end_column).setOnClickListener(new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| scrollOffBottom(); |
| } |
| }); |
| } |
| mListener = listener; |
| mIsOpenContactSquare = isOpenContactSquare; |
| |
| mPhotoView = (QuickContactImageView) findViewById(R.id.photo); |
| |
| mTitleGradientView = findViewById(R.id.title_gradient); |
| mTitleGradientView.setBackground(mTitleGradientDrawable); |
| mActionBarGradientView = findViewById(R.id.action_bar_gradient); |
| mActionBarGradientView.setBackground(mActionBarGradientDrawable); |
| mCollapsedTitleStartMargin = ((Toolbar) findViewById(R.id.toolbar)).getContentInsetStart(); |
| |
| mPhotoTouchInterceptOverlay = findViewById(R.id.photo_touch_intercept_overlay); |
| if (!mIsTwoPanel) { |
| mPhotoTouchInterceptOverlay.setOnClickListener(new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| expandHeader(); |
| } |
| }); |
| } |
| |
| SchedulingUtils.doOnPreDraw(this, /* drawNextFrame = */ false, new Runnable() { |
| @Override |
| public void run() { |
| if (!mIsTwoPanel) { |
| // We never want the height of the photo view to exceed its width. |
| mMaximumHeaderHeight = mPhotoViewContainer.getWidth(); |
| mIntermediateHeaderHeight = (int) (mMaximumHeaderHeight |
| * INTERMEDIATE_HEADER_HEIGHT_RATIO); |
| } |
| mMaximumPortraitHeaderHeight = mIsTwoPanel ? getHeight() |
| : mPhotoViewContainer.getWidth(); |
| setHeaderHeight(getMaximumScrollableHeaderHeight()); |
| if (shouldUpdateNameViewHeight) { |
| mMaximumHeaderTextSize = mTitleAndPhoneticNameView.getHeight(); |
| mMaximumFullNameViewHeight = mLargeTextView.getHeight(); |
| // We cannot rely on mPhoneticNameView.getHeight() since it could be 0 |
| final int phoneticNameSize = getResources().getDimensionPixelSize( |
| R.dimen.quickcontact_maximum_phonetic_name_size); |
| final int fullNameSize = getResources().getDimensionPixelSize( |
| R.dimen.quickcontact_maximum_title_size); |
| mMaximumPhoneticNameViewHeight = |
| mMaximumFullNameViewHeight * phoneticNameSize / fullNameSize; |
| } |
| if (maximumHeaderTextSize > 0) { |
| mMaximumHeaderTextSize = maximumHeaderTextSize; |
| } |
| if (mIsTwoPanel) { |
| mMaximumHeaderHeight = getHeight(); |
| mMinimumHeaderHeight = mMaximumHeaderHeight; |
| mIntermediateHeaderHeight = mMaximumHeaderHeight; |
| |
| // Permanently set photo width and height. |
| final ViewGroup.LayoutParams photoLayoutParams |
| = mPhotoViewContainer.getLayoutParams(); |
| photoLayoutParams.height = mMaximumHeaderHeight; |
| photoLayoutParams.width = (int) (mMaximumHeaderHeight * mLandscapePhotoRatio); |
| mPhotoViewContainer.setLayoutParams(photoLayoutParams); |
| |
| // Permanently set title width and margin. |
| final FrameLayout.LayoutParams largeTextLayoutParams |
| = (FrameLayout.LayoutParams) mTitleAndPhoneticNameView |
| .getLayoutParams(); |
| largeTextLayoutParams.width = photoLayoutParams.width - |
| largeTextLayoutParams.leftMargin - largeTextLayoutParams.rightMargin; |
| largeTextLayoutParams.gravity = Gravity.BOTTOM | Gravity.START; |
| mTitleAndPhoneticNameView.setLayoutParams(largeTextLayoutParams); |
| } else { |
| // Set the width of mLargeTextView as if it was nested inside |
| // mPhotoViewContainer. |
| mLargeTextView.setWidth(mPhotoViewContainer.getWidth() |
| - 2 * mMaximumTitleMargin); |
| mPhoneticNameView.setWidth(mPhotoViewContainer.getWidth() |
| - 2 * mMaximumTitleMargin); |
| } |
| |
| calculateCollapsedLargeTitlePadding(); |
| updateHeaderTextSizeAndMargin(); |
| configureGradientViewHeights(); |
| } |
| }); |
| } |
| |
| private void configureGradientViewHeights() { |
| final FrameLayout.LayoutParams actionBarGradientLayoutParams |
| = (FrameLayout.LayoutParams) mActionBarGradientView.getLayoutParams(); |
| actionBarGradientLayoutParams.height = mActionBarSize; |
| mActionBarGradientView.setLayoutParams(actionBarGradientLayoutParams); |
| final FrameLayout.LayoutParams titleGradientLayoutParams |
| = (FrameLayout.LayoutParams) mTitleGradientView.getLayoutParams(); |
| final float TITLE_GRADIENT_SIZE_COEFFICIENT = 1.25f; |
| final FrameLayout.LayoutParams largeTextLayoutParms |
| = (FrameLayout.LayoutParams) mTitleAndPhoneticNameView.getLayoutParams(); |
| titleGradientLayoutParams.height = (int) ((mMaximumHeaderTextSize |
| + largeTextLayoutParms.bottomMargin) * TITLE_GRADIENT_SIZE_COEFFICIENT); |
| mTitleGradientView.setLayoutParams(titleGradientLayoutParams); |
| } |
| |
| public void setTitle(String title, boolean isPhoneNumber) { |
| mLargeTextView.setText(title); |
| // We have a phone number as "mLargeTextView" so make it always LTR. |
| if (isPhoneNumber) { |
| mLargeTextView.setTextDirection(View.TEXT_DIRECTION_LTR); |
| } |
| mPhotoTouchInterceptOverlay.setContentDescription(title); |
| } |
| |
| public void setPhoneticName(String phoneticName) { |
| // Set phonetic name only when it was gone before or got changed. |
| if (mPhoneticNameView.getVisibility() == View.VISIBLE |
| && phoneticName.equals(mPhoneticNameView.getText())) { |
| return; |
| } |
| mPhoneticNameView.setText(phoneticName); |
| // Every time the phonetic name is changed, set mPhoneticNameView as visible, |
| // in case it just changed from Visibility=GONE. |
| mPhoneticNameView.setVisibility(View.VISIBLE); |
| // TODO try not using initialize() to refresh phonetic name view: b/27410518 |
| initialize(mListener, mIsOpenContactSquare, /* maximumHeaderTextSize */ |
| (mMaximumFullNameViewHeight + mMaximumPhoneticNameViewHeight), |
| /* shouldUpdateNameViewHeight */ false); |
| } |
| |
| public void setPhoneticNameGone() { |
| // Remove phonetic name only when it was visible before. |
| if (mPhoneticNameView.getVisibility() == View.GONE) { |
| return; |
| } |
| mPhoneticNameView.setVisibility(View.GONE); |
| // Initialize to make Visibility work. |
| // TODO try not using initialize() to refresh phonetic name view: b/27410518 |
| initialize(mListener, mIsOpenContactSquare, |
| /* maximumHeaderTextSize */ mMaximumFullNameViewHeight, |
| /* shouldUpdateNameViewHeight */ false); |
| } |
| |
| @Override |
| public boolean onInterceptTouchEvent(MotionEvent event) { |
| if (mVelocityTracker == null) { |
| mVelocityTracker = VelocityTracker.obtain(); |
| } |
| mVelocityTracker.addMovement(event); |
| |
| // The only time we want to intercept touch events is when we are being dragged. |
| return shouldStartDrag(event); |
| } |
| |
| private boolean shouldStartDrag(MotionEvent event) { |
| if (mIsTouchDisabledForDismissAnimation || mIsTouchDisabledForSuppressLayout) return false; |
| |
| |
| if (mIsBeingDragged) { |
| mIsBeingDragged = false; |
| return false; |
| } |
| |
| switch (event.getAction()) { |
| // If we are in the middle of a fling and there is a down event, we'll steal it and |
| // start a drag. |
| case MotionEvent.ACTION_DOWN: |
| updateLastEventPosition(event); |
| if (!mScroller.isFinished()) { |
| startDrag(); |
| return true; |
| } else { |
| mReceivedDown = true; |
| } |
| break; |
| |
| // Otherwise, we will start a drag if there is enough motion in the direction we are |
| // capable of scrolling. |
| case MotionEvent.ACTION_MOVE: |
| if (motionShouldStartDrag(event)) { |
| updateLastEventPosition(event); |
| startDrag(); |
| return true; |
| } |
| break; |
| } |
| |
| return false; |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent event) { |
| if (mIsTouchDisabledForDismissAnimation || mIsTouchDisabledForSuppressLayout) return true; |
| |
| final int action = event.getAction(); |
| |
| if (mVelocityTracker == null) { |
| mVelocityTracker = VelocityTracker.obtain(); |
| } |
| mVelocityTracker.addMovement(event); |
| |
| if (!mIsBeingDragged) { |
| if (shouldStartDrag(event)) { |
| return true; |
| } |
| |
| if (action == MotionEvent.ACTION_UP && mReceivedDown) { |
| mReceivedDown = false; |
| return performClick(); |
| } |
| return true; |
| } |
| |
| switch (action) { |
| case MotionEvent.ACTION_MOVE: |
| final float delta = updatePositionAndComputeDelta(event); |
| scrollTo(0, getScroll() + (int) delta); |
| mReceivedDown = false; |
| |
| if (mIsBeingDragged) { |
| final int distanceFromMaxScrolling = getMaximumScrollUpwards() - getScroll(); |
| if (delta > distanceFromMaxScrolling) { |
| // The ScrollView is being pulled upwards while there is no more |
| // content offscreen, and the view port is already fully expanded. |
| EdgeEffectCompat.onPull(mEdgeGlowBottom, delta / getHeight(), |
| 1 - event.getX() / getWidth()); |
| } |
| |
| if (!mEdgeGlowBottom.isFinished()) { |
| postInvalidateOnAnimation(); |
| } |
| |
| if (shouldDismissOnScroll()) { |
| scrollOffBottom(); |
| } |
| |
| } |
| break; |
| |
| case MotionEvent.ACTION_UP: |
| case MotionEvent.ACTION_CANCEL: |
| stopDrag(action == MotionEvent.ACTION_CANCEL); |
| mReceivedDown = false; |
| break; |
| } |
| |
| return true; |
| } |
| |
| public void setHeaderTintColor(int color) { |
| mHeaderTintColor = color; |
| updatePhotoTintAndDropShadow(); |
| if (CompatUtils.isLollipopCompatible()) { |
| // Use the same amount of alpha on the new tint color as the previous tint color. |
| final int edgeEffectAlpha = Color.alpha(mEdgeGlowBottom.getColor()); |
| mEdgeGlowBottom.setColor((color & 0xffffff) | Color.argb(edgeEffectAlpha, 0, 0, 0)); |
| mEdgeGlowTop.setColor(mEdgeGlowBottom.getColor()); |
| } |
| } |
| |
| /** |
| * Expand to maximum size. |
| */ |
| private void expandHeader() { |
| if (getHeaderHeight() != mMaximumHeaderHeight) { |
| final ObjectAnimator animator = ObjectAnimator.ofInt(this, "headerHeight", |
| mMaximumHeaderHeight); |
| animator.setDuration(ExpandingEntryCardView.DURATION_EXPAND_ANIMATION_CHANGE_BOUNDS); |
| animator.start(); |
| // Scroll nested scroll view to its top |
| if (mScrollView.getScrollY() != 0) { |
| ObjectAnimator.ofInt(mScrollView, "scrollY", -mScrollView.getScrollY()).start(); |
| } |
| } |
| } |
| |
| private void startDrag() { |
| mIsBeingDragged = true; |
| mScroller.abortAnimation(); |
| } |
| |
| private void stopDrag(boolean cancelled) { |
| mIsBeingDragged = false; |
| if (!cancelled && getChildCount() > 0) { |
| final float velocity = getCurrentVelocity(); |
| if (velocity > mMinimumVelocity || velocity < -mMinimumVelocity) { |
| fling(-velocity); |
| onDragFinished(mScroller.getFinalY() - mScroller.getStartY()); |
| } else { |
| onDragFinished(/* flingDelta = */ 0); |
| } |
| } else { |
| onDragFinished(/* flingDelta = */ 0); |
| } |
| |
| if (mVelocityTracker != null) { |
| mVelocityTracker.recycle(); |
| mVelocityTracker = null; |
| } |
| |
| mEdgeGlowBottom.onRelease(); |
| } |
| |
| private void onDragFinished(int flingDelta) { |
| if (getTransparentViewHeight() <= 0) { |
| // Don't perform any snapping if quick contacts is full screen. |
| return; |
| } |
| if (!snapToTopOnDragFinished(flingDelta)) { |
| // The drag/fling won't result in the content at the top of the Window. Consider |
| // snapping the content to the bottom of the window. |
| snapToBottomOnDragFinished(); |
| } |
| } |
| |
| /** |
| * If needed, snap the subviews to the top of the Window. |
| * |
| * @return TRUE if QuickContacts will snap/fling to to top after this method call. |
| */ |
| private boolean snapToTopOnDragFinished(int flingDelta) { |
| if (!mHasEverTouchedTheTop) { |
| // If the current fling is predicted to scroll past the top, then we don't need to snap |
| // to the top. However, if the fling only flings past the top by a tiny amount, |
| // it will look nicer to snap than to fling. |
| final float predictedScrollPastTop = getTransparentViewHeight() - flingDelta; |
| if (predictedScrollPastTop < -mSnapToTopSlopHeight) { |
| return false; |
| } |
| |
| if (getTransparentViewHeight() <= mTransparentStartHeight) { |
| // We are above the starting scroll position so snap to the top. |
| mScroller.forceFinished(true); |
| smoothScrollBy(getTransparentViewHeight()); |
| return true; |
| } |
| return false; |
| } |
| if (getTransparentViewHeight() < mDismissDistanceOnRelease) { |
| mScroller.forceFinished(true); |
| smoothScrollBy(getTransparentViewHeight()); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * If needed, scroll all the subviews off the bottom of the Window. |
| */ |
| private void snapToBottomOnDragFinished() { |
| if (mHasEverTouchedTheTop) { |
| if (getTransparentViewHeight() > mDismissDistanceOnRelease) { |
| scrollOffBottom(); |
| } |
| return; |
| } |
| if (getTransparentViewHeight() > mTransparentStartHeight) { |
| scrollOffBottom(); |
| } |
| } |
| |
| /** |
| * Returns TRUE if we have scrolled far QuickContacts far enough that we should dismiss it |
| * without waiting for the user to finish their drag. |
| */ |
| private boolean shouldDismissOnScroll() { |
| return mHasEverTouchedTheTop && getTransparentViewHeight() > mDismissDistanceOnScroll; |
| } |
| |
| /** |
| * Return ratio of non-transparent:viewgroup-height for this viewgroup at the starting position. |
| */ |
| public float getStartingTransparentHeightRatio() { |
| return getTransparentHeightRatio(mTransparentStartHeight); |
| } |
| |
| private float getTransparentHeightRatio(int transparentHeight) { |
| final float heightRatio = (float) transparentHeight / getHeight(); |
| // Clamp between [0, 1] in case this is called before height is initialized. |
| return 1.0f - Math.max(Math.min(1.0f, heightRatio), 0f); |
| } |
| |
| public void scrollOffBottom() { |
| mIsTouchDisabledForDismissAnimation = true; |
| final Interpolator interpolator = new AcceleratingFlingInterpolator( |
| EXIT_FLING_ANIMATION_DURATION_MS, getCurrentVelocity(), |
| getScrollUntilOffBottom()); |
| mScroller.forceFinished(true); |
| ObjectAnimator translateAnimation = ObjectAnimator.ofInt(this, "scroll", |
| getScroll() - getScrollUntilOffBottom()); |
| translateAnimation.setRepeatCount(0); |
| translateAnimation.setInterpolator(interpolator); |
| translateAnimation.setDuration(EXIT_FLING_ANIMATION_DURATION_MS); |
| translateAnimation.addListener(mSnapToBottomListener); |
| translateAnimation.start(); |
| if (mListener != null) { |
| mListener.onStartScrollOffBottom(); |
| } |
| } |
| |
| /** |
| * @param scrollToCurrentPosition if true, will scroll from the bottom of the screen to the |
| * current position. Otherwise, will scroll from the bottom of the screen to the top of the |
| * screen. |
| */ |
| public void scrollUpForEntranceAnimation(boolean scrollToCurrentPosition) { |
| final int currentPosition = getScroll(); |
| final int bottomScrollPosition = currentPosition |
| - (getHeight() - getTransparentViewHeight()) + 1; |
| final Interpolator interpolator = AnimationUtils.loadInterpolator(getContext(), |
| android.R.interpolator.linear_out_slow_in); |
| final int desiredValue = currentPosition + (scrollToCurrentPosition ? currentPosition |
| : getTransparentViewHeight()); |
| final ObjectAnimator animator = ObjectAnimator.ofInt(this, "scroll", bottomScrollPosition, |
| desiredValue); |
| animator.setInterpolator(interpolator); |
| animator.addUpdateListener(new AnimatorUpdateListener() { |
| @Override |
| public void onAnimationUpdate(ValueAnimator animation) { |
| if (animation.getAnimatedValue().equals(desiredValue) && mListener != null) { |
| mListener.onEntranceAnimationDone(); |
| } |
| } |
| }); |
| animator.start(); |
| } |
| |
| @Override |
| public void scrollTo(int x, int y) { |
| final int delta = y - getScroll(); |
| boolean wasFullscreen = getScrollNeededToBeFullScreen() <= 0; |
| if (delta > 0) { |
| scrollUp(delta); |
| } else { |
| scrollDown(delta); |
| } |
| updatePhotoTintAndDropShadow(); |
| updateHeaderTextSizeAndMargin(); |
| final boolean isFullscreen = getScrollNeededToBeFullScreen() <= 0; |
| mHasEverTouchedTheTop |= isFullscreen; |
| if (mListener != null) { |
| if (wasFullscreen && !isFullscreen) { |
| mListener.onExitFullscreen(); |
| } else if (!wasFullscreen && isFullscreen) { |
| mListener.onEnterFullscreen(); |
| } |
| if (!isFullscreen || !wasFullscreen) { |
| mListener.onTransparentViewHeightChange( |
| getTransparentHeightRatio(getTransparentViewHeight())); |
| } |
| } |
| } |
| |
| /** |
| * Change the height of the header/toolbar. Do *not* use this outside animations. This was |
| * designed for use by {@link #prepareForShrinkingScrollChild}. |
| */ |
| @NeededForReflection |
| public void setToolbarHeight(int delta) { |
| final ViewGroup.LayoutParams toolbarLayoutParams |
| = mToolbar.getLayoutParams(); |
| toolbarLayoutParams.height = delta; |
| mToolbar.setLayoutParams(toolbarLayoutParams); |
| |
| updatePhotoTintAndDropShadow(); |
| updateHeaderTextSizeAndMargin(); |
| } |
| |
| @NeededForReflection |
| public int getToolbarHeight() { |
| return mToolbar.getLayoutParams().height; |
| } |
| |
| /** |
| * Set the height of the toolbar and update its tint accordingly. |
| */ |
| @NeededForReflection |
| public void setHeaderHeight(int height) { |
| final ViewGroup.LayoutParams toolbarLayoutParams |
| = mToolbar.getLayoutParams(); |
| toolbarLayoutParams.height = height; |
| mToolbar.setLayoutParams(toolbarLayoutParams); |
| updatePhotoTintAndDropShadow(); |
| updateHeaderTextSizeAndMargin(); |
| } |
| |
| @NeededForReflection |
| public int getHeaderHeight() { |
| return mToolbar.getLayoutParams().height; |
| } |
| |
| @NeededForReflection |
| public void setScroll(int scroll) { |
| scrollTo(0, scroll); |
| } |
| |
| /** |
| * Returns the total amount scrolled inside the nested ScrollView + the amount of shrinking |
| * performed on the ToolBar. This is the value inspected by animators. |
| */ |
| @NeededForReflection |
| public int getScroll() { |
| return mTransparentStartHeight - getTransparentViewHeight() |
| + getMaximumScrollableHeaderHeight() - getToolbarHeight() |
| + mScrollView.getScrollY(); |
| } |
| |
| private int getMaximumScrollableHeaderHeight() { |
| return mIsOpenContactSquare ? mMaximumHeaderHeight : mIntermediateHeaderHeight; |
| } |
| |
| /** |
| * A variant of {@link #getScroll} that pretends the header is never larger than |
| * than mIntermediateHeaderHeight. This function is sometimes needed when making scrolling |
| * decisions that will not change the header size (ie, snapping to the bottom or top). |
| * |
| * When mIsOpenContactSquare is true, this function considers mIntermediateHeaderHeight == |
| * mMaximumHeaderHeight, since snapping decisions will be made relative the full header |
| * size when mIsOpenContactSquare = true. |
| * |
| * This value should never be used in conjunction with {@link #getScroll} values. |
| */ |
| private int getScroll_ignoreOversizedHeaderForSnapping() { |
| return mTransparentStartHeight - getTransparentViewHeight() |
| + Math.max(getMaximumScrollableHeaderHeight() - getToolbarHeight(), 0) |
| + mScrollView.getScrollY(); |
| } |
| |
| /** |
| * Amount of transparent space above the header/toolbar. |
| */ |
| public int getScrollNeededToBeFullScreen() { |
| return getTransparentViewHeight(); |
| } |
| |
| /** |
| * Return amount of scrolling needed in order for all the visible subviews to scroll off the |
| * bottom. |
| */ |
| private int getScrollUntilOffBottom() { |
| return getHeight() + getScroll_ignoreOversizedHeaderForSnapping() |
| - mTransparentStartHeight; |
| } |
| |
| @Override |
| public void computeScroll() { |
| if (mScroller.computeScrollOffset()) { |
| // Examine the fling results in order to activate EdgeEffect and halt flings. |
| final int oldScroll = getScroll(); |
| scrollTo(0, mScroller.getCurrY()); |
| final int delta = mScroller.getCurrY() - oldScroll; |
| final int distanceFromMaxScrolling = getMaximumScrollUpwards() - getScroll(); |
| if (delta > distanceFromMaxScrolling && distanceFromMaxScrolling > 0) { |
| mEdgeGlowBottom.onAbsorb((int) mScroller.getCurrVelocity()); |
| } |
| if (mIsFullscreenDownwardsFling && getTransparentViewHeight() > 0) { |
| // Halt the fling once QuickContact's top is on screen. |
| scrollTo(0, getScroll() + getTransparentViewHeight()); |
| mEdgeGlowTop.onAbsorb((int) mScroller.getCurrVelocity()); |
| mScroller.abortAnimation(); |
| mIsFullscreenDownwardsFling = false; |
| } |
| if (!awakenScrollBars()) { |
| // Keep on drawing until the animation has finished. |
| postInvalidateOnAnimation(); |
| } |
| if (mScroller.getCurrY() >= getMaximumScrollUpwards()) { |
| // Halt the fling once QuickContact's bottom is on screen. |
| mScroller.abortAnimation(); |
| mIsFullscreenDownwardsFling = false; |
| } |
| } |
| } |
| |
| @Override |
| public void draw(Canvas canvas) { |
| super.draw(canvas); |
| |
| final int width = getWidth() - getPaddingLeft() - getPaddingRight(); |
| final int height = getHeight(); |
| |
| if (!mEdgeGlowBottom.isFinished()) { |
| final int restoreCount = canvas.save(); |
| |
| // Draw the EdgeEffect on the bottom of the Window (Or a little bit below the bottom |
| // of the Window if we start to scroll upwards while EdgeEffect is visible). This |
| // does not need to consider the case where this MultiShrinkScroller doesn't fill |
| // the Window, since the nested ScrollView should be set to fillViewport. |
| canvas.translate(-width + getPaddingLeft(), |
| height + getMaximumScrollUpwards() - getScroll()); |
| |
| canvas.rotate(180, width, 0); |
| if (mIsTwoPanel) { |
| // Only show the EdgeEffect on the bottom of the ScrollView. |
| mEdgeGlowBottom.setSize(mScrollView.getWidth(), height); |
| if (getLayoutDirection() == View.LAYOUT_DIRECTION_RTL) { |
| canvas.translate(mPhotoViewContainer.getWidth(), 0); |
| } |
| } else { |
| mEdgeGlowBottom.setSize(width, height); |
| } |
| if (mEdgeGlowBottom.draw(canvas)) { |
| postInvalidateOnAnimation(); |
| } |
| canvas.restoreToCount(restoreCount); |
| } |
| |
| if (!mEdgeGlowTop.isFinished()) { |
| final int restoreCount = canvas.save(); |
| if (mIsTwoPanel) { |
| mEdgeGlowTop.setSize(mScrollView.getWidth(), height); |
| if (getLayoutDirection() != View.LAYOUT_DIRECTION_RTL) { |
| canvas.translate(mPhotoViewContainer.getWidth(), 0); |
| } |
| } else { |
| mEdgeGlowTop.setSize(width, height); |
| } |
| if (mEdgeGlowTop.draw(canvas)) { |
| postInvalidateOnAnimation(); |
| } |
| canvas.restoreToCount(restoreCount); |
| } |
| } |
| |
| private float getCurrentVelocity() { |
| if (mVelocityTracker == null) { |
| return 0; |
| } |
| mVelocityTracker.computeCurrentVelocity(PIXELS_PER_SECOND, mMaximumVelocity); |
| return mVelocityTracker.getYVelocity(); |
| } |
| |
| private void fling(float velocity) { |
| // For reasons I do not understand, scrolling is less janky when maxY=Integer.MAX_VALUE |
| // then when maxY is set to an actual value. |
| mScroller.fling(0, getScroll(), 0, (int) velocity, 0, 0, -Integer.MAX_VALUE, |
| Integer.MAX_VALUE); |
| if (velocity < 0 && mTransparentView.getHeight() <= 0) { |
| mIsFullscreenDownwardsFling = true; |
| } |
| invalidate(); |
| } |
| |
| private int getMaximumScrollUpwards() { |
| if (!mIsTwoPanel) { |
| return mTransparentStartHeight |
| // How much the Header view can compress |
| + getMaximumScrollableHeaderHeight() - getFullyCompressedHeaderHeight() |
| // How much the ScrollView can scroll. 0, if child is smaller than ScrollView. |
| + Math.max(0, mScrollViewChild.getHeight() - getHeight() |
| + getFullyCompressedHeaderHeight()); |
| } else { |
| return mTransparentStartHeight |
| // How much the ScrollView can scroll. 0, if child is smaller than ScrollView. |
| + Math.max(0, mScrollViewChild.getHeight() - getHeight()); |
| } |
| } |
| |
| private int getTransparentViewHeight() { |
| return mTransparentView.getLayoutParams().height; |
| } |
| |
| private void setTransparentViewHeight(int height) { |
| mTransparentView.getLayoutParams().height = height; |
| mTransparentView.setLayoutParams(mTransparentView.getLayoutParams()); |
| } |
| |
| private void scrollUp(int delta) { |
| if (getTransparentViewHeight() != 0) { |
| final int originalValue = getTransparentViewHeight(); |
| setTransparentViewHeight(getTransparentViewHeight() - delta); |
| setTransparentViewHeight(Math.max(0, getTransparentViewHeight())); |
| delta -= originalValue - getTransparentViewHeight(); |
| } |
| final ViewGroup.LayoutParams toolbarLayoutParams |
| = mToolbar.getLayoutParams(); |
| if (toolbarLayoutParams.height > getFullyCompressedHeaderHeight()) { |
| final int originalValue = toolbarLayoutParams.height; |
| toolbarLayoutParams.height -= delta; |
| toolbarLayoutParams.height = Math.max(toolbarLayoutParams.height, |
| getFullyCompressedHeaderHeight()); |
| mToolbar.setLayoutParams(toolbarLayoutParams); |
| delta -= originalValue - toolbarLayoutParams.height; |
| } |
| mScrollView.scrollBy(0, delta); |
| } |
| |
| /** |
| * Returns the minimum size that we want to compress the header to, given that we don't want to |
| * allow the the ScrollView to scroll unless there is new content off of the edge of ScrollView. |
| */ |
| private int getFullyCompressedHeaderHeight() { |
| return Math.min(Math.max(mToolbar.getLayoutParams().height - getOverflowingChildViewSize(), |
| mMinimumHeaderHeight), getMaximumScrollableHeaderHeight()); |
| } |
| |
| /** |
| * Returns the amount of mScrollViewChild that doesn't fit inside its parent. |
| */ |
| private int getOverflowingChildViewSize() { |
| final int usedScrollViewSpace = mScrollViewChild.getHeight(); |
| return -getHeight() + usedScrollViewSpace + mToolbar.getLayoutParams().height; |
| } |
| |
| private void scrollDown(int delta) { |
| if (mScrollView.getScrollY() > 0) { |
| final int originalValue = mScrollView.getScrollY(); |
| mScrollView.scrollBy(0, delta); |
| delta -= mScrollView.getScrollY() - originalValue; |
| } |
| final ViewGroup.LayoutParams toolbarLayoutParams = mToolbar.getLayoutParams(); |
| if (toolbarLayoutParams.height < getMaximumScrollableHeaderHeight()) { |
| final int originalValue = toolbarLayoutParams.height; |
| toolbarLayoutParams.height -= delta; |
| toolbarLayoutParams.height = Math.min(toolbarLayoutParams.height, |
| getMaximumScrollableHeaderHeight()); |
| mToolbar.setLayoutParams(toolbarLayoutParams); |
| delta -= originalValue - toolbarLayoutParams.height; |
| } |
| setTransparentViewHeight(getTransparentViewHeight() - delta); |
| |
| if (getScrollUntilOffBottom() <= 0) { |
| post(new Runnable() { |
| @Override |
| public void run() { |
| if (mListener != null) { |
| mListener.onScrolledOffBottom(); |
| // No other messages need to be sent to the listener. |
| mListener = null; |
| } |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Set the header size and padding, based on the current scroll position. |
| */ |
| private void updateHeaderTextSizeAndMargin() { |
| if (mIsTwoPanel) { |
| // The text size stays at a constant size & location in two panel layouts. |
| return; |
| } |
| |
| // The pivot point for scaling should be middle of the starting side. |
| if (getLayoutDirection() == View.LAYOUT_DIRECTION_RTL) { |
| mTitleAndPhoneticNameView.setPivotX(mTitleAndPhoneticNameView.getWidth()); |
| } else { |
| mTitleAndPhoneticNameView.setPivotX(0); |
| } |
| mTitleAndPhoneticNameView.setPivotY(mMaximumHeaderTextSize / 2); |
| |
| final int toolbarHeight = mToolbar.getLayoutParams().height; |
| mPhotoTouchInterceptOverlay.setClickable(toolbarHeight != mMaximumHeaderHeight); |
| |
| if (toolbarHeight >= mMaximumHeaderHeight) { |
| // Everything is full size when the header is fully expanded. |
| mTitleAndPhoneticNameView.setScaleX(1); |
| mTitleAndPhoneticNameView.setScaleY(1); |
| setInterpolatedTitleMargins(1); |
| return; |
| } |
| |
| final float ratio = (toolbarHeight - mMinimumHeaderHeight) |
| / (float)(mMaximumHeaderHeight - mMinimumHeaderHeight); |
| final float minimumSize = mInvisiblePlaceholderTextView.getHeight(); |
| float bezierOutput = mTextSizePathInterpolator.getInterpolation(ratio); |
| float scale = (minimumSize + (mMaximumHeaderTextSize - minimumSize) * bezierOutput) |
| / mMaximumHeaderTextSize; |
| |
| // Clamp to reasonable/finite values before passing into framework. The values |
| // can be wacky before the first pre-render. |
| bezierOutput = (float) Math.min(bezierOutput, 1.0f); |
| scale = (float) Math.min(scale, 1.0f); |
| |
| mTitleAndPhoneticNameView.setScaleX(scale); |
| mTitleAndPhoneticNameView.setScaleY(scale); |
| setInterpolatedTitleMargins(bezierOutput); |
| } |
| |
| /** |
| * Calculate the padding around mTitleAndPhoneticNameView so that it will look appropriate once it |
| * finishes moving into its target location/size. |
| */ |
| private void calculateCollapsedLargeTitlePadding() { |
| int invisiblePlaceHolderLocation[] = new int[2]; |
| int largeTextViewRectLocation[] = new int[2]; |
| mInvisiblePlaceholderTextView.getLocationOnScreen(invisiblePlaceHolderLocation); |
| mToolbar.getLocationOnScreen(largeTextViewRectLocation); |
| // Distance between top of toolbar to the center of the target rectangle. |
| final int desiredTopToCenter = invisiblePlaceHolderLocation[1] |
| + mInvisiblePlaceholderTextView.getHeight() / 2 |
| - largeTextViewRectLocation[1]; |
| // Padding needed on the mTitleAndPhoneticNameView so that it has the same amount of |
| // padding as the target rectangle. |
| mCollapsedTitleBottomMargin = |
| desiredTopToCenter - mMaximumHeaderTextSize / 2; |
| } |
| |
| /** |
| * Interpolate the title's margin size. When {@param x}=1, use the maximum title margins. |
| * When {@param x}=0, use the margin values taken from {@link #mInvisiblePlaceholderTextView}. |
| */ |
| private void setInterpolatedTitleMargins(float x) { |
| final FrameLayout.LayoutParams titleLayoutParams |
| = (FrameLayout.LayoutParams) mTitleAndPhoneticNameView.getLayoutParams(); |
| final LinearLayout.LayoutParams toolbarLayoutParams |
| = (LinearLayout.LayoutParams) mToolbar.getLayoutParams(); |
| |
| // Need to add more to margin start if there is a start column |
| int startColumnWidth = mStartColumn == null ? 0 : mStartColumn.getWidth(); |
| |
| titleLayoutParams.setMarginStart((int) (mCollapsedTitleStartMargin * (1 - x) |
| + mMaximumTitleMargin * x) + startColumnWidth); |
| // How offset the title should be from the bottom of the toolbar |
| final int pretendBottomMargin = (int) (mCollapsedTitleBottomMargin * (1 - x) |
| + mMaximumTitleMargin * x) ; |
| // Calculate how offset the title should be from the top of the screen. Instead of |
| // calling mTitleAndPhoneticNameView.getHeight() use the mMaximumHeaderTextSize for this |
| // calculation. The getHeight() value acts unexpectedly when mTitleAndPhoneticNameView is |
| // partially clipped by its parent. |
| titleLayoutParams.topMargin = getTransparentViewHeight() |
| + toolbarLayoutParams.height - pretendBottomMargin |
| - mMaximumHeaderTextSize; |
| titleLayoutParams.bottomMargin = 0; |
| mTitleAndPhoneticNameView.setLayoutParams(titleLayoutParams); |
| } |
| |
| private void updatePhotoTintAndDropShadow() { |
| // Let's keep an eye on how long this method takes to complete. |
| Trace.beginSection("updatePhotoTintAndDropShadow"); |
| |
| if (mIsTwoPanel && !mPhotoView.isBasedOffLetterTile()) { |
| // When in two panel mode, UX considers photo tinting unnecessary for non letter |
| // tile photos. |
| mTitleGradientDrawable.setAlpha(0xFF); |
| mActionBarGradientDrawable.setAlpha(0xFF); |
| return; |
| } |
| |
| // We need to use toolbarLayoutParams to determine the height, since the layout |
| // params can be updated before the height change is reflected inside the View#getHeight(). |
| final int toolbarHeight = getToolbarHeight(); |
| |
| if (toolbarHeight <= mMinimumHeaderHeight && !mIsTwoPanel) { |
| ViewCompat.setElevation(mPhotoViewContainer, mToolbarElevation); |
| } else { |
| ViewCompat.setElevation(mPhotoViewContainer, 0); |
| } |
| |
| // Reuse an existing mColorFilter (to avoid GC pauses) to change the photo's tint. |
| mPhotoView.clearColorFilter(); |
| mColorMatrix.reset(); |
| |
| final int gradientAlpha; |
| if (!mPhotoView.isBasedOffLetterTile()) { |
| // Constants and equations were arbitrarily picked to choose values for saturation, |
| // whiteness, tint and gradient alpha. There were four main objectives: |
| // 1) The transition period between the unmodified image and fully colored image should |
| // be very short. |
| // 2) The tinting should be fully applied even before the background image is fully |
| // faded out and desaturated. Why? A half tinted photo looks bad and results in |
| // unappealing colors. |
| // 3) The function should have a derivative of 0 at ratio = 1 to avoid discontinuities. |
| // 4) The entire process should look awesome. |
| final float ratio = calculateHeightRatioToBlendingStartHeight(toolbarHeight); |
| final float alpha = 1.0f - (float) Math.min(Math.pow(ratio, 1.5f) * 2f, 1f); |
| final float tint = (float) Math.min(Math.pow(ratio, 1.5f) * 3f, 1f); |
| mColorMatrix.setSaturation(alpha); |
| mColorMatrix.postConcat(alphaMatrix(alpha, Color.WHITE)); |
| mColorMatrix.postConcat(multiplyBlendMatrix(mHeaderTintColor, tint)); |
| gradientAlpha = (int) (255 * alpha); |
| } else if (mIsTwoPanel) { |
| mColorMatrix.reset(); |
| mColorMatrix.postConcat(alphaMatrix(DESIRED_INTERMEDIATE_LETTER_TILE_ALPHA, |
| mHeaderTintColor)); |
| gradientAlpha = 0; |
| } else { |
| // We want a function that has DESIRED_INTERMEDIATE_LETTER_TILE_ALPHA value |
| // at the intermediate position and uses TILE_EXPONENT. Finding an equation |
| // that satisfies this condition requires the following arithmetic. |
| final float ratio = calculateHeightRatioToFullyOpen(toolbarHeight); |
| final float intermediateRatio = calculateHeightRatioToFullyOpen((int) |
| (mMaximumPortraitHeaderHeight * INTERMEDIATE_HEADER_HEIGHT_RATIO)); |
| final float TILE_EXPONENT = 3f; |
| final float slowingFactor = (float) ((1 - intermediateRatio) / intermediateRatio |
| / (1 - Math.pow(1 - DESIRED_INTERMEDIATE_LETTER_TILE_ALPHA, 1/TILE_EXPONENT))); |
| float linearBeforeIntermediate = Math.max(1 - (1 - ratio) / intermediateRatio |
| / slowingFactor, 0); |
| float colorAlpha = 1 - (float) Math.pow(linearBeforeIntermediate, TILE_EXPONENT); |
| mColorMatrix.postConcat(alphaMatrix(colorAlpha, mHeaderTintColor)); |
| gradientAlpha = 0; |
| } |
| |
| // TODO: remove re-allocation of ColorMatrixColorFilter objects (b/17627000) |
| mPhotoView.setColorFilter(new ColorMatrixColorFilter(mColorMatrix)); |
| |
| // Tell the photo view what tint we are trying to achieve. Depending on the type of |
| // drawable used, the photo view may or may not use this tint. |
| mPhotoView.setTint(mHeaderTintColor); |
| mTitleGradientDrawable.setAlpha(gradientAlpha); |
| mActionBarGradientDrawable.setAlpha(gradientAlpha); |
| |
| Trace.endSection(); |
| } |
| |
| private float calculateHeightRatioToFullyOpen(int height) { |
| return (height - mMinimumPortraitHeaderHeight) |
| / (float) (mMaximumPortraitHeaderHeight - mMinimumPortraitHeaderHeight); |
| } |
| |
| private float calculateHeightRatioToBlendingStartHeight(int height) { |
| final float intermediateHeight = mMaximumPortraitHeaderHeight |
| * COLOR_BLENDING_START_RATIO; |
| final float interpolatingHeightRange = intermediateHeight - mMinimumPortraitHeaderHeight; |
| if (height > intermediateHeight) { |
| return 0; |
| } |
| return (intermediateHeight - height) / interpolatingHeightRange; |
| } |
| |
| /** |
| * Simulates alpha blending an image with {@param color}. |
| */ |
| private ColorMatrix alphaMatrix(float alpha, int color) { |
| mAlphaMatrixValues[0] = Color.red(color) * alpha / 255; |
| mAlphaMatrixValues[6] = Color.green(color) * alpha / 255; |
| mAlphaMatrixValues[12] = Color.blue(color) * alpha / 255; |
| mAlphaMatrixValues[4] = 255 * (1 - alpha); |
| mAlphaMatrixValues[9] = 255 * (1 - alpha); |
| mAlphaMatrixValues[14] = 255 * (1 - alpha); |
| mWhitenessColorMatrix.set(mAlphaMatrixValues); |
| return mWhitenessColorMatrix; |
| } |
| |
| /** |
| * Simulates multiply blending an image with a single {@param color}. |
| * |
| * Multiply blending is [Sa * Da, Sc * Dc]. See {@link android.graphics.PorterDuff}. |
| */ |
| private ColorMatrix multiplyBlendMatrix(int color, float alpha) { |
| mMultiplyBlendMatrixValues[0] = multiplyBlend(Color.red(color), alpha); |
| mMultiplyBlendMatrixValues[6] = multiplyBlend(Color.green(color), alpha); |
| mMultiplyBlendMatrixValues[12] = multiplyBlend(Color.blue(color), alpha); |
| mMultiplyBlendMatrix.set(mMultiplyBlendMatrixValues); |
| return mMultiplyBlendMatrix; |
| } |
| |
| private float multiplyBlend(int color, float alpha) { |
| return color * alpha / 255.0f + (1 - alpha); |
| } |
| |
| private void updateLastEventPosition(MotionEvent event) { |
| mLastEventPosition[0] = event.getX(); |
| mLastEventPosition[1] = event.getY(); |
| } |
| |
| private boolean motionShouldStartDrag(MotionEvent event) { |
| final float deltaY = event.getY() - mLastEventPosition[1]; |
| return deltaY > mTouchSlop || deltaY < -mTouchSlop; |
| } |
| |
| private float updatePositionAndComputeDelta(MotionEvent event) { |
| final int VERTICAL = 1; |
| final float position = mLastEventPosition[VERTICAL]; |
| updateLastEventPosition(event); |
| float elasticityFactor = 1; |
| if (position < mLastEventPosition[VERTICAL] && mHasEverTouchedTheTop) { |
| // As QuickContacts is dragged from the top of the window, its rate of movement will |
| // slow down in proportion to its distance from the top. This will feel springy. |
| elasticityFactor += mTransparentView.getHeight() * SPRING_DAMPENING_FACTOR; |
| } |
| return (position - mLastEventPosition[VERTICAL]) / elasticityFactor; |
| } |
| |
| private void smoothScrollBy(int delta) { |
| if (delta == 0) { |
| // Delta=0 implies the code calling smoothScrollBy is sloppy. We should avoid doing |
| // this, since it prevents Views from being able to register any clicks for 250ms. |
| throw new IllegalArgumentException("Smooth scrolling by delta=0 is " |
| + "pointless and harmful"); |
| } |
| mScroller.startScroll(0, getScroll(), 0, delta); |
| invalidate(); |
| } |
| |
| /** |
| * Interpolator that enforces a specific starting velocity. This is useful to avoid a |
| * discontinuity between dragging speed and flinging speed. |
| * |
| * Similar to a {@link android.view.animation.AccelerateInterpolator} in the sense that |
| * getInterpolation() is a quadratic function. |
| */ |
| private class AcceleratingFlingInterpolator implements Interpolator { |
| |
| private final float mStartingSpeedPixelsPerFrame; |
| private final float mDurationMs; |
| private final int mPixelsDelta; |
| private final float mNumberFrames; |
| |
| public AcceleratingFlingInterpolator(int durationMs, float startingSpeedPixelsPerSecond, |
| int pixelsDelta) { |
| mStartingSpeedPixelsPerFrame = startingSpeedPixelsPerSecond / getRefreshRate(); |
| mDurationMs = durationMs; |
| mPixelsDelta = pixelsDelta; |
| mNumberFrames = mDurationMs / getFrameIntervalMs(); |
| } |
| |
| @Override |
| public float getInterpolation(float input) { |
| final float animationIntervalNumber = mNumberFrames * input; |
| final float linearDelta = (animationIntervalNumber * mStartingSpeedPixelsPerFrame) |
| / mPixelsDelta; |
| // Add the results of a linear interpolator (with the initial speed) with the |
| // results of a AccelerateInterpolator. |
| if (mStartingSpeedPixelsPerFrame > 0) { |
| return Math.min(input * input + linearDelta, 1); |
| } else { |
| // Initial fling was in the wrong direction, make sure that the quadratic component |
| // grows faster in order to make up for this. |
| return Math.min(input * (input - linearDelta) + linearDelta, 1); |
| } |
| } |
| |
| private float getRefreshRate() { |
| final DisplayManager displayManager = (DisplayManager) MultiShrinkScroller |
| .this.getContext().getSystemService(Context.DISPLAY_SERVICE); |
| return displayManager.getDisplay(Display.DEFAULT_DISPLAY).getRefreshRate(); |
| } |
| |
| public long getFrameIntervalMs() { |
| return (long)(1000 / getRefreshRate()); |
| } |
| } |
| |
| /** |
| * Expand the header if the mScrollViewChild is about to shrink by enough to create new empty |
| * space at the bottom of this ViewGroup. |
| */ |
| public void prepareForShrinkingScrollChild(int heightDelta) { |
| final int newEmptyScrollViewSpace = -getOverflowingChildViewSize() + heightDelta; |
| if (newEmptyScrollViewSpace > 0 && !mIsTwoPanel) { |
| final int newDesiredToolbarHeight = Math.min(getToolbarHeight() |
| + newEmptyScrollViewSpace, getMaximumScrollableHeaderHeight()); |
| ObjectAnimator.ofInt(this, "toolbarHeight", newDesiredToolbarHeight).setDuration( |
| ExpandingEntryCardView.DURATION_COLLAPSE_ANIMATION_CHANGE_BOUNDS).start(); |
| } |
| } |
| |
| /** |
| * If {@param areTouchesDisabled} is TRUE, ignore all of the user's touches. |
| */ |
| public void setDisableTouchesForSuppressLayout(boolean areTouchesDisabled) { |
| // The card expansion animation uses the Transition framework's ChangeBounds API. This |
| // invokes suppressLayout(true) on the MultiShrinkScroller. As a result, we need to avoid |
| // all layout changes during expansion in order to avoid weird layout artifacts. |
| mIsTouchDisabledForSuppressLayout = areTouchesDisabled; |
| } |
| } |
