本文主要讲 view.requestLayout() 到 view 重新绘制成功流程。
view.requestLayout 调用的是 parent.requestLayout，直到 DecorView 最终到 ViewRootImpl.requestLayout 方法。
提示: requestLayout() 跟 invalidate() 区别在于 PFLAG_FORCE_LAYOUT、PFLAG_INVALIDATED，invalidate 不会重新测量布局，只会重新绘制
@Override
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
//1. 当前调用线程检查
checkThread();
mLayoutRequested = true;
//2.
scheduleTraversals();
}
}
void checkThread() {
//1.1 调用线程必须在主线程
if (mThread != Thread.currentThread()) {
throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can touch its views.");
}
@UnsupportedAppUsage
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
//首先中执行同步屏障，msg.target 为空,该 msg 会插入到 messageQueue 合适的位置，
//当 messageQueue.next() 发现有 target 为空的空的消息，则优先找 msg.isAsynchronous() 的消息插队，此处是为了 vsync 消息优先执行
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
//2.1 主要将 mTraversalRunnable 传递给 mChoreographer
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
}
}
}
Choreographer
调用栈：mChoreographer.postCallback(int callbackType, Runnable action, Object token) --> postCallbackDelayed() --> postCallbackDelayedInternal()
//参数 action 是 ViewRootImpl 中 mTraversalRunnable
private void postCallbackDelayedInternal(int callbackType,
Object action, Object token, long delayMillis) {
...
synchronized (mLock) {
final long now = SystemClock.uptimeMillis();
final long dueTime = now + delayMillis;
//2.1.1 Choreographer 将任务保存在 mCallbackQueues 中，callbackType 为 CALLBACK_TRAVERSAL，等待 vsync 到来时通过类型回调 runnable
mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
//如果不是延时消息，立即请求 vsync
if (dueTime <= now) {
//2.1.2
scheduleFrameLocked(now);
} else {
////2.1.3 延时消息，发送 MSG_DO_SCHEDULE_CALLBACK 的同步消息给 FrameHandler，
Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
msg.arg1 = callbackType;
//设置为异步消息，结合第 2 步的 postSyncBarrier 使用，是的该消息优先普通消息执行
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, dueTime);
}
}
}
private void scheduleFrameLocked(long now) {
if (!mFrameScheduled) {
mFrameScheduled = true;
if (USE_VSYNC) {
...
// 2.1.2.1 当运行在 Looper 线程，则立刻调度 vsync，否则发送消息到 UI 线程再调度 vsync
if (isRunningOnLooperThreadLocked()) {
//下面再看该方法
scheduleVsyncLocked();
} else {
//// 2.1.2.2 发送消息到 UI 线程，请求 vsync
Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
msg.setAsynchronous(true);
mHandler.sendMessageAtFrontOfQueue(msg);
}
} else {
// 否则执行 doFrame
Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, nextFrameTime);
}
}
}
@UnsupportedAppUsage
private void scheduleVsyncLocked() {
//通过 FrameDisplayEventReceiver 调度 vysnc，最终调用 nativeScheduleVsync() 方法
mDisplayEventReceiver.scheduleVsync();
}
至此从调用 requestLayout 到请求 Vsync 信号过程已经结束。
下面看收到 Vsync 信号后，如何处理 mTraversalRunnable 任务。
FrameDisplayEventReceiver
private final class FrameDisplayEventReceiver extends DisplayEventReceiver
implements Runnable {
private boolean mHavePendingVsync;
private long mTimestampNanos;
private int mFrame;
...
//收到 vsync 信号回调该方法
@Override
public void onVsync(long timestampNanos, long physicalDisplayId, int frame) {
...
//3.1 FrameDisplayEventReceiver 是一个 Runnable 的 callback，把此对象作为异步消息发送给 FrameHandler，随后 handler 会调用改对象的 run 方法。
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;
//3.2 FrameHandler 执行该方法，回到 Choreographer 的 doFrame 方法
doFrame(mTimestampNanos, mFrame);
}
}
回到 Choreographer
@UnsupportedAppUsage
void doFrame(long frameTimeNanos, int frame) {
final long startNanos;
synchronized (mLock) {
...
//省略，主要一计算掉帧逻辑，二是记录帧绘制信息
...
try {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame");
AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);
mFrameInfo.markInputHandlingStart();
//处理多种callback
//依次是 input 调用栈,会回调到 DecorView 的 dispatchTouchEvent
doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);
mFrameInfo.markAnimationsStart();
//二是 animation 用栈,
doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);
doCallbacks(Choreographer.CALLBACK_INSETS_ANIMATION, frameTimeNanos);
////三是Traversal调用栈，即最发送给 Choreographer 的任务 mTraversalRunnable
mFrameInfo.markPerformTraversalsStart();
doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);
doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);
} finally {
AnimationUtils.unlockAnimationClock();
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
...
}
void doCallbacks(int callbackType, long frameTimeNanos) {
CallbackRecord callbacks;
synchronized (mLock) {
final long now = System.nanoTime();
//通过 callbackType 取出 callbacks
callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(
now / TimeUtils.NANOS_PER_MS);
if (callbacks == null) {
return;
}
mCallbacksRunning = true;
...
try {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, CALLBACK_TRACE_TITLES[callbackType]);
for (CallbackRecord c = callbacks; c != null; c = c.next) {
//调用 Runnable.run 方法，mTraversalRunnable run 会调用 doTraversal() 方法
c.run(frameTimeNanos);
}
} finally {
...
}
}
doTraversal()方法则是 测量、布局、绘制 入口，此处不做分析。
Vsync 垂直同步：
涉及到垂直刷新脉冲、vsync 、gpu 缓冲区 Frame Buffer、Back Buffer 三重缓存，跟 Choreographer
gpu 像素栅格化
垂直同步使得显卡的输出帧数和屏幕的刷新速度保持一致，其中 vsync 用来同步信息，buffer 缓存数据，当 vsync 出现时，cpu 会立即处理下一帧数据写入到缓存中，
之后gpu再渲染数据写在同一个缓存中，当vsync时，下一帧的 buffer 跟当前帧所在的buffer数据交换，当如果之前帧未显示完，是不会进行数据交换的。屏幕扫描下一次的数据显示。
当一个信号来时，假设a b buffer都被占用，此时gpu使用c缓存下一帧的数据，可以有效减少掉帧的几率。
Choreographer（编舞者）
FrameHandler 处理 3 各消息类型
MSG_DO_FRAME:开始渲染下一帧操作
MSG_DO_SCHEDULE_VSYNC:请求 Vsync 信号
MSG_DO_SCHEDULE_CALLBACK:请求执行 callback
FrameDisplayEventReceiver 用来接收垂直跟发送同步信号
总结：
1、view.requestLayout 调用的是 parent.requestLayout ,直到 DecorView 最终到 ViewRootImpl.requestLayout 方法。
2、首先判断正在测量布局，没有则 checkThread 检验当前是否在主线程。在 scheduleTraversals 首先中执行同步屏障，其次再将任务 postCallback 给 Choreographer，Choreographer 将任务保存在 mCallbackQueues 中，同时发送 MSG_DO_SCHEDULE_CALLBACK 的同步消息给FrameHandler。FrameHandler 的优先执行 CALLBACK 同步消息调用 doScheduleCallback，mCallbackQueues 不为空且 callback 不是延迟执行，调用 scheduleFrameLocked 方法请求 Vsync 信号。当运行在 Looper 线程，则立刻调度 vsync，否则，发送消息到UI线程再调度 vsync。其中是通过 FrameDisplayEventReceiver 调度 vysnc。
FrameDisplayEventReceiver 有两个作用，一个是 scheduleVsync 请求调度，另一个是接收 vsync 信号回调 onVsync，当接收到 vsync 信号时，调用doFrame 方法，开始渲染下一帧。
doFrame 可以分为三步：一是计算掉帧逻辑，二是记录帧绘制信息，三是处理多种 callback，依次是 input 调用栈,会回调到 DecorView 的 dispatchTouchEvent。
二是 animation 调用栈，执行动画；三是 Traversal 调用栈，即最发送给 Choreographer 的任务
doTraversal()->performTraversals() ->
performMeasure():measere():onMeasure()->
performLayout():layout():onLayout()->
performDraw():drawSoftware():draw()->drawBackground()->保存当前图层信息(可跳过) ->onDraw()-> dispatchDraw()->绘制View边缘、阴影效果(可跳过)->onDrawForeground()装饰、滚动条.
动画如何流畅执行：调用animation.start时，最终在AnimationHandler会给Choreographer.FrameCallback 回调 doFrame，里面 post了自己。
