如下图所示是时间修正的一个例子，

 

没有跳帧但延迟

 

由于第二个 frame 执行超时，第三个 frame 实际启动时间比第三个 VSync 信号到来时间要晚，因为这时候延时比较小，没有超过一个时钟周期，系统还是将 frameTimeNanos3 传给回调，回调拿到的时间和 VSync 信号同步。

再来看看下图：

跳帧

由于第二个 frame执行时间超过 2 个时钟周期，导致第三个 frame 延后执行时间大于一个时钟周期，系统认为这时候影响较大，判定为跳帧了，将第三个 frame 的时间修正为 frameTimeNanos4，比 VSync 真正到来的时间晚了一个时钟周期。

时间修正，既保证了doFrame操作和 VSync 保持同步节奏，又保证实际启动时间与记录的时间点相差不会太大，便于同步及分析。

    void doCallbacks(int callbackType, long frameTimeNanos) {

        CallbackRecord callbacks;

        synchronized (mLock) {

            // We use "now" to determine when callbacks become due because it's possible

            // for earlier processing phases in a frame to post callbacks that should run

            // in a following phase, such as an input event that causes an animation to start.

            final long now = System.nanoTime();
　　　　　　　//

            callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(

                    now / TimeUtils.NANOS_PER_MS);

            if (callbacks == null) {

                return;

            }

            mCallbacksRunning = true;

            // Update the frame time if necessary when committing the frame.

            // We only update the frame time if we are more than 2 frames late reaching

            // the commit phase.  This ensures that the frame time which is observed by the

            // callbacks will always increase from one frame to the next and never repeat.

            // We never want the next frame's starting frame time to end up being less than

            // or equal to the previous frame's commit frame time.  Keep in mind that the

            // next frame has most likely already been scheduled by now so we play it

            // safe by ensuring the commit time is always at least one frame behind.
　　　　　　　// commit 类型是最后执行的，如果此时发现前面处理时间过长，就会进行纠正。

            if (callbackType == Choreographer.CALLBACK_COMMIT) {

                final long jitterNanos = now - frameTimeNanos;

                Trace.traceCounter(Trace.TRACE_TAG_VIEW, "jitterNanos", (int) jitterNanos);

                if (jitterNanos >= 2 * mFrameIntervalNanos) {

                    final long lastFrameOffset = jitterNanos % mFrameIntervalNanos

                            + mFrameIntervalNanos;

                    if (DEBUG_JANK) {

                        Log.d(TAG, "Commit callback delayed by " + (jitterNanos * 0.000001f)

                                + " ms which is more than twice the frame interval of "

                                + (mFrameIntervalNanos * 0.000001f) + " ms!  "

                                + "Setting frame time to " + (lastFrameOffset * 0.000001f)

                                + " ms in the past.");

                        mDebugPrintNextFrameTimeDelta = true;

                    }

                    frameTimeNanos = now - lastFrameOffset;

                    mLastFrameTimeNanos = frameTimeNanos;

                }

            }

        }

        try {

            Trace.traceBegin(Trace.TRACE_TAG_VIEW, CALLBACK_TRACE_TITLES[callbackType]);

            for (CallbackRecord c = callbacks; c != null; c = c.next) {

                if (DEBUG_FRAMES) {

                    Log.d(TAG, "RunCallback: type=" + callbackType

                            + ", action=" + c.action + ", token=" + c.token

                            + ", latencyMillis=" + (SystemClock.uptimeMillis() - c.dueTime));

                }
　　　　　　　　　　// 运行每一个 callback

                c.run(frameTimeNanos);

            }

        } finally {

            synchronized (mLock) {

                mCallbacksRunning = false;

                do {

                    final CallbackRecord next = callbacks.next;

                    recycleCallbackLocked(callbacks);

                    callbacks = next;

                } while (callbacks != null);

            }

            Trace.traceEnd(Trace.TRACE_TAG_VIEW);

        }

    }

callback的类型有以下 4 种，除了文章一开始提到的 3 种外，还有一个 CALLBACK_COMMIT。

1. CALLBACK_INPUT：输入

2. CALLBACK_ANIMATION：动画

3. CALLBACK_TRAVERSAL：遍历，执行 measure、layout、draw

4. CALLBACK_COMMIT：遍历完成的提交操作，用来修正动画启动时间

然后看上面的源码，分析一下每个 callback 的执行过程：

1. callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked( now / TimeUtils.NANOS_PER_MS);

得到执行时间在当前时间之前的所有 CallBack，保存在单链表中。每种类型的 callback 按执行时间先后顺序排序分别存在一个单链表里面。为了保证当前 callback 执行时新 post 进来的 callback 在下一个 frame 时才被执行，这个地方 extractDueCallbacksLocked 会将需要执行的 callback 和以后执行的 callback 断开变成两个链表，新 post 进来的 callback 会被放到后面一个链表中。当前 frame 只会执行前一个链表中的 callback，保证了在执行 callback 时，如果callback中Post相同类型的callback，这些新加的 callback 将在下一个 frame 启动后才会被执行。

2. 接下来，看一大段注释，如果类型是 CALLBACK_COMMIT，并且当前 frame 渲染时间超过了两个时钟周期，则将当前提交时间修正为上一个垂直同步信号时间。为了保证下一个frame 的提交时间和当前 frame 时间相差为一且不重复。

