动画分类

1，帧动画

顾名思义，就是连续播放多张不同的图片，形成的动画效果，这个必须是放在Drawable文件夹下，下面是XML的方式

<?xml version="1.0" encoding="utf-8"?>
<animation-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@color/loading0" android:duration="120"/>
    <item android:drawable="@color/loading1" android:duration="120"/>
    <item android:drawable="@color/loading2" android:duration="120"/>
</animation-list>

代码的方式

private AnimationDrawable mAnimationDrawable;
public AnimationDrawable getAnimationDrawableList() {
    if(mAnimationDrawable == null) {
        mAnimationDrawable = new AnimationDrawable();
        for (int i = 0; i < 5; i++) {
            int identifier = getResources().getIdentifier("loading"+i, "drawable", getPackageName());
            mAnimationDrawable.addFrame(getResources().getDrawable(identifier), 120);
        }
    }
    return mAnimationDrawable;
}

2,补间动画

这类动画只需要定义动画的开始和结束，时长，不需要定义动画的每一帧，通过对View的内容进行一系列的图像变换来实现的

主要包括四种基本的效果

• 透明度变化Alpha
• 大小变化Scale
• 位移变化 Translate
• 旋转变化 Retate

提到动画不得不提到插值器Interpolator，负责控制动画变化的速度。

通俗的可以理解为物理上的加速度。

同理,它能实现的基本效果就是匀速，加速，减速，抛物线等多种速度变化

• Interpolator其实是一个接口，继承自TimeInterpolator

• public interface Interpolator extends TimeInterpolator {
  }

  public interface TimeInterpolator {
  float getInterpolation(float input);
  }

该接口只有一个float getInterpolation(float input);方法，入参是一个0.0-1.0的值，返回值可以小于0.0，也可以大于1.0

Android已经默认帮我们实现了好几种的插值器，具体看Android
的源码

补间动画使用比较简单一些，这里就不放源码了，大家可以自行阅读Android
源码，查看实现方式

3,属性动画

属性动画是Android3.0引入的，补间动画我们只是改变了View的绘制效果，而View的实际属性是没有发生变化的。而属性动画正是直接View的属性来实现的，同时属性动画可以在任何对象上，不仅仅限于View

定义属性动画需要的一些基本属性

• 动画持续时间-通过android:duration来指定
• 动画的插值方式，这个和补间动画的插值器理解类似通过android:interpolater来指定
• 动画的重复次数-通过android:repeatCount来指定
• 动画的重复模式-通过android:repeatMode来指定
• 帧刷新频率
• 动画集合 -实现多个属性动画的组合使用-通过android:ordeing来指定这组动画是按照次序还是同时播放，资源文件中通过<set></set>来表示

属性动画中，另外一个重要的概念就是 Evaluator

Evaluator是用来控制属性动画是如何来计算属性值的-可以理解为每次对象属性的变化率

public interface TypeEvaluator<T> {
    public T evaluate(float fraction, T startValue, T endValue);
}

常见的实现类就是IntEvaluator，FloatEvaluator，ArgbEvaluator，我们来看下ArgbEvaluator的实现方式，实现的逻辑就是根据输入的初始值和结束值及一个进度比，计算出每一个进度的ARGB值

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;
        float startA = ((startInt >> 24) & 0xff) / 255.0f;
        float startR = ((startInt >> 16) & 0xff) / 255.0f;
        float startG = ((startInt >>  8) & 0xff) / 255.0f;
        float startB = ( startInt        & 0xff) / 255.0f;

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

        // convert from sRGB to linear
        startR = (float) Math.pow(startR, 2.2);
        startG = (float) Math.pow(startG, 2.2);
        startB = (float) Math.pow(startB, 2.2);

        endR = (float) Math.pow(endR, 2.2);
        endG = (float) Math.pow(endG, 2.2);
        endB = (float) Math.pow(endB, 2.2);

        // compute the interpolated color in linear space
        float a = startA + fraction * (endA - startA);
        float r = startR + fraction * (endR - startR);
        float g = startG + fraction * (endG - startG);
        float b = startB + fraction * (endB - startB);

        // convert back to sRGB in the [0..255] range
        a = a * 255.0f;
        r = (float) Math.pow(r, 1.0 / 2.2) * 255.0f;
        g = (float) Math.pow(g, 1.0 / 2.2) * 255.0f;
        b = (float) Math.pow(b, 1.0 / 2.2) * 255.0f;

        return Math.round(a) << 24 | Math.round(r) << 16 | Math.round(g) << 8 | Math.round(b);
    }
}

4,属性动画-AnimatorSet

AnimatorSet是Animator的子类，它可以指定多个属性动画是顺序执行还是同时执行

5,属性动画-ValueAnimator实现

ValueAnimator是属性动画中最重要的一个类，它定义了属性动画大部分的核心功能，包括计算各个帧的属性值，处理更新事件，按照属性值的类型控制计算规则等

