Android Choreographer源码分析

     搞客户端开发，时间也有点了，但是每次想起来，总感觉自己掌握的东西零零散散，没有一点集在的感觉，应用层的懂，framework的也懂，框架啥的了解一点，分层的思想也有一些，JVM的原理啊，内存分配和管理啊，运行机制啊啥的也知道一点，每次下班或者没事了，就在考虑，自己应该有一个主攻方向，往这个方向集中发展一下，首选的几个目标应该是非常清楚的，我们要掌握android，那么关于android的View机制、动画原理这些都是必须要掌握的，所以呢，自己想在这几个方面花些时间，好好研究一下，这样才能使自己更具竞争力。

     好了，不管是要了解View机制，还是android动画，我们应该都需要有Choreographer的知识，明白系统刷新机制到底是怎么样的，这样才能对其他方面有更好的辅助。本章博客，我们就来学习一下Android中的Choreographer的运行机制。

     我们都知道，应用层的一个Activity对应一个根View（也就是一个DecorView）、一个WindowState、一个ViewRootImpl，每个对象都非常重要，都是在Activity添加过程中重量级的对象，DecorView是当前Activity的根View，它里面管理着当前界面的View树；WindowState对象是当前Activity窗口在系统侧WindowManagerService中代理对象；ViewRootImpl则肩负着View的标准三步曲的处理和事件分发，而View绘制也是由Choreographer指导的，Choreographer的英文意思就是编舞者、舞蹈指挥，看着非常形象。那我们就从Choreographer对象的构建开始说起吧，它的构建是在ViewRootImpl的构造方法中的，代码如下：

public ViewRootImpl(Context context, Display display) {
        mContext = context;
        mWindowSession = WindowManagerGlobal.getWindowSession();
        mDisplay = display;
        mBasePackageName = context.getBasePackageName();

        mDisplayAdjustments = display.getDisplayAdjustments();

        mThread = Thread.currentThread();
        mLocation = new WindowLeaked(null);
        mLocation.fillInStackTrace();
        mWidth = -1;
        mHeight = -1;
        mDirty = new Rect();
        mTempRect = new Rect();
        mVisRect = new Rect();
        mWinFrame = new Rect();
        mWindow = new W(this);
        mTargetSdkVersion = context.getApplicationInfo().targetSdkVersion;
        mViewVisibility = View.GONE;
        mTransparentRegion = new Region();
        mPreviousTransparentRegion = new Region();
        // [+LEUI-9331]
        mPreBlurParams = new BlurParams();
        // [-LEUI-9331]
        mFirst = true; // true for the first time the view is added
        mAdded = false;
        mAttachInfo = new View.AttachInfo(mWindowSession, mWindow, display, this, mHandler, this);
        mAccessibilityManager = AccessibilityManager.getInstance(context);
        mAccessibilityInteractionConnectionManager =
            new AccessibilityInteractionConnectionManager();
        mAccessibilityManager.addAccessibilityStateChangeListener(
                mAccessibilityInteractionConnectionManager);
        mHighContrastTextManager = new HighContrastTextManager();
        mAccessibilityManager.addHighTextContrastStateChangeListener(
                mHighContrastTextManager);
        mViewConfiguration = ViewConfiguration.get(context);
        mDensity = context.getResources().getDisplayMetrics().densityDpi;
        mNoncompatDensity = context.getResources().getDisplayMetrics().noncompatDensityDpi;
        mFallbackEventHandler = new PhoneFallbackEventHandler(context);
        mChoreographer = Choreographer.getInstance();
        mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);
        loadSystemProperties();

        /**
         * M: increase instance count and check log property to determine
         * whether to enable/disable log system. @{
         */
        mIdent = sIdent++;
        checkViewRootImplLogProperty();
        if (LOCAL_LOGV) {
            enableLog(true, "a");
        }

        if (DEBUG_LIFECYCLE) {
            Log.v(TAG, "ViewRootImpl construct: context = " + context + ", mThread = " + mThread
                    + ", mChoreographer = " + mChoreographer + ", mTraversalRunnable = "
                    + mTraversalRunnable + ", this = " + this);
        }
    }

     从构造方法中可以看到Choreographer是单例模式的，也就是一个ViewRootImpl对象对应一个Choreographer，当界面需要重绘时，都会调用到ViewRootImp类的scheduleTraversals()方法，这里的实现也比较简单，代码如下：

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

     mTraversalScheduled表示是否已经发起重绘，每次scheduleTraversals()方法调用之后，就会将它置为true，然后在下次调用doTraversal()又先将它置为false，然后调用mChoreographer.postCallback()添加一个Runnable，请注意，第一个参数是Choreographer.CALLBACK_TRAVERSAL，在Choreographer当前，添加的类型一共有三种，分别是：CALLBACK_INPUT、CALLBACK_ANIMATION、CALLBACK_TRAVERSAL，分别表示事件回调、动画回调、绘制回调。postCallback()方法是转而调用postCallbackDelayed()方法的，最后一个参数delayMillis传的是0，表示当前的重绘不需要延时，我们跟进去看一下添加的postCallbackDelayed()方法的代码：

    /**
     * Posts a callback to run on the next frame after the specified delay.
     * 

     * The callback runs once then is automatically removed.
     * 
     *
     * @param callbackType The callback type.
     * @param action The callback action to run during the next frame after the specified delay.
     * @param token The callback token, or null if none.
     * @param delayMillis The delay time in milliseconds.
     *
     * @see #removeCallback
     * @hide
     */
    public void postCallbackDelayed(int callbackType,
            Runnable action, Object token, long delayMillis) {
        if (action == null) {
            throw new IllegalArgumentException("action must not be null");
        }
        if (callbackType < 0 || callbackType > CALLBACK_LAST) {
            throw new IllegalArgumentException("callbackType is invalid");
        }

        postCallbackDelayedInternal(callbackType, action, token, delayMillis);
    }

     首先判断参数action是否为空，action就是我们要回调的对象，回调对象都为空了，那我们还干啥呢？其实判断callbackType，在整个过程中，只定义了上面描述的三种类型的事件，如果传入的type值不符合，那就抛出一个IllegalArgumentException("callbackType is invalid")异常。参数正常了，继续调用postCallbackDelayedInternal()进一步处理。postCallbackDelayedInternal()方法的代码如下：

    private void postCallbackDelayedInternal(int callbackType,
            Object action, Object token, long delayMillis) {
        if (DEBUG) {
            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);
            }
        }
    }

     此处获取当前时间，然后加上要延迟的时间，作为当前Callback的时间点，以这个时间点作为标准，把Callback对象添加到mCallback