概述

一直對Android中View的整個繪製流程不是很瞭解，View是怎麼新增到Activity當中去的？當View中的內容發生改變的時候是怎樣執行介面的重新整理的？因此，今天準備從原始碼的角度來對View的整個繪製流程來進行分析，原始碼基於API25。由於篇幅限制，這篇文章只分析頂層檢視DecorView的顯示邏輯，具體的View樹繪製三部曲:measure,layout,draw將在下篇博文進行深入剖析。

從Activity的setContentView方法說起

我們都知道給Activity設定佈局通常就是呼叫其setContentView方法，這個方法有幾個過載的方法，如下所示：

public void setContentView(@LayoutRes int layoutResID) {
     getWindow().setContentView(layoutResID);
     initWindowDecorActionBar();
 }

 public void setContentView(View view) {
       getWindow().setContentView(view);
       initWindowDecorActionBar();
   }

public void setContentView(View view, ViewGroup.LayoutParams params) {
       getWindow().setContentView(view, params);
       initWindowDecorActionBar();
}
 

從上面的三個方法可以看出其均呼叫了getWindow()的相對應的方法，我們來看getWindow()方法：

public Window getWindow() {
       return mWindow;
   }

可以看出這個方法返回的是一個Window型別的變數mWindow，那麼這個mWindow肯定是在Activity某個地方進行初始化,如下所示在attach方法裡面進行了初始化：

final void attach(Context context, ActivityThread aThread,
           Instrumentation instr, IBinder token, int
 
 ident,
           Application application, Intent intent, ActivityInfo info,
           CharSequence title, Activity parent, String id,
           NonConfigurationInstances lastNonConfigurationInstances,
           Configuration config, String referrer, IVoiceInteractor voiceInteractor,
           Window window) {
       attachBaseContext(context);

       mFragments.attachHost(null /*parent*/);

       mWindow = new PhoneWindow(this, window);
       mWindow.setWindowControllerCallback(this);
       mWindow.setCallback(this);
       mWindow.setOnWindowDismissedCallback(this);
       mWindow.getLayoutInflater().setPrivateFactory(this);
       ..........
       ..........
   }

mWindow是一個PhoneWindow型別的變數，其實我們通過檢視抽象類Window最開始的簡介可以知道，PhoneWindow是Window的唯一子類！

/**
 * Abstract base class for a top-level window look and behavior policy.  An
 * instance of this class should be used as the top-level view added to the
 * window manager. It provides standard UI policies such as a background, title
 * area, default key processing, etc.
 *
 * <p>The only existing implementation of this abstract class is
 * android.view.PhoneWindow, which you should instantiate when needing a
 * Window.
 */
public abstract class Window {

接下來檢視PhoneWindow的setContentView方法，跟Activity對應，也有三個過載的方法：

 @Override
public void setContentView(int layoutResID) {
    // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
    // decor, when theme attributes and the like are crystalized. Do not check the feature
    // before this happens.
    if (mContentParent == null) {
        installDecor();
    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        mContentParent.removeAllViews();
    }

   if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
                getContext());
        transitionTo(newScene);
    } else {
        mLayoutInflater.inflate(layoutResID, mContentParent);
    }
    mContentParent.requestApplyInsets();
    final Callback cb = getCallback();
    if (cb != null && !isDestroyed()) {
        cb.onContentChanged();
    }
    mContentParentExplicitlySet = true;
}

@Override
public void setContentView(View view) {
    setContentView(view, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
}

@Override
public void setContentView(View view, ViewGroup.LayoutParams params) {
    // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
    // decor, when theme attributes and the like are crystalized. Do not check the feature
    // before this happens.
    if (mContentParent == null) {
        installDecor();
    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        mContentParent.removeAllViews();
    }
    if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        view.setLayoutParams(params);
        final Scene newScene = new Scene(mContentParent, view);
        transitionTo(newScene);
    } else {
        mContentParent.addView(view, params);
    }
    mContentParent.requestApplyInsets();
    final Callback cb = getCallback();
    if (cb != null && !isDestroyed()) {
        cb.onContentChanged();
    }
    mContentParentExplicitlySet = true;
}

對setContentView(View view,ViewGroup.LayoutParams)方法進行分析：

• 首先判斷mContentParent是否為null，如果為null的話就執行方法installDecor，這個mContentParent是一個ViewGroup型別，這個方法如下所示：

 private void installDecor() {
        mForceDecorInstall = false;
        if (mDecor == null) {
            mDecor = generateDecor(-1);
            mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
            mDecor.setIsRootNamespace(true);
            if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
                mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
            }
        } else {
            mDecor.setWindow(this);
        }
        if (mContentParent == null) {
            mContentParent = generateLayout(mDecor);
        ........
        .......
}

