Android动画

2016-08-03 本文已影响634人四月一号

Animation

Animation类是所有动画（scale、alpha、translate、rotate）的基类,以下是关于 Animation 的属性及意义:
android:duration 动画持续时间，以毫秒为单位
android:fillAfter 如果设置为true，控件动画结束时，将保持动画最后时的状态
android:fillBefore 如果设置为true,控件动画结束时，还原到开始动画前的状态
android:fillEnabled 与android:fillBefore 效果相同，都是在动画结束时，将控件还原到初始化状态
android:repeatCount 重复次数
android:repeatMode 重复类型，有reverse和restart两个值，reverse表示倒序回放，restart表示重新放一遍，必须与repeatCount一起使用才能看到效果。因为这里的意义是重复的类型，即回放时的动作。
android:interpolator 设定插值器，其实就是指定的动作效果，比如弹跳效果等

scale

scale标签是缩放动画，可以实现动态调控件尺寸的效果，有下面几个属性：
android:fromXScale 起始的X方向上相对自身的缩放比例，浮点值，比如1.0代表自身无变化，0.5代表起始时缩小一倍，2.0代表放大一倍；
android:toXScale 结尾的X方向上相对自身的缩放比例，浮点值；
android:fromYScale 起始的Y方向上相对自身的缩放比例，浮点值，
android:toYScale 结尾的Y方向上相对自身的缩放比例，浮点值；
android:pivotX 缩放起点X轴坐标，可以是数值、百分数、百分数p 三种样式，比如 50、50%、50%p，当为数值时，表示在当前View的左上角，即原点处加上50px，做为起始缩放点；如果是50%，表示在当前控件的左上角加上自己宽度的50%做为起始点；如果是50%p，那么就是表示在当前的左上角加上父控件宽度的50%做为起始点x轴坐标。
android:pivotY 缩放起点Y轴坐标，取值及意义跟android:pivotX一样。

alpha

alpha是透明动画,调节控件的透明度,属性如下:
android:fromAlpha 动画开始的透明度，从0.0 --1.0 ，0.0表示全透明，1.0表示完全不透明
android:toAlpha 动画结束时的透明度，也是从0.0 --1.0 ，0.0表示全透明，1.0表示完全不透明

rotate

rotate是旋转动画,控制控件在平面上的旋转角度
android:fromDegrees 开始旋转的角度位置，正值代表顺时针方向度数，负值代码逆时针方向度数
android:toDegrees 结束时旋转到的角度位置，正值代表顺时针方向度数，负值代码逆时针方向度数
android:pivotX 旋转中点X坐标
android:pivotY 旋转中点Y坐标

translate

translate是平移动画,控制控件水平或垂直移动
android:fromXDelta 起始点X轴坐标，可以是数值、百分数、百分数p 三种样式
android:fromYDelta 起始点Y轴从标
android:toXDelta 结束点X轴坐标
android:toYDelta 结束点Y轴坐标

set

set定义动画的集合,可以将多个动画打包执行,在XML中set的定义方式如下:
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android"
android:duration="3000"
android:fillAfter="true">

     <alpha   
         android:fromAlpha="0.0"  
         android:toAlpha="1.0"/>  

     <scale  
         android:fromXScale="0.0"  
         android:toXScale="1.4"  
         android:fromYScale="0.0"  
         android:toYScale="1.4"  
         android:pivotX="50%"  
         android:pivotY="50%"/>  

    <rotate  
         android:fromDegrees="0"  
         android:toDegrees="720"  
         android:pivotX="50%"  
        android:pivotY="50%"/>  
   
</set>

执行动画(XML)

在项目的 res -> anim下定义动画(xxx.xml)
在代码中加载动画,并让目标控件执行
Animation anim = AnimationUtils.loadAnimation(this, R.anim.xxx);
imag.startAnimation(anim);

Interpolator插值器

Interpolator赋予动画一些特性,它指定了动画变化的特征,系统提供的Interpolator如下:
- AccelerateDecelerateInterpolator 在动画开始与介绍的地方速率改变比较慢，在中间的时候加速
AccelerateInterpolator 在动画开始的地方速率改变比较慢，然后开始加速
AnticipateInterpolator 开始的时候向后然后向前甩
AnticipateOvershootInterpolator 开始的时候向后然后向前甩一定值后返回最后的值
BounceInterpolator 动画结束的时候弹起
CycleInterpolator 动画循环播放特定的次数，速率改变沿着正弦曲线
DecelerateInterpolator 在动画开始的地方快然后慢
LinearInterpolator 以常量速率改变
OvershootInterpolator 向前甩一定值后再回到原来位置
xml动画中添加Interpolator
android:interpolator="@android:anim/accelerate_decelerate_interpolator"

