🏠 Separate bottom sheet current from target state

chrome/android/java/src/org/chromium/chrome/browser/widget/bottomsheet/BottomSheet.java

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.widget.bottomsheet;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.ValueAnimator;
 import android.content.Context;
@@ skipping 35 matching lines @@
  * - HALF: The sheet is expanded to consume around half of the screen.
  * - FULL: The sheet is expanded to its full height.
  *
  * All the computation in this file is based off of the bottom of the screen instead of the top
  * for simplicity. This means that the bottom of the screen is 0 on the Y axis.
  */
 
 public class BottomSheet
         extends FrameLayout implements FadingBackgroundView.FadingViewObserver, NativePageHost {
     /** The different states that the bottom sheet can have. */
-    @IntDef({SHEET_STATE_PEEK, SHEET_STATE_HALF, SHEET_STATE_FULL})
+    @IntDef({SHEET_STATE_PEEK, SHEET_STATE_HALF, SHEET_STATE_FULL, SHEET_STATE_SCROLLING})
     @Retention(RetentionPolicy.SOURCE)
     public @interface SheetState {}
     public static final int SHEET_STATE_PEEK = 0;
     public static final int SHEET_STATE_HALF = 1;
     public static final int SHEET_STATE_FULL = 2;
+    public static final int SHEET_STATE_SCROLLING = 3;
 
     /**
      * The base duration of the settling animation of the sheet. 218 ms is a spec for material
      * design (this is the minimum time a user is guaranteed to pay attention to something).
      */
     private static final long BASE_ANIMATION_DURATION_MS = 218;
 
     /**
      * The fraction of the way to the next state the sheet must be swiped to animate there when
      * released. A smaller value here means a smaller swipe is needed to move the sheet around.
@@ skipping 34 matching lines @@
 
     /** The height of the toolbar. */
     private float mToolbarHeight;
 
     /** The width of the view that contains the bottom sheet. */
     private float mContainerWidth;
 
     /** The height of the view that contains the bottom sheet. */
     private float mContainerHeight;
 
-    /** The current sheet state. If the sheet is moving, this will be the target state. */
+    /** The current state that the sheet is in. */
     private int mCurrentState;
 
+    /** The target sheet state. This is the state that the sheet is currently moving to. */
+    private int mTargetState;
+
     /** Used for getting the current tab. */
     private TabModelSelector mTabModelSelector;
 
     /** The fullscreen manager for information about toolbar offsets. */
     private ChromeFullscreenManager mFullscreenManager;
 
     /** A handle to the content being shown by the sheet. */
     private BottomSheetContent mSheetContent;
 
     /** A handle to the toolbar control container. */
@@ skipping 112 matching lines @@
 
             // Similarly, if the sheet is in the min position, don't move if the scroll is downward.
             if (currentShownRatio <= getPeekRatio() && distanceY < 0) {
                 mIsScrolling = false;
                 return false;
             }
 
             float newOffset = getSheetOffsetFromBottom() + distanceY;
             setSheetOffsetFromBottom(MathUtils.clamp(newOffset, getMinOffset(), getMaxOffset()));
 
+            setInternalCurrentState(SHEET_STATE_SCROLLING);
             mIsScrolling = true;
             return true;
         }
 
         @Override
         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
             cancelAnimation();
 
             // Figure out the projected state of the sheet and animate there. Note that a swipe up
             // will have a negative velocity, swipe down will have a positive velocity. Negate this
@@ skipping 120 matching lines @@
                 // Make sure the size of the layout actually changed.
                 if (bottom - top == oldBottom - oldTop && right - left == oldRight - oldLeft) {
                     return;
                 }
 
                 mContainerWidth = right - left;
                 mContainerHeight = bottom - top;
                 updateSheetDimensions();
 
                 cancelAnimation();
-                setSheetState(mCurrentState, false);
+                setSheetState(mTargetState, false);
             }
         });
 
         // Listen to height changes on the toolbar.
         controlContainer.addOnLayoutChangeListener(new View.OnLayoutChangeListener() {
             @Override
             public void onLayoutChange(View v, int left, int top, int right, int bottom,
                     int oldLeft, int oldTop, int oldRight, int oldBottom) {
                 // Make sure the size of the layout actually changed.
                 if (bottom - top == oldBottom - oldTop && right - left == oldRight - oldLeft) {
                     return;
                 }
 
                 mToolbarHeight = bottom - top;
                 updateSheetDimensions();
 
                 cancelAnimation();
-                setSheetState(mCurrentState, false);
+                setSheetState(mTargetState, false);
             }
         });
 
         mPlaceholder = new View(getContext());
         LayoutParams placeHolderParams =
                 new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
         mPlaceholder.setBackgroundColor(
                 ApiCompatibilityUtils.getColor(getResources(), android.R.color.white));
         mBottomSheetContentContainer.addView(mPlaceholder, placeHolderParams);
 
