ValueAnimator的源码及插值器估值器相关解读

前言

本篇文章从动画的开始到结束，一个流程认识一下动画的源码。
解读一下源码中的类的关系。并说名义下插值器估值器的关系。

问题

问题1：动画涉及同时多个动画已经动画数据存储结构。
问题2：从开始到结束代码的流程是怎么走的。
问题3：插值器跟估值器是什么关系。

基础使用

mColorAnim = ValueAnimator.ofObject(new ArgbEvaluator(), 0, 0x80000000);//开始解读1
mColorAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
   @Override
    public void onAnimationUpdate(ValueAnimator animation) {
       final int c = (Integer) animation.getAnimatedValue();
          mColor.setColor(c);
    }
});
mColorAnim.setDuration(2000);
mColorAnim.start(); //开始解读2

源码解读

ValueAnimator.ofObject

public static ValueAnimator ofObject(TypeEvaluator evaluator, Object... values) {
        ValueAnimator anim = new ValueAnimator();
        anim.setObjectValues(values); //关键1
        anim.setEvaluator(evaluator); //关键2
        return anim;
    }

这个方法创建了一个ValueAnimator对象并设置了我们传入的三个参数值.

先看一下setObjectValues

PropertyValuesHolder[] mValues;
...
public void setObjectValues(Object... values) {
            // mValues还没有初始化
  if (mValues == null || mValues.length == 0) {
    setValues(PropertyValuesHolder.ofObject("", null, values)); //关键点1
    }
        ....
        // New property/values/target should cause re-initialization prior to starting
        mInitialized = false;
    }

这里先来看一下PropertyValuesHolder.ofObject("", null, values)返回了什么东西先

PropertyValuesHolder类
PropertyValuesHolder{ 
// 对应三个参数 "", null, values
public static PropertyValuesHolder ofObject(String propertyName, TypeEvaluator evaluator,Object... values) {
        PropertyValuesHolder pvh = new PropertyValuesHolder(propertyName);
        pvh.setObjectValues(values);//关键点1
        pvh.setEvaluator(evaluator);
        return pvh;
    }
public void setObjectValues(Object... values) {
        mValueType = values[0].getClass();//获取到传入值得类型。
        mKeyframes = KeyframeSet.ofObject(values);//关键点2
        if (mEvaluator != null) { //传入的是空 所以没有设置
            mKeyframes.setEvaluator(mEvaluator);
        }
    }
}
--------------------------------------------------------------------------------------------------------
KeyframeSet类
KeyframeSet{
public static KeyframeSet ofObject(Object... values) {
        int numKeyframes = values.length;
        ObjectKeyframe keyframes[] = new ObjectKeyframe[Math.max(numKeyframes,2)];
        if (numKeyframes == 1) {
            keyframes[0] = (ObjectKeyframe) Keyframe.ofObject(0f);
            keyframes[1] = (ObjectKeyframe) Keyframe.ofObject(1f, values[0]);
        } else {  //我们最开始传入的值是（0，0x8000000）这里numKeyframes=2 因此我们这里的keyframes[2]
            keyframes[0] = (ObjectKeyframe) Keyframe.ofObject(0f, values[0]);//关键3
            for (int i = 1; i < numKeyframes; ++i) {
                keyframes[i] = (ObjectKeyframe) Keyframe.ofObject((float) i / (numKeyframes - 1), values[i]);
            }
        }
        return new KeyframeSet(keyframes);
    }
}
--------------------------------------------------------------------------------------------------------
ObjectKeyframe类
ObjectKeyframe extends Keyframe {
Object mValue;
public static Keyframe ofObject(float fraction, Object value) {
        return new ObjectKeyframe(fraction, value);//关键4
    }
}
//关键5
ObjectKeyframe(float fraction, Object value)  Keyframe{
  mFraction = fraction;
  mValue = value;
  mHasValue = (value != null);
  mValueType = mHasValue ? value.getClass() : Object.class;
}

由上面可以看到 PropertyValuesHolder.ofObject("", null, values)返回了一个PropertyValuesHolder对象，PropertyValuesHolder包含了我们Keyframes。

Keyframes是一个数组，根据你传入的ValueAnimator.ofObject(new ArgbEvaluator(), 0, 0x80000000);传入的0, 0x80000000多少对应创建相对数量的Keyframe,（如果是传入一个则会产生2个Keyframe）

Keyframe的作用就是存储 mFraction分数信息，mValue 数值信息 mValueType 类型信息

image.png

返回上面最开始的anim.setEvaluator(evaluator); //关键2

    public void setEvaluator(TypeEvaluator value) {
        if (value != null && mValues != null && mValues.length > 0) {
            mValues[0].setEvaluator(value);
        }
    }
