android刷新屏幕,Android屏幕刷新机制（一）

Android屏幕刷新机制(一)：屏幕刷新发生了什么

参考

不过原文是从源码揭秘的角度从代码调用的层面层层深入到了底层，教着看源码摸原理。本文倒着来，直接说了原理，然后按着Android系统的步骤看代码是怎么走的。

开始

硬件——屏幕发送信号

Android 屏幕每16.6ms刷新一次【60fps，即1000ms/60f = 16.6ms】。也就是屏幕【Display】每隔16ms就会发出一次VSYNC信号。

image-20201031131730052.png

系统——接收屏幕传来的VSync信号

接收此信号系统类叫DisplayEventReceiver，是个抽象类。

/**

* Provides a low-level mechanism for an application to receive display events

* such as vertical sync.

*

* The display event receive is NOT thread safe. Moreover, its methods must only

* be called on the Looper thread to which it is attached.

*

* @hide

*/

public abstract class DisplayEventReceiver {

...

/**

* Called when a vertical sync pulse is received.

* 在VSync脉冲到达时会被调用

* The recipient should render a frame and then call {@link #scheduleVsync}

* 接受者应该rende a frame(渲染好框架？)并调用 #scheduleVsync

* to schedule the next vertical sync pulse.

*/

@UnsupportedAppUsage

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

}

...

/**

* Schedules a single vertical sync pulse to be delivered when the next

* display frame begins.

* 在下一帧到来前Schedules(规划)一个 用于被接收的 VSync脉冲

*/

@UnsupportedAppUsage

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

}

}

...

}

其中两个方法：onVsync是接收到脉冲信息时的回调，注释告诉我们在这之前会先调用scheduleVsync；scheduleVsync相当于对即将到来的下一帧注册了一个监听，只有注册了，下一帧才会调用到onVsync方法中来。

具体实现这个抽象类的是FrameDisplayEventReceiver。

private final class FrameDisplayEventReceiver extends DisplayEventReceiver implements Runnable {

@Override

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

// Post the vsync event to the Handler.

// The idea is to prevent incoming vsync events from completely starving

// the message queue. If there are no messages in the queue with timestamps

// earlier than the frame time, then the vsync event will be processed immediately.

// Otherwise, messages that predate the vsync event will be handled first.

long now = System.nanoTime();

if (timestampNanos > now) {

Log.w(TAG, "Frame time is " + ((timestampNanos - now) * 0.000001f)

+ " ms in the future! Check that graphics HAL is generating vsync "

+ "timestamps using the correct timebase.");

timestampNanos = now;

}

if (mHavePendingVsync) {

Log.w(TAG, "Already have a pending vsync event. There should only be "

+ "one at a time.");

} else {

mHavePendingVsync = true;

}

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中接收到信号后创建了一个Message,将自身(this)传了进去【因为自身实现了Runnable接口】。再通过mHandler发了出去。mHandler是一个FrameHandler，所以要去看FrameHandler。

用Handler传递消息

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://0

doFrame(System.nanoTime(), 0);

break;

case MSG_DO_SCHEDULE_VSYNC://1

doScheduleVsync();

break;

case MSG_DO_SCHEDULE_CALLBACK://2

doScheduleCallback(msg.arg1);

break;

}

}

}

显然，传入的msg未设置msg,所以msg为0。走doFrame(System.nanoTime(), 0);

走错了，因为Handler 在处理消息时会先查看 Message 是否有 callback，有则优先交由 Message 的 callback 处理消息，没有的话再去看看Handler 有没有 callback，如果也没有才会交由 handleMessage() 这个方法执行。

所以这里会直接执行doFrame()方法。

void doFrame(long frameTimeNanos, int frame) {

final long startNanos;

synchronized (mLock) {

...

mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos);

mFrameScheduled = false;

mLastFrameTimeNanos = frameTimeNanos;

}

try {

Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame");

AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);

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

}

}

doFrame代码有点长，里面有一段try catch 包裹的代码，不停的在doCallbacks(int,long)。源码往下滑两行就发现doCallbacks就在下面。

Handler收到消息走doFrame，又走doCallbacks

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

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

if (DEBUG_FRAMES) {

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

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

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

}

//② 循环调用callback.run

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

}

}

① mCallbackQueues

从mCallbackQueues的第callbackType个元素中，提取一个callback【extractDueCallbacksLocked()】。

mCallbackQueues是一个长度为5的队列，存的是元素CallbackQueue。

mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];

for (int i = 0; i <= CALLBACK_LAST; i++) {

mCallbackQueues[i] = new CallbackQueue();

}

CallbackQueue听名字又是一个队列。没错，就是队列中存放着队列。CallbackQueue中存放的元素是CallbackRecord，链表的形式。所以大概是这个样子：

image-20201101151630877.png

②c.run(frameTimeNanos);

取出来是一串链子(callbacks)，所以一个for循环，循环调用run方法。

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();

}

}

}

嗯？token是啥？action是啥？接下来怎么走？？不知道。因为这个CallbackRecord又不是我们加进来的，至少在上面分析的代码中没看到add操作。

总结：屏幕刷新发生了什么

屏幕每16.6ms向系统层面发送一个VSync信号，系统在FrameDisplayEventReceiver的onVsync()里通过Handler发送了个Message(把FrameDisplayEventReceiver自己作为runnable传了进去)。Handler中收到message后就调用doFrame中的doCallbacks方法，从一个**链表组成的列表(CallbackQueue)**中取链子(CallbackRecord)，然后调用每个链子(CallbackRecord`)的run方法。