Project: 4308Cirrus
Code Examples
/*
 * 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); 
    } 
}