设计之妙，理解Android动画流程

本文依据Android 12进行学习研讨，参考《深入了解Android内核源码》思路学习总结，如有了解不对，望各位朋友指正，别的或许留存一些疑问，留后续再探究。输出只是为了分享和提升自己。

动画初始化

依照窗口管理战略类中的界说，动画应该被分为四种类型。

• TRANSIT_ENTER：窗口进入。
• TRANSIT_EXIT：窗口移除。
• TRANSIT_SHOW：窗口可见。
• TRANSIT_HIDE：窗口隐藏。

而TRANSIT_PREVIEW_DONE其实不算是动画，而是一个标志发动窗口完结的标志位。在WMS的relayoutWindow函数，会依据窗口状况判别是否要履行动画。下面代码则是判别动画的起始点。

//仅有在窗口在可见状况下且是一个发动窗口类型或者相关的appToken不隐藏时才会进行从头布局
final boolean shouldRelayout = viewVisibility == View.VISIBLE &&
        (win.mActivityRecord == null || win.mAttrs.type == TYPE_APPLICATION_STARTING
                || win.mActivityRecord.isClientVisible());
//当时不需求从头布局、也已经有Surface,且不是在履行退出动画，则需求考虑是否履行动画
if (!shouldRelayout && winAnimator.hasSurface() && !win.mAnimatingExit) {
    result |= RELAYOUT_RES_SURFACE_CHANGED;
    if (!win.mWillReplaceWindow) {
        ......
        //测验开端或者退出动画    
        focusMayChange = tryStartExitingAnimation(win, winAnimator, focusMayChange);
    }
}

在tryStartExitingAnimation调用了WindowStateAnimator类型目标winAnimator的applyAnimationLocked函数履行动画。

private boolean tryStartExitingAnimation(WindowState win, WindowStateAnimator winAnimator,boolean focusMayChange) {
    int transit = WindowManagerPolicy.TRANSIT_EXIT;
    //特点类型是使用窗口
    if (win.mAttrs.type == TYPE_APPLICATION_STARTING) {
      //发动窗口完结
        transit = WindowManagerPolicy.TRANSIT_PREVIEW_DONE;
    }
//窗口处于动画改换
     if (win.inTransition()) {
        focusMayChange = true;
        win.mAnimatingExit = true;
    } else if (win.isWinVisibleLw() && win.mDisplayContent.okToAnimate()) {
        String reason = null;
        //履行动画，假如未履行动画或动画失利，则开释相关资源
        if (winAnimator.applyAnimationLocked(transit, false)) {
            reason = "applyAnimation";
            focusMayChange = true;
            win.mAnimatingExit = true;
        } else if (
                win.isSelfAnimating(0 /* flags */, ANIMATION_TYPE_WINDOW_ANIMATION)
                || win.isAnimating(PARENTS | TRANSITION,ANIMATION_TYPE_APP_TRANSITION | ANIMATION_TYPE_RECENTS)|| (win.inTransition()
            reason = "animating";
            win.mAnimatingExit = true;
        } else if (win.mDisplayContent.mWallpaperController.isWallpaperTarget(win)
                && win.mAttrs.type != TYPE_NOTIFICATION_SHADE) {
            reason = "isWallpaperTarget";
            win.mAnimatingExit = true;
        }
    .....
        }
    }
    //资源开释
    if (!win.mAnimatingExit) {
        boolean stopped = win.mActivityRecord == null || win.mActivityRecord.mAppStopped;
        win.mDestroying = true;
        win.destroySurface(false, stopped);
    }
    if (mAccessibilityController.hasCallbacks()) {
        mAccessibilityController.onWindowTransition(win, transit);
    }
    return focusMayChange;
}

applyAnimationLocked函数选择适宜的动画类型，并设置给WindowState，这儿也是 判别是否有设置动画的当地。假如设置了动画，调用WindowState的startAnimation函数。