generateDecor用於產生mDecor,mDecor是DecorView型別，是整個Activity的頂層檢視，DecorView是FrameLayout的子類，有興趣的可以看看DecorView原始碼，這裡只是給個結論。

• 然後是generateLayout方法，這個方法很長，看關鍵程式碼：

  ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
    if (contentParent == null) {
        throw new RuntimeException("Window couldn't find content container view");
    }
  ....
  return contentParent;

從上述程式碼可以看出，上面講到的mContentParent是頂層檢視mDecor中的一個子View，這個子View的id為：

  /**
    * The ID that the main layout in the XML layout file should have.
    */
   public static final int ID_ANDROID_CONTENT = com.android.internal.R.id.content;

• 因此，執行了installDecor方法之後就得到了mDecor和mContentParent，然後是一句很關鍵的程式碼，如下所示：

     mContentParent.addView(view, params);

通過這句程式碼就把我們在Activity當中設定的佈局檢視加入了mContentParent裡面。

層次關係為：DecorView > contentParent > Activity中的佈局。

由於mContentParent是ViewGroup型別，檢視ViewGroup#addView方法，如下所示：

/**
    * Adds a child view with the specified layout parameters.
    *
    * <p><strong>Note:</strong> do not invoke this method from
    * {@link #draw(android.graphics.Canvas)}, {@link #onDraw(android.graphics.Canvas)},
    * {@link #dispatchDraw(android.graphics.Canvas)} or any related method.</p>
    *
    * @param child the child view to add
    * @param index the position at which to add the child or -1 to add last
    * @param params the layout parameters to set on the child
    */
   public void addView(View child, int index, LayoutParams params) {
       if (DBG) {
           System.out.println(this + " addView");
       }

       if (child == null) {
           throw new IllegalArgumentException("Cannot add a null child view to a ViewGroup");
       }

       // addViewInner() will call child.requestLayout() when setting the new LayoutParams
       // therefore, we call requestLayout() on ourselves before, so that the child's request
       // will be blocked at our level
       requestLayout();
       invalidate(true);
       addViewInner(child, index, params, false);
   }

這個addView方法最後會呼叫requestLayout()和invalidate()方法，這兩個方法會導致整個View樹進行重新繪製，這樣就把我們在Activity當中自定義的佈局檔案給顯示出來了！

整個過程總結如下：

Activity.setContentView -> PhoneWindow.setContentView ->初始化PhoneWindow中的mDecor和mContentParent -> 把Activity當中的佈局檢視加入mContentParent -> 導致整個View樹進行重新繪製，從而把佈局檔案顯示出來！

DecorView是怎麼顯示出來的

前面說了DecorView是整個Activity的頂層檢視，那麼這個DecorView是怎麼顯示出來了的呢？主要實現過程在ActivityThread的handleResumeActivity方法裡面，如下所示：

