探究Android属性动画执行过程

原创独步闲庭 QiShare

1.引言

属性动画作为Android动画功能的一个重要组成部分，可以实现很多有趣的动画效果，理解属性动画的执行过程有助于我们更好地使用属性动画去实现需求。本文将从源码的角度去探索属性动画的实现过程，加深大家对其的认知和理解。

2.属性动画相关的类

2.1 ValueAnimator

这个类是实现属性动画的一个重要的类，通过ValueAnimator.ofFloat()、ValueAnimator.ofInt()、ValueAnimator.ofObject()、ValueAnimator.ofArgb()、ValueAnimator.ofPropertyValuesHolder()等方法可以获得ValueAnimator的对象，然后可以通过对这个对象的操作去实现动画。使用ValueAnimator实现属性动画，需要实现ValueAnimator.AnimatorUpdateListener()接口，并在onAnimationUpdate()方法内为要添加动画的对象设置属性值。

2.2 ObjectAnimator

ObjectAnimator是ValueAnimator的子类，可以操作目标对象的动画属性，这个类的构造函数支持采用参数的形式传入要使用动画的目标对象和属性名。

3.属性动画的实现过程

ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(iv, "alpha", 1.0f, 0f);
objectAnimator.setDuration(3000);
objectAnimator.start();

这是一段简单的代码，它使用属性动画实现了一张图片的透明度渐变的效果，我们从这一段代码入手，去分析属性动画的实现过程。

3.1 创建属性动画

/**
* target：添加动画效果的目标对象
* propertyName：动画效果的属性名
* values：动画将会在这个时间之间执行的数值集合
*/
public static ObjectAnimator ofFloat(Object target, String propertyName, float... values){
    ObjectAnimator anim = new ObjectAnimator(target, propertyName);
    anim.setFloatValues(values);
    return anim;
}

这个方法返回了一个属性动画对象，第一个参数是产生动画效果的目标对象，第二个参数是属性名，目标对象的属性名应该有与之对应的set()方法，例如我们传入属性名"alpha"，那么这个目标对象也应该有setAlpha()方法。参数values传一个值的时候，这个值是动画的结束值，传两个数值的时候，第一个值是开始值，第二个值是结束值，多于两个值的时候，第一个值是开始值，最后一个值是结束值。

private ObjectAnimator(Object target, String propertyName) {
    setTarget(target);
    setPropertyName(propertyName);
}

这个是属性动画的构造函数，里面执行了两个方法setTarget(target)和setPropertyName(propertyName)。

@Override
public void setTarget(@Nullable Object target) {
    final Object oldTarget = getTarget();
    if (oldTarget != target) {
        if (isStarted()) {
            cancel();
        }
        mTarget = target == null ? null : new WeakReference<Object>(target);
        // New target should cause re-initialization prior to starting
        mInitialized = false;
    }
}

public void setPropertyName(@NonNull String propertyName) {
    // mValues could be null if this is being constructed piecemeal. Just record the
    // propertyName to be used later when setValues() is called if so.
    if (mValues != null) {
        PropertyValuesHolder valuesHolder = mValues[0];
        String oldName = valuesHolder.getPropertyName();
        valuesHolder.setPropertyName(propertyName);
        mValuesMap.remove(oldName);
        mValuesMap.put(propertyName, valuesHolder);
     }
     mPropertyName = propertyName;
     // New property/values/target should cause re-initialization prior to starting
     mInitialized = false;
}

mValues是一个PropertyValuesHolder数组，PropertyValuesHolder持有动画的属性名和属性值信息，mValuesMap是一个hashmap数组，用来管理PropertyValuesHolder对象，在调用getAnimatedValue(String)方法的时候，这个map通过属性名去查找动画执行的数值。当mValues不为空的时候，将属性名信息放入mValuesMap。

//ObjectAnimator
@Override
public void setFloatValues(float... values) {
    if (mValues == null || mValues.length == 0) {
        // No values yet - this animator is being constructed piecemeal. Init the values with
        // whatever the current propertyName is
        if (mProperty != null) {
            setValues(PropertyValuesHolder.ofFloat(mProperty, values));
        } else {
            setValues(PropertyValuesHolder.ofFloat(mPropertyName, values));
        }
    } else {
        super.setFloatValues(values);
    }
}