boolean applyAnimationLocked(int transit, boolean isEntrance) {
  //防止加载相同动画两次
    if (mWin.isAnimating() && mAnimationIsEntrance == isEntrance) {
        return true;
    }
    if (mWin.mAttrs.type == TYPE_INPUT_METHOD) {
        mWin.getDisplayContent().adjustForImeIfNeeded();
        if (isEntrance) {
            mWin.setDisplayLayoutNeeded();
            mService.mWindowPlacerLocked.requestTraversal();
        }
    }
    if (mWin.mControllableInsetProvider != null) {
        // All our animations should be driven by the insets control target.
        return false;
    }
    // 假如显现处于 frozen状况，则不履行动画
    if (mWin.mToken.okToAnimate()) {
        int anim = mWin.getDisplayContent().getDisplayPolicy().selectAnimation(mWin, transit);
        int attr = -1;
        Animation a = null;
        //anim不等于ANIMATION_STYLEABLE，表明给窗口指定了动画
        if (anim != DisplayPolicy.ANIMATION_STYLEABLE) {//anim不等于0，表明指定了动画
            if (anim != DisplayPolicy.ANIMATION_NONE) {
                //加载动画资源
                a = AnimationUtils.loadAnimation(mContext, anim);
            }
        } else {
          //依据动画类型，选择默认的资源文件
            switch (transit) {
                case WindowManagerPolicy.TRANSIT_ENTER:
                    attr = com.android.internal.R.styleable.WindowAnimation_windowEnterAnimation;
                    break;
                case WindowManagerPolicy.TRANSIT_EXIT:
                    attr = com.android.internal.R.styleable.WindowAnimation_windowExitAnimation;
                    break;
                case WindowManagerPolicy.TRANSIT_SHOW:
                    attr = com.android.internal.R.styleable.WindowAnimation_windowShowAnimation;
                    break;
                case WindowManagerPolicy.TRANSIT_HIDE:
                    attr = com.android.internal.R.styleable.WindowAnimation_windowHideAnimation;
                    break;
            }
    //加载动画资源
            if (attr >= 0) {
                a = mWin.getDisplayContent().mAppTransition.loadAnimationAttr(
                        mWin.mAttrs, attr, TRANSIT_OLD_NONE);
            }
        }
        if (a != null) {
            mWin.startAnimation(a);//获取到动画资源，开端履行动画Animation目标
            mAnimationIsEntrance = isEntrance;
        }
    } else {
        mWin.cancelAnimation();
    }
    return mWin.isAnimating(0 /* flags */, ANIMATION_TYPE_WINDOW_ANIMATION);
}

WindowState在WMS表明一个窗口目标，startAnimation函数对动画anim进行进行初始化，封装成AnimationAdpater类型的adapter目标,并调用父类WindowContainer的startAnimation函数。WindowContainer界说了窗口和窗口层级之间一些通用接口。WindowContainer用来描绘动画和联络相相关的组件，以及履行动画的。

注意到这儿adpter实践类型是LocalAnimationAdapter，表明该动画不需求持有WindowManager 锁。重点是其构造函数的入参WindowAnimationSpec和SurfaceAnimationRunner目标,是后续监听VSYNC进行特点核算的当地。

void startAnimation(Animation anim) {
    if (mControllableInsetProvider != null) {
        return;
    }
    final DisplayInfo displayInfo = getDisplayInfo();
    //初始化宽高
    anim.initialize(mWindowFrames.mFrame.width(), mWindowFrames.mFrame.height(),
            displayInfo.appWidth, displayInfo.appHeight);
    anim.restrictDuration(MAX_ANIMATION_DURATION);
    anim.scaleCurrentDuration(mWmService.getWindowAnimationScaleLocked());
	//SurfaceAnimationRunner类型的 mWmService.mSurfaceAnimationRunner
    final AnimationAdapter adapter = new LocalAnimationAdapter(
            new WindowAnimationSpec(anim, mSurfacePosition, false,
                    0),
            mWmService.mSurfaceAnimationRunner);
    //getPendingTransaction剖析
    startAnimation(getPengetPendingTransaction剖析dingTransaction(), adapter);
    commitPendingTransaction();
}

