Android源码解析之属性动画详解

概述前言大家在日常开发中离不开动画，属性动画更为强大，我们不仅要知道如何使用，更要知道他的原理。这样，才能得心应手。那么，今天，就从最简单的来说，了解下属性动画的原理。

前言

大家在日常开发中离不开动画，属性动画更为强大，我们不仅要知道如何使用，更要知道他的原理。这样，才能得心应手。那么，今天，就从最简单的来说，了解下属性动画的原理。

ObjectAnimator .ofInt(mVIEw,"wIDth",100,500) .setDuration(1000) .start();

ObjectAnimator#ofInt

以这个为例，代码如下。

public static ObjectAnimator ofInt(Object target,String propertyname,int... values) { ObjectAnimator anim = new ObjectAnimator(target,propertyname); anim.setIntValues(values); return anim;}

在这个方法中，首先会new一个ObjectAnimator对象，然后通过setIntValues方法将值设置进去，然后返回。在ObjectAnimator的构造方法中，会通过setTarget方法设置当前动画的对象，通过setPropertyname设置当前的属性名。我们重点说下setIntValues方法。

public voID setIntValues(int... 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.ofInt(mProperty,values)); } else { setValues(PropertyValuesHolder.ofInt(mPropertyname,values)); } } else { super.setIntValues(values); }}

首先会判断，mValues是不是null，我们这里是null，并且mProperty也是null，所以会调用
setValues(PropertyValuesHolder.ofInt(mPropertyname,values));方法。先看PropertyValuesHolder.ofInt方法，PropertyValuesHolder这个类是holds属性和值的，在这个方法会构造一个IntPropertyValuesHolder对象并返回。

public static PropertyValuesHolder ofInt(String propertyname,int... values) { return new IntPropertyValuesHolder(propertyname,values);}

IntPropertyValuesHolder的构造方法如下：

public IntPropertyValuesHolder(String propertyname,int... values) { super(propertyname); setIntValues(values);}

在这里，首先会调用他的分类的构造方法，然后调用setIntValues方法，在他父类的构造方法中，只是设置了下propertyname。setIntValues内容如下：

public voID setIntValues(int... values) { super.setIntValues(values); mIntKeyframes = (Keyframes.IntKeyframes) mKeyframes;}

在父类的setIntValues方法中，初始化了mValueType为int.class，mKeyframes为KeyframeSet.ofInt(values)。其中KeyframeSet为关键帧集合。然后将mKeyframes赋值给mIntKeyframes。

KeyframeSet

这个类是记录关键帧的。我们看下他的ofInt方法。

public static KeyframeSet ofInt(int... values) { int numKeyframes = values.length; IntKeyframe keyframes[] = new IntKeyframe[Math.max(numKeyframes,2)]; if (numKeyframes == 1) { keyframes[0] = (IntKeyframe) Keyframe.ofInt(0f); keyframes[1] = (IntKeyframe) Keyframe.ofInt(1f,values[0]); } else { keyframes[0] = (IntKeyframe) Keyframe.ofInt(0f,values[0]); for (int i = 1; i < numKeyframes; ++i) { keyframes[i] =  (IntKeyframe) Keyframe.ofInt((float) i / (numKeyframes - 1),values[i]); } } return new IntKeyframeSet(keyframes);}

在这里呢？根据传入的values来计算关键帧，最后返回IntKeyframeSet。

回到ObjectAnimator里面，这里的setValues用的是父类ValueAnimator的

ValueAnimator#setValues

