Make infobars hide on scroll

chrome/android/java/src/org/chromium/chrome/browser/banners/SwipableOverlayView.java

 // Copyright 2014 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.banners;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
 import android.animation.PropertyValuesHolder;
 import android.content.Context;
 import android.util.AttributeSet;
 import android.view.GestureDetector;
 import android.view.GestureDetector.SimpleOnGestureListener;
 import android.view.Gravity;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.animation.DecelerateInterpolator;
 import android.view.animation.Interpolator;
 import android.widget.FrameLayout;
+import android.widget.ScrollView;
 
+import org.chromium.chrome.browser.EmptyTabObserver;
+import org.chromium.chrome.browser.Tab;
+import org.chromium.chrome.browser.TabObserver;
 import org.chromium.content.browser.ContentViewCore;
 import org.chromium.content_public.browser.GestureStateListener;
 import org.chromium.ui.UiUtils;
 
 /**
  * View that appears on the screen as the user scrolls on the page and can be swiped away.
  * Meant to be tacked onto the {@link org.chromium.content.browser.ContentViewCore}'s view and
  * alerted when either the page scroll position or viewport size changes.
  *
  * GENERAL BEHAVIOR
@@ skipping 26 matching lines @@
  * horizontally (with "enough" defined by the DISMISS_SWIPE_THRESHOLD AND DISMISS_FLING_THRESHOLD)
  * triggers an animation that removes the View from the hierarchy.  Failing to meet the threshold
  * will result in the View being translated back to the center of the screen.
  *
  * Because the fling velocity handed in by Android is highly inaccurate and often indicates
  * that a fling is moving in an opposite direction than expected, the scroll direction is tracked
  * to determine which direction the user was dragging the View when the fling was initiated.  When a
  * fling is completed, the more forgiving FLING_THRESHOLD is used to determine how far a user must
  * swipe to dismiss the View rather than try to use the fling velocity.
  */
