源码分析View的绘制流程-CFANZ编程社区

源码基于Android8.0

在Android应用程序启动（根Activity）过程中，我们知道Activity启动流程的最后一步就是调用 ActivityThread.handleLaunchActivity()方法：

// ActivityThread.java
 private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
        ...
        Activity a = performLaunchActivity(r, customIntent); // 1
        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            reportSizeConfigurations(r);
            Bundle oldState = r.state;
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);  // 2
             ...
        } ...
    }

注释1调用了 performLaunchActivity()，它的作用是创建PhoneWindow，执行Activity的onCreate方法，注释2是调用 handleResumeActivity()对Activity进入到resume状态中去。

很明显，在注释2调用resume方法时，Activity就必须完成布局的创建，而这个布局，最重要的是我们熟知的DecorView。
而注释2中，就需要将DecorView和其子View们在resume中被显示出来。这就涉及到了View的绘制。

我们先看看 PhoneWindow是如何被创建的。

1. DecorView的创建

1.1 performLaunchActivity()向下调用

进入到 performLaunchActivity()中：

// ActivityThread
   private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ...
        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);  // 1
            ...
            if (activity != null) {
                //2
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window, r.configCallback);

                ...
                if (r.isPersistable()) {
                    //3
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } 
    }

注释1的makeApplication()之前有研究过，它会调用App的Application类的 onCreate()。
注释2：调用 Activity.attach()方法，这个方法将马上要产生的Activity和Context进行绑定，并创建一些Activity需要的东西：

// Activity.java
    final void attach(Context context, ActivityThread aThread,
          ...) {
        attachBaseContext(context);  
        mFragments.attachHost(null /*parent*/);
        mWindow = new PhoneWindow(this, window, activityConfigCallback);  // 1
        ....

        // 2
        mWindow.setWindowManager(
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                mToken, mComponent.flattenToString(),
                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
        if (mParent != null) {
            mWindow.setContainer(mParent.getWindow());
        }
        mWindowManager = mWindow.getWindowManager();
        mCurrentConfig = config;
        mWindow.setColorMode(info.colorMode);
    }

注释1：new出一个 PhoneWindow，并赋值给 Window类型对象mWindow，我们知道在Android中，Window是以view的形式存在的，这个创建PhoneWindow，其实就是Activity最初始的View。
注释2：给mWindow对象设置一个新的 WindowManager用来管理界面，这样当我们在代码中调用getWindow()时，返回的是 mWindow，调用getWindowManager()时，返回的是mWindow的WindowManager。

对于绘制的角度来说，Activity.attach()已经创建了最初始的根View -> mWindow，接下来就是将mWindow作为DecorView展示出来。显然attach()方法已经没有这些代码了。我们回到 performLaunchActivity()的注释3中，看看 Instrumentation.callActivityOnCreate()：

// Instrumentation
    public void callActivityOnCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
        prePerformCreate(activity);
        activity.performCreate(icicle, persistentState);  // 1
        postPerformCreate(activity);
    }

注释1是关键，它调用了 Activity.oerformCreate()：

// Activity.java
    final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        restoreHasCurrentPermissionRequest(icicle);
        onCreate(icicle, persistentState);  // 1
        mActivityTransitionState.readState(icicle);
        performCreateCommon();
    }

它调用了我们Activity的onCreate()方法。而我们自己写的Activity中都会调用 setContentView()来设置一个布局：

// Activity.java
    public void setContentView(View view) {
        getWindow().setContentView(view);  // 1
        initWindowDecorActionBar();
    }

注释1调用了 getWindow()，得到就是 PhoneWindow mWindow，然后调用其 setContentView()，我们就到PhoneWindow中看看。

1.2 真正的setContentView方法

// PhoneWindow.java
    @Override
    public void setContentView(View view, ViewGroup.LayoutParams params) {
        if (mContentParent == null) {  // 1
            installDecor();  // 2
        } 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;
    }

注释1：判断 mContextParent是否为null，由于Activity是第一次被创建，所以其 mContentParent肯定是null的，所以为执行注释2的代码。
注释2：调用 installDecor()

// PhoneWindow.java
    private void installDecor() {
        mForceDecorInstall = false;
        if (mDecor == null) {  // 1
            mDecor = generateDecor(-1); // 2
            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);  // 3
            ...
        }
        ....
    }