------------------------------------------------------------------------------------------------------------------
PropertyValuesHolder类
PropertyValuesHolder {
 public void setEvaluator(TypeEvaluator evaluator) {
        mEvaluator = evaluator;
        mKeyframes.setEvaluator(evaluator);
    }
}

在PropertyValuesHolder跟KeyframeSet存入该Evaluator

阶段性大致小结从下图可以大致看出各个类的功能

回答问题1：多种动画怎么处理以及每帧数据存储的结构.png

mColorAnim.start(); //开始解读2

public void start() {
  start(false);
}
----------------------------------------------------------------------
private void start(boolean playBackwards) {
mReversing = playBackwards;
mStarted = true;
mPaused = false;
mRunning = false;
....标记位记录等工作
addAnimationCallback(0);//关键1 
if (mStartDelay == 0...){
 startAnimation();//关键2
if (mSeekFraction == -1) {
setCurrentPlayTime(0);}}}

关键1：等看完关键2再回过头看
关键2：先看一下回调的 startAnimation();

private void startAnimation() {
        .....
        mAnimationEndRequested = false;
        initAnimation(); //关键1
        mRunning = true;
        if (mSeekFraction >= 0) {
            mOverallFraction = mSeekFraction;
        } else {
            mOverallFraction = 0f;
        }
        if (mListeners != null) {
            notifyStartListeners();
        }
    }

 void initAnimation() {
        if (!mInitialized) {
            int numValues = mValues.length;
            for (int i = 0; i < numValues; ++i) {
                mValues[i].init();//关键2   mValues 是 PropertyValuesHolder类型的
            }
            mInitialized = true;
        }
    }
---------------------------------------------------
PropertyValuesHolder类
PropertyValuesHolder{
private static final TypeEvaluator sIntEvaluator = new IntEvaluator();
private static final TypeEvaluator sFloatEvaluator = new FloatEvaluator();
void init() {
        if (mEvaluator == null) {
            mEvaluator = (mValueType == Integer.class) ? sIntEvaluator :
                    (mValueType == Float.class) ? sFloatEvaluator :
                    null;
        }
        if (mEvaluator != null) {
            mKeyframes.setEvaluator(mEvaluator);
        }
    }
}

这里是做了一些开始状态的初始化，然后mEvaluator估值器根据你是否有传入，没有传入的话根据你之前传入的值得类型对应给你设置估值器。仅当Integer、Float类型的才会帮你自动设置估值器。

看回上面关键1：addAnimationCallback(0);

ValueAnimator类
ValueAnimator{
 private void addAnimationCallback(long delay) {
      ....
        getAnimationHandler().addAnimationFrameCallback(this, delay);
    }
}
--------------------------------------------------------------------------------------------------------
AnimationHandler类
public class AnimationHandler {
public void addAnimationFrameCallback(final AnimationFrameCallback callback, long delay) {
        if (mAnimationCallbacks.size() == 0) {
            getProvider().postFrameCallback(mFrameCallback);//关键1 getProvider返回 MyFrameCallbackProvider
        }
        if (!mAnimationCallbacks.contains(callback)) {
            mAnimationCallbacks.add(callback); 
        }
       ......    }}

    private AnimationFrameCallbackProvider getProvider() {
        if (mProvider == null) {
            mProvider = new MyFrameCallbackProvider();
        }
        return mProvider;
    }
------------------------------------------------------------------------------------------------------------------------
MyFrameCallbackProvider类
MyFrameCallbackProvider implements AnimationFrameCallbackProvider {
 final Choreographer mChoreographer = Choreographer.getInstance();
 @Override
  public void postFrameCallback(Choreographer.FrameCallback callback) {
            mChoreographer.postFrameCallback(callback);//关键2
        }
}
------------------------------------------------------------------------------------------------------------------------
Choreographer类
Choreographer{
 public void postFrameCallback(FrameCallback callback) {
        postFrameCallbackDelayed(callback, 0);//关键3
    }

 public void postFrameCallbackDelayed(FrameCallback callback, long delayMillis) {
          ...........
        postCallbackDelayedInternal(CALLBACK_ANIMATION,callback, FRAME_CALLBACK_TOKEN, delayMillis);//关键4
    }
 private void postCallbackDelayedInternal(int callbackType, Object action, Object token, long delayMillis) {
             ......
            synchronized (mLock) {
            final long now = SystemClock.uptimeMillis();
            final long dueTime = now + delayMillis; // 0 + now 
            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);//关键5
            if (dueTime <= now) {
                scheduleFrameLocked(now); //关键6
            } else {
            ......}}}

 private void scheduleFrameLocked(long now) {
        if (!mFrameScheduled) {
            mFrameScheduled = true;
            if (USE_VSYNC) { // USE_VSYNC = true
              ....
                if (isRunningOnLooperThreadLocked()) {
                    scheduleVsyncLocked();//关键7
                }  }
              ......}}  }
    @UnsupportedAppUsage
 private void scheduleVsyncLocked() {
    mDisplayEventReceiver.scheduleVsync();//关键8
    }
