Android 怎么就不卡了呢之Choreographer_choreography 安卓

### 1.2 FrameHandler


上一小节，如果已经到期就直接执行scheduleFrameLocked（）方法，如果没有执行就使用mHandler（FrameHandler类型）发送一个what值为**MSG\_DO\_SCHEDULE\_CALLBACK**的Message。到期后怎么执行的呢。这要看FrameHandler怎么处理的。

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:
//postCallbackDelayedInternal（）方法中当未到期的时候发送过来的
doScheduleCallback(msg.arg1);
break;
}
}
}

以上代码我们可以看出这个，FramHandler拿到 whate属性值为**MSG\_DO\_SCHEDULE\_CALLBACK**的时候会去执行 doScheduleCallback(msg.arg1);方法，跟进去看下


### 1.3 Choreography#doScheduleCallback

void doScheduleCallback(int callbackType) {
synchronized (mLock) {
if (!mFrameScheduled) {
final long now = SystemClock.uptimeMillis();
if (mCallbackQueues[callbackType].hasDueCallbacksLocked(now)) {
scheduleFrameLocked(now);
}
}
}
}

这个方法中先是做了一些判断，mFrameSceduled为false 并且hasDueCallbacksLocked（）这个方法的返回值为true，看方法名就能猜出这个callback是否到期了，下面我们再分析这个。最终如果满足条件的情况下它会调用 scheduleFrameLocked()这个方法，咦这个方法眼熟不？对，没错，postCallbackDelayedInternal（）方法中如果到期了的话就直接执行的那个方法。是时候看这个方法里面搞的什么事情了。


### 1.4 scheduleFrameLocked（）

