Android 动画 ValueAnimator(三)

第二篇我们讲了插值器，现在我们来看看另外一个东西，Evaluator。

Evaluator其实就是一个转换器，他能把小数进度转换成对应的数值位置

我们之前可以在监听器中拿到当前的进度值

animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {            @Override            public void onAnimationUpdate(ValueAnimator valueAnimator) {               int value = (int) valueAnimator.getAnimatedValue();                System.out.println("==========value: "+value);            }        });        animator.start();

那么这个值是怎么计算出来的呢？这就要靠Evaluator了，；Evaluator就是将从加速器返回的数字进度转成对应的数字值。
那这时候有朋友会问，之前也没有设置过插值器和Evaluator，那么怎么还能正常拿到结果呢?是因为ofInt和ofFloat都是系统直接提供的函数，所以在使用时都会有默认的插值器和Evaluator来使用的，不指定则使用默认的；对于Evaluator而言，ofInt()的默认Evaluator当然是IntEvaluator;而FloatEvalutar默认的则是FloatEvalutor。

下面我们看看系统的Evaluator是怎么实现的

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这个方法，第一个参数fraction代表开始到结束之间的百分比，后面两个参数分别代表起始值和结束值。
当前值 = 起始值+百分比*(结束值-起始值)
比如我们定义范围为(0,400),那么
当前值 = 0+百分比*(400),可以看到当前值是不断增大的。意思就是当前位置距离起始位置越来越远。

看懂了Evaluator的实现，我们来自定义一个Evaluator

public class AddEvaluator implements TypeEvaluator<Integer> {    @Override    public Integer evaluate(float fraction, Integer startValue, Integer endValue) {        return (int)(200+startValue+fraction*(endValue - startValue));    }}

  ValueAnimator animator = ValueAnimator.ofInt(0,400);        animator.setEvaluator(new AddEvaluator());        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {            @Override            public void onAnimationUpdate(ValueAnimator animation) {                int value = (int) animation.getAnimatedValue();                textView.layout(value,value,value+textView.getWidth(),value+textView.getHeight());            }        });        animator.setDuration(500);        animator.start();

我们可以看到，在原先的基础上增加了200.下面我们看一下效果图：

未使用Evaluator：

使用以后：

我们可以看到，使用自定义的Evaluator以后，textview的位置比原先增加了200.

下面我们再来实现一个之前用插值器实现过的效果

当前的值是随着进度的增加而减小的。

public class ReverseEvaluator implements TypeEvaluator<Integer> {    @Override    public Integer evaluate(float fraction, Integer startValue, Integer endValue) {        return (int)(endValue - fraction*(endValue - startValue));    }}

系统除了有IntEvaluator和FloatEvaluator之外，还有一个ArgbEvaluator,接下来我们看看到底是干啥的。

从名字上我们可以看出这个Evaluator和颜色有关，是的，就是用来变换颜色的，我们先看一下如何使用，然后去看源码。

从黄色变为蓝色

  ValueAnimator animator = ValueAnimator.ofInt(0xffffff00,0xff0000ff);        animator.setEvaluator(new ArgbEvaluator());        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {            @Override            public void onAnimationUpdate(ValueAnimator animation) {                int value = (int) animation.getAnimatedValue();                textView.setBackgroundColor(value);            }        });        animator.setDuration(1500);        animator.start();

public class ArgbEvaluator implements TypeEvaluator {    private static final ArgbEvaluator sInstance = new ArgbEvaluator();    /**     * Returns an instance of <code>ArgbEvaluator</code> that may be used in     * {@link ValueAnimator#setEvaluator(TypeEvaluator)}. The same instance may     * be used in multiple <code>Animator</code>s because it holds no state.     * @return An instance of <code>ArgbEvalutor</code>.     *     * @hide     */    public static ArgbEvaluator getInstance() {        return sInstance;    }    /**     * This function returns the calculated in-between value for a color     * given integers that represent the start and end values in the four     * bytes of the 32-bit int. Each channel is separately linearly interpolated     * and the resulting calculated values are recombined into the return value.     *     * @param fraction The fraction from the starting to the ending values     * @param startValue A 32-bit int value representing colors in the     * separate bytes of the parameter     * @param endValue A 32-bit int value representing colors in the     * separate bytes of the parameter     * @return A value that is calculated to be the linearly interpolated     * result, derived by separating the start and end values into separate     * color channels and interpolating each one separately, recombining the     * resulting values in the same way.     */    public Object evaluate(float fraction, Object startValue, Object endValue) {        int startInt = (Integer) startValue;        int startA = (startInt >> 24) & 0xff;        int startR = (startInt >> 16) & 0xff;        int startG = (startInt >> 8) & 0xff;        int startB = startInt & 0xff;        int endInt = (Integer) endValue;        int endA = (endInt >> 24) & 0xff;        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))));    }}

因为一共有四个值，ARGB,每个用八位来表示，所以十六进制就是0xffffff00

在evaluate方法里面先拿到A的颜色，然后分别拿到R,G,B的值，同理，拿到结束颜色相应的值，然后根据百分比分别计算出当前变化后的值，最后用或运算拼起来，就得到了一个完整的变化的值。