Android中的属性动画理解

Android中有补件动画，帧动画和属性动画这几种常见动画。属性动画是3.0系统后推出的比较强大的动画。可以实现生活中大多数常见的动画功能。最近学习，用到了属性动画，结合源码和一些参考做一个记录。

1.基本使用

属性动画中常用到类ValueAnimator，ObjectAnimator，属性动画就是通过改变对象的属性实现动画，这两个类完成了对象的属性从初始值到结束的值的变化。

常用的方法：ofFloat(),ofInt(),ofObject();等。这些方法都有很多不同的重载方法，提供不同的参数实现差异的功能。

其中有一个：ValueAnimator bizerAnimator = ObjectAnimator.ofObject(typeEvalautor, param, param,param);这个需要传入一个估值器对象（TypeEvaluator）

其他方法：

  bizerAnimator.setEvaluator();//设置一个估值器
  bizerAnimator.setRepeatCount();//设置重复执行次数
  bizerAnimator.setRepeatMode();//设置动画重复的模式
  bizerAnimator.setTarget();//设置动画添加一个对象
  bizerAnimator.setInterpolator();//设置一个插值器

这里插值器和估值器是实现一些复杂效果的关键。

基本使用举例：

ValueAnimator valueAnimator = ValueAnimator.ofFloat(0f,1f);
        valueAnimator.setDuration(500);
        valueAnimator.start();

一个基本的用法就是三行代码，实现500毫秒从0到1的变化；其实还可以传入多个参数，这个ofFloat()方法参数是边长参数。

 ValueAnimator valueAnimator = ValueAnimator.ofFloat(0f,0.6f,0.2f,1f);
        valueAnimator.setDuration(500);
        valueAnimator.start();

上面实现了从0到0.6到0.2再到1的变化。

ObjectAnimator类：

ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(imageView,"translationX",0f,200f,0f);
                objectAnimator.setDuration(2000);
                objectAnimator.start();

对一个ImageView 实现从起始位置到200px在到原始位置的变化，对应的：

"translationX"

是ImageView 的一个属性，这个属性在ImageView 中有个对应的set方法：

imageView.setTranslationX(0);

这里需要注意的一点就是： 在对一个对象进行操作的时候，第一个参数是对象示例，第二个参数一定是对应对象的一个属性并且有一个set方法去设置这个属性。动画执行过程就是通过这个属性设置值的。

2.组合使用

组合使用就是把不同的动画效果放一起执行，可以是先后执行，也可以同时执行，这是实现一些复杂效果的关键。组合使用通过AnimatorSet 来组合。

比如对上的图片添加第一个移动，透明度变化和旋转三种动画，组合执行：

 AnimatorSet animatorSet = new AnimatorSet();
                ObjectAnimator translation = ObjectAnimator.ofFloat(imageView,"translationX",0f,300f,0f);
                ObjectAnimator alpha = ObjectAnimator.ofFloat(imageView,"alpha",1f,0f,1f);
                ObjectAnimator rotationY = ObjectAnimator.ofFloat(imageView,"rotationY",0f,360f);
                //animatorSet.playSequentially(translation,alpha,rotationY);//按顺序执行位置移动，透明度变化，和旋转三个动画效果。
                //animatorSet.play(translation).with(alpha).before(rotationY);//执行translation同时执行alpha 设置，在执行rotationY之前。
                animatorSet.playTogether(translation,alpha,rotationY);//三个同时执行
                animatorSet.setDuration(3000);
                animatorSet.start();

以上代码创建了三个通话效果，通过不同的方法组合不同的执行效果。
知道了这些，我们还可以通过操作其他的对象属性作出其他的效果来。

属性动画的基本使用就是这些，如果代码操作不方便还可以写xml，在项目中使用。直接在代码中加载设置执行。

<set xmlns:android="http://schemas.android.com/apk/res/android">

    <objectAnimator
        android:duration="1000"
        android:propertyName="translationX"
        android:valueFrom="0dp"
        android:valueTo="100dp"
        android:valueType="floatType" />

    <objectAnimator
        android:duration="1000"
        android:propertyName="alpha"
        android:valueFrom="0"
        android:valueTo="1"
        android:valueType="floatType"/>

    <!--<objectAnimator-->
        <!--android:duration="1000"-->
        <!--android:propertyName="translationX"-->
        <!--android:valueFrom="100dp"-->
        <!--android:valueTo="0dp"-->
        <!--android:valueType="floatType" />-->

</set>

加载执行：

 Animator animator = AnimatorInflater.loadAnimator(this,R.animator.animator1);
                animator.setTarget(imageView);
                animator.start();

仔细的看看xml代码，其实没有直接java创建动画方便，java中属性在一个动画可以重复操作如：位置移动，从左到右，在到左。

3.实际应用

如果还需要其他的复杂效果就要通过我们自定义来实现了。比如网络中的一些弹跳效果，水波效果等，这里了解一些概念。

估值器：

所谓估值器从名称上一直没有理解明白。实际就是实现一个逻辑处理的方法。

估值器实现了一个接口重写了evaluate()方法。

public interface TypeEvaluator<T> {

