前言

《Android开发艺术探索》第三章弹性滑动中有这么一段话：”如何实现弹性滑呢？实现方法有很多，但它们都有一个共同的思想：将一次大的滑动分成若干次小的滑动并在一个时间段内完成，其实现方式有很多种，Scroller、Handler.postDelayed()、Thread.sleep()等“；我们将这段话套用到Android动画上：将一次大的属性变化（如透明度从1到0）分成很多次小的属性变化并在一个时间段内完成（16.7ms内完成），从而实现透明度渐变动画效果，其实现方式是通过Choreographer来完成的；Choreographer是动画原理的一个核心，搞明白动画工作原理之前我们需要先了解Choreographer工作过程；
Choreographer工作过程简单描述如下：在Choreographer对象中有四条链表，分别保存着待处理的输入事件，待处理的动画事件，待处理的View绘制事件、待处理的post到Choreographer中事件，Android系统每隔16.7ms发出VSYNC信号，Choreographer.FrameDisplayEventReceiver收到信号后调用onVsync方法，最终会调用Choreographer.doFrame()方法，在doFrame方法中处理输入事件、动画事件、View绘制、post到Choreographer中的FrameCallback；我们可以使用Choreographer#postFrameCallback设置callback与Choreographer交互，设置的FrameCallCack（doFrame方法）会在下一个frame被渲染时触发（即下一个VSYNC到来时执行）；Choreographer更多内容请参考Android Choreographer 源码分析
Android动画原理简单描述：将View的一次大的属性变化拆分为多次小的属性变化，在每次VSYNC信号到来时，根据当前时间和插值器来计算当前View属性的值，然后给View设置该属性值，直到动画执行完毕。其中Choreographer将动画拆分成一次次小的属性变化，Choreographer是动画的指挥者。理想情况下，属性刷新次数（动画拆分为多次小的属性变化） = 动画执行时间/16.7ms 。
我们通过属性动画工作流程来介绍Android动画工作原理，其它动画的工作过程也应该类似，感兴趣的可以阅读源码来了解其原理；本文主要围绕以下四个问题来讲解动画原理：
问题一：动画如何完成一次属性变化刷新？
问题二：动画如何被拆分成一次次小的属性变化？
问题三：动画如何跳出属性刷新的流程，从而结束动画？
问题四：动画监听器何时被调用？

属性动画简单例子

在讲解原理前，我们先来看一下属性的动画的一个简单例子：

public class AnimationActivity extends AppCompatActivity implements View.OnClickListener{

    private Button mButton;
    public static final String TAG = "AnimationTest";
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.animation_layout);
        mButton = (Button) findViewById(R.id.button);
        mButton.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        //ObjectAnimator extends ValueAnimator;
        ValueAnimator alphaAnimation = ObjectAnimator.ofFloat(mButton,"alpha",1.0f,0f);
        alphaAnimation.setDuration(100);
        alphaAnimation.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                //属性刷新
                Log.d(TAG, "onAnimationUpdate: " + animation.getAnimatedValue());
            }
        });
        alphaAnimation.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {
                //动画开始
                Log.d(TAG, "onAnimationStart: ");
            }

            @Override
            public void onAnimationEnd(Animator animation) {
                //动画结束
                Log.d(TAG, "onAnimationEnd: ");
            }

            @Override
            public void onAnimationCancel(Animator animation) {
                Log.d(TAG, "onAnimationCancel: ");
            }

            @Override
            public void onAnimationRepeat(Animator animation) {
                Log.d(TAG, "onAnimationRepeat: ");
            }
        });
        alphaAnimation.start();
    }
}

运行之后，我们点击Button，对Button开始做透明度动画，相关日志打印如下：

01-28 10:15:39.587 3867-3867/com.android.animation D/AnimationTest: onAnimationStart: 
01-28 10:15:39.587 3867-3867/com.android.animation D/AnimationTest: onAnimationUpdate: 1.0
01-28 10:15:39.597 3867-3867/com.android.animation D/AnimationTest: onAnimationUpdate: 1.0
01-28 10:15:39.607 3867-3867/com.android.animation D/AnimationTest: onAnimationUpdate: 0.93037105
01-28 10:15:39.627 3867-3867/com.android.animation D/AnimationTest: onAnimationUpdate: 0.75452065
01-28 10:15:39.647 3867-3867/com.android.animation D/AnimationTest: onAnimationUpdate: 0.5
01-28 10:15:39.657 3867-3867/com.android.animation D/AnimationTest: onAnimationUpdate: 0.24547923
01-28 10:15:39.677 3867-3867/com.android.animation D/AnimationTest: onAnimationUpdate: 0.061846733
01-28 10:15:39.697 3867-3867/com.android.animation D/AnimationTest: onAnimationUpdate: 0.0
01-28 10:15:39.697 3867-3867/com.android.animation D/AnimationTest: onAnimationEnd: 

