View Animation 运行原理解析

Android 平台目前提供了两大类动画，在 Android 3.0 之前，一大类是 View Animation，包括 Tween animation（补间动画），Frame animation（帧动画），在 Android 3.0 中又引入了一个新的动画系统：Property Animation，即属性动画。本篇文章主要介绍 View Animation 的运行原理。

View Animation 可以使视图执行补间动画。即给定两个关键帧，然后中间部分按照一定的算法自动计算补充。

补间动画的继承关系：

下面看一个示例，比如想要对透明度做一个变化：

Animation alphaAnimation = new AlphaAnimation(1,0);
alphaAnimation.setDuration(1000);
imageView.startAnimation(alphaAnimation);      

 那么这个动画是如何实现的呢，下面就要讲述其实现原理。 

为了探究补间动画的实现原理，需要对相关源码进行解读，源码版本为 Android API 29 Platform。在解读之前，大家可以试着回答下面这些问题。

1. 为什么移动位置后，点击事件的响应依旧是在原来位置上？
2. 如果想知道动画的执行进度，是如何获取呢？
3. 如果对 View 做放大缩小得动画，那么其宽度高度值是否会变化。

相关类介绍

下面开始源码分析。首先看下基类 Animation。

public abstract class Animation implements Cloneable {

}      

Animation 是一个抽象类，里面包含了各种动画相关的属性（时长，起始时间，重复次数，插值器等），回调(listeners)。该类整体比较简单，大家直接看源码就好。

alphaAnimation

下面来看下 Animation 子类，为了方便，本次就只说说 AlphaAnimation。

public class AlphaAnimation extends Animation {
    private float mFromAlpha;
    private float mToAlpha;

    /**
     * Constructor used when an AlphaAnimation is loaded from a resource. 
     * 
     * @param context Application context to use
     * @param attrs Attribute set from which to read values
     */
    public AlphaAnimation(Context context, AttributeSet attrs) {
        super(context, attrs);
        
        TypedArray a =
            context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AlphaAnimation);
        
        mFromAlpha = a.getFloat(com.android.internal.R.styleable.AlphaAnimation_fromAlpha, 1.0f);
        mToAlpha = a.getFloat(com.android.internal.R.styleable.AlphaAnimation_toAlpha, 1.0f);
        
        a.recycle();
    }
    
    /**
     * Constructor to use when building an AlphaAnimation from code
     * 
     * @param fromAlpha Starting alpha value for the animation, where 1.0 means
     *        fully opaque and 0.0 means fully transparent.
     * @param toAlpha Ending alpha value for the animation.
     */
    public AlphaAnimation(float fromAlpha, float toAlpha) {
        mFromAlpha = fromAlpha;
        mToAlpha = toAlpha;
    }
    
    /**
     * Changes the alpha property of the supplied {@link Transformation} 
　　　* 实现动画的关键函数，这里通过当前的播放进度，计算当前的透明度，然后将其赋值给 Transformation 实例
     */
    @Override
    protected void applyTransformation(float interpolatedTime, Transformation t) {
        final float alpha = mFromAlpha;
        t.setAlpha(alpha + ((mToAlpha - alpha) * interpolatedTime));
    }

    @Override
    public boolean willChangeTransformationMatrix() {
        return false;
    }

    @Override // 不改变边界
    public boolean willChangeBounds() {
        return false;
    }

    /**
     * @hide
     */
    @Override
    public boolean hasAlpha() {
        return true;
    }
}      

整个代码也是很简单，其实很多逻辑都在基类处理了。然后子类只需要重写一些和自己动画相关的方法就好。其中 applyTransformation 是实现某一种动画的关键，每个子类都必须重写。

这里需要注意的是，Transformation 就是用来存储每一次动画的参数。其中平移，旋转，缩放都是通过改变 Matrix 实现的，而透明度则是改变 Alpha 值实现的。

为了便于大家进一步理解，可以在看看 AnimationSet。

AnimationSet

因为 AnimationSet 是其他几个子类得集合体，所以看看它的代码逻辑还是可以发现一些不一样的。其内部代码比较多，就不贴出来了。只是挑一部分讲下：

