1、概述

Android中想做很炫酷的动画效果，相信在很多时候你都可以选择使用属性动画，关于属性动画如何使用，我们已经很详细的写过两篇博客讲解。如果你还不了解，请参考：

Android 属性动画（Property Animation） 完全解析 （上）

Android 属性动画（Property Animation） 完全解析 （下）

本篇博客将分析属性动画的实现源码，带你深入的了解Android属性动画的内部实现机制。如果你经常用属性动画，但又一直没有去查看其源码实现，没关系，请往下看。

2、分析前的猜想

在源码分析之前，我们需要有一个明确的思路，例如：源码的入口的选择、甚至对其实现进行简单的猜测，源码分析相当于一个验证的过程，带着一个目标去看源码，这样的话，分析和理解起来更为方便。

对于实现属性动画，最常用的类就是ObjectAnimator了，只需要简单的设置目标view，属性，以及目标值等必要属性，调用一下start();我们的动画就完成了。

类似如下代码：

[java] view plain copy

1. ObjectAnimator
2. .ofInt(target,propName,values[])
3. .setInterpolator(LinearInterpolator)
4. .setEvaluator(IntEvaluator)
5. .setDuration(500)
6. .start();

上述代码很好理解吧，设置动画作用的view，作用的属性，动画开始、结束、以及中间的任意个属性值；

然后是设置插值器，当然了插值器这个词比较难理解，我要是说例如：AccelerateInterpolator、LinearInterpolator

然后设置估值算法，这个看名字挺高端，其实内部实现尤其简单： return (int)(startInt + fraction * (endValue - startInt)); 开始值，加上当前的属性改变的百分比*（结束-开始）

当然了，这个百分比是fraction ，其实就是上面的插值器算出来的。比如线性插值器：fraction值就是currentTime - mStartTime) / mDuration，动画的运行时间/总设置时间。

然后是设置动画事件，

最后start()。

好了，现在我想问个问题，根据上面这些参数，如果我要你设计个属性动画框架，你怎么做？

这个嘛，好整，拿到上述参数之后，start()中，开启一个定时器，去执行一个任务；在任务内部，根据Interpolator计算出来的fraction，交给Evaluator，得到属性当前应该设置的值，然后反射设置tagert的指定属性，ok，奏事这么简单。嗯，大体上应该就是这样，当然了，源码的实现肯定复杂很多，但是万变不离其宗，所以接下来的源码阅读，就是去验证我们的这个答案。

3、源码分析

好了，猜想完了，我们就得进入验证阶段了~~

那么，我们源码的入口就是上述代码了，不过貌似上述代码调用了好几个方法，but，我觉得start之前的代码，无法是初始化实例，设置一些成员变量。

首先我们看ofInt，这里为了简单，我们的ofInt中的values参数，默认就一个，类似.ofInt(view, "translationX", 300) ；

1、ofInt

[java] view plain copy

1. publicstaticObjectAnimatorofInt(Objecttarget,StringpropertyName,int...values){
2. ObjectAnimatoranim=newObjectAnimator(target,propertyName);
3. anim.setIntValues(values);
4. returnanim;
5. }

首先调用ObjectAnimator的构造方法传入了一个target和propName，估计就是创建对象，然后旧路下target和propName，简单看下

[java] view plain copy

1. privateObjectAnimator(Objecttarget,StringpropertyName){
2. mTarget=target;
3. setPropertyName(propertyName);
4. }
5. publicvoidsetPropertyName(StringpropertyName){
6. //...
7. mPropertyName=propertyName;
8. mInitialized=false;
9. }

记录完成target,propName以后，调用setIntValues

[java] view plain copy

1. @Override
2. publicvoidsetIntValues(int...values){
3. setValues(PropertyValuesHolder.ofInt(mPropertyName,values));
4. }

可以看到，把我们的propName，和values传入到了一个PropertyValuesHolder的ofInt方法中，去构造一个PropertyValuesHolder对象，这个对象是干什么的呢？

从字面上看，是保存view在动画期间的属性和值，记住是动画期间的。继续往下看：

