Choreographer全解析

前言

今天继续屏幕刷新机制的知识讲解，上文说到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可获得面试题《思考与解答》以往期刊。

巴特西