/**
     * Add a child animation to this animation set.
     * The transforms of the child animations are applied in the order
     * that they were added
     * @param a Animation to add.
     */
    public void addAnimation(Animation a) {
　　　　　// 数组来保存动画
        mAnimations.add(a);

        boolean noMatrix = (mFlags & PROPERTY_MORPH_MATRIX_MASK) == 0;
        if (noMatrix && a.willChangeTransformationMatrix()) {
            mFlags |= PROPERTY_MORPH_MATRIX_MASK;
        }

        boolean changeBounds = (mFlags & PROPERTY_CHANGE_BOUNDS_MASK) == 0;

        if (changeBounds && a.willChangeBounds()) {
            mFlags |= PROPERTY_CHANGE_BOUNDS_MASK;
        }

        if ((mFlags & PROPERTY_DURATION_MASK) == PROPERTY_DURATION_MASK) {
            mLastEnd = mStartOffset + mDuration;
        } else {
            if (mAnimations.size() == 1) {
                mDuration = a.getStartOffset() + a.getDuration();
                mLastEnd = mStartOffset + mDuration;
            } else {
                mLastEnd = Math.max(mLastEnd, mStartOffset + a.getStartOffset() + a.getDuration());
                mDuration = mLastEnd - mStartOffset;
            }
        }

        mDirty = true;
    }


    /**
     * The transformation of an animation set is the concatenation of all of its
     * component animations.
     *
     * @see android.view.animation.Animation#getTransformation
　　　* true 表示动画还在运行
     */
    @Override
    public boolean getTransformation(long currentTime, Transformation t) {
        final int count = mAnimations.size();
        final ArrayList<Animation> animations = mAnimations;
        final Transformation temp = mTempTransformation;

        boolean more = false;
        boolean started = false;
        boolean ended = true;

        t.clear();

        for (int i = count - 1; i >= 0; --i) {
            final Animation a = animations.get(i);
　　　　　　　// 清除上一个的数据
            temp.clear();
　　　　　　　// 通过 temp 来获取每个 Animation 的 transformation
            more = a.getTransformation(currentTime, temp, getScaleFactor()) || more;
　　　　　　　// 将各种动画参数组合在一起，注意 t 是引用对象，所以这里改了之后，外面拿到的也是改了的。
            t.compose(temp);

            started = started || a.hasStarted();
            ended = a.hasEnded() && ended;
        }
　　　　　// 是否开始了
        if (started && !mStarted) {
            dispatchAnimationStart();
            mStarted = true;
        }

        if (ended != mEnded) {
            dispatchAnimationEnd();
            mEnded = ended;
        }

        return more;
    }      

上面是 AnimationSet 中我认为两个比较重要的方法：

• addAnimation：将其他动画类型添加到 set 里面，内部实际上是通过一个 list 来保存的。然后将每个动画的各种属性都记录下。
• getTransformation：获取每个动画的下一个动画参数，然后将其组合在一起。

前面介绍了 Animation 一些背景知识。到这里，大家多少会有一些认识了。接下去就按照调用流程来分析动画的执行。

源码解析

View.startAnimation()

public void startAnimation(Animation animation) {
　　　　　// 传入的值是-1，代表准备动画了
        animation.setStartTime(Animation.START_ON_FIRST_FRAME);
        setAnimation(animation);
        invalidateParentCaches();  // 给 parent 的 mPrivateFlag 加了一个 PFLAG_INVALIDATED
        invalidate(true);  // 其目的就是将其和子 view 的 drawing 缓存都标记为无效,然后可以 redrawn
    }

    public void setAnimation(Animation animation) {
　　　　　// View 中有个属性是用来存储当前的 Animation 的
        mCurrentAnimation = animation;

        if (animation != null) {
            // If the screen is off assume the animation start time is now instead of
            // the next frame we draw. Keeping the START_ON_FIRST_FRAME start time
            // would cause the animation to start when the screen turns back on
            if (mAttachInfo != null && mAttachInfo.mDisplayState == Display.STATE_OFF
                    && animation.getStartTime() == Animation.START_ON_FIRST_FRAME) {
                animation.setStartTime(AnimationUtils.currentAnimationTimeMillis());
            }
            animation.reset();
        }
    }      

 简而言之 startAnimation 主要是做这么几件事情：