private void scheduleFrameLocked(long now) {
    if (!mFrameScheduled) {
        mFrameScheduled = true;//设置标记位，表示已经安排请求下一帧渲染了。
        if (USE_VSYNC) {

​
// If running on the Looper thread, then schedule the vsync immediately,
// otherwise post a message to schedule the vsync from the UI thread
// as soon as possible.
/**
翻译一下，如果在主线程中，就直接调用立即安排垂直同步，否则也就是非主线程的化就发送一个消息在主线程尽快安排一个垂直同步
*/
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为true，也就是设备支持垂直同步
* 如果不是垂直同步就通过handler发送一个延时一个周期的消息安排垂直同步，这个Message的what值为 **MSG\_DO\_FRAME**，参照1.2的代码块对what为MSG\_DO\_FRAME的消息会去执行doFrame（）方法。
* 一个细节,当这个值mFrameScheduled为true的时候就直接返回不安排请求下一帧渲染了，如果为false，执行scheduleFrameLocked（）方法继续执行，并且将其设置为ture；在什么时候设置为false的呢？


安排垂直同步的具体实现是FrameDisplayEventReceiver类他是DisplayEventReceiver的用于接收垂直信号

private final class FrameDisplayEventReceiver extends DisplayEventReceiver
        implements Runnable {
    private boolean mHavePendingVsync;
    private long mTimestampNanos;
    private int mFrame;

​
public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {
super(looper, vsyncSource);
}
@Override
public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
mTimestampNanos = timestampNanos;
mFrame = frame;
Message msg = Message.obtain(mHandler, this);
msg.setAsynchronous(true);//Message设置为异步
mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
}
@Override
public void run() {
mHavePendingVsync = false;
doFrame(mTimestampNanos, mFrame);
}
}

接收到垂直同步信号后回调onVsync方法，这个方法使用handler发送带callback（Runnable类型，自身已继承）的message，最后run（）中也是调用doFrame（）;


这个message设置为了异步 （msg.setAsynchronous(true);）这意味这他有优先执行的权利，他是怎么被优先执行的呢？


综上，添加callback流程


![](https://img-blog.csdnimg.cn/img_convert/13ceffb733f532f07477f1cd77071960.webp?x-oss-process=image/format,png)


## 二、执行


#### doFrame

void doFrame(long frameTimeNanos, int frame) {
    final long startNanos;
    synchronized (mLock) {
        if (!mFrameScheduled) {
            return; // no work to do
        }

​
//当前时间
startNanos = System.nanoTime();
//当前时间和垂直同步时间
final long jitterNanos = startNanos - frameTimeNanos;
//垂直同步时间和当前时间的差值如果大于一个周期就修正一下
if (jitterNanos >= mFrameIntervalNanos) {
//取插值和始终周期的余数
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”);
AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);
​
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 {
AnimationUtils.unlockAnimationClock();
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
​
if (DEBUG_FRAMES) {
final long endNanos = System.nanoTime();
Log.d(TAG, "Frame " + frame + “: Finished, took "
+ (endNanos - startNanos) * 0.000001f + " ms, latency "
+ (startNanos - frameTimeNanos) * 0.000001f + " ms.”);
}
}

0. **第一步修正判断**


* 当前时间 startNanos = System.nanoTime();
* 求当前时间和垂直同步时间的差值 ：jitterNanos = startNanos - frameTimeNanos;
* 垂直同步时间和当前时间的差值如果大于一个周期（jitterNanos >= mFrameIntervalNanos）就修正一下


	+ 取插值和始终周期的余数：lastFrameOffset = jitterNanos % mFrameIntervalNanos;
	+ 当前时间减去上一步得到的余数当作最新的始终信号时间：frameTimeNanos = startNanos - lastFrameOffset;
* 垂直同步时间上一次时间还小，就安排下次渲染： frameTimeNanos < mLastFrameTimeNanos，直接返回


0. **第二步‍执行callback** callback的执行顺序是：


* CALLBACK\_INPUT输入时间优先级最高
* CALLBACK\_ANIMATION 动画的次之
* CALLBACK\_TRAVERSAL UI绘制布局的再次之
* CALLBACK\_COMMIT动画修正相关最后。


### 2.2 doCallbacks();


* 在 **CallbackQueue[] mCallbackQueues**在取特定类型（输入，动画，布局，Commit）的单向链表
* 然后取出已到期的Callback/Runable执行


##### 取出需要被执行的Actions


Action包装在CallbackRecord中，是一个单向列表，按照时间的大小顺序排列的。 取出待执行的Actions是通过CallBackQueue的extractDueCallbacksLocked（）方法，可以把CallBackQueue看做是CallBack的管理类，其中还包括添加Action addCallbackLocked（），移除Action removeCallbacksLocked（）,是否有带起的Anction hasDueCallbacksLocked（）方法。

private final class CallbackQueue {
//链表头
private CallbackRecord mHead;
//是否存在已经到期的Action
public boolean hasDueCallbacksLocked(long now) {
return mHead != null && mHead.dueTime <= now;
}
//获取已经到期的Action
public CallbackRecord extractDueCallbacksLocked(long now) {
…
return callbacks;
}
​
//添加Action
public void addCallbackLocked(long dueTime, Object action, Object token) {
…
}
//移除Action
public void removeCallbacksLocked(Object action, Object token) {
…
}
}

##### 执行Action

for (CallbackRecord c = callbacks; c != null; c = c.next) {
c.run(frameTimeNanos);
}

从callback中遍历出CallBcakRecord，挨个执行。


## 三、小结


* Choreographer对外提供了postCallback等方法，最终他们内部都是通过调用postCallbackDelayedInternal（）实现这个方法主要会做两件事情


	+ 存储Action
	+ 请求垂直同步，垂直同步
* 垂直同步回调立马执行Action（CallBack/Runnable）。
* Action一个动作内容的类型可能是


	+ CALLBACK\_INPUT输入时间优先级最高
	+ CALLBACK\_ANIMATION 动画的次之
	+ CALLBACK\_TRAVERSAL UI绘制布局的再次之
	+ CALLBACK\_COMMIT动画修正相关最后。
* 复习Hanlder机制，我认为他是Android系统跑起来的大引擎终点关注下，handler对message的分发执行，以及“异步模式”。


## 附


### 附一、关于handler执行Message


下面是handler分发逻辑，Looper在MessageQueue得到要执行的message之后就会交给message的target（Handler类型）属性处理msg.target.dispatchMessage(msg);;

public void dispatchMessage(Message msg) {
//当msg的callback不为空的时候直接执行msg的callback它是一个Runnable对象
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
//然后再交给mCallBack，它是handler的一个属性， 
//创建Handler的时候可以选择传入一个CallBack对象
//当callBack中handleMessage返回true的时候表示：True if no further handling is desired（不需要进一步处理）

        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
//当mCallback处理返回为false的时候才去执行Handler自身的handleMessage（）方法
        handleMessage(msg);
    }
}

关键逻辑在已注释，小结一下 handler的执行分发Message逻辑


0. 如果message的callback（runnable）属性不为空，调用这个runable的run（）方法执行

private static void handleCallback(Message message) {
message.callback.run();
}

当我们使用handler.post(Runnable r)方法时候就是将r设置给message的callback


0. 上述条件不满足的情况下，如果handler自身的mCallback不为空的时候就会，将message交给mCallback处理，handlerMessage（）结束。这个属性是在handler创建的时候传入的。mCallback是CallBack类型，他是handler的一个内部接口。

public interface Callback {
     boolean handleMessage(Message msg);
}

3.当messaga 的callBak为空，且handler的mCallBack为空的时候就交给自己的handlerMessage（）方法执行了。我们在自定义handler的时候可以重写这个方法对message进行相应的操作。


### 附二 、mFrameScheduled属性作用


* 执行callcack的时候会判断mFrameScheduled属性如果为false表示没有安排渲染下一帧就直接返回，不执行。

void doFrame(long frameTimeNanos, int frame) {
final long startNanos;
synchronized (mLock) {
if (!mFrameScheduled) {
return; // no work to do
}
…
…
mFrameScheduled = false;
…
}

* 在scheduleFrameLocked()方法中，将mFrameScheduled值设置为ture表示安排了请求渲染下一帧。如果这时mFrameScheduled为true表示已经安排了下一帧那么就返回，不添乱！


### 附三、Handler机制的异步模式


##### 作用