Android 系统架构 —— Choreographer 的工作机制

public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, ThreadedRenderer.DrawCallbacks {
    ......
    
    Choreographer mChoreographer;
     
    public ViewRootImpl(Context context, Display display) {
        ......
        mContext = context;
        ......
        // 获取渲染编舞者实例对象
        mChoreographer = Choreographer.getInstance();
    }

}

public final class Choreographer {
    
    // Thread local storage for the choreographer.
    private static final ThreadLocal<Choreographer> sThreadInstance =
            new ThreadLocal<Choreographer>() {
        @Override
        protected Choreographer initialValue() {
            Looper looper = Looper.myLooper();
            if (looper == null) {
                throw new IllegalStateException("The current thread must have a looper!");
            }
            // 创建 Choreographer 对象
            Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);
            if (looper == Looper.getMainLooper()) {
                mMainInstance = choreographer;
            }
            return choreographer;
        }
    };

    private static volatile Choreographer mMainInstance;

    public static Choreographer getInstance() {
        return sThreadInstance.get();
    }
    
}

public final class Choreographer {
    
    private static final boolean USE_VSYNC = SystemProperties.getBoolean(
            "debug.choreographer.vsync", true);
    
    
    // 触摸事件
    public static final int CALLBACK_INPUT = 0;
    // 动画的 Callback
    public static final int CALLBACK_ANIMATION = 1;
    // View 遍历的 Callback
    public static final int CALLBACK_TRAVERSAL = 2;
    // 在 Traversals 之后, 优先级最低的 Callback
    public static final int CALLBACK_COMMIT = 3;

    private static final int CALLBACK_LAST = CALLBACK_COMMIT;
    
    private Choreographer(Looper looper, int vsyncSource) {
        mLooper = looper;
        // 1. 用于处理 Frame 相关消息的 Handler
        mHandler = new FrameHandler(looper);
        // 2. 创建垂直同步信号的接收器
        mDisplayEventReceiver = USE_VSYNC
                ? new FrameDisplayEventReceiver(looper, vsyncSource)
                : null;
        // 记录最后绘制的时间
        mLastFrameTimeNanos = Long.MIN_VALUE;
        // 记录每帧间隔: 1s / 屏幕刷新率
        mFrameIntervalNanos = (long)(1000000000 / getRefreshRate());
        // 3. 创建 CallbackQueue 数组, 一共有 4 个 CallbackQueue
        mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];
        for (int i = 0; i <= CALLBACK_LAST; i++) {
            mCallbackQueues[i] = new CallbackQueue();
        }
        // b/68769804: 用于 Low FPS 实验
        setFPSDivisor(SystemProperties.getInt(ThreadedRenderer.DEBUG_FPS_DIVISOR, 1));
    }
    
}

public final class Choreographer {
    
    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);
        }
        
    }
    
}

public abstract class DisplayEventReceiver {
    
    // 描述 APP-VSYNC 信好
    public static final int VSYNC_SOURCE_APP = 0;
    
    private MessageQueue mMessageQueue;
    private long mReceiverPtr;

    public DisplayEventReceiver(Looper looper, int vsyncSource) {
        ......
        mMessageQueue = looper.getQueue();
        // 调用了进行 Native 初始化 
        mReceiverPtr = nativeInit(new WeakReference<DisplayEventReceiver>(this), mMessageQueue,
                vsyncSource);
    }
    
    private static native long nativeInit(WeakReference<DisplayEventReceiver> receiver,
            MessageQueue messageQueue, int vsyncSource);
    
}

public final class Choreographer {
    
    public void postCallback(int callbackType, Runnable action, Object token) {
        postCallbackDelayed(callbackType, action, token, 0);
    }

    @TestApi
    public void postCallbackDelayed(int callbackType,
            Runnable action, Object token, long delayMillis) {
        ......
        postCallbackDelayedInternal(callbackType, action, token, delayMillis);
    }

    private void postCallbackDelayedInternal(int callbackType,
            Object action, Object token, long delayMillis) {
        ......
        synchronized (mLock) {
            final long now = SystemClock.uptimeMillis();
            final long dueTime = now + delayMillis;
            // 1. 添加到指定类型的 CallbackQueue 中
            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
            // 2. 请求 VSYNC 信号
            // 2.1 若需要现在执行, 则立即请求 VSYNC 信号
            if (dueTime <= now) {
                scheduleFrameLocked(now);
            } 
            // 2.2 投递到 MessageQueue 中, 到 dueTime 时刻再请求 VSYNC 信号
            else {
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                msg.arg1 = callbackType;
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, dueTime);
            }
        }
    }
    
}

public final class Choreographer {

