TypeEvaluator

一、系统内置的Evaluator：

IntEvaluator

public class IntEvaluator implements TypeEvaluator<Integer> {

    public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
        int startInt = startValue;
        return (int)(startInt + fraction * (endValue - startInt));
    }
}

FloatEvaluator

public class FloatEvaluator implements TypeEvaluator<Number> {

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

ArgbEvaluator

public class ArgbEvaluator implements TypeEvaluator {
    private static final ArgbEvaluator sInstance = new ArgbEvaluator();

    public static ArgbEvaluator getInstance() {
        return sInstance;
    }

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

二、自定义Evaluator

平抛：

public class HorizontalThrowEvaluator implements TypeEvaluator<PointF> {

    /**
     * 计算曲线的值
     *
     * @param fraction   ：进度
     * @param startValue ：起点
     * @param endValue   ：终点
     * @return ：曲线位置的值
     */
    @Override
    public PointF evaluate(float fraction, PointF startValue, PointF endValue) {
        PointF point = new PointF();//结果

        //水平：s=vt
        point.x = 300 * fraction;
        //竖直：g*t*t/2
        point.y = 10 * fraction * fraction / 2;

        return point;
    }
}

平抛示意图：

二阶贝塞尔曲线：

public class Bezier2Evaluator implements TypeEvaluator<PointF> {

    private PointF pointFCtrl;//控制点

    public Bezier2Evaluator(PointF pointFCtrl1) {
        this.pointFCtrl = pointFCtrl1;
    }

    /**
     * 计算曲线的值
     *
     * @param fraction   ：进度
     * @param startValue ：起点
     * @param endValue   ：终点
     * @return ：曲线位置的值
     */
    @Override
    public PointF evaluate(float fraction, PointF startValue, PointF endValue) {
        float timeLeft = 1.0f - fraction;
        PointF point = new PointF();//结果

        point.x = timeLeft * timeLeft * (startValue.x)
                + 2 * timeLeft * fraction * (pointFCtrl.x)
                + fraction * fraction * (endValue.x);

        point.y = timeLeft * timeLeft * (startValue.y)
                + 2 * timeLeft * fraction * (pointFCtrl.y)
                + fraction * fraction * (endValue.y);

        return point;
    }
}

二次方公式：

三阶贝塞尔曲线：

public class Bezier3Evaluator implements TypeEvaluator<PointF> {

    private PointF pointFCtrl1;//控制点一
    private PointF pointFCtrl2;//控制点二

    public Bezier3Evaluator(PointF pointFCtrl1, PointF pointFCtrl2) {
        this.pointFCtrl1 = pointFCtrl1;
        this.pointFCtrl2 = pointFCtrl2;
    }

    /**
     * 计算曲线的值
     *
     * @param fraction   ：进度
     * @param startValue ：起点
     * @param endValue   ：终点
     * @return ：曲线位置的值
     */
    @Override
    public PointF evaluate(float fraction, PointF startValue, PointF endValue) {
        float timeLeft = 1.0f - fraction;
        PointF point = new PointF();//结果

        point.x = timeLeft * timeLeft * timeLeft * (startValue.x)
                + 3 * timeLeft * timeLeft * fraction * (pointFCtrl1.x)
                + 3 * timeLeft * fraction * fraction * (pointFCtrl2.x)
                + fraction * fraction * fraction * (endValue.x);

        point.y = timeLeft * timeLeft * timeLeft * (startValue.y)
                + 3 * timeLeft * timeLeft * fraction * (pointFCtrl1.y)
                + 3 * timeLeft * fraction * fraction * (pointFCtrl2.y)
                + fraction * fraction * fraction * (endValue.y);

        return point;
    }
}

三次方公式：