淺談Android的Choreographer

對於渲染繪製的分析，我們從ViewRootImpl中的scheduleTraversals方法着手，從這個方法開始觸發performTraversals，之後會調用onMeasure，onLayout，onDraw進行界面的繪製。

那麼先來看一看scheduleTraversals這個方法吧~

void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            if (!mUnbufferedInputDispatch) {
                scheduleConsumeBatchedInput();
            }
            notifyRendererOfFramePending();
            pokeDrawLockIfNeeded();
        }
    }

繼續追蹤

mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

這裏提示一下跟進的流程：
postCallback()->postCallbackDelayed()->postCallbackDelayedInternal():

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);
            //delayMillis傳的是0，故此處進入條件
            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 void scheduleFrameLocked(long now) {
        if (!mFrameScheduled) {
            mFrameScheduled = true;
            if (USE_VSYNC) {
                if (DEBUG_FRAMES) {
                    Log.d(TAG, "Scheduling next frame on 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

// Enable/disable vsync for animations and drawing.
    private static final boolean USE_VSYNC = SystemProperties.getBoolean(
            "debug.choreographer.vsync", true);

緊接着scheduleVsyncLocked()-> mDisplayEventReceiver.scheduleVsync()->nativeScheduleVsync(mReceiverPtr)
走到一個native方法。最後在底層處理垂直同步，然後會回調onVsync()方法，抽象類DisplayEventReceiver沒有實現這個方法的調用，我們找到實現類是FrameDisplayEventReceiver。

@Override
public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
    ...

    mTimestampNanos = timestampNanos;
    mFrame = frame;
    Message msg = Message.obtain(mHandler, this);
    msg.setAsynchronous(true);
    mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
}

把自身包裝成Message傳給了handler，調用其run方法：

@Override
        public void run() {
            mHavePendingVsync = false;
            doFrame(mTimestampNanos, mFrame);
        }

        void doFrame(long frameTimeNanos, int frame) {
        final long startNanos;
        synchronized (mLock) {
            ...
            //是否有跳幀，如果有那麼就打印log並且修正偏差
        }

        //執行callback
        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.");
        }
    }

doFrame方法做的就是渲染下一幀，第一個痛不塊中就是去檢測是否卡頓並修補卡頓。然後開始做渲染工作，我們看幾個doCallbacks方法的參數：
CALLBACK_INPUT：輸入
CALLBACK_ANIMATION:動畫
CALLBACK_TRAVERSAL:遍歷，執行measure、layout、draw
CALLBACK_COMMIT：遍歷完成的提交操作，用來修正動畫啓動時間

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

Choreographer內部維護了這四種鏈表，渲染每一幀的時候都會從上往下的去執行相應的渲染操作，有輸入那麼就先渲染輸入隊列，有動畫就渲染動畫，然後遍歷，然後提交。

總結
控制外部輸入事件處理，動畫執行，UI變化，以及提交執行都是在同一個類中做的處理，即是Choreographer。

在Choreographer對象中有四條鏈表，分別保存着待處理的輸入事件，待處理的動畫事件，待處理的遍歷事件，以及待處理的提交時間。

每次執行的時候，Choreographer會根據當前的時間，只處理事件鏈表中最後一個事件，當有耗時操作在主線程時，事件不能及時執行，就會出現所謂的“跳幀”，“卡頓”現象。

Choreographer的共有方法postCallback(callbackType, Object)是往事件鏈表中放事件的方法。而doFrame()是消耗這些事件的方法。