Pinch to zoom out into overview mode.

There are 3 classes coordinating the gesture: PinchToOverviewListener,
PinchThresholdManager, and PinchAnimationManager.
- PTOL listens for the pinch gesture on DragLayer.
- When a pinch is detected, the PTOL keeps track of the interpolated
  progress and passes it along to both the PTM and PAM.
- The PTM uses the progress to determine whether a new threshold has
  been passed, and tells the PAM to animate it if so.
- The PAM uses the progress to animate things like workspace scale
  throughout the pinch.
- If the pinch ends early, the PTOL uses the last passed threshold to
  determine whether to animate to workspace or overview, and tells
  PAM to perform the animation at the same velocity as the pinch.

Bug: 24414635
Change-Id: I9e53706c705f8b2982409bf7c223d8d0e9618bf0

1 files changed, 285 insertions, 0 deletions

diff --git a/src/com/android/launcher3/PinchAnimationManager.java b/src/com/android/launcher3/PinchAnimationManager.java
new file mode 100644
index 000000000..3302cb652
--- /dev/null
+++ b/src/com/android/launcher3/PinchAnimationManager.java
@@ -0,0 +1,285 @@
+package com.android.launcher3;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.animation.ValueAnimator;
+import android.util.Log;
+import android.view.View;
+
+import static com.android.launcher3.Workspace.State.NORMAL;
+import static com.android.launcher3.Workspace.State.OVERVIEW;
+
+/**
+ * Manages the animations that play as the user pinches to/from overview mode.
+ *
+ *  It will look like this pinching in:
+ * - Workspace scales down
+ * - At some threshold 1, hotseat and QSB fade out (full animation)
+ * - At a later threshold 2, panel buttons fade in and scrim fades in
+ * - At a final threshold 3, snap to overview
+ *
+ * Pinching out:
+ * - Workspace scales up
+ * - At threshold 1, panel buttons fade out
+ * - At threshold 2, hotseat and QSB fade in and scrim fades out
+ * - At threshold 3, snap to workspace
+ *
+ * @see PinchToOverviewListener
+ * @see PinchThresholdManager
+ */
+public class PinchAnimationManager {
+    private static final String TAG = "PinchAnimationManager";
+
+    private static final int THRESHOLD_ANIM_DURATION = 150;
+
+    private Launcher mLauncher;
+    private Workspace mWorkspace;
+
+    private float mOverviewScale;
+    private float mOverviewTranslationY;
+    private int mNormalOverviewTransitionDuration;
+    private final int[] mVisiblePageRange = new int[2];
+    private boolean mIsAnimating;
+
+    // Animators
+    private Animator mShowPageIndicatorAnimator;
+    private Animator mShowHotseatAnimator;
+    private Animator mShowOverviewPanelButtonsAnimator;
+    private Animator mShowScrimAnimator;
+    private Animator mHidePageIndicatorAnimator;
+    private Animator mHideHotseatAnimator;
+    private Animator mHideOverviewPanelButtonsAnimator;
+    private Animator mHideScrimAnimator;
+
+    public PinchAnimationManager(Launcher launcher) {
+        mLauncher = launcher;
+        mWorkspace = launcher.mWorkspace;
+
+        mOverviewScale = mWorkspace.getOverviewModeShrinkFactor();
+        mOverviewTranslationY = mWorkspace.getOverviewModeTranslationY();
+        mNormalOverviewTransitionDuration = mWorkspace.getStateTransitionAnimation()
+                .mOverviewTransitionTime;
+
+        initializeAnimators();
+    }
+
+    private void initializeAnimators() {
+        mShowPageIndicatorAnimator = new LauncherViewPropertyAnimator(
+                mWorkspace.getPageIndicator()).alpha(1f).withLayer();
+        mShowPageIndicatorAnimator.setInterpolator(null);
+
+        mShowHotseatAnimator = new LauncherViewPropertyAnimator(mLauncher.getHotseat())
+                .alpha(1f).withLayer();
+        mShowHotseatAnimator.setInterpolator(null);
+
+        mShowOverviewPanelButtonsAnimator = new LauncherViewPropertyAnimator(
+                mLauncher.getOverviewPanel()).alpha(1f).withLayer();
+        mShowOverviewPanelButtonsAnimator.setInterpolator(null);
+
+        mShowScrimAnimator = ObjectAnimator.ofFloat(mLauncher.getDragLayer(), "backgroundAlpha",
+                mWorkspace.getStateTransitionAnimation().mWorkspaceScrimAlpha);
+        mShowScrimAnimator.setInterpolator(null);
+
+        mHidePageIndicatorAnimator = new LauncherViewPropertyAnimator(
+                mWorkspace.getPageIndicator()).alpha(0f).withLayer();
+        mHidePageIndicatorAnimator.setInterpolator(null);
+        mHidePageIndicatorAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                if (mWorkspace.getPageIndicator() != null) {
+                    mWorkspace.getPageIndicator().setVisibility(View.INVISIBLE);
+                }
+            }
+        });
+
+        mHideHotseatAnimator = new LauncherViewPropertyAnimator(mLauncher.getHotseat())
+                .alpha(0f).withLayer();
+        mHideHotseatAnimator.setInterpolator(null);
+        mHideHotseatAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mLauncher.getHotseat().setVisibility(View.INVISIBLE);
+            }
+        });
+
+        mHideOverviewPanelButtonsAnimator = new LauncherViewPropertyAnimator(
+                mLauncher.getOverviewPanel()).alpha(0f).withLayer();
+        mHideOverviewPanelButtonsAnimator.setInterpolator(null);
+        mHideOverviewPanelButtonsAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mLauncher.getOverviewPanel().setVisibility(View.INVISIBLE);
+            }
+        });
+
+        mHideScrimAnimator = ObjectAnimator.ofFloat(mLauncher.getDragLayer(), "backgroundAlpha", 0f);
+        mHideScrimAnimator.setInterpolator(null);
+    }
+
+    public int getNormalOverviewTransitionDuration() {
+        return mNormalOverviewTransitionDuration;
+    }
+
+    /**
+     * Interpolate from {@param currentProgress} to {@param toProgress}, calling
+     * {@link #setAnimationProgress(float)} throughout the duration. If duration is -1,
+     * the default overview transition duration is used.
+     */
+    public void animateToProgress(float currentProgress, float toProgress, int duration,
+            final PinchThresholdManager thresholdManager) {
+        if (duration == -1) {
+            duration = mNormalOverviewTransitionDuration;
+        }
+        ValueAnimator animator = ValueAnimator.ofFloat(currentProgress, toProgress);
+        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+               @Override
+               public void onAnimationUpdate(ValueAnimator animation) {
+                   float pinchProgress = (Float) animation.getAnimatedValue();
+                   setAnimationProgress(pinchProgress);
+                   thresholdManager.updateAndAnimatePassedThreshold(pinchProgress,
+                           PinchAnimationManager.this);
+               }
+           }
+        );
+        animator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mIsAnimating = false;
+                thresholdManager.reset();
+            }
+        });
+        animator.setDuration(duration).start();
+        mIsAnimating = true;
+    }
+
+    public boolean isAnimating() {
+        return mIsAnimating;
+    }
+
+    /**
+     * Animates to the specified progress. This should be called repeatedly throughout the pinch
+     * gesture to run animations that interpolate throughout the gesture.
+     * @param interpolatedProgress The progress from 0 to 1, where 0 is overview and 1 is workspace.
+     */
+    public void setAnimationProgress(float interpolatedProgress) {
+        float interpolatedScale = interpolatedProgress * (1f - mOverviewScale) + mOverviewScale;
+        float interpolatedTranslationY = (1f - interpolatedProgress) * mOverviewTranslationY;
+        mWorkspace.setScaleX(interpolatedScale);
+        mWorkspace.setScaleY(interpolatedScale);
+        mWorkspace.setTranslationY(interpolatedTranslationY);
+        setOverviewPanelsAlpha(1f - interpolatedProgress, 0);
+
+        // Make sure adjacent pages, except custom content page, are visible while scaling.
+        mWorkspace.setCustomContentVisibility(View.INVISIBLE);
+        mWorkspace.invalidate();
+    }
+
+    /**
+     * Animates certain properties based on which threshold was passed, and in what direction. The
+     * starting state must also be taken into account because the thresholds mean different things
+     * when going from workspace to overview and vice versa.
+     * @param threshold One of {@link PinchThresholdManager#THRESHOLD_ONE},
+     *                  {@link PinchThresholdManager#THRESHOLD_TWO}, or
+     *                  {@link PinchThresholdManager#THRESHOLD_THREE}
+     * @param startState {@link Workspace.State#NORMAL} or {@link Workspace.State#OVERVIEW}.
+     * @param goingTowards {@link Workspace.State#NORMAL} or {@link Workspace.State#OVERVIEW}.
+ *                     Note that this doesn't have to be the opposite of startState;
+     */
+    public void animateThreshold(float threshold, Workspace.State startState,
+            Workspace.State goingTowards) {
+        if (threshold == PinchThresholdManager.THRESHOLD_ONE) {
+            if (startState == OVERVIEW) {
+                animateOverviewPanelButtons(goingTowards == OVERVIEW);
+            } else if (startState == NORMAL) {
+                animateHotseatAndPageIndicator(goingTowards == NORMAL);
+                animateQsb(goingTowards == NORMAL);
+            }
+        } else if (threshold == PinchThresholdManager.THRESHOLD_TWO) {
+            if (startState == OVERVIEW) {
+                animateHotseatAndPageIndicator(goingTowards == NORMAL);
+                animateQsb(goingTowards == NORMAL);
+                animateScrim(goingTowards == OVERVIEW);
+            } else if (startState == NORMAL) {
+                animateOverviewPanelButtons(goingTowards == OVERVIEW);
+                animateScrim(goingTowards == OVERVIEW);
+            }
+        } else if (threshold == PinchThresholdManager.THRESHOLD_THREE) {
+            // Passing threshold 3 ends the pinch and snaps to the new state.
+            if (startState == OVERVIEW && goingTowards == NORMAL) {
+                mLauncher.showWorkspace(true);
+                mWorkspace.snapToPage(mWorkspace.getPageNearestToCenterOfScreen());
+            } else if (startState == NORMAL && goingTowards == OVERVIEW) {
+                mLauncher.showOverviewMode(true);
+            }
+        } else {
+            Log.e(TAG, "Received unknown threshold to animate: " + threshold);
+        }
+    }
+
+    private void setOverviewPanelsAlpha(float alpha, int duration) {
+        mWorkspace.getVisiblePages(mVisiblePageRange);
+        for (int i = mVisiblePageRange[0]; i <= mVisiblePageRange[1]; i++) {
+            View page = mWorkspace.getPageAt(i);
+            if (!mWorkspace.shouldDrawChild(page)) {
+                continue;
+            }
+            if (duration == 0) {
+                ((CellLayout) page).setBackgroundAlpha(alpha);
+            } else {
+                ObjectAnimator.ofFloat(page, "backgroundAlpha", alpha)
+                        .setDuration(duration).start();
+            }
+        }
+    }
+
+    private void animateHotseatAndPageIndicator(boolean show) {
+        if (show) {
+            mLauncher.getHotseat().setVisibility(View.VISIBLE);
+            mShowHotseatAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
+            if (mWorkspace.getPageIndicator() != null) {
+                // There aren't page indicators in landscape mode on phones, hence the null check.
+                mWorkspace.getPageIndicator().setVisibility(View.VISIBLE);
+                mShowPageIndicatorAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
+            }
+        } else {
+            mHideHotseatAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
+            if (mWorkspace.getPageIndicator() != null) {
+                // There aren't page indicators in landscape mode on phones, hence the null check.
+                mHidePageIndicatorAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
+            }
+        }
+    }
+
+    private void animateQsb(boolean show) {
+        SearchDropTargetBar.State searchBarState = show ? SearchDropTargetBar.State.SEARCH_BAR
+                : SearchDropTargetBar.State.INVISIBLE;
+        mLauncher.getSearchDropTargetBar().animateToState(searchBarState, THRESHOLD_ANIM_DURATION);
+    }
+
+    private void animateOverviewPanelButtons(boolean show) {
+        if (show) {
+            mLauncher.getOverviewPanel().setVisibility(View.VISIBLE);
+            mShowOverviewPanelButtonsAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
+        } else {
+            mHideOverviewPanelButtonsAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
+        }
+    }
+
+    private void animateScrim(boolean show) {
+        // We reninitialize the animators here so that they have the correct start values.
+        if (show) {
+            mShowScrimAnimator = ObjectAnimator.ofFloat(mLauncher.getDragLayer(), "backgroundAlpha",
+                    mWorkspace.getStateTransitionAnimation().mWorkspaceScrimAlpha);
+            mShowScrimAnimator.setInterpolator(null);
+            mShowScrimAnimator.setDuration(mNormalOverviewTransitionDuration).start();
+        } else {
+            mHideScrimAnimator.setupStartValues();
+            mHideScrimAnimator = ObjectAnimator.ofFloat(mLauncher.getDragLayer(), "backgroundAlpha",
+                    0f);
+            mHideScrimAnimator.setInterpolator(null);
+            mHideScrimAnimator.setDuration(mNormalOverviewTransitionDuration).start();
+            mHideScrimAnimator.setDuration(mNormalOverviewTransitionDuration).start();
+        }
+    }
+}