[java] view plain copy

1. publicstaticPropertyValuesHolderofInt(StringpropertyName,int...values){
2. returnnewIntPropertyValuesHolder(propertyName,values);
3. }
4. publicIntPropertyValuesHolder(StringpropertyName,int...values){
5. mPropertyName=propertyName;
6. setIntValues(values);
7. }
8. @Override
9. publicvoidsetIntValues(int...values){
10. mValueType=int.class;
11. mKeyframeSet=KeyframeSet.ofInt(values);
12. mIntKeyframeSet=(IntKeyframeSet)mKeyframeSet;
13. }

可以看到在IntPropertyValuesHolder内部存储了我们的propertyName;，然后又调用了setIntValues，存储了我们的mValueType ，此外还存了一个mIntKeyframeSet。

这里又出现一个新名词，叫做mKeyframeSet，这个是由KeyframeSet.ofInt(values);得到的。

那么这个KeyframeSet是什么呢？单纯的理解是，Keyframe的集合，而Keyframe叫做关键帧，为一个动画保存time/value（时间与值）对。

那么我们去看看它是如何通过KeyframeSet.ofInt(values);去构造与保存的：

[java] view plain copy

1. publicstaticKeyframeSetofInt(int...values){
2. intnumKeyframes=values.length;
3. IntKeyframekeyframes[]=newIntKeyframe[Math.max(numKeyframes,2)];
4. if(numKeyframes==1){
5. keyframes[0]=(IntKeyframe)Keyframe.ofInt(0f);
6. keyframes[1]=(IntKeyframe)Keyframe.ofInt(1f,values[0]);
7. }else{
8. //...
9. }
10. returnnewIntKeyframeSet(keyframes);
11. }
12. publicIntKeyframeSet(IntKeyframe...keyframes){
13. mNumKeyframes=keyframes.length;
14. mKeyframes=newArrayList<Keyframe>();
15. mKeyframes.addAll(Arrays.asList(keyframes));
16. mFirstKeyframe=mKeyframes.get(0);
17. mLastKeyframe=mKeyframes.get(mNumKeyframes-1);
18. mInterpolator=mLastKeyframe.getInterpolator();
19. }

这里代码跳跃比较大，部分代码我来解释：

根据我们的values的长度，构造了keyframes数组，然后分别通过Keyframe的ofInt方法，去构造keyframe对象，其实在内部：

[java] view plain copy

1. IntKeyframe(floatfraction,intvalue){
2. mFraction=fraction;
3. mValue=value;
4. mValueType=int.class;
5. mHasValue=true;
6. }
8. IntKeyframe(floatfraction){
9. mFraction=fraction;
10. mValueType=int.class;
11. }

就简单存了一下fraction，和value；当然了，我们这里values只有一个值，所以构造了两个Keyframe。

拿到初始化完成的keyframes数组以后，将其传入了KeyframeSet的构造方法，初始化了KeyframeSet内部的一些成员变量。

[java] view plain copy

1. publicIntKeyframeSet(IntKeyframe...keyframes){
2. mNumKeyframes=keyframes.length;
3. mKeyframes=newArrayList<Keyframe>();
4. mKeyframes.addAll(Arrays.asList(keyframes));
5. mFirstKeyframe=mKeyframes.get(0);
6. mLastKeyframe=mKeyframes.get(mNumKeyframes-1);
7. mInterpolator=mLastKeyframe.getInterpolator();
8. }

存了有多少关键帧，开始帧，结束帧，以及插值器。