mValues为null或者数组元素个数为0的时候，调用其父类ValueAnimator的setValues()方法，在setValues()内执行了初始化mValues和mValuesMap的操作，并将PropertyValuesHolder放入mValuesMap。当mValues不为null且元素个数不为0的时候，调用其父类ValueAnimator的setFloatValues()方法，在setFloatValues()方法内满足条件又会调用到PropertyValuesHolder的setFloatValues()方法。

//PropertyValuesHolder
public void setFloatValues(float... values) {
    mValueType = float.class;
    mKeyframes = KeyframeSet.ofFloat(values);
}

这里的mValueType指的是提供的值的类型，mKeyframes是定义这个动画的关键帧集合。

//KeyframeSet
public static KeyframeSet ofFloat(float... values) {
    boolean badValue = false;
    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]);
        if (Float.isNaN(values[0])) {
            badValue = true;
        }
    } else {
        keyframes[0] = (FloatKeyframe) Keyframe.ofFloat(0f, values[0]);
        for (int i = 1; i < numKeyframes; ++i) {
            keyframes[i] =
                    (FloatKeyframe) Keyframe.ofFloat((float) i / (numKeyframes - 1), values[i]);
            if (Float.isNaN(values[i])) {
                badValue = true;
            }
        }
    }
    if (badValue) {
        Log.w("Animator", "Bad value (NaN) in float animator");
    }
    return new FloatKeyframeSet(keyframes);
}

在这个方法内新建了一个FloatKeyframe数组，数组的元素至少为2个，FloatKeyframe是Keyframe的内部子类，持有这个动画的时间值对，Keyframe类被ValueAnimator用来定义整个动画过程中动画目标的数值，当时间从一帧到另一帧，目标对象的值也会从上一帧的值运动到下一帧的值。

/**
* fraction:取值范围0到1之间，表示全部动画时长中已经执行的时间部分
* value：关键帧中与时间相对应的数值
*/
public static Keyframe ofFloat(float fraction, float value) {
    return new FloatKeyframe(fraction, value);
}

此方法使用给定的时间和数值创建一个关键帧对象，到这里，属性动画的创建过程基本完成。

3.2 属性动画执行过程

//ObjectAnimator
@Override
public void start() {
    AnimationHandler.getInstance().autoCancelBasedOn(this);
    if (DBG) {
        Log.d(LOG_TAG, "Anim target, duration: " + getTarget() + ", " + getDuration());
        for (int i = 0; i < mValues.length; ++i) {
            PropertyValuesHolder pvh = mValues[i];
            Log.d(LOG_TAG, "   Values[" + i + "]: " +
                    pvh.getPropertyName() + ", " + pvh.mKeyframes.getValue(0) + ", " +
                    pvh.mKeyframes.getValue(1));
        }
    }
    super.start();
}

在代码中调用objectAnimator.start()的时候动画开始执行，内部调用了其父类ValueAnimator的start()方法。

//ValueAnimator
private void start(boolean playBackwards) {
    if (Looper.myLooper() == null) {
        throw new AndroidRuntimeException("Animators may only be run on Looper threads");
    }
    mReversing = playBackwards;
    mSelfPulse = !mSuppressSelfPulseRequested;
    // Special case: reversing from seek-to-0 should act as if not seeked at all.
    if (playBackwards && mSeekFraction != -1 && mSeekFraction != 0) {
        if (mRepeatCount == INFINITE) {
            // Calculate the fraction of the current iteration.
            float fraction = (float) (mSeekFraction - Math.floor(mSeekFraction));
            mSeekFraction = 1 - fraction;
        } else {
            mSeekFraction = 1 + mRepeatCount - mSeekFraction;
        }
    }
    mStarted = true;
    mPaused = false;
    mRunning = false;
    mAnimationEndRequested = false;
    // Resets mLastFrameTime when start() is called, so that if the animation was running,
    // calling start() would put the animation in the
    // started-but-not-yet-reached-the-first-frame phase.
    mLastFrameTime = -1;
    mFirstFrameTime = -1;
    mStartTime = -1;
    addAnimationCallback(0);

    if (mStartDelay == 0 || mSeekFraction >= 0 || mReversing) {
        // 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.
        startAnimation();
        if (mSeekFraction == -1) {
            // No seek, start at play time 0. Note that the reason we are not using fraction 0
            // is because for animations with 0 duration, we want to be consistent with pre-N
            // behavior: skip to the final value immediately.
            setCurrentPlayTime(0);
        } else {
            setCurrentFraction(mSeekFraction);
        }
    }
}