WindowContainer.startAnimation函数又调用了SurfaceAnimator.startAnimation。SurfaceAnimator首要是将一组子Surface经过束缚重置为新的Surface，称为Leach,然后交由AnimationAdapter履行动画。

// mWinAnimator.mLastHidden, ANIMATION_TYPE_WINDOW_ANIMATION
//animationFinishedCallback、animationCancelledCallback、snapshotAnim此刻为null
void startAnimation(Transaction t, AnimationAdapter anim, boolean hidden,
        @AnimationType int type,
        @Nullable OnAnimationFinishedCallback animationFinishedCallback,
        @Nullable Runnable animationCancelledCallback,
        @Nullable AnimationAdapter snapshotAnim) {
    mSurfaceAnimator.startAnimation(t, anim, hidden, type, animationFinishedCallback,
            animationCancelledCallback, snapshotAnim, mSurfaceFreezer);
}

startAnimation建立动画链成功之后，就会调用入参anim履行动画。hidden表明WindowContainer当时持有Surface是否可见。按前面剖析，此刻startAnimation只要前面四个参数有值。三种动画：Surface、adapter、snapshot。

void startAnimation(Transaction t, AnimationAdapter anim, boolean hidden,
        @AnimationType int type,
        @Nullable OnAnimationFinishedCallback animationFinishedCallback,
        @Nullable Runnable animationCancelledCallback,
        @Nullable AnimationAdapter snapshotAnim, @Nullable SurfaceFreezer freezer) {
   //强制撤销与t相同类型的动画，并从头履行
   cancelAnimation(t, true /* restarting */, true /* forwardCancel */);
    mAnimation = anim;
    mAnimationType = type;
    mSurfaceAnimationFinishedCallback = animationFinishedCallback;
    mAnimationCancelledCallback = animationCancelledCallback;
    final SurfaceControl surface = mAnimatable.getSurfaceControl();
    if (surface == null) {
        cancelAnimation();
        return;
    }
    //freezer==null
    mLeash = freezer != null ? freezer.takeLeashForAnimation() : null;
    if (mLeash == null) {
      //创立动画链（SurfaceController）,一起也会设置给t
        mLeash = createAnimationLeash(mAnimatable, surface, t, type,
                mAnimatable.getSurfaceWidth(), mAnimatable.getSurfaceHeight(), 0 /* x */,
                0 /* y */, hidden, mService.mTransactionFactory);
        mAnimatable.onAnimationLeashCreated(t, mLeash);
    }
    //开端动画链
    mAnimatable.onLeashAnimationStarting(t, mLeash);
    if (mAnimationStartDelayed) {
        return;
    }
    //此刻履行AnimationAdapter目标mAnimation动画，mInnerAnimationFinishedCallback是WC的监听
    mAnimation.startAnimation(mLeash, t, type, mInnerAnimationFinishedCallback);
   //开端snapshot动画，此刻snapshotAnim==null
   if (snapshotAnim != null) {
        mSnapshot = freezer.takeSnapshotForAnimation();
        if (mSnapshot == null) {
            return;
        }
        mSnapshot.startAnimation(t, snapshotAnim, type);
    }
}

按前面的剖析，这儿mAnimation的实践类型是LocalAnimationAdapter。其startAnimation又调用了SurfaceAnimationRunner目标的startAnimation函数。

先是将动画相关内容封装成RunningAnimation目标，并存放到mPendingAnimations中。

然后向编舞者Choreographer注册了VSYNC监听，这样当信号来暂时，会调用startAnimations函数。