final void handleResumeActivity(IBinder token,
        boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
    ActivityClientRecord r = mActivities.get(token);
    if (!checkAndUpdateLifecycleSeq(seq, r, "resumeActivity")) {
        return;
    }

    // If we are getting ready to gc after going to the background, well
    // we are back active so skip it.
    unscheduleGcIdler();
    mSomeActivitiesChanged = true;

    // TODO Push resumeArgs into the activity for consideration
    r = performResumeActivity(token, clearHide, reason);

    if (r != null) {
        final Activity a = r.activity;

        if (localLOGV) Slog.v(
            TAG, "Resume " + r + " started activity: " +
            a.mStartedActivity + ", hideForNow: " + r.hideForNow
            + ", finished: " + a.mFinished);

        final int forwardBit = isForward ?
                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

        // If the window hasn't yet been added to the window manager,
        // and this guy didn't finish itself or start another activity,
        // then go ahead and add the window.
        boolean willBeVisible = !a.mStartedActivity;
        if (!willBeVisible) {
            try {
                willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(
                        a.getActivityToken());
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
        if (r.window == null && !a.mFinished && willBeVisible) {
            r.window = r.activity.getWindow();
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            ViewManager wm = a.getWindowManager();
            WindowManager.LayoutParams l = r.window.getAttributes();
            a.mDecor = decor;
            l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
            l.softInputMode |= forwardBit;
            if (r.mPreserveWindow) {
                a.mWindowAdded = true;
                r.mPreserveWindow = false;
                // Normally the ViewRoot sets up callbacks with the Activity
                // in addView->ViewRootImpl#setView. If we are instead reusing
                // the decor view we have to notify the view root that the
                // callbacks may have changed.
                ViewRootImpl impl = decor.getViewRootImpl();
                if (impl != null) {
                    impl.notifyChildRebuilt();
                }
            }
            if (a.mVisibleFromClient && !a.mWindowAdded) {
                a.mWindowAdded = true;
                wm.addView(decor, l);
            }

        ................................
    }
}

如上述方法所示，首先從ActivityThread儲存的mActivities列表裡面得到一個ActivityClientRecord物件，這個物件儲存了Activity的一些資訊。

• 得到Activity之後呼叫View decor = r.window.getDecorView();方法得到頂層檢視DecorView，這個檢視前面說過是儲存在PhoneWindow裡面，也就是一個Activity對應一個 PhoneWindow，從而對應一個DecorView。
• 然後是呼叫ViewManager wm = a.getWindowManager();方法得到Activity當中的WindowManager物件，那為什麼返回的是ViewManager物件呢？檢視WindowManager介面，如下所示，發現WindowManager是繼承自ViewManager介面的。

      public interface WindowManager extends ViewManager {

ViewManager介面如下所示，從註釋可以看出這個介面主要是用來往Activity當中新增或者移除View。

/** Interface to let you add and remove child views to an Activity. To get an instance
  * of this class, call {@link android.content.Context#getSystemService(java.lang.String) Context.getSystemService()}.
  */
public interface ViewManager
{
    /**
     * Assign the passed LayoutParams to the passed View and add the view to the window.
     * <p>Throws {@link android.view.WindowManager.BadTokenException} for certain programming
     * errors, such as adding a second view to a window without removing the first view.
     * <p>Throws {@link android.view.WindowManager.InvalidDisplayException} if the window is on a
     * secondary {@link Display} and the specified display can't be found
     * (see {@link android.app.Presentation}).
     * @param view The view to be added to this window.
     * @param params The LayoutParams to assign to view.
     */
    public void addView(View view, ViewGroup.LayoutParams params);
    public void updateViewLayout(View view, ViewGroup.LayoutParams params);
    public void removeView(View view);
}

• 得到Activity當中的WindowManager之後，呼叫wm.addView(decor, l);方法，就把DecorView加入了WindowManager。我們知道WindowManager只是一個介面，具體的實現類是WindowManagerImpl,看下其addView方法：

@Override
   public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
       applyDefaultToken(params);
       mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
   }

發現這個addView方法其實是呼叫了成員變數mGlobal的addVeiw方法，mGlobal是WindowManagerGlobal型別，我們來看下其addView方法，如下所示：

public void addView(View view, ViewGroup.LayoutParams params,
           Display display, Window parentWindow) {
       ........................
       ViewRootImpl root;
       View panelParentView = null;

      .........................
           root = new ViewRootImpl(view.getContext(), display);

           view.setLayoutParams(wparams);

           mViews.add(view);
           mRoots.add(root);
           mParams.add(wparams);
      ...........................

       // do this last because it fires off messages to start doing things
       try {
           root.setView(view, wparams, panelParentView);
       } catch (RuntimeException e) {
           // BadTokenException or InvalidDisplayException, clean up.
           synchronized (mLock) {
               final int index = findViewLocked(view, false);
               if (index >= 0) {
                   removeViewLocked(index, true);
               }
           }
           throw e;
       }
   }

通過上述程式碼可以發現頂層檢視DecorView最終被加入到了ViewRootImpl裡面，且應該是在其setView方法裡面執行了某些操作，導致DecorView被顯示出來。這個方法比較長，大家可以自行檢視，在裡面有一句關鍵的程式碼：

// Schedule the first layout -before- adding to the window
// manager, to make sure we do the relayout before receiving
// any other events from the system.
requestLayout();

requestLayout方法如下：

    @Override
    public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();
            mLayoutRequested = true;
            scheduleTraversals();
        }
    }

在這個方法當中呼叫了scheduleTraversals方法，如下所示：

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

在這個方法當中把mTraversalRunnable給post到了訊息佇列裡面，來看看這個Runnable裡面執行了什麼操作：

final class TraversalRunnable implements Runnable {
       @Override
       public void run() {
           doTraversal();
       }
   }
   final TraversalRunnable mTraversalRunnable = new TraversalRunnable();

從上面可以看出在TraversalRunnable裡面執行了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方法，這個方法最終負責整個View樹的繪製流程，因此這個方法比較關鍵。這個方法比較長，其負責繪製的View樹的核心語句如下，其中mView就是頂層檢視DecorView。

private void performTraversals() {
        ......
        int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
        int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
        ......
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        ......
        mView.layout(0, 0, mView.getMeasuredWidth(), mView.getMeasuredHeight());
        ......
        mView.draw(canvas);
        ......
    }

上面對頂層檢視DecorView的顯示機制進行了深入剖析，通過一層層分析，最終得出ViewRootImpl負責整個View樹的繪製。measure,layout,draw是View樹繪製三個主要流程，只有理解了這三個基本流程的原理，在自定義View的時候才能做到遊刃有餘（當然還有View事件分發機制也很關鍵）！關於這三個流程的具體細節剖析將在下一篇部落格中進行講解。感謝大家的閱讀！