这个地方注释挺难看懂，实际上这个地方 CALLBACK_COMMIT 是为了解决 ValueAnimator 的一个问题而引入的，主要是解决因为遍历时间过长导致动画时间启动过长，时间缩短，导致跳帧，这里修正动画第一个 frame 开始时间延后来改善，这时候才表示动画真正启动。为什么不直接设置当前时间而是回溯一个时钟周期之前的时间呢？看注释，这里如果设置为当前 frame 时间，因为动画的第一个 frame 其实已经绘制完成，第二个 frame 这时候已经开始了，设置为当前时间会导致这两个 frame 时间一样，导致冲突。

详细情况请看官方针对这个问题的修改。Fix animation start jank due to expensive layout operations.

如下图所示：

 

修正commit时间

比如说在第二个frame开始执行时，开始渲染动画的第一个画面，第二个frame执行时间超过了两个时钟周期，Draw操作执行结束后，这时候完成了动画第一帧的渲染，动画实际上还没开始，但是时间已经过了两个时钟周期，后面动画实际执行时间将会缩短一个时钟周期。这时候系统通过修正commit时间到frameTimeNanos的上一个VSync信号时间，即完成动画第一帧渲染之前的VSync信号到来时间，修正了动画启动时间，保证动画执行时间的正确性。

调用 c.run(frameTimeNanos) 执行回调

    private static final class CallbackRecord {

        public CallbackRecord next;

        public long dueTime;

        public Object action; // Runnable or FrameCallback

        public Object token;

        @UnsupportedAppUsage

        public void run(long frameTimeNanos) {

            if (token == FRAME_CALLBACK_TOKEN) {

                ((FrameCallback)action).doFrame(frameTimeNanos);

            } else {

                ((Runnable)action).run();

            }

        }

    }

CallbackRecord 的代码如上所示。

发起绘制的请求

doFrame 的逻辑了解清楚了，但是关于发起 vsync 请求的逻辑却没有讲。

// ViewRootImpl

 @UnsupportedAppUsage

    void scheduleTraversals() {
　　　　　// 如果已经请求绘制了，就不会再次请求，因为多次请求，只有有一个执行就满足要求了

        if (!mTraversalScheduled) {

            mTraversalScheduled = true;
　　　　　　　// 同步

            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
　　　　　　  // 发送一个 callback 用于在下一帧来临时候处理

            mChoreographer.postCallback(

                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

            if (!mUnbufferedInputDispatch) {

                scheduleConsumeBatchedInput();

            }
　　　　　　　// 通知稍候绘制

            notifyRendererOfFramePending();

            pokeDrawLockIfNeeded();

        }

    }

接着会调用 postCallbackDelayed：

    public void postCallbackDelayed(int callbackType,

            Runnable action, Object token, long delayMillis) {

        if (action == null) {

            throw new IllegalArgumentException("action must not be null");

        }

        if (callbackType < 0 || callbackType > CALLBACK_LAST) {

            throw new IllegalArgumentException("callbackType is invalid");

        }

        postCallbackDelayedInternal(callbackType, action, token, delayMillis);

    }

    private void postCallbackDelayedInternal(int callbackType,

            Object action, Object token, long delayMillis) {

        if (DEBUG_FRAMES) {

            Log.d(TAG, "PostCallback: type=" + callbackType

                    + ", action=" + action + ", token=" + token

                    + ", delayMillis=" + delayMillis);

        }

        synchronized (mLock) {

            final long now = SystemClock.uptimeMillis();

            final long dueTime = now + delayMillis;

            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);

　　　　　　　 // 小于当前时间，说明需要立即执行

            if (dueTime <= now) {

                scheduleFrameLocked(now);

            } else {
　　　　　　　　　 // 发送一个延迟 msg

                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);

                msg.arg1 = callbackType;

                msg.setAsynchronous(true);

                mHandler.sendMessageAtTime(msg, dueTime);

            }

        }

    }

   private void scheduleFrameLocked(long now) {

        if (!mFrameScheduled) {

            mFrameScheduled = true;

            if (USE_VSYNC) {

                if (DEBUG_FRAMES) {

                    Log.d(TAG, "Scheduling next frame on vsync.");

                }

                // If running on the Looper thread, then schedule the vsync immediately,

                // otherwise post a message to schedule the vsync from the UI thread

                // as soon as possible.
　　　　　　　　　// 如果是在一个 looper 线程中，那么直接执行请求就好

                if (isRunningOnLooperThreadLocked()) {

                    scheduleVsyncLocked();

                } else {
　　　　　　　　　　　　// 如果是在主线程，那么需要发送一个请求 vsync 的消息，并插到最前面，需要确保前一个消息处理完后在开始请求

                    Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);

                    msg.setAsynchronous(true);

                    mHandler.sendMessageAtFrontOfQueue(msg);

                }

            } else {
　　　　　　　　　　// 如果不用 vsync 信号，那么就可以直接执行，只是需要记录每一帧的时间

                final long nextFrameTime = Math.max(

                        mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);

                if (DEBUG_FRAMES) {

                    Log.d(TAG, "Scheduling next frame in " + (nextFrameTime - now) + " ms.");

                }

                Message msg = mHandler.obtainMessage(MSG_DO_FRAME);

                msg.setAsynchronous(true);

                mHandler.sendMessageAtTime(msg, nextFrameTime);

            }

        }

    }