代码生成动画

前面介绍了通过xml定义动画,动画集合,插值器等,其实通过代码也可以做到.

ScaleAnimation
ScaleAnimation scaleAnim = new ScaleAnimation(0.0f,1.4f,0.0f,1.4f,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);
scaleAnim.setDuration(700);

//它相当于在xml如下定义
 <?xml version="1.0" encoding="utf-8"?>  
 <scale xmlns:android="http://schemas.android.com/apk/res/android"                                                                   
     android:fromXScale="0.0"  
     android:toXScale="1.4"  
     android:fromYScale="0.0"  
     android:toYScale="1.4"  
     android:pivotX="50"  
     android:pivotY="50"  
     android:duration="700" />

AlphaAnimation
AlphaAnimation alphaAnim = new AlphaAnimation(1.0f,0.1f);
alphaAnim.setDuration(3000);
alphaAnim.setFillBefore(true);

//对应xml属性如下:
//android:fromAlpha="1.0"  
//android:toAlpha="0.1"  
//android:duration="3000"  
//android:fillBefore="true"

RotateAnimation
RotateAnimation rotateAnim = new RotateAnimation(0, -650, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
rotateAnim.setDuration(3000);
rotateAnim.setFillAfter(true);
```
//对应xml属性如下:
//android:fromDegrees="0"  
//android:toDegrees="-650"  
//android:pivotX="50%"  
//android:pivotY="50%"  
//android:duration="3000"  
//android:fillAfter="true"
```
TranslateAnimation
TranslateAnimation translateAnim = new TranslateAnimation(Animation.ABSOLUTE, 0, Animation.ABSOLUTE, -80,
Animation.ABSOLUTE, 0, Animation.ABSOLUTE, -80);
translateAnim.setDuration(2000);
translateAnim.setFillBefore(true);
```
//对应xml属性:
//android:fromXDelta="0"   
//android:toXDelta="-80"  
//android:fromYDelta="0"  
//android:toYDelta="-80"  
//android:duration="2000"  
//android:fillBefore="true"
```
AnimationSet
AlphaAnimation alphaAnim = new AlphaAnimation(1.0f,0.1f);
ScaleAnimation scaleAnim = new ScaleAnimation(0.0f,1.4f,0.0f,1.4f,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);
RotateAnimation rotateAnim = new RotateAnimation(0, 720, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
```
AnimationSet setAnim=new AnimationSet(true);  
setAnim.addAnimation(alphaAnim);  
setAnim.addAnimation(scaleAnim);  
setAnim.addAnimation(rotateAnim);   
setAnim.setDuration(3000);  
```
Interpolater
ScaleAnimation interpolateScaleAnim=new ScaleAnimation(0.0f,1.4f,0.0f,1.4f,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);
interpolateScaleAnim.setInterpolator(new BounceInterpolator());
interpolateScaleAnim.setDuration(3000);

Property Animator(属性动画)

ValueAnimator

ValueAnimator只负责对指定的数字区间进行动画运算
我们需要对运算过程进行监听，然后自己对控件做动画操作

ValueAnimator的构件方法
public static ValueAnimator ofInt(int... values)
public static ValueAnimator ofFloat(float... values)

 //他们的参数类型都是可变参数长参数，所以我们可以传入任何数量的值；传进去的值列表，就表示动画时的变化范围；
 //比如ofInt(2,90,45)就表示从数值2变化到数字90再变化到数字45；所以我们传进去的数字越多，动画变化就越复杂。
 //从参数类型也可以看出ofInt与ofFloat的唯一区别就是传入的数字类型不一样，
 //ofInt需要传入Int类型的参数，而ofFloat则表示需要传入Float类型的参数。

ValueAnimator的常用函数
//设置动画时长，单位是毫秒
ValueAnimator setDuration(long duration)
//获取ValueAnimator在运动时，当前运动点的值
Object getAnimatedValue();
//开始动画
void start()
//设置循环次数,设置为INFINITE表示无限循环
void setRepeatCount(int value)
//设置循环模式 value取值有RESTART，REVERSE，
void setRepeatMode(int value)
//取消动画
void cancel()
//设置插值器
void setInterpolator(TimeInterpolator value)
//延时多久时间开始，单位是毫秒
void setStartDelay(long startDelay)
//完全克隆一个ValueAnimator实例，包括它所有的设置以及所有对监听器代码的处理
ValueAnimator clone()
举例说明ValueAnimator的使用方式
ValueAnimator animator = ValueAnimator.ofFloat(0f,400f,50f,300f);
animator.setDuration(3000);
//监听动画变化时的实时值
animator.addUpdateListener(
new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
//获取当前的值(这里传入的是float,所以强转为Float)
Float curValueFloat = (Float)animation.getAnimatedValue();
int curValue = curValueFloat.intValue();
//跟随值的变化,而改变控件的属性
tv.layout(curValue,curValue,curValue+tv.getWidth(),
curValue+tv.getHeight());
}
});
animator.start();