在这个方法内进行了一些赋值操作，addAnimationCallback(0)和startAnimation()是比较重要的操作。

//ValueAnimator
private void addAnimationCallback(long delay) {
    if (!mSelfPulse) {
        return;
    }
    getAnimationHandler().addAnimationFrameCallback(this, delay);
}

这个方法内执行了AnimationHandler的addAnimationFrameCallback()方法注册回调，我们继续看看addAnimationFrameCallback()方法。

//AnimationHandler
public void addAnimationFrameCallback(final AnimationFrameCallback callback, long delay) {
    if (mAnimationCallbacks.size() == 0) {
        getProvider().postFrameCallback(mFrameCallback);
    }
    if (!mAnimationCallbacks.contains(callback)) {
        mAnimationCallbacks.add(callback);
    }

    if (delay > 0) {
        mDelayedCallbackStartTime.put(callback, (SystemClock.uptimeMillis() + delay));
    }
 }

这个方法添加了一个AnimationFrameCallback回调，AnimationFrameCallback是AnimationHandler的一个内部接口，其中有两个重要的方法doAnimationFrame()和commitAnimationFrame()。

//AnimationHandler
interface AnimationFrameCallback {
  boolean doAnimationFrame(long frameTime);
  
    void commitAnimationFrame(long frameTime);
}

AnimationFrameCallback是可以收到动画执行时间和帧提交时间通知的回调，内有两个方法，doAnimationFrame()和commitAnimationFrame()。

//AnimationHandler
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() {
        return mChoreographer.getFrameTime();
    }

    @Override
    public long getFrameDelay() {
        return Choreographer.getFrameDelay();
    }

    @Override
    public void setFrameDelay(long delay) {
        Choreographer.setFrameDelay(delay);
    }
}

前面的getProvider()方法获得了MyFrameCallbackProvider的一个实例，MyFrameCallbackProvider是AnimationHandler的一个内部类，实现了AnimationFrameCallbackProvider接口，使用Choreographer作为计时脉冲的提供者，去发送帧回调。Choreographer从显示器子系统获得时间脉冲，postFrameCallback()方法发送帧回调。

//AnimationHandler
public interface AnimationFrameCallbackProvider {
    void postFrameCallback(Choreographer.FrameCallback callback);
    void postCommitCallback(Runnable runnable);
    long getFrameTime();
    long getFrameDelay();
    void setFrameDelay(long delay);
}

//AnimationHandler
private final Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
    @Override
    public void doFrame(long frameTimeNanos) {
        doAnimationFrame(getProvider().getFrameTime());
        if (mAnimationCallbacks.size() > 0) {
            getProvider().postFrameCallback(this);
        }
    }
};

在这个回调内执行了doAnimationFrame()方法，如果mAnimationCallbacks的个数大于0，AnimationFrameCallbackProvider就继续发送帧回调，继续重复执行doAnimationFrame()。

//AnimationHandler   
private void doAnimationFrame(long frameTime) {
    long currentTime = SystemClock.uptimeMillis();
    final int size = mAnimationCallbacks.size();
    for (int i = 0; i < size; i++) {
        final AnimationFrameCallback callback = mAnimationCallbacks.get(i);
        if (callback == null) {
            continue;
        }
        if (isCallbackDue(callback, currentTime)) {
            callback.doAnimationFrame(frameTime);
            if (mCommitCallbacks.contains(callback)) {
                getProvider().postCommitCallback(new Runnable() {
                    @Override
                    public void run() {
                        commitAnimationFrame(callback, getProvider().getFrameTime());
                    }
                });
            }
        }
    }
    cleanUpList();
}

