From 13351997aa36eb53e5ff0fcee3f5e3da83787278 Mon Sep 17 00:00:00 2001 From: Doris Liu Date: Tue, 17 Jan 2017 17:10:42 -0800 Subject: [PATCH] New functionalities for AnimatorSet: Reverse, Seek This CL adds reverse and seek to AnimatorSet's capabilities. Structural changes: 1) Child animators are now being pulsed by AnimatorSet in a more timeline manner, as opposed to the old listener based style. This timeline based approach avoids the time offset in between sequential animations, and therefore produces a more accurate overall duration. 2) Timeline is done by representing start and end of each child animator in two separate events. All the events are then sorted based on the time they happen, such that it's clear what should happen in between last frame and the new frame (i.e. which animations should start or end). Test: CTS (in the same topic branch) Bug: 30993532 Change-Id: If1dc6e8dbc93a4bf5ade8c5b0dcf43d3ee6ba7b5 --- api/current.txt | 4 + api/system-current.txt | 4 + api/test-current.txt | 4 + .../android/animation/AnimationHandler.java | 3 +- core/java/android/animation/Animator.java | 93 +- core/java/android/animation/AnimatorSet.java | 972 +++++++++++++----- .../android/animation/ObjectAnimator.java | 5 + .../java/android/animation/ValueAnimator.java | 215 +++- 8 files changed, 997 insertions(+), 303 deletions(-) diff --git a/api/current.txt b/api/current.txt index 072d4bbf2cf7a..d57663434e988 100644 --- a/api/current.txt +++ b/api/current.txt @@ -3067,8 +3067,10 @@ package android.animation { public static abstract interface Animator.AnimatorListener { method public abstract void onAnimationCancel(android.animation.Animator); + method public default void onAnimationEnd(android.animation.Animator, boolean); method public abstract void onAnimationEnd(android.animation.Animator); method public abstract void onAnimationRepeat(android.animation.Animator); + method public default void onAnimationStart(android.animation.Animator, boolean); method public abstract void onAnimationStart(android.animation.Animator); } @@ -3104,6 +3106,8 @@ package android.animation { method public void playSequentially(java.util.List); method public void playTogether(android.animation.Animator...); method public void playTogether(java.util.Collection); + method public void reverse(); + method public void setCurrentPlayTime(long); method public android.animation.AnimatorSet setDuration(long); method public void setInterpolator(android.animation.TimeInterpolator); method public void setStartDelay(long); diff --git a/api/system-current.txt b/api/system-current.txt index 8a18190306c7d..1a7bf96edaa78 100644 --- a/api/system-current.txt +++ b/api/system-current.txt @@ -3186,8 +3186,10 @@ package android.animation { public static abstract interface Animator.AnimatorListener { method public abstract void onAnimationCancel(android.animation.Animator); + method public default void onAnimationEnd(android.animation.Animator, boolean); method public abstract void onAnimationEnd(android.animation.Animator); method public abstract void onAnimationRepeat(android.animation.Animator); + method public default void onAnimationStart(android.animation.Animator, boolean); method public abstract void onAnimationStart(android.animation.Animator); } @@ -3223,6 +3225,8 @@ package android.animation { method public void playSequentially(java.util.List); method public void playTogether(android.animation.Animator...); method public void playTogether(java.util.Collection); + method public void reverse(); + method public void setCurrentPlayTime(long); method public android.animation.AnimatorSet setDuration(long); method public void setInterpolator(android.animation.TimeInterpolator); method public void setStartDelay(long); diff --git a/api/test-current.txt b/api/test-current.txt index 057d5a45f1aea..2db7e775504f0 100644 --- a/api/test-current.txt +++ b/api/test-current.txt @@ -3067,8 +3067,10 @@ package android.animation { public static abstract interface Animator.AnimatorListener { method public abstract void onAnimationCancel(android.animation.Animator); + method public default void onAnimationEnd(android.animation.Animator, boolean); method public abstract void onAnimationEnd(android.animation.Animator); method public abstract void onAnimationRepeat(android.animation.Animator); + method public default void onAnimationStart(android.animation.Animator, boolean); method public abstract void onAnimationStart(android.animation.Animator); } @@ -3104,6 +3106,8 @@ package android.animation { method public void playSequentially(java.util.List); method public void playTogether(android.animation.Animator...); method public void playTogether(java.util.Collection); + method public void reverse(); + method public void setCurrentPlayTime(long); method public android.animation.AnimatorSet setDuration(long); method public void setInterpolator(android.animation.TimeInterpolator); method public void setStartDelay(long); diff --git a/core/java/android/animation/AnimationHandler.java b/core/java/android/animation/AnimationHandler.java index 95262ab46a9e5..e2e5a8f66288c 100644 --- a/core/java/android/animation/AnimationHandler.java +++ b/core/java/android/animation/AnimationHandler.java @@ -276,8 +276,9 @@ public class AnimationHandler { * Run animation based on the frame time. * @param frameTime The frame start time, in the {@link SystemClock#uptimeMillis()} time * base. + * @return if the animation has finished. */ - void doAnimationFrame(long frameTime); + boolean doAnimationFrame(long frameTime); /** * This notifies the callback of frame commit time. Frame commit time is the time after diff --git a/core/java/android/animation/Animator.java b/core/java/android/animation/Animator.java index c51725a2caac4..634dc1fd6ee7f 100644 --- a/core/java/android/animation/Animator.java +++ b/core/java/android/animation/Animator.java @@ -26,7 +26,7 @@ import java.util.ArrayList; * This is the superclass for classes which provide basic support for animations which can be * started, ended, and have AnimatorListeners added to them. */ -public abstract class Animator implements Cloneable { +public abstract class Animator implements Cloneable, AnimationHandler.AnimationFrameCallback { /** * The value used to indicate infinite duration (e.g. when Animators repeat infinitely). @@ -464,12 +464,103 @@ public abstract class Animator implements Cloneable { throw new IllegalStateException("Reverse is not supported"); } + /** + * @hide + */ + @Override + public boolean doAnimationFrame(long frameTime) { + // TODO: Need to find a better signal than this + return getDuration() + getStartDelay() >= frameTime; + } + + /** + * @hide + */ + @Override + public void commitAnimationFrame(long frameTime) {} + + + /** + * Internal use only. + * This call starts the animation in regular or reverse direction without requiring them to + * register frame callbacks. The caller will be responsible for all the subsequent animation + * pulses. Specifically, the caller needs to call doAnimationFrame(...) for the animation on + * every frame. + * + * @param inReverse whether the animation should play in reverse direction + */ + void startWithoutPulsing(boolean inReverse) { + if (inReverse) { + reverse(); + } else { + start(); + } + } + + /** + * Internal use only. + * Skips the animation value to end/start, depending on whether the play direction is forward + * or backward. + * + * @param inReverse whether the end value is based on a reverse direction. If yes, this is + * equivalent to skip to start value in a forward playing direction. + */ + void skipToEndValue(boolean inReverse) {} + + + /** + * Internal use only. + * + * Returns whether the animation has start/end values setup. For most of the animations, this + * should always be true. For ObjectAnimators, the start values are setup in the initialization + * of the animation. + */ + boolean isInitialized() { + return true; + } + + /** + * Internal use only. + */ + void animateBasedOnPlayTime(long currentPlayTime, long lastPlayTime, boolean inReverse) {} + /** *

An animation listener receives notifications from an animation. * Notifications indicate animation related events, such as the end or the * repetition of the animation.

*/ public static interface AnimatorListener { + + /** + *

Notifies the start of the animation as well as the animation's overall play direction. + * This method's default behavior is to call {@link #onAnimationStart(Animator)}. This + * method can be overridden, though not required, to get the additional play direction info + * when an animation starts. Skipping calling super when overriding this method results in + * {@link #onAnimationStart(Animator)} not getting called. + * + * @param animation The started animation. + * @param isReverse Whether the animation is playing in reverse. + */ + default void onAnimationStart(Animator animation, boolean isReverse) { + onAnimationStart(animation); + } + + /** + *

Notifies the end of the animation. This callback is not invoked + * for animations with repeat count set to INFINITE.

+ * + *

This method's default behavior is to call {@link #onAnimationEnd(Animator)}. This + * method can be overridden, though not required, to get the additional play direction info + * when an animation ends. Skipping calling super when overriding this method results in + * {@link #onAnimationEnd(Animator)} not getting called. + * + * @param animation The animation which reached its end. + * @param isReverse Whether the animation is playing in reverse. + */ + default void onAnimationEnd(Animator animation, boolean isReverse) { + onAnimationEnd(animation); + } + /** *

Notifies the start of the animation.

* diff --git a/core/java/android/animation/AnimatorSet.java b/core/java/android/animation/AnimatorSet.java index a904f9d5447b5..d5814a30ac170 100644 --- a/core/java/android/animation/AnimatorSet.java +++ b/core/java/android/animation/AnimatorSet.java @@ -19,11 +19,15 @@ package android.animation; import android.app.ActivityThread; import android.app.Application; import android.os.Build; +import android.os.Looper; +import android.util.AndroidRuntimeException; import android.util.ArrayMap; import android.util.Log; +import android.view.animation.Animation; import java.util.ArrayList; import java.util.Collection; +import java.util.Comparator; import java.util.List; /** @@ -52,7 +56,7 @@ import java.util.List; * Animation developer guide.

* */ -public final class AnimatorSet extends Animator { +public final class AnimatorSet extends Animator implements AnimationHandler.AnimationFrameCallback { private static final String TAG = "AnimatorSet"; /** @@ -66,7 +70,7 @@ public final class AnimatorSet extends Animator { * Tracks animations currently being played, so that we know what to * cancel or end when cancel() or end() is called on this AnimatorSet */ - private ArrayList mPlayingSet = new ArrayList(); + private ArrayList mPlayingSet = new ArrayList(); /** * Contains all nodes, mapped to their respective Animators. When new @@ -76,6 +80,11 @@ public final class AnimatorSet extends Animator { */ private ArrayMap mNodeMap = new ArrayMap(); + /** + * Contains the start and end events of all the nodes. All these events are sorted in this list. + */ + private ArrayList mEvents = new ArrayList<>(); + /** * Set of all nodes created for this AnimatorSet. This list is used upon * starting the set, and the nodes are placed in sorted order into the @@ -83,21 +92,6 @@ public final class AnimatorSet extends Animator { */ private ArrayList mNodes = new ArrayList(); - /** - * Animator Listener that tracks the lifecycle of each Animator in the set. It will be added - * to each Animator before they start and removed after they end. - */ - private AnimatorSetListener mSetListener = new AnimatorSetListener(this); - - /** - * Flag indicating that the AnimatorSet has been manually - * terminated (by calling cancel() or end()). - * This flag is used to avoid starting other animations when currently-playing - * child animations of this AnimatorSet end. It also determines whether cancel/end - * notifications are sent out via the normal AnimatorSetListener mechanism. - */ - private boolean mTerminated = false; - /** * Tracks whether any change has been made to the AnimatorSet, which is then used to * determine whether the dependency graph should be re-constructed. @@ -131,8 +125,6 @@ public final class AnimatorSet extends Animator { // was set on this AnimatorSet, so it should not be passed down to the children. private TimeInterpolator mInterpolator = null; - // Whether the AnimatorSet can be reversed. - private boolean mReversible = true; // The total duration of finishing all the Animators in the set. private long mTotalDuration = 0; @@ -142,6 +134,46 @@ public final class AnimatorSet extends Animator { // the animator set and immediately end it for N and forward. private final boolean mShouldIgnoreEndWithoutStart; + // In pre-O releases, calling start() doesn't reset all the animators values to start values. + // As a result, the start of the animation is inconsistent with what setCurrentPlayTime(0) would + // look like on O. Also it is inconsistent with what reverse() does on O, as reverse would + // advance all the animations to the right beginning values for before starting to reverse. + // From O and forward, we will add an additional step of resetting the animation values (unless + // the animation was previously seeked and therefore doesn't start from the beginning). + private final boolean mShouldResetValuesAtStart; + + // The time, in milliseconds, when last frame of the animation came in. -1 when the animation is + // not running. + private long mLastFrameTime = -1; + + // The time, in milliseconds, when the first frame of the animation came in. + // -1 when the animation is not running. + private long mFirstFrame = -1; + + // The time, in milliseconds, when the first frame of the animation came in. + // -1 when the animation is not running. + private int mLastEventId = -1; + + // Indicates whether the animation is reversing. + private boolean mReversing = false; + + // Indicates whether the animation should register frame callbacks. If false, the animation will + // passively wait for an AnimatorSet to pulse it. + private boolean mSelfPulse = true; + + // SeekState stores the last seeked play time as well as seek direction. + private SeekState mSeekState = new SeekState(); + + // Indicates where children animators are all initialized with their start values captured. + private boolean mChildrenInitialized = false; + + /** + * Set on the next frame after pause() is called, used to calculate a new startTime + * or delayStartTime which allows the animator set to continue from the point at which + * it was paused. If negative, has not yet been set. + */ + private long mPauseTime = -1; + public AnimatorSet() { super(); mNodeMap.put(mDelayAnim, mRootNode); @@ -150,10 +182,19 @@ public final class AnimatorSet extends Animator { Application app = ActivityThread.currentApplication(); if (app == null || app.getApplicationInfo() == null) { mShouldIgnoreEndWithoutStart = true; - } else if (app.getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.N) { - mShouldIgnoreEndWithoutStart = true; + mShouldResetValuesAtStart = false; } else { - mShouldIgnoreEndWithoutStart = false; + if (app.getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.N) { + mShouldIgnoreEndWithoutStart = true; + } else { + mShouldIgnoreEndWithoutStart = false; + } + + if (app.getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.O) { + mShouldResetValuesAtStart = false; + } else { + mShouldResetValuesAtStart = true; + } } } @@ -206,7 +247,6 @@ public final class AnimatorSet extends Animator { if (items.length == 1) { play(items[0]); } else { - mReversible = false; for (int i = 0; i < items.length - 1; ++i) { play(items[i]).before(items[i + 1]); } @@ -225,7 +265,6 @@ public final class AnimatorSet extends Animator { if (items.size() == 1) { play(items.get(0)); } else { - mReversible = false; for (int i = 0; i < items.size() - 1; ++i) { play(items.get(i)).before(items.get(i + 1)); } @@ -350,7 +389,9 @@ public final class AnimatorSet extends Animator { @SuppressWarnings("unchecked") @Override public void cancel() { - mTerminated = true; + if (Looper.myLooper() == null) { + throw new AndroidRuntimeException("Animators may only be run on Looper threads"); + } if (isStarted()) { ArrayList tmpListeners = null; if (mListeners != null) { @@ -360,18 +401,13 @@ public final class AnimatorSet extends Animator { tmpListeners.get(i).onAnimationCancel(this); } } - ArrayList playingSet = new ArrayList<>(mPlayingSet); + ArrayList playingSet = new ArrayList<>(mPlayingSet); int setSize = playingSet.size(); for (int i = 0; i < setSize; i++) { - playingSet.get(i).cancel(); + playingSet.get(i).mAnimation.cancel(); } - if (tmpListeners != null) { - int size = tmpListeners.size(); - for (int i = 0; i < size; i++) { - tmpListeners.get(i).onAnimationEnd(this); - } - } - mStarted = false; + mPlayingSet.clear(); + endAnimation(); } } @@ -383,50 +419,40 @@ public final class AnimatorSet extends Animator { */ @Override public void end() { + if (Looper.myLooper() == null) { + throw new AndroidRuntimeException("Animators may only be run on Looper threads"); + } if (mShouldIgnoreEndWithoutStart && !isStarted()) { return; } - mTerminated = true; if (isStarted()) { - endRemainingAnimations(); - } - if (mListeners != null) { - ArrayList tmpListeners = - (ArrayList) mListeners.clone(); - for (int i = 0; i < tmpListeners.size(); i++) { - tmpListeners.get(i).onAnimationEnd(this); - } - } - mStarted = false; - } - - /** - * Iterate the animations that haven't finished or haven't started, and end them. - */ - private void endRemainingAnimations() { - ArrayList remainingList = new ArrayList(mNodes.size()); - remainingList.addAll(mPlayingSet); - - int index = 0; - while (index < remainingList.size()) { - Animator anim = remainingList.get(index); - anim.end(); - index++; - Node node = mNodeMap.get(anim); - if (node.mChildNodes != null) { - int childSize = node.mChildNodes.size(); - for (int i = 0; i < childSize; i++) { - Node child = node.mChildNodes.get(i); - if (child.mLatestParent != node) { - continue; + // Iterate the animations that haven't finished or haven't started, and end them. + if (mReversing) { + // Between start() and first frame, mLastEventId would be unset (i.e. -1) + mLastEventId = mLastEventId == -1 ? mEvents.size() : mLastEventId; + for (int j = mLastEventId - 1; j >= 0; j--) { + AnimationEvent event = mEvents.get(j); + if (event.mEvent == AnimationEvent.ANIMATION_END) { + event.mNode.mAnimation.reverse(); + } else if (event.mEvent == AnimationEvent.ANIMATION_DELAY_ENDED) { + event.mNode.mAnimation.end(); + } + } + } else { + for (int j = mLastEventId + 1; j < mEvents.size(); j++) { + AnimationEvent event = mEvents.get(j); + if (event.mEvent == AnimationEvent.ANIMATION_START) { + event.mNode.mAnimation.start(); + } else if (event.mEvent == AnimationEvent.ANIMATION_END) { + event.mNode.mAnimation.end(); } - remainingList.add(child.mAnimation); } } + mPlayingSet.clear(); } + endAnimation(); } - /** * Returns true if any of the child animations of this AnimatorSet have been started and have * not yet ended. Child animations will not be started until the AnimatorSet has gone past @@ -437,14 +463,12 @@ public final class AnimatorSet extends Animator { */ @Override public boolean isRunning() { - int size = mNodes.size(); - for (int i = 0; i < size; i++) { - Node node = mNodes.get(i); - if (node != mRootNode && node.mAnimation.isStarted()) { - return true; - } + if (mStartDelay > 0) { + return mStarted && !mDelayAnim.isRunning(); + } else { + // No start delay, animation should start right away + return mStarted; } - return false; } @Override @@ -482,9 +506,6 @@ public final class AnimatorSet extends Animator { return; } mStartDelay = startDelay; - if (mStartDelay > 0) { - mReversible = false; - } if (!mDependencyDirty) { // Dependency graph already constructed, update all the nodes' start/end time int size = mNodes.size(); @@ -562,40 +583,26 @@ public final class AnimatorSet extends Animator { @Override public void pause() { + if (Looper.myLooper() == null) { + throw new AndroidRuntimeException("Animators may only be run on Looper threads"); + } boolean previouslyPaused = mPaused; super.pause(); if (!previouslyPaused && mPaused) { - if (mDelayAnim.isStarted()) { - // If delay hasn't passed, pause the start delay animator. - mDelayAnim.pause(); - } else { - int size = mNodes.size(); - for (int i = 0; i < size; i++) { - Node node = mNodes.get(i); - if (node != mRootNode) { - node.mAnimation.pause(); - } - } - } + mPauseTime = -1; } } @Override public void resume() { + if (Looper.myLooper() == null) { + throw new AndroidRuntimeException("Animators may only be run on Looper threads"); + } boolean previouslyPaused = mPaused; super.resume(); if (previouslyPaused && !mPaused) { - if (mDelayAnim.isStarted()) { - // If start delay hasn't passed, resume the previously paused start delay animator - mDelayAnim.resume(); - } else { - int size = mNodes.size(); - for (int i = 0; i < size; i++) { - Node node = mNodes.get(i); - if (node != mRootNode) { - node.mAnimation.resume(); - } - } + if (mPauseTime >= 0) { + addAnimationCallback(0); } } } @@ -610,9 +617,33 @@ public final class AnimatorSet extends Animator { @SuppressWarnings("unchecked") @Override public void start() { - mTerminated = false; + start(false, true); + } + + @Override + void startWithoutPulsing(boolean inReverse) { + start(inReverse, false); + } + + private void initAnimation() { + if (mInterpolator != null) { + for (int i = 0; i < mNodes.size(); i++) { + Node node = mNodes.get(i); + node.mAnimation.setInterpolator(mInterpolator); + } + } + updateAnimatorsDuration(); + createDependencyGraph(); + } + + private void start(boolean inReverse, boolean selfPulse) { + if (Looper.myLooper() == null) { + throw new AndroidRuntimeException("Animators may only be run on Looper threads"); + } mStarted = true; + mSelfPulse = selfPulse; mPaused = false; + mPauseTime = -1; int size = mNodes.size(); for (int i = 0; i < size; i++) { @@ -621,26 +652,17 @@ public final class AnimatorSet extends Animator { node.mAnimation.setAllowRunningAsynchronously(false); } - if (mInterpolator != null) { - for (int i = 0; i < size; i++) { - Node node = mNodes.get(i); - node.mAnimation.setInterpolator(mInterpolator); - } + initAnimation(); + if (inReverse && !canReverse()) { + throw new UnsupportedOperationException("Cannot reverse infinite AnimatorSet"); } - updateAnimatorsDuration(); - createDependencyGraph(); + mReversing = inReverse; // Now that all dependencies are set up, start the animations that should be started. - boolean setIsEmpty = false; - if (mStartDelay > 0) { - start(mRootNode); - } else if (isEmptySet(this)) { - // Set is empty or contains only empty animator sets. Skip to end in this case. - setIsEmpty = true; - } else { - // No delay, but there are other animators in the set - onChildAnimatorEnded(mDelayAnim); + boolean setIsEmpty = isEmptySet(this); + if (!setIsEmpty) { + startAnimation(); } if (mListeners != null) { @@ -648,12 +670,12 @@ public final class AnimatorSet extends Animator { (ArrayList) mListeners.clone(); int numListeners = tmpListeners.size(); for (int i = 0; i < numListeners; ++i) { - tmpListeners.get(i).onAnimationStart(this); + tmpListeners.get(i).onAnimationStart(this, inReverse); } } if (setIsEmpty) { // In the case of empty AnimatorSet, we will trigger the onAnimationEnd() right away. - onChildAnimatorEnded(mDelayAnim); + end(); } } @@ -690,11 +712,419 @@ public final class AnimatorSet extends Animator { mDelayAnim.setDuration(mStartDelay); } - void start(final Node node) { - final Animator anim = node.mAnimation; - mPlayingSet.add(anim); - anim.addListener(mSetListener); - anim.start(); + @Override + void skipToEndValue(boolean inReverse) { + if (!isInitialized()) { + throw new UnsupportedOperationException("Children must be initialized."); + } + + // This makes sure the animation events are sorted an up to date. + initAnimation(); + + // Calling skip to the end in the sequence that they would be called in a forward/reverse + // run, such that the sequential animations modifying the same property would have + // the right value in the end. + if (inReverse) { + for (int i = mEvents.size() - 1; i >= 0; i--) { + if (mEvents.get(i).mEvent == AnimationEvent.ANIMATION_DELAY_ENDED) { + mEvents.get(i).mNode.mAnimation.skipToEndValue(true); + } + } + } else { + for (int i = 0; i < mEvents.size(); i++) { + if (mEvents.get(i).mEvent == AnimationEvent.ANIMATION_END) { + mEvents.get(i).mNode.mAnimation.skipToEndValue(false); + } + } + } + } + + /** + * Internal only. + * + * This method sets the animation values based on the play time. It also fast forward or + * backward all the child animations progress accordingly. + * + * This method is also responsible for calling + * {@link android.view.animation.Animation.AnimationListener#onAnimationRepeat(Animation)}, + * as needed, based on the last play time and current play time. + */ + @Override + void animateBasedOnPlayTime(long currentPlayTime, long lastPlayTime, boolean inReverse) { + if (currentPlayTime < 0 || lastPlayTime < 0) { + throw new UnsupportedOperationException("Error: Play time should never be negative."); + } + // TODO: take into account repeat counts and repeat callback when repeat is implemented. + // Clamp currentPlayTime and lastPlayTime + + // TODO: Make this more efficient + + // Convert the play times to the forward direction. + if (inReverse) { + if (getTotalDuration() == DURATION_INFINITE) { + throw new UnsupportedOperationException("Cannot reverse AnimatorSet with infinite" + + " duration"); + } + long duration = getTotalDuration() - mStartDelay; + currentPlayTime = Math.min(currentPlayTime, duration); + currentPlayTime = duration - currentPlayTime; + lastPlayTime = duration - lastPlayTime; + inReverse = false; + } + // Skip all values to start, and iterate mEvents to get animations to the right fraction. + skipToStartValue(false); + + ArrayList unfinishedNodes = new ArrayList<>(); + // Assumes forward playing from here on. + for (int i = 0; i < mEvents.size(); i++) { + AnimationEvent event = mEvents.get(i); + if (event.getTime() > currentPlayTime) { + break; + } + + // This animation started prior to the current play time, and won't finish before the + // play time, add to the unfinished list. + if (event.mEvent == AnimationEvent.ANIMATION_DELAY_ENDED) { + if (event.mNode.mEndTime == DURATION_INFINITE + || event.mNode.mEndTime > currentPlayTime) { + unfinishedNodes.add(event.mNode); + } + } + // For animations that do finish before the play time, end them in the sequence that + // they would in a normal run. + if (event.mEvent == AnimationEvent.ANIMATION_END) { + // Skip to the end of the animation. + event.mNode.mAnimation.skipToEndValue(false); + } + } + + // Seek unfinished animation to the right time. + for (int i = 0; i < unfinishedNodes.size(); i++) { + Node node = unfinishedNodes.get(i); + long playTime = getPlayTimeForNode(currentPlayTime, node, inReverse); + node.mAnimation.animateBasedOnPlayTime(playTime, lastPlayTime, inReverse); + } + } + + @Override + boolean isInitialized() { + if (mChildrenInitialized) { + return true; + } + + boolean allInitialized = true; + for (int i = 0; i < mNodes.size(); i++) { + if (!mNodes.get(i).mAnimation.isInitialized()) { + allInitialized = false; + break; + } + } + mChildrenInitialized = allInitialized; + return mChildrenInitialized; + } + + private void skipToStartValue(boolean inReverse) { + skipToEndValue(!inReverse); + } + + /** + * Sets the position of the animation to the specified point in time. This time should + * be between 0 and the total duration of the animation, including any repetition. If + * the animation has not yet been started, then it will not advance forward after it is + * set to this time; it will simply set the time to this value and perform any appropriate + * actions based on that time. If the animation is already running, then setCurrentPlayTime() + * will set the current playing time to this value and continue playing from that point. + * + * @param playTime The time, in milliseconds, to which the animation is advanced or rewound. + * Unless the animation is reversing, the playtime is considered the time since + * the end of the start delay of the AnimatorSet in a forward playing direction. + * + */ + public void setCurrentPlayTime(long playTime) { + if (mReversing && getTotalDuration() == DURATION_INFINITE) { + // Should never get here + throw new UnsupportedOperationException("Error: Cannot seek in reverse in an infinite" + + " AnimatorSet"); + } + + if ((getTotalDuration() != DURATION_INFINITE && playTime > getTotalDuration() - mStartDelay) + || playTime < 0) { + throw new UnsupportedOperationException("Error: Play time should always be in between" + + "0 and duration."); + } + + initAnimation(); + + if (!isStarted()) { + if (mReversing) { + throw new UnsupportedOperationException("Error: Something went wrong. mReversing" + + " should not be set when AnimatorSet is not started."); + } + if (!mSeekState.isActive()) { + findLatestEventIdForTime(0); + // Set all the values to start values. + initChildren(); + skipToStartValue(mReversing); + mSeekState.setPlayTime(0, mReversing); + } + animateBasedOnPlayTime(playTime, 0, mReversing); + mSeekState.setPlayTime(playTime, mReversing); + } else { + // If the animation is running, just set the seek time and wait until the next frame + // (i.e. doAnimationFrame(...)) to advance the animation. + mSeekState.setPlayTime(playTime, mReversing); + } + } + + private void initChildren() { + if (!isInitialized()) { + mChildrenInitialized = true; + // Forcefully initialize all children based on their end time, so that if the start + // value of a child is dependent on a previous animation, the animation will be + // initialized after the the previous animations have been advanced to the end. + skipToEndValue(false); + } + } + + /** + * @param frameTime The frame start time, in the {@link SystemClock#uptimeMillis()} time + * base. + * @return + * @hide + */ + @Override + public boolean doAnimationFrame(long frameTime) { + if (mLastFrameTime < 0) { + mFirstFrame = mLastFrameTime = frameTime; + } + + // Handle pause/resume + if (mPaused) { + // Note: Child animations don't receive pause events. Since it's never a contract that + // the child animators will be paused when set is paused, this is unlikely to be an + // issue. + mPauseTime = frameTime; + removeAnimationCallback(); + return false; + } else if (mPauseTime > 0) { + // Offset by the duration that the animation was paused + mFirstFrame += (frameTime - mPauseTime); + mPauseTime = -1; + } + + // Continue at seeked position + if (mSeekState.isActive()) { + mSeekState.updateSeekDirection(mReversing); + mFirstFrame = frameTime - mSeekState.getPlayTime() - mStartDelay; + mSeekState.reset(); + } + + // This playTime includes the start delay. + long playTime = frameTime - mFirstFrame; + + // 1. Pulse the animators that will start or end in this frame + // 2. Pulse the animators that will finish in a later frame + int latestId = findLatestEventIdForTime(playTime); + int startId = mLastEventId; + + handleAnimationEvents(startId, latestId, playTime); + + mLastEventId = latestId; + + // Pump a frame to the on-going animators + for (int i = 0; i < mPlayingSet.size(); i++) { + Node node = mPlayingSet.get(i); + if (!node.mEnded) { + node.mEnded = node.mAnimation.doAnimationFrame(getPlayTimeForNode(playTime, node)); + } + } + + // Remove all the finished anims + for (int i = mPlayingSet.size() - 1; i >= 0; i--) { + if (mPlayingSet.get(i).mEnded) { + mPlayingSet.remove(i); + } + } + + mLastFrameTime = frameTime; + if (mPlayingSet.isEmpty()) { + boolean finished; + if (mReversing) { + // Make sure there's no more END event before current event id and after start delay + finished = mLastEventId <= 3; + } else { + // Make sure there's no more START event before current event id: + finished = (mLastEventId == mEvents.size() - 1); + } + if (finished) { + endAnimation(); + return true; + } + } + return false; + } + + /** + * When playing forward, we call start() at the animation's scheduled start time, and make sure + * to pump a frame at the animation's scheduled end time. + * + * When playing in reverse, we should reverse the animation when we hit animation's end event, + * and expect the animation to end at the its delay ended event, rather than start event. + */ + private void handleAnimationEvents(int startId, int latestId, long playTime) { + if (mReversing) { + startId = startId == -1 ? mEvents.size() : startId; + for (int i = startId - 1; i >= latestId; i--) { + AnimationEvent event = mEvents.get(i); + Node node = event.mNode; + if (event.mEvent == AnimationEvent.ANIMATION_END) { + mPlayingSet.add(event.mNode); + node.mAnimation.startWithoutPulsing(true); + node.mAnimation.doAnimationFrame(0); + } else if (event.mEvent == AnimationEvent.ANIMATION_DELAY_ENDED && !node.mEnded) { + // end event: + node.mEnded = + node.mAnimation.doAnimationFrame(getPlayTimeForNode(playTime, node)); + } + } + } else { + for (int i = startId + 1; i <= latestId; i++) { + AnimationEvent event = mEvents.get(i); + Node node = event.mNode; + if (event.mEvent == AnimationEvent.ANIMATION_START) { + mPlayingSet.add(event.mNode); + node.mAnimation.startWithoutPulsing(false); + node.mAnimation.doAnimationFrame(0); + } else if (event.mEvent == AnimationEvent.ANIMATION_END && !node.mEnded) { + // start event: + node.mEnded = + node.mAnimation.doAnimationFrame(getPlayTimeForNode(playTime, node)); + } + } + } + } + + private long getPlayTimeForNode(long overallPlayTime, Node node) { + return getPlayTimeForNode(overallPlayTime, node, mReversing); + } + + private long getPlayTimeForNode(long overallPlayTime, Node node, boolean inReverse) { + if (inReverse) { + overallPlayTime = getTotalDuration() - overallPlayTime; + return node.mEndTime - overallPlayTime; + } else { + return overallPlayTime - node.mStartTime; + } + } + + private void startAnimation() { + // Register animation callback + addAnimationCallback(mStartDelay); + + if (mSeekState.getPlayTimeNormalized() == 0 && mReversing) { + // Maintain old behavior, if seeked to 0 then call reverse, we'll treat the case + // the same as no seeking at all. + mSeekState.reset(); + } + // Set the child animators to the right end: + if (mShouldResetValuesAtStart) { + if (mReversing || isInitialized()) { + skipToEndValue(!mReversing); + } else { + // If not all children are initialized and play direction is forward + for (int i = mEvents.size() - 1; i >= 0; i--) { + if (mEvents.get(i).mEvent == AnimationEvent.ANIMATION_DELAY_ENDED) { + Animator anim = mEvents.get(i).mNode.mAnimation; + // Only reset the animations that have been initialized to start value, + // so that if they are defined without a start value, they will get the + // values set at the right time (i.e. the next animation run) + if (anim.isInitialized()) { + anim.skipToEndValue(true); + } + } + } + } + } + + if (mReversing || mStartDelay == 0 || mSeekState.isActive()) { + long playTime; + // If no delay, we need to call start on the first animations to be consistent with old + // behavior. + if (mSeekState.isActive()) { + mSeekState.updateSeekDirection(mReversing); + playTime = mSeekState.getPlayTime(); + } else { + playTime = 0; + } + int toId = findLatestEventIdForTime(playTime); + handleAnimationEvents(-1, toId, playTime); + mLastEventId = toId; + } + } + + private int findLatestEventIdForTime(long currentPlayTime) { + int size = mEvents.size(); + int latestId = mLastEventId; + // Call start on the first animations now to be consistent with the old behavior + if (mReversing) { + currentPlayTime = getTotalDuration() - currentPlayTime; + mLastEventId = mLastEventId == -1 ? size : mLastEventId; + for (int j = mLastEventId - 1; j >= 0; j--) { + AnimationEvent event = mEvents.get(j); + if (event.getTime() >= currentPlayTime) { + latestId = j; + } + } + } else { + for (int i = mLastEventId + 1; i < size; i++) { + AnimationEvent event = mEvents.get(i); + if (event.getTime() <= currentPlayTime) { + latestId = i; + } + } + } + return latestId; + } + + private void endAnimation() { + mStarted = false; + mLastFrameTime = -1; + mFirstFrame = -1; + mLastEventId = -1; + mPaused = false; + mPauseTime = -1; + mSeekState.reset(); + mPlayingSet.clear(); + + // No longer receive callbacks + removeAnimationCallback(); + // Call end listener + if (mListeners != null) { + ArrayList tmpListeners = + (ArrayList) mListeners.clone(); + int numListeners = tmpListeners.size(); + for (int i = 0; i < numListeners; ++i) { + tmpListeners.get(i).onAnimationEnd(this, mReversing); + } + } + mSelfPulse = true; + mReversing = false; + } + + private void removeAnimationCallback() { + if (!mSelfPulse) { + return; + } + AnimationHandler handler = AnimationHandler.getInstance(); + handler.removeCallback(this); + } + + private void addAnimationCallback(long delay) { + if (!mSelfPulse) { + return; + } + AnimationHandler handler = AnimationHandler.getInstance(); + handler.addAnimationFrameCallback(this, delay); } @Override @@ -709,13 +1139,20 @@ public final class AnimatorSet extends Animator { * and will populate any appropriate lists, when it is started. */ final int nodeCount = mNodes.size(); - anim.mTerminated = false; anim.mStarted = false; - anim.mPlayingSet = new ArrayList(); + anim.mLastFrameTime = -1; + anim.mFirstFrame = -1; + anim.mLastEventId = -1; + anim.mPaused = false; + anim.mPauseTime = -1; + anim.mSeekState = new SeekState(); + anim.mSelfPulse = true; + anim.mPlayingSet = new ArrayList(); anim.mNodeMap = new ArrayMap(); anim.mNodes = new ArrayList(nodeCount); - anim.mReversible = mReversible; - anim.mSetListener = new AnimatorSetListener(anim); + anim.mEvents = new ArrayList(); + anim.mReversing = false; + anim.mDependencyDirty = true; // Walk through the old nodes list, cloning each node and adding it to the new nodemap. // One problem is that the old node dependencies point to nodes in the old AnimatorSet. @@ -727,17 +1164,6 @@ public final class AnimatorSet extends Animator { node.mTmpClone = nodeClone; anim.mNodes.add(nodeClone); anim.mNodeMap.put(nodeClone.mAnimation, nodeClone); - - // clear out any listeners that were set up by the AnimatorSet - final ArrayList cloneListeners = nodeClone.mAnimation.getListeners(); - if (cloneListeners != null) { - for (int i = cloneListeners.size() - 1; i >= 0; i--) { - final AnimatorListener listener = cloneListeners.get(i); - if (listener instanceof AnimatorSetListener) { - cloneListeners.remove(i); - } - } - } } anim.mRootNode = mRootNode.mTmpClone; @@ -771,89 +1197,6 @@ public final class AnimatorSet extends Animator { } - private static class AnimatorSetListener implements AnimatorListener { - - private AnimatorSet mAnimatorSet; - - AnimatorSetListener(AnimatorSet animatorSet) { - mAnimatorSet = animatorSet; - } - - public void onAnimationCancel(Animator animation) { - - if (!mAnimatorSet.mTerminated) { - // Listeners are already notified of the AnimatorSet canceling in cancel(). - // The logic below only kicks in when animations end normally - if (mAnimatorSet.mPlayingSet.size() == 0) { - ArrayList listeners = mAnimatorSet.mListeners; - if (listeners != null) { - int numListeners = listeners.size(); - for (int i = 0; i < numListeners; ++i) { - listeners.get(i).onAnimationCancel(mAnimatorSet); - } - } - } - } - } - - @SuppressWarnings("unchecked") - public void onAnimationEnd(Animator animation) { - animation.removeListener(this); - mAnimatorSet.mPlayingSet.remove(animation); - mAnimatorSet.onChildAnimatorEnded(animation); - } - - // Nothing to do - public void onAnimationRepeat(Animator animation) { - } - - // Nothing to do - public void onAnimationStart(Animator animation) { - } - - } - - private void onChildAnimatorEnded(Animator animation) { - Node animNode = mNodeMap.get(animation); - animNode.mEnded = true; - - if (!mTerminated) { - List children = animNode.mChildNodes; - // Start children animations, if any. - int childrenSize = children == null ? 0 : children.size(); - for (int i = 0; i < childrenSize; i++) { - if (children.get(i).mLatestParent == animNode) { - start(children.get(i)); - } - } - // Listeners are already notified of the AnimatorSet ending in cancel() or - // end(); the logic below only kicks in when animations end normally - boolean allDone = true; - // Traverse the tree and find if there's any unfinished node - int size = mNodes.size(); - for (int i = 0; i < size; i++) { - if (!mNodes.get(i).mEnded) { - allDone = false; - break; - } - } - if (allDone) { - mStarted = false; - mPaused = false; - // If this was the last child animation to end, then notify listeners that this - // AnimatorSet has ended - if (mListeners != null) { - ArrayList tmpListeners = - (ArrayList) mListeners.clone(); - int numListeners = tmpListeners.size(); - for (int i = 0; i < numListeners; ++i) { - tmpListeners.get(i).onAnimationEnd(this); - } - } - } - } - } - /** * AnimatorSet is only reversible when the set contains no sequential animation, and no child * animators have a start delay. @@ -861,32 +1204,21 @@ public final class AnimatorSet extends Animator { */ @Override public boolean canReverse() { - if (!mReversible) { - return false; - } - // Loop to make sure all the Nodes can reverse. - int size = mNodes.size(); - for (int i = 0; i < size; i++) { - Node node = mNodes.get(i); - if (!node.mAnimation.canReverse() || node.mAnimation.getStartDelay() > 0) { - return false; - } - } - return true; + return getTotalDuration() != DURATION_INFINITE; } /** - * @hide + * Plays the AnimatorSet in reverse. If the animation has been seeked to a specific play time + * using {@link #setCurrentPlayTime(long)}, it will play backwards from the point seeked when + * reverse was called. Otherwise, then it will start from the end and play backwards. This + * behavior is only set for the current animation; future playing of the animation will use the + * default behavior of playing forward. + *

+ * Note: reverse is not supported for infinite AnimatorSet. */ @Override public void reverse() { - if (canReverse()) { - int size = mNodes.size(); - for (int i = 0; i < size; i++) { - Node node = mNodes.get(i); - node.mAnimation.reverse(); - } - } + start(true, true); } @Override @@ -993,18 +1325,61 @@ public final class AnimatorSet extends Animator { mRootNode.mEndTime = mDelayAnim.getDuration(); updatePlayTime(mRootNode, visited); - long maxEndTime = 0; - for (int i = 0; i < size; i++) { + sortAnimationEvents(); + mTotalDuration = mEvents.get(mEvents.size() - 1).getTime(); + } + + private void sortAnimationEvents() { + // Sort the list of events in ascending order of their time + // Create the list including the delay animation. + mEvents.clear(); + for (int i = 0; i < mNodes.size(); i++) { Node node = mNodes.get(i); - node.mTotalDuration = node.mAnimation.getTotalDuration(); - if (node.mEndTime == DURATION_INFINITE) { - maxEndTime = DURATION_INFINITE; - break; - } else { - maxEndTime = node.mEndTime > maxEndTime ? node.mEndTime : maxEndTime; - } + mEvents.add(new AnimationEvent(node, AnimationEvent.ANIMATION_START)); + mEvents.add(new AnimationEvent(node, AnimationEvent.ANIMATION_DELAY_ENDED)); + mEvents.add(new AnimationEvent(node, AnimationEvent.ANIMATION_END)); + } + mEvents.sort(new Comparator() { + @Override + public int compare(AnimationEvent e1, AnimationEvent e2) { + long t1 = e1.getTime(); + long t2 = e2.getTime(); + if (t1 == t2) { + if (e1.mNode == e2.mNode) { + // For the same animation, start event has to happen before end. + return e1.mEvent - e2.mEvent; + } + // For different animation, end events need to happen before start, to ensure + // sequential animations finish the previous one before starting the next one. + return e2.mEvent - e1.mEvent; + } + if (t2 == DURATION_INFINITE) { + return -1; + } + if (t1 == DURATION_INFINITE) { + return 1; + } + // When neither event happens at INFINITE time: + return (int) (t1 - t2); + } + }); + + if (mEvents.get(mEvents.size() - 1).mEvent == AnimationEvent.ANIMATION_START + || mEvents.get(mEvents.size() - 1).mEvent == AnimationEvent.ANIMATION_DELAY_ENDED) { + throw new UnsupportedOperationException( + "Something went wrong, the last event is not an end event"); + } + if (mEvents.get(1).mEvent != AnimationEvent.ANIMATION_DELAY_ENDED + || mEvents.get(1).mNode != mRootNode) { + throw new UnsupportedOperationException( + "Sorting went bad, the root node's start delay end event should always be at" + + " index 1"); + } + if (mEvents.get(2).mEvent != AnimationEvent.ANIMATION_END + || mEvents.get(2).mNode != mRootNode) { + throw new UnsupportedOperationException( + "Sorting went bad, the start delay end event should always be at index 2"); } - mTotalDuration = maxEndTime; } /** @@ -1234,6 +1609,95 @@ public final class AnimatorSet extends Animator { } } + /** + * This class is a wrapper around a node and an event for the animation corresponding to the + * node. The 3 types of events represent the start of an animation, the end of a start delay of + * an animation, and the end of an animation. When playing forward (i.e. in the non-reverse + * direction), start event marks when start() should be called, and end event corresponds to + * when the animation should finish. When playing in reverse, start delay will not be a part + * of the animation. Therefore, reverse() is called at the end event, and animation should end + * at the delay ended event. + */ + private static class AnimationEvent { + static final int ANIMATION_START = 0; + static final int ANIMATION_DELAY_ENDED = 1; + static final int ANIMATION_END = 2; + final Node mNode; + final int mEvent; + + AnimationEvent(Node node, int event) { + mNode = node; + mEvent = event; + } + + long getTime() { + if (mEvent == ANIMATION_START) { + return mNode.mStartTime; + } else if (mEvent == ANIMATION_DELAY_ENDED) { + return mNode.mStartTime + mNode.mAnimation.getStartDelay(); + } else { + return mNode.mEndTime; + } + } + + public String toString() { + String eventStr = mEvent == ANIMATION_START ? "start" : ( + mEvent == ANIMATION_DELAY_ENDED ? "delay ended" : "end"); + return eventStr + " " + mNode.mAnimation.toString(); + } + } + + private class SeekState { + private long mPlayTime = -1; + private boolean mSeekingInReverse = false; + void reset() { + mPlayTime = -1; + mSeekingInReverse = false; + } + + void setPlayTime(long playTime, boolean inReverse) { + // TODO: This can be simplified. + + // Clamp the play time + if (getTotalDuration() != DURATION_INFINITE) { + mPlayTime = Math.min(playTime, getTotalDuration() - mStartDelay); + } + mPlayTime = Math.max(0, mPlayTime); + mSeekingInReverse = inReverse; + } + + void updateSeekDirection(boolean inReverse) { + // Change seek direction without changing the overall fraction + if (inReverse && getTotalDuration() == DURATION_INFINITE) { + throw new UnsupportedOperationException("Error: Cannot reverse infinite animator" + + " set"); + } + if (mPlayTime >= 0) { + if (inReverse != mSeekingInReverse) { + mPlayTime = getTotalDuration() - mStartDelay - mPlayTime; + } + } + } + + long getPlayTime() { + return mPlayTime; + } + + /** + * Returns the playtime assuming the animation is forward playing + */ + long getPlayTimeNormalized() { + if (mReversing) { + return getTotalDuration() - mStartDelay - mPlayTime; + } + return mPlayTime; + } + + boolean isActive() { + return mPlayTime != -1; + } + } + /** * The Builder object is a utility class to facilitate adding animations to a * AnimatorSet along with the relationships between the various animations. The @@ -1328,7 +1792,6 @@ public final class AnimatorSet extends Animator { * {@link AnimatorSet#play(Animator)} method ends. */ public Builder before(Animator anim) { - mReversible = false; Node node = getNodeForAnimation(anim); mCurrentNode.addChild(node); return this; @@ -1343,7 +1806,6 @@ public final class AnimatorSet extends Animator { * {@link AnimatorSet#play(Animator)} method to play. */ public Builder after(Animator anim) { - mReversible = false; Node node = getNodeForAnimation(anim); mCurrentNode.addParent(node); return this; diff --git a/core/java/android/animation/ObjectAnimator.java b/core/java/android/animation/ObjectAnimator.java index 4707bed3ee143..1e1f1554d3a28 100644 --- a/core/java/android/animation/ObjectAnimator.java +++ b/core/java/android/animation/ObjectAnimator.java @@ -991,6 +991,11 @@ public final class ObjectAnimator extends ValueAnimator { } } + @Override + boolean isInitialized() { + return mInitialized; + } + @Override public ObjectAnimator clone() { final ObjectAnimator anim = (ObjectAnimator) super.clone(); diff --git a/core/java/android/animation/ValueAnimator.java b/core/java/android/animation/ValueAnimator.java index f0fc8af9d504e..470523fc42522 100644 --- a/core/java/android/animation/ValueAnimator.java +++ b/core/java/android/animation/ValueAnimator.java @@ -24,6 +24,7 @@ import android.os.Trace; import android.util.AndroidRuntimeException; import android.util.Log; import android.view.animation.AccelerateDecelerateInterpolator; +import android.view.animation.Animation; import android.view.animation.AnimationUtils; import android.view.animation.LinearInterpolator; @@ -67,7 +68,7 @@ import java.util.HashMap; * */ @SuppressWarnings("unchecked") -public class ValueAnimator extends Animator implements AnimationHandler.AnimationFrameCallback { +public class ValueAnimator extends Animator { private static final String TAG = "ValueAnimator"; private static final boolean DEBUG = false; @@ -90,7 +91,7 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio * * Whenever mStartTime is set, you must also update mStartTimeCommitted. */ - long mStartTime; + long mStartTime = -1; /** * When true, the start time has been firmly committed as a chosen reference point in @@ -152,7 +153,13 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio /** * Tracks the time (in milliseconds) when the last frame arrived. */ - private long mLastFrameTime = 0; + private long mLastFrameTime = -1; + + /** + * Tracks the time (in milliseconds) when the first frame arrived. Note the frame may arrive + * during the start delay. + */ + private long mFirstFrameTime = -1; /** * Additional playing state to indicate whether an animator has been start()'d. There is @@ -211,6 +218,12 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio */ private int mRepeatMode = RESTART; + /** + * Whether or not the animator should register for its own animation callback to receive + * animation pulse. + */ + private boolean mSelfPulse = true; + /** * The time interpolator to be used. The elapsed fraction of the animation will be passed * through this interpolator to calculate the interpolated fraction, which is then used to @@ -628,7 +641,7 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio mSeekFraction = fraction; } mOverallFraction = fraction; - final float currentIterationFraction = getCurrentIterationFraction(fraction); + final float currentIterationFraction = getCurrentIterationFraction(fraction, mReversing); animateValue(currentIterationFraction); } @@ -654,11 +667,11 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio * should be played backwards. E.g. When the animation is played backwards in an iteration, * the fraction for that iteration will go from 1f to 0f. */ - private float getCurrentIterationFraction(float fraction) { + private float getCurrentIterationFraction(float fraction, boolean inReverse) { fraction = clampFraction(fraction); int iteration = getCurrentIteration(fraction); float currentFraction = fraction - iteration; - return shouldPlayBackward(iteration) ? 1f - currentFraction : currentFraction; + return shouldPlayBackward(iteration, inReverse) ? 1f - currentFraction : currentFraction; } /** @@ -682,18 +695,18 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio * whether the entire animation is being reversed, 2) repeat mode applied to the current * iteration. */ - private boolean shouldPlayBackward(int iteration) { + private boolean shouldPlayBackward(int iteration, boolean inReverse) { if (iteration > 0 && mRepeatMode == REVERSE && (iteration < (mRepeatCount + 1) || mRepeatCount == INFINITE)) { // if we were seeked to some other iteration in a reversing animator, // figure out the correct direction to start playing based on the iteration - if (mReversing) { + if (inReverse) { return (iteration % 2) == 0; } else { return (iteration % 2) != 0; } } else { - return mReversing; + return inReverse; } } @@ -965,7 +978,7 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio (ArrayList) mListeners.clone(); int numListeners = tmpListeners.size(); for (int i = 0; i < numListeners; ++i) { - tmpListeners.get(i).onAnimationStart(this); + tmpListeners.get(i).onAnimationStart(this, mReversing); } } mStartListenersCalled = true; @@ -984,11 +997,12 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio * * @param playBackwards Whether the ValueAnimator should start playing in reverse. */ - private void start(boolean playBackwards) { + private void start(boolean playBackwards, boolean selfPulse) { if (Looper.myLooper() == null) { throw new AndroidRuntimeException("Animators may only be run on Looper threads"); } mReversing = playBackwards; + mSelfPulse = selfPulse; // Special case: reversing from seek-to-0 should act as if not seeked at all. if (playBackwards && mSeekFraction != -1 && mSeekFraction != 0) { if (mRepeatCount == INFINITE) { @@ -1006,11 +1020,11 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio // Resets mLastFrameTime when start() is called, so that if the animation was running, // calling start() would put the animation in the // started-but-not-yet-reached-the-first-frame phase. - mLastFrameTime = 0; - AnimationHandler animationHandler = AnimationHandler.getInstance(); - animationHandler.addAnimationFrameCallback(this, (long) (mStartDelay * sDurationScale)); + mLastFrameTime = -1; + mFirstFrameTime = -1; + addAnimationCallback((long) (mStartDelay * sDurationScale)); - if (mStartDelay == 0 || mSeekFraction >= 0) { + if (mStartDelay == 0 || mSeekFraction >= 0 || mReversing) { // If there's no start delay, init the animation and notify start listeners right away // to be consistent with the previous behavior. Otherwise, postpone this until the first // frame after the start delay. @@ -1026,9 +1040,13 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio } } + void startWithoutPulsing(boolean inReverse) { + start(inReverse, false); + } + @Override public void start() { - start(false); + start(false, true); } @Override @@ -1073,7 +1091,7 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio } else if (!mInitialized) { initAnimation(); } - animateValue(shouldPlayBackward(mRepeatCount) ? 0f : 1f); + animateValue(shouldPlayBackward(mRepeatCount, mReversing) ? 0f : 1f); endAnimation(); } @@ -1086,8 +1104,7 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio if (mPaused && !mResumed) { mResumed = true; if (mPauseTime > 0) { - AnimationHandler handler = AnimationHandler.getInstance(); - handler.addAnimationFrameCallback(this, 0); + addAnimationCallback(0); } } super.resume(); @@ -1133,7 +1150,7 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio mReversing = !mReversing; end(); } else { - start(true); + start(true, true); } } @@ -1153,8 +1170,7 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio if (mAnimationEndRequested) { return; } - AnimationHandler handler = AnimationHandler.getInstance(); - handler.removeCallback(this); + removeAnimationCallback(); mAnimationEndRequested = true; mPaused = false; @@ -1166,16 +1182,18 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio mRunning = false; mStarted = false; mStartListenersCalled = false; + mLastFrameTime = -1; + mFirstFrameTime = -1; mReversing = false; - mLastFrameTime = 0; if (notify && mListeners != null) { ArrayList tmpListeners = (ArrayList) mListeners.clone(); int numListeners = tmpListeners.size(); for (int i = 0; i < numListeners; ++i) { - tmpListeners.get(i).onAnimationEnd(this); + tmpListeners.get(i).onAnimationEnd(this, mReversing); } } + mReversing = false; if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) { Trace.asyncTraceEnd(Trace.TRACE_TAG_VIEW, getNameForTrace(), System.identityHashCode(this)); @@ -1211,7 +1229,7 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio * is called (or after start delay if any), which may be before the animation loop starts. */ private boolean isPulsingInternal() { - return mLastFrameTime > 0; + return mLastFrameTime >= 0; } /** @@ -1276,12 +1294,76 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio done = true; } mOverallFraction = clampFraction(fraction); - float currentIterationFraction = getCurrentIterationFraction(mOverallFraction); + float currentIterationFraction = getCurrentIterationFraction( + mOverallFraction, mReversing); animateValue(currentIterationFraction); } return done; } + /** + * Internal use only. + * + * This method does not modify any fields of the animation. It should be called when seeking + * in an AnimatorSet. When the last play time and current play time are of different repeat + * iterations, + * {@link android.view.animation.Animation.AnimationListener#onAnimationRepeat(Animation)} + * will be called. + */ + @Override + void animateBasedOnPlayTime(long currentPlayTime, long lastPlayTime, boolean inReverse) { + if (currentPlayTime < 0 || lastPlayTime < 0) { + throw new UnsupportedOperationException("Error: Play time should never be negative."); + } + + initAnimation(); + // Check whether repeat callback is needed only when repeat count is non-zero + if (mRepeatCount > 0) { + int iteration = (int) (currentPlayTime / mDuration); + int lastIteration = (int) (lastPlayTime / mDuration); + + // Clamp iteration to [0, mRepeatCount] + iteration = Math.min(iteration, mRepeatCount); + lastIteration = Math.min(lastIteration, mRepeatCount); + + if (iteration != lastIteration) { + if (mListeners != null) { + int numListeners = mListeners.size(); + for (int i = 0; i < numListeners; ++i) { + mListeners.get(i).onAnimationRepeat(this); + } + } + } + } + + if (mRepeatCount != INFINITE && currentPlayTime >= (mRepeatCount + 1) * mDuration) { + skipToEndValue(inReverse); + } else { + // Find the current fraction: + float fraction = currentPlayTime / (float) mDuration; + fraction = getCurrentIterationFraction(fraction, inReverse); + animateValue(fraction); + } + } + + /** + * Internal use only. + * Skips the animation value to end/start, depending on whether the play direction is forward + * or backward. + * + * @param inReverse whether the end value is based on a reverse direction. If yes, this is + * equivalent to skip to start value in a forward playing direction. + */ + void skipToEndValue(boolean inReverse) { + initAnimation(); + float endFraction = inReverse ? 0f : 1f; + if (mRepeatCount % 2 == 1 && mRepeatMode == REVERSE) { + // This would end on fraction = 0 + endFraction = 0f; + } + animateValue(endFraction); + } + /** * Processes a frame of the animation, adjusting the start time if needed. * @@ -1289,11 +1371,39 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio * @return true if the animation has ended. * @hide */ - public final void doAnimationFrame(long frameTime) { - AnimationHandler handler = AnimationHandler.getInstance(); - if (mLastFrameTime == 0) { + public final boolean doAnimationFrame(long frameTime) { + if (!mRunning && mStartTime < 0) { + // First frame during delay + mStartTime = frameTime + mStartDelay; + } + + // Handle pause/resume + if (mPaused) { + mPauseTime = frameTime; + removeAnimationCallback(); + return false; + } else if (mResumed) { + mResumed = false; + if (mPauseTime > 0) { + // Offset by the duration that the animation was paused + mStartTime += (frameTime - mPauseTime); + } + } + + if (!mRunning) { + // If not running, that means the animation is in the start delay phase. In the case of + // reversing, we want to run start delay in the end. + if (mStartTime > frameTime) { + // During start delay + return false; + } else { + // Start delay has passed. + mRunning = true; + } + } + + if (mLastFrameTime < 0) { // First frame - handler.addOneShotCommitCallback(this); if (mStartDelay > 0) { startAnimation(); } @@ -1307,19 +1417,6 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio mStartTimeCommitted = false; // allow start time to be compensated for jank } mLastFrameTime = frameTime; - if (mPaused) { - mPauseTime = frameTime; - handler.removeCallback(this); - return; - } else if (mResumed) { - mResumed = false; - if (mPauseTime > 0) { - // Offset by the duration that the animation was paused - mStartTime += (frameTime - mPauseTime); - mStartTimeCommitted = false; // allow start time to be compensated for jank - } - handler.addOneShotCommitCallback(this); - } // The frame time might be before the start time during the first frame of // an animation. The "current time" must always be on or after the start // time to avoid animating frames at negative time intervals. In practice, this @@ -1330,6 +1427,31 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio if (finished) { endAnimation(); } + return finished; + } + + private void addOneShotCommitCallback() { + if (!mSelfPulse) { + return; + } + AnimationHandler handler = AnimationHandler.getInstance(); + handler.addOneShotCommitCallback(this); + } + + private void removeAnimationCallback() { + if (!mSelfPulse) { + return; + } + AnimationHandler handler = AnimationHandler.getInstance(); + handler.removeCallback(this); + } + + private void addAnimationCallback(long delay) { + if (!mSelfPulse) { + return; + } + AnimationHandler handler = AnimationHandler.getInstance(); + handler.addAnimationFrameCallback(this, delay); } /** @@ -1384,11 +1506,12 @@ public class ValueAnimator extends Animator implements AnimationHandler.Animatio anim.mPaused = false; anim.mResumed = false; anim.mStartListenersCalled = false; - anim.mStartTime = 0; + anim.mStartTime = -1; anim.mStartTimeCommitted = false; anim.mAnimationEndRequested = false; - anim.mPauseTime = 0; - anim.mLastFrameTime = 0; + anim.mPauseTime = -1; + anim.mLastFrameTime = -1; + anim.mFirstFrameTime = -1; anim.mOverallFraction = 0; anim.mCurrentFraction = 0;