@@ skipping 182 matching lines @@
         if (mSettleAnimator == null) return;
         mSettleAnimator.cancel();
         mSettleAnimator = null;
     }
 
     /**
      * Creates the sheet's animation to a target state.
      * @param targetState The target state.
      */
     private void createSettleAnimation(@SheetState int targetState) {
-        mCurrentState = targetState;
+        mTargetState = targetState;
         mSettleAnimator = ValueAnimator.ofFloat(
                 getSheetOffsetFromBottom(), getSheetHeightForState(targetState));
         mSettleAnimator.setDuration(BASE_ANIMATION_DURATION_MS);
         mSettleAnimator.setInterpolator(mInterpolator);
 
         // When the animation is canceled or ends, reset the handle to null.
         mSettleAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animator) {
                 mSettleAnimator = null;
+                setInternalCurrentState(mTargetState);
             }
         });
 
         mSettleAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
             @Override
             public void onAnimationUpdate(ValueAnimator animator) {
                 setSheetOffsetFromBottom((Float) animator.getAnimatedValue());
             }
         });
 
         mSettleAnimator.start();
+        setInternalCurrentState(SHEET_STATE_SCROLLING);
     }
 
     /**
      * Gets the distance of a fling based on the velocity and the base animation time. This formula
      * assumes the deceleration curve is quadratic (t^2), hence the displacement formula should be:
      * displacement = initialVelocity * duration / 2.
      * @param velocity The velocity of the fling.
      * @return The distance the fling would cover.
      */
     private float getFlingDistance(float velocity) {
@@ skipping 94 matching lines @@
         if (mLastPeekToHalfRatioSent < 1f || peekHalfRatio < 1f) {
             mLastPeekToHalfRatioSent = peekHalfRatio;
             for (BottomSheetObserver o : mObservers) {
                 o.onTransitionPeekToHalf(peekHalfRatio);
             }
         }
     }
 
     /**
      * Moves the sheet to the provided state.
-     * @param state The state to move the panel to.
+     * @param state The state to move the panel to. This cannot be SHEET_STATE_SCROLLING.
      * @param animate If true, the sheet will animate to the provided state, otherwise it will
      *                move there instantly.
      */
     public void setSheetState(@SheetState int state, boolean animate) {
-        boolean stateChanged = state != mCurrentState;
-        mCurrentState = state;
+        assert state != SHEET_STATE_SCROLLING;
+        mTargetState = state;
 
         if (animate) {
             createSettleAnimation(state);
         } else {
             setSheetOffsetFromBottom(getSheetHeightForState(state));
-        }
-
-        if (!stateChanged) return;
-
-        for (BottomSheetObserver o : mObservers) {
-            o.onSheetStateChanged(mCurrentState);
+            setInternalCurrentState(mTargetState);
         }
     }
 
     /**
      * @return The current state of the bottom sheet. If the sheet is animating, this will be the
      *         state the sheet is animating to.
      */
     public int getSheetState() {
         return mCurrentState;
     }
 
     /**
+     * Set the current state of the bottom sheet. This is for internal use to notify observers of
+     * state change events.
+     * @param state The current state of the sheet.
+     */
+    private void setInternalCurrentState(@SheetState int state) {
+        boolean stateChanged = state != mCurrentState;
+        mCurrentState = state;
+
+        if (!stateChanged) return;

[Theresa, 2017/03/21 23:07:01]

This early return can move up:

if (state == mCurrentState) return;

mCurrentState = state;
for (BottomSheetObserver o...

[mdjones, 2017/03/21 23:32:42]

Done.

+
+        for (BottomSheetObserver o : mObservers) {
+            o.onSheetStateChanged(mCurrentState);
+        }
+    }
+
+    /**
      * If the animation to settle the sheet in one of its states is running.
      * @return True if the animation is running.
      */
     public boolean isRunningSettleAnimation() {
         return mSettleAnimator != null;
     }
 
     @VisibleForTesting
     public BottomSheetContent getCurrentSheetContent() {
         return mSheetContent;
@@ skipping 67 matching lines @@
     @Override
     public void onFadingViewVisibilityChanged(boolean visible) {}
 
     private boolean canMoveSheet() {
         boolean isInOverviewMode = mTabModelSelector != null
                 && (mTabModelSelector.getCurrentTab() == null
                            || mTabModelSelector.getCurrentTab().getActivity().isInOverviewMode());
         return !isToolbarAndroidViewHidden() && !isInOverviewMode;
     }
 }