void startAnimation(AnimationSpec a, SurfaceControl animationLeash, Transaction t,
        Runnable finishCallback) {
    synchronized (mLock) {
        final RunningAnimation runningAnim = new RunningAnimation(a, animationLeash,
                finishCallback);
        //这样帧信号来暂时，会履行该Map中所有动画
        mPendingAnimations.put(animationLeash, runningAnim);
        //假如当时动画部推迟履行，则立即向Choreographer注册笔直信号监听
        //这样笔直信号来暂时，履行startAnimations，存在必定推迟
        if (!mAnimationStartDeferred) {
            mChoreographer.postFrameCallback(this::startAnimations);
        }
        //一些动画需求初始并使用一些改换
        applyTransformation(runningAnim, t, 0 /* currentPlayTime */);
    }
}

SurfaceAnimationRunner的startAnimations函数。

private void startAnimations(long frameTimeNanos) {
    synchronized (mLock) {
        startPendingAnimationsLocked();
    }
    mPowerManagerInternal.setPowerBoost(Boost.INTERACTION, 0);
}

遍历mPendingAnimations中所有等待帧信号降临的RunningAnimation目标，调用startAnimationLocked履行它们。

private void startPendingAnimationsLocked() {
    for (int i = mPendingAnimations.size() - 1; i >= 0; i--) {
        startAnimationLocked(mPendingAnimations.valueAt(i));
    }
    mPendingAnimations.clear();
}

SurfaceAnimatorRunner目标，startAnimationLocked首要为每个RunningAnimation动画创立ValueAnimator目标并设置相关参数，并在AnimatorUpdateListener回调中核算动画使用目标的相关特点。

@GuardedBy("mLock")
private void startAnimationLocked(RunningAnimation a) {
    final ValueAnimator anim = mAnimatorFactory.makeAnimator();
    //设置动画相关参数
    anim.overrideDurationScale(1.0f);
    anim.setDuration(a.mAnimSpec.getDuration());
    //更改动画目标相关特点
    anim.addUpdateListener(animation -> {
        synchronized (mCancelLock) {
            if (!a.mCancelled) {
                final long duration = anim.getDuration();
                long currentPlayTime = anim.getCurrentPlayTime();
                if (currentPlayTime > duration) {
                    currentPlayTime = duration;
                }
                //每次更改相关动画特点
                applyTransformation(a, mFrameTransaction, currentPlayTime);
            }
        }
        scheduleApplyTransaction();
    });
	//anim开端后，会回调此处。
    anim.addListener(new AnimatorListenerAdapter() {
        @Override
        public void onAnimationStart(Animator animation) {
            synchronized (mCancelLock) {
                if (!a.mCancelled) {
                    mFrameTransaction.setAlpha(a.mLeash, 1);
                }
            }
        }
        @Override
        public void onAnimationEnd(Animator animation) {
            synchronized (mLock) {
                mRunningAnimations.remove(a.mLeash);
                synchronized (mCancelLock) {
                    if (!a.mCancelled) {
                        mAnimationThreadHandler.post(a.mFinishCallback);
                    }
                }
            }
        }
    });
    a.mAnim = anim;
    mRunningAnimations.put(a.mLeash, a);
	//调用ValueAnimator的start函数。
    anim.start();
    if (a.mAnimSpec.canSkipFirstFrame()) {
        anim.setCurrentPlayTime(mChoreographer.getFrameIntervalNanos() / NANOS_PER_MS);
    }
	//手动触发一帧动画特点
    anim.doAnimationFrame(mChoreographer.getFrameTime());
}

ValueAnimator.start=>start(false),该函数首要ValueAnimator目标对一些变量进行初始化。其间调用了addAnimationCallback(0)向AnimationHandler注册帧信号的监听。