ValueAnimator 监听
/**
* 监听器一：监听动画变化时的实时值
*/
public static interface AnimatorUpdateListener {
void onAnimationUpdate(ValueAnimator animation);
}
//添加方法为：
//public void addUpdateListener(AnimatorUpdateListener listener)
//移除的方法
//void removeUpdateListener(AnimatorUpdateListener listener);
//void removeAllUpdateListeners();

/** 
 * 监听器二：监听动画变化时四个状态 
 */  
 public static interface AnimatorListener {  
   void onAnimationStart(Animator animation);  
   void onAnimationEnd(Animator animation);  
   void onAnimationCancel(Animator animation);  
   void onAnimationRepeat(Animator animation);  
}  
//添加方法为：
//public void addListener(AnimatorListener listener)  
//void removeListener(AnimatorListener listener);  
//void removeAllListeners();

自定义Interpolator
public class MyInterpolator implements Interpolator {

   public LinearInterpolator() {  
   }  

   public LinearInterpolator(Context context, AttributeSet attrs) {  
   }  

   public float getInterpolation(float input) { 
      // input表示动画的时间进度,范围是0到1,随着动画的执行匀速增长
      // 返回值表示动画的实际进度,是关于input的一维函数
      // 当前的值 = start + （end- start）* 动画进度
      return input;  
   }  
}

Evaluator
- 插值器的进度,是如何转换为动画实际的值?
  Evaluator就是将动画进度转换为实际值的东西,它定义了转换的规则.
- FloatEvaluator 和 IntEvaluator分别对应 ofFloat() 和 ofInt()
  当我们定义动画的时候,如果不显示的添加Evaluator,则使用默认的Evaluator
  public class IntEvaluator implements TypeEvaluator<Integer> {
  public Integer evaluate(float fraction,
  Integer startValue, Integer endValue) {
  int startInt = startValue;
  //当前的值 = start + （end- start）* 动画进度
  //可以自定义规则
  return (int)(startInt + fraction * (endValue - startInt));
  }
  }

ArgbEvaluator (用于处理颜色值过渡转换)
public class ArgbEvaluator implements TypeEvaluator {
public Object evaluate(float fraction,
Object startValue, Object endValue) {
int startInt = (Integer) startValue;
int startA = (startInt >> 24);
int startR = (startInt >> 16) & 0xff;
int startG = (startInt >> 8) & 0xff;
int startB = startInt & 0xff;

        int endInt = (Integer) endValue;  
        int endA = (endInt >> 24);  
        int endR = (endInt >> 16) & 0xff;  
        int endG = (endInt >> 8) & 0xff;  
        int endB = endInt & 0xff;  

        return (int)((startA + (int)(fraction * (endA - startA))) << 24) |  
           (int)((startR + (int)(fraction * (endR - startR))) << 16) |  
           (int)((startG + (int)(fraction * (endG - startG))) << 8) |  
           (int)((startB + (int)(fraction * (endB - startB))));  
      }  
 }  

 ...
 //使用例子
  ValueAnimator animator = ValueAnimator.ofInt(0xffffff00,0xff0000ff);                                                                    
  animator.setEvaluator(new ArgbEvaluator());  
  animator.setDuration(3000);  

  animator.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {  
     @Override  
     public void onAnimationUpdate(ValueAnimator animation) {  
         int curValue = (int)animation.getAnimatedValue();  
         tv.setBackgroundColor(curValue);  
     }  
  });  
  animator.start();