-------------------------------------------------------------------------------------------------------------
DisplayEventReceiver类
DisplayEventReceiver{
   @FastNative
    private static native void nativeScheduleVsync(long receiverPtr);//关键10
public void scheduleVsync() {
            ............
            nativeScheduleVsync(mReceiverPtr);//关键9
    }
}
}

跟到最后这里是一个Native方法。。。。。因为这块涉及到界面渲染的问题。当我们接受到一个新的Vsync信号的时候，它会回调FrameCallback接口的doFrame(long frameTimeNanos)函数。

我们从最开始的关键1getProvider().postFrameCallback(mFrameCallback)便传入了回调方法mFrameCallback
再到关键5 mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token); action 就是我们传入的mFrameCallback

代码如下

public void addCallbackLocked(long dueTime, Object action, Object token) {
            CallbackRecord callback = obtainCallbackLocked(dueTime, action, token);
            ....
        }
//创建 CallbackRecord 
private CallbackRecord obtainCallbackLocked(long dueTime, Object action, Object token) {
        CallbackRecord callback = mCallbackPool;
        if (callback == null) {
            callback = new CallbackRecord();
        } else {
            mCallbackPool = callback.next;
            callback.next = null;
        }
        callback.dueTime = dueTime;
        callback.action = action;
        callback.token = token;
        return callback;
    }
 private static final class CallbackRecord {
        public CallbackRecord next;
        public long dueTime;
        public Object action; // Runnable or FrameCallback
        public Object token;

        @UnsupportedAppUsage
        public void run(long frameTimeNanos) {
            if (token == FRAME_CALLBACK_TOKEN) {
                ((FrameCallback)action).doFrame(frameTimeNanos);//关键点1.1
            } else {
                ((Runnable)action).run();
            }
        }
    }

当最终回调的时候会跑((FrameCallback)action).doFrame(frameTimeNanos);//关键点1.1 token == FRAME_CALLBACK_TOKEN 。

此时会回调到最开始AnimationHandler类中的 getProvider().postFrameCallback(mFrameCallback)的回调方法mFrameCallback

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

private void doAnimationFrame(long frameTime) {
        long currentTime = SystemClock.uptimeMillis();
        final int size = mAnimationCallbacks.size(); //在第一个代码块中添加了一个callback进去，至少有一个。
        for (int i = 0; i < size; i++) {
            final AnimationFrameCallback callback = mAnimationCallbacks.get(i);
            ......
            if (isCallbackDue(callback, currentTime)) {
                callback.doAnimationFrame(frameTime); //关键2 //回看上面的可以知道frameTime这个类型是VaueAnimator
               ....................
            }
        }
      .....
    }
}
------------------------------------------------------------------------------------------------------------------------
public class ValueAnimator extends Animator implements AnimationHandler.AnimationFrameCallback {
public final boolean doAnimationFrame(long frameTime) {
      if (mStartTime < 0) {
            // 第一帧跑的逻辑.
            mStartTime = mReversing
                    ? frameTime
                    : frameTime + (long) (mStartDelay * resolveDurationScale());
        }

        // 处理 pause/resume的状态位
        if (mPaused) {
            mPauseTime = frameTime;
            removeAnimationCallback();//暂停的状态则取消该回调
            return false;
        } else if (mResumed) {
            mResumed = false;
          ......
        }
         .....
mLastFrameTime = frameTime;
final long currentTime = Math.max(frameTime, mStartTime);
boolean finished = animateBasedOnTime(currentTime);//关键点3

        if (finished) {
            endAnimation();
        }
        return finished;
    }
//计算对应的数值，这里处理动画重复等相关逻辑
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);
          ......
            mOverallFraction = clampFraction(fraction);
            float currentIterationFraction = getCurrentIterationFraction(
                    mOverallFraction, mReversing);
            animateValue(currentIterationFraction);//关键点4
        }
        return done;
    }

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

mUpdateListeners.get(i).onAnimationUpdate(this);走到这里，我们在API使用的时候就可以回调到最后的值了，以上就是我们找到的ValueAnimator的源码逻辑解读。

关于插值器跟估值器

void animateValue(float fraction) {
        fraction = mInterpolator.getInterpolation(fraction);//关键1 对应插值器计算出分数值
        mCurrentFraction = fraction;
        int numValues = mValues.length;
        for (int i = 0; i < numValues; ++i) {
            mValues[i].calculateValue(fraction);//关键2 传入插值器的分值，后面交给估值器计算出最后的值
        }
        if (mUpdateListeners != null) {
            int numListeners = mUpdateListeners.size();
            for (int i = 0; i < numListeners; ++i) {
                mUpdateListeners.get(i).onAnimationUpdate(this);
            }
        }
    }

