Android Animation动画原理源码分析

Android 平台提供了三类动画，一类是 Tween 动画-Animation，即通过对场景里的对象不断做图像变换 ( 平移、缩放、旋转 ) 产生动画效果；第二类是 Frame 动画，即顺序播放事先做好的图像，跟电影类似。最后一种就是3.0之后才出现的属性动画PropertyAnimator ，这个分享的是第一类动画原理。

Animation动画有4种，TranslateAnimation、ScaleAnimation、RotateAnimation、AlphAnimation，其都继承了Animation这个抽象类，实现了applyTransformation(float interpolatedTime, Transformation t)函数，如下ScaleAnimation的实现：

根据函数的命名来看就是对Transformation进行设置，通过传来interpolatedTime浮点值不断改变Transformation的矩阵Matrix来实现动画的缩放。那这个函数什么时候被调用，如何被调用，一步步来分析下：

可以看到在Animation中getTransformation(long currentTime, Transformation outTransformation)进行了调用，并且判断了动画是否继续下去，还有其他变化帧是否完成，如下:

public boolean getTransformation(long currentTime, Transformation outTransformation) {
if (mStartTime == -1) {
mStartTime = currentTime;
}

final long startOffset = getStartOffset();
final long duration = mDuration;
float normalizedTime;
if (duration != 0) {
normalizedTime = ((float) (currentTime - (mStartTime + startOffset))) /
(float) duration;
} else {
// time is a step-change with a zero duration
normalizedTime = currentTime < mStartTime ? 0.0f : 1.0f;
}
//是否完成判断
final boolean expired = normalizedTime >= 1.0f || isCanceled();
mMore = !expired;

if (!mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);

if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) {
if (!mStarted) {
fireAnimationStart();
mStarted = true;
if (NoImagePreloadHolder.USE_CLOSEGUARD) {
guard.open("cancel or detach or getTransformation");
}
}

if (mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);

if (mCycleFlip) {
normalizedTime = 1.0f - normalizedTime;
}
//根据时间的变化进度算出插值变化结果
final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
//对transformation进行改变
applyTransformation(interpolatedTime, outTransformation);
}

******省略代码******

if (!mMore && mOneMoreTime) {
mOneMoreTime = false;
return true;
}

return mMore;
}

那getTransformation函数又是在哪里被调用呢。我们一步步从动画api使用源头开始分析：

我们知道使用Animation执行动画从view.startAnimation（Animation animation)开始，其实现如下：

public void startAnimation(Animation animation) {
animation.setStartTime(Animation.START_ON_FIRST_FRAME);
setAnimation(animation);
invalidateParentCaches();
invalidate(true);
}

一看没有啥，就是设置赋值以及清父View Caches的标签设置，没有看出啥是如何让动画执行起来，调用了Animation的getTransformation函数。一般会说看到了invalidate函数调用了，就是刷新了View，那具体是怎么刷新View绘制的呢，那先讲下invalidate（true）执行流程和逻辑是啥，到底怎么样导致了刷新。没有别的办法，看源码，gogogo……详见我的另一遍文章《Android invalidate()和postInvalidate()刷新原理》

1、invalidate最后调用到invalidateInternal函数，把view的相对尺寸和相关状态设置传递

void invalidate(boolean invalidateCache) {
invalidateInternal(0, 0, mRight - mLeft, mBottom -  mTop, invalidateCache, true);
}

void invalidateInternal(int l, int t, int r, int b, boolean invalidateCache,
boolean fullInvalidate)

2、invalidateInternal函数中逻辑不少，主要部分如下，有段调用父view进行刷新：

// Propagate the damage rectangle to the parent view.
final AttachInfo ai = mAttachInfo;
final ViewParent p = mParent;
if (p != null && ai != null && l < r && t < b) {
final Rect damage = ai.mTmpInvalRect;
damage.set(l, t, r, b);
p.invalidateChild(this, damage);
}