private void start(boolean playBackwards) {
    if (Looper.myLooper() == null) {
        throw new AndroidRuntimeException("Animators may only be run on Looper threads");
    }
    mReversing = playBackwards;//此刻false，表明为正向动画
    mSelfPulse = !mSuppressSelfPulseRequested;
    //判别是否快进到某个时刻点
    if (playBackwards && mSeekFraction != -1 && mSeekFraction != 0) {
        if (mRepeatCount == INFINITE) {
            // Calculate the fraction of the current iteration.
            float fraction = (float) (mSeekFraction - Math.floor(mSeekFraction));
            mSeekFraction = 1 - fraction;
        } else {
            mSeekFraction = 1 + mRepeatCount - mSeekFraction;
        }
    }
    mStarted = true;
    mPaused = false;
    mRunning = false;
    mAnimationEndRequested = false;
    mLastFrameTime = -1;
    mFirstFrameTime = -1;
    mStartTime = -1;
    addAnimationCallback(0);
    if (mStartDelay == 0 || mSeekFraction >= 0 || mReversing) {
        //内部初始化动画目标所使用的特点,和回调开端监听
        startAnimation();
        //初始化mStartTime
        if (mSeekFraction == -1) {
            setCurrentPlayTime(0);
        } else {
            setCurrentFraction(mSeekFraction);
        }
    }
}

AnimationHandler在线程中静态单例的，在默认状况下，向编舞者Choreographer注册并接纳其帧信号（笔直信号）回调， 向所有的动画ValueAnimator目标发送刷新帧的时刻，这样它们在同一个线程以相同的时刻履行各自窗口特点值的核算，抵达视觉动画作用。AnimationHandler也为咱们供给 设置类似编舞者供给周期信号的 接口，方便测验和特定功能开发。

private void addAnimationCallback(long delay) {
    if (!mSelfPulse) {
        return;
    }
    getAnimationHandler().addAnimationFrameCallback(this, delay);
}
public void addAnimationFrameCallback(final AnimationFrameCallback callback, long delay) {
	//注册笔直信号监听
    if (mAnimationCallbacks.size() == 0) {
        getProvider().postFrameCallback(mFrameCallback);
    }
    //防止重复增加
    if (!mAnimationCallbacks.contains(callback)) {
        mAnimationCallbacks.add(callback);
    }
	//延时履行
    if (delay > 0) {
        mDelayedCallbackStartTime.put(callback, (SystemClock.uptimeMillis() + delay));
    }
}
//这样笔直信号降临，会调用doFrame函数
private final Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
    @Override
    public void doFrame(long frameTimeNanos) {
        doAnimationFrame(getProvider().getFrameTime());
        if (mAnimationCallbacks.size() > 0) {
            getProvider().postFrameCallback(this);
        }
    }
};

动画触发

AnimationHandler默认状况会向编舞者Choreographer注册笔直信号(VSYNC)监听，这样当笔直信号来暂时，就回调mFrameCallback目标doFrame函数。

doFrame函数获取当时帧时刻并传递给doAnimationFrame函数，假如履行完之后，还有动画没有履行完结则再次监听VSYNC。所以在doAnimationFrame函数中履行动画完毕后肯定将AnimationFrameCallback目标从mAnimationCallbacks移除。

private final Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
    @Override
    public void doFrame(long frameTimeNanos) {
        doAnimationFrame(getProvider().getFrameTime());
        if (mAnimationCallbacks.size() > 0) {
            getProvider().postFrameCallback(this);
        }
    }
};

doAnimationFrame函数遍历mAnimationCallbacks中所有AnimationFrameCallback目标，判别其是否抵达开端履行动画（部分动画或许设置延时履行），抵达开端时刻，则调用它们的doAnimationFrame函数。

private void doAnimationFrame(long frameTime) {
    long currentTime = SystemClock.uptimeMillis();
    final int size = mAnimationCallbacks.size();
    for (int i = 0; i < size; i++) {
        final AnimationFrameCallback callback = mAnimationCallbacks.get(i);
        if (callback == null) {
            continue;
        }
        //判别动画是否抵达开端履行时刻
        if (isCallbackDue(callback, currentTime)) {
            callback.doAnimationFrame(frameTime);//回调AnimationFrameCallback，进行逻辑处理
            if (mCommitCallbacks.contains(callback)) {//检查在哪里注册到该map，推迟大的时分
                getProvider().postCommitCallback(new Runnable() {
                    @Override
                    public void run() {
                        //延时问题
                        commitAnimationFrame(callback, getProvider().getFrameTime());
                    }
                });
            }
        }
    }
    cleanUpList();
}