ofObject()
public static ValueAnimator ofObject(TypeEvaluator evaluator, Object... values);
//ofObject相对于ofInt和ofFloat自由度更大些,相应也更复杂点.个人认为ofObject使用的机会不多,所以简单列举一个例子说明它的用法

  ValueAnimator animator = ValueAnimator.ofObject(new CharEvaluator(),new Character('A'),new Character('Z'));                                                                                    
  animator.addUpdateListener(
          new ValueAnimator.AnimatorUpdateListener() {  
    @Override  
    public void onAnimationUpdate(ValueAnimator animation) {  
           char text = (char)animation.getAnimatedValue();  
          tv.setText(String.valueOf(text));  
    }  
  });  
  animator.setDuration(10000);  
  animator.setInterpolator(new AccelerateInterpolator());  
  animator.start();  

  //... 自定义Evaluator
  
  public class CharEvaluator implements TypeEvaluator<Character> {  
       @Override  
       public Character evaluate(float fraction,
                    Character startValue, Character endValue) {  
            int startInt  = (int)startValue;  
            int endInt = (int)endValue;  
            int curInt = (int)(startInt + fraction *(endInt - startInt));  
            char result = (char)curInt;  
            return result;  
        }  
   }

ObjectAnimator

ValueAnimator使用相对比较麻烦,谷歌在ValueAnimator的基础上派生了ObjectAnimator,所以ObjectAnimator可以视为ValueAnimator的封装,使用起来更简单.
public static ObjectAnimator ofInt(Object target, String propertyName, int... values)
public static ObjectAnimator ofFloat(Object target, String propertyName, float... values)

 ...
 //以下是透明,旋转,位移,缩放动画的定义
 ObjectAnimator animator =  ObjectAnimator.ofFloat(tv,"alpha",1,0,1);  
 ObjectAnimator animator = ObjectAnimator.ofFloat(tv,"rotation",0,180,0);   
 ObjectAnimator animator = ObjectAnimator.ofFloat(tv,"rotationX",0,270,0);
 ObjectAnimator animator = ObjectAnimator.ofFloat(tv,"rotationY",0,180,0);
 ObjectAnimator animator = ObjectAnimator.ofFloat(tv, "translationX", 0, 200,-200,0);
 ObjectAnimator animator = ObjectAnimator.ofFloat(tv, "translationY", 0, 200,-100,0);
 ObjectAnimator animator = ObjectAnimator.ofFloat(tv, "scaleX", 0, 3, 1); 
 ObjectAnimator animator = ObjectAnimator.ofFloat(tv, "scaleY", 0, 3, 1);

why ? 为什么通过一段字符串,就可以执行指定的动画?
- 其实上面这些属性,都有其对应的set函数:
  - setAlpha()
  - setRotation() / setRotationY() / setRotationX()
  - setTranslationY() / setTranslationX()
  - setScaleX() / setScaleY()
    当我们使用以上方式定义属性动画时,系统会拼接出目标控件对应的set函数,然后通过反射执行.
    依次类推,只要控件有某一set函数,我们就可以定义对应的动画,比如:
    //setBackgrounColor()
    ObjectAnimator animator = ObjectAnimator.ofInt(tv, "BackgroundColor", 0xffff00ff, 0xffffff00, 0xffff00ff);
    animator.setDuration(8000);
    animator.setEvaluator(new ArgbEvaluator());
    animator.start();
    进一步,自定义控件的时候,我们可以自定义set函数,都可以使用对应的动画
因为ObjectAnimator派生自ValueAnimator,所以ValueAnimator其它的函数,它都可以使用,这里不再叙述
属性的get函数又有何作用呢 ?
我们已经知道属性的set函数的作用,那么对应的get函数有没有什么特殊的作用呢?
有,OberjectAnimator的构件方法,所需的值都是可变参数,如果只传入一个值呢?动画该怎么执行?
当只有一个值的时候,这个值将是动画的结束值,而开始值,则由相应的get函数返回