注释1：判断 mDecor是否为null，由于之前我们没有看到有关于mDecor的创建代码，所以显然它为null。
注释2：调用 generatorView()来创建一个 DecorView：

// PhoneWindow.java
    protected DecorView generateDecor(int featureId) {
        ...
        return new DecorView(context, featureId, this, getAttributes());
    }

这里是本流程中第一次看到的调用了 new DecorView()方法.

注释3:调用了 generateLayout(mDecor)方法，创建了 mContentParent这个ViewGroup，其实在这里我们已经大概知道了 mCotnentParent就是 DecorView两个部分中的 ContentView。我们来看看这个方法：

// PhoneWindow.java
    protected ViewGroup generateLayout(DecorView decor) {
        ....

        int layoutResource;  // 根据不同的情况加载不同的布局给layoutResource
        int features = getLocalFeatures();
        if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {
            layoutResource = R.layout.screen_swipe_dismiss;
            setCloseOnSwipeEnabled(true);
        } else if ((features & (1 << FEATURE_ACTION_MODE_OVERLAY)) != 0) {
            layoutResource = R.layout.screen_simple_overlay_action_mode;
        } ....
        } else {
            layoutResource = R.layout.screen_simple;  // 1
        } 
        ...
        mDecor.onResourcesLoaded(mLayoutInflater, layoutResource); // 2
        ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT); 
        ...
        return contentParent;
    }

这个代码非常长，它根据代码中所设置的FEATURE或者在AndroidManifest中对Activity设置的Flag来加载不同的资源。

然后在注释2中，让Activity加载这个资源。

在上面不同的资源中，我们需要留意的是注释1中的 R.layout.screen_simple，它是在Activity没有设置任何界面选项的情况下加载的，即默认布局，我们看看它是什么样的：

源码分析View的绘制流程_宽高

它分成了两个部分，顶部是一个ViewStub，它是一个 ActionBar状态栏，它下面是一个 FrameLayout，表示content。这个时候 mContentParent通过findViewById得到了下面的content。最后在一开始的 setContentView中将mContentParent渲染上我们想要的layout。如下图所示：

源码分析View的绘制流程_宽高_02

至此，DecorView的产生以及它的布局就到此为止了。

1.3 小结

下面来总结一下 DecorView的创建

DecorView的创建来是在 Activity的加载过程中，在ActivityThread.performLaunchActivity()中，创建了最初始的PhoneWindow
在Activity.onCreate()中调用了Activity.setContentView()来加载布局，其实是调用第一步创建的PhoneWindow.setContentView
判断Activity的 DecorView是否为null，如果不存在，则创建一个 DecorView。DecorView被PhoneWindow持有着，继承自FrameLayout。
判断DecorView中有没有内容（即mContentParent），如果没有，则根据配置在DecorView上加载一个默认布局layout，一般来说，这个布局包含了Action Bar 和 ContentView
回到setContentView中，将我们写的layout布局加载到DecorView的 ContentView中。完成Activity的页面布局。

2. View绘制的入口

在第一节中，我们已经创建并初始化好了一个DecorView，并且将其ContentView加载了我们自定义化的Layout。但是它们处于的生命周期还是在 onCreate中，我们知道，只有在 onResume、onStart中，我们才能看到它。

在一开始的 handleLaunchActivity中，我们还看到执行了 handleResumeActivity()，它是执行了绘制的地方。

2.1 handleResumeActivity

final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        ActivityClientRecord r = mActivities.get(token);
        ...
        r = performResumeActivity(token, clearHide, reason); // 1

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

            ...
            if (r.window == null && !a.mFinished && willBeVisible) {
                r.window = r.activity.getWindow();
                View decor = r.window.getDecorView(); // 2
                decor.setVisibility(View.INVISIBLE);  
                ViewManager wm = a.getWindowManager(); // 3
                WindowManager.LayoutParams l = r.window.getAttributes();
                a.mDecor = decor;
                .....
                if (a.mVisibleFromClient) {
                    if (!a.mWindowAdded) {
                        a.mWindowAdded = true;
                        wm.addView(decor, l); // 4
                    } else {
                        a.onWindowAttributesChanged(l);
                    }
                }
                ....
            }  
         ....
    }

