在Android4.1之后增加了Choreographer机制，用于同Vsync机制配合，统一动画、输入和绘制时机。
从绘制流程开始 ViewRootImpl的requestLayout开启绘制流程：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 @Override public void requestLayout () if (!mHandlingLayoutInLayoutRequest) { checkThread(); mLayoutRequested = true ; scheduleTraversals(); } } void scheduleTraversals () if (!mTraversalScheduled) { mTraversalScheduled = true ; mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier(); mChoreographer.postCallback( Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null ); } }
这里主要关注两点：
postSyncBarrier : Handler 的同步屏障。它的作用是可以拦截 Looper 对同步消息的获取和分发，加入同步屏障之后，Looper 只会获取和处理异步消息，如果没有异步消息那么就会进入阻塞状态。也就是说，对View绘制渲染的处理操作可以优先处理（设置为异步消息）。
Choreographer: 编舞者。统一动画、输入和绘制时机。也是这章需要重点分析的内容。
Choreographer启动 1 2 3 4 5 6 public ViewRootImpl (Context context, Display display) ... mChoreographer = Choreographer.getInstance(); ... }
frameworks\base\core\java\android\view\Choreographer.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public static Choreographer getInstance () return sThreadInstance.get(); } private static final ThreadLocal<Choreographer> sThreadInstance = new ThreadLocal<Choreographer>() { @Override protected Choreographer initialValue () Looper looper = Looper.myLooper(); if (looper == null ) { throw new IllegalStateException("The current thread must have a looper!" ); } return new Choreographer(looper); } };
每一个Looper线程都有自己的Choreographer，其他线程发送的回调只能运行在对应Choreographer所属的Looper线程上
1 2 3 4 5 6 7 8 9 10 11 12 13 private Choreographer (Looper looper) mLooper = looper; mHandler = new FrameHandler(looper); mDisplayEventReceiver = USE_VSYNC ? new FrameDisplayEventReceiver(looper) : null ; mLastFrameTimeNanos = Long.MIN_VALUE; mFrameIntervalNanos = (long )(1000000000 / getRefreshRate()); mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1 ]; for (int i = 0 ; i <= CALLBACK_LAST; i++) { mCallbackQueues[i] = new CallbackQueue(); } }
Choreographer类中有一个Looper和一个FrameHandler变量。变量USE_VSYNC用于表示系统是否是用了Vsync同步机制，该值是通过读取系统属性debug.choreographer.vsync来获取的。如果系统使用了Vsync同步机制，则创建一个FrameDisplayEventReceiver对象用于请求并接收Vsync事件，最后Choreographer创建了一个大小为3的CallbackQueue队列数组，用于保存不同类型的Callback。
这里，不同类型的Callback包括如下4种：
1 2 3 4 public static final int CALLBACK_INPUT = 0 ; public static final int CALLBACK_ANIMATION = 1 ; public static final int CALLBACK_TRAVERSAL = 2 ; public static final int CALLBACK_COMMIT = 3 ;
CallbackQueue是一个容量为4的数组，每一个元素作为头指针，引出对应类型的链表，4种事件就是通过这4个链表来维护的。
而FrameHandler中主要处理三类消息：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 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 ; } } }
Choreographer执行流程
Choreographer提供了两类添加回调的方式：postCallback 与 postFrameCallback，当然对应类型也包含delay的方法，算上其实有4个方法。
postCallback对应的：
1 2 3 4 5 6 7 8 9 10 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); }
postFrameCallback对应的：
1 2 3 4 5 6 7 public void postFrameCallbackDelayed (FrameCallback callback, long delayMillis) if (callback == null ) { throw new IllegalArgumentException("callback must not be null" ); } postCallbackDelayedInternal(CALLBACK_ANIMATION, callback, FRAME_CALLBACK_TOKEN, delayMillis); }
相比之下postCallback更灵活一点。两者最终都会调到：postCallbackDelayedInternal
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 private void postCallbackDelayedInternal (int callbackType, Object action, Object token, long 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 { Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action); msg.arg1 = callbackType; msg.setAsynchronous(true ); mHandler.sendMessageAtTime(msg, dueTime); } } }
mCallbackQueues先把对应的callback添加到链表上来，然后判断是否有延迟，如果没有则会马上执行scheduleFrameLocked，如果有，则发送一个what为MSG_DO_SCHEDULE_CALLBACK类型的定时消息，等时间到了再处理，其最终处理也是执行scheduleFrameLocked(long now)方法。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 private void scheduleFrameLocked (long now) if (!mFrameScheduled) { mFrameScheduled = true ; if (USE_VSYNC) { if (DEBUG_FRAMES) { Log.d(TAG, "Scheduling next frame on vsync." ); } if (isRunningOnLooperThreadLocked()) { scheduleVsyncLocked(); } else { 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); 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); } } }
这里首先判断USE_VSYNC，如果使用了VSYNC:走scheduleVsyncLocked，即请求VSYNC信号，最终调用doFrame，如果没使用VSYNC，则通过消息执行doFrame。
那么我们先简单了解下请求VSYNC信号的流程：
1 2 3 4 5 6 7 8 9 10 11 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); } }
mDisplayEventReceiver 对应的是FrameDisplayEventReceiver，它继承自 DisplayEventReceiver ， 主要是用来接收同步脉冲信号 VSYNC。scheduleVsync()方法通过底层nativeScheduleVsync()向SurfaceFlinger 服务注册，即在下一次脉冲接收后会调用 DisplayEventReceiver的dispatchVsync()方法。这里类似于订阅者模式，但是每次调用nativeScheduleVsync()方法都有且只有一次dispatchVsync()方法回调。
然后再看看接收VSYNC信号：
底层向应用层发送VSYNC信号，java层通过dispatchVsync()接收，最后回调在FrameDisplayEventReceiver的onVsync
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 private final class FrameDisplayEventReceiver extends DisplayEventReceiver implements Runnable private boolean mHavePendingVsync; private long mTimestampNanos; private int mFrame; @Override public void onVsync (long timestampNanos, int builtInDisplayId, int frame) if (builtInDisplayId != SurfaceControl.BUILT_IN_DISPLAY_ID_MAIN) { scheduleVsync(); return ; } ... 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); } }
可见onVsync()过程是通过FrameHandler向主线程Looper发送了一个自带callback的消息 callback为FrameDisplayEventReceiver。 当主线程Looper执行到该消息时，则调用FrameDisplayEventReceiver.run()方法，紧接着便是调用doFrame。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 void doFrame (long frameTimeNanos, int frame) final long startNanos; synchronized (mLock) { if (!mFrameScheduled) { return ; } long intendedFrameTimeNanos = frameTimeNanos; startNanos = System.nanoTime(); final long jitterNanos = startNanos - frameTimeNanos; if (jitterNanos >= mFrameIntervalNanos) { final long skippedFrames = jitterNanos / mFrameIntervalNanos; if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) { Log.i(TAG, "Skipped " + skippedFrames + " frames! " + "The application may be doing too much work on its main thread." ); } final long lastFrameOffset = jitterNanos % mFrameIntervalNanos; frameTimeNanos = startNanos - lastFrameOffset; } if (frameTimeNanos < mLastFrameTimeNanos) { scheduleVsyncLocked(); return ; } mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos); mFrameScheduled = false ; mLastFrameTimeNanos = frameTimeNanos; } try { Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame" ); mFrameInfo.markInputHandlingStart(); doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos); mFrameInfo.markAnimationsStart(); doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos); mFrameInfo.markPerformTraversalsStart(); doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos); doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos); } finally { Trace.traceEnd(Trace.TRACE_TAG_VIEW); } }
当Vsync事件到来时，顺序执行4种事件对应CallbackQueue队列中注册的回调。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 void doCallbacks (int callbackType, long frameTimeNanos) CallbackRecord callbacks; synchronized (mLock) { final long now = SystemClock.uptimeMillis(); callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(now); if (callbacks == null ) { return ; } mCallbacksRunning = true ; } try { for (CallbackRecord c = callbacks; c != null ; c = c.next) { c.run(frameTimeNanos); } } finally { synchronized (mLock) { mCallbacksRunning = false ; do { final CallbackRecord next = callbacks.next; recycleCallbackLocked(callbacks); callbacks = next; } while (callbacks != null ); } } }
按时间顺序先后执行CallbackRecord对应的run方法
1 2 3 4 5 6 7 8 9 10 11 12 13 private static final class CallbackRecord public CallbackRecord next; public long dueTime; public Object action; public Object token; public void run (long frameTimeNanos) if (token == FRAME_CALLBACK_TOKEN) { ((FrameCallback)action).doFrame(frameTimeNanos); } else { ((Runnable)action).run(); } } }
接开篇讲的
1 2 3 4 5 void scheduleTraversals () ... mChoreographer.postCallback( Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null ); }
mTraversalRunnable对应：
1 2 3 4 5 6 final class TraversalRunnable implements Runnable @Override public void run () doTraversal(); } }
run方法被执行，所以doTraversal()被执行，开启View的绘制流程。
所以整个绘制过程总的流程如下所示：
简单总结：
Choreographer支持4种类型事件：输入、绘制、动画、提交，并通过postCallback在对应需要同步vsync进行刷新处进行注册，等待回调。
Choreographer监听底层Vsync信号，一旦接收到回调信号，则通过doFrame统一对java层4种类型事件进行回调。