public voID setValues(PropertyValuesHolder... values) { int numValues = values.length; mValues = values; mValuesMap = new HashMap<String,PropertyValuesHolder>(numValues); for (int i = 0; i < numValues; ++i) { PropertyValuesHolder valuesHolder = values[i]; mValuesMap.put(valuesHolder.getPropertyname(),valuesHolder); } // New property/values/target should cause re-initialization prior to starting mInitialized = false;}

这里的 *** 作就简单了，就是把PropertyValuesHolder放入到mValuesMap中。

ObjectAnimator#start

这个方法就是动画开始的地方。

public voID start() { // See if any of the current active/pending animators need to be canceled AnimationHandler handler = sAnimationHandler.get(); if (handler != null) { int numAnims = handler.mAnimations.size(); for (int i = numAnims - 1; i >= 0; i--) { if (handler.mAnimations.get(i) instanceof ObjectAnimator) { ObjectAnimator anim = (ObjectAnimator) handler.mAnimations.get(i); if (anim.mautoCancel && hasSaMetargetAndPropertIEs(anim)) {  anim.cancel(); } } } numAnims = handler.mPendingAnimations.size(); for (int i = numAnims - 1; i >= 0; i--) { if (handler.mPendingAnimations.get(i) instanceof ObjectAnimator) { ObjectAnimator anim = (ObjectAnimator) handler.mPendingAnimations.get(i); if (anim.mautoCancel && hasSaMetargetAndPropertIEs(anim)) {  anim.cancel(); } } } numAnims = handler.mDelayedAnims.size(); for (int i = numAnims - 1; i >= 0; i--) { if (handler.mDelayedAnims.get(i) instanceof ObjectAnimator) { ObjectAnimator anim = (ObjectAnimator) handler.mDelayedAnims.get(i); if (anim.mautoCancel && hasSaMetargetAndPropertIEs(anim)) {  anim.cancel(); } } } } 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();}

首先呢，会获取AnimationHandler对象，如果不为空的话，就会判断是mAnimations、mPendingAnimations、mDelayedAnims中的动画，并且取消。最后调用父类的start方法。

ValueAnimator#start

private voID start(boolean playBackwards) { if (Looper.myLooper() == null) { throw new AndroIDRuntimeException("Animators may only be run on Looper threads"); } mreversing = playBackwards; mPlayingBackwards = playBackwards; if (playBackwards && mSeekFraction != -1) { if (mSeekFraction == 0 && mCurrentIteration == 0) { // special case: reversing from seek-to-0 should act as if not seeked at all mSeekFraction = 0; } else if (mRepeatCount == INFINITE) { mSeekFraction = 1 - (mSeekFraction % 1); } else { mSeekFraction = 1 + mRepeatCount - (mCurrentIteration + mSeekFraction); } mCurrentIteration = (int) mSeekFraction; mSeekFraction = mSeekFraction % 1; } if (mCurrentIteration > 0 && mRepeatMode == REVERSE && (mCurrentIteration < (mRepeatCount + 1) || mRepeatCount == INFINITE)) { // if we were seeked to some other iteration in a reversing animator,// figure out the correct direction to start playing based on the iteration if (playBackwards) { mPlayingBackwards = (mCurrentIteration % 2) == 0; } else { mPlayingBackwards = (mCurrentIteration % 2) != 0; } } int prevPlayingState = mPlayingState; mPlayingState = StopPED; mStarted = true; mStartedDelay = false; mPaused = false; updateScaledDuration(); // in case the scale factor has changed since creation time AnimationHandler animationHandler = getorCreateAnimationHandler(); animationHandler.mPendingAnimations.add(this); if (mStartDelay == 0) { // This sets the initial value of the animation,prior to actually starting it running if (prevPlayingState != SEEKED) { setCurrentPlayTime(0); } mPlayingState = StopPED; mRunning = true; notifyStartListeners(); } animationHandler.start();}

先初始化一些值 updateScaledDuration 缩放时间，默认为1.0f 获取或者创建AnimationHandler，将动画加入到mPendingAnimations列表中， 如果没延迟，通知监听器 animationHandler.start

在animationHandler.start中，会调用scheduleAnimation方法，在这个种，会用mChoreographerpost一个callback，最终会执行mAnimate的run方法。mChoreographerpost涉及到VSYNC，这里不多介绍。

mAnimate#run

doAnimationFrame(mChoreographer.getFrameTime());

在这里会用过doAnimationFrame设置动画帧，我们看下这个方法的代码。

voID doAnimationFrame(long frameTime) { mLastFrameTime = frameTime; // mPendingAnimations holds any animations that have requested to be started // We're going to clear mPendingAnimations,but starting animation may // cause more to be added to the pending List (for example,if one animation // starting triggers another starting). So we loop until mPendingAnimations // is empty. while (mPendingAnimations.size() > 0) { ArrayList<ValueAnimator> pendingcopy = (ArrayList<ValueAnimator>) mPendingAnimations.clone(); mPendingAnimations.clear(); int count = pendingcopy.size(); for (int i = 0; i < count; ++i) { ValueAnimator anim = pendingcopy.get(i); // If the animation has a startDelay,place it on the delayed List if (anim.mStartDelay == 0) { anim.startAnimation(this); } else { mDelayedAnims.add(anim); } } } // Next,process animations currently sitting on the delayed queue,adding // them to the active animations if they are ready int numDelayedAnims = mDelayedAnims.size(); for (int i = 0; i < numDelayedAnims; ++i) { ValueAnimator anim = mDelayedAnims.get(i); if (anim.delayedAnimationFrame(frameTime)) { mReadyAnims.add(anim); } } int numReadyAnims = mReadyAnims.size(); if (numReadyAnims > 0) { for (int i = 0; i < numReadyAnims; ++i) { ValueAnimator anim = mReadyAnims.get(i); anim.startAnimation(this); anim.mRunning = true; mDelayedAnims.remove(anim); } mReadyAnims.clear(); } // Now process all active animations. The return value from animationFrame() // tells the handler whether it should Now be ended int numAnims = mAnimations.size(); for (int i = 0; i < numAnims; ++i) { mTmpAnimations.add(mAnimations.get(i)); } for (int i = 0; i < numAnims; ++i) { ValueAnimator anim = mTmpAnimations.get(i); if (mAnimations.contains(anim) && anim.doAnimationFrame(frameTime)) { mEndingAnims.add(anim); } } mTmpAnimations.clear(); if (mEndingAnims.size() > 0) { for (int i = 0; i < mEndingAnims.size(); ++i) { mEndingAnims.get(i).endAnimation(this); } mEndingAnims.clear(); } // Schedule final commit for the frame. mChoreographer.postCallback(Choreographer.CALLBACK_COMMIT,mCommit,null); // If there are still active or delayed animations,schedule a future call to // onAnimate to process the next frame of the animations. if (!mAnimations.isEmpty() || !mDelayedAnims.isEmpty()) { scheduleAnimation(); }}

方法较长，逻辑如下：

从mPendingAnimations中取出动画，根据事先选择startAnimation还是加入到mDelayedAnims列表。 如果mDelayedAnims列表中的动画准备好了，就加入到mReadyAnims列表中 从mAnimations列表中取出要执行的动画，加入到mTmpAnimations列表 通过doAnimationFrame方法执行动画帧 继续执行scheduleAnimation

从上面我们能看出，执行动画的关键是doAnimationFrame方法。在这个方法中，会调用animationFrame方法。

ValueAniator#animationFrame

boolean animationFrame(long currentTime) { boolean done = false; switch (mPlayingState) { case RUNNING: case SEEKED: float fraction = mDuration > 0 ? (float)(currentTime - mStartTime) / mDuration : 1f; if (mDuration == 0 && mRepeatCount != INFINITE) { // Skip to the end mCurrentIteration = mRepeatCount; if (!mreversing) {  mPlayingBackwards = false; } } if (fraction >= 1f) { if (mCurrentIteration < mRepeatCount || mRepeatCount == INFINITE) {  // Time to repeat  if (mListeners != null) {  int numListeners = mListeners.size();  for (int i = 0; i < numListeners; ++i) {  mListeners.get(i).onAnimationRepeat(this);  }  }  if (mRepeatMode == REVERSE) {  mPlayingBackwards = !mPlayingBackwards;  }  mCurrentIteration += (int) fraction;  fraction = fraction % 1f;  mStartTime += mDuration;  // Note: We do not need to update the value of mStartTimeCommitted here  // since we just added a duration offset. } else {  done = true;  fraction = Math.min(fraction,1.0f); } } if (mPlayingBackwards) { fraction = 1f - fraction; } animateValue(fraction); break; } return done; }

计算fraction 调用animateValue方法

根据虚拟机执行引擎动态分派原则，这里会调用ObjectAnimator的animateValue方法。

ObjectAnimator#animateValue

voID animateValue(float fraction) { final Object target = getTarget(); if (mTarget != null && target == null) { // We lost the target reference,cancel and clean up. cancel(); return; } super.animateValue(fraction); int numValues = mValues.length; for (int i = 0; i < numValues; ++i) { mValues[i].setAnimatedValue(target); }}

这里主要干了两件事，

调用父类的animateValue方法 通过setAnimatedValue设置属性

其父类的方法如下：

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

在这个方法中，会通过Interpolator得到出当前的fraction，并通过calculateValue来计算当前应该的值，这里会调用IntPropertyValuesHolder的calculateValue

voID calculateValue(float fraction) { mIntAnimatedValue = mIntKeyframes.getIntValue(fraction);}

我们知道，mIntKeyframes对应的是IntKeyframeSet。在这个类的getIntValue中，会通过TypeEvaluator来计算当前对应的值。不多说了。

最后，回到animateValue。计算了值之后，会调用setAnimatedValue来设置值。我们看看他的实现。

IntPropertyValuesHolder#setAnimatedValue

voID setAnimatedValue(Object target) { if (mIntProperty != null) { mIntProperty.setValue(target,mIntAnimatedValue); return; } if (mProperty != null) { mProperty.set(target,mIntAnimatedValue); return; } if (mJniSetter != 0) { nCallintMethod(target,mJniSetter,mIntAnimatedValue); return; } if (mSetter != null) { try { mTmpValueArray[0] = mIntAnimatedValue; mSetter.invoke(target,mTmpValueArray); } catch (InvocationTargetException e) { Log.e("PropertyValuesHolder",e.toString()); } catch (illegalaccessexception e) { Log.e("PropertyValuesHolder",e.toString()); } }}

恩，到这里就能看到修改属性值得痕迹了，有以下四种情况

mIntProperty不为null mProperty不为null mJniSetter不为null mSetter不为null

首先，我们通过String propertyname,int… values参数构造的对象，mIntProperty为null，并且mProperty也为null。那其他两个是怎么来的呢？似乎漏了什么？

还节的，在doAnimationFrame中，直接调用startAnimation么?没错，就是这里。

startAnimation

在这个方法中调用了initAnimation方法。还是根据动态分派规则，这里调用ObjectAnimator的initAnimation方法。在这里调用PropertyValuesHolder的setupSetterandGetter方法，在这里对mSetter等进行了初始化，这里就不多说了，大家自己看代码吧。

好了，以上就是关于AndroID中属性动画对的全部内容，希望本文的内容对各位AndroID开发者们能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对编程小技巧的支持。

总结

以上是内存溢出为你收集整理的Android源码解析之属性动画详解全部内容，希望文章能够帮你解决Android源码解析之属性动画详解所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。