注释1中：performResumeActivity()会调用Activity的onResume()方法。
注释2：获取第一节中创建的 DecorView 注释3：获取第一节中通过 setWindowManager()创建好的 WindowManager 注释4：调用 WindowManager.addView(decor)，将DecorView绘制到屏幕上。

因为Android中，WindowManager家族使用了桥接模式，即WindowManager是一个抽象类，它的实现类是WindowManagerImpl，然后它桥接到 WindowManagerGlobal中，它是一个单例，一个进程中只有一个实例，实现了真正对View的增加(add)、修改(update)、删除(remove)方法。
具体可以看《Android进阶解密》关于WindowManagerService的讲解。

2.2 WindowManagerGlobal.addView()

来看看其 addView：

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

        synchronized (mLock) {
            ....
            root = new ViewRootImpl(view.getContext(), display); // 1
            view.setLayoutParams(wparams);
            mViews.add(view);
            mRoots.add(root);
            mParams.add(wparams);
            try {
                root.setView(view, wparams, panelParentView); // 2
            } catch (RuntimeException e) {
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
                throw e;
            }
        }
    }

注释1创建了ViewRootImpl实例，然后让WindowManagerGlobal维护，注释1下面的代码就是将View的信息保存到WMG的管理的列表中。
ViewRootImpl 身负很多职责，主要有以下几点：

View树的根并管理View树
触发View的测量、布局和绘制
输入事件的中转站
管理Surface
负责与WMS进行进程间通信

注释2中调用 ViewRootImpl.setView：

// ViewRootImpl.java
 public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
                ...
                try {
                    mOrigWindowType = mWindowAttributes.type;
                    mAttachInfo.mRecomputeGlobalAttributes = true;
                    collectViewAttributes();
                    // 1
                    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(),
                            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                            mAttachInfo.mOutsets, mInputChannel);
                  ...
        }
    }

这里使用了AIDL，将代码转移到了 WindowManagerService中去了。当然，我们现在研究的是View的绘制流程，而WMS做的事情是配置/存储View信息，并没有涉及到绘制的内容，所以不用深入到SystemServer进程中。

setView()在WMS执行完后最终会执行scheduleTraversals，它会向主线程发消息，让主线程执行performTraversals()，这个方法就是绘制的入口，它是这样的：

// ViewRootImpl.java
  private void performTraversals() {
  ...
     relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
  ... 
    // 1
    int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
    int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    ...
    // 2
      performLayout(lp, mWidth, mHeight);
    ... 
    // 3 
     performDraw();
     ...
  }

在 performTraversals()中，走了三个方法， performMeasure()、performLayout()、performDraw()， performXXX的意思就是将要做XXX。所以很明显，这就是View绘制中三大流程的入口。

到这里，我们通过Activity的启动来到了Activity的绘制，它调用了 ViewRootImpl.setView()来进入到Acitivty绘制的入口。
我们使用的例子是Activity，而实际上，不只是Activity，任何View的添加、修改和删除，最终都会来到这个方法来。
再往下，我们就可以把Activity看成是一个ViewGroup，进入到绘制流程的源码中。

3. 解析MeasureSpec

我们知道在调用 performMeasure()前，创建了宽高的MeasureSpec。我们要了解它是做什么的。

MeasureSpec是View的内部类，它封装了一个View的规格尺寸，包括View的宽和高的信息，它的作用是在Measure流程中，系统会将View的LayoutParams根据父容器所施加的规则转换成对应的MeasureSpec。然后在 onMeasure方法中根据这个MeasureSpec来确定View的宽和高。我们来看看它的源码：

public static class MeasureSpec {
        private static final int MODE_SHIFT = 30;
        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;
        public static final int UNSPECIFIED = 0 << MODE_SHIFT;
        public static final int EXACTLY     = 1 << MODE_SHIFT;
        public static final int AT_MOST     = 2 << MODE_SHIFT;
        