PropertyValuesHolder
PropertyValuesHolder也可以用来构造动画,事实上,前面我们讲的动画的构造,最终都是通过PropertyValuesHolder完成,并且PropertyValuesHolder可以让多个动画效果一起执行,先看下几个系统的函数:
// ObjectAnimator
public static ObjectAnimator ofPropertyValuesHolder(Object target,PropertyValuesHolder... values)
// PropertyValuesHolder
public static PropertyValuesHolder ofFloat(String propertyName, float... values)
public static PropertyValuesHolder ofInt(String propertyName, int... values)
public static PropertyValuesHolder ofObject(String propertyName, TypeEvaluator evaluator,Object... values)
public static PropertyValuesHolder ofKeyframe(String propertyName, Keyframe... values)

// 其实已经很明显了,我们可以使用PropertyValuesHolder 构建具体的动画效果, 
//然后使用 ObjectAnimator 的 ofPropertyValuesHolder函数将一个或多个PropertyValuesHolder 打包创建为动画对象
//以下是 使用PropertyValuesHolder 创建动画的例子:
PropertyValuesHolder rotationHolder = PropertyValuesHolder.ofFloat("Rotation", 60f, -60f, 40f, -40f, -20f, 20f, 10f, -10f, 0f);  
PropertyValuesHolder colorHolder = PropertyValuesHolder.ofInt("BackgroundColor", 0xffffffff, 0xffff00ff, 0xffffff00, 0xffffffff);  
ObjectAnimator animator = ObjectAnimator.ofPropertyValuesHolder(mTextView, rotationHolder, colorHolder);  
animator.setDuration(3000);  
animator.setInterpolator(new AccelerateInterpolator());  
animator.start(); 

//关于ofObject的使用方与ObjectAnimator的ofObject大同小异...
//ofKeyframe会在下面具体讲解

Keyframe(关键帧)
之前我们知道,通过插值器和Evaluator可以控制动画的变化速率,但如果要实现更复杂的效果,就需要定义更复杂的公式.Keyframe同样可以控制动画的速率,使用起来也更简单.在讲自定义插值器的时候,曾提到过,动画的进度在0~1之间,而Keyframe可以让我们指定动画在某一进度点上的值,通过这种方式,我们可以更灵活,更简单的控制动画的速率.
//动画开始的值为 0
Keyframe frame0 = Keyframe.ofFloat(0f, 0);
//动画进度为0.1的时候,值为 -20
Keyframe frame1 = Keyframe.ofFloat(0.1f, -20f);
//动画结束的时候,值为 0
Keyframe frame2 = Keyframe.ofFloat(1, 0);
//通过 Keyframe 构建 PropertyValuesHolder
PropertyValuesHolder frameHolder = PropertyValuesHolder.ofKeyframe("rotation",frame0,frame1,frame2);
Animator animator = ObjectAnimator.ofPropertyValuesHolder(mImage,frameHolder);
animator.setDuration(1000);
animator.start();
```
//使用Keyframe,每两帧之间默认匀速执行,即线性插值器,更强大的是,我们可以给Keyframe指定插值器,
//如果给某个Keyframe设置了插值器,那么从前一帧到这一帧的动画会按插值器执行
public void setInterpolator(TimeInterpolator interpolator)

//同样的,Keyframe的构建方式也有以下几种
public static Keyframe ofInt(float fraction, int value)  
public static Keyframe ofFloat(float fraction, float value)
public static Keyframe ofObject(float fraction, Object value)

//***需要强调的是,使用Keyframe的时候,最少需要两帧,否则会报错
//***另外第一帧是动画的开始,最后一帧是动画的结束
```

AnimatorSet
顾名思义,AnimatorSet可以联合多个动画一起执行:
//多个动画顺序执行
public void playSequentially(Animator... items);
public void playSequentially(List<Animator> items);
//多个动画同时执行
public void playTogether(Animator... items);
public void playTogether(Collection<Animator> items);

//以上方式都比较简单, 我们可以使用AnimatorSet.Builder实现更具体的控制,比如指定动画的执行顺序
// 执行动画
public Builder after(Animator aim)
//和前面动画一起执行
public Builder with(Animator anim)
//先执行前面的动画,再执行这个动画
public Builder before(Animator anim)
//先执行这个动画,再执行前面的动画
public Builder after(Animator anim)

