Property Animation框架详解(一)

作者： ztelur
联系方式：segmentfault，csdn，简书

本文转载请注明原作者、文章来源，链接，版权归原文作者所有。

 前段时间阅读了一篇关于Android动画学习的文章《如何学习 Android Animation？》，深感Android动画种类繁复，类型多遍，虽然自己实现过很多动画效果，但是对Android动画的整体领悟还有所欠缺，所以决定最近好好研究一下Android动画的相关内容。
 我首先决定好好看一下Android属性动画的相关源码，因为平时属性动画用的最多而且涉及的知识点也很多。于是写下这个系列的总结笔记吧，预计一共两篇文章。
 为了节约你的时间，本文主要内容如下:

• ValueAnimator,PropertyValuesHolder和Keyframe之间的关系
• 使用ValueAnimator实现动画的背后原理，本篇不包括Choreographer原理的分析。
• Keyframe的动画数据计算原理。
• ObjectAnimator的属性赋值问题。

 先上一张Android Animation相关的UML图吧。

使用ValueAnimator实现动画

 我们先来看ValueAnimator实现一个Android动画的小例子吧。

ValueAnimator animation = ValueAnimator.ofFloat(0f, 1f);
animation.setDuration(1000);
animation.start();

 当然，上述并不是全部的代码，你需要使用AnimatorUpdateListener来监控ValueAnimator来自己实视图属性设置来完成动画。
 下面，我们就以上述实例为基础，来讲述一下Android属性动画原理。

ValueAnimator的初始化

 相信大家在使用ValueAnimator或者ObjectAnimator的使用，一般都是直接使用其工厂方法来获得对象实例，而不是直接new出来。我们现在就从ofFloat这个工厂方法入手，来分析一下ValueAnimator的初始化过程。

public static ValueAnimator ofFloat(float... values) {
    ValueAnimator anim = new ValueAnimator();
    anim.setFloatValues(values);
    return anim;
}

 首先这个函数的参数是一个可变长参数，也就是说你既可以想第一节的例子一样传入两个值，也可以传入三个，四个值，也就是说传入的数值个数是不限的。传入数值个数不同，对其内部初始化过程有很大的影响，具体影响之后会讲到。

 ValueAnimator的构造函数是一个空函数，没有任何内容，所以我们直接调到setFloatValues函数。大家要注意的是，这个函数有对应的一系列函数，比如setIntValues，但是setIntValues会在ofInt这个工厂方法中被调用。

public void setFloatValues(float... values) {
    if (values == null || values.length == 0) {
        return;
    }
    // mValues如果没有初始化或者无值的话
    if (mValues == null || mValues.length == 0) {
        setValues(PropertyValuesHolder.ofFloat("", values));
    } else {
        //否则直接取出第一个位置的对象，进行复制。
        PropertyValuesHolder valuesHolder = mValues[0];
        valuesHolder.setFloatValues(values);
    }
    // New property/values/target should cause re-initialization prior to starting
    mInitialized = false;
}

 上述代码主要是进行mValues的初始化或者赋值，并涉及到PropertyValuesHolder的初始化过程了，相应得，PropertyValuesHolder的setFloatValues和ofFloat函数也是一系列函数中的一个，用于Float数据的初始化。
 PropertyValuesHolder这个类包含了属性(Property)和在动画期间属性的相关数值，它是属性动画中很重要的一个类，基本上属性的反射赋值，属性数值随时间变化的原理都在其中。它的ofFloat方法中就是实例化了一个FloatPropertyValuesHolder对象，它是PropertyValuesHolder的子类。所以我们直接看对应的构造函数及其相关函数。

private PropertyValuesHolder(String propertyName) {
    mPropertyName = propertyName;
}
public FloatPropertyValuesHolder(String propertyName, float... values) {
    super(propertyName);
    setFloatValues(values);
}

 从代码中可以看出，构造函数只是将传入的属性名赋值给mPropertyName,并且调用setFloatValues函数，仔细的读者可能会发现发现在ValueAnimator的setFloatValues函数中也调用了PropertyValueHoler的这个函数。