        // size和mode，size范围在0~2^30-1 mode是0、1、2
        public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
                                          @MeasureSpecMode int mode) {
            if (sUseBrokenMakeMeasureSpec) {
                return size + mode;
            } else {
                return (size & ~MODE_MASK) | (mode & MODE_MASK);
            }
        }

        public static int makeSafeMeasureSpec(int size, int mode) {
            if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {
                return 0;
            }
            return makeMeasureSpec(size, mode);
        }
        
        public static int getMode(int measureSpec) {
            return (measureSpec & MODE_MASK);
        }

        public static int getSize(int measureSpec) {
            return (measureSpec & ~MODE_MASK);
        }

        static int adjust(int measureSpec, int delta) {
            final int mode = getMode(measureSpec);
            int size = getSize(measureSpec);
            if (mode == UNSPECIFIED) {
                return makeMeasureSpec(size, UNSPECIFIED);
            }
            size += delta;
            if (size < 0) {
                Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +
                        ") spec: " + toString(measureSpec) + " delta: " + delta);
                size = 0;
            }
            return makeMeasureSpec(size, mode);
        }
    }

从MeasureSpec的常量可以看出，它代表了32位的int值，其中高2位代表了SpecMode，低30位则代表SpecSize。SpecMode指的是测量模式，SpecSize指的是测量大小。SpecMode有3种模式，如下所示。

UNSPECIFIED：未指定模式，View想多大就多大，父容器不做限制，一般用于系统内部的测量。
AT_MOST：最大模式，对应于wrap_comtent属性，子View的最终大小是父View指定的SpecSize值，并且子View的大小不能大于这个值。
EXACTLY：精确模式，对应于 match_parent 属性和具体的数值，父容器测量出 View所需要的大小，也就是SpecSize的值。

对于每一个View，都持有一个MeasureSpec，而该MeasureSpec则保存了该View的尺寸规格。在View的测量流程中，通过makeMeasureSpec()来保存宽和高的信息。通过getMode或getSize得到模式和宽、高。MeasureSpec是受自身LayoutParams和父容器的MeasureSpec共同影响的。作为顶层View的DecorView来说，其并没有父容器，那么它的MeasureSpec是如何得来的呢？为了解决这个疑问，我们再回到ViewRootImpl的PerformTraveals方法，如下所示：

// ViewRootImpl.java
    int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);  // 1
    int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height); //2
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

注释1、2中的 getRootMeasureSpec()得到了DecorView的宽高的MeasureSpec，我们来看看它做了什么：

// ViewRootImpl.java
    private static int getRootMeasureSpec(int windowSize, int rootDimension) {
        int measureSpec;
        switch (rootDimension) {
        case ViewGroup.LayoutParams.MATCH_PARENT:
            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
            break;
        case ViewGroup.LayoutParams.WRAP_CONTENT:
            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
            break;
        default:
            measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
            break;
        }
        return measureSpec;
    }

getRootMeasureSpec的第一个参数时窗口的尺寸，对于DecorView来说，它的MeasureSpec是由自身的LayoutParams和窗口尺寸决定的，普通View获取MeasureSpec和它有区别的地方就在这里了。

再来看看 performMeasure方法：

// ViewRootImpl.java
    private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
        if (mView == null) {
            return;
        }
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
        try {
            mView.measure(childWidthMeasureSpec, childHeightMeasureSpec); // 1
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
    }

在DecorView得到了它的MeasureSpec后，就开始真正的measure流程了。这里的 mView指的就是 WindowManager.addView()进去的View，也就是DecorView。

4. View的measure流程

measure的作用就是用来测量一个DecorView及其所有子View的宽和高。
它的流程分为View的measure流程和ViewGroup的measure流程。
而他们的入口，都是在于上一节中的 mView.measure()方法，我们从入口开始看起。

4.1 View的measure方法

因为DecorView、FrameLayout都没有重写measure方法，所以mView.measure方法其实调用了 View.measure()，我们来看看这个方法。

// View.java
    public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
        ....
        if (forceLayout || needsLayout) {
            ...
            int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key); // 1
            if (cacheIndex < 0 || sIgnoreMeasureCache) {
                onMeasure(widthMeasureSpec, heightMeasureSpec);  // 2
                mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
            } else {
                long value = mMeasureCache.valueAt(cacheIndex);
                setMeasuredDimensionRaw((int) (value >> 32), (int) value);
                mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
            }

            ...
            }

            ...
        }
        ...
        mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
                (long) mMeasuredHeight & 0xffffffffL); // 3
    }

注释1：看看cache中有没有缓存
注释2：如果没有缓存就调用 onMeasure()计算View的 mMeasureWidth和mMeasureHeight
注释3：将注释2算出来的值放入到缓存中，下次再算此View时，如果此View没有做宽高的改变，就不用再计算宽高了。

