Choreographer全解析

msg.arg1 = callbackType;

msg.setAsynchronous(true);

mHandler.sendMessageAtTime(msg, dueTime);

}

}

}

private final class FrameHandler extends Handler {

public FrameHandler(Looper looper) {

super(looper);

}

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case MSG_DO_FRAME:

doFrame(System.nanoTime(), 0);

break;

case MSG_DO_SCHEDULE_VSYNC:

doScheduleVsync();

break;

case MSG_DO_SCHEDULE_CALLBACK:

doScheduleCallback(msg.arg1);

break;

}

}

}

void doScheduleCallback(int callbackType) {

synchronized (mLock) {

if (!mFrameScheduled) {

final long now = SystemClock.uptimeMillis();

if (mCallbackQueues[callbackType].hasDueCallbacksLocked(now)) {

scheduleFrameLocked(now);

}

}

}

}

在ViewRootImpl中调用了postCallback方法之后，可以看到通过addCallbackLocked方法，添加了一条CallbackRecord数据，其中action就是对应之前ViewRootImpl的mTraversalRunnable。

然后判断设定的时间是否在当前时间之后，也就是有没有延迟，如果有延迟就发送延迟消息消息MSG_DO_SCHEDULE_CALLBACK到Handler所在线程，并最终执行到scheduleFrameLocked方法。如果没有延迟，则直接执行scheduleFrameLocked。

scheduleFrameLocked（准备申请VSYNC信号）

---

private void scheduleFrameLocked(long now) {

if (!mFrameScheduled) {

mFrameScheduled = true;

if (USE_VSYNC) {

//是否运行在主线程

if (isRunningOnLooperThreadLocked()) {

scheduleVsyncLocked();

} else {

//通过Handler切换线程

Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);

msg.setAsynchronous(true);

mHandler.sendMessageAtFrontOfQueue(msg);

}

} else {

//计算下一帧的时间

final long nextFrameTime = Math.max(

mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);

Message msg = mHandler.obtainMessage(MSG_DO_FRAME);

msg.setAsynchronous(true);

mHandler.sendMessageAtTime(msg, nextFrameTime);

}

}

}

case MSG_DO_FRAME:

doFrame(System.nanoTime(), 0);

break;

case MSG_DO_SCHEDULE_VSYNC:

doScheduleVsync();

break;

void doScheduleVsync() {

synchronized (mLock) {

if (mFrameScheduled) {

scheduleVsyncLocked();

}

}

}

该方法中，首先判断了是否开启了VSYNC（上节说过Android4.1之后默认开启VSYNC），如果开启了，判断在不在主线程，如果是主线程就运行scheduleVsyncLocked，如果不在就切换线程，也会调用到scheduleVsyncLocked方法，而这个方法就是我们之前说过的申请VSYNC信号的方法了。

如果没有开启VSYNC，则直接调用doFrame方法。

另外可以看到，刚才我们用到Handler发送消息的时候，都调用了msg.setAsynchronous(true)方法，这个方法就是设置消息为异步消息。因为我们刚才一开始的时候设置了同步屏障，所以异步消息就会先执行，这里的设置异步也就是为了让消息第一时间执行而不受其他Handler消息影响。

小结1

---

通过上面一系列方法，我们能得到一个初步的逻辑过程了：

• ViewRootImpl初始化的时候 《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》无偿开源 威信搜索公众号【编程进阶路】 ，会实例化Choreographer对象，也就是获取当前线程（一般就是主线程）对应的Choreographer对象。

• Choreographer初始化的时候，会新建一个当前线程对应的Handler对象，初始化FrameDisplayEventReceiver，计算一帧的时间等一系列初始化工作。

• 当UI改变的时候，会调用到ViewRootImpl的scheduleTraversals方法，这个方法中加入了同步屏障消息，并且调用了Choreographer的postCallback方法去申请VSYNC信号。

在这个过程中，Handler发送了延迟消息，切换了线程，并且给消息都设置了异步，保证最先执行。

