playingSet = new ArrayList<>(mPlayingSet);
int setSize = playingSet.size();
for (int i = 0; i < setSize; i++) {
playingSet.get(i).mAnimation.cancel();
}
mPlayingSet.clear();
endAnimation();
}
}
// Force all the animations to end when the duration scale is 0.
private void forceToEnd() {
if (mEndCanBeCalled) {
end();
return;
}
// Note: we don't want to combine this case with the end() method below because in
// the case of developer calling end(), we still need to make sure end() is explicitly
// called on the child animators to maintain the old behavior.
if (mReversing) {
handleAnimationEvents(mLastEventId, 0, getTotalDuration());
} else {
long zeroScalePlayTime = getTotalDuration();
if (zeroScalePlayTime == DURATION_INFINITE) {
// Use a large number for the play time.
zeroScalePlayTime = Integer.MAX_VALUE;
}
handleAnimationEvents(mLastEventId, mEvents.size() - 1, zeroScalePlayTime);
}
mPlayingSet.clear();
endAnimation();
}
/**
* {@inheritDoc}
*
* Note that ending a AnimatorSet also ends all of the animations that it is
* responsible for.
*/
@Override
public void end() {
if (Looper.myLooper() == null) {
throw new AndroidRuntimeException("Animators may only be run on Looper threads");
}
if (mShouldIgnoreEndWithoutStart && !isStarted()) {
return;
}
if (isStarted()) {
// 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;
while (mLastEventId > 0) {
mLastEventId = mLastEventId - 1;
AnimationEvent event = mEvents.get(mLastEventId);
Animator anim = event.mNode.mAnimation;
if (mNodeMap.get(anim).mEnded) {
continue;
}
if (event.mEvent == AnimationEvent.ANIMATION_END) {
anim.reverse();
} else if (event.mEvent == AnimationEvent.ANIMATION_DELAY_ENDED
&& anim.isStarted()) {
// Make sure anim hasn't finished before calling end() so that we don't end
// already ended animations, which will cause start and end callbacks to be
// triggered again.
anim.end();
}
}
} else {
while (mLastEventId < mEvents.size() - 1) {
// Avoid potential reentrant loop caused by child animators manipulating
// AnimatorSet's lifecycle (i.e. not a recommended approach).
mLastEventId = mLastEventId + 1;
AnimationEvent event = mEvents.get(mLastEventId);
Animator anim = event.mNode.mAnimation;
if (mNodeMap.get(anim).mEnded) {
continue;
}
if (event.mEvent == AnimationEvent.ANIMATION_START) {
anim.start();
} else if (event.mEvent == AnimationEvent.ANIMATION_END && anim.isStarted()) {
// Make sure anim hasn't finished before calling end() so that we don't end
// already ended animations, which will cause start and end callbacks to be
// triggered again.
anim.end();
}
}
}
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
* its initial delay set through {@link #setStartDelay(long)}.
*
* @return Whether this AnimatorSet has gone past the initial delay, and at least one child
* animation has been started and not yet ended.
*/
@Override
public boolean isRunning() {
if (mStartDelay == 0) {
return mStarted;
}
return mLastFrameTime > 0;
}
@Override
public boolean isStarted() {
return mStarted;
}
/**
* The amount of time, in milliseconds, to delay starting the animation after
* {@link #start()} is called.
*
* @return the number of milliseconds to delay running the animation
*/
@Override
public long getStartDelay() {
return mStartDelay;
}
/**
* The amount of time, in milliseconds, to delay starting the animation after
* {@link #start()} is called. Note that the start delay should always be non-negative. Any
* negative start delay will be clamped to 0 on N and above.
*
* @param startDelay The amount of the delay, in milliseconds
*/
@Override
public void setStartDelay(long startDelay) {
// Clamp start delay to non-negative range.
if (startDelay < 0) {
Log.w(TAG, "Start delay should always be non-negative");
startDelay = 0;
}
long delta = startDelay - mStartDelay;
if (delta == 0) {
return;
}
mStartDelay = startDelay;
if (!mDependencyDirty) {
// Dependency graph already constructed, update all the nodes' start/end time
int size = mNodes.size();
for (int i = 0; i < size; i++) {
Node node = mNodes.get(i);
if (node == mRootNode) {
node.mEndTime = mStartDelay;
} else {
node.mStartTime = node.mStartTime == DURATION_INFINITE ?
DURATION_INFINITE : node.mStartTime + delta;
node.mEndTime = node.mEndTime == DURATION_INFINITE ?
DURATION_INFINITE : node.mEndTime + delta;
}
}
// Update total duration, if necessary.
if (mTotalDuration != DURATION_INFINITE) {
mTotalDuration += delta;
}
}
}
/**
* Gets the length of each of the child animations of this AnimatorSet. This value may
* be less than 0, which indicates that no duration has been set on this AnimatorSet
* and each of the child animations will use their own duration.
*
* @return The length of the animation, in milliseconds, of each of the child
* animations of this AnimatorSet.
*/
@Override
public long getDuration() {
return mDuration;
}
/**
* Sets the length of each of the current child animations of this AnimatorSet. By default,
* each child animation will use its own duration. If the duration is set on the AnimatorSet,
* then each child animation inherits this duration.
*
* @param duration The length of the animation, in milliseconds, of each of the child
* animations of this AnimatorSet.
*/
@Override
public AnimatorSet setDuration(long duration) {
if (duration < 0) {
throw new IllegalArgumentException("duration must be a value of zero or greater");
}
mDependencyDirty = true;
// Just record the value for now - it will be used later when the AnimatorSet starts
mDuration = duration;
return this;
}
@Override
public void setupStartValues() {
int size = mNodes.size();
for (int i = 0; i < size; i++) {
Node node = mNodes.get(i);
if (node != mRootNode) {
node.mAnimation.setupStartValues();
}
}
}
@Override
public void setupEndValues() {
int size = mNodes.size();
for (int i = 0; i < size; i++) {
Node node = mNodes.get(i);
if (node != mRootNode) {
node.mAnimation.setupEndValues();
}
}
}
@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) {
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 (mPauseTime >= 0) {
addAnimationCallback(0);
}
}
}
/**
* {@inheritDoc}
*
* Starting this AnimatorSet will, in turn, start the animations for which
* it is responsible. The details of when exactly those animations are started depends on
* the dependency relationships that have been set up between the animations.
*
* Note: Manipulating AnimatorSet's lifecycle in the child animators' listener callbacks
* will lead to undefined behaviors. Also, AnimatorSet will ignore any seeking in the child
* animators once {@link #start()} is called.
*/
@SuppressWarnings("unchecked")
@Override
public void start() {
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++) {
Node node = mNodes.get(i);
node.mEnded = false;
node.mAnimation.setAllowRunningAsynchronously(false);
}
initAnimation();
if (inReverse && !canReverse()) {
throw new UnsupportedOperationException("Cannot reverse infinite AnimatorSet");
}
mReversing = inReverse;
// Now that all dependencies are set up, start the animations that should be started.
boolean isEmptySet = isEmptySet(this);
if (!isEmptySet) {
startAnimation();
}
if (mListeners != null) {
ArrayList tmpListeners =
(ArrayList) mListeners.clone();
int numListeners = tmpListeners.size();
for (int i = 0; i < numListeners; ++i) {
tmpListeners.get(i).onAnimationStart(this, inReverse);
}
}
if (isEmptySet) {
// In the case of empty AnimatorSet, or 0 duration scale, we will trigger the
// onAnimationEnd() right away.
end();
}
}
// Returns true if set is empty or contains nothing but animator sets with no start delay.
private static boolean isEmptySet(AnimatorSet set) {
if (set.getStartDelay() > 0) {
return false;
}
for (int i = 0; i < set.getChildAnimations().size(); i++) {
Animator anim = set.getChildAnimations().get(i);
if (!(anim instanceof AnimatorSet)) {
// Contains non-AnimatorSet, not empty.
return false;
} else {
if (!isEmptySet((AnimatorSet) anim)) {
return false;
}
}
}
return true;
}
private void updateAnimatorsDuration() {
if (mDuration >= 0) {
// If the duration was set on this AnimatorSet, pass it along to all child animations
int size = mNodes.size();
for (int i = 0; i < size; i++) {
Node node = mNodes.get(i);
// TODO: don't set the duration of the timing-only nodes created by AnimatorSet to
// insert "play-after" delays
node.mAnimation.setDuration(mDuration);
}
}
mDelayAnim.setDuration(mStartDelay);
}
@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 || event.getTime() == DURATION_INFINITE) {
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);
if (!inReverse) {
playTime -= node.mAnimation.getStartDelay();
}
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);
}
}
/**
* Returns the milliseconds elapsed since the start of the animation.
*
* For ongoing animations, this method returns the current progress of the animation in
* terms of play time. For an animation that has not yet been started: if the animation has been
* seeked to a certain time via {@link #setCurrentPlayTime(long)}, the seeked play time will
* be returned; otherwise, this method will return 0.
*
* @return the current position in time of the animation in milliseconds
*/
public long getCurrentPlayTime() {
if (mSeekState.isActive()) {
return mSeekState.getPlayTime();
}
if (mLastFrameTime == -1) {
// Not yet started or during start delay
return 0;
}
float durationScale = ValueAnimator.getDurationScale();
durationScale = durationScale == 0 ? 1 : durationScale;
if (mReversing) {
return (long) ((mLastFrameTime - mFirstFrame) / durationScale);
} else {
return (long) ((mLastFrameTime - mFirstFrame - mStartDelay) / durationScale);
}
}
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) {
float durationScale = ValueAnimator.getDurationScale();
if (durationScale == 0f) {
// Duration scale is 0, end the animation right away.
forceToEnd();
return true;
}
// After the first frame comes in, we need to wait for start delay to pass before updating
// any animation values.
if (mFirstFrame < 0) {
mFirstFrame = 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);
if (mReversing) {
mFirstFrame = (long) (frameTime - mSeekState.getPlayTime() * durationScale);
} else {
mFirstFrame = (long) (frameTime - (mSeekState.getPlayTime() + mStartDelay)
* durationScale);
}
mSeekState.reset();
}
if (!mReversing && frameTime < mFirstFrame + mStartDelay * durationScale) {
// Still during start delay in a forward playing case.
return false;
}
// From here on, we always use unscaled play time. Note this unscaled playtime includes
// the start delay.
long unscaledPlayTime = (long) ((frameTime - mFirstFrame) / durationScale);
mLastFrameTime = frameTime;
// 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(unscaledPlayTime);
int startId = mLastEventId;
handleAnimationEvents(startId, latestId, unscaledPlayTime);
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) {
pulseFrame(node, getPlayTimeForNode(unscaledPlayTime, node));
}
}
// Remove all the finished anims
for (int i = mPlayingSet.size() - 1; i >= 0; i--) {
if (mPlayingSet.get(i).mEnded) {
mPlayingSet.remove(i);
}
}
boolean finished = false;
if (mReversing) {
if (mPlayingSet.size() == 1 && mPlayingSet.get(0) == mRootNode) {
// The only animation that is running is the delay animation.
finished = true;
} else if (mPlayingSet.isEmpty() && mLastEventId < 3) {
// The only remaining animation is the delay animation
finished = true;
}
} else {
finished = mPlayingSet.isEmpty() && mLastEventId == mEvents.size() - 1;
}
if (finished) {
endAnimation();
return true;
}
return false;
}
/**
* @hide
*/
@Override
public void commitAnimationFrame(long frameTime) {
// No op.
}
@Override
boolean pulseAnimationFrame(long frameTime) {
return doAnimationFrame(frameTime);
}
/**
* 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) {
if (node.mAnimation.isStarted()) {
// If the animation has already been started before its due time (i.e.
// the child animator is being manipulated outside of the AnimatorSet), we
// need to cancel the animation to reset the internal state (e.g. frame
// time tracking) and remove the self pulsing callbacks
node.mAnimation.cancel();
}
node.mEnded = false;
mPlayingSet.add(event.mNode);
node.mAnimation.startWithoutPulsing(true);
pulseFrame(node, 0);
} else if (event.mEvent == AnimationEvent.ANIMATION_DELAY_ENDED && !node.mEnded) {
// end event:
pulseFrame(node, 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);
if (node.mAnimation.isStarted()) {
// If the animation has already been started before its due time (i.e.
// the child animator is being manipulated outside of the AnimatorSet), we
// need to cancel the animation to reset the internal state (e.g. frame
// time tracking) and remove the self pulsing callbacks
node.mAnimation.cancel();
}
node.mEnded = false;
node.mAnimation.startWithoutPulsing(false);
pulseFrame(node, 0);
} else if (event.mEvent == AnimationEvent.ANIMATION_END && !node.mEnded) {
// start event:
pulseFrame(node, getPlayTimeForNode(playTime, node));
}
}
}
}
/**
* This method pulses frames into child animations. It scales the input animation play time
* with the duration scale and pass that to the child animation via pulseAnimationFrame(long).
*
* @param node child animator node
* @param animPlayTime unscaled play time (including start delay) for the child animator
*/
private void pulseFrame(Node node, long animPlayTime) {
if (!node.mEnded) {
float durationScale = ValueAnimator.getDurationScale();
durationScale = durationScale == 0 ? 1 : durationScale;
node.mEnded = node.mAnimation.pulseAnimationFrame(
(long) (animPlayTime * durationScale));
}
}
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() {
addDummyListener();
// Register animation callback
addAnimationCallback(0);
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 (isInitialized()) {
skipToEndValue(!mReversing);
} else if (mReversing) {
// Reversing but haven't initialized all the children yet.
initChildren();
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);
for (int i = mPlayingSet.size() - 1; i >= 0; i--) {
if (mPlayingSet.get(i).mEnded) {
mPlayingSet.remove(i);
}
}
mLastEventId = toId;
}
}
// This is to work around the issue in b/34736819, as the old behavior in AnimatorSet had
// masked a real bug in play movies. TODO: remove this and below once the root cause is fixed.
private void addDummyListener() {
for (int i = 1; i < mNodes.size(); i++) {
mNodes.get(i).mAnimation.addListener(mDummyListener);
}
}
private void removeDummyListener() {
for (int i = 1; i < mNodes.size(); i++) {
mNodes.get(i).mAnimation.removeListener(mDummyListener);
}
}
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);
// TODO: need a function that accounts for infinite duration to compare time
if (event.getTime() != DURATION_INFINITE && 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);
}
}
removeDummyListener();
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
public AnimatorSet clone() {
final AnimatorSet anim = (AnimatorSet) super.clone();
/*
* The basic clone() operation copies all items. This doesn't work very well for
* AnimatorSet, because it will copy references that need to be recreated and state
* that may not apply. What we need to do now is put the clone in an uninitialized
* state, with fresh, empty data structures. Then we will build up the nodes list
* manually, as we clone each Node (and its animation). The clone will then be sorted,
* and will populate any appropriate lists, when it is started.
*/
final int nodeCount = mNodes.size();
anim.mStarted = false;
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.mEvents = new ArrayList();
anim.mDummyListener = new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
if (anim.mNodeMap.get(animation) == null) {
throw new AndroidRuntimeException("Error: animation ended is not in the node"
+ " map");
}
anim.mNodeMap.get(animation).mEnded = true;
}
};
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.
// We need to track the old/new nodes in order to reconstruct the dependencies in the clone.
HashMap clonesMap = new HashMap<>(nodeCount);
for (int n = 0; n < nodeCount; n++) {
final Node node = mNodes.get(n);
Node nodeClone = node.clone();
// Remove the old internal listener from the cloned child
nodeClone.mAnimation.removeListener(mDummyListener);
clonesMap.put(node, nodeClone);
anim.mNodes.add(nodeClone);
anim.mNodeMap.put(nodeClone.mAnimation, nodeClone);
}
anim.mRootNode = clonesMap.get(mRootNode);
anim.mDelayAnim = (ValueAnimator) anim.mRootNode.mAnimation;
// Now that we've cloned all of the nodes, we're ready to walk through their
// dependencies, mapping the old dependencies to the new nodes
for (int i = 0; i < nodeCount; i++) {
Node node = mNodes.get(i);
// Update dependencies for node's clone
Node nodeClone = clonesMap.get(node);
nodeClone.mLatestParent = node.mLatestParent == null
? null : clonesMap.get(node.mLatestParent);
int size = node.mChildNodes == null ? 0 : node.mChildNodes.size();
for (int j = 0; j < size; j++) {
nodeClone.mChildNodes.set(j, clonesMap.get(node.mChildNodes.get(j)));
}
size = node.mSiblings == null ? 0 : node.mSiblings.size();
for (int j = 0; j < size; j++) {
nodeClone.mSiblings.set(j, clonesMap.get(node.mSiblings.get(j)));
}
size = node.mParents == null ? 0 : node.mParents.size();
for (int j = 0; j < size; j++) {
nodeClone.mParents.set(j, clonesMap.get(node.mParents.get(j)));
}
}
return anim;
}
/**
* AnimatorSet is only reversible when the set contains no sequential animation, and no child
* animators have a start delay.
* @hide
*/
@Override
public boolean canReverse() {
return getTotalDuration() != DURATION_INFINITE;
}
/**
* 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() {
start(true, true);
}
@Override
public String toString() {
String returnVal = "AnimatorSet@" + Integer.toHexString(hashCode()) + "{";
int size = mNodes.size();
for (int i = 0; i < size; i++) {
Node node = mNodes.get(i);
returnVal += "\n " + node.mAnimation.toString();
}
return returnVal + "\n}";
}
private void printChildCount() {
// Print out the child count through a level traverse.
ArrayList list = new ArrayList<>(mNodes.size());
list.add(mRootNode);
Log.d(TAG, "Current tree: ");
int index = 0;
while (index < list.size()) {
int listSize = list.size();
StringBuilder builder = new StringBuilder();
for (; index < listSize; index++) {
Node node = list.get(index);
int num = 0;
if (node.mChildNodes != null) {
for (int i = 0; i < node.mChildNodes.size(); i++) {
Node child = node.mChildNodes.get(i);
if (child.mLatestParent == node) {
num++;
list.add(child);
}
}
}
builder.append(" ");
builder.append(num);
}
Log.d(TAG, builder.toString());
}
}
private void createDependencyGraph() {
if (!mDependencyDirty) {
// Check whether any duration of the child animations has changed
boolean durationChanged = false;
for (int i = 0; i < mNodes.size(); i++) {
Animator anim = mNodes.get(i).mAnimation;
if (mNodes.get(i).mTotalDuration != anim.getTotalDuration()) {
durationChanged = true;
break;
}
}
if (!durationChanged) {
return;
}
}
mDependencyDirty = false;
// Traverse all the siblings and make sure they have all the parents
int size = mNodes.size();
for (int i = 0; i < size; i++) {
mNodes.get(i).mParentsAdded = false;
}
for (int i = 0; i < size; i++) {
Node node = mNodes.get(i);
if (node.mParentsAdded) {
continue;
}
node.mParentsAdded = true;
if (node.mSiblings == null) {
continue;
}
// Find all the siblings
findSiblings(node, node.mSiblings);
node.mSiblings.remove(node);
// Get parents from all siblings
int siblingSize = node.mSiblings.size();
for (int j = 0; j < siblingSize; j++) {
node.addParents(node.mSiblings.get(j).mParents);
}
// Now make sure all siblings share the same set of parents
for (int j = 0; j < siblingSize; j++) {
Node sibling = node.mSiblings.get(j);
sibling.addParents(node.mParents);
sibling.mParentsAdded = true;
}
}
for (int i = 0; i < size; i++) {
Node node = mNodes.get(i);
if (node != mRootNode && node.mParents == null) {
node.addParent(mRootNode);
}
}
// Do a DFS on the tree
ArrayList visited = new ArrayList(mNodes.size());
// Assign start/end time
mRootNode.mStartTime = 0;
mRootNode.mEndTime = mDelayAnim.getDuration();
updatePlayTime(mRootNode, visited);
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 = 1; i < mNodes.size(); i++) {
Node node = mNodes.get(i);
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) {
// For events that happen at the same time, we need them to be in the sequence
// (end, start, start delay ended)
if (e2.mEvent + e1.mEvent == AnimationEvent.ANIMATION_START
+ AnimationEvent.ANIMATION_DELAY_ENDED) {
// Ensure start delay happens after start
return e1.mEvent - e2.mEvent;
} else {
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);
}
});
int eventSize = mEvents.size();
// For the same animation, start event has to happen before end.
for (int i = 0; i < eventSize;) {
AnimationEvent event = mEvents.get(i);
if (event.mEvent == AnimationEvent.ANIMATION_END) {
boolean needToSwapStart;
if (event.mNode.mStartTime == event.mNode.mEndTime) {
needToSwapStart = true;
} else if (event.mNode.mEndTime == event.mNode.mStartTime
+ event.mNode.mAnimation.getStartDelay()) {
// Swapping start delay
needToSwapStart = false;
} else {
i++;
continue;
}
int startEventId = eventSize;
int startDelayEndId = eventSize;
for (int j = i + 1; j < eventSize; j++) {
if (startEventId < eventSize && startDelayEndId < eventSize) {
break;
}
if (mEvents.get(j).mNode == event.mNode) {
if (mEvents.get(j).mEvent == AnimationEvent.ANIMATION_START) {
// Found start event
startEventId = j;
} else if (mEvents.get(j).mEvent == AnimationEvent.ANIMATION_DELAY_ENDED) {
startDelayEndId = j;
}
}
}
if (needToSwapStart && startEventId == mEvents.size()) {
throw new UnsupportedOperationException("Something went wrong, no start is"
+ "found after stop for an animation that has the same start and end"
+ "time.");
}
if (startDelayEndId == mEvents.size()) {
throw new UnsupportedOperationException("Something went wrong, no start"
+ "delay end is found after stop for an animation");
}
// We need to make sure start is inserted before start delay ended event,
// because otherwise inserting start delay ended events first would change
// the start event index.
if (needToSwapStart) {
AnimationEvent startEvent = mEvents.remove(startEventId);
mEvents.add(i, startEvent);
i++;
}
AnimationEvent startDelayEndEvent = mEvents.remove(startDelayEndId);
mEvents.add(i, startDelayEndEvent);
i += 2;
} else {
i++;
}
}
if (!mEvents.isEmpty() && mEvents.get(0).mEvent != AnimationEvent.ANIMATION_START) {
throw new UnsupportedOperationException(
"Sorting went bad, the start event should always be at index 0");
}
// Add AnimatorSet's start delay node to the beginning
mEvents.add(0, new AnimationEvent(mRootNode, AnimationEvent.ANIMATION_START));
mEvents.add(1, new AnimationEvent(mRootNode, AnimationEvent.ANIMATION_DELAY_ENDED));
mEvents.add(2, new AnimationEvent(mRootNode, AnimationEvent.ANIMATION_END));
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");
}
}
/**
* Based on parent's start/end time, calculate children's start/end time. If cycle exists in
* the graph, all the nodes on the cycle will be marked to start at {@link #DURATION_INFINITE},
* meaning they will ever play.
*/
private void updatePlayTime(Node parent, ArrayList visited) {
if (parent.mChildNodes == null) {
if (parent == mRootNode) {
// All the animators are in a cycle
for (int i = 0; i < mNodes.size(); i++) {
Node node = mNodes.get(i);
if (node != mRootNode) {
node.mStartTime = DURATION_INFINITE;
node.mEndTime = DURATION_INFINITE;
}
}
}
return;
}
visited.add(parent);
int childrenSize = parent.mChildNodes.size();
for (int i = 0; i < childrenSize; i++) {
Node child = parent.mChildNodes.get(i);
child.mTotalDuration = child.mAnimation.getTotalDuration(); // Update cached duration.
int index = visited.indexOf(child);
if (index >= 0) {
// Child has been visited, cycle found. Mark all the nodes in the cycle.
for (int j = index; j < visited.size(); j++) {
visited.get(j).mLatestParent = null;
visited.get(j).mStartTime = DURATION_INFINITE;
visited.get(j).mEndTime = DURATION_INFINITE;
}
child.mStartTime = DURATION_INFINITE;
child.mEndTime = DURATION_INFINITE;
child.mLatestParent = null;
Log.w(TAG, "Cycle found in AnimatorSet: " + this);
continue;
}
if (child.mStartTime != DURATION_INFINITE) {
if (parent.mEndTime == DURATION_INFINITE) {
child.mLatestParent = parent;
child.mStartTime = DURATION_INFINITE;
child.mEndTime = DURATION_INFINITE;
} else {
if (parent.mEndTime >= child.mStartTime) {
child.mLatestParent = parent;
child.mStartTime = parent.mEndTime;
}
child.mEndTime = child.mTotalDuration == DURATION_INFINITE
? DURATION_INFINITE : child.mStartTime + child.mTotalDuration;
}
}
updatePlayTime(child, visited);
}
visited.remove(parent);
}
// Recursively find all the siblings
private void findSiblings(Node node, ArrayList siblings) {
if (!siblings.contains(node)) {
siblings.add(node);
if (node.mSiblings == null) {
return;
}
for (int i = 0; i < node.mSiblings.size(); i++) {
findSiblings(node.mSiblings.get(i), siblings);
}
}
}
/**
* @hide
* TODO: For animatorSet defined in XML, we can use a flag to indicate what the play order
* if defined (i.e. sequential or together), then we can use the flag instead of calculating
* dynamically. Note that when AnimatorSet is empty this method returns true.
* @return whether all the animators in the set are supposed to play together
*/
public boolean shouldPlayTogether() {
updateAnimatorsDuration();
createDependencyGraph();
// All the child nodes are set out to play right after the delay animation
return mRootNode.mChildNodes == null || mRootNode.mChildNodes.size() == mNodes.size() - 1;
}
@Override
public long getTotalDuration() {
updateAnimatorsDuration();
createDependencyGraph();
return mTotalDuration;
}
private Node getNodeForAnimation(Animator anim) {
Node node = mNodeMap.get(anim);
if (node == null) {
node = new Node(anim);
mNodeMap.put(anim, node);
mNodes.add(node);
}
return node;
}
/**
* A Node is an embodiment of both the Animator that it wraps as well as
* any dependencies that are associated with that Animation. This includes
* both dependencies upon other nodes (in the dependencies list) as
* well as dependencies of other nodes upon this (in the nodeDependents list).
*/
private static class Node implements Cloneable {
Animator mAnimation;
/**
* Child nodes are the nodes associated with animations that will be played immediately
* after current node.
*/
ArrayList mChildNodes = null;
/**
* Flag indicating whether the animation in this node is finished. This flag
* is used by AnimatorSet to check, as each animation ends, whether all child animations
* are mEnded and it's time to send out an end event for the entire AnimatorSet.
*/
boolean mEnded = false;
/**
* Nodes with animations that are defined to play simultaneously with the animation
* associated with this current node.
*/
ArrayList mSiblings;
/**
* Parent nodes are the nodes with animations preceding current node's animation. Parent
* nodes here are derived from user defined animation sequence.
*/
ArrayList mParents;
/**
* Latest parent is the parent node associated with a animation that finishes after all
* the other parents' animations.
*/
Node mLatestParent = null;
boolean mParentsAdded = false;
long mStartTime = 0;
long mEndTime = 0;
long mTotalDuration = 0;
/**
* Constructs the Node with the animation that it encapsulates. A Node has no
* dependencies by default; dependencies are added via the addDependency()
* method.
*
* @param animation The animation that the Node encapsulates.
*/
public Node(Animator animation) {
this.mAnimation = animation;
}
@Override
public Node clone() {
try {
Node node = (Node) super.clone();
node.mAnimation = mAnimation.clone();
if (mChildNodes != null) {
node.mChildNodes = new ArrayList<>(mChildNodes);
}
if (mSiblings != null) {
node.mSiblings = new ArrayList<>(mSiblings);
}
if (mParents != null) {
node.mParents = new ArrayList<>(mParents);
}
node.mEnded = false;
return node;
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
void addChild(Node node) {
if (mChildNodes == null) {
mChildNodes = new ArrayList<>();
}
if (!mChildNodes.contains(node)) {
mChildNodes.add(node);
node.addParent(this);
}
}
public void addSibling(Node node) {
if (mSiblings == null) {
mSiblings = new ArrayList();
}
if (!mSiblings.contains(node)) {
mSiblings.add(node);
node.addSibling(this);
}
}
public void addParent(Node node) {
if (mParents == null) {
mParents = new ArrayList();
}
if (!mParents.contains(node)) {
mParents.add(node);
node.addChild(this);
}
}
public void addParents(ArrayList parents) {
if (parents == null) {
return;
}
int size = parents.size();
for (int i = 0; i < size; i++) {
addParent(parents.get(i));
}
}
}
/**
* 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 == DURATION_INFINITE
? DURATION_INFINITE : 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;
mSeekingInReverse = inReverse;
}
}
}
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
* intention of the Builder methods, along with the {@link
* AnimatorSet#play(Animator) play()} method of AnimatorSet is to make it possible
* to express the dependency relationships of animations in a natural way. Developers can also
* use the {@link AnimatorSet#playTogether(Animator[]) playTogether()} and {@link
* AnimatorSet#playSequentially(Animator[]) playSequentially()} methods if these suit the need,
* but it might be easier in some situations to express the AnimatorSet of animations in pairs.
*
* The Builder object cannot be constructed directly, but is rather constructed
* internally via a call to {@link AnimatorSet#play(Animator)}.
*
* For example, this sets up a AnimatorSet to play anim1 and anim2 at the same time, anim3 to
* play when anim2 finishes, and anim4 to play when anim3 finishes:
*
* AnimatorSet s = new AnimatorSet();
* s.play(anim1).with(anim2);
* s.play(anim2).before(anim3);
* s.play(anim4).after(anim3);
*
*
* Note in the example that both {@link Builder#before(Animator)} and {@link
* Builder#after(Animator)} are used. These are just different ways of expressing the same
* relationship and are provided to make it easier to say things in a way that is more natural,
* depending on the situation.
*
* It is possible to make several calls into the same Builder object to express
* multiple relationships. However, note that it is only the animation passed into the initial
* {@link AnimatorSet#play(Animator)} method that is the dependency in any of the successive
* calls to the Builder object. For example, the following code starts both anim2
* and anim3 when anim1 ends; there is no direct dependency relationship between anim2 and
* anim3:
*
* AnimatorSet s = new AnimatorSet();
* s.play(anim1).before(anim2).before(anim3);
*
* If the desired result is to play anim1 then anim2 then anim3, this code expresses the
* relationship correctly:
*
* AnimatorSet s = new AnimatorSet();
* s.play(anim1).before(anim2);
* s.play(anim2).before(anim3);
*
*
* Note that it is possible to express relationships that cannot be resolved and will not
* result in sensible results. For example, play(anim1).after(anim1) makes no
* sense. In general, circular dependencies like this one (or more indirect ones where a depends
* on b, which depends on c, which depends on a) should be avoided. Only create AnimatorSets
* that can boil down to a simple, one-way relationship of animations starting with, before, and
* after other, different, animations.
*/
public class Builder {
/**
* This tracks the current node being processed. It is supplied to the play() method
* of AnimatorSet and passed into the constructor of Builder.
*/
private Node mCurrentNode;
/**
* package-private constructor. Builders are only constructed by AnimatorSet, when the
* play() method is called.
*
* @param anim The animation that is the dependency for the other animations passed into
* the other methods of this Builder object.
*/
Builder(Animator anim) {
mDependencyDirty = true;
mCurrentNode = getNodeForAnimation(anim);
}
/**
* Sets up the given animation to play at the same time as the animation supplied in the
* {@link AnimatorSet#play(Animator)} call that created this Builder object.
*
* @param anim The animation that will play when the animation supplied to the
* {@link AnimatorSet#play(Animator)} method starts.
*/
public Builder with(Animator anim) {
Node node = getNodeForAnimation(anim);
mCurrentNode.addSibling(node);
return this;
}
/**
* Sets up the given animation to play when the animation supplied in the
* {@link AnimatorSet#play(Animator)} call that created this Builder object
* ends.
*
* @param anim The animation that will play when the animation supplied to the
* {@link AnimatorSet#play(Animator)} method ends.
*/
public Builder before(Animator anim) {
Node node = getNodeForAnimation(anim);
mCurrentNode.addChild(node);
return this;
}
/**
* Sets up the given animation to play when the animation supplied in the
* {@link AnimatorSet#play(Animator)} call that created this Builder object
* to start when the animation supplied in this method call ends.
*
* @param anim The animation whose end will cause the animation supplied to the
* {@link AnimatorSet#play(Animator)} method to play.
*/
public Builder after(Animator anim) {
Node node = getNodeForAnimation(anim);
mCurrentNode.addParent(node);
return this;
}
/**
* Sets up the animation supplied in the
* {@link AnimatorSet#play(Animator)} call that created this Builder object
* to play when the given amount of time elapses.
*
* @param delay The number of milliseconds that should elapse before the
* animation starts.
*/
public Builder after(long delay) {
// setup dummy ValueAnimator just to run the clock
ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
anim.setDuration(delay);
after(anim);
return this;
}
}
}