在注释2中，因为继承和多态的关系，会先调用 DecorView.onMeasure()，因为DecorView的onMeausre和普通View的onMeasure方法区别并不大，我这里列出一个调用链：
ViewRootImpl.performMeasure() -> View.measure() -> DecorView.onMeasure() -> FrameLayout.onMeasure() -> ViewGroup.measureChildWithMargins() -> View.onMeasure() 其中最后一个方法的实现和 measureChild()一样，我们后面会讲到它。
可以看到这个调用链其实就是从最顶层的View开始走measure，然后其子View随其后而measure。

4.2 View的measure流程

首先来看看View的measure流程：

// View.java
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
    }

它调用了 getDefaultSize()和 setMeasuredDimension()、 getSuggestedMinimumXXX()方法。
我们先看看 setMeasuredDimension()方法做了什么：

// View.java
    protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
        boolean optical = isLayoutModeOptical(this);
        if (optical != isLayoutModeOptical(mParent)) {
            Insets insets = getOpticalInsets();
            int opticalWidth  = insets.left + insets.right;
            int opticalHeight = insets.top  + insets.bottom;

            measuredWidth  += optical ? opticalWidth  : -opticalWidth;
            measuredHeight += optical ? opticalHeight : -opticalHeight;
        }
        setMeasuredDimensionRaw(measuredWidth, measuredHeight);
    }

上面的代码很明显是用来设置View的宽高。
再回头看看 getDefaultSize()是做了什么的：

// View.java
    public static int getDefaultSize(int size, int measureSpec) {
        int result = size;
        int specMode = MeasureSpec.getMode(measureSpec);
        int specSize = MeasureSpec.getSize(measureSpec);

        switch (specMode) {
        case MeasureSpec.UNSPECIFIED:
            result = size;
            break;
        case MeasureSpec.AT_MOST:
        case MeasureSpec.EXACTLY:
            result = specSize;
            break;
        }
        return result;
    }

这个代码就和上节讲到的MeasureSpec有关了。他根据不同的SpecMode来计算出不同的宽高值。

AT_MOST和EXACTLY这两个SpecMode下，返回的都是同一个值：measureSpec中的Size
而在UNSPECIFIED，则计算出的值是传进来的宽高值。即getSuggestedMinimumXXX()得到的数值。

我们来看看 getSuggestedMinimumXX()方法：

// View.java
    protected int getSuggestedMinimumWidth() {
        return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
    }

如果View没有设置背景Backgroud，则取值为 mMinWidth，这个值时可以设置的，它对应的是 Android:minWidth / View.setMinimumWidth，如果不指定的话，默认就是0，如果设置了背景，则取 mMinWidth和 mBackground.getMinimumWidth间的最大值。

mBackgroud是Drawable类型的，Drawable类的getMinmumWidth()方法：

// Drawable.java
    public int getMinimumWidth() {
        final int intrinsicWidth = getIntrinsicWidth();
        return intrinsicWidth > 0 ? intrinsicWidth : 0;
    }

而 intrinsicWidth值的就是Drawable的固有宽度，如果固有宽度大于0则返回固有宽度，否则返回0.

也就是说，如果如果一个View的宽/高设置的SpecMode为UNSPECIFIED，那么它这条边的长度就是mMinXXX和Drawable背景的最大值。如果一个View的宽/高的SpecMode为 AT_MOST或EXACTLY，那么它这条边长度就是SpecSize

4.3 ViewGroup的measureChildren方法

对于ViewGroup，它不只要测量自身，还要遍历地调用子元素的 measure()，ViewGroup中没有定义onMeasure方法，却定义了 measureChildren()方法：

// ViewGroup.java
    protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
        final int size = mChildrenCount;
        final View[] children = mChildren;
        for (int i = 0; i < size; ++i) {  // 1
            final View child = children[i];
            if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {  // 2
                measureChild(child, widthMeasureSpec, heightMeasureSpec); // 3
            }
        }
    }

注释1：遍历所有子View
注释2、3：如果子View的不是GONE的，就调用 measureChild()，并传入自己的 MeaseSpec

来看看 measureChild()：