ValueAnimator目标doAnimationFrame函数。在VSYNC来暂时，需求依据一些状况调整动画的开端时刻mStartTime。动画未开端、康复动画、暂停动画、动画快进、动画推迟履行都会调整动画的开端时刻。假如此刻动画未开端，此帧时刻则是开端时刻，或者开端倒计时的时刻（动画设置延时履行）。假如当时是康复动画，开端时刻则更改为当时时刻节点+已暂停时刻（mStartTime+elapseTime），而不是停留在前次动画的帧时刻。这儿或许会了解为从继续前次暂停的动画作用，然后继续履行后续动画。假如此刻仍是榜首帧时刻，还需求判别是否存在动画快进的状况。

终究调用animateBasedOnTime函数核算此刻此刻动画的相关特点值。参数为帧时刻（开端之后）或者开端时刻（刚开端）。

public final boolean doAnimationFrame(long frameTime) {
  //动画刚初始化，mStartTime=-1,未开端
    if (mStartTime < 0) {
        // 榜首帧动画时刻，假如有推迟开端动画，此刻开端倒计时
        mStartTime = mReversing
                ? frameTime
                : frameTime + (long) (mStartDelay * resolveDurationScale());
    }
    if (mPaused) {//暂停
        mPauseTime = frameTime;
        removeAnimationCallback();
        return false;
    } else if (mResumed) {//康复
        mResumed = false;
        if (mPauseTime > 0) {
            //康复并不是从前次动画进展节点康复，而是以当时帧时刻为开端
            mStartTime += (frameTime - mPauseTime);
        }
    }
    if (!mRunning) {
  //动画开端时刻未到，而且没有快进
        if (mStartTime > frameTime && mSeekFraction == -1) {
            return false;
        } else {
            mRunning = true;
    //初始化ValueAnimator中各个特点值
            startAnimation();
        }
    }
    if (mLastFrameTime < 0) {//此次榜首帧时刻
        if (mSeekFraction >= 0) {
            long seekTime = (long) (getScaledDuration() * mSeekFraction);
            mStartTime = frameTime - seekTime;
            mSeekFraction = -1;
        }
        mStartTimeCommitted = false; // allow start time to be compensated for jank
    }
    mLastFrameTime = frameTime;
    //防止当时帧时刻比开端时刻早的问题
    final long currentTime = Math.max(frameTime, mStartTime);
//核算特点值
    boolean finished = animateBasedOnTime(currentTime);
    if (finished) {
        endAnimation();//移除FrameCallback监听，通知已注册监听
    }
    return finished;
}

咱们知道动画是可以指定重复次数或无限循环的。所以animateBasedOnTime函数核算出本次帧时刻来暂时，本次动画进展在整体进展状况fraction。0表明刚开端履行动画；0-1表明榜首次动画某个时刻点；等于1表明刚好履行完榜首次动画；大于1则表明开端循环动画。当大于1时，正数部分表明第几次重复动画，而小数部分表明本次动画的时刻节点；正数部分假如大于前次fraction，则表明是新的循环。

这个函数有许多规划妙处。