由上面的逻辑可以看到 fraction = mInterpolator.getInterpolation(fraction);//对应插值器计算出分数值先计算出插值器0-1区间的分值，再将此值传入到mValues[i].calculateValue(fraction);进行计算
关键1：代码代码如下

private static final TimeInterpolator sDefaultInterpolator =new AccelerateDecelerateInterpolator();
mInterpolator = sDefaultInterpolator 
fraction = mInterpolator.getInterpolation(fraction);//对应插值器计算出分数值

public class AccelerateDecelerateInterpolator extends BaseInterpolator
        implements NativeInterpolatorFactory {
......
    public float getInterpolation(float input) {
        return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
    }
......
}

现在来看一下估值器Evaluate的
关键2：代码代码如下

mValues[i].calculateValue(fraction); //传入插值器的分值，后面交给估值器计算出最后的值
---------------------------------------------------------------------
PropertyValuesHolder类
PropertyValuesHolder{
void calculateValue(float fraction) {
        Object value = mKeyframes.getValue(fraction);
        mAnimatedValue = mConverter == null ? value : mConverter.convert(value);
    }
}

mKeyframes是什么类型的？？

在上面 源码解读 ValueAnimator.ofObject可以看到setObjectValues ->PropertyValuesHolder.ofObject("", null, values)->setObjectValues 中可以看到 mKeyframes 是 KeyframeSet类型的。

public class KeyframeSet implements Keyframes {
public Object getValue(float fraction) {
        // Special-case optimization for the common case of only two keyframes
        if (mNumKeyframes == 2) {
            if (mInterpolator != null) {
                fraction = mInterpolator.getInterpolation(fraction);
            }
            return mEvaluator.evaluate(fraction, mFirstKeyframe.getValue(),
                    mLastKeyframe.getValue());
        }
       .......
        Keyframe prevKeyframe = mFirstKeyframe;
        for (int i = 1; i < mNumKeyframes; ++i) {
            Keyframe nextKeyframe = mKeyframes.get(i);
            if (fraction < nextKeyframe.getFraction()) {
                final TimeInterpolator interpolator = nextKeyframe.getInterpolator();
                final float prevFraction = prevKeyframe.getFraction();
                float intervalFraction = (fraction - prevFraction) /
                    (nextKeyframe.getFraction() - prevFraction);
                // Apply interpolator on the proportional duration.
                if (interpolator != null) {
                    intervalFraction = interpolator.getInterpolation(intervalFraction);
                }
                return mEvaluator.evaluate(intervalFraction, prevKeyframe.getValue(),
                        nextKeyframe.getValue());
            }
            prevKeyframe = nextKeyframe;
        }
        // shouldn't reach here
        return mLastKeyframe.getValue();
    }
}

从上面的逻辑你可以看到mEvaluator.evaluate(fraction,mFirstKeyframe.getValue(),mLastKeyframe.getValue());反正就是计算出各种对应的数值交给估值器去计算出最终的值并返回，将其赋值给上个代码块中的mAnimatedValue。
从这一点上我们可以看到
当我们在调用API接口的时候

mColorAnim = ValueAnimator.ofObject(new ArgbEvaluator(), 0, 0x80000000);//开始解读1
mColorAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
   @Override
    public void onAnimationUpdate(ValueAnimator animation) {
       final int c = (Integer) animation.getAnimatedValue();
          mColor.setColor(c);
    }
});
mColorAnim.setDuration(2000);
mColorAnim.start(); //开始解读2

animation.getAnimatedValue();这里获取到的是我们估值器计算出来的最终值。

小结：插值器是计算出分值，即0-1中间的分数值，估值器才是我们最后使用的属性值。估值器是由我们的属性值跟插值器的分数值相乘得出的一个我们此时此刻需要的属性值

这个代码是比较粗略的过了一遍动画的开始到结束，然后确定出来动画的一些协助类。很多细节的东西并没有讲出来，比如涉及到中间的Vsyn回调屏幕渲染的问题。这个很多东西讲的，如果在代码中一个个说的话，那实在太长了。下次再看看那个屏幕渲染的文章再写一篇博文吧。

最后编辑于：2020.03.16 18:27:59

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 213,864评论 6赞 494
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,175评论 3赞 387
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 159,401评论 0赞 349
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,170评论 1赞 286
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,276评论 6赞 385
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,364评论 1赞 292
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,401评论 3赞 412
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,179评论 0赞 269
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,604评论 1赞 306
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,902评论 2赞 328
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,070评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,751评论 4赞 337
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,380评论 3赞 319
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,077评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,312评论 1赞 267
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,924评论 2赞 365
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,957评论 2赞 351