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

Choreographer全解析

前言

代码未动，图先行

UI变化

Choreographer实例化

postCallback

scheduleFrameLocked（准备申请VSYNC信号）

小结1

scheduleVsyncLocked

onVsync（接收VSYNC信号）

doFrame（绘制帧数据）

doCallbacks（执行任务）

mTraversalRunnable

总结

参考

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Choreographer全解析

前言

代码未动，图先行

UI变化

Choreographer实例化

postCallback

scheduleFrameLocked（准备申请VSYNC信号）

小结1

scheduleVsyncLocked

onVsync（接收VSYNC信号）

doFrame（绘制帧数据）

doCallbacks（执行任务）

mTraversalRunnable

总结

参考

热门文章

最新文章

相关课程

相关电子书