TypeEvaluator 估值器抛物线

TypeEvaluator简介

Android提供了以下几个简单的Evalutor实现类：

IntEvaluator：属性的值类型为int
FloatEvaluator：属性的值类型为float
ArgbEvaluator：属性的值类型为十六进制颜色值

TypeEvaluator：一个接口，可以通过实现该接口自定义Evaluator。

TypeEvaluator的实现过程：

首先根据动画【已进行的时间】跟动画【总时间】的比计算出一个时间因子(0~1，即evalute()中的fraction参数，这个值是自动计算得到的)

然后根据【TimeInterpolator】得到出另一个算法因子

TypeEvaluator通过这【两个】因子计算出属性值并将其【传给】我们定义的泛型对象

最后在我们监听动画的绘制过程中，将泛型对象中保存的值【取出】并用于【更改】目标对象的属性

自定义TypeEvaluator时传入的泛型可以根据自己的需求，自己设计个Bean。

只要evaluate中的函数能够满足：当fraction=0时返回值为startValue，并且当fraction=1时返回值为endValue，就是一个比较合理的函数。

TypeEvaluator 接口源码

/**
 * Interface for use with the  ValueAnimator#setEvaluator(TypeEvaluator) function. Evaluators
 * allow developers to create animations on arbitrary任意的 property types, by allowing them to supply
 * custom evaluators for types that are not automatically understood and used by the animation system.
 */
public interface TypeEvaluator<T> {
    /**
     * This function returns the result of linearly interpolating the start and end values, with fraction representing
     * the proportion比例 between the start and end values. The calculation is a simple parametric参数
     * calculation: result = x0 + t * (x1 - x0), where "x0" is startValue, "x1" is endValue, and "t" is fraction.
     * @param fraction   The fraction from the starting to the ending values
     * @return A linear interpolation between the start and end values, given the fraction parameter.
     */
    public T evaluate(float fraction, T startValue, T endValue);
}

IntEvaluator 源码

/** This evaluator can be used to perform type interpolation between int values. */
public class IntEvaluator implements TypeEvaluator<Integer> {
    public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
        return (int)(startValue + fraction * (endValue - startValue)); 
    }
}

FloatEvaluator 源码

public Float evaluate(float fraction, Number startValue, Number endValue) {
   return startValue.floatValue() + fraction * (endValue.floatValue() - startValue.floatValue());
}

ArgbEvaluator 源码

/** integer values that represent ARGB colors. */
public class ArgbEvaluator implements TypeEvaluator {
    /**
     * 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))));
    }
}

自定义TypeEvaluator实现抛物线效果

自定义TypeEvaluator时传入的泛型可以根据自己的需求，自己设计个Bean。

为了以不同的函数分别设置x和y的位置，我们自定义的TypeEvaluator传入的泛型为PointF对象，每次根据当前时间返回一个PointF对象，PointF中的x、y代表View当前的位置，然后在监听动画绘制过程时更新UI。

自定义TypeEvaluator

public class PointFEvaluator implements TypeEvaluator<PointF> {

@Override

public PointF evaluate(float fraction, PointF startValue, PointF endValue) {

//只要能保证：当fraction=0时返回值为startValue，并且当fraction=1时返回值为endValue，就是一个比较合理的函数

PointF pointF = new PointF();

pointF.x = startValue.x + fraction * (endValue.x - startValue.x);// x方向匀速移动

pointF.y = startValue.y + fraction * fraction * (endValue.y - startValue.y);// y方向抛物线加速移动

return pointF;

}

在Activity中的使用

// 自定义TypeEvaluator实现抛物线动画效果

public class TypeEvaluatorActivity extends Activity {

private ImageView iv_src;

private boolean b = true;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);//全屏

requestWindowFeature(Window.FEATURE_NO_TITLE);//取消标题栏

Bitmap bitmap = Bitmap.createBitmap(20, 20, Bitmap.Config.ARGB_8888);

Canvas canvas = new Canvas(bitmap);

Paint paint = new Paint();

paint.setColor(Color.RED);

paint.setAntiAlias(true);

paint.setDither(true);

canvas.drawCircle(10, 10, 10, paint);

iv_src = new ImageView(this);

iv_src.setImageBitmap(bitmap);

setContentView(iv_src, new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));

}

@Override

public boolean onTouchEvent(MotionEvent event) {

if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {

b = !b;

Point point = new Point();

((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getSize(point);

ValueAnimator animator = new ValueAnimator().setDuration(1000);

//通过new创建的ValueAnimator要明确的setObjectValues和setEvaluator，并且一定要先setObjectValues，再setEvaluator

if (b) animator.setObjectValues(new PointF(0, 0), new PointF(point.x - iv_src.getWidth(), point.y - iv_src.getHeight()));

else animator.setObjectValues(new PointF(0, point.y - iv_src.getHeight()), new PointF(point.x - iv_src.getWidth(), 0));

animator.setEvaluator(new PointFEvaluator());//PointFEvaluator为自定义的估值器，其实就是用来封装你需要的数据用的

animator.addUpdateListener(new AnimatorUpdateListener() {

@Override

public void onAnimationUpdate(ValueAnimator animation) {

PointF point = (PointF) animation.getAnimatedValue();

iv_src.setX(point.x);

iv_src.setY(point.y);

}

});

animator.start();

}

return super.onTouchEvent(event);

}