一个完整的属性动画可以由俩部分组成

• 计算动画各个帧的属性值
• 将这些属性值设置给指定的对象

ValueAnimator为我们实现了第一部分的功能，第二部分由我们开发者自己来实现。ValueAnimator的构造函数是空实现，一般都是使用静态工厂方法来实现

下面是实现一个完整的ValueAnimator的动画流程

1，定义一个Evaluator

public class IntEvaluator implements TypeEvaluator<Integer> {
    public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
        int startInt = startValue;
        return (int)(startInt + fraction * (endValue - startInt));
    }
}

2，定义一个Interpolator

public class LinearInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {

    public LinearInterpolator() {
    }

    public LinearInterpolator(Context context, AttributeSet attrs) {
    }

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

3，开始动画

public void startAnim(Object target, int from, int to, int duration) {
    ValueAnimator va = ValueAnimator.ofInt(from, to);
    va.setInterpolator(new LinearInterpolator());
    va.setEvaluator(new IntEvaluator());
    va.setDuration(duration);
    va.setTarget(this);
    va.addUpdateListener(animator -> {
        int value = (int) animator.getAnimatedValue();//
        animator.getAnimatedFraction();//动画执行的百分比0-1
        target.update(value);


    });
    va.start();
}

4，停止动画

public void stopAnim() {
    va.cancel();
}

5,属性动画-ObjectAnimator实现

ObjectAnimator动画是ValueAnimator的子类，实现的上面提到的第二部分功能。它和ValueAnimator最大的不同就是构造的时候需要指定作用的对象和对象的属性名，而且不需要实现addUpdateListener接口

public class CustomProgressBar extends ProgressBar {
    public CustomProgressBar(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public void setProgressWithAnim(int progress, int duration) {
        ObjectAnimator animator = ObjectAnimator.ofInt(this, "progress", progress);
        animator.setDuration(duration);
        animator.start();
    }
}

使用ObjectAnimator有以下几点需要注意：

• 需要为对象对应的属性提高setter方法，例如上面的setProgress方法

• 如果动画的对象是View，那么为了能让其显示动画效果，某些情况下可能还是需要注册addUpdateListener，在回调中刷新view的显示

• 属性动画也可以在XML中定义

    <set xmlns:android="http://schemas.android.com/apk/res/android">
    <!--消失-->
    <objectAnimator android:duration="0"
                    android:propertyName="alpha"
                    android:valueFrom="1.0"
                    android:valueTo="0.0"/>
        
    <!--旋转-->
    <objectAnimator android:duration="300"
                    android:propertyName="rotationY"
                    android:valueFrom="360"
                    android:valueTo="0"/>
    </set>
  

获取XML属性动画

AnimatorSet as = AnimatorInflater.loadAnimator(context, R.animator.animator);
as.setTarget(mBackView);
as.start();

6,属性动画-XxxAnimator.ofPropertyValuesHolder使用

先上代码

 public static ObjectAnimator getPulseAnimator(View labelToAnimate, float decreaseRatio,
        float increaseRatio) {
    Keyframe k0 = Keyframe.ofFloat(0f, 1f);
    Keyframe k1 = Keyframe.ofFloat(0.275f, decreaseRatio);
    Keyframe k2 = Keyframe.ofFloat(0.69f, increaseRatio);
    Keyframe k3 = Keyframe.ofFloat(1f, 1f);

    PropertyValuesHolder scaleX = PropertyValuesHolder.ofKeyframe("scaleX", k0, k1, k2, k3);
    PropertyValuesHolder scaleY = PropertyValuesHolder.ofKeyframe("scaleY", k0, k1, k2, k3);
    ObjectAnimator pulseAnimator =
            ObjectAnimator.ofPropertyValuesHolder(labelToAnimate, scaleX, scaleY);
    pulseAnimator.setDuration(PULSE_ANIMATOR_DURATION);

    return pulseAnimator;
}

PropertyValuesHolder这个类的意义就是，它其中保存了动画过程中所需要操作的属性和对应的值

Keyframe直译过来就是关键帧

关键帧这个概念是从动画里学来的，类似帧动画，我们指定的每一张图片就是一个关键帧
Keyframe就相当于定义帧动画中的每一个图片显示的时间和位置

fraction：表示当前的显示进度，即从加速器中getInterpolation()函数的返回值；
value：表示当前应该在的位置 
public static Keyframe ofFloat(float fraction, float value)

• 比如Keyframe.ofFloat(0f, 1f);表示动画进度为0时，动画所在的数值位置为0
• Keyframe.ofFloat(0.275f, decreaseRatio)表示动画进度为27.5%时，动画所在的数值位置为decreaseRatio
• Keyframe.ofFloat(1f,1f)表示动画结束时，动画所在的数值位置为1