动画原理分析

问题一：动画如何完成一次属性变化刷新？
下面我们从动画的入口alphaAnimation.start()开始分析动画原理，先来看动画如何完成一次属性刷新：

    private void start(boolean playBackwards) {
        //设置相关标志位
        mStarted = true;
        mPaused = false;
        mRunning = false;
        mAnimationEndRequested = false;
        //最关键的方法，动画循环执行在该方法中实现
        AnimationHandler animationHandler = AnimationHandler.getInstance();
        animationHandler.addAnimationFrameCallback(this, (long) (mStartDelay * sDurationScale));

        if (mStartDelay == 0 || mSeekFraction >= 0) {
            // If there's no start delay, init the animation and notify start listeners right away
            // to be consistent with the previous behavior. Otherwise, postpone this until the first
            // frame after the start delay.
            //初始化相关属性，onAnimationStart在该方法中被调用；
            startAnimation();
        }
    }

以上最核心的方法是AnimationHandler.addAnimationFrameCallback（）。下面我们来分析该方法：

AnimationHandler
    //final AnimationFrameCallback callback就是ValueAnimation
    //public class ValueAnimator extends Animator implements AnimationHandler.AnimationFrameCallback
    public void addAnimationFrameCallback(final AnimationFrameCallback callback, long delay) {
        if (mAnimationCallbacks.size() == 0) {
            //动画开始执行时，mAnimationCallbacks.size()为0.会调用getProvider().postFrameCallback方法；
            getProvider().postFrameCallback(mFrameCallback);
        }
        if (!mAnimationCallbacks.contains(callback)) {
            //将ValueAnimator添加在mAnimationCallbacks列表；
            mAnimationCallbacks.add(callback);
        }
    }

下面我们来看getProvider().postFrameCallback(mFrameCallback);
AnimationHandler.getProvider（）方法、MyFrameCallbackProvider、mFrameCallback代码如下：

private AnimationFrameCallbackProvider getProvider() {
        if (mProvider == null) {
            mProvider = new MyFrameCallbackProvider();
        }
        return mProvider;
    }
    
     /**
     * Default provider of timing pulse that uses Choreographer for frame callbacks.
     */
    private class MyFrameCallbackProvider implements AnimationFrameCallbackProvider {
        //最核心的大佬编舞者终于现身了
        final Choreographer mChoreographer = Choreographer.getInstance();

        @Override
        public void postFrameCallback(Choreographer.FrameCallback callback) {
            mChoreographer.postFrameCallback(callback);
        }

        @Override
        public void postCommitCallback(Runnable runnable) {
            mChoreographer.postCallback(Choreographer.CALLBACK_COMMIT, runnable, null);
        }

        @Override
        public long getFrameTime() {
            //获取上一次VSYNC信号时间；
            return mChoreographer.getFrameTime();
        }
    }
    
    private final Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
        @Override
        public void doFrame(long frameTimeNanos) {
            //Choreographer收到VSYNC都会调用该方法，正常情况下每16.7ms就会调用一次doFrame
            doAnimationFrame(getProvider().getFrameTime());
            if (mAnimationCallbacks.size() > 0) {
                //再将自己post到编舞者中，以便下次收到VSYNC时，继续调用doFrame来刷新动画；
                getProvider().postFrameCallback(this);
            }
        }
    };

在执行完getProvider().postFrameCallback(mFrameCallback)后，下一次收到VYSNC信号时，就会调用mFrameCallback.doFrame方法，doFrame方法主要做了两件重要的工作：
（1）调用doAnimationFrame刷新View的相关属性；
（2）将自己再次post到Choreographer中，这样在下一次VSYNC到来时继续执行doFrame，完成下一次属性刷新;
关键点：动画属性一次次刷新就是通过mFrameCallback来实现的；
下面我们来看doAnimationFrame(getProvider().getFrameTime())方法：

    private void doAnimationFrame(long frameTime) {
        for (int i = 0; i < size; i++) {
            //callback就是我们添加到mAnimationCallbacks列表中的ValueAnimator
            final AnimationFrameCallback callback = mAnimationCallbacks.get(i);
            if (isCallbackDue(callback, currentTime)) {
                //执行ValueAnimator.doAnimationFrame；
                callback.doAnimationFrame(frameTime);
                if (mCommitCallbacks.contains(callback)) {
                    getProvider().postCommitCallback(new Runnable() {
                        @Override
                        public void run() {
                            //每一次刷新刷新之后会调用，目前没有看到会执行该方法；
                            commitAnimationFrame(callback, getProvider().getFrameTime());
                        }
                    });
                }
            }
        }
        cleanUpList();
    }