//示例如下
ObjectAnimator tv1BgAnimator = ObjectAnimator.ofInt(mTv1, "BackgroundColor", 0xffff00ff, 0xffffff00, 0xffff00ff);
ObjectAnimator tv1TranslateY = ObjectAnimator.ofFloat(mTv1, "translationY", 0, 400, 0);
ObjectAnimator tv2TranslateY = ObjectAnimator.ofFloat(mTv2, "translationY", 0, 400, 0);
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.play(tv1TranslateY).with(tv2TranslateY).after(tv1BgAnimator);
animatorSet.setDuration(2000);
animatorSet.start();

AnimatorSet 可以通过*addListener(AnimatorListener listener) *监听其状态的变化
需要注意的是,某些属性可以通过AnimatorSet统一设置,比如: 动画时长,重复次数等.并且如果统一设置了这些属性,那么针对单个动画的设置将无效.
使用XML定义属性动画
- 在xml中对应animator总共有三个标签，分别是

<animator /> 对应ValueAnimator
<objectAnimator /> 对应ObjectAnimator
<set /> 对应AnimatorSet

animator (以下是animator完整的字段,及对应的值类型)
<animator android:duration="int"
android:valueFrom="float | int | color"
android:valueTo="float | int | color"
android:startOffset="int"
android:repeatCount="int"
android:repeatMode=["repeat" | "reverse"]
android:valueType=["intType" | "floatType"]
android:interpolator=["@android:interpolator/XXX"]/>
- android:duration:每次动画播放的时长
- android:valueFrom:初始动化值；取值范围为float,int和color，如果取值为float对应的值样式应该为89.0，取值为Int时，对应的值样式为：89;当取值为clolor时，对应的值样式为 #333333;
- android:valueTo：动画结束值；取值范围同样是float,int和color这三种类型的值；
- android:startOffset：动画激活延时；对应代码中的startDelay(long delay)函数；
- android:repeatCount：动画重复次数
- android:repeatMode：动画重复模式，取值为repeat和reverse；repeat表示正序重播，reverse表示倒序重播
- android:valueType：表示参数值类型，取值为intType和floatType；与android:valueFrom、android:valueTo相对应。如果这里的取值为intType，那么android:valueFrom、android:valueTo的值也就要对应的是int类型的数值。如果这里的数值是floatType，那么android:valueFrom、android:valueTo的值也要对应的设置为float类型的值。非常注意的是，如果android:valueFrom、android:valueTo的值设置为color类型的值，那么不需要设置这个参数；
- android:interpolator:设置加速器
objectAnimator
objectAnimator对比animator多了一条属性
android:propertyName="string"
- android:propertyName：对应属性名，即ObjectAnimator所需要操作的属性名
set(set标签只有一条属性)
<set android:ordering=["together" | "sequentially"]>
- android:ordering：表示动画开始顺序。together表示同时开始动画，sequentially表示逐个开始动画

加载XML里定义的动画
ValueAnimator valueAnimator = (ValueAnimator) AnimatorInflater.loadAnimator(context,R.animator.animator);
valueAnimator.start();

 ObjectAnimator animator = (ObjectAnimator) AnimatorInflater.loadAnimator(MyActivity.this, R.animator.object_animator);
 animator.setTarget(mTv1);
 animator.start();

 AnimatorSet set = (AnimatorSet) AnimatorInflater.loadAnimator(MyActivity.this, R.animator.set_animator);
 set.setTarget(mTv1);
 set.start();

布局动画

LayoutAnimation

XML实现
<?xml version="1.0" encoding="utf-8"?>
<layoutAnimation
xmlns:android="http://schemas.android.com/apk/res/android"
android:delay="1"
android:animationOrder="normal"
android:animation="@anim/slide_in_left"/>
```
...

<ListView android:id="@+id/listview" 
        android:layout_width="match_parent" 
        android:layout_height="match_parent" 
        android:layoutAnimation="@anim/layout_animation" />
```
代码实现
//得到一个LayoutAnimationController对象；
LayoutAnimationController controller = new LayoutAnimationController(animation);
//设置控件显示的顺序；
controller.setOrder(LayoutAnimationController.ORDER_REVERSE);
//设置控件显示间隔时间；
controller.setDelay(0.3f);
//为ListView设置LayoutAnimationController属性；
mListView.setLayoutAnimation(controller);
mListView.startLayoutAnimation();
各字段解释
delay:指每个Item的动画开始延时，取值是android:animation所指定动画时长的倍数，取值类型可以是float类型，也可以是百分数，默认是0.5;比如我们这里指定的动画是@anim/slide_in_left，而在slide_in_left.xml中指定android:duration=”1000”，即单次动画的时长是1000毫秒，而我们在这里的指定android:delay=”1”，即一个Item的动画会在上一个item动画完成后延时单次动画时长的一倍时间开始，即延时1000毫秒后开始。
animationOrder:指viewGroup中的控件动画开始顺序，取值有normal(正序)、reverse(倒序)、random(随机)
animation：指定每个item入场所要应用的动画。仅能指定res/aim文件夹下的animation定义的动画，不可使用animator动画。

