这次主要就介绍android动画，android动画目前分为三种形式，Tween Animation 这个只能应用于view对象上面的，Drawable Animation这个是帧动画，就是类似我们有一些列的图片依次播放图片时出现的动画，Property Animation 这个是属性动画，这也是在android3.0之后引进的动画，在手机的版本上是android４.0就可以使用这个动画，下面我们主要就是针对这三种情况进行介绍。
Tween Animation
这个动画在Property Animation之前使用最多的，当然在android4.0之后也是有很多人使用这个动画来弄一些简单的动画效果，Tween Animation主要是包括四种动画实现效果：
- AlphaAniamtion:渐变效果，这个是一个透明度的动画效果
AlphaAnimation(float fromAlpha,float toAlpha)
这个就是AlphaAnimation的构造函数，fromAlpha表示的是动画初始时的透明度，toAlpha表示的是动画结束时的透明度，这个取值范围是０～1，0表示的是完全透明，１表示的是完全不透明
- ScaleAnimation:图片进行放大缩小的动画效果，
ScaleAnimation(float fromX, float toX, float fromY,float toY, int pivotXType, float pivotXValue, int pivotYType, float pivotYValue)
上面就是这个Scale参数的情况，这个参数是最多的，fromX：起始X坐标上的伸缩尺寸,toX：结束X坐标上的伸缩尺寸,fromY：起始Y坐标上的伸缩尺寸,toY：结束Y坐标上的伸缩尺寸,关于这个伸缩尺寸，０表示的就是看不见，１表示原始大小，依此类推，１.5表示的就是1.5倍
pivotXType和pivotYType分别表示在X和Y轴上伸缩模式。这里有三个值：
Animation.ABSOLUTE：这个表示的是绝对坐标
Animation.RELATIVE_TO_SELF：相对于自己的坐标
Animation.RELATIVE_TO_PARENT：相对于父控件
上面这些说的都是这个动画效果相对于哪一个点来进行变化的，Animation.RELATIVE_TO_SELF这个就相对于自己的坐标，就是说这个坐标原始坐标是在你设置view的左上角，Animation.RELATIVE_TO_PARENT相对于父控件的坐标，这个大多数指的就是手机上的坐标原点。Animation.ABSOLUTE绝对坐标说的就是具体相对哪个一个点，比如(100,200)，就是表示相对坐标点在(100,200)这个点来进行动画。
pivotXValue和pivotYValue值就是相对上面的值设置的，表示的是相对于哪一个点来进行放大缩小的动画，对于Animation.RELATIVE_TO_SELF和Animation.RELATIVE_TO_PARENT
(0,0)表示的是原点，（0.5f,0.5f）表示的中间点这个对于Animation.RELATIVE_TO_SELF相对于view控件的中间点，Animation.RELATIVE_TO_PARENT就是值该view上父控件的中间点，(1,1)表示的就是右下角的坐标。这个我们可以多多试试就知道效果了。
一般情况下使用是Animation.RELATIVE_TO_SELF，选择点是(0.5f,0.5f)就是该view的中间点，这样图片变化看起来不会产生很奇怪的感觉。
- TranslateAnimation:view在水平方向和垂直方向进行移动动画效果
TranslateAnimation(fromXDelta, toXDelta, fromYDelta, toYDelta)
fromXDelta和fromYDelta分别表示在X和Y轴上面的起始坐标，（0，0）这个表示的就是当前view的坐标，toXDelta和toYDelta分别表示最终目标，如果只是X轴移动或者Y轴移动，那么可以把对应不移动的坐标设置为０。
- RotateAnimation：旋转动画效果
RotateAnimation(fromDegrees, toDegrees, pivotXType, pivotXValue, pivotYType, pivotYValue)
fromDegrees和toDegrees分别表示的起始角度和结束角度，比如（０,4５）这个就是表示从默认状态旋转到４５度的意思。剩下的参数上面已经介绍过来，比如下面的代码：
RotateAnimation rotate=new RotateAnimation(0, 50, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
表示就是从默认状态旋转到５０度，旋转的中心点就是这个view的中心点(Animation.RELATIVE_TO_SELF表示的以自身为参考点，0.5f表示就是一般)
上面介绍就是这个Tween Animation动画效果，分别是透明度的变化，放大缩小，移动以及旋转动画效果，这些动画除了上面的构造函数之外当然还有一些公共的其它方法，下面就介绍一下：
setDuration(long durationMillis)
这个表示的是设置动画的显示时间，就是这个动画从初始状态到结束状态所需要的时间，durationMillis参数为动画显示时间的长短，单位是毫秒。
setStartOffset(long startOffset)
这个表示的是动画的开始时间，startOffset表示就是动画的开始时间，单位毫秒（有时候我们在startAnimation之后可能不希望立即取执行这个动画，需要等待一会再进行动画就可以使用这个
setFillAfter(boolean fillAfter)
这个表示的动画结束之后是否保留结束的位置，这个值默认是flase表示动画结束之后不保留动画的位置，就是说在我们进行动画效果结束之后又会自动恢复到原始的状态，true表示就是保留动画结束时的状态，这个值一般都是要设置为true的
startAnimation(Animation animation)
这个是在view对象上使用的，表示开始进行动画，参数就是我们上面说的那四种(注意上面的四种类型都是继承于Animation的)，比如我现在有一个ImageView对象image,那么我现在要开始动画时就是用imageView.startAnimation(rotateAnimation);就可以进行动画了，
setInterpolator(Interpolator i)
这个表示的设置动画的变化速度，这里android提供很多类型的Interpolator类型的变化器
１。setInterpolator(new AccelerateInterpolator(float factor)：这个AccelerateInterpolator表示的是加速，factor参数可以设置为加速的倍数，数值越大动画的速度越快，当然也可以是默认的new AccelerateInterpolator（）默认这个参数为１。我们来看一下源码：
/** * An interpolator where the rate of change starts out slowly and * and then accelerates. * */ public class AccelerateInterpolator implements Interpolator { private final float mFactor; private final double mDoubleFactor; public AccelerateInterpolator() { mFactor = 1.0f; mDoubleFactor = 2.0; } /** * Constructor * * @param factor Degree to which the animation should be eased. Seting * factor to 1.0f produces a y=x^2 parabola. Increasing factor above * 1.0f exaggerates the ease-in effect (i.e., it starts even * slower and ends evens faster) */ public AccelerateInterpolator(float factor) { mFactor = factor; mDoubleFactor = 2 * mFactor; } public AccelerateInterpolator(Context context, AttributeSet attrs) { TypedArray a = context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AccelerateInterpolator); mFactor = a.getFloat(com.android.internal.R.styleable.AccelerateInterpolator_factor, 1.0f); mDoubleFactor = 2 * mFactor; a.recycle(); } public float getInterpolation(float input) { if (mFactor == 1.0f) { return input * input; } else { return (float)Math.pow(input, mDoubleFactor); } } }
上面那个就是AccelerateInterpolator的源码，这个源码中有两个构造函数一个带参数一个不带参数的，从上面代码中getInterpolation这个方法是最重要的，那么跟踪一下这个方法调用是在Animation.java类中的getTransformation()方法
public boolean getTransformation(long currentTime, Transformation outTransformation) { if (mStartTime == -1) { mStartTime = currentTime; } final long startOffset = getStartOffset(); final long duration = mDuration; float normalizedTime; if (duration != 0) { normalizedTime = ((float) (currentTime - (mStartTime + startOffset))) / (float) duration; } else { // time is a step-change with a zero duration normalizedTime = currentTime < mStartTime ? 0.0f : 1.0f; } final boolean expired = normalizedTime >= 1.0f; mMore = !expired; if (!mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f); if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) { if (!mStarted) { fireAnimationStart(); mStarted = true; if (USE_CLOSEGUARD) { guard.open("cancel or detach or getTransformation"); } } if (mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f); if (mCycleFlip) { normalizedTime = 1.0f - normalizedTime; } final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime); applyTransformation(interpolatedTime, outTransformation); }
。。。。。。。。。
return mMore; }
上面就是getTransformation()方法，在这个方法中也看到之前设置的getStartOffset()以及mDuration等等，在下面发现这么一句话
final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);mInterpolator对象创建也是在这个类里面
public void setInterpolator(Interpolator i) { mInterpolator = i; }
看上面就是我们代码中设置的，那么来看看这个getInterpolation里面参数的值，从上面源码中知道mFillEnabled和mCycleFlip默认值都是flase,一般情况下我们都不会去设置这两个值都是取默认值的，if (mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);这个设置了normalizedTime的值，就是下面要用做getInterpolation参数值，从上面的代码中可以发现normalizedTime这个值是不小于０的，Math.max(Math.min(normalizedTime, 1.0f), 0.0f)表示取值范围就是０～１，也就是手这个getInterpolation（float input）这个input参数的变化就是在指定的动画事件内从０到１递增变化。
我们来看看Interpolator这个类
package android.view.animation; import android.animation.TimeInterpolator; /** * An interpolator defines the rate of change of an animation. This allows * the basic animation effects (alpha, scale, translate, rotate) to be * accelerated, decelerated, repeated, etc. */ public interface Interpolator extends TimeInterpolator { // A new interface, TimeInterpolator, was introduced for the new android.animation // package. This older Interpolator interface extends TimeInterpolator so that users of // the new Animator-based animations can use either the old Interpolator implementations or // new classes that implement TimeInterpolator directly. }
再看这个TimeInterpolator类
/* * 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 android.animation; /** * A time interpolator defines the rate of change of an animation. This allows animations * to have non-linear motion, such as acceleration and deceleration. */ public interface TimeInterpolator { /** * Maps a value representing the elapsed fraction of an animation to a value that represents * the interpolated fraction. This interpolated value is then multiplied by the change in * value of an animation to derive the animated value at the current elapsed animation time. * * @param input A value between 0 and 1.0 indicating our current point * in the animation where 0 represents the start and 1.0 represents * the end * @return The interpolation value. This value can be more than 1.0 for * interpolators which overshoot their targets, or less than 0 for * interpolators that undershoot their targets. */ float getInterpolation(float input); }
从这段代码中我们得出结论就是所有的变化器都是继承于Interpolator接口，而且都实现了float getInterpolation(float input);这个方法，那么我们就要弄清楚这个getTransformation()方法在哪里调用，我们说过StartAnimation是view对象调用那么我们在View.java里面
public void startAnimation(Animation animation) { animation.setStartTime(Animation.START_ON_FIRST_FRAME); setAnimation(animation); invalidateParentCaches(); invalidate(true); }
这段代码中最后一句就是更新，看一下
/** * This method is called by ViewGroup.drawChild() to have each child view draw itself. * This draw() method is an implementation detail and is not intended to be overridden or * to be called from anywhere else other than ViewGroup.drawChild(). */ boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) { boolean useDisplayListProperties = mAttachInfo != null && mAttachInfo.mHardwareAccelerated; boolean more = false; final boolean childHasIdentityMatrix = hasIdentityMatrix(); final int flags = parent.mGroupFlags; if ((flags & ViewGroup.FLAG_CLEAR_TRANSFORMATION) == ViewGroup.FLAG_CLEAR_TRANSFORMATION) { parent.getChildTransformation().clear(); parent.mGroupFlags &= ~ViewGroup.FLAG_CLEAR_TRANSFORMATION; } Transformation transformToApply = null; boolean concatMatrix = false; boolean scalingRequired = false; boolean caching; int layerType = getLayerType(); final boolean hardwareAccelerated = canvas.isHardwareAccelerated(); if ((flags & ViewGroup.FLAG_CHILDREN_DRAWN_WITH_CACHE) != 0 || (flags & ViewGroup.FLAG_ALWAYS_DRAWN_WITH_CACHE) != 0) { caching = true; // Auto-scaled apps are not hw-accelerated, no need to set scaling flag on DisplayList if (mAttachInfo != null) scalingRequired = mAttachInfo.mScalingRequired; } else { caching = (layerType != LAYER_TYPE_NONE) || hardwareAccelerated; } final Animation a = getAnimation(); if (a != null) { more = drawAnimation(parent, drawingTime, a, scalingRequired); concatMatrix = a.willChangeTransformationMatrix(); if (concatMatrix) { mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM; } transformToApply = parent.getChildTransformation(); } else { 。。。。。。。。。。。。。。。。。。。。。。。
上面这段代码中有这么一句话 more = drawAnimation(parent, drawingTime, a, scalingRequired)，这个函数就是
private boolean drawAnimation(ViewGroup parent, long drawingTime, Animation a, boolean scalingRequired) { Transformation invalidationTransform; final int flags = parent.mGroupFlags; final boolean initialized = a.isInitialized(); if (!initialized) { a.initialize(mRight - mLeft, mBottom - mTop, parent.getWidth(), parent.getHeight()); a.initializeInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop); if (mAttachInfo != null) a.setListenerHandler(mAttachInfo.mHandler); onAnimationStart(); } final Transformation t = parent.getChildTransformation(); boolean more = a.getTransformation(drawingTime, t, 1f);
。。。。。。。。。。。。。。。。。。。。。。。。。
看到上面的drawAnimation方法中就有a.getTransformation(drawingTime, t, 1f);这个方法，我们也就明白了这个getTransformation()方法是在startAnimation()之后调用的。
２。setInterpolator(new AccelerateDecelerateInterpolator())：这个AccelerateDecelerateInterpolator表示的是先加速后减速的动画
/** * An interpolator where the rate of change starts and ends slowly but * accelerates through the middle. * */ public class AccelerateDecelerateInterpolator implements Interpolator { public AccelerateDecelerateInterpolator() { } @SuppressWarnings({"UnusedDeclaration"}) public AccelerateDecelerateInterpolator(Context context, AttributeSet attrs) { } public float getInterpolation(float input) { return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f; } }
３。setInterpolator(new DecelerateInterpolator(float factor))：这个表示的就是减速，factor和上面的加速参数是一个意思，只不过作用是相反的，也可以不带参数new DecelerateInterpolator()这样
/** * An interpolator where the rate of change starts out quickly and * and then decelerates. * */ public class DecelerateInterpolator implements Interpolator { public DecelerateInterpolator() { } /** * Constructor * * @param factor Degree to which the animation should be eased. Setting factor to 1.0f produces * an upside-down y=x^2 parabola. Increasing factor above 1.0f makes exaggerates the * ease-out effect (i.e., it starts even faster and ends evens slower) */ public DecelerateInterpolator(float factor) { mFactor = factor; } public DecelerateInterpolator(Context context, AttributeSet attrs) { TypedArray a = context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.DecelerateInterpolator); mFactor = a.getFloat(com.android.internal.R.styleable.DecelerateInterpolator_factor, 1.0f); a.recycle(); } public float getInterpolation(float input) { float result; if (mFactor == 1.0f) { result = (float)(1.0f - (1.0f - input) * (1.0f - input)); } else { result = (float)(1.0f - Math.pow((1.0f - input), 2 * mFactor)); } return result; } private float mFactor = 1.0f; }
４。setInterpolator(new CycleInterpolator())：动画循环播放特定次数，速率改变沿着正弦曲线
/** * Repeats the animation for a specified number of cycles. The * rate of change follows a sinusoidal pattern. * */ public class CycleInterpolator implements Interpolator { public CycleInterpolator(float cycles) { mCycles = cycles; } public CycleInterpolator(Context context, AttributeSet attrs) { TypedArray a = context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.CycleInterpolator); mCycles = a.getFloat(com.android.internal.R.styleable.CycleInterpolator_cycles, 1.0f); a.recycle(); } public float getInterpolation(float input) { return (float)(Math.sin(2 * mCycles * Math.PI * input)); } private float mCycles; }
５。setInterpolator(new LinearInterpolator())：表示匀速
/** * An interpolator where the rate of change is constant * */ public class LinearInterpolator implements Interpolator { public LinearInterpolator() { } public LinearInterpolator(Context context, AttributeSet attrs) { } public float getInterpolation(float input) { return input; } }
６。setInterpolator(new OvershootInterpolator()) 超越，最后超出目的值然后缓慢改变到目的值
/** * An interpolator where the change flings forward and overshoots the last value * then comes back. */ public class OvershootInterpolator implements Interpolator { private final float mTension; public OvershootInterpolator() { mTension = 2.0f; } /** * @param tension Amount of overshoot. When tension equals 0.0f, there is * no overshoot and the interpolator becomes a simple * deceleration interpolator. */ public OvershootInterpolator(float tension) { mTension = tension; } public OvershootInterpolator(Context context, AttributeSet attrs) { TypedArray a = context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.OvershootInterpolator); mTension = a.getFloat(com.android.internal.R.styleable.OvershootInterpolator_tension, 2.0f); a.recycle(); } public float getInterpolation(float t) { // _o(t) = t * t * ((tension + 1) * t + tension) // o(t) = _o(t - 1) + 1 t -= 1.0f; return t * t * ((mTension + 1) * t + mTension) + 1.0f; } }
７。setInterpolator(new BounceInterpolator())：跳跃，快到目的值时值会跳跃，如目的值100，后面的值可能依次为85，77，70，80，90，100
/** * An interpolator where the change bounces at the end. */ public class BounceInterpolator implements Interpolator { public BounceInterpolator() { } @SuppressWarnings({"UnusedDeclaration"}) public BounceInterpolator(Context context, AttributeSet attrs) { } private static float bounce(float t) { return t * t * 8.0f; } public float getInterpolation(float t) { // _b(t) = t * t * 8 // bs(t) = _b(t) for t < 0.3535 // bs(t) = _b(t - 0.54719) + 0.7 for t < 0.7408 // bs(t) = _b(t - 0.8526) + 0.9 for t < 0.9644 // bs(t) = _b(t - 1.0435) + 0.95 for t <= 1.0 // b(t) = bs(t * 1.1226) t *= 1.1226f; if (t < 0.3535f) return bounce(t); else if (t < 0.7408f) return bounce(t - 0.54719f) + 0.7f; else if (t < 0.9644f) return bounce(t - 0.8526f) + 0.9f; else return bounce(t - 1.0435f) + 0.95f; } }
８。setInterpolator(new AnticipateOvershootInterpolator())：反向加超越，先向相反方向改变，再加速播放，会超出目的值然后缓慢移动至目的值
/** * An interpolator where the change starts backward then flings forward and overshoots * the target value and finally goes back to the final value. */ public class AnticipateOvershootInterpolator implements Interpolator { private final float mTension; public AnticipateOvershootInterpolator() { mTension = 2.0f * 1.5f; } /** * @param tension Amount of anticipation/overshoot. When tension equals 0.0f, * there is no anticipation/overshoot and the interpolator becomes * a simple acceleration/deceleration interpolator. */ public AnticipateOvershootInterpolator(float tension) { mTension = tension * 1.5f; } /** * @param tension Amount of anticipation/overshoot. When tension equals 0.0f, * there is no anticipation/overshoot and the interpolator becomes * a simple acceleration/deceleration interpolator. * @param extraTension Amount by which to multiply the tension. For instance, * to get the same overshoot as an OvershootInterpolator with * a tension of 2.0f, you would use an extraTension of 1.5f. */ public AnticipateOvershootInterpolator(float tension, float extraTension) { mTension = tension * extraTension; } public AnticipateOvershootInterpolator(Context context, AttributeSet attrs) { TypedArray a = context.obtainStyledAttributes(attrs, AnticipateOvershootInterpolator); mTension = a.getFloat(AnticipateOvershootInterpolator_tension, 2.0f) * a.getFloat(AnticipateOvershootInterpolator_extraTension, 1.5f); a.recycle(); } private static float a(float t, float s) { return t * t * ((s + 1) * t - s); } private static float o(float t, float s) { return t * t * ((s + 1) * t + s); } public float getInterpolation(float t) { // a(t, s) = t * t * ((s + 1) * t - s) // o(t, s) = t * t * ((s + 1) * t + s) // f(t) = 0.5 * a(t * 2, tension * extraTension), when t < 0.5 // f(t) = 0.5 * (o(t * 2 - 2, tension * extraTension) + 2), when t <= 1.0 if (t < 0.5f) return 0.5f * a(t * 2.0f, mTension); else return 0.5f * (o(t * 2.0f - 2.0f, mTension) + 2.0f); } }
９。setInterpolator(new AnticipateInterpolator())：反向 ，先向相反方向改变一段再加速播放
/** * An interpolator where the change starts backward then flings forward. */ public class AnticipateInterpolator implements Interpolator { private final float mTension; public AnticipateInterpolator() { mTension = 2.0f; } /** * @param tension Amount of anticipation. When tension equals 0.0f, there is * no anticipation and the interpolator becomes a simple * acceleration interpolator. */ public AnticipateInterpolator(float tension) { mTension = tension; } public AnticipateInterpolator(Context context, AttributeSet attrs) { TypedArray a = context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AnticipateInterpolator); mTension = a.getFloat(com.android.internal.R.styleable.AnticipateInterpolator_tension, 2.0f); a.recycle(); } public float getInterpolation(float t) { // a(t) = t * t * ((tension + 1) * t - tension) return t * t * ((mTension + 1) * t - mTension); } }
就上面这么多了，按照上面的代码我们也可以自定义我们符合我们自己的Interpolator,定义方法就是写一个类继承于Interpolator接口，并且去实现getInterpolation()方法，在该方法里面做相应的运算。
常用的方法就上面这些，来看一下一个ScaleAnimation用法，其它类似：
private ScaleAnimation scale(){ ScaleAnimation scaleAnimation=new ScaleAnimation(0, 1, 0, 1, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f); scaleAnimation.setDuration(1000); scaleAnimation.setStartOffset(0); scaleAnimation.setInterpolator(new AccelerateInterpolator()); scaleAnimation.setFillAfter(true); return scaleAnimation; }
开启这个动画在一个按钮上面
imageView=(ImageView) findViewById(R.id.image); scaleBtn.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub imageView.startAnimation(scale()); } });
上面这个就实现图片放大缩小的效果
如果我们想要实现两种以上的动画如何处理呢，这个时候我们就可以使用AnimationSet这个类实现多个动画叠加效果，
AnimationSet(boolean shareInterpolator);
这个参数设为false表示可以在每个添加到AnimationSet中的Animation都使用Interpolator，且效果都能清楚的观察。设置为true如果在添加到AnimationSet中的Animation设置Interpolator将无效果，通过设置AnimationSet的Interpolator可以设置所有动画的Interpolator且所有动画的Interpolator都一样。
private AnimationSet allAnimation(){ AnimationSet set=new AnimationSet(boolean shareInterpolator); TranslateAnimation translate=new TranslateAnimation(0, 100, 0, 100); RotateAnimation rotate=new RotateAnimation(0, 50, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f); set.addAnimation(translate); set.addAnimation(rotate); set.setInterpolator(new AnticipateOvershootInterpolator()); set.setFillAfter(true); set.setDuration(1000); set.setStartOffset(100); return set; }
我们看到addAnimation就是添加动画效果，其它方法和那个是一样的
我们在使用的过程有时候需要监听动画的开始和结束，AnimationListener这个就是动画监听
set.setAnimationListener(new AnimationListener() { @Override public void onAnimationStart(Animation animation) { // TODO Auto-generated method stub } @Override public void onAnimationRepeat(Animation animation) { // TODO Auto-generated method stub } @Override public void onAnimationEnd(Animation animation) { // TODO Auto-generated method stub } });
看上面的意思就会明白那个是表示动画的开始，那个是动画结束了
这个我们可以在res／anim目录中通过xml来写动画
<?xml version="1.0" encoding="utf-8"?> <set xmlns:android="http://schemas.android.com/apk/res/android"> <alpha android:fromAlpha="0" android:toAlpha="1" android:duration="1000" /> <translate android:interpolator="@android:anim/accelerate_decelerate_interpolator" android:fromXDelta="0" android:toXDelta="100" android:fromYDelta="0" android:toYDelta="100" android:startOffset="50" android:duration="1000" /> </set>
上面就是xml写的，那么如何加载呢？看下面的代码
Animation an=AnimationUtils.loadAnimation(AnimationTest.this, R.anim.itchqanimator); imageView.startAnimation(an);
这个就是加载xml里面的动画的
Property Animation
这个是属性动画，是android4.0引入手机中（android 3.0中就有了只是３.0主要的在平板电脑上使用的），我们上面讲解的那种tween Animation动画改变的是view绘制，而没有改变View对象本身，比如，你有一个Button，坐标 （100,100），Width:200,Height:50，而你有一个动画使其变为Width：100，Height：100，你会发现动画过程中触 发按钮点击的区域仍是(100,100)-(300,150)。而在Property Animation中，改变的是对象的实际属性，而且Property Animation不止可以应用于View，还可以应用于任何对象。
ValueAnimator类就是这个的包含Property Animation的动画所以核心功能，如动画的时间，开始，结束的属性值等等，当时对于ValueAnimator来说我们一般都不会直接使用这个，我们都是直接使用ValueAnimator的子类就是ObjectAnimator。
ObjectAnimator是继承于ValueAnimator的，使用这个ObjectAnimator是有条件限制的
１。对象应该有一个setter函数：set<PropertyName>（驼峰命名法），这个命名法可以上网查一下，很容易理解的
２。创建ObjectAnimation对象一般是
ObjectAnimator objectAnimator=ObjectAnimator.ofFloat(valueBtn, "alpha", 1f,0f);
像ofFloat之类的工场方法，第一个参数为对象名(这个也就是我们的view类了)，第二个为属性名，后面的参数为可变参 数，如果values…参数只设置了一个值的话，那么会假定为目的值，属性值的变化范围为当前值到目的值，为了获得当前值，该对象要有相应属性的 getter方法：get<PropertyName>
３。如果有getter方法，其应返回值类型应与相应的setter方法的参数类型一致。正常情况驼峰命名法都是get和set方法对应的出现
valueBtn=(Button) findViewById(R.id.valueAnimation); valueBtn.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub ObjectAnimator objectAnimator=ObjectAnimator.ofFloat(valueBtn, "alpha", 1f,0f); objectAnimator.setDuration(1000); objectAnimator.start(); } });
这个就是ObjectAnimator简单的用法，通过这个我们也可以监听动画的开始和结束，上面有介绍过AnimatorListener的监听，如下：
objectAnimator.addListener(new AnimatorListener() { @Override public void onAnimationStart(Animator animation) { // TODO Auto-generated method stub } @Override public void onAnimationRepeat(Animator animation) { // TODO Auto-generated method stub } @Override public void onAnimationEnd(Animator animation) { // TODO Auto-generated method stub } @Override public void onAnimationCancel(Animator animation) { // TODO Auto-generated method stub } });
当是我们有时候不需要取监听动画的取消或者重复，这些代码在这里显然是多余的，这个时候我们就可以使用AnimatorListenerAdapter这个适配器来进行监听了，如下
objectAnimator.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { // TODO Auto-generated method stub super.onAnimationEnd(animation); } @Override public void onAnimationStart(Animator animation) { // TODO Auto-generated method stub super.onAnimationStart(animation); } });
这个就只关心我们的动画开始和介绍，其它就不需要了，代码看起来简洁了很多。ObjectAnimator当然也有setInterpolator()和setStartDelay()等一系列方法，这些的话就和我们上面的说的tween Animation动画方法是一样的。如果我们想要同时实现很多个动画就需要AnimatorSet这个类来实现，如下代码：
AnimatorSet set=new AnimatorSet(); ObjectAnimator alphaAnimator=ObjectAnimator.ofFloat(valueBtn, "alpha", 0f,1f); ObjectAnimator xAnimator=ObjectAnimator.ofFloat(valueBtn, "translationX", 0f,5f,10f); ObjectAnimator yAnimator=ObjectAnimator.ofFloat(valueBtn, "translationY", 0f,5f,10f); ObjectAnimator rotateYAnimator=ObjectAnimator.ofFloat(valueBtn, "rotationX", 0f,90f); set.play(alphaAnimator).before(xAnimator); set.play(xAnimator).with(yAnimator); set.play(yAnimator).after(rotateYAnimator); set.setDuration(2000); set.start();
上面就是使用AnimatorSet方法，这个方法提供了before,with,after方法，按上面代码的意思就是alphaAnimator先执行，之后到xAnimator，yAnimator和xAnimator是同时执行的，执行完yAnimator和xAnimator之后就执行rotateYAnimator，看上面的字面意思也很容易理解了。
在实现过程中经常使用一些动画属性：
１。translationX,translationY,x,y
这些translationX和x，TranslationY和y是用区别的，下面来看看这个区别在哪里（我们这里以X坐标为例）
valueBtn=(Button) findViewById(R.id.valueAnimation); Log.i("itchq", "valueBtn.getLeft()="+valueBtn.getLeft()); Log.i("itchq", "valueBtn.getX()="+valueBtn.getX()); Log.i("itchq", "valueBtn.getTranslationX()="+valueBtn.getTranslationX());
上面的代码中看一默认打印的信息是：
这个默认都是为０的，当我使用translationX动画之后
ObjectAnimator objectAnimator=ObjectAnimator.ofFloat(valueBtn, "translationX", 0f,100f); objectAnimator.setDuration(1000); objectAnimator.start(); objectAnimator.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { // TODO Auto-generated method stub Log.i("itchq", "valueBtn.getLeft()="+valueBtn.getLeft()); Log.i("itchq", "valueBtn.getX()="+valueBtn.getX()); Log.i("itchq", "valueBtn.getTranslationX()="+valueBtn.getTranslationX()); } });
动画结束之后打印的信息如下
这个时候我们再使用x动画之后
还是一样的，这个主要是因为这个getLeft为０，那么我们这个时候把getLeft设置为２０时，当是translationX时动画之后打出的log是
这个时候的x不再是１００了而是１２０了，再设置为x,看一下结果
这个时候的getTranslationX()不再是１００了，而是８０，所以无论啥样应用动画，getLeft的值是不会变的，而TranslationX的值是为最终位置于布局时初始位置的差，即“最终位置－getLeft()",而x为最终位置之和，即”getLeft()+getTranslationX()“,所以当getLeft为０的时候就会发现两个值是相等的。
２。rotation,rotationX,rotationY:旋转，rotation用于2D旋转角度，3D中用到后两个
３。scaleX,scaleY:缩放
４。alpha:透明度
Keyframe
keyFrame是一个 时间/值 对，通过它可以定义一个在特定时间的特定状态，而且在两个keyFrame之间可以定义不同的Interpolator，就相当多个动画的拼接，第一个动 画的结束点是第二个动画的开始点。KeyFrame是抽象类，要通过ofInt(),ofFloat(),ofObject()获得适当的 KeyFrame，然后通过PropertyValuesHolder.ofKeyframe获得PropertyValuesHolder对象，如以下代码：
Keyframe kf0 = Keyframe.ofInt(0, 400); Keyframe kf1 = Keyframe.ofInt(0.25f, 200); Keyframe kf2 = Keyframe.ofInt(0.5f, 400); Keyframe kf4 = Keyframe.ofInt(0.75f, 100); Keyframe kf3 = Keyframe.ofInt(1f, 500); PropertyValuesHolder pvhRotation = PropertyValuesHolder.ofKeyframe("width", kf0, kf1, kf2, kf4, kf3); ObjectAnimator widthAnim = ObjectAnimator.ofPropertyValuesHolder(valueBtn, pvhRotation); widthAnim.setDuration(2000); widthAnim.start();
上述代码的意思为：设置valueBtn对象的width属性值使其：
开始时 Width=400
动画开始1/4时 Width=200
动画开始1/2时 Width=400
动画开始3/4时 Width=100
动画结束时 Width=500
第一个参数为时间百分比，第二个参数是在第一个参数的时间时的属性值。定义了一些Keyframe后，通过PropertyValuesHolder类的方法ofKeyframe封装，然后通过ObjectAnimator.ofPropertyValuesHolder获得Animator。
PropertyValuesHolder
如果需要对一个View的多个属性进行动画可以用ViewPropertyAnimator类，该类对多属性动画进行了优化，会合并一些invalidate()来减少刷新视图
PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("x", 50f);
PropertyValuesHolder pvhY = PropertyValuesHolder.ofFloat("y", 100f);
ObjectAnimator x_yAnimator=ObjectAnimator.ofPropertyValuesHolder(valueBtn, pvhX, pvhY);
x_yAnimator.setDuration(1000);
x_yAnimator.start();
上面这段代码就是同时进行X轴和Y轴的动画