AnimationFrameCallback callback = mAnimationCallbacks.get(i);该callback就是valueAnimator，即我们在调用AnimationHandler.addAnimationFrameCallback中将ValueAnimator添加在mAnimationCallbacks列表；
下面我们来看ValueAnimator.doAnimationFrame(frameTime)方法，在该方法最终会刷新View的属性；

 /**
     * Processes a frame of the animation, adjusting the start time if needed.
     *  处理每一帧中的刷新
     * @param frameTime The frame time.
     * @return true if the animation has ended.
     * @hide
     */
    public final void doAnimationFrame(long frameTime) {
        //在animateBasedOnTime刷新View属性，并判断动画是否执行完毕；
        boolean finished = animateBasedOnTime(currentTime);
        if (finished) {
            //如果动画结束执行endAnimation
            endAnimation();
        }
    }

下面我们继续来看animateBasedOnTime()方法：

    boolean animateBasedOnTime(long currentTime) {
        //done表示动画是否执行完毕；
        boolean done = false;
        //在ValueAnimator.startAnimation中将mRuning置为true；
        if (mRunning) {
            final long scaledDuration = getScaledDuration();
            final float fraction = scaledDuration > 0 ?
                    (float)(currentTime - mStartTime) / scaledDuration : 1f;
            final float lastFraction = mOverallFraction;
            final boolean newIteration = (int) fraction > (int) lastFraction;
            //根据当前时间currentTime来判断动画是否执行完毕；
            final boolean lastIterationFinished = (fraction >= mRepeatCount + 1) &&
                    (mRepeatCount != INFINITE);
            if (scaledDuration == 0) {
                ...
            } else if (newIteration && !lastIterationFinished) {
                ...
            } else if (lastIterationFinished) {
                //动画执行完毕；
                done = true;
            }
            //计算当前View属性值，然后设置View相关属性；
            animateValue(currentIterationFraction);
        }
        return done;
    }

我们继续来看ObjectAnimator和ValueAnimator的animateValue方法，ObjectAnimator继承ValueAnimator；

ObjectAnimator：
    void animateValue(float fraction) {
        //getTarget（）返回的就是ValueAnimator alphaAnimation = ObjectAnimator.ofFloat(mButton,"alpha",1.0f,0f)中的mButton，
        final Object target = getTarget();
        //调用ValueAnimator.animateValue,主要是计算当前动画的进度
        super.animateValue(fraction);
        int numValues = mValues.length;
        for (int i = 0; i < numValues; ++i) {
            //调用PropertyValuesHolder.setAnimatedValue设置mButton在该帧的透明度，即super.animateValue(fraction)计算出的当前透明度
            mValues[i].setAnimatedValue(target);
        }
    }
VauleAnimator：
    void animateValue(float fraction) {
        //根据插值器计算当前属性动画的进度
        fraction = mInterpolator.getInterpolation(fraction);
        mCurrentFraction = fraction;
        int numValues = mValues.length;
        for (int i = 0; i < numValues; ++i) {
            //将当前进度存放到PropertyValuesHolder.mAnimatedValue,
            //在AnimatorUpdateListener.onAnimationUpdate方法中可以通过ValueAnimator.getAnimatedValue获取动画进度
            mValues[i].calculateValue(fraction);
        }
        if (mUpdateListeners != null) {
            int numListeners = mUpdateListeners.size();
            for (int i = 0; i < numListeners; ++i) {
                //回调AnimatorUpdateListener.onAnimationUpdate方法
                mUpdateListeners.get(i).onAnimationUpdate(this);
            }
        }
    }

animateValue方法主要工作：根据插值器计算mButton在该帧时的透明度，然后调用PropertyValuesHolder.setAnimatedValue设置mButton的透明度，从而完成该帧透明度变化；每一帧更新一次透明度，最终完成整个透明度变化过程；
下面我们来看PropertyValuesHolder.setAnimatedValue(Object target)代码，其中target就是ValueAnimator alphaAnimation = ObjectAnimator.ofFloat(mButton,"alpha",1.0f,0f)中的mButton，该方法主要就是设置当前View的属性值，执行该方法最终会调用View.setAlpha()来设置mButton的透明度，在该帧中mButton的透明度就完成了更新。

