mirror of https://github.com/tasks/tasks
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
279 lines
10 KiB
Java
279 lines
10 KiB
Java
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.actionbarsherlock.internal.nineoldandroids.animation;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import android.view.animation.Interpolator;
|
|
|
|
/**
|
|
* This is the superclass for classes which provide basic support for animations which can be
|
|
* started, ended, and have <code>AnimatorListeners</code> added to them.
|
|
*/
|
|
public abstract class Animator implements Cloneable {
|
|
|
|
|
|
/**
|
|
* The set of listeners to be sent events through the life of an animation.
|
|
*/
|
|
ArrayList<AnimatorListener> mListeners = null;
|
|
|
|
/**
|
|
* Starts this animation. If the animation has a nonzero startDelay, the animation will start
|
|
* running after that delay elapses. A non-delayed animation will have its initial
|
|
* value(s) set immediately, followed by calls to
|
|
* {@link AnimatorListener#onAnimationStart(Animator)} for any listeners of this animator.
|
|
*
|
|
* <p>The animation started by calling this method will be run on the thread that called
|
|
* this method. This thread should have a Looper on it (a runtime exception will be thrown if
|
|
* this is not the case). Also, if the animation will animate
|
|
* properties of objects in the view hierarchy, then the calling thread should be the UI
|
|
* thread for that view hierarchy.</p>
|
|
*
|
|
*/
|
|
public void start() {
|
|
}
|
|
|
|
/**
|
|
* Cancels the animation. Unlike {@link #end()}, <code>cancel()</code> causes the animation to
|
|
* stop in its tracks, sending an
|
|
* {@link android.animation.Animator.AnimatorListener#onAnimationCancel(Animator)} to
|
|
* its listeners, followed by an
|
|
* {@link android.animation.Animator.AnimatorListener#onAnimationEnd(Animator)} message.
|
|
*
|
|
* <p>This method must be called on the thread that is running the animation.</p>
|
|
*/
|
|
public void cancel() {
|
|
}
|
|
|
|
/**
|
|
* Ends the animation. This causes the animation to assign the end value of the property being
|
|
* animated, then calling the
|
|
* {@link android.animation.Animator.AnimatorListener#onAnimationEnd(Animator)} method on
|
|
* its listeners.
|
|
*
|
|
* <p>This method must be called on the thread that is running the animation.</p>
|
|
*/
|
|
public void end() {
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
public abstract long getStartDelay();
|
|
|
|
/**
|
|
* The amount of time, in milliseconds, to delay starting the animation after
|
|
* {@link #start()} is called.
|
|
|
|
* @param startDelay The amount of the delay, in milliseconds
|
|
*/
|
|
public abstract void setStartDelay(long startDelay);
|
|
|
|
|
|
/**
|
|
* Sets the length of the animation.
|
|
*
|
|
* @param duration The length of the animation, in milliseconds.
|
|
*/
|
|
public abstract Animator setDuration(long duration);
|
|
|
|
/**
|
|
* Gets the length of the animation.
|
|
*
|
|
* @return The length of the animation, in milliseconds.
|
|
*/
|
|
public abstract long getDuration();
|
|
|
|
/**
|
|
* The time interpolator used in calculating the elapsed fraction of this animation. The
|
|
* interpolator determines whether the animation runs with linear or non-linear motion,
|
|
* such as acceleration and deceleration. The default value is
|
|
* {@link android.view.animation.AccelerateDecelerateInterpolator}
|
|
*
|
|
* @param value the interpolator to be used by this animation
|
|
*/
|
|
public abstract void setInterpolator(/*Time*/Interpolator value);
|
|
|
|
/**
|
|
* Returns whether this Animator is currently running (having been started and gone past any
|
|
* initial startDelay period and not yet ended).
|
|
*
|
|
* @return Whether the Animator is running.
|
|
*/
|
|
public abstract boolean isRunning();
|
|
|
|
/**
|
|
* Returns whether this Animator has been started and not yet ended. This state is a superset
|
|
* of the state of {@link #isRunning()}, because an Animator with a nonzero
|
|
* {@link #getStartDelay() startDelay} will return true for {@link #isStarted()} during the
|
|
* delay phase, whereas {@link #isRunning()} will return true only after the delay phase
|
|
* is complete.
|
|
*
|
|
* @return Whether the Animator has been started and not yet ended.
|
|
*/
|
|
public boolean isStarted() {
|
|
// Default method returns value for isRunning(). Subclasses should override to return a
|
|
// real value.
|
|
return isRunning();
|
|
}
|
|
|
|
/**
|
|
* Adds a listener to the set of listeners that are sent events through the life of an
|
|
* animation, such as start, repeat, and end.
|
|
*
|
|
* @param listener the listener to be added to the current set of listeners for this animation.
|
|
*/
|
|
public void addListener(AnimatorListener listener) {
|
|
if (mListeners == null) {
|
|
mListeners = new ArrayList<AnimatorListener>();
|
|
}
|
|
mListeners.add(listener);
|
|
}
|
|
|
|
/**
|
|
* Removes a listener from the set listening to this animation.
|
|
*
|
|
* @param listener the listener to be removed from the current set of listeners for this
|
|
* animation.
|
|
*/
|
|
public void removeListener(AnimatorListener listener) {
|
|
if (mListeners == null) {
|
|
return;
|
|
}
|
|
mListeners.remove(listener);
|
|
if (mListeners.size() == 0) {
|
|
mListeners = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the set of {@link android.animation.Animator.AnimatorListener} objects that are currently
|
|
* listening for events on this <code>Animator</code> object.
|
|
*
|
|
* @return ArrayList<AnimatorListener> The set of listeners.
|
|
*/
|
|
public ArrayList<AnimatorListener> getListeners() {
|
|
return mListeners;
|
|
}
|
|
|
|
/**
|
|
* Removes all listeners from this object. This is equivalent to calling
|
|
* <code>getListeners()</code> followed by calling <code>clear()</code> on the
|
|
* returned list of listeners.
|
|
*/
|
|
public void removeAllListeners() {
|
|
if (mListeners != null) {
|
|
mListeners.clear();
|
|
mListeners = null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Animator clone() {
|
|
try {
|
|
final Animator anim = (Animator) super.clone();
|
|
if (mListeners != null) {
|
|
ArrayList<AnimatorListener> oldListeners = mListeners;
|
|
anim.mListeners = new ArrayList<AnimatorListener>();
|
|
int numListeners = oldListeners.size();
|
|
for (int i = 0; i < numListeners; ++i) {
|
|
anim.mListeners.add(oldListeners.get(i));
|
|
}
|
|
}
|
|
return anim;
|
|
} catch (CloneNotSupportedException e) {
|
|
throw new AssertionError();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method tells the object to use appropriate information to extract
|
|
* starting values for the animation. For example, a AnimatorSet object will pass
|
|
* this call to its child objects to tell them to set up the values. A
|
|
* ObjectAnimator object will use the information it has about its target object
|
|
* and PropertyValuesHolder objects to get the start values for its properties.
|
|
* An ValueAnimator object will ignore the request since it does not have enough
|
|
* information (such as a target object) to gather these values.
|
|
*/
|
|
public void setupStartValues() {
|
|
}
|
|
|
|
/**
|
|
* This method tells the object to use appropriate information to extract
|
|
* ending values for the animation. For example, a AnimatorSet object will pass
|
|
* this call to its child objects to tell them to set up the values. A
|
|
* ObjectAnimator object will use the information it has about its target object
|
|
* and PropertyValuesHolder objects to get the start values for its properties.
|
|
* An ValueAnimator object will ignore the request since it does not have enough
|
|
* information (such as a target object) to gather these values.
|
|
*/
|
|
public void setupEndValues() {
|
|
}
|
|
|
|
/**
|
|
* Sets the target object whose property will be animated by this animation. Not all subclasses
|
|
* operate on target objects (for example, {@link ValueAnimator}, but this method
|
|
* is on the superclass for the convenience of dealing generically with those subclasses
|
|
* that do handle targets.
|
|
*
|
|
* @param target The object being animated
|
|
*/
|
|
public void setTarget(Object target) {
|
|
}
|
|
|
|
/**
|
|
* <p>An animation listener receives notifications from an animation.
|
|
* Notifications indicate animation related events, such as the end or the
|
|
* repetition of the animation.</p>
|
|
*/
|
|
public static interface AnimatorListener {
|
|
/**
|
|
* <p>Notifies the start of the animation.</p>
|
|
*
|
|
* @param animation The started animation.
|
|
*/
|
|
void onAnimationStart(Animator animation);
|
|
|
|
/**
|
|
* <p>Notifies the end of the animation. This callback is not invoked
|
|
* for animations with repeat count set to INFINITE.</p>
|
|
*
|
|
* @param animation The animation which reached its end.
|
|
*/
|
|
void onAnimationEnd(Animator animation);
|
|
|
|
/**
|
|
* <p>Notifies the cancellation of the animation. This callback is not invoked
|
|
* for animations with repeat count set to INFINITE.</p>
|
|
*
|
|
* @param animation The animation which was canceled.
|
|
*/
|
|
void onAnimationCancel(Animator animation);
|
|
|
|
/**
|
|
* <p>Notifies the repetition of the animation.</p>
|
|
*
|
|
* @param animation The animation which was repeated.
|
|
*/
|
|
void onAnimationRepeat(Animator animation);
|
|
}
|
|
}
|