    private void scheduleFrameLocked(long now) {
        if (!mFrameScheduled) {
            mFrameScheduled = true;
            // 1. 支持 VSYNC
            if (USE_VSYNC) {
                // 1.1 若是执行在 Choreographer Looper 的线程, 则立即执行
                if (isRunningOnLooperThreadLocked()) {
                    scheduleVsyncLocked();
                } else {
                    // 1.2 否则, 投递到 Looper 的消息队列中执行
                    Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
                    msg.setAsynchronous(true);
                    mHandler.sendMessageAtFrontOfQueue(msg);
                }
            } 
            // 2. 若不支持 VSYNC
            else {
                // 则手动计算下一帧的准备的时间
                final long nextFrameTime = Math.max(
                        mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);
                ......
                // 发送 MSG_DO_FRAME 执行帧的准备
                Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, nextFrameTime);
            }
        }
    }
    
    private void scheduleVsyncLocked() {
        mDisplayEventReceiver.scheduleVsync();
    }
    
}

public abstract class DisplayEventReceiver {

    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);
        }
    }
    
    private static native void nativeScheduleVsync(long receiverPtr);

}

public abstract class DisplayEventReceiver {


    // Called from native code.
    @SuppressWarnings("unused")
    private void dispatchVsync(long timestampNanos, int builtInDisplayId, int frame) {
        // 回调实现类 FrameDisplayEventReceiver 的 onVsync 方法
        onVsync(timestampNanos, builtInDisplayId, frame);
    }

}

public final class Choreographer {

    private final class FrameDisplayEventReceiver extends DisplayEventReceiver
            implements Runnable {
   
        @Override
        public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
            // Choreographer 目前不支持处理第二个显示屏的 VSYNC 信号
            if (builtInDisplayId != SurfaceControl.BUILT_IN_DISPLAY_ID_MAIN) {
                ......
                return;
            }

            // 矫正 VSYNC 信号的时间
            long now = System.nanoTime();
            if (timestampNanos > now) {
                timestampNanos = now;
            }
            
            if (mHavePendingVsync) {
                
            } else {
                mHavePendingVsync = true;
            }
            
            mTimestampNanos = timestampNanos;
            // 记录垂直同步信号的数量
            mFrame = frame;
            // 发送一个异步消息, 保证 MessageQueue 的睡眠被立即唤醒
            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);
        }
        
    }

}

public final class Choreographer {
    
    // 丢帧上报上限为 30 帧
    private static final int SKIPPED_FRAME_WARNING_LIMIT = SystemProperties.getInt(
            "debug.choreographer.skipwarning", 30);
    
    void doFrame(long frameTimeNanos, int frame) {
        final long startNanos;
        // 1. 更新待准备帧信息
        synchronized (mLock) {
            if (!mFrameScheduled) {
                return; // no work to do
            }
            ......

            long intendedFrameTimeNanos = frameTimeNanos;
            startNanos = System.nanoTime();
            
            // 1.1 计算丢帧数量
            // 计算当前 doFrame 执行时间, 和这个 VSYNC 到来的时间差
            final long jitterNanos = startNanos - frameTimeNanos;
            if (jitterNanos >= mFrameIntervalNanos) {
                // 1.2 计算丢帧数量
                final long skippedFrames = jitterNanos / mFrameIntervalNanos;
                if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) {
                    // 若我们在主线程处理耗时操作是, 控制台便会打印这条日志
                    Log.i(TAG, "Skipped " + skippedFrames + " frames!  "
                            + "The application may be doing too much work on its main thread.");
                }
                // 1.3 矫正 VSYNC 发布时间
                final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;
                ......
                frameTimeNanos = startNanos - lastFrameOffset;
            }
            ......
            
            // 1.3 更新当前要准备的帧信息
            mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos);
            mFrameScheduled = false;
            mLastFrameTimeNanos = frameTimeNanos;
        }
        // 2. 执行回调队列, 准备帧信息
        try {
            Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame");
            AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);
            
            // 2.1 执行输入流的 Callback 队列
            mFrameInfo.markInputHandlingStart();
            doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);
            
            // 2.2 执行动画的 Callback 队列
            mFrameInfo.markAnimationsStart();
            doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);
            
            // 2.3 执行 View 绘制流程的 Callback 队列
            mFrameInfo.markPerformTraversalsStart();
            doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);
            
            // 2.4 执行 COMMIT 的 Callback 队列
            doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);
        } finally {
            AnimationUtils.unlockAnimationClock();
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
        ......
    }
    
}

public final class Choreographer {

    void doCallbacks(int callbackType, long frameTimeNanos) {
        CallbackRecord callbacks;
        synchronized (mLock) {
            ......
            final long now = System.nanoTime();
            // 1. 获取指定 Type 的回调队列
            callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(
                    now / TimeUtils.NANOS_PER_MS);
            if (callbacks == null) {
                return;
            }
            mCallbacksRunning = true;
            ......
        }
        try {
            // 2. 执行所有 CallbackRecord 的 run 方法
            for (CallbackRecord c = callbacks; c != null; c = c.next) {
                c.run(frameTimeNanos);
            }
        } finally {
            synchronized (mLock) {
                mCallbacksRunning = false;
                // 3. 释放 CallbackRecord 资源
                do {
                    final CallbackRecord next = callbacks.next;
                    recycleCallbackLocked(callbacks);
                    callbacks = next;
                } while (callbacks != null);
            }
            ......
        }
    }
    
}