到此，我们的(PropertyValuesHolder.ofInt在彻底返回，可以看到这个过程中，我们成功的为PropertyValuesHolder对象赋值了propName,valueType,keyframeSet .

keyframeset中存了Keyframe集合，keyframe中存储了（fraction , valuetype , value , hasValue）。

最后，叫PropertyValuesHolder 交给我们的 ObjectAnimator的setValues方法。

[java] view plain copy

1. publicvoidsetValues(PropertyValuesHolder...values){
2. intnumValues=values.length;
3. mValues=values;
4. mValuesMap=newHashMap<String,PropertyValuesHolder>(numValues);
5. for(inti=0;i<numValues;++i){
6. PropertyValuesHoldervaluesHolder=values[i];
7. mValuesMap.put(valuesHolder.getPropertyName(),valuesHolder);
8. }
9. //Newproperty/values/targetshouldcausere-initializationpriortostarting
10. mInitialized=false;
11. }

首先记录了mValues，注意这里的values是PropertyValuesHolder类型的，然后通过一个mValueMap记录：key为属性的名称，值为PropertyValuesHolder 。

好了，到此我们的ofInt结束了，晕否，其实还好。如果你晕了，我帮你总结下：ofInt就是记录了target,propName,values（是将我们传入的int型values，辗转转化成了PropertyValuesHolder）,以及一个mValueMap，这个map的key是propName，value是PropertyValuesHolder，在PropertyValuesHolder内部又存储了proprName, valueType , keyframeSet等等。

好了，接下来会轻松点，按照顺序到setInterpolator了：

2、setInterpolator

[java] view plain copy

1. @Override
2. publicvoidsetInterpolator(TimeInterpolatorvalue){
3. if(value!=null){
4. mInterpolator=value;
5. }else{
6. mInterpolator=newLinearInterpolator();
7. }
8. }

没撒说的，记录下插值器，我们这里也线性插值器，默认也是~~

然后是setEvaluator。

3、setEvaluator

[java] view plain copy

1. publicvoidsetEvaluator(TypeEvaluatorvalue){
2. if(value!=null&&mValues!=null&&mValues.length>0){
3. mValues[0].setEvaluator(value);
4. }
5. }

记得我们这里的mValue吧，在ofInt里面初始化的，类型是PropertyValuesHolder。然后调用了PropertyValuesHolder.setEvalutor

[java] view plain copy

1. publicvoidsetEvaluator(TypeEvaluatorevaluator){
2. mEvaluator=evaluator;
3. mKeyframeSet.setEvaluator(evaluator);
4. }

记录了一下估值算法，然后再将其传给KeyframeSet对象：

[java] view plain copy

1. publicvoidsetEvaluator(TypeEvaluatorevaluator){
2. mEvaluator=evaluator;
3. }

可以看到，我们把估值算法，交给了PropertyValuesHolder以及KeyframeSet。

接下来，最后一个属性，duration

4、setDuration

[java] view plain copy

1. //Howlongtheanimationshouldlastinms
2. privatelongmDuration=(long)(300*sDurationScale);
3. privatelongmUnscaledDuration=300;
4. privatestaticfloatsDurationScale=1.0f;
6. publicObjectAnimatorsetDuration(longduration){
7. if(duration<0){
8. thrownewIllegalArgumentException("Animatorscannothavenegativeduration:"+
9. duration);
10. }
11. mUnscaledDuration=duration;
12. mDuration=(long)(duration*sDurationScale);
13. returnthis;
14. }

就是简单在mDuration中记录了一下动画的持续时间，这个sDurationScale默认为1，貌似是用于调整，观察动画的，比如你可以调整为10，动画就会慢10倍的播放。

好了，到此该设置的设置完成了，小小总结一下：

ofInt中实例化了一个ObjectAnimator对象，然后设置了target，propName，values(PropertyValuesHolder) ；然后分别在setInterpolator，setDuration设置了Interpolator和duration。其中setEvaluator是给values[0]，以及keyframeSet设置估值算法。

PropertyValueHolder实际上是IntPropertyValueHolder类型对象，包含propName,valueType,keyframeSet .

keyframeset中存了Keyframe集合，keyframe中存储了（fraction , valuetype , value , hasValue）。

以上都比较简单，关键就是看start()方法中，如何将这些属性进行合理的处理调用神马的。

5、start

喝杯水，小憩一下，准备征战start()方法。

[java] view plain copy

1. @Override
2. publicvoidstart(){
3. super.start();
4. }
5. ValueAnimator
6. @Override
7. publicvoidstart(){
8. start(false);
9. }
10. ValueAnimator
11. privatevoidstart(booleanplayBackwards){
12. if(Looper.myLooper()==null){
13. thrownewAndroidRuntimeException("AnimatorsmayonlyberunonLooperthreads");
14. }
15. mPlayingBackwards=playBackwards;
16. mCurrentIteration=0;
17. mPlayingState=STOPPED;
18. mStarted=true;
19. mStartedDelay=false;
20. mPaused=false;
21. AnimationHandleranimationHandler=getOrCreateAnimationHandler();
22. animationHandler.mPendingAnimations.add(this);
23. if(mStartDelay==0){
24. //Thissetstheinitialvalueoftheanimation,priortoactuallystartingitrunning
25. setCurrentPlayTime(0);
26. mPlayingState=STOPPED;
27. mRunning=true;
28. notifyStartListeners();
29. }
30. animationHandler.start();
31. }

最终调用了ValueAnimator的statr(playBackwards)方法；

15-20行：设置了关于动画的一些标志位，mPlayingBackwards 表示动画是否reverse；mCurrentIteration 记录当前的动画的执行次数（与setRepeatCount有关）；mPlayingState 动画的状态为STOPPED；还有些其他的标志位；

21行：生成一个AnimationHandler对象，getOrCreateAnimationHandler就是在当前线程变量ThreadLocal中取出来，没有的话，则创建一个，然后set进去。

AnimationHandler中包含一些List集合用于存储各种状态的ValueAnimator。

22行：将当前ValueAnimator对象，加入 animationHandler.mPendingAnimations 集合。

23行：未设置mStartDelay，默认为0，则进入循环；

24行： setCurrentPlayTime(0);一会需要细说

25-26行：设置些状态。

27行：回调监听动画的接口AnimatorListener的onAnimationStart方法，如果你设置了回调监听，此时就会进行回调；

最后30行：调用animationHandler.start();需要细说；

好了，有两个方法需要细说，首先看setCurrentPlayTime（0）

[java] view plain copy

1. publicvoidsetCurrentPlayTime(longplayTime){
2. initAnimation();
3. longcurrentTime=AnimationUtils.currentAnimationTimeMillis();
4. if(mPlayingState!=RUNNING){
5. mSeekTime=playTime;
6. mPlayingState=SEEKED;
7. }
8. mStartTime=currentTime-playTime;
9. doAnimationFrame(currentTime);
10. }

首先初始化动画，然后得到当前的系统开始到现在的时间currentTime；设置mSeekTime，设置当前状态为SEEKED；然后使用mSeekTime-playTime得到动画现在需要执行的时间；最后调用doAnimationFrame(currentTime)，稍后看其代码;

关于initAnimation()，实际就是去设置我们ValueAnimator中存储的mValues，也就是IntPropertyValueHolder的mEvaluator；

[java] view plain copy

1. voidinitAnimation(){
2. if(!mInitialized){
3. intnumValues=mValues.length;
4. for(inti=0;i<numValues;++i){
5. mValues[i].init();
6. }
7. mInitialized=true;
8. }

PropertyValuesHolder的init方法：

[java] view plain copy

1. voidinit(){
2. if(mEvaluator==null){
3. //Wealreadyhandleintandfloatautomatically,butnottheirObject
4. //equivalents
5. mEvaluator=(mValueType==Integer.class)?sIntEvaluator:
6. (mValueType==Float.class)?sFloatEvaluator:
7. null;
8. }
9. if(mEvaluator!=null){
10. //KeyframeSetknowshowtoevaluatethecommontypes-onlygiveitacustom
11. //evaluatorifonehasbeensetonthisclass
12. mKeyframeSet.setEvaluator(mEvaluator);
13. }
14. }

其实就是遍历设置PropertyValuesHolder中的mEvaluator属性，默认根据valueType进行判断，IntEvaluator或者FloatEvaluator。

接下来应该看doAnimationFrame(currentTime);了

[java] view plain copy

1. finalbooleandoAnimationFrame(longframeTime){
3. finallongcurrentTime=Math.max(frameTime,mStartTime);
4. returnanimationFrame(currentTime);
5. }

内部调用了：animationFrame(currentTime);

[java] view plain copy

1. booleananimationFrame(longcurrentTime){
2. booleandone=false;
3. switch(mPlayingState){
4. caseRUNNING:
5. caseSEEKED:
6. floatfraction=mDuration>0?(float)(currentTime-mStartTime)/mDuration:1f;
7. if(fraction>=1f){
8. //...
9. }
10. if(mPlayingBackwards){
11. fraction=1f-fraction;
12. }
13. animateValue(fraction);
14. break;
15. }
17. returndone;
18. }

这里通过判断当前动画的状态，给出fraction，默认传入的就是(float)(currentTime - mStartTime) / mDuration，动画执行的时间除以总的时间比值；

接下来调用了animateValue(fraction)

在animateValue的内部，会将传入的fraction，交给mInterpolator.getInterpolation(fraction);方法，获得插值器处理后的fraction；然后在将fraction交给估值算法mEvaluator.evaluate(fraction, firstValue, lastValue)).intValue();进行计算得到当前时间点，属性应该的值；最后会反射对我们设置的属性进行设置。

终于看到，对我们的属性的值进行设置了，偶也~~当然了，动画如果没结束，应该每隔一定的帧数，再次调用，嗯，的确是这样的，你看到animationFrame最后是不是有个返回值，这个值会在fraction>=1的时候返回true;

我们还是先看看animateValue方法:

[java] view plain copy

1. voidanimateValue(floatfraction){
2. fraction=mInterpolator.getInterpolation(fraction);
3. mCurrentFraction=fraction;
4. intnumValues=mValues.length;
5. for(inti=0;i<numValues;++i){
6. mValues[i].calculateValue(fraction);
7. }
8. if(mUpdateListeners!=null){
9. intnumListeners=mUpdateListeners.size();
10. for(inti=0;i<numListeners;++i){
11. mUpdateListeners.get(i).onAnimationUpdate(this);
12. }
13. }
15. intnumValues=mValues.length;
16. for(inti=0;i<numValues;++i){
17. mValues[i].setAnimatedValue(mTarget);
18. }
19. }

首先将fraction交给给mInterpolator.getInterpolation(fraction);得到计算后的fraction；

然后for循环遍历调用IntPropertyValueHolder的calculateValue方法：

[java] view plain copy

1. voidcalculateValue(floatfraction){
2. mAnimatedValue=mKeyframeSet.getValue(fraction);
3. }

在其内部，调用了mKeyframeSet的getValue，这里注意我们的IntKeyFrameSet，千万不要看错方法了。

[java] view plain copy

1. @Override
2. publicObjectgetValue(floatfraction){
3. returngetIntValue(fraction);
4. }
5. publicintgetIntValue(floatfraction){
6. if(mNumKeyframes==2){
7. if(firstTime){
8. firstTime=false;
9. firstValue=((IntKeyframe)mKeyframes.get(0)).getIntValue();
10. lastValue=((IntKeyframe)mKeyframes.get(1)).getIntValue();
11. deltaValue=lastValue-firstValue;
12. }
13. if(mInterpolator!=null){
14. fraction=mInterpolator.getInterpolation(fraction);
15. }
16. if(mEvaluator==null){
17. returnfirstValue+(int)(fraction*deltaValue);
18. }else{
19. return((Number)mEvaluator.evaluate(fraction,firstValue,lastValue)).intValue();
20. }
21. }
22. //...省略了很多代码
23. }

在其内部，因为我们只设置了一个目标属性值，所以只有两个关键帧；

然后16-20行，调用估值算法的mEvaluator.evaluate方法，可以看到如果mEvaluator == null直接调用了firstValue + (int)(fraction * deltaValue);其实这个就是IntEvaluator的默认实现。

好了，for循环结束了，经过我们插值器和估值算法得出的值，最终给了IntPropertyValueHolder的mIntAnimatedValue属性；

回到animateValue方法：在animateValue的8-12行，继续回调动画监听onAnimationUpdate(this);方法；

animateValue的15-18行：循环拿到（其实我们就只有一个属性）我们的IntPropertyValueHolder调用setAnimatedValue，进行反射为我们的属性设置值，反射需要一些东西，比如target，propname，以及该属性应该设置的值；这三个参数在哪呢？target作为参数传入了，propName初始化的时候就设置了，至于该属性应该设置的值，上面有一句：“ 好了，for循环结束了，经过我们插值器和估值算法得出的值，最终给了IntPropertyValueHolder的mIntAnimatedValue属性” 。是不是全了~~反射的代码就不贴了。

好了，到此，我们属性动画，设置的各种值，经过重重的计算作用到了我们的属性上，反射修改了我们的属性。到此我们已经完成了一大半，但是貌似还少了个，每隔多少帧调用一次~~

嗯，的确是的，跨度好大，现在回到我们的start方法，最后一行：调用animationHandler.start();这个还没细说呢~~

animationHandler我们上面已经介绍了，存储在当前线程的ThreadLocal里面，里面放了一些集合用于存储各种状态的ObjectAnimator，我们当前的ObjectAnimator对象也存储在其mPendingAnimations的集合中（上面提到过~~）。

[java] view plain copy

1. /**
2. *Startanimatingonthenextframe.
3. */
4. publicvoidstart(){
5. scheduleAnimation();
6. }
7. privatevoidscheduleAnimation(){
8. if(!mAnimationScheduled){
9. mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION,this,null);
10. mAnimationScheduled=true;
11. }
12. }