public void setFloatValues(float... values) {
   //做了两个事情,一是设置了类型,另外一个是生成了Keyframe,关键的类就是Keyframe啦
    mValueType = float.class;
    mKeyframes = KeyframeSet.ofFloat(values);
}

 在setFloatValues中，函数记录了数值的类型float.class，这个在属性赋值时需要用到，并且使用KeyframeSet的ofFloat方法实例化了一个Keyframe。我们之前说PropertyValueHoler负责动画期间数值的变化，其实真正负责的对象是Keyframe。

public static KeyframeSet ofFloat(float... values) {
    int numKeyframes = values.length;
    FloatKeyframe keyframes[] = new FloatKeyframe[Math.max(numKeyframes,2)];
    if (numKeyframes == 1) {
        keyframes[0] = (FloatKeyframe) Keyframe.ofFloat(0f);
        keyframes[1] = (FloatKeyframe) Keyframe.ofFloat(1f, values[0]);
        ....
    } else {
        keyframes[0] = (FloatKeyframe) Keyframe.ofFloat(0f, values[0]);
        for (int i = 1; i < numKeyframes; ++i) {
            // ofFloat的第一个参数会从小逐渐变大，最后为1f
            keyframes[i] = (FloatKeyframe) Keyframe.ofFloat(
                                      (float) i / (numKeyframes - 1), values[i]);
            ....
        }
    }
    .....
    return new FloatKeyframeSet(keyframes);
}

 说实话，刚看到这里，我并不是很明白Keyframe初始化的传参问题，为什么第一个参数fraction是从小到大最终为1呢？我们可以往看一下。FloatKeyframe的工厂方法和构造函数都很简单，只是将传入的参数赋值给成员变量。FloatKeyframeSet的构造函数也只是调用了KeyframeSet的构造函数。

public KeyframeSet(Keyframe... keyframes) {
    mNumKeyframes = keyframes.length;
    mKeyframes = Arrays.asList(keyframes);
    mFirstKeyframe = keyframes[0];
    mLastKeyframe = keyframes[mNumKeyframes - 1];
    mInterpolator = mLastKeyframe.getInterpolator();//以最后一个为准
}

 看到这里大家可能感到疑惑，我们好像没有看到Keyframe中的Interpolator初始化啊，这是怎么回事呢？我检查了代码，它在Keyframe中确实没有初始化，而且必须通过setInterpolator，而且KeyframeSet中也没有进行相应的初始化。
 至此，ValueAnimator的整个初始化就结束了，它将ValueAnimator,PropertyValueHoler还有Keyframe连接起来，三者的职责划分十分清楚明了。

动画start之后

 接着，我们就来看start函数调用之后的源码吧。我们直接来看start(boolean)这个函数。

private void start(boolean playBackwards) {
    if (Looper.myLooper() == null) {
        throw new AndroidRuntimeException("Animators may only be run on Looper threads");
    }
    .....
    //这边是重点，涉及到ThreadLocal的使用
    AnimationHandler animationHandler = getOrCreateAnimationHandler();
    animationHandler.mPendingAnimations.add(this);
    ....
    animationHandler.start();
}

 省略的内容中是一些成员变量的赋值，比如mPlayingBackwards，mSeekFraction，和mPlayingState。大家从字面上就能理解它们的作用，这里就不细说。
 getOrCreateAnimationHandler中涉及到ThreadLocal的使用，相比了解Handler,Looper相关原理的同学都比较了解，这里也不具体讲解，感兴趣的同学可以去学习一下，可以简单的理解为每个线程都可以保存一个单例的一种实现方法。
 我们着重的了解一下AnimationHandler,它是Runnable的子类。它的start函数中直接调用了scheduleAnimation函数。