// ViewGroup.java
    protected void measureChild(View child, int parentWidthMeasureSpec,
            int parentHeightMeasureSpec) {
        final LayoutParams lp = child.getLayoutParams();  // 1

        final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
                mPaddingLeft + mPaddingRight, lp.width);  // 2
        final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
                mPaddingTop + mPaddingBottom, lp.height); // 3

        child.measure(childWidthMeasureSpec, childHeightMeasureSpec); // 4
    }

注释1：拿到子View的 LayoutParams 注释2、3：通过 getChildMeasureSpec()计算出子View的MeasureSpec
注释4：调用子View的measure方法。

这里有一个值得注意点，在注释2、3中，ViewGroup是如何通过自己的MeasureSpec和子View的LayoutParams来计算出子View的MeasureSpec的呢，我们有必要看看这个方法：

// ViewGroup.java
    public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
        int specMode = MeasureSpec.getMode(spec);  // 1
        int specSize = MeasureSpec.getSize(spec);  // 2

        int size = Math.max(0, specSize - padding); // 3

        int resultSize = 0;
        int resultMode = 0;

        switch (specMode) { // 3
        case MeasureSpec.EXACTLY:
            if (childDimension >= 0) {
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                resultSize = size;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            }
            break;

        case MeasureSpec.AT_MOST:
            if (childDimension >= 0) {
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            }
            break;

        case MeasureSpec.UNSPECIFIED:
            if (childDimension >= 0) {
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                resultMode = MeasureSpec.UNSPECIFIED;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                resultMode = MeasureSpec.UNSPECIFIED;
            }
            break;
        }
        return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
    }

上面的代码虽然长，但是很好理解：

注释1：拿到ViewGroup的 SpecMode和SpecSize。

注释2：size为ViewGroup的SpecSize减去padding值，如果小于0，则取0

注释3：根据ViewGroup的SpecMode来确定子View的MeasuSpec。这里分为了多种情况，下面列个表：

（图源自自定义View：Measure过程说明之MeasureSpec类详细讲解）

源码分析View的绘制流程_加载_03

就这样计算出了子View的MeasureSpec，接着就是调用子View的measure方法。

而调用每个View的measure方法，还会去计算这个View是否有子View，一层层的递归下去。
这样，当调用DecorView的onMeasure方法，相当于把一个屏幕所有View的宽高都给测量下来了。这也是剩下两个流程所用到的技巧。

5. View的layout流程

layout流程的作用是用来确定元素的位置的。
和measure一样，layout的流程有View的layout流程，还有ViewGroup的layout流程。

5.1 performLayout方法

当然，我们的入口是 ViewRootImpl.performLayout()，看看它做了什么：

// ViewRootImpl.java
    private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
            int desiredWindowHeight) {
        ...
        final View host = mView;
        if (host == null) {
            return;
        }
        ...
        try {
            host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
            ....
            }
        } ...
    }

调用了 DecorView的 layout方法，这里有一个调用链：
ViewRootImpl.performLayout() -> View.layout() -> DecorView.onLayout() -> FrameLayout.onLayout() -> FrameLayout.layoutChildren()，由于FrameLayout自己实现了layout（一般来说，自定义ViewGroup都需要自己实现layout函数），所以我们不研究其函数。
而是研究一般的View、ViewGroup是这么Layout的。了解了他们，其他就是触类旁通。

5.2 View的layout流程

我们看看View的layout方法，View的layout是用来确定自身的位置：

// View.java
    public void layout(int l, int t, int r, int b) {
        if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
            onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
            mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
        }

        int oldL = mLeft;
        int oldT = mTop;
        int oldB = mBottom;
        int oldR = mRight;
        boolean changed = isLayoutModeOptical(mParent) ?
                setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);  // 1
        if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
            onLayout(changed, l, t, r, b);  // 2
            if (shouldDrawRoundScrollbar()) {
                if(mRoundScrollbarRenderer == null) {
                    mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);
                }
            } else {
                mRoundScrollbarRenderer = null;
            }
            mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
            ListenerInfo li = mListenerInfo;
            if (li != null && li.mOnLayoutChangeListeners != null) {
                ArrayList<OnLayoutChangeListener> listenersCopy =
                        (ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();
                int numListeners = listenersCopy.size();
                for (int i = 0; i < numListeners; ++i) {
                    listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);
                }
            }
        }
        mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
        mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
        ....
    }