继续看scheduleVsyncLocked方法。

scheduleVsyncLocked

---

private void scheduleVsyncLocked() {

mDisplayEventReceiver.scheduleVsync();

}

public void scheduleVsync() {

if (mReceiverPtr == 0) {

Log.w(TAG, "Attempted to schedule a vertical sync pulse but the display event "

• “receiver has already been disposed.”);

} else {

nativeScheduleVsync(mReceiverPtr);

}

}

代码很简单，就是通过FrameDisplayEventReceiver，请求native层面的垂直同步信号VSYNC。

这个FrameDisplayEventReceiver是在Choreographer构造方法中实例化的，继承自DisplayEventReceiver，主要就是处理VSYNC信号的申请和接收。

刚才说到调用nativeScheduleVsync方法申请VSYNC信号，然后当收到VSYNC信号的时候就会回调onVsync方法了。

onVsync（接收VSYNC信号）

---

private final class FrameDisplayEventReceiver extends DisplayEventReceiver

implements Runnable {

@Override

public void onVsync(long timestampNanos, long physicalDisplayId, int frame) {

//…

mTimestampNanos = timestampNanos;

mFrame = frame;

Message msg = Message.obtain(mHandler, this);

msg.setAsynchronous(true);

mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);

}

@Override

public void run() {

mHavePendingVsync = false;

doFrame(mTimestampNanos, mFrame);

}

}

这里同样通过Handler发送了一条消息，执行了本身的Runnable回调方法，也就是doFrame()。

doFrame（绘制帧数据）

---

void doFrame(long frameTimeNanos, int frame) {

final long startNanos;

synchronized (mLock) {

//…

//当前帧的vsync信号来的时间，假如为12分200ms

long intendedFrameTimeNanos = frameTimeNanos;

//当前时间，也就是开始绘制的时间,假如为12分150ms

startNanos = System.nanoTime();

//计算时间差，如果大于一个帧时间，则是跳帧了。比如是50ms，大于16ms

final long jitterNanos = startNanos - frameTimeNanos;

if (jitterNanos >= mFrameIntervalNanos) {

//计算掉了几帧，50/16=3帧

final long skippedFrames = jitterNanos / mFrameIntervalNanos;

//计算一帧内时间差，50%16=2ms

final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;

//修正时间,vsync信号应该来得时间，为12分148ms，保证和绘制时间对应上

frameTimeNanos = startNanos - lastFrameOffset;

}

if (frameTimeNanos < mLastFrameTimeNanos) {

//信号时间已过，不能再绘制了，等待下一个vsync信号，保证后续时间同步上

scheduleVsyncLocked();

return;

}

mFrameScheduled = false;

mLastFrameTimeNanos = frameTimeNanos;

}

try {

//执行相关的callback任务

mFrameInfo.markInputHandlingStart();

doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);

mFrameInfo.markAnimationsStart();

doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);

doCallbacks(Choreographer.CALLBACK_INSETS_ANIMATION, frameTimeNanos);

mFrameInfo.markPerformTraversalsStart();

doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);

doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);

} finally {

AnimationUtils.unlockAnimationClock();

Trace.traceEnd(Trace.TRACE_TAG_VIEW);

}

}

这里主要的工作就是：

• 设置当前帧的开始绘制时间，上节说过开始绘制要在vsync信号来的时候开始，保证两者时间对应。所以如果时间没对上，就是发送了跳帧，那么就要修正这个时间，保证后续的时间对应上。

• 执行所有的Callback任务。

doCallbacks（执行任务）

---

void doCallbacks(int callbackType, long frameTimeNanos) {

CallbackRecord callbacks;

synchronized (mLock) {

final long now = System.nanoTime();

callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(

now / TimeUtils.NANOS_PER_MS);

if (callbacks == null) {

return;

}

mCallbacksRunning = true;

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;

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) {

c.run(frameTimeNanos);

}

} finally {

synchronized (mLock) {

mCallbacksRunning = false;

do {