在这个方法内开启了一个循环，里面执行了callback.doAnimationFrame()，这个操作会触发ValueAnimator类中的doAnimationFrame()。

//ValueAnimator
private void startAnimation() {
    if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
        Trace.asyncTraceBegin(Trace.TRACE_TAG_VIEW, getNameForTrace(),
                System.identityHashCode(this));
    }

    mAnimationEndRequested = false;
    initAnimation();
    mRunning = true;
    if (mSeekFraction >= 0) {
        mOverallFraction = mSeekFraction;
    } else {
        mOverallFraction = 0f;
    }
    if (mListeners != null) {
        notifyStartListeners();
    }
}

startAnimation()方法内调用了initAnimation()初始化动画。

//ValueAnimator
public final boolean doAnimationFrame(long frameTime) {
    //省略部分代码    
    ...
    final long currentTime = Math.max(frameTime, mStartTime);
    boolean finished = animateBasedOnTime(currentTime);

    if (finished) {
        endAnimation();
    }
    return finished;
}

这个方法在执行动画的过程中会被多次调用，其中重要的操作是animateBasedOnTime(currentTime)。

//ValueAnimator
boolean animateBasedOnTime(long currentTime) {
    boolean done = false;
    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;
        final boolean lastIterationFinished = (fraction >= mRepeatCount + 1) &&
                (mRepeatCount != INFINITE);
        if (scaledDuration == 0) {
            // 0 duration animator, ignore the repeat count and skip to the end
            done = true;
        } else if (newIteration && !lastIterationFinished) {
            // Time to repeat
            if (mListeners != null) {
                int numListeners = mListeners.size();
                for (int i = 0; i < numListeners; ++i) {
                    mListeners.get(i).onAnimationRepeat(this);
                }
            }
        } else if (lastIterationFinished) {
            done = true;
        }
        mOverallFraction = clampFraction(fraction);
        float currentIterationFraction = getCurrentIterationFraction(
                mOverallFraction, mReversing);
        animateValue(currentIterationFraction);
    }
    return done;
}

animateBasedOnTime()方法计算了已经执行的动画时长和动画分数，并调用animateValue()方法计算动画值。

//ValueAnimator
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);
    }
    if (mUpdateListeners != null) {
        int numListeners = mUpdateListeners.size();
        for (int i = 0; i < numListeners; ++i) {
            mUpdateListeners.get(i).onAnimationUpdate(this);
        }
    }
}

ValueAnimator的animateValue()方法内部首先根据动画分数得到插值分数，再根据插值分数计算动画值，并调用了AnimatorUpdateListener的onAnimationUpdate()方法通知更新。

//ObjectAnimator
@Override
void animateValue(float fraction) {
    final Object target = getTarget();
    if (mTarget != null && target == null) {
        // We lost the target reference, cancel and clean up. Note: we allow null target if the
        /// target has never been set.
        cancel();
        return;
    }

    super.animateValue(fraction);
    int numValues = mValues.length;
    for (int i = 0; i < numValues; ++i) {
        mValues[i].setAnimatedValue(target);
    }
}

ObjectAnimator的animateValue()方法不仅调用了父类的animateValue()方法，还在循环内调用了PropertyValuesHolder的setAnimatedValue()方法，传入的参数是产生动画效果的目标对象。

//PropertyValuesHolder
@Override
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());
        }
    }
}

在PropertyValuesHolder的setAnimatedValue()方法内部，先通过JNI去修改目标对象的属性值，如果通过JNI找不到对应的方法，则通过使用反射机制修改目标对象的属性值。

4.总结

属性动画的功能相当强大，可以为视图对象和非视图对象添加动画效果，属性动画是通过改变要添加动画的目标对象的属性值实现的，ValueAnimator基于动画时长和已经执行的时长计算得出动画分数，然后根据设置的时间插值器TimeInterpolator计算得出动画的插值分数，再调用对应的估值器TypeEvaluator根据插值分数、起始值和结束值计算得出对象的属性值，ObjectAnimator类在计算出动画的新值后自动地更新对象的属性值，ValueAnimator类则需要手动地去设置对象的属性值。

继续滑动看下一个