那ViewParent.invalidateChild实现是在哪里呢，猜到ViewGroup，发现其实现了ViewParent的接口，并且在ViewGroup.addView时添加子View的逻辑中会最后调用到`addViewInner方法：

private void addViewInner(View child, int index, LayoutParams params,
boolean preventRequestLayout) {

......

if (child.getParent() != null) {
throw new IllegalStateException("The specified child already has a parent. " +
"You must call removeView() on the child's parent first.");
}

if (mTransition != null) {
mTransition.addChild(this, child);
}

if (!checkLayoutParams(params)) {
params = generateLayoutParams(params);
}

if (preventRequestLayout) {
child.mLayoutParams = params;
} else {
child.setLayoutParams(params);
}

if (index < 0) {
index = mChildrenCount;
}

addInArray(child, index);

// tell our children
//设置父view
if (preventRequestLayout) {
child.assignParent(this);
} else {
child.mParent = this;
}

if (child.hasFocus()) {
requestChildFocus(child, child.findFocus());
}

.....
}

对child的ViewPrarent变量mParent进行赋值，把自己传递给子View,那么定位到ViewGroup对invalidateChild方法实现，发现里面有循环查找父View逻辑，如下：

do {
View view = null;
if (parent instanceof View) {
view = (View) parent;
}

**********
省略代码
// If the parent is dirty opaque or not dirty, mark it dirty with the opaque
**********
parent = parent.invalidateChildInParent(location, dirty);
if (view != null) {
// Account for transform on current parent
********
}
} while(parent!=null)

这个循环直到parent!=null才停止，那什么时候parent.invalidateChildInParent(location, dirty)会返回null呢。这里就要分析View树形结构了，布局结构中最上层的ViewParent是谁，什么时候赋值的。这个要从setContentView函数设置布局文件开始讲，有点长，但也许都是到布局的最顶层view就是DecorView(可以查源码)，那DecorView的ViewParent又是谁，这个就必须从添加decorView定位。参考http://blog.csdn.net/luoshengyang/article/details/6689748这边老罗的文章，分析应用启动以及View显示加载过程，从中可以知道在AMS通知PerformResumeActivity命令时开始显示界面，会调用activity的makeVisible（），该函数添加了mDecor(DecorView)

void makeVisible() {
if (!mWindowAdded) {
ViewManager wm = getWindowManager();
wm.addView(mDecor, getWindow().getAttributes());
mWindowAdded = true;
}
mDecor.setVisibility(View.VISIBLE);
}

ViewManager.addView的实现在WindowManagerGlobal的addView方法中：

会看到一个ViewRootImpl，看起来很想最最顶层 的View,查找源码发现：并发View,但是其实现了ViewParent，这就差不多连起来了，然后其调用了setView方法查看实现如下

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
synchronized (this) {
if (mView == null) {
mView = view;

************
很多代码省略
*************
view.assignParent(this);
mAddedTouchMode = (res & WindowManagerGlobal.ADD_FLAG_IN_TOUCH_MODE) != 0;
mAppVisible = (res & WindowManagerGlobal.ADD_FLAG_APP_VISIBLE) != 0;

************
很多代码省略
*************
}
}
}

发现 mView = view进行赋值，并调用assignParent(this)，把这个ViewParent实现付给DecorView，从持有父View。既然ViewRootImp实现了ViewParent，并且付给了DecorView，那在DecorView查找父parent时（parent.invalidateChildInParent(location, dirty)）就可以定位到ViewRootImpl实现了，找到ViewRootImp.invalidateChildInParent:发现终于返回了null，结束了循环。

@Override
public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
checkThread();
if (DEBUG_DRAW) Log.v(TAG, "Invalidate child: " + dirty);

if (mCurScrollY != 0 || mTranslator != null) {
mTempRect.set(dirty);
dirty = mTempRect;
if (mCurScrollY != 0) {
dirty.offset(0, -mCurScrollY);
}
if (mTranslator != null) {
mTranslator.translateRectInAppWindowToScreen(dirty);
}
if (mAttachInfo.mScalingRequired) {
dirty.inset(-1, -1);
}
}

invalidateRectOnScreen(dirty);

return null;
}

invalidateRectOnScreen(dirty);又调用了谁，继续定位

可以查源码分析就不一步步写了，schuduleTraversals（）调用是固定最后调用到performTraversals函数，这个是view绘制的源头开始处，代码很多，里面调用了mView.measure() mView.layout 、mView.draw等方法。终于差不多看到希望了，mView.draw()就是调用了DecorView的draw(),然后就把这个布局遍历绘制了一遍。那么走到执行动画的View的其父View绘制draw方法时候，会走到dispatchDraw，在View.draw(canvas)里面按步骤分别回执如下1、2、3、4、5、6步，其中有dispatchDraw来绘制子View。

public void draw(Canvas canvas) {
final int privateFlags = mPrivateFlags;
final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
(mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;

/*
* Draw traversal performs several drawing steps which must be executed
* in the appropriate order:
*
*      1. Draw the background
*      2. If necessary, save the canvas' layers to prepare for fading
*      3. Draw view's content
*      4. Draw children
*      5. If necessary, draw the fading edges and restore layers
*      6. Draw decorations (scrollbars for instance)
*/

ViewGroup重载了dispatchDraw，实现绘制子View的内容，源码如下：

protected void dispatchDraw(Canvas canvas) {
boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
final int childrenCount = mChildrenCount;
final View[] children = mChildren;
int flags = mGroupFlags;
//执行布局动画
if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate(){
final boolean buildCache = !isHardwareAccelerated();
for (int i = 0; i < childrenCount; i++) {
final View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
final LayoutParams params = child.getLayoutParams();
attachLayoutAnimationParameters(child, params, i, childrenCount);
bindLayoutAnimation(child);
}
}
final LayoutAnimationController controller = mLayoutAnimationController;
if (controller.willOverlap()) {
mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
}
controller.start();
mGroupFlags &= ~FLAG_RUN_ANIMATION;
mGroupFlags &= ~FLAG_ANIMATION_DONE;

if (mAnimationListener != null) {
mAnimationListener.onAnimationStart(controller.getAnimation());
}
}
*******省略部分代码 *********
// We will draw our child's animation, let's reset the flag

//more为true表示动画没有执行完
boolean more = false;
final long drawingTime = getDrawingTime();
*******省略部分代码 *********
for (int i = 0; i < childrenCount; i++) {
*******省略部分代码 *********
int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
final View child = (preorderedList == null) ? children[childIndex] :
preorderedList.get(childIndex);
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
//绘制子View，直接调用了child.draw(canvas, this(ViewParent), drawingTime);
// 动画真正执行地方
more |= drawChild(canvas, child, drawingTime);
}
}

*******省略部分代码 *********
// mGroupFlags might have been updated by drawChild()
flags = mGroupFlags;
if ((flags & FLAG_INVALIDATE_REQUIRED) == FLAG_INVALIDATE_REQUIRED) {
invalidate(true);
}
*******省略部分代码 *********
}

看到调用child.draw(Canvas canvas, ViewGroup parent, long drawingTime)，这个draw(canvas)函数不一样，不过前者又会调用到后者。看下child.draw(Canvas canvas, ViewGroup parent, long drawingTime)是如何执行动画调用到animattion.applyTransformation()对Matrix进行矩阵变化，源码如下：

boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {

****************省略部分代码 ***************
boolean more = false;
Transformation transformToApply = null;
boolean concatMatrix = false;
final boolean scalingRequired = mAttachInfo != null && mAttachInfo.mScalingRequired;
final Animation a = getAnimation();//获取ziView的动画，在View.startAnimation是就开始赋值了。
if (a != null) {
more = applyLegacyAnimation(parent, drawingTime, a, scalingRequired);
concatMatrix = a.willChangeTransformationMatrix();
if (concatMatrix) {
mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM;
}
transformToApply = parent.getChildTransformation();// a.applyLegacyAnimation进行赋值
} else {
****************省略代码 ***************
}
****************省略代码 ***************
if (transformToApply != null || alpha < 1 || !
hasIdentityMatrix() || (mPrivateFlags3 & PFLAG3_VIEW_IS_ANIMATING_ALPHA) != 0) {
if (transformToApply != null || !childHasIdentityMatrix) {
int transX = 0;
int transY = 0;
if (offsetForScroll) {
transX = -sx;
transY = -sy;
}
if (transformToApply != null) {
if (concatMatrix) {
if (drawingWithRenderNode) {
renderNode.setAnimationMatrix(transformToApply.getMatrix());
} else {
// Undo the scroll translation, apply the transformation matrix,                        // then redo the scroll translate to get the correct result.
canvas.concat(transformToApply.getMatrix());//传递给canvas进行矩阵实现动画
canvas.translate(transX, transY);
}
parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION;
}
float transformAlpha = transformToApply.getAlpha();
if (transformAlpha < 1) {
alpha *= transformAlpha;
parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION;
}
}
if (!childHasIdentityMatrix && !drawingWithRenderNode) {
canvas.translate(-transX, -transY);
canvas.concat(getMatrix());
canvas.translate(transX, transY);
}
}
****************省略代码 ***************
return more;
}

在这么代码中动画animation判断不为空之后，进入more = applyLegacyAnimation(parent, drawingTime, a, scalingRequired);，这里面传入了animation,有没有对动画执行操作呢，如下源码：

private boolean applyLegacyAnimation(ViewGroup parent, long drawingTime,
Animation a, boolean scalingRequired) {
Transformation invalidationTransform;
*********省略部分代码 **********
final Transformation t = parent.getChildTransformation();
boolean more = a.getTransformation(drawingTime, t, 1f);///调用了Animation的
///getTransformation方法，这个方法进而调用了applyTransformation
if (scalingRequired && mAttachInfo.mApplicationScale != 1f) {
if (parent.mInvalidationTransformation == null) {
parent.mInvalidationTransformation = new Transformation();
}
invalidationTransform = parent.mInvalidationTransformation;
a.getTransformation(drawingTime, invalidationTransform, 1f);
} else {
invalidationTransform = t;
}
if (more) {//为true又重新刷新，调用viewparent.invalidate
if (!a.willChangeBounds()) {
if ((flags & (ViewGroup.FLAG_OPTIMIZE_INVALIDATE | ViewGroup.FLAG_ANIMATION_DONE))
== ViewGroup.FLAG_OPTIMIZE_INVALIDATE) {
parent.mGroupFlags |= ViewGroup.FLAG_INVALIDATE_REQUIRED;
} else if ((flags & ViewGroup.FLAG_INVALIDATE_REQUIRED) == 0) {
// The child need to draw an animation, potentially offscreen, so
// make sure we do not cancel invalidate requests
parent.mPrivateFlags |= PFLAG_DRAW_ANIMATION;
parent.invalidate(mLeft, mTop, mRight, mBottom);
}
} else {
if (parent.mInvalidateRegion == null) {
parent.mInvalidateRegion = new RectF();
}
final RectF region = parent.mInvalidateRegion;
a.getInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop,
region, invalidationTransform);
// The child need to draw an animation, potentially offscreen, so
// make sure we do not cancel invalidate requests
parent.mPrivateFlags |= PFLAG_DRAW_ANIMATION;
final int left = mLeft + (int) region.left;
final int top = mTop + (int) region.top;
parent.invalidate(left, top, left + (int) (region.width() + .5f),
top + (int) (region.height() + .5f));//重新刷新
}
}
return more;
}

从 view.applyLegacyAnimation()源码可以看到调用了animation.getChildTransformation（）并通过返回的boolean值覆盖more变量，并且同时把对传入animation.getTransformation(drawingTime, t, 1f)中的transformToApply（parent.getChildTransformation()获取）进行变化矩阵，当more为true,看到又调用父View parent.invalidate()，重新刷新view树进行再一次绘制剩余动画内容。当applyLegacyAnimation执行完成之后draw(Canvas canvas, ViewGroup parent, long drawingTime)里面继续transformToApply = parent.getChildTransformation()获取变化之后transformToApply，若不为空，又传递给canvas.concat(transformToApply.getMatrix())来对canvas进行矩阵变化操作，从而对绘制的view内容发生动画。

到这里就讲完了view tween动画的执行原理