start内部最终调用了mChoreographer.postCallback，其中有一个参数是this；至于什么是Choreographer，暂时不用管；但是你需要知道一件事，其实我们的animationHandler是Runnable的子类，而mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, this, null);类似与handler发送消息，最终执行这个Runnable的run方法。

说这么多，其实就是一句话，这里调用了animationHandler的 run方法。

[java] view plain copy

1. publicvoidrun(){
2. mAnimationScheduled=false;
3. doAnimationFrame(mChoreographer.getFrameTime());
4. }
5. privatevoiddoAnimationFrame(longframeTime){
6. while(mPendingAnimations.size()>0){
7. ArrayList<ValueAnimator>pendingCopy=
8. (ArrayList<ValueAnimator>)mPendingAnimations.clone();
9. mPendingAnimations.clear();
10. intcount=pendingCopy.size();
11. for(inti=0;i<count;++i){
12. ValueAnimatoranim=pendingCopy.get(i);
13. //IftheanimationhasastartDelay,placeitonthedelayedlist
14. if(anim.mStartDelay==0){
15. anim.startAnimation(this);
16. }else{
17. mDelayedAnims.add(anim);
18. }
19. }
20. }
21. //...省略了一些代码
24. //Nowprocessallactiveanimations.ThereturnvaluefromanimationFrame()
25. //tellsthehandlerwhetheritshouldnowbeended
26. intnumAnims=mAnimations.size();
27. for(inti=0;i<numAnims;++i){
28. mTmpAnimations.add(mAnimations.get(i));
29. }
30. for(inti=0;i<numAnims;++i){
31. ValueAnimatoranim=mTmpAnimations.get(i);
32. if(mAnimations.contains(anim)&&anim.doAnimationFrame(frameTime)){
33. mEndingAnims.add(anim);
34. }
35. }
36. mTmpAnimations.clear();
37. if(mEndingAnims.size()>0){
38. for(inti=0;i<mEndingAnims.size();++i){
39. mEndingAnims.get(i).endAnimation(this);
40. }
41. mEndingAnims.clear();
42. }
44. //Iftherearestillactiveordelayedanimations,scheduleafuturecallto
45. //onAnimatetoprocessthenextframeoftheanimations.
46. if(!mAnimations.isEmpty()||!mDelayedAnims.isEmpty()){
47. scheduleAnimation();
48. }
49. }

