Making the reordering play nice with the 3D widget carousel

-> Ensuring that transforms, hidden side pages, alphas all transition
   and fade seamlessly to and from the carousel

Change-Id: I6197f17899135a9e551ff1691c63ad5a2bb1d0f7

Author: Adam Cohen

policy/src/com/android/internal/policy/impl/keyguard/KeyguardHostView.java

@@ -162,6 +162,7 @@ protected void onFinishInflate() {
 
         addDefaultWidgets();
         addWidgetsFromSettings();
+        mSwitchPageRunnable.run();
 
         mViewStateManager = new KeyguardViewStateManager();
         SlidingChallengeLayout slider =
@@ -217,7 +218,6 @@ void setLockPatternUtils(LockPatternUtils utils) {
     protected void onAttachedToWindow() {
         super.onAttachedToWindow();
         mAppWidgetHost.startListening();
-        post(mSwitchPageRunnable);
     }
 
     @Override

policy/src/com/android/internal/policy/impl/keyguard/KeyguardViewStateManager.java

@@ -86,6 +86,14 @@ public void showBouncer(boolean show) {
         mChallengeLayout.showBouncer();
     }
 
+    public void fadeOutSecurity(int duration) {
+        ((View) mKeyguardSecurityContainer).animate().alpha(0).setDuration(duration);
+    }
+
+    public void fadeInSecurity(int duration) {
+        ((View) mKeyguardSecurityContainer).animate().alpha(1f).setDuration(duration);
+    }
+
     public void onPageSwitch(View newPage, int newPageIndex) {
         // Reset the previous page size and ensure the current page is sized appropriately.
         // We only modify the page state if it is not currently under control by the slider.

policy/src/com/android/internal/policy/impl/keyguard/KeyguardWidgetCarousel.java

@@ -15,9 +15,19 @@
  */
 package com.android.internal.policy.impl.keyguard;
 
+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.View;
+import android.view.animation.AccelerateInterpolator;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
+
+import java.util.ArrayList;
 
 import com.android.internal.R;
 
@@ -26,6 +36,8 @@ public class KeyguardWidgetCarousel extends KeyguardWidgetPager {
     private float mAdjacentPagesAngle;
     private static float MAX_SCROLL_PROGRESS = 1.3f;
     private static float CAMERA_DISTANCE = 10000;
+    protected AnimatorSet mChildrenTransformsAnimator;
+    float[] mTmpTransform = new float[3];
 
     public KeyguardWidgetCarousel(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
@@ -48,13 +60,15 @@ public float getAlphaForPage(int screenCenter, int index) {
         View child = getChildAt(index);
         if (child == null) return 0f;
 
+        float maxAlpha = KeyguardWidgetFrame.OUTLINE_ALPHA_MULTIPLIER;
+
         float scrollProgress = getScrollProgress(screenCenter, child, index);
         if (!isOverScrollChild(index, scrollProgress)) {
             scrollProgress = getBoundedScrollProgress(screenCenter, child, index);
-            float alpha = 1 - Math.abs(scrollProgress / MAX_SCROLL_PROGRESS);
+            float alpha = maxAlpha - maxAlpha * Math.abs(scrollProgress / MAX_SCROLL_PROGRESS);
             return alpha;
         } else {
-            return 1f;
+            return maxAlpha;
         }
     }
 
@@ -73,34 +87,33 @@ private void updatePageAlphaValues(int screenCenter) {
                 }
             }
         }
-
     }
 
     @Override
     protected void screenScrolled(int screenCenter) {
         mScreenCenter = screenCenter;
         updatePageAlphaValues(screenCenter);
+        if (isReordering(false)) return;
         for (int i = 0; i < getChildCount(); i++) {
             KeyguardWidgetFrame v = getWidgetPageAt(i);
             float scrollProgress = getScrollProgress(screenCenter, v, i);
+            float boundedProgress = getBoundedScrollProgress(screenCenter, v, i);
             if (v == mDragView || v == null) continue;
             v.setCameraDistance(CAMERA_DISTANCE);
 
             if (isOverScrollChild(i, scrollProgress)) {
                 v.setRotationY(- OVERSCROLL_MAX_ROTATION * scrollProgress);
                 v.setOverScrollAmount(Math.abs(scrollProgress), scrollProgress < 0);
             } else {
-                scrollProgress = getBoundedScrollProgress(screenCenter, v, i);
                 int width = v.getMeasuredWidth();
-                float pivotX = (width / 2f) + scrollProgress * (width / 2f);
+                float pivotX = (width / 2f) + boundedProgress * (width / 2f);
                 float pivotY = v.getMeasuredHeight() / 2;
-                float rotationY = - mAdjacentPagesAngle * scrollProgress;
+                float rotationY = - mAdjacentPagesAngle * boundedProgress;
                 v.setPivotX(pivotX);
                 v.setPivotY(pivotY);
                 v.setRotationY(rotationY);
                 v.setOverScrollAmount(0f, false);
             }
-
             float alpha = v.getAlpha();
             // If the view has 0 alpha, we set it to be invisible so as to prevent
             // it from accepting touches
@@ -111,4 +124,137 @@ protected void screenScrolled(int screenCenter) {
             }
         }
     }
+
+    void animatePagesToNeutral() {
+        if (mChildrenTransformsAnimator != null) {
+            mChildrenTransformsAnimator.cancel();
+            mChildrenTransformsAnimator = null;
+        }
+
+        int count = getChildCount();
+        PropertyValuesHolder alpha;
+        PropertyValuesHolder outlineAlpha;
+        PropertyValuesHolder rotationY;
+        ArrayList<Animator> anims = new ArrayList<Animator>();
+
+        for (int i = 0; i < count; i++) {
+            KeyguardWidgetFrame child = getWidgetPageAt(i);
+            boolean inVisibleRange = (i >= mCurrentPage - 1 && i <= mCurrentPage + 1);
+            if (!inVisibleRange) {
+                child.setRotationY(0f);
+            }
+            alpha = PropertyValuesHolder.ofFloat("contentAlpha", 1.0f);
+            outlineAlpha = PropertyValuesHolder.ofFloat("backgroundAlpha", 1.0f);
+            rotationY = PropertyValuesHolder.ofFloat("rotationY", 0f);
+            ObjectAnimator a = ObjectAnimator.ofPropertyValuesHolder(child, alpha, outlineAlpha, rotationY);
+            child.setVisibility(VISIBLE);
+            if (!inVisibleRange) {
+                a.setInterpolator(mSlowFadeInterpolator);
+            }
+            anims.add(a);
+        }
+
+        int duration = REORDERING_ZOOM_IN_OUT_DURATION;
+        mChildrenTransformsAnimator = new AnimatorSet();
+        mChildrenTransformsAnimator.playTogether(anims);
+
+        mChildrenTransformsAnimator.setDuration(duration);
+        mChildrenTransformsAnimator.start();
+    }
+
+    private void getTransformForPage(int screenCenter, int index, float[] transform) {
+        View child = getChildAt(index);
+        float boundedProgress = getBoundedScrollProgress(screenCenter, child, index);
+        float rotationY = - mAdjacentPagesAngle * boundedProgress;
+        int width = child.getMeasuredWidth();
+        float pivotX = (width / 2f) + boundedProgress * (width / 2f);
+        float pivotY = child.getMeasuredHeight() / 2;
+
+        transform[0] = pivotX;
+        transform[1] = pivotY;
+        transform[2] = rotationY;
+    }
+
+    Interpolator mFastFadeInterpolator = new Interpolator() {
+        Interpolator mInternal = new DecelerateInterpolator(1.5f);
+        float mFactor = 2.5f;
+        @Override
+        public float getInterpolation(float input) {
+            return mInternal.getInterpolation(Math.min(mFactor * input, 1f));
+        }
+    };
+
+    Interpolator mSlowFadeInterpolator = new Interpolator() {
+        Interpolator mInternal = new AccelerateInterpolator(1.5f);
+        float mFactor = 1.3f;
+        @Override
+        public float getInterpolation(float input) {
+            input -= (1 - 1 / mFactor);
+            input = mFactor * Math.max(input, 0f);
+            return mInternal.getInterpolation(input);
+        }
+    };
+
+    void animatePagesToCarousel() {
+        if (mChildrenTransformsAnimator != null) {
+            mChildrenTransformsAnimator.cancel();
+            mChildrenTransformsAnimator = null;
+        }
+
+        int count = getChildCount();
+        PropertyValuesHolder alpha;
+        PropertyValuesHolder outlineAlpha;
+        PropertyValuesHolder rotationY;
+        PropertyValuesHolder pivotX;
+        PropertyValuesHolder pivotY;
+        ArrayList<Animator> anims = new ArrayList<Animator>();
+
+        for (int i = 0; i < count; i++) {
+            KeyguardWidgetFrame child = getWidgetPageAt(i);
+            float finalAlpha = getAlphaForPage(mScreenCenter, i);
+            getTransformForPage(mScreenCenter, i, mTmpTransform);
+
+            boolean inVisibleRange = (i >= mCurrentPage - 1 && i <= mCurrentPage + 1);
+
+            ObjectAnimator a;
+            alpha = PropertyValuesHolder.ofFloat("contentAlpha", finalAlpha);
+            outlineAlpha = PropertyValuesHolder.ofFloat("backgroundAlpha", finalAlpha);
+            pivotX = PropertyValuesHolder.ofFloat("pivotX", mTmpTransform[0]);
+            pivotY = PropertyValuesHolder.ofFloat("pivotY", mTmpTransform[1]);
+            rotationY = PropertyValuesHolder.ofFloat("rotationY", mTmpTransform[2]);
+
+            if (inVisibleRange) {
+                // for the central pages we animate into a rotated state
+                a = ObjectAnimator.ofPropertyValuesHolder(child, alpha, outlineAlpha,
+                        pivotX, pivotY, rotationY);
+            } else {
+                a = ObjectAnimator.ofPropertyValuesHolder(child, alpha, outlineAlpha);
+                a.setInterpolator(mFastFadeInterpolator);
+            }
+            anims.add(a);
+        }
+
+        int duration = REORDERING_ZOOM_IN_OUT_DURATION;
+        mChildrenTransformsAnimator = new AnimatorSet();
+        mChildrenTransformsAnimator.playTogether(anims);
+
+        mChildrenTransformsAnimator.setDuration(duration);
+        mChildrenTransformsAnimator.start();
+    }
+
+    protected void reorderStarting() {
+        mViewStateManager.fadeOutSecurity(REORDERING_ZOOM_IN_OUT_DURATION);
+        animatePagesToNeutral();
+    }
+
+    protected boolean zoomIn(final Runnable onCompleteRunnable) {
+        animatePagesToCarousel();
+        return super.zoomIn(onCompleteRunnable);
+    }
+
+    @Override
+    protected void onEndReordering() {
+        super.onEndReordering();
+        mViewStateManager.fadeInSecurity(REORDERING_ZOOM_IN_OUT_DURATION);
+    }
 }