layout方法的4个参数l、t、r、b分别是View的左上右下相对于其父容器的距离。
注释1中调用了 setFrame()方法，setOpticalFrame()最终也会调用到setFrame()，它将这四个值设置给了View：

// View.java
    protected boolean setFrame(int left, int top, int right, int bottom) {
        boolean changed = false;
        if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {
            changed = true;

            int drawn = mPrivateFlags & PFLAG_DRAWN;

            int oldWidth = mRight - mLeft;
            int oldHeight = mBottom - mTop;
            int newWidth = right - left;
            int newHeight = bottom - top;
            boolean sizeChanged = (newWidth != oldWidth) || (newHeight != oldHeight);
            invalidate(sizeChanged);
            mLeft = left;
            mTop = top;
            mRight = right;
            mBottom = bottom;
            mRenderNode.setLeftTopRightBottom(mLeft, mTop, mRight, mBottom);
            ...
        }
        return changed;
    }

setFrame方法用传进来的l、t、r、b这4个参数分别初始化给 mLeft、mTop、mRight、mBottom这4个值，这样就确定了该View在父容器中的位置。

回到上面的layout方法中，在调用完setFrame()，会调用 onLayout()，这个方法是一个空方法。无论是View还是ViewGroup，这是因为位置会因为不同的控件会有不同的实现，这个由开发者自己实现。

5.3 ViewGroup是如何用layout的

因为系统并没有给ViewGroup实现默认的onLayout()，所以这需要ViewGroup的创建者来自己实现。对自己ViewGroup下的每个组件实现位置的确定。而对于最下层的子View，只需要调用它的 layout()方法就行了。

我们来看看 FrameLayout是如何实现layout子布局的：

// FrameLayout.java
    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        layoutChildren(left, top, right, bottom, false /* no force left gravity */);
    }

    void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
        ...
        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                ....
                switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                    case Gravity.CENTER_HORIZONTAL:
                       ...
                    case Gravity.RIGHT:
                      ....
                }

                switch (verticalGravity) {
                    case Gravity.TOP:
                      ...
                    case Gravity.CENTER_VERTICAL:
                      ....
                }
                child.layout(childLeft, childTop, childLeft + width, childTop + height);
            }
        }
    }

其实很简单，就是遍历每个子View，然后拿到他们的测量宽高，根据子View在FrameLayout中设置的位置属性进行调整，最后调用每个子View的layout即 child.layout()。
这样，就和measure一样，把layout的过程交给了自己的子View。

在这里，我们不考虑FrameLayout实现layout的细节，因为它不是重点，但是我们平时自己在写ViewGroup的时候，layout是很重要的一环，我们要靠它实现各种View的展示。

6. View的draw流程

View的draw流程很简单，下面先来看看View的draw方法。在perform中自然也调用到了draw方法。
官方注释清楚的说明了每一步的做法：

如果需要，则绘制背景。
保存当前canvas层。
绘制View的内容。
绘制子View。
如果需要，则绘制View的褪色边缘，这类似于阴影效果。
绘制装饰，比如滚动条。

在我们自定义View的 onDraw里面，调用了 super.onDraw()都会实现上面的方法

6.1 绘制背景

绘制背景调用了 View的drawBackground方法：

// View.java
    private void drawBackground(Canvas canvas) {
        final Drawable background = mBackground;
        if (background == null) {
            return;
        }

        setBackgroundBounds();
        ....
        final int scrollX = mScrollX;
        final int scrollY = mScrollY;
        if ((scrollX | scrollY) == 0) {  // 1
            background.draw(canvas);
        } else {
            canvas.translate(scrollX, scrollY);
            background.draw(canvas);
            canvas.translate(-scrollX, -scrollY);
        }
    }

注释1：可以看出绘制背景考虑了偏移参数scrollX、scrollY，如果有偏移值不为0，则会在偏移后的canvas绘制背景。

6.2 绘制View内容

调用了View的 onDraw方法，这是一个空方法，因为不同的View有着不同的内容，这需要我们自己去实现。

6.3 绘制子View

调用了 dispatchDraw():

protected void dispatchDraw(Canvas canvas) {}

这个方法也是一个空实现，ViewGroup重写了这个方法，我们看看：