1. 开始动画前，先告知 Animation，可以做一些准备，包括部分参数的赋值；
2. 更新 View 自身的 Animation 的属性值；
3. 给父 View 的 mPrivateFlag 加上 PFLAG_INVALIDATED 属性；
4. 将自身和子 view 的 draw cache 都标记为无效的，通过 父 View 调用 invalidateChild 促发 redrawn；

ViewGroup.invalidateChild

下面看下 invalidateChild 是怎么促发重绘的：

// ViewGroup    
 public final void invalidateChild(View child, final Rect dirty) {
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null && attachInfo.mHardwareAccelerated) {
            // HW accelerated fast path
            onDescendantInvalidated(child, child);
            return;
        }

        ViewParent parent = this;
        if (attachInfo != null) {
           //  ..... 省略非关键性代码 

            do { // 无限循环
                View view = null;
                if (parent instanceof View) {
                    view = (View) parent;
                }

                if (drawAnimation) {
                    if (view != null) {
                        view.mPrivateFlags |= PFLAG_DRAW_ANIMATION;
                    } else if (parent instanceof ViewRootImpl) {
                        ((ViewRootImpl) parent).mIsAnimating = true;
                    }
                }

                // If the parent is dirty opaque or not dirty, mark it dirty with the opaque
                // flag coming from the child that initiated the invalidate
                if (view != null) {
                    if ((view.mPrivateFlags & PFLAG_DIRTY_MASK) != PFLAG_DIRTY) {
                        view.mPrivateFlags = (view.mPrivateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DIRTY;
                    }
                }
　　　　　　　　　 // 最终调用的是该方法来重绘
                parent = parent.invalidateChildInParent(location, dirty);
                //  .... 省略非关键性代码 
            } while (parent != null);  // 终止条件是找不到父 View 了。
        }
    }      

这里很主要的一件事，找到 rooView ，然后调用了 invalidateChildInParent 方法。这里的 rootView 其实就是 ViewRootImpl，至于为啥不是 DecorVIew，这个可以去看看这篇文章：

Android View 绘制流程之 DecorView 与 ViewRootImpl

ViewRootImpl.invalidateChildInParent

@Override
    public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
        checkThread();  // 检查是否是主线程
        if (DEBUG_DRAW) Log.v(mTag, "Invalidate child: " + dirty);

        if (dirty == null) {  // 从上面路径来看，这里是不可能为空的
            invalidate();  
            return null;
        } else if (dirty.isEmpty() && !mIsAnimating) {
            return null;
        }

        // ... 跳过一段无关的代码

        invalidateRectOnScreen(dirty);
        return null;
    }      

这里可以看出的是，最终会调用 invalidateRectOnScreen 方法。

ViewRootImpl.invalidateRectOnScreen

private void invalidateRectOnScreen(Rect dirty) {
        final Rect localDirty = mDirty;

        // Add the new dirty rect to the current one 其实就是把两个矩阵融合在一起
        localDirty.union(dirty.left, dirty.top, dirty.right, dirty.bottom);
        // Intersect with the bounds of the window to skip
        // updates that lie outside of the visible region
        final float appScale = mAttachInfo.mApplicationScale;
　　　　  // 主要就是检查菊矩阵边界对不对
        final boolean intersected = localDirty.intersect(0, 0,
                (int) (mWidth * appScale + 0.5f), (int) (mHeight * appScale + 0.5f)); 
　　　　  // 边界不对，就会直接置空
        if (!intersected) {
            localDirty.setEmpty();
        }
　　　　　// mWillDrawSoon 是当前是否马上就要开始绘制了，如果开始绘制，就不去发起绘制了
        if (!mWillDrawSoon && (intersected || mIsAnimating)) {
            scheduleTraversals();
        }
    }      

 invalidateRectOnScreen 主要是就是把 dirty 这个矩阵和已有的进行融合，然后再看看需不需要发起刷新。

scheduleTraversals()

作用是将

performTraversals()

封装到一个 Runnable 里面，然后扔到 Choreographer 的待执行队列里，这些待执行的 Runnable 将会在最近的一个 16.6 ms 屏幕刷新信号到来的时候被执行。而

performTraversals()

是 View 的三大操作：测量、布局、绘制的发起者。

小结：