private void scheduleAnimation() {
    if (!mAnimationScheduled) {
        mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, this, null);
        mAnimationScheduled = true;
    }
}

 这里涉及了另外一个比较重要的类Choreographer，我们将在写一篇文章中详细说明这个类的代码，现在大家只要知道使用postCallback注册了这个类之后，它会协调不同动画或者其他活动的时间，并每隔一定时间之后调用该Runnable的run方法,并且getFrameTime可以获得调用时的时间，需要注意的是这个时间不一定是System.nanoTime。
 在run()函数里调用了doAnimationFrame并将Choreographer的getFrameTime获得的时间值传递进去。

final boolean doAnimationFrame(long frameTime) {
    if (mPlayingState == STOPPED) {
        mPlayingState = RUNNING;
        ...
    }
    if (mPaused) {
        ....
        return false;
    } else if (mResumed) {
      ....
    }
    final long currentTime = Math.max(frameTime, mStartTime);
    return animationFrame(currentTime);
}

 在doAnimationFrame中，程序会根据mPlayingState做一些相应的操作，并改变状态值，最后调用animationFrame。

boolean animationFrame(long currentTime) {
    boolean done = false;
    switch (mPlayingState) {
    case RUNNING:
    case SEEKED:
        float fraction = mDuration > 0 ? (float)(currentTime - mStartTime) / mDuration : 1f;
        ....
        animateValue(fraction);
        break;
    }
    return done;
}

 我们可以看到，这里通过开始时间，当前事件和每帧动画间隔事件求出了一个fraction,然后代码中的省略部分主要是处理动画重复播放和倒着播发时的fraction处理，最后调用animateValue函数。

    void animateValue(float fraction) {
        fraction = mInterpolator.getInterpolation(fraction);
        mCurrentFraction = fraction;
        int numValues = mValues.length;
        for (int i = 0; i < numValues; ++i) {
            mValues[i].calculateValue(fraction);//ViewPropertyViewHolder
        }
        if (mUpdateListeners != null) {
            int numListeners = mUpdateListeners.size();
            for (int i = 0; i < numListeners; ++i) {
                //这边就结束啦，直接传递给AnimationUpdateListener
                mUpdateListeners.get(i).onAnimationUpdate(this);
            }
        }
    }

 这个函数是理解动画流程的关键之一，你首先可以看到Interpolator的使用，这个参数传入的fraction是通过动画开始时间和当前时间计算出来的，而通过不同Interpolator进行转换，无论是BounceInterpolator还是LinerInterpolator。接着，ValueAnimator调用了mValues保存的所有ViewPropertyViewHolder的calculateValue方法，让其去计算动画需要的数据。最后通过AnimatorUpdateListenters通知用户，然后我们会在回调函数中进行响应的操作。ObjectAnimator会override这个函数，然后加上属性反射赋值的相关逻辑。我们先来看如何计算动画所需的数值吧。

动画所需数值计算

@Override
void calculateValue(float fraction) {
    mFloatAnimatedValue = mFloatKeyframes.getFloatValue(fraction);
}

 从代码上来看，FloatViewPropertyViewHolder将计算动画所需的数值的任务又交给了Keyframe,这也符合二者的职责分配。我们按照之前的分析，来看一下FloatKeyframeSet的响应操作。getValue中直接调用了getFloatValue函数，而后者是了解动画相关数值计算的关键函数。