// ViewGroup.java
    @Override
    protected void dispatchDraw(Canvas canvas) {
        ....
        for (int i = 0; i < childrenCount; i++) {
            while (transientIndex >= 0 && mTransientIndices.get(transientIndex) == i) {
                final View transientChild = mTransientViews.get(transientIndex);
                if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
                        transientChild.getAnimation() != null) {
                    more |= drawChild(canvas, transientChild, drawingTime);
                }
                transientIndex++;
                if (transientIndex >= transientCount) {
                    transientIndex = -1;
                }
            }
        }
        ...
   }

源码很长，这里截取了关键的部分，在dispatchDraw中对子View进行遍历，并调用 drawChild方法：

protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
        return child.draw(canvas, this, drawingTime);
    }

即调用了子View的draw()，而draw方法就是开节讲的那六个步骤。

也就是说ViewGroup递归调用了每个子View的draw方法。

6.4 绘制装饰

在draw方法里调用了 onDrawForeground()来绘制装饰

// View.java
    public void onDrawForeground(Canvas canvas) {
        onDrawScrollIndicators(canvas);  // 1
        onDrawScrollBars(canvas);  // 2

        final Drawable foreground = mForegroundInfo != null ? mForegroundInfo.mDrawable : null;
        if (foreground != null) {
            if (mForegroundInfo.mBoundsChanged) {
                mForegroundInfo.mBoundsChanged = false;
                final Rect selfBounds = mForegroundInfo.mSelfBounds;
                final Rect overlayBounds = mForegroundInfo.mOverlayBounds;

                if (mForegroundInfo.mInsidePadding) {
                    selfBounds.set(0, 0, getWidth(), getHeight());
                } else {
                    selfBounds.set(getPaddingLeft(), getPaddingTop(),
                            getWidth() - getPaddingRight(), getHeight() - getPaddingBottom());
                }

                final int ld = getLayoutDirection();
                Gravity.apply(mForegroundInfo.mGravity, foreground.getIntrinsicWidth(),
                        foreground.getIntrinsicHeight(), selfBounds, overlayBounds, ld);
                foreground.setBounds(overlayBounds);
            }

            foreground.draw(canvas);
        }
    }

在注释1、2中，我们看到这个方法可能会去绘制 ScrollBar，ScrollIndicator这些东西。并且因为这个方法是处于draw方法最后做的，所以这些View是在视图的上层一些的位置。

7. 总结

至此，我们以Activity的启动为例子，大致看了一个Activity中的View是如何被布局的。
这里大致总结一下为：

在Activity创建时，会创建一个PhoneWidow做为显示Activity的界面
PhoneWindow创建并持有一个DecorView，并对其进行加载布局，默认布局下，它包含一个TitleBar和一个ContentView。
因为之后都是对DecorView做操作而不是对PhoneWindow，所以DecorView就是Activity展示的根界面。
调用Activity的handleResumeActivity()后，会对DecorView进行绘制。也就是调用WindowManager.addView()方法。
而 addView最终会调用到ViewRootImpl.performTraversals()，在这个方法中，会分别调用调用DecorView的 measure、layout、draw。
performMeasure()从根View开始，根View通过自己的LayoutParams和长宽数值决定自己的MeasureSpec，然后遍历每个子View，根据父View自己的MeasureSpec和子View的LayouParams计算出子View的MeasureSpec。然后调用子View的measure方法。
子View也会做和父View一样的事情，所以这样，会把一个界面所有的View都给measure出其测量宽/高。
performLayout()从根View开始调用layout()，计算出其左上右下距离父容器的位置，DecorView因为没有父容器，所以它填满整个屏幕。
无论是View还是ViewGroup，他们的onLayout()方法都是空的，因为不同的控件有自己的实现。而Android自带的ViewGroup(LinearLayout等)已经在onLayout()中实现了递归所有的子View的位置计算。而我们自己写ViewGroup时，需要根据控件情况手写onLayout()方法。
performDraw()会调用View的draw()。而draw()有多个步骤，其中有绘制背景、绘制自身的onDraw()，以及绘制子View的dispatchDraw(),绘制装饰等。
而onDraw()、dispatchDraw()都是空方法，由开发者自己根据控件情况实现。而ViewGroup重写了dispatchDraw()实现了对所有子View进行绘制（就是遍历调用子View的draw()）