/**
     * Internal function to set the value on the target object, using the setter set up
     * earlier on this PropertyValuesHolder object. This function is called by ObjectAnimator
     * to handle turning the value calculated by ValueAnimator into a value set on the object
     * according to the name of the property.
     * @param target The target object on which the value is set
     *  通过注释可以看出，该方法主要就是设置当前View的属性值，执行完该方法后，在该帧中mButton的透明度就完成了更新
     */
    void setAnimatedValue(Object target) {
        // 如果有属性，通过set方法来更新属性值
        if (mProperty != null) {
            //getAnimatedValue（）就是返回VauleAnimator.animateValue中计算出的当前进度值
            mProperty.set(target, getAnimatedValue());
        }
        // 是否通过反射调用属性的setter方法来更新属性值
        if (mSetter != null) {
            try {
                //getAnimatedValue（）就是返回VauleAnimator.animateValue中计算出的当前进度值    
                mTmpValueArray[0] = getAnimatedValue();
                mSetter.invoke(target, mTmpValueArray);
            }
        }
    }

以上流程完成了mButton透明度的一次更新，同时也解释了动画是如何完成一次属性变化的刷新。
问题二：动画如何被拆分成一次次小的属性变化？
该问题也可以简单理解如何循环更新mButton透明度呢？我们再来回顾AnimationHandler.addAnimationFrameCallback方法中：

public void addAnimationFrameCallback(final AnimationFrameCallback callback, long delay) {
        if (mAnimationCallbacks.size() == 0) {
            getProvider().postFrameCallback(mFrameCallback);
        }
    }
    
    private final Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
        @Override
        public void doFrame(long frameTimeNanos) {
            //在doAnimationFrame更新mButton在当前帧中的透明度
            doAnimationFrame(getProvider().getFrameTime());
            //mAnimationCallbacks列表中存放正在执行的动画，动画执行完毕会将对应的AnimationFrameCallback remove掉
            if (mAnimationCallbacks.size() > 0) {
                //将mFrameCallback自身再次post到Choreographer在下一次VSYNC信号到来时，再次调用doFrame来更新mButton的透明度
                //如果动画一直没有执行完毕，会一直循环执行doFrame
                getProvider().postFrameCallback(this);
            }
        }
    };

在mFrameCallback中完成多次动画的拆分，并在每次收到VSYNC信号时，更新View的属性，连续不停的更新View属性，直到动画结束。
问题三：动画如何跳出属性刷新的流程，从而结束动画？
该问题也可以理解为动画是如何跳出mFrameCallback循环，在mFrameCallback中会判断mAnimationCallback列表中是否还有AnimationFrameCallback，如果mAnimationCallback列表中没有AnimationFrameCallback，那么透明度变化在下一次VSYNC到来时就不会再继续执行从而结束动画，那么我们找到mAnimationCallbacks列表啥时候将AnimationFrameCallback remove掉，就代表动画结束；主要流程如下：

ValueAnimator：
    public final void doAnimationFrame(long frameTime) {
        //animateBasedOnTime根据当前时间计算动画是否应该结束
        //如果动画应该结束，返回true；
        boolean finished = animateBasedOnTime(currentTime);
        if (finished) {
            //调用endAnimation结束动画
            endAnimation();
        }
    }
    
    private void endAnimation() {
        AnimationHandler handler = AnimationHandler.getInstance();
        //在AnimationHandler将ValueAnimator remove掉；
        handler.removeCallback(this);
        if ((mStarted || mRunning) && mListeners != null) {
            for (int i = 0; i < numListeners; ++i) {
                //调用AnimatorListener.onAnimationEnd方法通知应用
                tmpListeners.get(i).onAnimationEnd(this);
            }
        }
    }
AnimationHandler：
    public void removeCallback(AnimationFrameCallback callback) {
        int id = mAnimationCallbacks.indexOf(callback);
        if (id >= 0) {
            //将ValueAnimator remove调用，这样在下一此VSYNC到来时就不会继续执行动画
            mAnimationCallbacks.set(id, null);
        }
    }

问题四：动画监听器何时被调用？
即以下几个方法是在何时回调的？
AnimatorListener.onAnimationStart(); //在动画开始时调用
AnimatorUpdateListener.onAnimationUpdate();//在每一次属性刷新时调用
AnimatorListener.onAnimationEnd();//动画结束时调用
通过以上代码中注释我们可以找到以下调用关系：

ValueAnimator.start() > startAnimation() > notifyStartListeners > AnimatorListener.onAnimationStart()
ValueAnimator.doAnimationFrame() > animateBasedOnTime() > AnimatorListener.onAnimationUpdate();
ValueAnimator.doAnimationFrame() > endAnimation() > AnimatorListener.onAnimationEnd();

最后，我们再来回顾一下动画原理的简单描述：将View的一次大的属性变化拆分为多次小的属性变化，在每次VSYNC信号到来时，根据当前时间和插值器来计算当前View属性的值，然后设置给View设置该属性值，直到动画执行完毕，动画的拆分是由Choreographer来完成的。
以上就是动画执行的主要过程，希望对你理解Android动画有所帮助。

参考资料

《Android开发艺术探索》
《深入理解Android卷三》第四章Android动画原理简介
Android动画原理分析