-public abstract class SwipableOverlayView extends FrameLayout {
+public abstract class SwipableOverlayView extends ScrollView {
     private static final float ALPHA_THRESHOLD = 0.25f;
     private static final float DISMISS_SWIPE_THRESHOLD = 0.75f;
     private static final float FULL_THRESHOLD = 0.5f;
     private static final float VERTICAL_FLING_SHOW_THRESHOLD = 0.2f;
     private static final float VERTICAL_FLING_HIDE_THRESHOLD = 0.9f;
+    private static final long REATTACH_FADE_IN_MS = 250;
     protected static final float ZERO_THRESHOLD = 0.001f;
 
     private static final int GESTURE_NONE = 0;
     private static final int GESTURE_SCROLLING = 1;
     private static final int GESTURE_FLINGING = 2;
 
     private static final int DRAGGED_LEFT = -1;
     private static final int DRAGGED_CANCEL = 0;
     private static final int DRAGGED_RIGHT = 1;
 
     protected static final long MS_ANIMATION_DURATION = 250;
     private static final long MS_DISMISS_FLING_THRESHOLD = MS_ANIMATION_DURATION * 2;
     private static final long MS_SLOW_DISMISS = MS_ANIMATION_DURATION * 3;
 
+    /** Resets the state of the SwipableOverlayView, as needed. */
+    protected class SwipableOverlayViewTabObserver extends EmptyTabObserver {
+        @Override
+        public void onDidNavigateMainFrame(Tab tab, String url, String baseUrl,
+                boolean isNavigationToDifferentPage, boolean isFragmentNavigation,
+                int statusCode) {
+            setDoStayInvisible(false);
+        }
+    }
+
     // Detects when the user is dragging the View.
     private final GestureDetector mGestureDetector;
 
     // Detects when the user is dragging the ContentViewCore.
     private final GestureStateListener mGestureStateListener;
 
+    // Listens for changes in the layout.
+    private final View.OnLayoutChangeListener mLayoutChangeListener;
+
     // Monitors for animation completions and resets the state.
     private final AnimatorListenerAdapter mAnimatorListenerAdapter;
 
     // Interpolator used for the animation.
     private final Interpolator mInterpolator;
 
+    // Observes the Tab.
+    private final TabObserver mTabObserver;
+
     // Tracks whether the user is scrolling or flinging.
     private int mGestureState;
 
     // Animation currently being used to translate the View.
     private AnimatorSet mCurrentAnimation;
 
     // Direction the user is horizontally dragging.
     private int mDragDirection;
 
     // How quickly the user is horizontally dragging.
@@ skipping 16 matching lines @@
 
     // Whether or not the View ever been fully displayed.
     private boolean mIsBeingDisplayedForFirstTime;
 
     // Whether or not the View has been, or is being, dismissed.
     private boolean mIsDismissed;
 
     // The ContentViewCore to which the overlay is added.
     private ContentViewCore mContentViewCore;
 
+    // Keeps the View from becoming visible when it normally would.
+    private boolean mDoStayInvisible;
+
+    // Whether the View should be allowed to be swiped away.
+    private boolean mIsSwipable = true;
+
     /**
      * Creates a SwipableOverlayView.
      * @param context Context for acquiring resources.
      * @param attrs Attributes from the XML layout inflation.
      */
     public SwipableOverlayView(Context context, AttributeSet attrs) {
         super(context, attrs);
         SimpleOnGestureListener gestureListener = createGestureListener();
         mGestureDetector = new GestureDetector(context, gestureListener);
         mGestureStateListener = createGestureStateListener();
         mGestureState = GESTURE_NONE;
+        mLayoutChangeListener = createLayoutChangeListener();
         mAnimatorListenerAdapter = createAnimatorListenerAdapter();
         mInterpolator = new DecelerateInterpolator(1.0f);
+        mTabObserver = createTabObserver();
     }
 
     /**
-     * Adds this View to the given ContentViewCore's view.
-     * @param layout Layout to add this View to.
+     * Indicates whether the View should be allowed to be swiped away.
+     * @param swipable Whether the View is reacts to horizontal gestures.
      */
-    protected void addToView(ContentViewCore contentViewCore) {
-        assert mContentViewCore == null;
-        mContentViewCore = contentViewCore;
-        contentViewCore.getContainerView().addView(this, 0, createLayoutParams());
-        contentViewCore.addGestureStateListener(mGestureStateListener);
-
-        // Listen for the layout to know when to animate the View coming onto the screen.
-        addOnLayoutChangeListener(createLayoutChangeListener());
+    protected void setIsSwipable(boolean swipable) {
+        mIsSwipable = swipable;
     }
 
     /**
+     * Watches the given ContentViewCore for scrolling changes.
+     */
+    public void setContentViewCore(ContentViewCore contentViewCore) {
+        if (mContentViewCore != null) {
+            mContentViewCore.removeGestureStateListener(mGestureStateListener);
+        }
+
+        mContentViewCore = contentViewCore;
+        if (mContentViewCore != null) {
+            mContentViewCore.addGestureStateListener(mGestureStateListener);
+        }
+    }
+
+    public void addToParentView(ViewGroup parentView) {
+        if (parentView != null && parentView.indexOfChild(this) == -1) {
+            parentView.addView(this, createLayoutParams());
+
+            // Listen for the layout to know when to animate the View coming onto the screen.
+            addOnLayoutChangeListener(mLayoutChangeListener);
+        }
+    }
+
+    /**
+     * Removes the SwipableOverlayView from its parent and stops monitoring the ContentViewCore.
+     * @return Whether the View was removed from its parent.
+     */
+    public boolean removeFromParentView() {
+        if (getParent() == null) return false;
+
+        ((ViewGroup) getParent()).removeView(this);
+        removeOnLayoutChangeListener(mLayoutChangeListener);
+        return true;
+    }
+
+    /**
      * Creates a set of LayoutParams that makes the View hug the bottom of the screen.  Override it
      * for other types of behavior.
      * @return LayoutParams for use when adding the View to its parent.
      */
-    protected ViewGroup.MarginLayoutParams createLayoutParams() {
+    public ViewGroup.MarginLayoutParams createLayoutParams() {
         return new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT,
                 Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL);
     }
 
     /**
-     * Removes the View from its parent.
+     * Call with {@code true} when a higher priority bottom element is visible to keep the View
+     * from ever becoming visible.  Call with {@code false} to restore normal visibility behavior.
+     * @param doStayInvisible Whether the View should stay invisible even when they would
+     *        normally become visible.
      */
-    boolean removeFromParent() {
-        if (mContentViewCore != null) {
-            mContentViewCore.getContainerView().removeView(this);
-            mContentViewCore = null;
-            return true;
+    public void setDoStayInvisible(boolean doStayInvisible) {
+        mDoStayInvisible = doStayInvisible;
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        if (!mDoStayInvisible) {
+            ObjectAnimator.ofFloat(this, "alpha", 0.f, 1.f).setDuration(REATTACH_FADE_IN_MS)
+                    .start();
+            setVisibility(VISIBLE);
         }
-        return false;
     }
 
     /**
+     * @return TabObserver that can be used to monitor a Tab.
+     */
+    protected TabObserver createTabObserver() {
+        return new SwipableOverlayViewTabObserver();
+    }
+
+    /**
+     * @return TabObserver that is used to monitor a Tab.
+     */
+    public TabObserver getTabObserver() {
+        return mTabObserver;
+    }
+
+    /**
      * See {@link #android.view.ViewGroup.onLayout(boolean, int, int, int, int)}.
      */
     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         // Hide the View when the keyboard is showing.
-        boolean keyboardIsShowing = UiUtils.isKeyboardShowing(getContext(), this);
-        setVisibility(keyboardIsShowing ? INVISIBLE : VISIBLE);
+        boolean isShowing = (getVisibility() == View.VISIBLE);
+        if (UiUtils.isKeyboardShowing(getContext(), this)) {
+            if (isShowing) {
+                setVisibility(View.INVISIBLE);
+            }
+        } else {
+            if (!isShowing && !mDoStayInvisible) {
+                setVisibility(View.VISIBLE);
+            }
+        }
 
         // Update the viewport height when the parent View's height changes (e.g. after rotation).
         int currentParentHeight = getParent() == null ? 0 : ((View) getParent()).getHeight();
         if (mParentHeight != currentParentHeight) {
             mParentHeight = currentParentHeight;
             mGestureState = GESTURE_NONE;
             if (mCurrentAnimation != null) mCurrentAnimation.end();
         }
 
         // Update the known effective height of the View.
         mTotalHeight = getMeasuredHeight();
         if (getLayoutParams() instanceof MarginLayoutParams) {
             MarginLayoutParams params = (MarginLayoutParams) getLayoutParams();
             mTotalHeight += params.topMargin + params.bottomMargin;
         }
 
         super.onLayout(changed, l, t, r, b);
     }
 
     /**
      * See {@link #android.view.View.onTouchEvent(MotionEvent)}.
      */
     @Override
     public boolean onTouchEvent(MotionEvent event) {
+        if (!mIsSwipable) return false;
+
         if (mGestureDetector.onTouchEvent(event)) return true;
         if (mCurrentAnimation != null) return true;
 
         int action = event.getActionMasked();
         if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
             onFinishHorizontalGesture();
             return true;
         }
         return false;
     }
@@ skipping 153 matching lines @@
 
     /**
      * Creates a listener that is used only to animate the View coming onto the screen.
      * @return The SimpleOnGestureListener that will monitor the View.
      */
     private View.OnLayoutChangeListener createLayoutChangeListener() {
         return 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) {
-                removeOnLayoutChangeListener(this);
+                removeOnLayoutChangeListener(mLayoutChangeListener);
 
                 // Animate the View coming in from the bottom of the screen.
                 setTranslationY(mTotalHeight);
                 mIsBeingDisplayedForFirstTime = true;
                 createVerticalSnapAnimation(true);
                 mCurrentAnimation.start();
             }
         };
     }
 
@@ skipping 148 matching lines @@
     }
 
     /**
      * Creates an AnimatorListenerAdapter that cleans up after an animation is completed.
      * @return {@link AnimatorListenerAdapter} to use for animations.
      */
     private AnimatorListenerAdapter createAnimatorListenerAdapter() {
         return new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
-                if (mIsDismissed) removeFromParent();
+                if (mIsDismissed) removeFromParentView();
 
                 mGestureState = GESTURE_NONE;
                 mCurrentAnimation = null;
                 mIsBeingDisplayedForFirstTime = false;
             }
         };
     }
 
     /**
      * Records the conditions of the page when a gesture is initiated.
@@ skipping 32 matching lines @@
     /**
      * Called when the View has been clicked.
      */
     protected abstract void onViewClicked();
 
     /**
      * Called when the View needs to show that it's been pressed.
      */
     protected abstract void onViewPressed(MotionEvent event);
 }