6-20行：while循环，遍历所有在mPendingAnimations中的ObjectAnimator，依次调用anim.startAnimation(this);

在anim.startAnimation(this);内部其实主要就一行代码：handler.mAnimations.add(this); 将当前动画加入animationHandler的mAnimations集合；

26-29行：将animationHandler的mAnimations集合中的每个anim，加入到mTmpAnimations中；

30-35行：依次调用mTmpAnimations中的anim，anim.doAnimationFrame(frameTime)

doAnimationFrame（frameTime）上面已经分析过了，如果返回true，即doAnimationFrame的done为true，则将该动画加入到结束动画集合。

37-43行：循环调用mEndingAnims，mEndingAnims.get(i).endAnimation(this);内部，会将动画移除mAnimations，回调动画监听接口onAnimationEnd；以及重置各种标志变量。 46-48行：如果mAnimations不为null，则再次调用scheduleAnimation(); 哈哈，终于终于发现了，每隔多少帧调用一次动画的地方了~~尼玛这个scheduleAnimation，不就是animationHandler的 run方法调用的么~~
前面已经描述过animationHandler的 run方法中通过计算属性应该的值，反射设置；加上我们这里的动画没结束，就会再次调用该run方法内部一致的方法~~~

搜噶，到此~~我们的属性动画的流程已经完美跑通了~~~