@Override
public float getFloatValue(float fraction) {
  //分为两种情况,一个是2 Keyframe时一般就是你给出两个值进行初始化,另外一个是多个keyframe时
    if (mNumKeyframes == 2) {
        if (firstTime) {
            firstTime = false;
            firstValue = ((FloatKeyframe) mKeyframes.get(0)).getFloatValue();
            lastValue = ((FloatKeyframe) mKeyframes.get(1)).getFloatValue();
            deltaValue = lastValue - firstValue;
        }
        //如果KeyframeSet也有Interpolator
        if (mInterpolator != null) {
            fraction = mInterpolator.getInterpolation(fraction);
        }
        //如果有Evaluator，那么使用它计算，如果没有就使用默认计算方法。
        if (mEvaluator == null) {
            return firstValue + fraction * deltaValue;
        } else {
            return ((Number)mEvaluator.evaluate(fraction, firstValue, lastValue)).floatValue();
        }
    }
    //处理多个Keyframe的情况
    ..... //省略代码处是处理fraction<=0和fraction>=1的特殊情况
    FloatKeyframe prevKeyframe = (FloatKeyframe) mKeyframes.get(0);
    for (int i = 1; i < mNumKeyframes; ++i) {
        FloatKeyframe nextKeyframe = (FloatKeyframe) mKeyframes.get(i);
        //找到第一个可以处理这个fraction的keyframe。
        if (fraction < nextKeyframe.getFraction()) {
            final TimeInterpolator interpolator = nextKeyframe.getInterpolator();
            if (interpolator != null) {
                fraction = interpolator.getInterpolation(fraction);
            }
            //在构造Keyframe时，我们知道第i个Keyframe的fraction就是i/(总个数)
            //所以下边这个计算公式就是将整个动画区间的fraction转变成prevKeyframe到nextKeyframe
            //这个小区间中的fraction
            float intervalFraction = (fraction - prevKeyframe.getFraction()) /
                (nextKeyframe.getFraction() - prevKeyframe.getFraction());
            //用于计算动画数值的值区间是前一个Keyframe的value和当前的value
            float prevValue = prevKeyframe.getFloatValue();
            float nextValue = nextKeyframe.getFloatValue();
            //默认计算方式或者使用Evaluator进行计算
            return mEvaluator == null ?
                    prevValue + intervalFraction * (nextValue - prevValue) :
                    ((Number)mEvaluator.evaluate(intervalFraction, prevValue, nextValue)).
                        floatValue();
        }
        prevKeyframe = nextKeyframe;
    }
    return ((Number)mKeyframes.get(mNumKeyframes - 1).getValue()).floatValue();
}

 代码中有很详细的注释，大家自己阅读吧，理解这段代码，感觉对Android动画框架的理解十分的重要，你会对其中动画数值的计算有更加深刻的理解。

ObjectAnimator的属性赋值

 如果你使用ObjectAnimator来实现动画的话，我们可以验证上述关于ValueAnimator的梳理路线继续走下去，动画所需的数值已经计算完全，之后就是对属性继续赋值了。我们来看ObjectAnimator的animateValue函数。

@Override
void animateValue(float fraction) {
    final Object target = getTarget();
    //target是一个WeakReference，使用前需要检查。
    if (mTarget != null && target == null) {
        cancel();
        return;
    }
    super.animateValue(fraction);
    int numValues = mValues.length;
    for (int i = 0; i < numValues; ++i) {
        //这是使用反射将值赋给对象的啦.
        mValues[i].setAnimatedValue(target);
    }
}

 这个函数首先调用了父函数，进行计算数值，然后遍历mValues来设置对象的属性值。我们直接看FloatPropertyValuesHolder的setAnimatedValue函数。当然不同的PropertyValuesHolder子类的这个函数的实现都是差不多，只是涉及的数据类型不同。

void setAnimatedValue(Object target) {
    if (mFloatProperty != null) {
        mFloatProperty.setValue(target, mFloatAnimatedValue);
        return;
    }
    if (mProperty != null) {
        mProperty.set(target, mFloatAnimatedValue);
        return;
    }
    if (mJniSetter != 0) {
        nCallFloatMethod(target, mJniSetter, mFloatAnimatedValue);
        return;
    }
    if (mSetter != null) {
        try {
            mTmpValueArray[0] = mFloatAnimatedValue;
            mSetter.invoke(target, mTmpValueArray);
        } catch (InvocationTargetException e) {
            Log.e("PropertyValuesHolder", e.toString());
        } catch (IllegalAccessException e) {
            Log.e("PropertyValuesHolder", e.toString());
        }
    }
}

 通过上述代码，ObjectAnimator就将每一次计算而来的数值赋值给View的对象的相应属性上，形成了动画。

后记

 本文介绍了Android属性动画的基本框架流程，为的是让大家更好的理解Andorid动画。但是Android动画这一类的知识还是需要多多实践和练习才能发挥其正真的价值，所以，希望自己之后写出几个比较好的动画效果在来和大家进行分享吧。