前言
今天繼續螢幕重新整理機制的知識講解，上文說到vsync的處理，每一幀UI的繪製前期處理都在Choreographer中實現，那麼今天就來看看這個神奇的舞蹈編舞師是怎麼將UI變化反應到螢幕上的。
程式碼未動，圖先行
UI變化
上期說到app並不是每一個vsync訊號都能接收到的，只有當應用有繪製需求的時候，才會通過scheduledVsync 方法申請VSYNC訊號。
那我們就從有繪製需求開始看，當我們修改了UI後，都會執行invalidate方法進行繪製，這裡我們舉例setText方法，再回顧下修改UI時候的流程：
可以看到，最後會呼叫到父佈局ViewRootImpl的scheduleTraversals方法。
public ViewRootImpl(Context context, Display display) {
//...
mChoreographer = Choreographer.getInstance();
}
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
//...
}
}
為了方便檢視，我只留了相關程式碼。可以看到，在ViewRootImpl構造方法中，例項化了Choreographer物件，並且在發現UI變化的時候呼叫的scheduleTraversals方法中，呼叫了postSyncBarrier方法插入了同步屏障，然後呼叫了postCallback方法，並且傳入了一個mTraversalRunnable（後面有用處，先留意一下），暫時還不知道這個方法是幹嘛的。繼續看看。
Choreographer例項化
//Choreographer.java
public static Choreographer getInstance() {
return sThreadInstance.get();
}
private static final ThreadLocal<Choreographer> sThreadInstance =
new ThreadLocal<Choreographer>() {
@Override
protected Choreographer initialValue() {
Looper looper = Looper.myLooper();
//...
Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);
//...
return choreographer;
}
};
private Choreographer(Looper looper, int vsyncSource) {
mLooper = looper;
mHandler = new FrameHandler(looper);
//初始化FrameDisplayEventReceiver
mDisplayEventReceiver = USE_VSYNC
? new FrameDisplayEventReceiver(looper, vsyncSource)
: 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();
}
}
ThreadLocal，是不是有點熟悉？之前說Handler的時候說過，Handler是怎麼獲取當前執行緒的Looper的？就是通過這個ThreadLocal，同樣，這裡也是用到ThreadLocal來保證每個執行緒對應一個Choreographer。
儲存方法還是一樣，以ThreadLocal為key，Choreographer為value儲存到ThreadLocalMap中，不熟悉的朋友可以再翻到《Handler另類難點三問》看看。
所以這裡建立的mHandler就是ViewRootImpl所處的執行緒的handler。接著看postCallback做了什麼。
postCallback
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 {
Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
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初始化的時候，會例項化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 {
final CallbackRecord next = callbacks.next;
recycleCallbackLocked(callbacks);
callbacks = next;
} while (callbacks != null);
}
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
}
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();
}
}
}
其實就是按型別，從mCallbackQueues佇列中取任務，並執行對應的CallbackRecord的run方法。
而這個run方法中，判斷了token，並執行了action的對應方法。再回頭看看我們當初ViewRootImpl傳入的方法：
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
token為空，所以會執行到action也就是mTraversalRunnable的run方法。
所以兜兜轉轉，又回到了ViewRootImpl本身，通過Choreographer申請了VSYNC訊號，然後接收了VSYNC訊號，最終回到自己這裡，開始view的繪製。
最後看看mTraversalRunnable的run方法。
mTraversalRunnable
final class TraversalRunnable implements Runnable {
@Override
public void run() {
doTraversal();
}
}
void doTraversal() {
if (mTraversalScheduled) {
mTraversalScheduled = false;
mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
if (mProfile) {
Debug.startMethodTracing("ViewAncestor");
}
performTraversals();
if (mProfile) {
Debug.stopMethodTracing();
mProfile = false;
}
}
}
這就很熟悉了吧，呼叫了performTraversals方法，也就是開始了測量，佈局，繪製的步驟。同時，關閉了同步屏障。
總結
最後再看看總結圖：
參考
https://juejin.cn/post/6863756420380196877
https://blog.csdn.net/stven_king/article/details/78775166
拜拜
有一起學習的小夥伴可以關注下❤️ 我的公眾號——碼上積木，每天剖析一個知識點，我們一起積累知識。公眾號回覆111可獲得面試題《思考與解答》以往期刊。