对了，看完以后，和我们文章开始的预期符合么，其实我觉得差不多~~

4、总结

其实看源码的目的，最终就是为了总结，尼玛这么长的代码谁也记不住。。。所以看完记得总结：

ofInt中实例化了一个ObjectAnimator对象，然后设置了target，propName，values(PropertyValuesHolder) ；然后分别在setInterpolator，setDuration设置了Interpolator

和duration。其中setEvaluator是给PropertyValuesHolder，以及keyframeSet设置估值算法。

PropertyValueHolder实际上是IntPropertyValueHolder类型对象，包含propName,valueType,keyframeSet .

keyframeset中存了Keyframe集合，keyframe中存储了（fraction , valuetype , value , hasValue）。

上述其实都是设置各种值什么的。真正核心要看start~

start()中：

首先，步骤1：更新动画各种状态，然后初步计算fraction为(currentTime - mStartTime) / mDuration；然后将这个fraction交给我们的插值器计算后得到新的fraction，再将新的fraction交给我们的估值算法，估值算法根据开始、结束、fraction得到当前属性（动画作用的属性）应该的值，最大调用反射进行设置；

当然了：start中还会根据动画的状态，如果没有结束，不断的调用scheduleAnimation();该方法内部利用mChoreographer不断的去重复我们的上述步骤1。