当调用了 View.startAniamtion() 之后，动画并没有马上就被执行，这个方法只是做了一些变量初始化操作，接着将 View 和 Animation 绑定起来，然后调用重绘请求操作，内部层层寻找 mParent，最终走到 ViewRootImpl 的 scheduleTraversals 里发起一个遍历 View 树的请求，这个请求会在最近的一个屏幕刷新信号到来的时候被执行，调用 performTraversals 从根布局 DecorView 开始遍历 View 树。

开始动画

前面说到了动画的开始最终是通过促发 View 绘制来形成的。此处不会再讲 View 的绘制原理，不懂得可以看下面两篇文章：

• Android View 的绘制流程之 Measure 过程详解 (一)

• Android View 的绘制流程之 Layout 和 Draw 过程详解 (二)

那么在 View  绘制过程中，是在哪里开始绘制的呢? 答案是 View 的 draw 方法里面开始的。

但是这个 draw 不是我们自定义 view 时常见的 draw 方法，该 draw 方法有三个参数，是用于 View 自身绘制用的。

View.draw

该方法比较长，截取部分来讲：

/**
     * This method is called by ViewGroup.drawChild() to have each child view draw itself.
     *
     * This is where the View specializes rendering behavior based on layer type,
     * and hardware acceleration.
     */
    boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
　　　　　// 用于判断是否支持硬件加速
        final boolean hardwareAcceleratedCanvas = canvas.isHardwareAccelerated();
        /* If an attached view draws to a HW canvas, it may use its RenderNode + DisplayList.
         *
         * If a view is dettached, its DisplayList shouldn't exist. If the canvas isn't
         * HW accelerated, it can't handle drawing RenderNodes.
         */
        boolean drawingWithRenderNode = mAttachInfo != null
                && mAttachInfo.mHardwareAccelerated
                && hardwareAcceleratedCanvas;

        boolean more = false;
        // ..... 跳过一些代码

　　　　 // 获取之前存储的 animation
　　　　 final Animation a = getAnimation();
        if (a != null) {
　　　　　　　// 不为空就说明是有动画的
            more = applyLegacyAnimation(parent, drawingTime, a, scalingRequired);
            concatMatrix = a.willChangeTransformationMatrix();
            if (concatMatrix) {
                mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM;
            }
　　　　　　　// 这里是拿到动画参数，后面会再次讲到
            transformToApply = parent.getChildTransformation();
        }

        // ...... 省略代码
}      

首先来看这个 draw 方法的三个参数：

1. canvas：这个没有什么好分析的，是用来绘制用的
2. parent：这个其实就是父 View，方便获取一些数据；
3. drawingTime：这个很重要，就是当前的绘制时间，后续做动画的时候，会计算时间差，然后更新插值器；

一进到 draw 方法，就先获取当前是否支持硬件加速。有硬件加速和没有硬件加速走的是两套逻辑。然后是获取保之前存储的 animation。

View.applyLegacyAnimation

接着调用 applyLegacyAnimation 开始处理动画相关的逻辑。下面看下其方法内部的逻辑。

/**
     * Utility function, called by draw(canvas, parent, drawingTime) to handle the less common
     * case of an active Animation being run on the view.
     */
    private boolean applyLegacyAnimation(ViewGroup parent, long drawingTime,
            Animation a, boolean scalingRequired) {
　　　　　// 用于保存此时重绘的变换
        Transformation invalidationTransform;
        final int flags = parent.mGroupFlags;
        final boolean initialized = a.isInitialized();
　　　　　// 判断动画有没有开始初始化，没有的化先进行初始化
        if (!initialized) {
            a.initialize(mRight - mLeft, mBottom - mTop, parent.getWidth(), parent.getHeight());
            a.initializeInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop);
            if (mAttachInfo != null) a.setListenerHandler(mAttachInfo.mHandler);
　　　　　　　// 同时调用开始动画回调
            onAnimationStart();
        }
　　　　　// 这里是从父类中获取当前的t，但是如果一个父类存在多个子 view 需要运动，那获取的岂不是一样了？其实每个子view 都会重新赋值，不会影响。
        final Transformation t = parent.getChildTransformation();
　　　　　// 这里是根据时间，t, 缩放因子来计算 t,这里 t 是一个对象，在 animation 中进行赋值后，在这里也可以用到
        boolean more = a.getTransformation(drawingTime, t, 1f);
