core/java/android/view/animation/AnimationSet.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2006 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 android.view.animation;

 import android.content.Context;
 import android.content.res.TypedArray;
 import android.os.Build;
 import android.util.AttributeSet;
 import android.graphics.RectF;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * Represents a group of Animations that should be played together.
  * The transformation of each individual animation are composed
  * together into a single transform.
  * If AnimationSet sets any properties that its children also set
  * (for example, duration or fillBefore), the values of AnimationSet
  * override the child values.
  *
  * <p>The way that AnimationSet inherits behavior from Animation is important to
  * understand. Some of the Animation attributes applied to AnimationSet affect the
  * AnimationSet itself, some are pushed down to the children, and some are ignored,
  * as follows:
  * <ul>
  *     <li>duration, repeatMode, fillBefore, fillAfter: These properties, when set
  *     on an AnimationSet object, will be pushed down to all child animations.</li>
  *     <li>repeatCount, fillEnabled: These properties are ignored for AnimationSet.</li>
  *     <li>startOffset, shareInterpolator: These properties apply to the AnimationSet itself.</li>
  * </ul>
  * Starting with {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH},
  * the behavior of these properties is the same in XML resources and at runtime (prior to that
  * release, the values set in XML were ignored for AnimationSet). That is, calling
  * <code>setDuration(500)</code> on an AnimationSet has the same effect as declaring
  * <code>android:duration="500"</code> in an XML resource for an AnimationSet object.</p>
  */
 public class AnimationSet extends Animation {
     private static final int PROPERTY_FILL_AFTER_MASK         = 0x1;
     private static final int PROPERTY_FILL_BEFORE_MASK        = 0x2;
     private static final int PROPERTY_REPEAT_MODE_MASK        = 0x4;
     private static final int PROPERTY_START_OFFSET_MASK       = 0x8;
     private static final int PROPERTY_SHARE_INTERPOLATOR_MASK = 0x10;
     private static final int PROPERTY_DURATION_MASK           = 0x20;
     private static final int PROPERTY_MORPH_MATRIX_MASK       = 0x40;
     private static final int PROPERTY_CHANGE_BOUNDS_MASK      = 0x80;

     private int mFlags = 0;
     private boolean mDirty;
     private boolean mHasAlpha;

     private ArrayList<Animation> mAnimations = new ArrayList<Animation>();

     private Transformation mTempTransformation = new Transformation();

     private long mLastEnd;

     private long[] mStoredOffsets;

     /**
      * Constructor used when an AnimationSet is loaded from a resource.
      *
      * @param context Application context to use
      * @param attrs Attribute set from which to read values
      */
     public AnimationSet(Context context, AttributeSet attrs) {
         super(context, attrs);

         TypedArray a =
             context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AnimationSet);

         setFlag(PROPERTY_SHARE_INTERPOLATOR_MASK,
                 a.getBoolean(com.android.internal.R.styleable.AnimationSet_shareInterpolator, true));
         init();

         if (context.getApplicationInfo().targetSdkVersion >=
                 Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
             if (a.hasValue(com.android.internal.R.styleable.AnimationSet_duration)) {
                 mFlags |= PROPERTY_DURATION_MASK;
             }
             if (a.hasValue(com.android.internal.R.styleable.AnimationSet_fillBefore)) {
                 mFlags |= PROPERTY_FILL_BEFORE_MASK;
             }
             if (a.hasValue(com.android.internal.R.styleable.AnimationSet_fillAfter)) {
                 mFlags |= PROPERTY_FILL_AFTER_MASK;
             }
             if (a.hasValue(com.android.internal.R.styleable.AnimationSet_repeatMode)) {
                 mFlags |= PROPERTY_REPEAT_MODE_MASK;
             }
             if (a.hasValue(com.android.internal.R.styleable.AnimationSet_startOffset)) {
                 mFlags |= PROPERTY_START_OFFSET_MASK;
             }
         }

         a.recycle();
     }


     /**
      * Constructor to use when building an AnimationSet from code
      *
      * @param shareInterpolator Pass true if all of the animations in this set
      *        should use the interpolator assocciated with this AnimationSet.
      *        Pass false if each animation should use its own interpolator.
      */
     public AnimationSet(boolean shareInterpolator) {
         setFlag(PROPERTY_SHARE_INTERPOLATOR_MASK, shareInterpolator);
         init();
     }

     @Override
     protected AnimationSet clone() throws CloneNotSupportedException {
         final AnimationSet animation = (AnimationSet) super.clone();
         animation.mTempTransformation = new Transformation();
         animation.mAnimations = new ArrayList<Animation>();

         final int count = mAnimations.size();
         final ArrayList<Animation> animations = mAnimations;

         for (int i = 0; i < count; i++) {
             animation.mAnimations.add(animations.get(i).clone());
         }

         return animation;
     }

     private void setFlag(int mask, boolean value) {
         if (value) {
             mFlags |= mask;
         } else {
             mFlags &= ~mask;
         }
     }

     private void init() {
         mStartTime = 0;
     }

     @Override
     public void setFillAfter(boolean fillAfter) {
         mFlags |= PROPERTY_FILL_AFTER_MASK;
         super.setFillAfter(fillAfter);
     }

     @Override
     public void setFillBefore(boolean fillBefore) {
         mFlags |= PROPERTY_FILL_BEFORE_MASK;
         super.setFillBefore(fillBefore);
     }

     @Override
     public void setRepeatMode(int repeatMode) {
         mFlags |= PROPERTY_REPEAT_MODE_MASK;
         super.setRepeatMode(repeatMode);
     }

     @Override
     public void setStartOffset(long startOffset) {
         mFlags |= PROPERTY_START_OFFSET_MASK;
         super.setStartOffset(startOffset);
     }

     /**
      * @hide
      */
     @Override
     public boolean hasAlpha() {
         if (mDirty) {
             mDirty = mHasAlpha = false;

             final int count = mAnimations.size();
             final ArrayList<Animation> animations = mAnimations;

             for (int i = 0; i < count; i++) {
                 if (animations.get(i).hasAlpha()) {
                     mHasAlpha = true;
                     break;
                 }
             }
         }

         return mHasAlpha;
     }

     /**
      * <p>Sets the duration of every child animation.</p>
      *
      * @param durationMillis the duration of the animation, in milliseconds, for
      *        every child in this set
      */
     @Override
     public void setDuration(long durationMillis) {
         mFlags |= PROPERTY_DURATION_MASK;
         super.setDuration(durationMillis);
         mLastEnd = mStartOffset + mDuration;
     }

     /**
      * Add a child animation to this animation set.
      * The transforms of the child animations are applied in the order
      * that they were added
      * @param a Animation to add.
      */
     public void addAnimation(Animation a) {
         mAnimations.add(a);

         boolean noMatrix = (mFlags & PROPERTY_MORPH_MATRIX_MASK) == 0;
         if (noMatrix && a.willChangeTransformationMatrix()) {
             mFlags |= PROPERTY_MORPH_MATRIX_MASK;
         }

         boolean changeBounds = (mFlags & PROPERTY_CHANGE_BOUNDS_MASK) == 0;


         if (changeBounds && a.willChangeBounds()) {
             mFlags |= PROPERTY_CHANGE_BOUNDS_MASK;
         }

         if ((mFlags & PROPERTY_DURATION_MASK) == PROPERTY_DURATION_MASK) {
             mLastEnd = mStartOffset + mDuration;
         } else {
             if (mAnimations.size() == 1) {
                 mDuration = a.getStartOffset() + a.getDuration();
                 mLastEnd = mStartOffset + mDuration;
             } else {
                 mLastEnd = Math.max(mLastEnd, a.getStartOffset() + a.getDuration());
                 mDuration = mLastEnd - mStartOffset;
             }
         }

         mDirty = true;
     }

     /**
      * Sets the start time of this animation and all child animations
      *
      * @see android.view.animation.Animation#setStartTime(long)
      */
     @Override
     public void setStartTime(long startTimeMillis) {
         super.setStartTime(startTimeMillis);

         final int count = mAnimations.size();
         final ArrayList<Animation> animations = mAnimations;

         for (int i = 0; i < count; i++) {
             Animation a = animations.get(i);
             a.setStartTime(startTimeMillis);
         }
     }

     @Override
     public long getStartTime() {
         long startTime = Long.MAX_VALUE;

         final int count = mAnimations.size();
         final ArrayList<Animation> animations = mAnimations;

         for (int i = 0; i < count; i++) {
             Animation a = animations.get(i);
             startTime = Math.min(startTime, a.getStartTime());
         }

         return startTime;
     }

     @Override
     public void restrictDuration(long durationMillis) {
         super.restrictDuration(durationMillis);

         final ArrayList<Animation> animations = mAnimations;
         int count = animations.size();

         for (int i = 0; i < count; i++) {
             animations.get(i).restrictDuration(durationMillis);
         }
     }

     /**
      * The duration of an AnimationSet is defined to be the
      * duration of the longest child animation.
      *
      * @see android.view.animation.Animation#getDuration()
      */
     @Override
     public long getDuration() {
         final ArrayList<Animation> animations = mAnimations;
         final int count = animations.size();
         long duration = 0;

         boolean durationSet = (mFlags & PROPERTY_DURATION_MASK) == PROPERTY_DURATION_MASK;
         if (durationSet) {
             duration = mDuration;
         } else {
             for (int i = 0; i < count; i++) {
                 duration = Math.max(duration, animations.get(i).getDuration());
             }
         }

         return duration;
     }

     /**
      * The duration hint of an animation set is the maximum of the duration
      * hints of all of its component animations.
      *
      * @see android.view.animation.Animation#computeDurationHint
      */
     public long computeDurationHint() {
         long duration = 0;
         final int count = mAnimations.size();
         final ArrayList<Animation> animations = mAnimations;
         for (int i = count - 1; i >= 0; --i) {
             final long d = animations.get(i).computeDurationHint();
             if (d > duration) duration = d;
         }
         return duration;
     }

     /**
      * @hide
      */
     public void initializeInvalidateRegion(int left, int top, int right, int bottom) {
         final RectF region = mPreviousRegion;
         region.set(left, top, right, bottom);
         region.inset(-1.0f, -1.0f);

         if (mFillBefore) {
             final int count = mAnimations.size();
             final ArrayList<Animation> animations = mAnimations;
             final Transformation temp = mTempTransformation;

             final Transformation previousTransformation = mPreviousTransformation;

             for (int i = count - 1; i >= 0; --i) {
                 final Animation a = animations.get(i);
                 if (!a.isFillEnabled() || a.getFillBefore() || a.getStartOffset() == 0) {
                     temp.clear();
                     final Interpolator interpolator = a.mInterpolator;
                     a.applyTransformation(interpolator != null ? interpolator.getInterpolation(0.0f)
                             : 0.0f, temp);
                     previousTransformation.compose(temp);
                 }
             }
         }
     }

     /**
      * The transformation of an animation set is the concatenation of all of its
      * component animations.
      *
      * @see android.view.animation.Animation#getTransformation
      */
     @Override
     public boolean getTransformation(long currentTime, Transformation t) {
         final int count = mAnimations.size();
         final ArrayList<Animation> animations = mAnimations;
         final Transformation temp = mTempTransformation;

         boolean more = false;
         boolean started = false;
         boolean ended = true;

         t.clear();

         for (int i = count - 1; i >= 0; --i) {
             final Animation a = animations.get(i);

             temp.clear();
             more = a.getTransformation(currentTime, temp, getScaleFactor()) || more;
             t.compose(temp);

             started = started || a.hasStarted();
             ended = a.hasEnded() && ended;
         }

         if (started && !mStarted) {
             if (mListener != null) {
                 mListener.onAnimationStart(this);
             }
             mStarted = true;
         }

         if (ended != mEnded) {
             if (mListener != null) {
                 mListener.onAnimationEnd(this);
             }
             mEnded = ended;
         }

         return more;
     }

     /**
      * @see android.view.animation.Animation#scaleCurrentDuration(float)
      */
     @Override
     public void scaleCurrentDuration(float scale) {
         final ArrayList<Animation> animations = mAnimations;
         int count = animations.size();
         for (int i = 0; i < count; i++) {
             animations.get(i).scaleCurrentDuration(scale);
         }
     }

     /**
      * @see android.view.animation.Animation#initialize(int, int, int, int)
      */
     @Override
     public void initialize(int width, int height, int parentWidth, int parentHeight) {
         super.initialize(width, height, parentWidth, parentHeight);

         boolean durationSet = (mFlags & PROPERTY_DURATION_MASK) == PROPERTY_DURATION_MASK;
         boolean fillAfterSet = (mFlags & PROPERTY_FILL_AFTER_MASK) == PROPERTY_FILL_AFTER_MASK;
         boolean fillBeforeSet = (mFlags & PROPERTY_FILL_BEFORE_MASK) == PROPERTY_FILL_BEFORE_MASK;
         boolean repeatModeSet = (mFlags & PROPERTY_REPEAT_MODE_MASK) == PROPERTY_REPEAT_MODE_MASK;
         boolean shareInterpolator = (mFlags & PROPERTY_SHARE_INTERPOLATOR_MASK)
                 == PROPERTY_SHARE_INTERPOLATOR_MASK;
         boolean startOffsetSet = (mFlags & PROPERTY_START_OFFSET_MASK)
                 == PROPERTY_START_OFFSET_MASK;

         if (shareInterpolator) {
             ensureInterpolator();
         }

         final ArrayList<Animation> children = mAnimations;
         final int count = children.size();

         final long duration = mDuration;
         final boolean fillAfter = mFillAfter;
         final boolean fillBefore = mFillBefore;
         final int repeatMode = mRepeatMode;
         final Interpolator interpolator = mInterpolator;
         final long startOffset = mStartOffset;


         long[] storedOffsets = mStoredOffsets;
         if (startOffsetSet) {
             if (storedOffsets == null || storedOffsets.length != count) {
                 storedOffsets = mStoredOffsets = new long[count];
             }
         } else if (storedOffsets != null) {
             storedOffsets = mStoredOffsets = null;
         }

         for (int i = 0; i < count; i++) {
             Animation a = children.get(i);
             if (durationSet) {
                 a.setDuration(duration);
             }
             if (fillAfterSet) {
                 a.setFillAfter(fillAfter);
             }
             if (fillBeforeSet) {
                 a.setFillBefore(fillBefore);
             }
             if (repeatModeSet) {
                 a.setRepeatMode(repeatMode);
             }
             if (shareInterpolator) {
                 a.setInterpolator(interpolator);
             }
             if (startOffsetSet) {
                 long offset = a.getStartOffset();
                 a.setStartOffset(offset + startOffset);
                 storedOffsets[i] = offset;
             }
             a.initialize(width, height, parentWidth, parentHeight);
         }
     }

     @Override
     public void reset() {
         super.reset();
         restoreChildrenStartOffset();
     }

     /**
      * @hide
      */
     void restoreChildrenStartOffset() {
         final long[] offsets = mStoredOffsets;
         if (offsets == null) return;

         final ArrayList<Animation> children = mAnimations;
         final int count = children.size();

         for (int i = 0; i < count; i++) {
             children.get(i).setStartOffset(offsets[i]);
         }
     }

     /**
      * @return All the child animations in this AnimationSet. Note that
      * this may include other AnimationSets, which are not expanded.
      */
     public List<Animation> getAnimations() {
         return mAnimations;
     }

     @Override
     public boolean willChangeTransformationMatrix() {
         return (mFlags & PROPERTY_MORPH_MATRIX_MASK) == PROPERTY_MORPH_MATRIX_MASK;
     }

     @Override
     public boolean willChangeBounds() {
         return (mFlags & PROPERTY_CHANGE_BOUNDS_MASK) == PROPERTY_CHANGE_BOUNDS_MASK;
     }
 }
	/*
	* Copyright (C) 2006 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 android.view.animation;

	import android.content.Context;
	import android.content.res.TypedArray;
	import android.os.Build;
	import android.util.AttributeSet;
	import android.graphics.RectF;

	import java.util.ArrayList;
	import java.util.List;

	/**
	* Represents a group of Animations that should be played together.
	* The transformation of each individual animation are composed
	* together into a single transform.
	* If AnimationSet sets any properties that its children also set
	* (for example, duration or fillBefore), the values of AnimationSet
	* override the child values.
	*
	* <p>The way that AnimationSet inherits behavior from Animation is important to
	* understand. Some of the Animation attributes applied to AnimationSet affect the
	* AnimationSet itself, some are pushed down to the children, and some are ignored,
	* as follows:
	* <ul>
	* <li>duration, repeatMode, fillBefore, fillAfter: These properties, when set
	* on an AnimationSet object, will be pushed down to all child animations.</li>
	* <li>repeatCount, fillEnabled: These properties are ignored for AnimationSet.</li>
	* <li>startOffset, shareInterpolator: These properties apply to the AnimationSet itself.</li>
	* </ul>
	* Starting with {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH},
	* the behavior of these properties is the same in XML resources and at runtime (prior to that
	* release, the values set in XML were ignored for AnimationSet). That is, calling
	* <code>setDuration(500)</code> on an AnimationSet has the same effect as declaring
	* <code>android:duration="500"</code> in an XML resource for an AnimationSet object.</p>
	*/
	public class AnimationSet extends Animation {
	private static final int PROPERTY_FILL_AFTER_MASK = 0x1;
	private static final int PROPERTY_FILL_BEFORE_MASK = 0x2;
	private static final int PROPERTY_REPEAT_MODE_MASK = 0x4;
	private static final int PROPERTY_START_OFFSET_MASK = 0x8;
	private static final int PROPERTY_SHARE_INTERPOLATOR_MASK = 0x10;
	private static final int PROPERTY_DURATION_MASK = 0x20;
	private static final int PROPERTY_MORPH_MATRIX_MASK = 0x40;
	private static final int PROPERTY_CHANGE_BOUNDS_MASK = 0x80;

	private int mFlags = 0;
	private boolean mDirty;
	private boolean mHasAlpha;

	private ArrayList<Animation> mAnimations = new ArrayList<Animation>();

	private Transformation mTempTransformation = new Transformation();

	private long mLastEnd;

	private long[] mStoredOffsets;

	/**
	* Constructor used when an AnimationSet is loaded from a resource.
	*
	* @param context Application context to use
	* @param attrs Attribute set from which to read values
	*/
	public AnimationSet(Context context, AttributeSet attrs) {
	super(context, attrs);

	TypedArray a =
	context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AnimationSet);

	setFlag(PROPERTY_SHARE_INTERPOLATOR_MASK,
	a.getBoolean(com.android.internal.R.styleable.AnimationSet_shareInterpolator, true));
	init();

	if (context.getApplicationInfo().targetSdkVersion >=
	Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
	if (a.hasValue(com.android.internal.R.styleable.AnimationSet_duration)) {
	mFlags \|= PROPERTY_DURATION_MASK;
	}
	if (a.hasValue(com.android.internal.R.styleable.AnimationSet_fillBefore)) {
	mFlags \|= PROPERTY_FILL_BEFORE_MASK;
	}
	if (a.hasValue(com.android.internal.R.styleable.AnimationSet_fillAfter)) {
	mFlags \|= PROPERTY_FILL_AFTER_MASK;
	}
	if (a.hasValue(com.android.internal.R.styleable.AnimationSet_repeatMode)) {
	mFlags \|= PROPERTY_REPEAT_MODE_MASK;
	}
	if (a.hasValue(com.android.internal.R.styleable.AnimationSet_startOffset)) {
	mFlags \|= PROPERTY_START_OFFSET_MASK;
	}
	}

	a.recycle();
	}


	/**
	* Constructor to use when building an AnimationSet from code
	*
	* @param shareInterpolator Pass true if all of the animations in this set
	* should use the interpolator assocciated with this AnimationSet.
	* Pass false if each animation should use its own interpolator.
	*/
	public AnimationSet(boolean shareInterpolator) {
	setFlag(PROPERTY_SHARE_INTERPOLATOR_MASK, shareInterpolator);
	init();
	}

	@Override
	protected AnimationSet clone() throws CloneNotSupportedException {
	final AnimationSet animation = (AnimationSet) super.clone();
	animation.mTempTransformation = new Transformation();
	animation.mAnimations = new ArrayList<Animation>();

	final int count = mAnimations.size();
	final ArrayList<Animation> animations = mAnimations;

	for (int i = 0; i < count; i++) {
	animation.mAnimations.add(animations.get(i).clone());
	}

	return animation;
	}

	private void setFlag(int mask, boolean value) {
	if (value) {
	mFlags \|= mask;
	} else {
	mFlags &= ~mask;
	}
	}

	private void init() {
	mStartTime = 0;
	}

	@Override
	public void setFillAfter(boolean fillAfter) {
	mFlags \|= PROPERTY_FILL_AFTER_MASK;
	super.setFillAfter(fillAfter);
	}

	@Override
	public void setFillBefore(boolean fillBefore) {
	mFlags \|= PROPERTY_FILL_BEFORE_MASK;
	super.setFillBefore(fillBefore);
	}

	@Override
	public void setRepeatMode(int repeatMode) {
	mFlags \|= PROPERTY_REPEAT_MODE_MASK;
	super.setRepeatMode(repeatMode);
	}

	@Override
	public void setStartOffset(long startOffset) {
	mFlags \|= PROPERTY_START_OFFSET_MASK;
	super.setStartOffset(startOffset);
	}

	/**
	* @hide
	*/
	@Override
	public boolean hasAlpha() {
	if (mDirty) {
	mDirty = mHasAlpha = false;

	final int count = mAnimations.size();
	final ArrayList<Animation> animations = mAnimations;

	for (int i = 0; i < count; i++) {
	if (animations.get(i).hasAlpha()) {
	mHasAlpha = true;
	break;
	}
	}
	}

	return mHasAlpha;
	}

	/**
	* <p>Sets the duration of every child animation.</p>
	*
	* @param durationMillis the duration of the animation, in milliseconds, for
	* every child in this set
	*/
	@Override
	public void setDuration(long durationMillis) {
	mFlags \|= PROPERTY_DURATION_MASK;
	super.setDuration(durationMillis);
	mLastEnd = mStartOffset + mDuration;
	}

	/**
	* Add a child animation to this animation set.
	* The transforms of the child animations are applied in the order
	* that they were added
	* @param a Animation to add.
	*/
	public void addAnimation(Animation a) {
	mAnimations.add(a);

	boolean noMatrix = (mFlags & PROPERTY_MORPH_MATRIX_MASK) == 0;
	if (noMatrix && a.willChangeTransformationMatrix()) {
	mFlags \|= PROPERTY_MORPH_MATRIX_MASK;
	}

	boolean changeBounds = (mFlags & PROPERTY_CHANGE_BOUNDS_MASK) == 0;


	if (changeBounds && a.willChangeBounds()) {
	mFlags \|= PROPERTY_CHANGE_BOUNDS_MASK;
	}

	if ((mFlags & PROPERTY_DURATION_MASK) == PROPERTY_DURATION_MASK) {
	mLastEnd = mStartOffset + mDuration;
	} else {
	if (mAnimations.size() == 1) {
	mDuration = a.getStartOffset() + a.getDuration();
	mLastEnd = mStartOffset + mDuration;
	} else {
	mLastEnd = Math.max(mLastEnd, a.getStartOffset() + a.getDuration());
	mDuration = mLastEnd - mStartOffset;
	}
	}

	mDirty = true;
	}

	/**
	* Sets the start time of this animation and all child animations
	*
	* @see android.view.animation.Animation#setStartTime(long)
	*/
	@Override
	public void setStartTime(long startTimeMillis) {
	super.setStartTime(startTimeMillis);

	final int count = mAnimations.size();
	final ArrayList<Animation> animations = mAnimations;

	for (int i = 0; i < count; i++) {
	Animation a = animations.get(i);
	a.setStartTime(startTimeMillis);
	}
	}

	@Override
	public long getStartTime() {
	long startTime = Long.MAX_VALUE;

	final int count = mAnimations.size();
	final ArrayList<Animation> animations = mAnimations;

	for (int i = 0; i < count; i++) {
	Animation a = animations.get(i);
	startTime = Math.min(startTime, a.getStartTime());
	}

	return startTime;
	}

	@Override
	public void restrictDuration(long durationMillis) {
	super.restrictDuration(durationMillis);

	final ArrayList<Animation> animations = mAnimations;
	int count = animations.size();

	for (int i = 0; i < count; i++) {
	animations.get(i).restrictDuration(durationMillis);
	}
	}

	/**
	* The duration of an AnimationSet is defined to be the
	* duration of the longest child animation.
	*
	* @see android.view.animation.Animation#getDuration()
	*/
	@Override
	public long getDuration() {
	final ArrayList<Animation> animations = mAnimations;
	final int count = animations.size();
	long duration = 0;

	boolean durationSet = (mFlags & PROPERTY_DURATION_MASK) == PROPERTY_DURATION_MASK;
	if (durationSet) {
	duration = mDuration;
	} else {
	for (int i = 0; i < count; i++) {
	duration = Math.max(duration, animations.get(i).getDuration());
	}
	}

	return duration;
	}

	/**
	* The duration hint of an animation set is the maximum of the duration
	* hints of all of its component animations.
	*
	* @see android.view.animation.Animation#computeDurationHint
	*/
	public long computeDurationHint() {
	long duration = 0;
	final int count = mAnimations.size();
	final ArrayList<Animation> animations = mAnimations;
	for (int i = count - 1; i >= 0; --i) {
	final long d = animations.get(i).computeDurationHint();
	if (d > duration) duration = d;
	}
	return duration;
	}

	/**
	* @hide
	*/
	public void initializeInvalidateRegion(int left, int top, int right, int bottom) {
	final RectF region = mPreviousRegion;
	region.set(left, top, right, bottom);
	region.inset(-1.0f, -1.0f);

	if (mFillBefore) {
	final int count = mAnimations.size();
	final ArrayList<Animation> animations = mAnimations;
	final Transformation temp = mTempTransformation;

	final Transformation previousTransformation = mPreviousTransformation;

	for (int i = count - 1; i >= 0; --i) {
	final Animation a = animations.get(i);
	if (!a.isFillEnabled() \|\| a.getFillBefore() \|\| a.getStartOffset() == 0) {
	temp.clear();
	final Interpolator interpolator = a.mInterpolator;
	a.applyTransformation(interpolator != null ? interpolator.getInterpolation(0.0f)
	: 0.0f, temp);
	previousTransformation.compose(temp);
	}
	}
	}
	}

	/**
	* The transformation of an animation set is the concatenation of all of its
	* component animations.
	*
	* @see android.view.animation.Animation#getTransformation
	*/
	@Override
	public boolean getTransformation(long currentTime, Transformation t) {
	final int count = mAnimations.size();
	final ArrayList<Animation> animations = mAnimations;
	final Transformation temp = mTempTransformation;

	boolean more = false;
	boolean started = false;
	boolean ended = true;

	t.clear();

	for (int i = count - 1; i >= 0; --i) {
	final Animation a = animations.get(i);

	temp.clear();
	more = a.getTransformation(currentTime, temp, getScaleFactor()) \|\| more;
	t.compose(temp);

	started = started \|\| a.hasStarted();
	ended = a.hasEnded() && ended;
	}

	if (started && !mStarted) {
	if (mListener != null) {
	mListener.onAnimationStart(this);
	}
	mStarted = true;
	}

	if (ended != mEnded) {
	if (mListener != null) {
	mListener.onAnimationEnd(this);
	}
	mEnded = ended;
	}

	return more;
	}

	/**
	* @see android.view.animation.Animation#scaleCurrentDuration(float)
	*/
	@Override
	public void scaleCurrentDuration(float scale) {
	final ArrayList<Animation> animations = mAnimations;
	int count = animations.size();
	for (int i = 0; i < count; i++) {
	animations.get(i).scaleCurrentDuration(scale);
	}
	}

	/**
	* @see android.view.animation.Animation#initialize(int, int, int, int)
	*/
	@Override
	public void initialize(int width, int height, int parentWidth, int parentHeight) {
	super.initialize(width, height, parentWidth, parentHeight);

	boolean durationSet = (mFlags & PROPERTY_DURATION_MASK) == PROPERTY_DURATION_MASK;
	boolean fillAfterSet = (mFlags & PROPERTY_FILL_AFTER_MASK) == PROPERTY_FILL_AFTER_MASK;
	boolean fillBeforeSet = (mFlags & PROPERTY_FILL_BEFORE_MASK) == PROPERTY_FILL_BEFORE_MASK;
	boolean repeatModeSet = (mFlags & PROPERTY_REPEAT_MODE_MASK) == PROPERTY_REPEAT_MODE_MASK;
	boolean shareInterpolator = (mFlags & PROPERTY_SHARE_INTERPOLATOR_MASK)
	== PROPERTY_SHARE_INTERPOLATOR_MASK;
	boolean startOffsetSet = (mFlags & PROPERTY_START_OFFSET_MASK)
	== PROPERTY_START_OFFSET_MASK;

	if (shareInterpolator) {
	ensureInterpolator();
	}

	final ArrayList<Animation> children = mAnimations;
	final int count = children.size();

	final long duration = mDuration;
	final boolean fillAfter = mFillAfter;
	final boolean fillBefore = mFillBefore;
	final int repeatMode = mRepeatMode;
	final Interpolator interpolator = mInterpolator;
	final long startOffset = mStartOffset;


	long[] storedOffsets = mStoredOffsets;
	if (startOffsetSet) {
	if (storedOffsets == null \|\| storedOffsets.length != count) {
	storedOffsets = mStoredOffsets = new long[count];
	}
	} else if (storedOffsets != null) {
	storedOffsets = mStoredOffsets = null;
	}

	for (int i = 0; i < count; i++) {
	Animation a = children.get(i);
	if (durationSet) {
	a.setDuration(duration);
	}
	if (fillAfterSet) {
	a.setFillAfter(fillAfter);
	}
	if (fillBeforeSet) {
	a.setFillBefore(fillBefore);
	}
	if (repeatModeSet) {
	a.setRepeatMode(repeatMode);
	}
	if (shareInterpolator) {
	a.setInterpolator(interpolator);
	}
	if (startOffsetSet) {
	long offset = a.getStartOffset();
	a.setStartOffset(offset + startOffset);
	storedOffsets[i] = offset;
	}
	a.initialize(width, height, parentWidth, parentHeight);
	}
	}

	@Override
	public void reset() {
	super.reset();
	restoreChildrenStartOffset();
	}

	/**
	* @hide
	*/
	void restoreChildrenStartOffset() {
	final long[] offsets = mStoredOffsets;
	if (offsets == null) return;

	final ArrayList<Animation> children = mAnimations;
	final int count = children.size();

	for (int i = 0; i < count; i++) {
	children.get(i).setStartOffset(offsets[i]);
	}
	}

	/**
	* @return All the child animations in this AnimationSet. Note that
	* this may include other AnimationSets, which are not expanded.
	*/
	public List<Animation> getAnimations() {
	return mAnimations;
	}

	@Override
	public boolean willChangeTransformationMatrix() {
	return (mFlags & PROPERTY_MORPH_MATRIX_MASK) == PROPERTY_MORPH_MATRIX_MASK;
	}

	@Override
	public boolean willChangeBounds() {
	return (mFlags & PROPERTY_CHANGE_BOUNDS_MASK) == PROPERTY_CHANGE_BOUNDS_MASK;
	}
	}