好了，顺便说一句，在看源码的时候，一定要注意，你点进去的有可能不是真正运行时调用的，记得查看该方法子类，比如我们查看ObjectAnimator的方法，可能我们某个方法会跟到其父类ValueAnimator的方法，但是记得查看ObjectAnimator是否复写了该方法~~如果复写了，你该看的应该是ObjectAnimator的方法~~~

源码，嗯？木有源码点击下载了~~~

更多相关文章

1. android textview xml 属性设置
2. android的一些属性
3. android RelativeLayout属性和使用, 实现上面view叠加在下面view
4. android RelativeLayout属性及demo
5. Android的Activity屏幕切换动画||GestureDetector、OnGestureLis
6. RelativeLayout属性和使用, 实现上面view叠加在下面view之上的效
7. 用fastboot大刷Android ~换个方法刷android手机
8. Android多进程总结一:生成多进程(android:process属性)

随机推荐

1. android studio gradle自动签名构建实现
2. android UI进阶之弹窗的使用（2）--实现通讯
3. android & Linux uevent机制
4. Android应用程序设计——入门配置
5. Android菜鸟的成长笔记（1）——Android开发
6. App Inventor for Android(安卓)- 大家都
7. Android下USB Accessory的实现分析
8. Android中字体颜色的设置
9. [Android] 开发资料收集：动态加载、插件化
10. android studio导入 so ，jar 文件。