　　　　　// 对于需要缩放的子view,需要重新计算t,可是调用方法确是一样的？那结果有啥不一样吗？这里是为了将缩放和不缩放的 t 分出来
        if (scalingRequired && mAttachInfo.mApplicationScale != 1f) {
            if (parent.mInvalidationTransformation == null) {
                parent.mInvalidationTransformation = new Transformation();
            }
            invalidationTransform = parent.mInvalidationTransformation;
            a.getTransformation(drawingTime, invalidationTransform, 1f);
        } else {
            invalidationTransform = t;
        }
　　　　　// more 为 true ，代表动画还未结束
        if (more) {
            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;
　　　　　　　　　　// region 此时是更新尺寸后的范围了
                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;
    }      

这个方法其实理解起来也很简单，主要就是为了得到一个根据当前时间计算得到 Transformation 实例，里面包含了下一次动画所需要的信息。

Transformation 里面的内容如下：

Transformation

public class Transformation {
    /**
     * Indicates a transformation that has no effect (alpha = 1 and identity matrix.)
     */
    public static final int TYPE_IDENTITY = 0x0;
    /**
     * Indicates a transformation that applies an alpha only (uses an identity matrix.)
     */
    public static final int TYPE_ALPHA = 0x1;
    /**
     * Indicates a transformation that applies a matrix only (alpha = 1.)
     */
    public static final int TYPE_MATRIX = 0x2;
    /**
     * Indicates a transformation that applies an alpha and a matrix.
     */
    public static final int TYPE_BOTH = TYPE_ALPHA | TYPE_MATRIX;
　　 // 矩阵，控制缩放，平移，旋转
    protected Matrix mMatrix;
　　 // 透明度
    protected float mAlpha;
    protected int mTransformationType;

    private boolean mHasClipRect;
    private Rect mClipRect = new Rect();

  // ...... 省略一大串代码  
}      

上述代码还省略很多方法，其实都是对矩阵的操作。

这里提一下：Matrix 方法中的 setRotate() 方法会先清除该矩阵，即设为单位矩阵。之后设置旋转操作的，同样，setTranslate() 等方法也是一样的。所以是不能叠加各种效果在一起的.如果是想多种效果同时使用的话，postRotate()，postTranslate()等类似的矩阵变换方法吧。

想进一步了解的可直接阅读代码。

下面讲下是如何获取 Transformation 的。

Animation.getTransformation

public boolean getTransformation(long currentTime, Transformation outTransformation) {
　　　　　// 等于-1，说明是刚开始动画，记录第一帧动画时间
        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;
　　　　　// 确保动画在 0-1 之间
        if (!mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);

        if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) {
            if (!mStarted) {
　　　　　　　　　　// 通知动画开始了。onAnimationStart 就是在这里被调用
                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);
　　　　　　　// 这里 out 前缀就是这个是要传出去的，这个方法每个 Animation 子类都要自己实现，然后其实我们可以重写这个方法，把进度传出去你就知道当前动画的进度了
            applyTransformation(interpolatedTime, outTransformation);
        }
　　　　　// 如果动画被取消或者已经完成了
        if (expired) {
            if (mRepeatCount == mRepeated || isCanceled()) {
                if (!mEnded) {
                    mEnded = true;
                    guard.close();
　　　　　　　　　　　　// 这里就是 onAnimationEnd 调用的地方
                    fireAnimationEnd();
                }
            } else {
　　　　　　　　　　// else 说明动画是重复的，这是需要计算重复次数，还有是不是无限循环的
                if (mRepeatCount > 0) {
                    mRepeated++;
                }

                if (mRepeatMode == REVERSE) {
                    mCycleFlip = !mCycleFlip;
                }

                mStartTime = -1;
                mMore = true;
　　　　　　　　　　// 这里就是 onAnimationRepeat 调用的地方
                fireAnimationRepeat();
            }
        }

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

        return mMore;
    }      

getTransformation 主要就是管理动画状态的。到底是开始（记录开始时间），还是正在进行（计算进度），还是已经结束了（通知结束了）。

其中调用的 applyTransformation，每个 Animation 子类都要自己实现，然后其实我们可以重写这个方法，把进度传出去你就知道当前动画的进度了。子类其实是把最后的计算结果保存在 Transformation 里面了，这样就拿到了下一帧动画参数。

