From 742574b15b2b5298a2328443176f2890fb8ebe98 Mon Sep 17 00:00:00 2001 From: Michael Jurka Date: Wed, 2 Feb 2011 23:51:01 -0800 Subject: optimizing transitions in Launcher Bug #3413510 Change-Id: I89896b40b73d781255f9c0263300e9c5716d4efc --- src/com/android/launcher2/CellLayout.java | 16 ++ src/com/android/launcher2/Launcher.java | 86 ++++++---- src/com/android/launcher2/PagedViewIcon.java | 7 +- src/com/android/launcher2/Workspace.java | 229 +++++++++++++++++++-------- 4 files changed, 244 insertions(+), 94 deletions(-) (limited to 'src/com/android') diff --git a/src/com/android/launcher2/CellLayout.java b/src/com/android/launcher2/CellLayout.java index b27770c25..6691e6447 100644 --- a/src/com/android/launcher2/CellLayout.java +++ b/src/com/android/launcher2/CellLayout.java @@ -803,6 +803,10 @@ public class CellLayout extends ViewGroup { return mBackgroundAlpha; } + public void setFastBackgroundAlpha(float alpha) { + mBackgroundAlpha = alpha; + } + public void setBackgroundAlphaMultiplier(float multiplier) { mBackgroundAlphaMultiplier = multiplier; } @@ -829,6 +833,11 @@ public class CellLayout extends ViewGroup { super.setAlpha(alpha); } + public void setFastAlpha(float alpha) { + setFastChildrenAlpha(alpha); + super.setFastAlpha(alpha); + } + private void setChildrenAlpha(float alpha) { final int childCount = getChildCount(); for (int i = 0; i < childCount; i++) { @@ -836,6 +845,13 @@ public class CellLayout extends ViewGroup { } } + private void setFastChildrenAlpha(float alpha) { + final int childCount = getChildCount(); + for (int i = 0; i < childCount; i++) { + getChildAt(i).setFastAlpha(alpha); + } + } + public View getChildAt(int x, int y) { return mChildren.getChildAt(x, y); } diff --git a/src/com/android/launcher2/Launcher.java b/src/com/android/launcher2/Launcher.java index 7e69681eb..a3b35dd7c 100644 --- a/src/com/android/launcher2/Launcher.java +++ b/src/com/android/launcher2/Launcher.java @@ -17,13 +17,10 @@ package com.android.launcher2; -import java.io.DataInputStream; -import java.io.DataOutputStream; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; +import com.android.common.Search; +import com.android.launcher.R; +import com.android.launcher2.CustomizePagedView.CustomizationType; +import com.android.launcher2.Workspace.ShrinkState; import android.animation.Animator; import android.animation.AnimatorListenerAdapter; @@ -31,6 +28,7 @@ import android.animation.AnimatorSet; import android.animation.ObjectAnimator; import android.animation.PropertyValuesHolder; import android.animation.ValueAnimator; +import android.animation.ValueAnimator.AnimatorUpdateListener; import android.app.Activity; import android.app.AlertDialog; import android.app.Dialog; @@ -106,10 +104,13 @@ import android.widget.Toast; import android.widget.TabHost.OnTabChangeListener; import android.widget.TabHost.TabContentFactory; -import com.android.common.Search; -import com.android.launcher.R; -import com.android.launcher2.CustomizePagedView.CustomizationType; -import com.android.launcher2.Workspace.ShrinkState; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; /** @@ -2674,22 +2675,36 @@ public final class Launcher extends Activity } if (animated) { - ValueAnimator scaleAnim = ObjectAnimator.ofPropertyValuesHolder(toView, - PropertyValuesHolder.ofFloat("scaleX", scale, 1.0f), - PropertyValuesHolder.ofFloat("scaleY", scale, 1.0f)); + final float oldScaleX = toView.getScaleX(); + final float oldScaleY = toView.getScaleY(); - scaleAnim.setDuration(duration); + ValueAnimator scaleAnim = ValueAnimator.ofFloat(0f, 1f).setDuration(duration); + scaleAnim.setInterpolator(new Workspace.ZoomOutInterpolator()); + scaleAnim.addUpdateListener(new AnimatorUpdateListener() { + public void onAnimationUpdate(ValueAnimator animation) { + final float b = (Float) animation.getAnimatedValue(); + final float a = 1f - b; + ((View) toView.getParent()).fastInvalidate(); + toView.setFastScaleX(a * oldScaleX + b * 1f); + toView.setFastScaleY(a * oldScaleY + b * 1f); + } + }); if (toAllApps) { toView.setAlpha(0f); - ObjectAnimator alphaAnim = ObjectAnimator.ofPropertyValuesHolder(toView, - PropertyValuesHolder.ofFloat("alpha", 1.0f)); + ValueAnimator alphaAnim = ValueAnimator.ofFloat(0f, 1f).setDuration(duration); alphaAnim.setInterpolator(new DecelerateInterpolator(1.0f)); - alphaAnim.setDuration(duration); + alphaAnim.addUpdateListener(new AnimatorUpdateListener() { + public void onAnimationUpdate(ValueAnimator animation) { + final float b = (Float) animation.getAnimatedValue(); + final float a = 1f - b; + // don't need to invalidate because we do so above + toView.setFastAlpha(a * 0f + b * 1f); + } + }); alphaAnim.start(); } - scaleAnim.setInterpolator(new Workspace.ZoomOutInterpolator()); // Only use hardware layers in portrait mode, they don't give any gains in landscape if (mWorkspace.getWidth() < mWorkspace.getHeight()) { toView.setLayerType(View.LAYER_TYPE_HARDWARE, null); @@ -2760,7 +2775,7 @@ public final class Launcher extends Activity res.getInteger(R.integer.config_allAppsZoomOutTime) : res.getInteger(R.integer.config_customizeZoomOutTime); - float scaleFactor = fromAllApps ? + final float scaleFactor = fromAllApps ? (float) res.getInteger(R.integer.config_allAppsZoomScaleFactor) : (float) res.getInteger(R.integer.config_customizeZoomScaleFactor); @@ -2778,16 +2793,33 @@ public final class Launcher extends Activity if (animated) { if (mStateAnimation != null) mStateAnimation.cancel(); mStateAnimation = new AnimatorSet(); - ValueAnimator scaleAnim = ObjectAnimator.ofPropertyValuesHolder(fromView, - PropertyValuesHolder.ofFloat("scaleX", scaleFactor), - PropertyValuesHolder.ofFloat("scaleY", scaleFactor)); - scaleAnim.setDuration(duration); - scaleAnim.setInterpolator(new Workspace.ZoomInInterpolator()); - ValueAnimator alphaAnim = ObjectAnimator.ofPropertyValuesHolder(fromView, - PropertyValuesHolder.ofFloat("alpha", 1.0f, 0.0f)); + final float oldScaleX = fromView.getScaleX(); + final float oldScaleY = fromView.getScaleY(); + + ValueAnimator scaleAnim = ValueAnimator.ofFloat(0f, 1f).setDuration(duration); + scaleAnim.setInterpolator(new Workspace.ZoomInInterpolator()); + scaleAnim.addUpdateListener(new AnimatorUpdateListener() { + public void onAnimationUpdate(ValueAnimator animation) { + final float b = (Float) animation.getAnimatedValue(); + final float a = 1f - b; + ((View)fromView.getParent()).fastInvalidate(); + fromView.setFastScaleX(a * oldScaleX + b * scaleFactor); + fromView.setFastScaleY(a * oldScaleY + b * scaleFactor); + } + }); + ValueAnimator alphaAnim = ValueAnimator.ofFloat(0f, 1f); alphaAnim.setDuration(res.getInteger(R.integer.config_allAppsFadeOutTime)); alphaAnim.setInterpolator(new DecelerateInterpolator(2.0f)); + alphaAnim.addUpdateListener(new AnimatorUpdateListener() { + public void onAnimationUpdate(ValueAnimator animation) { + final float b = (Float) animation.getAnimatedValue(); + final float a = 1f - b; + // don't need to invalidate because we do so above + fromView.setFastAlpha(a * 1f + b * 0f); + } + }); + fromView.setLayerType(View.LAYER_TYPE_HARDWARE, null); alphaAnim.addListener(new AnimatorListenerAdapter() { @Override diff --git a/src/com/android/launcher2/PagedViewIcon.java b/src/com/android/launcher2/PagedViewIcon.java index 702e227d5..ca67d2f42 100644 --- a/src/com/android/launcher2/PagedViewIcon.java +++ b/src/com/android/launcher2/PagedViewIcon.java @@ -16,6 +16,8 @@ package com.android.launcher2; +import com.android.launcher.R; + import android.animation.ObjectAnimator; import android.content.Context; import android.content.pm.PackageManager; @@ -30,8 +32,7 @@ import android.os.HandlerThread; import android.os.Message; import android.util.AttributeSet; import android.widget.Checkable; - -import com.android.launcher.R; +import android.widget.TextView; @@ -39,7 +40,7 @@ import com.android.launcher.R; * An icon on a PagedView, specifically for items in the launcher's paged view (with compound * drawables on the top). */ -public class PagedViewIcon extends CachedTextView implements Checkable { +public class PagedViewIcon extends TextView implements Checkable { private static final String TAG = "PagedViewIcon"; // holographic outline diff --git a/src/com/android/launcher2/Workspace.java b/src/com/android/launcher2/Workspace.java index f37ac1f62..42a746ae6 100644 --- a/src/com/android/launcher2/Workspace.java +++ b/src/com/android/launcher2/Workspace.java @@ -1363,24 +1363,24 @@ public class Workspace extends SmoothPagedView float totalWidth = screenCount * scaledPageWidth + (screenCount - 1) * extraScaledSpacing; boolean isPortrait = getMeasuredHeight() > getMeasuredWidth(); - float newY = (isPortrait ? + float y = (isPortrait ? getResources().getDimension(R.dimen.allAppsSmallScreenVerticalMarginPortrait) : getResources().getDimension(R.dimen.allAppsSmallScreenVerticalMarginLandscape)); float finalAlpha = 1.0f; float extraShrinkFactor = 1.0f; if (shrinkState == ShrinkState.BOTTOM_VISIBLE) { - newY = screenHeight - newY - scaledPageHeight; + y = screenHeight - y - scaledPageHeight; } else if (shrinkState == ShrinkState.BOTTOM_HIDDEN) { // We shrink and disappear to nothing in the case of all apps // (which is when we shrink to the bottom) - newY = screenHeight - newY - scaledPageHeight; + y = screenHeight - y - scaledPageHeight; finalAlpha = 0.0f; } else if (shrinkState == ShrinkState.MIDDLE) { - newY = screenHeight / 2 - scaledPageHeight / 2; + y = screenHeight / 2 - scaledPageHeight / 2; finalAlpha = 1.0f; } else if (shrinkState == ShrinkState.TOP) { - newY = (isPortrait ? + y = (isPortrait ? getResources().getDimension(R.dimen.customizeSmallScreenVerticalMarginPortrait) : getResources().getDimension(R.dimen.customizeSmallScreenVerticalMarginLandscape)); } @@ -1396,18 +1396,34 @@ public class Workspace extends SmoothPagedView // At the same time, the screens become greyed/dimmed // newX is initialized to the left-most position of the centered screens - float newX = mScroller.getFinalX() + screenWidth / 2 - totalWidth / 2; + float x = mScroller.getFinalX() + screenWidth / 2 - totalWidth / 2; // We are going to scale about the center of the view, so we need to adjust the positions // of the views accordingly - newX -= (pageWidth - scaledPageWidth) / 2.0f; - newY -= (pageHeight - scaledPageHeight) / 2.0f; + x -= (pageWidth - scaledPageWidth) / 2.0f; + y -= (pageHeight - scaledPageHeight) / 2.0f; if (mAnimator != null) { mAnimator.cancel(); } mAnimator = new AnimatorSet(); + + final float[] oldXs = new float[getChildCount()]; + final float[] oldYs = new float[getChildCount()]; + final float[] oldScaleXs = new float[getChildCount()]; + final float[] oldScaleYs = new float[getChildCount()]; + final float[] oldBackgroundAlphas = new float[getChildCount()]; + final float[] oldAlphas = new float[getChildCount()]; + final float[] oldRotationYs = new float[getChildCount()]; + final float[] newXs = new float[getChildCount()]; + final float[] newYs = new float[getChildCount()]; + final float[] newScaleXs = new float[getChildCount()]; + final float[] newScaleYs = new float[getChildCount()]; + final float[] newBackgroundAlphas = new float[getChildCount()]; + final float[] newAlphas = new float[getChildCount()]; + final float[] newRotationYs = new float[getChildCount()]; + for (int i = 0; i < screenCount; i++) { final CellLayout cl = (CellLayout) getChildAt(i); @@ -1415,33 +1431,33 @@ public class Workspace extends SmoothPagedView float rotationScaleX = (float) (1.0f / Math.cos(Math.PI * rotation / 180.0f)); float rotationScaleY = getYScaleForScreen(i); - if (animated) { - ObjectAnimator animWithInterpolator = ObjectAnimator.ofPropertyValuesHolder(cl, - PropertyValuesHolder.ofFloat("x", newX), - PropertyValuesHolder.ofFloat("y", newY), - PropertyValuesHolder.ofFloat("scaleX", - SHRINK_FACTOR * rotationScaleX * extraShrinkFactor), - PropertyValuesHolder.ofFloat("scaleY", - SHRINK_FACTOR * rotationScaleY * extraShrinkFactor), - PropertyValuesHolder.ofFloat("backgroundAlpha", finalAlpha), - PropertyValuesHolder.ofFloat("alpha", finalAlpha), - PropertyValuesHolder.ofFloat("rotationY", rotation)); - - animWithInterpolator.setDuration(duration); - animWithInterpolator.setInterpolator(mZoomOutInterpolator); - mAnimator.playTogether(animWithInterpolator); + oldAlphas[i] = cl.getAlpha(); + newAlphas[i] = finalAlpha; + if (animated && !(oldAlphas[i] == 0f && newAlphas[i] == 0f)) { + oldXs[i] = cl.getX(); + oldYs[i] = cl.getY(); + oldScaleXs[i] = cl.getScaleX(); + oldScaleYs[i] = cl.getScaleY(); + oldBackgroundAlphas[i] = cl.getBackgroundAlpha(); + oldRotationYs[i] = cl.getRotationY(); + newXs[i] = x; + newYs[i] = y; + newScaleXs[i] = SHRINK_FACTOR * rotationScaleX * extraShrinkFactor; + newScaleYs[i] = SHRINK_FACTOR * rotationScaleY * extraShrinkFactor; + newBackgroundAlphas[i] = finalAlpha; + newRotationYs[i] = rotation; } else { - cl.setX((int)newX); - cl.setY((int)newY); + cl.setX((int)x); + cl.setY((int)y); cl.setScaleX(SHRINK_FACTOR * rotationScaleX * extraShrinkFactor); cl.setScaleY(SHRINK_FACTOR * rotationScaleY * extraShrinkFactor); cl.setBackgroundAlpha(finalAlpha); cl.setAlpha(finalAlpha); cl.setRotationY(rotation); - mShrinkAnimationListener.onAnimationEnd(null); + if (!animated) mShrinkAnimationListener.onAnimationEnd(null); } // increment newX for the next screen - newX += scaledPageWidth + extraScaledSpacing; + x += scaledPageWidth + extraScaledSpacing; } float wallpaperOffset = 0.5f; @@ -1471,21 +1487,46 @@ public class Workspace extends SmoothPagedView break; } + setLayoutScale(1.0f); if (animated) { mWallpaperOffset.setHorizontalCatchupConstant(0.46f); mWallpaperOffset.setOverrideHorizontalCatchupConstant(true); - } - setLayoutScale(1.0f); - if (animated) { mSyncWallpaperOffsetWithScroll = false; - ObjectAnimator wallpaperAnim = ObjectAnimator.ofPropertyValuesHolder(this, - PropertyValuesHolder.ofFloat("verticalWallpaperOffset", wallpaperOffset), - PropertyValuesHolder.ofFloat("horizontalWallpaperOffset", 0.5f)); - mAnimator.play(wallpaperAnim); - wallpaperAnim.setDuration(duration); - wallpaperAnim.setInterpolator(mZoomOutInterpolator); + ValueAnimator animWithInterpolator = + ValueAnimator.ofFloat(0f, 1f).setDuration(duration); + animWithInterpolator.setInterpolator(mZoomOutInterpolator); + + final float oldHorizontalWallpaperOffset = getHorizontalWallpaperOffset(); + final float oldVerticalWallpaperOffset = getVerticalWallpaperOffset(); + final float newHorizontalWallpaperOffset = 0.5f; + final float newVerticalWallpaperOffset = wallpaperOffset; + animWithInterpolator.addUpdateListener(new AnimatorUpdateListener() { + public void onAnimationUpdate(ValueAnimator animation) { + fastInvalidate(); + final float b = (Float) animation.getAnimatedValue(); + final float a = 1f - b; + setHorizontalWallpaperOffset( + a * oldHorizontalWallpaperOffset + b * newHorizontalWallpaperOffset); + setVerticalWallpaperOffset( + a * oldVerticalWallpaperOffset + b * newVerticalWallpaperOffset); + for (int i = 0; i < screenCount; i++) { + if (oldAlphas[i] == 0f && newAlphas[i] == 0f) continue; + final CellLayout cl = (CellLayout) getChildAt(i); + cl.fastInvalidate(); + cl.setFastX(a * oldXs[i] + b * newXs[i]); + cl.setFastY(a * oldYs[i] + b * newYs[i]); + cl.setFastScaleX(a * oldScaleXs[i] + b * newScaleXs[i]); + cl.setFastScaleY(a * oldScaleYs[i] + b * newScaleYs[i]); + cl.setFastBackgroundAlpha( + a * oldBackgroundAlphas[i] + b * newBackgroundAlphas[i]); + cl.setFastAlpha(a * oldAlphas[i] + b * newAlphas[i]); + cl.setFastRotationY(a * oldRotationYs[i] + b * newRotationYs[i]); + } + } + }); + mAnimator.playTogether(animWithInterpolator); mAnimator.addListener(mShrinkAnimationListener); mAnimator.start(); } else { @@ -1687,6 +1728,23 @@ public class Workspace extends SmoothPagedView final int duration = getResources().getInteger(R.integer.config_workspaceUnshrinkTime); + final float[] oldTranslationXs = new float[getChildCount()]; + final float[] oldTranslationYs = new float[getChildCount()]; + final float[] oldScaleXs = new float[getChildCount()]; + final float[] oldScaleYs = new float[getChildCount()]; + final float[] oldBackgroundAlphas = new float[getChildCount()]; + final float[] oldBackgroundAlphaMultipliers = new float[getChildCount()]; + final float[] oldAlphas = new float[getChildCount()]; + final float[] oldRotationYs = new float[getChildCount()]; + final float[] newTranslationXs = new float[getChildCount()]; + final float[] newTranslationYs = new float[getChildCount()]; + final float[] newScaleXs = new float[getChildCount()]; + final float[] newScaleYs = new float[getChildCount()]; + final float[] newBackgroundAlphas = new float[getChildCount()]; + final float[] newBackgroundAlphaMultipliers = new float[getChildCount()]; + final float[] newAlphas = new float[getChildCount()]; + final float[] newRotationYs = new float[getChildCount()]; + for (int i = 0; i < screenCount; i++) { final CellLayout cl = (CellLayout)getChildAt(i); float finalAlphaValue = (i == mCurrentPage) ? 1.0f : 0.0f; @@ -1703,25 +1761,24 @@ public class Workspace extends SmoothPagedView float translation = getOffsetXForRotation(rotation, cl.getWidth(), cl.getHeight()); - if (animated) { - ObjectAnimator animWithInterpolator = ObjectAnimator.ofPropertyValuesHolder(cl, - PropertyValuesHolder.ofFloat("translationX", translation), - PropertyValuesHolder.ofFloat("translationY", 0.0f), - PropertyValuesHolder.ofFloat("scaleX", finalScaleFactor), - PropertyValuesHolder.ofFloat("scaleY", finalScaleFactor), - PropertyValuesHolder.ofFloat("backgroundAlpha", finalBackgroundAlpha), - PropertyValuesHolder.ofFloat("backgroundAlphaMultiplier", - finalAlphaMultiplierValue), - PropertyValuesHolder.ofFloat("alpha", finalAlphaValue)); - animWithInterpolator.setDuration(duration); - animWithInterpolator.setInterpolator(mZoomInInterpolator); - - ObjectAnimator rotationAnim = ObjectAnimator.ofPropertyValuesHolder(cl, - PropertyValuesHolder.ofFloat("rotationY", rotation)); - rotationAnim.setDuration(duration); - rotationAnim.setInterpolator(new DecelerateInterpolator(2.0f)); - - mAnimator.playTogether(animWithInterpolator, rotationAnim); + oldAlphas[i] = cl.getAlpha(); + newAlphas[i] = finalAlphaValue; + if (animated && !(oldAlphas[i] == 0f && newAlphas[i] == 0f)) { + oldTranslationXs[i] = cl.getTranslationX(); + oldTranslationYs[i] = cl.getTranslationY(); + oldScaleXs[i] = cl.getScaleX(); + oldScaleYs[i] = cl.getScaleY(); + oldBackgroundAlphas[i] = cl.getBackgroundAlpha(); + oldBackgroundAlphaMultipliers[i] = cl.getBackgroundAlphaMultiplier(); + oldRotationYs[i] = cl.getRotationY(); + + newTranslationXs[i] = translation; + newTranslationYs[i] = 0f; + newScaleXs[i] = finalScaleFactor; + newScaleYs[i] = finalScaleFactor; + newBackgroundAlphas[i] = finalBackgroundAlpha; + newBackgroundAlphaMultipliers[i] = finalAlphaMultiplierValue; + newRotationYs[i] = rotation; } else { cl.setTranslationX(translation); cl.setTranslationY(0.0f); @@ -1731,7 +1788,7 @@ public class Workspace extends SmoothPagedView cl.setBackgroundAlphaMultiplier(finalAlphaMultiplierValue); cl.setAlpha(finalAlphaValue); cl.setRotationY(rotation); - mUnshrinkAnimationListener.onAnimationEnd(null); + if (!animated) mUnshrinkAnimationListener.onAnimationEnd(null); } } Display display = mLauncher.getWindowManager().getDefaultDisplay(); @@ -1765,15 +1822,59 @@ public class Workspace extends SmoothPagedView break; } if (animated) { - ObjectAnimator wallpaperAnim = ObjectAnimator.ofPropertyValuesHolder(this, - PropertyValuesHolder.ofFloat( - "verticalWallpaperOffset", 0.5f), - PropertyValuesHolder.ofFloat( - "horizontalWallpaperOffset", wallpaperOffsetForCurrentScroll())); - wallpaperAnim.setDuration(duration); - wallpaperAnim.setInterpolator(mZoomInInterpolator); - mAnimator.play(wallpaperAnim); + ValueAnimator animWithInterpolator = + ValueAnimator.ofFloat(0f, 1f).setDuration(duration); + animWithInterpolator.setInterpolator(mZoomInInterpolator); + + final float oldHorizontalWallpaperOffset = getHorizontalWallpaperOffset(); + final float oldVerticalWallpaperOffset = getVerticalWallpaperOffset(); + final float newHorizontalWallpaperOffset = wallpaperOffsetForCurrentScroll(); + final float newVerticalWallpaperOffset = 0.5f; + animWithInterpolator.addUpdateListener(new AnimatorUpdateListener() { + public void onAnimationUpdate(ValueAnimator animation) { + fastInvalidate(); + final float b = (Float) animation.getAnimatedValue(); + final float a = 1f - b; + setHorizontalWallpaperOffset( + a * oldHorizontalWallpaperOffset + b * newHorizontalWallpaperOffset); + setVerticalWallpaperOffset( + a * oldVerticalWallpaperOffset + b * newVerticalWallpaperOffset); + for (int i = 0; i < screenCount; i++) { + if (oldAlphas[i] == 0f && newAlphas[i] == 0f) continue; + final CellLayout cl = (CellLayout) getChildAt(i); + cl.fastInvalidate(); + cl.setFastTranslationX( + a * oldTranslationXs[i] + b * newTranslationXs[i]); + cl.setFastTranslationY( + a * oldTranslationYs[i] + b * newTranslationYs[i]); + cl.setFastScaleX(a * oldScaleXs[i] + b * newScaleXs[i]); + cl.setFastScaleY(a * oldScaleYs[i] + b * newScaleYs[i]); + cl.setFastBackgroundAlpha( + a * oldBackgroundAlphas[i] + b * newBackgroundAlphas[i]); + cl.setBackgroundAlphaMultiplier(a * oldBackgroundAlphaMultipliers[i] + + b * newBackgroundAlphaMultipliers[i]); + cl.setFastAlpha(a * oldAlphas[i] + b * newAlphas[i]); + } + } + }); + + ValueAnimator rotationAnim = + ValueAnimator.ofFloat(0f, 1f).setDuration(duration); + rotationAnim.setInterpolator(new DecelerateInterpolator(2.0f)); + rotationAnim.addUpdateListener(new AnimatorUpdateListener() { + public void onAnimationUpdate(ValueAnimator animation) { + // don't invalidate workspace because we did it above + final float b = (Float) animation.getAnimatedValue(); + final float a = 1f - b; + for (int i = 0; i < screenCount; i++) { + if (oldAlphas[i] == 0f && newAlphas[i] == 0f) continue; + final CellLayout cl = (CellLayout) getChildAt(i); + cl.setFastRotationY(a * oldRotationYs[i] + b * newRotationYs[i]); + } + } + }); + mAnimator.playTogether(animWithInterpolator, rotationAnim); // If we call this when we're not animated, onAnimationEnd is never called on // the listener; make sure we only use the listener when we're actually animating mAnimator.addListener(mUnshrinkAnimationListener); -- cgit v1.2.3