boolean animateBasedOnTime(long currentTime) {
    boolean done = false;
    if (mRunning) {
        //获取持续时刻
        final long scaledDuration = getScaledDuration();
        //currentTime - mStartTime表明动画已履行完的时刻长度，等于0表明刚开端，大于0，说明要越过这部分时刻。
        //(float)(currentTime - mStartTime) / scaledDuration大于1表明已经开端重复履行动画了，0-1则是榜首次。1刚好榜首次动画完毕
        final float fraction = scaledDuration > 0 ?
                (float)(currentTime - mStartTime) / scaledDuration : 1f;
        final float lastFraction = mOverallFraction;
        //fraction在整型比上一次大,则判别为新一次循环，持平判别为同一次动画内的不同阶段
        final boolean newIteration = (int) fraction > (int) lastFraction;
        //判别是否终究一次动画循环：在有限循环次数内，本次动画等于或超出设置的总重复次数
        final boolean lastIterationFinished = (fraction >= mRepeatCount + 1) &&
                (mRepeatCount != INFINITE);
        if (scaledDuration == 0) {
            //持续时刻为0的，直接完毕
            done = true;
        } else if (newIteration && !lastIterationFinished) {
            // 当时属于新的迭代次数，且还没有完毕动画
            if (mListeners != null) {
                int numListeners = mListeners.size();
                for (int i = 0; i < numListeners; ++i) {
                    mListeners.get(i).onAnimationRepeat(this);
                }
            }
        } else if (lastIterationFinished) {
            done = true;//当时属于终究一次迭代
        }
        mOverallFraction = clampFraction(fraction);//缓存本次进展节点
        //先核算本次动画是第几次iteration
        //再取小数部分curFraction=fraction-iteration，依据是否反向动画，确定终究的进展curFraction or 1-curFraction
        float currentIterationFraction = getCurrentIterationFraction(
                mOverallFraction, mReversing);
        animateValue(currentIterationFraction);//经过插值器核算动画特点值
    }
    return done;
}

animateValue函数以本次动画时刻进展节点，经过时刻插值器改换进展节点，然后通知特点数组mValues中的目标，让它们依据改换后fraction，转化具体的特点值。然后回调UpdateListener目标的onAnimationUpdate函数。

void animateValue(float fraction) {
	//插值器改换fraction
    fraction = mInterpolator.getInterpolation(fraction);
    mCurrentFraction = fraction;
    int numValues = mValues.length;
    for (int i = 0; i < numValues; ++i) {
    	//各个特点依据fraction转化自己的值
        mValues[i].calculateValue(fraction);
    }
    if (mUpdateListeners != null) {
        int numListeners = mUpdateListeners.size();
        for (int i = 0; i < numListeners; ++i) {
        	//回调通知
            mUpdateListeners.get(i).onAnimationUpdate(this);
        }
    }
}

这就回到了SurfaceAnimatorRunner对像startAnimationLocked函数给ValueAnimator设置监听的当地。

private void startAnimationLocked(RunningAnimation a) {
    ......
    //帧动画经过valueAnimator核算发生后回调此处
    anim.addUpdateListener(animation -> {
        synchronized (mCancelLock) {
            if (!a.mCancelled) {
                final long duration = anim.getDuration();
                long currentPlayTime = anim.getCurrentPlayTime();
                if (currentPlayTime > duration) {//履行完毕
                    currentPlayTime = duration;
                }
                //动画特点核算
                applyTransformation(a, mFrameTransaction, currentPlayTime);
            }
        }
        // Transaction will be applied in the commit phase.
        scheduleApplyTransaction();
    });
    ......
}

applyTransformation函数内部有调用了WindowAnimationSpec目标的apply函数。

private void applyTransformation(RunningAnimation a, Transaction t, long currentPlayTime) {
    a.mAnimSpec.apply(t, a.mLeash, currentPlayTime);
}

apply函数获取线程本地TmpValues目标,将相关特点核算结果写到其Transformation类型的transformation成员变量。Transformation类封装Matrix、裁剪、透明度、动画类型。而Matrix可以对目标进行缩放、平移、和旋转。也就是说，Transformation类型囊括了四个动画类型缩放、平移、旋转、透明度,代表了动画某刻要使用的改换。