GridLayoutAnimation

XML实现
<?xml version="1.0" encoding="utf-8"?>
<gridLayoutAnimation
xmlns:android="http://schemas.android.com/apk/res/android"
android:rowDelay="75%"
android:columnDelay="60%"
android:directionPriority="none"
android:direction="bottom_to_top|right_to_left"
android:animation="@android:anim/slide_in_left"/>

***

<GridView android:id="@+id/grid" 
      android:layout_width="match_parent" 
      android:layout_height="match_parent" 
      android:columnWidth="60dp" 
      android:gravity="center" 
      android:horizontalSpacing="10dp"           
      android:layoutAnimation="@anim/gride_animation"  
      android:numColumns="auto_fit" 
      android:stretchMode="columnWidth" 
      android:verticalSpacing="10dp"/>

代码实现
GridLayoutAnimationController controller = new GridLayoutAnimationController(animation);
controller.setColumnDelay(0.75f);
controller.setRowDelay(0.5f);
controller.setDirection(GridLayoutAnimationController.DIRECTION_BOTTOM_TO_TOP|GridLayoutAnimationController.DIRECTION_LEFT_TO_RIGHT);
controller.setDirectionPriority(GridLayoutAnimationController.PRIORITY_NONE);
grid.setLayoutAnimation(controller);
grid.startLayoutAnimation();
各属性解释
rowDelay:每一行动画开始的延迟。与LayoutAnimation一样，可以取百分数，也可以取浮点数。取值意义为，当前android:animation所指动画时长的倍数。 columnDelay：每一列动画开始的延迟。取值类型及意义与rowDelay相同。 directionPriority：方向优先级。取值为row,collumn,none，意义分别为：行优先，列优先，和无优先级（同时进行）;
direction：gridview动画方向。取值有四个：
*left_to_right：列，从左向右开始动画
right_to_left ：列，从右向左开始动画
top_to_bottom：行，从上向下开始动画
bottom_to_top：行，从下向上开始动画 *
这四个值之间可以通过“|”连接，从而可以取多个值。
很显然left_to_right和right_to_left是互斥的，
top_to_bottom和bottom_to_top是互斥的。
如果不指定 direction字段，
默认值为left_to_right | top_to_bottom；
即从上往下，从左往右。
animation: gridview内部元素所使用的动画。

布局增加/移除动画

android:animateLayoutChanges="true"
只要给布局添加该属性,它内部的控件在添加和删除时，是会带有默认动画
LayoutTransaction ,允许我们自定义动画效果
LayoutTransaction transitioner = new LayoutTransition();
ObjectAnimator animOut = ObjectAnimator.ofFloat(null, "rotation", 0f, 90f, 0f);
//设置动画
//第一个参数int transitionType：表示当前应用动画的对象范围，取值有：
//APPEARING —— 添加元素的动画
//DISAPPEARING —— 移除元素的动画
//CHANGE_APPEARING —— 添加元素时,其它元素的动画(该动画必须通过PropertyValuesHolder创建)
//CHANGE_DISAPPEARING —— 移除元素时,其它元素的动画(该动画必须通过PropertyValuesHolder创建)
//第二个参数Animator animator：表示当前所选范围的控件所使用的动画。
transitioner.setAnimator(LayoutTransition.DISAPPEARING, animOut);
//将LayoutTransaction设置进ViewGroup
linearLayout.setLayoutTransition(mTransitioner);
因为LayoutTransaction 使用的机会不多,且实际应用相对麻烦,所以不再详细说明