源码分析视图动画是如何实现的

我们知道视图动画的启动方式如下：

ImageView image = (ImageView) findViewById(R.id.image);
Animation hyperspaceJump = AnimationUtils.loadAnimation(this, R.anim.hyperspace_jump);
image.startAnimation(hyperspaceJump);

也即从调用view.java类的startAnimation()函数开始，我们先分析如下的函数，drawAnimation()函数是真正通过不断的刷新视图内容绘制一个动态的视图的地方，怎么从startAnimation()到drawAnimation()我们后面再讲，我们的重点是放在视图动画的绘制原理上。

private boolean drawAnimation(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);//初始化了一个矩形区域，mRight,mLeft,mBottom,mTop是根据该View得到的区域参数
            if (mAttachInfo != null) a.setListenerHandler(mAttachInfo.mHandler);
            onAnimationStart();
        }

        boolean more = a.getTransformation(drawingTime, parent.mChildTransformation, 1f);//第一个重要函数，后面源码分析，这里我们关注parent.mChildTransformation这个参数
        if (scalingRequired && mAttachInfo.mApplicationScale != 1f) {
            if (parent.mInvalidationTransformation == null) {
                parent.mInvalidationTransformation = new Transformation();
            }
            invalidationTransform = parent.mInvalidationTransformation;
            a.getTransformation(drawingTime, invalidationTransform, 1f);//比较这个if-else，不管走if还是else,我们可以看到它都走了a.getTransformation这个函数。
        } else {
            invalidationTransform = parent.mChildTransformation;//不管是if，还是else，invalidationTransform的值都来自于对getTransformation的调用
        }

        if (more) {
            if (!a.willChangeBounds()) {//除了alphaAnimation，其它的该函数都return true
                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);//对于AlphaAnimation，视图大小没有任何变化
                }
            } else {
                if (parent.mInvalidateRegion == null) {
                    parent.mInvalidateRegion = new RectF();
                }
                final RectF region = parent.mInvalidateRegion;
                a.getInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop, region,
                        invalidationTransform);//第二个重要函数，举行参数region动态的得到了下一桢的区域大小

                // 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值不断的更新得到新的区域值
                final int top = mTop + (int) region.top;
                parent.invalidate(left, top, left + (int) (region.width() + .5f),//绘制，并刷新下一桢，得到下一个区域大小。
                        top + (int) (region.height() + .5f));
            }
        }
        return more;
    }

通过上面这个函数可以了解到，视图通过不断的刷新并得到Animation提供的视图区域的大小的参数而绘制出动态视图。下面来看看上面提到的两个重要函数，通过这两个函数，可以看出Animation是如何提供动态的区域参数的。

   /**
     * Gets the transformation to apply at a specified point in time. Implementations of this
     * method should always replace the specified Transformation or document they are doing
     * otherwise.
     *
     * @param currentTime Where we are in the animation. This is wall clock time.
     * @param outTransformation A transformation object that is provided by the
     *        caller and will be filled in by the animation.
     * @return True if the animation is still running
     */

//上面的这段注释清晰的说明了这个函数的功能————在某个指定的时间点获取一个Transformation对象

 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;
        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 (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);//插值器，提供不同的时间点
            applyTransformation(interpolatedTime, outTransformation);
        }
...
    }

所有继承自Animation类的函数都需要重写applyTransformation()函数，正是在这个函数中，指定的不同的动画效果所需要的变化。我们以TranslateAnimation的该函数作为示例：

    protected void applyTransformation(float interpolatedTime, Transformation t) {
        float dx = mFromXDelta;
        float dy = mFromYDelta;
        if (mFromXDelta != mToXDelta) {
            dx = mFromXDelta + ((mToXDelta - mFromXDelta) * interpolatedTime);
        }
        if (mFromYDelta != mToYDelta) {
            dy = mFromYDelta + ((mToYDelta - mFromYDelta) * interpolatedTime);
        }
        t.getMatrix().setTranslate(dx, dy);
    }

Transformation.java类中有两个属性：Matrix和Alpha(float)，以及一些改变这两个属性值的方法。上面这里还有一个疑问，就是插值器是如何工作的，留到后面再做解释，我们先看看第二个重要函数，即动态的得到了上面的Transformation对象后是如何得到动态绘制区域的。

    public void getInvalidateRegion(int left, int top, int right, int bottom,
            RectF invalidate, Transformation transformation) {

        final RectF tempRegion = mRegion;
        final RectF previousRegion = mPreviousRegion;

        invalidate.set(left, top, right, bottom);
        transformation.getMatrix().mapRect(invalidate);
        // Enlarge the invalidate region to account for rounding errors
        invalidate.inset(-1.0f, -1.0f);
        tempRegion.set(invalidate);
        invalidate.union(previousRegion);

        previousRegion.set(tempRegion);

        final Transformation tempTransformation = mTransformation;
        final Transformation previousTransformation = mPreviousTransformation;

        tempTransformation.set(transformation);
        transformation.set(previousTransformation);
        previousTransformation.set(tempTransformation);
    }

根据上面这些代码，可以窥见到Animation.java是如何影响到view不停刷新绘制，从而得到动态效果的。下面解释前面的一些疑问：

先来看看插值器的工作原理

public class AccelerateInterpolator implements Interpolator {
    private final float mFactor;
    private final double mDoubleFactor;
    
    public AccelerateInterpolator(Context context, AttributeSet attrs) {
        TypedArray a =
            context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AccelerateInterpolator);
        
        mFactor = a.getFloat(com.android.internal.R.styleable.AccelerateInterpolator_factor, 1.0f);
        mDoubleFactor = 2 * mFactor;

        a.recycle();
    }
    
    public float getInterpolation(float input) {
        if (mFactor == 1.0f) {
            return input * input;
        } else {
            return (float)Math.pow(input, mDoubleFactor);//Math.pow(x, y)——计算x的y次方
        }
    }
}

插值器的内容很简单，只需要实现getInterpolation(float input)这个接口即可，这个接口的输入input是根据当前时间得到的一个值，每次刷新得到的值不同，因此输出也就成了一个动态值。因此我们可以得知插值器的原理——输出是时间输入的函数。知晓这个原理，我们就可以编写自己的插值器。下面的内容是前面出现的getTransformation()中的interpolatedTime，也就是input。从下面的这段代码中，我们可以看见它是和当前时间currentTime相关的。

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