还有大家平时用到的 AnimationListener 也是在这里进行通知回调的。

那拿到 Transformation 后，是怎么用的呢，这个就得 回到 view.draw 方法了。

view.draw

前面讲到了 Transformation 其实是从 parent 中获取，赋值给 transformToApply；

boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {   
         // ...... 省略一大部分代码
        float alpha = drawingWithRenderNode ? 1 : (getAlpha() * getTransitionAlpha());
　　　　　// 下面这个if 会进入动画的真正的绘制时期
        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) {
　　　　　　　　　　　　　　 // 为TRUE，代表是使用硬件加速来进行绘制
                        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.translate(-transX, -transY);
                            canvas.concat(transformToApply.getMatrix());
                            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);
                }
            }

            // Deal with alpha if it is or used to be <1
            if (alpha < 1 || (mPrivateFlags3 & PFLAG3_VIEW_IS_ANIMATING_ALPHA) != 0) {
                if (alpha < 1) {
                    mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_ALPHA;
                } else {
                    mPrivateFlags3 &= ~PFLAG3_VIEW_IS_ANIMATING_ALPHA;
                }
                parent.mGroupFlags |= ViewGroup.FLAG_CLEAR_TRANSFORMATION;
                if (!drawingWithDrawingCache) {
                    final int multipliedAlpha = (int) (255 * alpha);
                    if (!onSetAlpha(multipliedAlpha)) {
                        if (drawingWithRenderNode) {
                            renderNode.setAlpha(alpha * getAlpha() * getTransitionAlpha());
                        } else if (layerType == LAYER_TYPE_NONE) {
                            canvas.saveLayerAlpha(sx, sy, sx + getWidth(), sy + getHeight(),
                                    multipliedAlpha);
                        }
                    } else {
                        // Alpha is handled by the child directly, clobber the layer's alpha
                        mPrivateFlags |= PFLAG_ALPHA_SET;
                    }
                }
            }
        } else if ((mPrivateFlags & PFLAG_ALPHA_SET) == PFLAG_ALPHA_SET) {
            onSetAlpha(255);
            mPrivateFlags &= ~PFLAG_ALPHA_SET;
        }              

那么对于 AnimationSet 又是如何处理的呢？

首先他也是继承了了 Animation，其次，它有个数组装门用来存放 Animation 集合。也是通过  getTransformation 来获取Transformation的。

AnimationSet.

public boolean getTransformation(long currentTime, Transformation t) {
        final int count = mAnimations.size();
        final ArrayList<Animation> animations = mAnimations;
        final Transformation temp = mTempTransformation;

        boolean more = false;
        boolean started = false;
        boolean ended = true;

        t.clear();

        for (int i = count - 1; i >= 0; --i) {
            final Animation a = animations.get(i);

            temp.clear();
            more = a.getTransformation(currentTime, temp, getScaleFactor()) || more;
            t.compose(temp);

            started = started || a.hasStarted();
            ended = a.hasEnded() && ended;
        }

        if (started && !mStarted) {
            dispatchAnimationStart();
            mStarted = true;
        }

        if (ended != mEnded) {
            dispatchAnimationEnd();
            mEnded = ended;
        }

        return more;
    }      

通过 for 循环，依次获取对应的 annimation 的矩阵，然后再将矩阵效果合到一起。

到此，对于 动画应该是有自己的认识了。 View Animation 的整个执行逻辑也就讲完了。

总结

那么这里回答开头的三个问题：

因为动画是在 draw 时候形成的，也就是说只是视觉效果。其并没有改变它本身在父类中的位置；

继承 Animation 对应的子类，然后重写 applyTransformation 方法，就可以从中获取到进度。

动画发生在 draw 时期，并不会改变测量结果

View Animation 是在绘制的时候，改变 view 的视觉效果来实现动画的。所以不会对 view 的测量和布局过程有影响。

View 的动画是通过触发绘制过程来执行 draw 的。因为动画是连续的，所以需要不停的触发。

参考文章：

View 动画 Animation 运行原理解析

树林美丽、幽暗而深邃，但我有诺言尚待实现，还要奔行百里方可沉睡。 -- 罗伯特·弗罗斯特