从源码的角度分析Android动画运行原理

一.概述

首先说说动画的运行模式，一共有两种模式：

• 独占模式，即程序主线程进入一个循环，根据动画指令不断刷新屏幕，直到动画结束；
• 中断模式，即有单独一个线程对时间计数，每隔一定的时间向主线程发通知，主线程接到通知后更新屏幕；

接下来我们看看动画的运行原理，一般情况下我们会调用使用如下的方式开启动画：

  AlphaAnimation animation = new AlphaAnimation(0,1f);
        animation.setDuration(200);
        animation.setFillAfter(true);
        button.startAnimation(animation);

重点在startAnimation这个方法，这个方法是在哪定义的呢？是在所有控件的父类，View中，所以我们去View的源码中看看。

二.源码分析

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

首先给animation设置了一个起始时间START_ON_FIRST_FRAME，这个值是Animation类中定义的一个常量，值为-1，然后调用View中的setAnimation传入我们的动画对象，

public void setAnimation(Animation 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();
        }
    }

在setAnimation方法里面，我们的animation对象会赋值给mCurrentAnimation这样一个全局变量，然后进行了判断，满足条件的话又重新设置了动画的时间，

public static long currentAnimationTimeMillis() {
        return SystemClock.uptimeMillis();
    }

这里返回了一个系统时间。然后调用reset方法重置动画为初始状态。
也就是说setAnimation主要做了两件事。第一件事就是设置动画起始时间，第二件事是重置动画状态。

最后调用invalidata方法重绘自己。

既然调用了setAnimation设置动画，那么应该有getAnimation来获取动画吧，最后我们在View的draw(Canvas canvas, ViewGroup parent, long drawingTime)里面发现了getAnimation这个方法。

  Transformation transformToApply = null;
        boolean concatMatrix = false;
        final boolean scalingRequired = mAttachInfo != null && mAttachInfo.mScalingRequired;
        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();

public Animation getAnimation() {
        return mCurrentAnimation;
    }

这个getAnimation方法返回的正是我们定义的动画对象，因为我们之前在setAniamation方法中，将动画对象赋值给了这个全局变量。

接下来有调用了applyLegacyAnimation这个方法，

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

        final Transformation t = parent.getChildTransformation();
        boolean more = a.getTransformation(drawingTime, t, 1f);
        if (scalingRequired && mAttachInfo.mApplicationScale != 1f) {
            if (parent.mInvalidationTransformation == null) {
                parent.mInvalidationTransformation = new Transformation();
            }
            invalidationTransform = parent.mInvalidationTransformation;
            a.getTransformation(drawingTime, invalidationTransform, 1f);
        } else {
            invalidationTransform = t;
        }

我们只看重点代码，这里调用了动画对象的getTransformation方法

public boolean getTransformation(long currentTime, Transformation outTransformation,
            float scale) {
        mScaleFactor = scale;
        return getTransformation(currentTime, 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;
        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);
        }

该方法首先将当前时间currentTime处理成一个float类型的代表当前动画进度的对象。

 final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
            applyTransformation(interpolatedTime, outTransformation);

然后将我们计算好的时间传入getInterpolation方法里面，获得一个插值器对应的时间，最后把这个时间和Transformation对象传入到applyTransformation方法中。

protected void applyTransformation(float interpolatedTime, Transformation t) {
    }

我们发现applyTransformation这个方法的实现是空的，为何呢？因为不同的子类对这个方法进行了不同的实现。接下来我们看看

AlphaAnimation

 protected void applyTransformation(float interpolatedTime, Transformation t) {
        final float alpha = mFromAlpha;
        t.setAlpha(alpha + ((mToAlpha - alpha) * interpolatedTime));
    }

ScaleAnimation

 protected void applyTransformation(float interpolatedTime, Transformation t) {
        float sx = 1.0f;
        float sy = 1.0f;
        float scale = getScaleFactor();

        if (mFromX != 1.0f || mToX != 1.0f) {
            sx = mFromX + ((mToX - mFromX) * interpolatedTime);
        }
        if (mFromY != 1.0f || mToY != 1.0f) {
            sy = mFromY + ((mToY - mFromY) * interpolatedTime);
        }

        if (mPivotX == 0 && mPivotY == 0) {
            t.getMatrix().setScale(sx, sy);
        } else {
            t.getMatrix().setScale(sx, sy, scale * mPivotX, scale * mPivotY);
        }
    }

RotateAnimation

protected void applyTransformation(float interpolatedTime, Transformation t) {
        float degrees = mFromDegrees + ((mToDegrees - mFromDegrees) * interpolatedTime);
        float scale = getScaleFactor();

        if (mPivotX == 0.0f && mPivotY == 0.0f) {
            t.getMatrix().setRotate(degrees);
        } else {
            t.getMatrix().setRotate(degrees, mPivotX * scale, mPivotY * scale);
        }
    }

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

可见applyTransformation()方法就是动画具体的实现，系统会以一个比较高的频率来调用这个方法，一般情况下60FPS，是一个非常流畅的画面了，也就是16ms，接下来我们验证一下这个时间。

 public void click(View vIew){
        Animation animation = new Animation() {
            private long last = 0;
            @Override
            protected void applyTransformation(float interpolatedTime, Transformation t) {
                super.applyTransformation(interpolatedTime, t);
                long curr = System.currentTimeMillis();
                long time = curr-last;
                last = curr;
                System.out.println("===time: "+time);
                t.getMatrix().postTranslate(10, 10);
            }
        };
        animation.setDuration(500);
        textView.startAnimation(animation);
    }

可以看到时间间隔大概在20ms左右