From ef1292149a577f3d4a1207781c177706b6828887 Mon Sep 17 00:00:00 2001 From: Sunny Goyal Date: Mon, 13 Feb 2017 20:03:08 +0000 Subject: [PATCH] Revert "Changing LauncherViewPropertyAnimator to use ValueAnimator" Issue: Animations do not run This reverts commit 33c04705beee04f7df309d702bc7303f161a8f18. Change-Id: I069379ac1003c4b11e008b82530c952a66604459 --- .../launcher3/LauncherViewPropertyAnimator.java | 265 +++++++++++++++++---- .../android/launcher3/anim/AnimationLayerSet.java | 20 +- 2 files changed, 223 insertions(+), 62 deletions(-) diff --git a/src/com/android/launcher3/LauncherViewPropertyAnimator.java b/src/com/android/launcher3/LauncherViewPropertyAnimator.java index 9bafc2afe..4406a2c5c 100644 --- a/src/com/android/launcher3/LauncherViewPropertyAnimator.java +++ b/src/com/android/launcher3/LauncherViewPropertyAnimator.java @@ -17,90 +17,259 @@ package com.android.launcher3; import android.animation.Animator; -import android.animation.AnimatorListenerAdapter; -import android.animation.PropertyValuesHolder; -import android.animation.ValueAnimator; +import android.animation.Animator.AnimatorListener; +import android.animation.TimeInterpolator; import android.view.View; - -import com.android.launcher3.anim.AnimationLayerSet; +import android.view.ViewPropertyAnimator; import java.util.ArrayList; +import java.util.EnumSet; -/** - * Extension of {@link ValueAnimator} to provide an interface similar to - * {@link android.view.ViewPropertyAnimator}. - */ -public class LauncherViewPropertyAnimator extends ValueAnimator { +public class LauncherViewPropertyAnimator extends Animator implements AnimatorListener { + + enum Properties { + TRANSLATION_X, + TRANSLATION_Y, + SCALE_X, + SCALE_Y, + ROTATION_Y, + ALPHA, + START_DELAY, + DURATION, + INTERPOLATOR, + WITH_LAYER + } + EnumSet mPropertiesToSet = EnumSet.noneOf(Properties.class); + ViewPropertyAnimator mViewPropertyAnimator; + View mTarget; + + float mTranslationX; + float mTranslationY; + float mScaleX; + float mScaleY; + float mRotationY; + float mAlpha; + long mStartDelay; + long mDuration; + TimeInterpolator mInterpolator; + ArrayList mListeners = new ArrayList<>(); + boolean mRunning = false; + FirstFrameAnimatorHelper mFirstFrameHelper; + + public LauncherViewPropertyAnimator(View target) { + mTarget = target; + } + + @Override + public void addListener(Animator.AnimatorListener listener) { + mListeners.add(listener); + } + + @Override + public void cancel() { + if (mViewPropertyAnimator != null) { + mViewPropertyAnimator.cancel(); + } + } + + @Override + public Animator clone() { + throw new RuntimeException("Not implemented"); + } + + @Override + public void end() { + throw new RuntimeException("Not implemented"); + } + + @Override + public long getDuration() { + return mDuration; + } + + @Override + public ArrayList getListeners() { + return mListeners; + } + + @Override + public long getStartDelay() { + return mStartDelay; + } + + @Override + public void onAnimationCancel(Animator animation) { + for (int i = 0; i < mListeners.size(); i++) { + Animator.AnimatorListener listener = mListeners.get(i); + listener.onAnimationCancel(this); + } + mRunning = false; + } + + @Override + public void onAnimationEnd(Animator animation) { + for (int i = 0; i < mListeners.size(); i++) { + Animator.AnimatorListener listener = mListeners.get(i); + listener.onAnimationEnd(this); + } + mRunning = false; + } + + @Override + public void onAnimationRepeat(Animator animation) { + for (int i = 0; i < mListeners.size(); i++) { + Animator.AnimatorListener listener = mListeners.get(i); + listener.onAnimationRepeat(this); + } + } + + @Override + public void onAnimationStart(Animator animation) { + // This is the first time we get a handle to the internal ValueAnimator + // used by the ViewPropertyAnimator. + mFirstFrameHelper.onAnimationStart(animation); + + for (int i = 0; i < mListeners.size(); i++) { + Animator.AnimatorListener listener = mListeners.get(i); + listener.onAnimationStart(this); + } + mRunning = true; + } + + @Override + public boolean isRunning() { + return mRunning; + } + + @Override + public boolean isStarted() { + return mViewPropertyAnimator != null; + } + + @Override + public void removeAllListeners() { + mListeners.clear(); + } + + @Override + public void removeListener(Animator.AnimatorListener listener) { + mListeners.remove(listener); + } + + @Override + public Animator setDuration(long duration) { + mPropertiesToSet.add(Properties.DURATION); + mDuration = duration; + return this; + } + + @Override + public void setInterpolator(TimeInterpolator value) { + mPropertiesToSet.add(Properties.INTERPOLATOR); + mInterpolator = value; + } + + @Override + public void setStartDelay(long startDelay) { + mPropertiesToSet.add(Properties.START_DELAY); + mStartDelay = startDelay; + } + + @Override + public void setTarget(Object target) { + throw new RuntimeException("Not implemented"); + } - private final View mTarget; - private final ArrayList mProperties; + @Override + public void setupEndValues() { - private boolean mPrepared = false; + } - public LauncherViewPropertyAnimator(View view) { - mTarget = view; - mProperties = new ArrayList<>(); - setTarget(mTarget); - addListener(new TransientStateUpdater(mTarget)); + @Override + public void setupStartValues() { } @Override public void start() { - if (!mPrepared) { - mPrepared = true; - setValues(mProperties.toArray(new PropertyValuesHolder[mProperties.size()])); + mViewPropertyAnimator = mTarget.animate(); + + // FirstFrameAnimatorHelper hooks itself up to the updates on the animator, + // and then adjusts the play time to keep the first two frames jank-free + mFirstFrameHelper = new FirstFrameAnimatorHelper(mViewPropertyAnimator, mTarget); + + if (mPropertiesToSet.contains(Properties.TRANSLATION_X)) { + mViewPropertyAnimator.translationX(mTranslationX); + } + if (mPropertiesToSet.contains(Properties.TRANSLATION_Y)) { + mViewPropertyAnimator.translationY(mTranslationY); + } + if (mPropertiesToSet.contains(Properties.SCALE_X)) { + mViewPropertyAnimator.scaleX(mScaleX); + } + if (mPropertiesToSet.contains(Properties.ROTATION_Y)) { + mViewPropertyAnimator.rotationY(mRotationY); + } + if (mPropertiesToSet.contains(Properties.SCALE_Y)) { + mViewPropertyAnimator.scaleY(mScaleY); + } + if (mPropertiesToSet.contains(Properties.ALPHA)) { + mViewPropertyAnimator.alpha(mAlpha); + } + if (mPropertiesToSet.contains(Properties.START_DELAY)) { + mViewPropertyAnimator.setStartDelay(mStartDelay); + } + if (mPropertiesToSet.contains(Properties.DURATION)) { + mViewPropertyAnimator.setDuration(mDuration); + } + if (mPropertiesToSet.contains(Properties.INTERPOLATOR)) { + mViewPropertyAnimator.setInterpolator(mInterpolator); } + if (mPropertiesToSet.contains(Properties.WITH_LAYER)) { + mViewPropertyAnimator.withLayer(); + } + mViewPropertyAnimator.setListener(this); + mViewPropertyAnimator.start(); LauncherAnimUtils.cancelOnDestroyActivity(this); - super.start(); } public LauncherViewPropertyAnimator translationX(float value) { - mProperties.add(PropertyValuesHolder.ofFloat(View.TRANSLATION_X, value)); + mPropertiesToSet.add(Properties.TRANSLATION_X); + mTranslationX = value; return this; } public LauncherViewPropertyAnimator translationY(float value) { - mProperties.add(PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, value)); + mPropertiesToSet.add(Properties.TRANSLATION_Y); + mTranslationY = value; return this; } public LauncherViewPropertyAnimator scaleX(float value) { - mProperties.add(PropertyValuesHolder.ofFloat(View.SCALE_X, value)); + mPropertiesToSet.add(Properties.SCALE_X); + mScaleX = value; return this; } public LauncherViewPropertyAnimator scaleY(float value) { - mProperties.add(PropertyValuesHolder.ofFloat(View.SCALE_Y, value)); + mPropertiesToSet.add(Properties.SCALE_Y); + mScaleY = value; return this; } - public LauncherViewPropertyAnimator alpha(float value) { - mProperties.add(PropertyValuesHolder.ofFloat(View.ALPHA, value)); + public LauncherViewPropertyAnimator rotationY(float value) { + mPropertiesToSet.add(Properties.ROTATION_Y); + mRotationY = value; return this; } - public LauncherViewPropertyAnimator withLayer() { - AnimationLayerSet listener = new AnimationLayerSet(); - listener.addView(mTarget); - addListener(listener); + public LauncherViewPropertyAnimator alpha(float value) { + mPropertiesToSet.add(Properties.ALPHA); + mAlpha = value; return this; } - private static class TransientStateUpdater extends AnimatorListenerAdapter { - private final View mView; - - TransientStateUpdater(View v) { - mView = v; - } - - @Override - public void onAnimationStart(Animator animation) { - mView.setHasTransientState(true); - } - - @Override - public void onAnimationEnd(Animator animation) { - mView.setHasTransientState(false); - } + public LauncherViewPropertyAnimator withLayer() { + mPropertiesToSet.add(Properties.WITH_LAYER); + return this; } } diff --git a/src/com/android/launcher3/anim/AnimationLayerSet.java b/src/com/android/launcher3/anim/AnimationLayerSet.java index d2f5e78a2..42706ffa1 100644 --- a/src/com/android/launcher3/anim/AnimationLayerSet.java +++ b/src/com/android/launcher3/anim/AnimationLayerSet.java @@ -20,29 +20,23 @@ import android.animation.Animator; import android.animation.AnimatorListenerAdapter; import android.view.View; -import java.util.HashMap; -import java.util.Iterator; -import java.util.Map; +import java.util.HashSet; /** * Helper class to automatically build view hardware layers for the duration of an animation. */ public class AnimationLayerSet extends AnimatorListenerAdapter { - private final HashMap mViewsToLayerTypeMap = new HashMap<>(); + private final HashSet mViews = new HashSet<>(); public void addView(View v) { - mViewsToLayerTypeMap.put(v, v.getLayerType()); + mViews.add(v); } @Override public void onAnimationStart(Animator animation) { // Enable all necessary layers - Iterator> itr = mViewsToLayerTypeMap.entrySet().iterator(); - while (itr.hasNext()) { - Map.Entry entry = itr.next(); - View v = entry.getKey(); - entry.setValue(v.getLayerType()); + for (View v : mViews) { v.setLayerType(View.LAYER_TYPE_HARDWARE, null); if (v.isAttachedToWindow() && v.getVisibility() == View.VISIBLE) { v.buildLayer(); @@ -52,10 +46,8 @@ public class AnimationLayerSet extends AnimatorListenerAdapter { @Override public void onAnimationEnd(Animator animation) { - Iterator> itr = mViewsToLayerTypeMap.entrySet().iterator(); - while (itr.hasNext()) { - Map.Entry entry = itr.next(); - entry.getKey().setLayerType(entry.getValue(), null); + for (View v : mViews) { + v.setLayerType(View.LAYER_TYPE_NONE, null); } } } -- 2.11.0