public void apply(Transaction t, SurfaceControl leash, long currentPlayTime) {
    final TmpValues tmp = mThreadLocalTmps.get();
    //重置transformation
    tmp.transformation.clear();
    //核算某个时刻的动画特点,并将结果写会tmp.transformation
    mAnimation.getTransformation(currentPlayTime, tmp.transformation);
    //位移
    tmp.transformation.getMatrix().postTranslate(mPosition.x, mPosition.y);
    //旋转、缩放
    t.setMatrix(leash, tmp.transformation.getMatrix(), tmp.floats);
    //透明度
    t.setAlpha(leash, tmp.transformation.getAlpha());
    boolean cropSet = false;
    if (mRootTaskClipMode == ROOT_TASK_CLIP_NONE) {
        if (tmp.transformation.hasClipRect()) {
            t.setWindowCrop(leash, tmp.transformation.getClipRect());
            cropSet = true;
        }
    } else {
        mTmpRect.set(mRootTaskBounds);
        if (tmp.transformation.hasClipRect()) {
            mTmpRect.intersect(tmp.transformation.getClipRect());
        }
        t.setWindowCrop(leash, mTmpRect);
        cropSet = true;
    }
    //设置圆角
    if (cropSet && mAnimation.hasRoundedCorners() && mWindowCornerRadius > 0) {
        t.setCornerRadius(leash, mWindowCornerRadius);
    }
}

代码中调用了Animation的getTransformation函数，首要是核算动画的状况，是否开端、运转、完毕。假如动画仍是处于运转状况，则调用getTransformationAt函数。

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) {
		//核算当时所处的方位0
        normalizedTime = ((float) (currentTime - (mStartTime + startOffset))) /
                (float) duration;
    } else {
        //未开端或者完毕了
        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");
            }
        }
		//normalized在0f~1f之间
        if (mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);
		//此刻是否反向动画
        if (mCycleFlip) {
            normalizedTime = 1.0f - normalizedTime;
        }
		//将动画特点缓冲到outTransformation
        getTransformationAt(normalizedTime, outTransformation);
    }
	//完毕了，但是或许循环动画
    if (expired) {
        if (mRepeatCount == mRepeated || isCanceled()) {//动画完毕
            if (!mEnded) {
                mEnded = true;
                guard.close();
                fireAnimationEnd();
            }
        } else {//动画循环
            if (mRepeatCount > 0) {
                mRepeated++;
            }
            if (mRepeatMode == REVERSE) {
                mCycleFlip = !mCycleFlip;
            }
            mStartTime = -1;
            mMore = true;
            fireAnimationRepeat();
        }
    }
    if (!mMore && mOneMoreTime) {
        mOneMoreTime = false;
        return true;
    }
    return mMore;
}

getTransformationAt函数内部又调用Animation的applyTransformation函数。这儿的Animation子类会重写该函数，完成自己的特定特点核算。Animation子类可所以在主题或者指定的Animation为准，如前面由系统默认指定的动画。

public void getTransformationAt(float normalizedTime, Transformation outTransformation) {
    final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
    applyTransformation(interpolatedTime, outTransformation);
}

动画的展示

回到了SurfaceAnimatorRunner对像startAnimationLocked函数给ValueAnimator设置监听的当地。在上面履行了applyTransformation函数之后，调用了applyTransformation。

private final Runnable mApplyTransactionRunnable = this::applyTransaction;
private void scheduleApplyTransaction() {
    if (!mApplyScheduled) {
        mChoreographer.postCallback(CALLBACK_TRAVERSAL, mApplyTransactionRunnable,
                null /* token */);
        mApplyScheduled = true;
    }
}
private void applyTransaction() {
    mFrameTransaction.setAnimationTransaction();
    mFrameTransaction.setFrameTimelineVsync(mChoreographer.getVsyncId());
    mFrameTransaction.apply();
    mApplyScheduled = false;
}

依据前面mSurfaceAnimationRunner目标来自WMS的成员变量，其在WMS创立的时分被创立，Transaction类型的mFrameTransaction目标以同步方式设置SurfaceController。applyTransaction函数调用mFrameTransaction目标的几个方法，内部都调用底层代码去设置Surface。这儿不再进一步跟进。

总结

经过本文对动画源码的学习，了解在动画上面临Float浮点数奇妙运用，用来合理操控动画的重复行为和单次进展。

一起也了解到动画在底层也是经过ValueAnimator来核算动画的各个特点 ，因而进一步确定原理，动画就是在指定的时刻内播放一帧帧图像，依据人眼对图像的感知特色，然后构成动效。

别的，动画会以笔直信号来初始化动画和触发动画的开端。