    /**
     * This function returns the result of linearly interpolating the start and end values, with
     * <code>fraction</code> representing the proportion between the start and end values. The
     * calculation is a simple parametric calculation: <code>result = x0 + t * (x1 - x0)</code>,
     * where <code>x0</code> is <code>startValue</code>, <code>x1</code> is <code>endValue</code>,
     * and <code>t</code> is <code>fraction</code>.
     *
     * @param fraction   The fraction from the starting to the ending values
     * @param startValue The start value.
     * @param endValue   The end value.
     * @return A linear interpolation between the start and end values, given the
     *         <code>fraction</code> parameter.
     */
    public T evaluate(float fraction, T startValue, T endValue);

}

看几个个系统提供的估值器代码：

public class IntEvaluator implements TypeEvaluator<Integer> {

    /**
     * This function returns the result of linearly interpolating the start and end values, with
     * <code>fraction</code> representing the proportion between the start and end values. The
     * calculation is a simple parametric calculation: <code>result = x0 + t * (v1 - v0)</code>,
     * where <code>x0</code> is <code>startValue</code>, <code>x1</code> is <code>endValue</code>,
     * and <code>t</code> is <code>fraction</code>.
     *
     * @param fraction   The fraction from the starting to the ending values
     * @param startValue The start value; should be of type <code>int</code> or
     *                   <code>Integer</code>
     * @param endValue   The end value; should be of type <code>int</code> or <code>Integer</code>
     * @return A linear interpolation between the start and end values, given the
     *         <code>fraction</code> parameter.
     */
    public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
        int startInt = startValue;
        return (int)(startInt + fraction * (endValue - startInt));
    }
}

上面是一个整数估值器，evaluate();方法就是进行一个计算处理在返回去。

public class PointFEvaluator implements TypeEvaluator<PointF> {

    private PointF mPoint;

    public PointFEvaluator() {
    }

    public PointFEvaluator(PointF reuse) {
        mPoint = reuse;
    }

    /**
     * This function returns the result of linearly interpolating the start and
     * end PointF values, with <code>fraction</code> representing the proportion
     * between the start and end values. The calculation is a simple parametric
     * calculation on each of the separate components in the PointF objects
     * (x, y).
     *
     * <p>If {@link #PointFEvaluator(android.graphics.PointF)} was used to construct
     * this PointFEvaluator, the object returned will be the <code>reuse</code>
     * passed into the constructor.</p>
     *
     * @param fraction   The fraction from the starting to the ending values
     * @param startValue The start PointF
     * @param endValue   The end PointF
     * @return A linear interpolation between the start and end values, given the
     *         <code>fraction</code> parameter.
     */
    @Override
    public PointF evaluate(float fraction, PointF startValue, PointF endValue) {
        float x = startValue.x + (fraction * (endValue.x - startValue.x));
        float y = startValue.y + (fraction * (endValue.y - startValue.y));

        if (mPoint != null) {
            mPoint.set(x, y);
            return mPoint;
        } else {
            return new PointF(x, y);
        }
    }
}

PointFEvaluator 中evaluate（）方法对两个PointF进行处理，最后返回。从上面看，估值器就是对指定的一些参数按照我们的需求，重新处理生成一个新的参数给动画执行。

插值器：

估值器也是实现了一个接口和方法。

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);
}

系统提供了一些常用的插值器：

线性插值器，让动画成线性运动执行。对于接口的方法getInterpolation（）直接返回数据，没有处理。

public class LinearInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {

    public LinearInterpolator() {
    }

    public LinearInterpolator(Context context, AttributeSet attrs) {
    }

    public float getInterpolation(float input) {
        return input;
    }

    /** @hide */
    @Override
    public long createNativeInterpolator() {
        return NativeInterpolatorFactoryHelper.createLinearInterpolator();
    }
}

加速插值器，动画逐渐加速。从代码看，getInterpolation()方法返回值是一个进行了乘法或者多次幂函数计算，从数学上说这就是一个幂函数曲线加速。

Math.pow(input, mDoubleFactor);

public class AccelerateInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {
    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) {
        this(context.getResources(), context.getTheme(), attrs);
    }

    /** @hide */
    public AccelerateInterpolator(Resources res, Theme theme, AttributeSet attrs) {
        TypedArray a;
        if (theme != null) {
            a = theme.obtainStyledAttributes(attrs, R.styleable.AccelerateInterpolator, 0, 0);
        } else {
            a = res.obtainAttributes(attrs, R.styleable.AccelerateInterpolator);
        }

        mFactor = a.getFloat(R.styleable.AccelerateInterpolator_factor, 1.0f);
        mDoubleFactor = 2 * mFactor;
        setChangingConfiguration(a.getChangingConfigurations());
        a.recycle();
    }

    public float getInterpolation(float input) {
        if (mFactor == 1.0f) {
            return input * input;
        } else {
            return (float)Math.pow(input, mDoubleFactor);
        }
    }

    /** @hide */
    @Override
    public long createNativeInterpolator() {
        return NativeInterpolatorFactoryHelper.createAccelerateInterpolator(mFactor);
    }

通过上述系统代码的查看我们大致了解了，插值器就是通过一些数学计算，让当前时间的动画值改变，从而达到一定效果。

总的来说，估值器是处理了动画当前的数据，而插值器就对当前执行速度操作，达到一定效果。后边在对实际的自定义做练习。

参考资料：

http://www.jianshu.com/p/02deec7bf8f0

http://www.cnblogs.com/mengdd/p/3346003.html