Android事件分发和View绘制流程分析(三)

本篇就Android中View的测量整体流程简单记录如下<下面涉及到的Android源码均为API23的源码>

二、Android中View树的绘制

对于View树的绘制起始点可以追溯到在ActivityThread的performResumeActivity()–>WindowManagerGloble.addView()–>new RootViewImpl()+root.setView(DecorView)–>RootViewImpl.setView()—->RootViewImpl.requestLayout()以上步骤在第一篇文章中均可以找到，最终调用到RootViewImpl.requestLayout()方法

下面我们就从RootViewImpl.requestLayout()开始：

2.1、RootViewImpl.requestLayout()的代码，最终会调用到performTraversals()，其简单的代码逻辑如下：

    @ViewRootImpl.java  @Override//-----------1、在setView（）中有调用该方法，开始进行视图绘制----------public void requestLayout() {    if (!mHandlingLayoutInLayoutRequest) {        checkThread();        mLayoutRequested = true;        scheduleTraversals();//schedule:安排 Traversals：穿越    }}//---------------2、异步调用绘制视图 Choreographer:Coordinates the timing of animations, input and drawing.--------- void scheduleTraversals() {    if (!mTraversalScheduled) {        mTraversalScheduled = true;        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();        //--------***mTraversalRunnable 是一个TraversalRunnable类型可执行对象,视图绘制专用线程***-------------        mChoreographer.postCallback(                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);        if (!mUnbufferedInputDispatch) {            scheduleConsumeBatchedInput();        }        notifyRendererOfFramePending();        pokeDrawLockIfNeeded();    }}//-------------3、TraversalRunnable定义-------------------    @ViewRootImpl.java  final class TraversalRunnable implements Runnable {    @Override    public void run() {        //在该处调用doTraversal()        doTraversal();    }}//--------------4、mTraversalRunnable初始化---------------final TraversalRunnable mTraversalRunnable = new TraversalRunnable();//--------------5、一般常见的View开始绘制的调用performTraversals();在此方法中调用--------------void doTraversal() {    if (mTraversalScheduled) {        mTraversalScheduled = false;        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);        if (mProfile) {            Debug.startMethodTracing("ViewAncestor");        }        performTraversals();//---------6.performTraversals()----        if (mProfile) {            Debug.stopMethodTracing();            mProfile = false;        }    }}

2.2 我们下面看performTraversals()的具体实现，该部分代码是在ViewRootImpl。实现如下：

2.2.1 从2.1中调用到 performTraversals()

2.2.2 把mWindowAttributes赋值给lp，此处的lp会在下面合成DecorView的测量模式时使用。mWindowAttributes实际就是当前从当前的PhoneWindow的参数中传递过来的，而PhoneWindow中的该值是在其Window初始化话时赋值的，其默认宽高都是LayoutParams.MATCH_PARENT 具体代码在Window中，代码如下：

@Window private final WindowManager.LayoutParams mWindowAttributes =    new WindowManager.LayoutParams();@WindowManager.LayoutParams//LayoutParams 的默认构造函数实现如下，可知其宽高默认都是LayoutParams.MATCH_PARENT的public LayoutParams() {        super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);        type = TYPE_APPLICATION;        format = PixelFormat.OPAQUE;    }

2.2.3 初始化测量开始时DecorView所需的具体size大小，默认为实际屏幕的宽高

2.2.4 该处最终会回调到Activity的onAttatchWindow（）

2.2.5 mApplyInsetsRequested该值是在requestFitSystemWindows()方法中设置的，如果该值满足为true，则会执行2.2.6，否则跳过2.2.6

我们在View中调用的requestFitSystemWindows()最终会调用到ViewRootImpl中的requestFitSystemWindows() 并设置mApplyInsetsRequested 为true，大致是在设置了Window的属性之后例如SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION 属性之后应该调用一次该方法，以保证得到我们想要的效果

2.2.6 在此处调用measureHierarchy()，此处的lp为WindowManager.LayoutParams desiredWindowWidth为屏幕宽度，该方法最终会调用到 ViewRootImpl的performMeasure()，和在2.2.8处调用的是同一个方法

2.2.7 生成顶级DecorView的MeasureSpec，默认是Mode为：EXACTLY Size：屏幕相应的宽高

2.2.8 performMeasure() 正式测量确认各子View的尺寸，会回调所有View的onMeasure（）方法确定其大小。（前面2.2.6处的执行依赖2.2.5中mApplyInsetsRequested的值不一定会执行）

2.2.9 如果Window的Layoutparams中设置的有权重值则会根据权重再次测量，一般也不会执行

2.2.10 测量完毕继续调用执行layout，此时则会回调所有ViewGroup及View中的onLayout()，即我们常说的onLayout（）方法

2.2.11 布局完之后开始调用performDraw()，最终会回调到所有可绘制View的onDraw（）

 @ViewRootImpl.java private void performTraversals() {//---------2.2.1 经过上面的逻辑最终会调用到此处performTraversals()    // cache mView since it is used so much below...    final View host = mView;    WindowManager.LayoutParams lp = mWindowAttributes;//------2.2.2下面measureHierarchy（）方法中调用的getRootMeasureSpec()方法参数中的lp 实际即为当前Window的LayoutParams    int desiredWindowWidth;//下面measureHierarchy（）方法中调用的getRootMeasureSpec()方法参数中宽度大小，实际即为屏幕的宽    int desiredWindowHeight;//下面measureHierarchy（）方法中调用的getRootMeasureSpec()方法参数中高度大小，实际即为屏幕的高    ...    if（mFirst）{        ....        //----2.2.3初始化desiredWindowWidth和desiredWindowHeight 对应下面measureHierarchy（）第一个参数初始化位置；对于普通Activity即为屏幕的宽高        if (lp.type == WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL                        || lp.type == WindowManager.LayoutParams.TYPE_INPUT_METHOD) {                    // NOTE -- system code, won't try to do compat mode.                    Point size = new Point();                    mDisplay.getRealSize(size);                    desiredWindowWidth = size.x;                    desiredWindowHeight = size.y;                } else {                    DisplayMetrics packageMetrics =                        mView.getContext().getResources().getDisplayMetrics();                    desiredWindowWidth = packageMetrics.widthPixels;                    desiredWindowHeight = packageMetrics.heightPixels;                }        ....        host.dispatchAttachedToWindow(mAttachInfo, 0);//------2.2.4、该处最终会回调到Activity的onAttatchWindow（）    }    ...    if (mApplyInsetsRequested) {//-----2.2.5 mApplyInsetsRequested该值是在requestFitSystemWindows()方法中设置的，我们在View中调用的requestFitSystemWindows()最终会调用到ViewRootImpl中的requestFitSystemWindows() 并设置mApplyInsetsRequested 为true，大致是在设置了Window的属性之后例如SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION 属性之后需要调用一次该方法        mApplyInsetsRequested = false;        mLastOverscanRequested = mAttachInfo.mOverscanRequested;        dispatchApplyInsets(host);        if (mLayoutRequested) {            // Short-circuit catching a new layout request here, so            // we don't need to go through two layout passes when things            // change due to fitting system windows, which can happen a lot.            //----------2.2.6在此处调用measureHierarchy()开始measure 此处的lp为WindowManager.LayoutParams desiredWindowWidth为 屏幕宽度 desiredWindowHeight为屏幕高度---------            windowSizeMayChange |= measureHierarchy(host, lp,                    mView.getContext().getResources(),                    desiredWindowWidth, desiredWindowHeight);        }    }    ...     if (!mStopped || mReportNextDraw) {            boolean focusChangedDueToTouchMode = ensureTouchModeLocally(                    (relayoutResult&WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE) != 0);            if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth()                    || mHeight != host.getMeasuredHeight() || contentInsetsChanged) {                -----2.2.7拿取根部局的MeasureSpec-----                int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);//---1.拿取根部局的MeasureSpec---                int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);//---2.拿取根部局的MeasureSpec---                if (DEBUG_LAYOUT) Log.v(TAG, "Ooops, something changed!  mWidth="                        + mWidth + " measuredWidth=" + host.getMeasuredWidth()                        + " mHeight=" + mHeight                        + " measuredHeight=" + host.getMeasuredHeight()                        + " coveredInsetsChanged=" + contentInsetsChanged);                 // Ask host how big it wants to be                performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);//------2.2.8正式测量确认各子View的尺寸------                // Implementation of weights from WindowManager.LayoutParams                // We just grow the dimensions as needed and re-measure if                // needs be                int width = host.getMeasuredWidth();                int height = host.getMeasuredHeight();                boolean measureAgain = false;                if (lp.horizontalWeight > 0.0f) {//--------如果权重值不管是横向的还是竖向的都需要再次measure（）                    width += (int) ((mWidth - width) * lp.horizontalWeight);                    childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width,                            MeasureSpec.EXACTLY);                    measureAgain = true;                }                if (lp.verticalWeight > 0.0f) {//----------如果权重值不管是横向的还是竖向的都需要再次measure（）                    height += (int) ((mHeight - height) * lp.verticalWeight);                    childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height,                            MeasureSpec.EXACTLY);                    measureAgain = true;                }                if (measureAgain) {//---------如果需要再次测量                    if (DEBUG_LAYOUT) Log.v(TAG,                            "And hey let's measure once more: width=" + width                            + " height=" + height);                    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec); ------2.2.9 如果Window的Layoutparams中设置的有权重值则会根据权重再次测量                }                layoutRequested = true;            }        }    } else {//？？？--wtf如果不是第一次测量&&window/insets/visibility都没有变化，只是窗口有移动        ...//省略代码    }     final boolean didLayout = layoutRequested && (!mStopped || mReportNextDraw);    boolean triggerGlobalLayoutListener = didLayout            || mAttachInfo.mRecomputeGlobalAttributes;    if (didLayout) {        performLayout(lp, desiredWindowWidth, desiredWindowHeight);//------2.2.10、执行layout，会回调所有ViewGroup及View中的onLayout()-------------        //By this point all views have been sized and positioned 到此则所有View的大小及位置都已经确定完毕        // We can compute the transparent area         if ((host.mPrivateFlags & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) != 0) {            // start out transparent            // TODO: AVOID THAT CALL BY CACHING THE RESULT?            //----##首先确认DecorView在Window中的位置##-----            host.getLocationInWindow(mTmpLocation);            ...            }        }    mFirst = false;    mWillDrawSoon = false;    mNewSurfaceNeeded = false;    mViewVisibility = viewVisibility;    ...     if (!cancelDraw && !newSurface) {        if (!skipDraw || mReportNextDraw) {            if (mPendingTransitions != null && mPendingTransitions.size() > 0) {                for (int i = 0; i < mPendingTransitions.size(); ++i) {                    mPendingTransitions.get(i).startChangingAnimations();                }                mPendingTransitions.clear();            }            performDraw();//------------2.2.11该方法中会回调所有onDraw（）-----        }    } else {        if (viewVisibility == View.VISIBLE) {            // Try again            scheduleTraversals();        } else if (mPendingTransitions != null && mPendingTransitions.size() > 0) {            for (int i = 0; i < mPendingTransitions.size(); ++i) {                mPendingTransitions.get(i).endChangingAnimations();            }            mPendingTransitions.clear();        }    }    mIsInTraversal = false;}

2.3 在2.2.6中的ViewRootImpl的measureHierarchy()最终会调用到和2.2.8处相同的方法performMeasure()，而performMeasure()最终会调用到DecorView的measure()方法，measureHierarchy()和performMeasure()的实现代码如下：

2.3.1 在performMeasure()中，会调用到mView.measure（），而该mView正是DecorView,至此进入我们比较熟悉的View的measure()方法中

  private boolean measureHierarchy(final View host, final WindowManager.LayoutParams lp,        final Resources res, final int desiredWindowWidth, final int desiredWindowHeight) {    int childWidthMeasureSpec;    int childHeightMeasureSpec;    boolean windowSizeMayChange = false;    if (DEBUG_ORIENTATION || DEBUG_LAYOUT) Log.v(TAG,            "Measuring " + host + " in display " + desiredWindowWidth            + "x" + desiredWindowHeight + "...");    boolean goodMeasure = false;    if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT) {//当Window设置的为WrapContent时        // On large screens, we don't want to allow dialogs to just        // stretch to fill the entire width of the screen to display        // one line of text.  First try doing the layout at a smaller        // size to see if it will fit.        ....    }    if (!goodMeasure) {//一般的Activity中的Window在初始化时都是ViewGroup.LayoutParams.MATCH_PARENT的，上面的逻辑不会走直接走到此处        childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);        childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);        //---------执行perforMeasure()-----------        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);        if (mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight()) {            windowSizeMayChange = true;        }    }    if (DBG) {        System.out.println("======================================");        System.out.println("performTraversals -- after measure");        host.debug();    }    return windowSizeMayChange;}//----------至此开始调用DecorView的measure（）方法，Activity中一般给入的参数都是屏幕的实际宽高和MeasureSpec.EXACTLY合成的MeasureSpecprivate void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");        try {            mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);//----2.3.1 该mView正是DecorView        } finally {            Trace.traceEnd(Trace.TRACE_TAG_VIEW);        }    }

2.4 View测量开始：因为DecorView继承自FrameLayout因此其是一个ViewGroup，从此处开始就是常见的ViewGroup和View的measure过程了。

View的测量开始是从View.measure()方法开始的，我们先理清一下View树的测量逻辑

1.对于顶级DecorView的measure()我们在2.2中已经看到是在ViewRootImpl中触发，然后会调用的DecorView的onMeasure（）方法（需要明确的是DecorView是一个ViewGroup）；

2.对于一个子View（不管是单个的View还是一个ViewGroup）其measure（）方法的触发逻辑为：当其父View在执行onMeasure的时候会依次调用测量子View，最终会调用到子View的measure（）方法。

3.如果子View是一个普通的View，当触发其onMeasure之后（该过程可能执行不止一次），该View会根据传入的MeasureSpecMode和自己的测量规则算出自己的大小（只算大小，不管位置），并调用setMeasuredDimension()保存自己的测量出来的大小。

4.如果子View还是一个ViewGroup，则会再次在其onMeasure（）方法中按照实际的逻辑依次触发子View的measure（）方法，并调用setMeasuredDimension()保存自己的测量出来的大小；

5.进一步依次递归

2.4.1 在测量过程中，我们知道View的measure（）最终都会回调到View的onMeasure()，onMeasure()在View中的默认实现如下：

@View.javaprotected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {    //测量完成后调用setMeasuredDimension(),只有在调用该方法之后View的getMeasureWidth（）才会有值    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),            getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));}

2.4.2 在上面的View的onMeasure（）回调方法中的有两个参数widthMeasureSpec和heightMeasureSpec,我们暂撇开DecorView的具体测量，首先先明确一下onMeasure函数中的两个参数是怎么来的：

2.4.2.1 对于DecorView因为其是一个顶级的布局View，DecorView之上并没有父布局，其WidthMeasureSpec和heightMeasureSpec从2.2中我们可以看到是在ViewRootImpl中通过getRootMeasureSpec()生成，然后调用DecorView的measure（）方法传递进去的，getRootMeasureSpec()方法如下：

对于常见的Activity，DecorView默认其是由屏幕的实际宽高和MeasureSpec.EXACTLY合成的，具体其他的情况可以参考源码查看

@ViewRootImpl.javaprivate static int getRootMeasureSpec(int windowSize, int rootDimension) {//---此处的rootDimension默认是LayoutParams.MATCH_PARENT    int measureSpec;    switch (rootDimension) {    case ViewGroup.LayoutParams.MATCH_PARENT:        // Window can't resize. Force root view to be windowSize.        measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);        break;    case ViewGroup.LayoutParams.WRAP_CONTENT:        // Window can resize. Set max size for root view.        measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);        break;    default:        // Window wants to be an exact size. Force root view to be that size.        measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);        break;    }    return measureSpec;}

一般对于Activity来说其WindowSize即为屏幕的宽高；rootDimension则对应为WindowManager.LayputParams,因为一般默认系统生成的PhoneWindow都会设定为Match_PARENT，因此Mode就对应为就对应MeasureSpec.EXACTLY。但是该LayoutParams是可以改变的，我们比较常用的手动设置的场景是在自定义Dialog时根据需要设置Dialog的Window的相关参数

2.4.2.2 对于一般的View无论是一个View还是一个ViewGroup，这两个参数都是在父布局中生成并最终传入的，而只要是父布局则肯定是ViewGroup,其测量模式都是在父布局中生成的：

在ViewGroup中不同的ViewGroup实现的onMeasure由于工作机制不同，其measureChildren（）和measureChild（）的实现也不相同，默认实现如下：

    @ViewGroup.java   protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {    final int size = mChildrenCount;    final View[] children = mChildren;    for (int i = 0; i < size; ++i) {        final View child = children[i];        if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {            measureChild(child, widthMeasureSpec, heightMeasureSpec);        }    }}//measureChild的默认实现如下 protected void measureChild(View child, int parentWidthMeasureSpec,        int parentHeightMeasureSpec) {    final LayoutParams lp = child.getLayoutParams();    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,            mPaddingLeft + mPaddingRight, lp.width);    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,            mPaddingTop + mPaddingBottom, lp.height);    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);}

但是不管ViewGroup的具体实现是什么，最终都会调用getChildMeaureSpec（）来生成子View所需的MeasureSpec，实现如下：

@ViewGroup.java//getChildMeasureSpec()实现如下public static int getChildMeasureSpec(int spec, int padding, int childDimension) {        int specMode = MeasureSpec.getMode(spec);        int specSize = MeasureSpec.getSize(spec);        int size = Math.max(0, specSize - padding);        int resultSize = 0;        int resultMode = 0;        switch (specMode) {        // Parent has imposed an exact size on us        case MeasureSpec.EXACTLY:            if (childDimension >= 0) {                resultSize = childDimension;                resultMode = MeasureSpec.EXACTLY;            } else if (childDimension == LayoutParams.MATCH_PARENT) {                // Child wants to be our size. So be it.                resultSize = size;                resultMode = MeasureSpec.EXACTLY;            } else if (childDimension == LayoutParams.WRAP_CONTENT) {                // Child wants to determine its own size. It can't be                // bigger than us.                resultSize = size;                resultMode = MeasureSpec.AT_MOST;            }            break;        // Parent has imposed a maximum size on us        case MeasureSpec.AT_MOST:            if (childDimension >= 0) {                // Child wants a specific size... so be it                resultSize = childDimension;                resultMode = MeasureSpec.EXACTLY;            } else if (childDimension == LayoutParams.MATCH_PARENT) {                // Child wants to be our size, but our size is not fixed.                // Constrain child to not be bigger than us.                resultSize = size;                resultMode = MeasureSpec.AT_MOST;            } else if (childDimension == LayoutParams.WRAP_CONTENT) {                // Child wants to determine its own size. It can't be                // bigger than us.                resultSize = size;                resultMode = MeasureSpec.AT_MOST;            }            break;        // Parent asked to see how big we want to be        case MeasureSpec.UNSPECIFIED:            if (childDimension >= 0) {                // Child wants a specific size... let him have it                resultSize = childDimension;                resultMode = MeasureSpec.EXACTLY;            } else if (childDimension == LayoutParams.MATCH_PARENT) {                // Child wants to be our size... find out how big it should                // be                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;                resultMode = MeasureSpec.UNSPECIFIED;            } else if (childDimension == LayoutParams.WRAP_CONTENT) {                // Child wants to determine its own size.... find out how                // big it should be                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;                resultMode = MeasureSpec.UNSPECIFIED;            }            break;        }        return MeasureSpec.makeMeasureSpec(resultSize, resultMode);    }

而该getChildMeasureSpec(int spec, int padding, int childDimension)的逻辑则可以总结为我们经常能够见到的一张表格：

Android事件分发和View绘制流程分析(三)_第1张图片

2.5 以上我们知道了在View的测量起始位置measure（），然后会调用onMeasure（，以及onMeasure（）方法中的两个参数的来历，下面就以一个常见的LinearLayout来走一下一个ViewGroup具体的measure过程：

首先：我们带着以下几个问题来看其测量过程

1.在测量中为什么有时measure会调用多次?
2.LinearLayout中设置Weight后是怎么测量的？
3.什么时候getMeasureWidth（），getMeasureHeight（）才能得到正确的值？
4.什么时候getWidth（）和getHeight（）才能拿到正确的值？

2.5.1 我们先看LinearLayout的onMeasure方法，再提一下View（不管是View还是ViewGroup）的onMeasure方法的调用逻辑为：当父View在执行onMeasure的时候依次调用子View的measure()方法，而在View的measure中会回调onMeasure()：

2.5.1.1在LinearLayout的onMeasure（）中方法中，首先会根据当前LinearLayout设置的orientation调用来调用相关的测量方法，代码如下：

@LinearLayout.java   @Overrideprotected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {    if (mOrientation == VERTICAL) {        measureVertical(widthMeasureSpec, heightMeasureSpec);//设置Orientation = VERTICAL 时会使用该方法进行测量    } else {        measureHorizontal(widthMeasureSpec, heightMeasureSpec);    }}

2.5.1.2 我们只以orientation设置为VERTICAL的来进行分析，measureVertical的代码如下：**

1、在该方法中会首先置mTotalLength为0，该字段记录当前LinearLayout的总高，每测量出来一个子View的总高时即会加上该子View的高度，以及其设置的margin值
2、在该方法中会声明局部变量totalWeight用来记录子View设置的权重值
3.拿取当前LinearLayout所有的子View个数，不管是是否已经设置为了GONE，但是在下面测量中设置为GONE的子View将不会测量
4.然后会得到当前LinearLayout的widthMode和heightMode，以便在确定子View的测量模式时使用
5.for循环拿取依次遍历子View，对于每一个子View实现以下luoji
6.如果该子View为设置为了GONE，则直接continue，跳过该View的测量并统计跳过的View
7.判断该子View是否有Divider，如果有的话则总高加上一个Divider的高度
8.拿取子View设置的LayoutParams，即在XML中的声明的相关LayoutParams或代码中设置的相应LayoutParams
9.1如果当前LinearLayout的测量模式是MeasureSpec.EXACTLY并且该子View的LayoutParams的lp.height == 0 并且lp.weight > 0，此时会先跳过该子View的测量，但是mTotalLength会加上该子View设置的margin，并设置skippedMeasure标志位为true，标识有跳过的子View未测量，以便在下面的逻辑中测量
10.如果不满足9.1的条件，该开始对子View会进行一次测量
10.1、如果当该子View的lp.height == 0 并且lp.weight > 0时，此时当前LinearLayout的测量模式肯定不为MeasureSpec.EXACTLY，则设更改该子View的lpt的参数lp.height为LayoutParams.WRAP_CONTENT，表示当当前LinearLayout的尺寸高度不确定时，该子类View的在测量时尽量利用所有的有效空间
10.2 调用 measureChildBeforeLayout(),正式开始测量子View的大小，该方法会调用ViewGroup中的 measureChildWithMargins(child,widthMeasureSpec, totalWidth,heightMeasureSpec, totalHeight);其中的参数totalHeight即是当前已经测量出来的mTotalLength。该参数最终会被当做已经占用的高度（heightused），在合成子View的MeasureSpec时候使用的size会相应的减掉该值
11、根据已经占用的高度计算剩余的有效高度空间，此时满足9.1条件的View还没有进行测量不再已占用的高度之内，另外需要注意的一个场景是当一个View的高设置为WrapContent，同时weight>0次数该View的高度会按照WrapConten的测量模式，执行measureChildBeforeLayout()进行过一次测量一遍并已经计入了mTotalLength。
12、到该步骤则View大致是对应9.1的条件满足还没有进行过测量的，以及不管是否有weight值，但是已经按照相应的测量模式测量过一次了的
13.如果满足有跳过的View没有测量（即有满足9.1条件的View）或者统计到的weight值大于0同时还有剩余空间，则循环遍历所有子View
14、如果子View的weight>0,则根据剩余高度和统计出来的所有子View的weight值，对剩余空间进行切分，并把该值按比例添加到子View已经测量出来的高度上并和MeasureSpec.EXACTLY合成子View测量模式进行重新测量，总之就是把剩余的空间按比例重新分配到子View上去，需要注意对于前面满足9.1跳过的子View，不会有把当前的高度加上相应比例剩余空间的操作，而是直接按照其需要占用的剩余空间的大小进行重新测量。因为之前没有对其测量过根本
15、如果没有跳过任何子View的测量的（对应13条件的else{}），且满足设置了使用useLargestChild为true且当前的LinearLayout的测量模式不为MeasureSpec.EXACTLY，ps：一般的情形不会走到该逻辑中
16、当前LinearLayout测量完毕调用setMeasuredDimension（）设置其宽高。其中的入参heightSizeAndState，在第11步代码之前已经确认，因为如果没有weight则那是已经计算出了总高，如果是设置有weight则weight就是要占据所有剩余空间，此时height也是可以确定的

具体LinearLayout的代码及相应的简单注释如下：

@LinearLayout.java//竖直布局时使用的测量方法void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {    mTotalLength = 0;//---1.用来记录当前LinearLayout已经占用的高度（或者简单的说每测量一个子View该值都会加上该子View的高度）    int maxWidth = 0;    int childState = 0;    int alternativeMaxWidth = 0;    int weightedMaxWidth = 0;    boolean allFillParent = true;    float totalWeight = 0;//---2.权重值统计    final int count = getVirtualChildCount();//-----3.拿取子View的个数，但不一定是最终子View的个数，子View的Visible属性为GONE时会直接跳过不再测量    final int widthMode = MeasureSpec.getMode(widthMeasureSpec);//----4.当前布局的测量模式--对于该LinearLayout的子View来书这个即使父布局的测量模式，在合成子View的MeasureSpecMode的时候父布局的测量模式即使从此处得到    final int heightMode = MeasureSpec.getMode(heightMeasureSpec);//当前布局的测量模式    boolean matchWidth = false;    boolean skippedMeasure = false;    final int baselineChildIndex = mBaselineAlignedChildIndex;            final boolean useLargestChild = mUseLargestChild;    int largestChildHeight = Integer.MIN_VALUE;    // See how tall everyone is. Also remember max width.----5、 开始所有子View的测量，ViewGrop的测量师递归的即如果子View也是一个ViewGroup则会直接进入该子View其内部进行测量    for (int i = 0; i < count; ++i) {        final View child = getVirtualChildAt(i);        if (child == null) {            mTotalLength += measureNullChild(i);            continue;        }        if (child.getVisibility() == View.GONE) {//----6、如果子View的Visibility属性设置为GONE则统计后直接continue           i += getChildrenSkipCount(child, i);           continue;        }        if (hasDividerBeforeChildAt(i)) {//------7、是否有Divider            mTotalLength += mDividerHeight;        }        LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();//----8、拿取子View的LayoutParams        totalWeight += lp.weight;//统计子View设置的权重值        if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {//----9.如果LinearLayout的SpecMode为EXACTLY&&子View的height ==0 且子View设置的weight>0（简单书就是如果当前的Linearlayout的高度尺寸已经确定同时该子View的高度设置为0且该子View的weight值不为0）---            // Optimization: don't bother measuring children who are going to use            // 优化：不再过度的去测量将会使用剩余空间的子View            // leftover space. These views will get measured again down below if            //这些子View将会在下面再次得到测量当还有剩余空间时            // there is any leftover space.            final int totalLength = mTotalLength;            mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);            skippedMeasure = true;//测量子View过程中是否有跳过        } else {//----10、否则            int oldHeight = Integer.MIN_VALUE;            if (lp.height == 0 && lp.weight > 0) {//----11、如果子View的Weight>0(即有权重值)且设置的高度为0                 // heightMode is either UNSPECIFIED or AT_MOST, and this                //不管当前布局的测量模式是 ATMOST还是UNSPECIFIED（不可能再会是EXACTLY），                // child wanted to stretch to fill available space.                //并且该子View想要填充当前Linearlayout剩余的有效空间。                // Translate that to WRAP_CONTENT so that it does not end up                //则设置该子View的LayoutParams为WrapContent                // with a height of 0                oldHeight = 0;                lp.height = LayoutParams.WRAP_CONTENT;//设置子View为WrapContent            }            // Determine how big this child would like to be. If this or            //确认该子View想要得到多大的空间如果该子View或者之前有子View设置过Weight，            // previous children have given a weight, then we allow it to            //那么会允许子View得到所有的有效空间（但是如果需要的话我们在后面可能会收缩该空间）            // use all available space (and we will shrink things later            // if needed).            measureChildBeforeLayout(//                   child, i, widthMeasureSpec, 0, heightMeasureSpec,                   totalWeight == 0 ? mTotalLength : 0);            if (oldHeight != Integer.MIN_VALUE) {               lp.height = oldHeight;            }            final int childHeight = child.getMeasuredHeight();            final int totalLength = mTotalLength;            mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +                   lp.bottomMargin + getNextLocationOffset(child));            if (useLargestChild) {                largestChildHeight = Math.max(childHeight, largestChildHeight);            }        }        /**         * If applicable, compute the additional offset to the child's baseline         * we'll need later when asked {@link #getBaseline}.         */        if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {           mBaselineChildTop = mTotalLength;        }        // if we are trying to use a child index for our baseline, the above        // book keeping only works if there are no children above it with        // weight.  fail fast to aid the developer.        if (i < baselineChildIndex && lp.weight > 0) {            throw new RuntimeException("A child of LinearLayout with index "                    + "less than mBaselineAlignedChildIndex has weight > 0, which "                    + "won't work.  Either remove the weight, or don't set "                    + "mBaselineAlignedChildIndex.");        }        boolean matchWidthLocally = false;        if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {            // The width of the linear layout will scale, and at least one            // child said it wanted to match our width. Set a flag            // indicating that we need to remeasure at least that view when            // we know our width.            matchWidth = true;            matchWidthLocally = true;        }        final int margin = lp.leftMargin + lp.rightMargin;        final int measuredWidth = child.getMeasuredWidth() + margin;        maxWidth = Math.max(maxWidth, measuredWidth);        childState = combineMeasuredStates(childState, child.getMeasuredState());        allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;        if (lp.weight > 0) {            /*             * Widths of weighted Views are bogus if we end up             * remeasuring, so keep them separate.             */            weightedMaxWidth = Math.max(weightedMaxWidth,                    matchWidthLocally ? margin : measuredWidth);        } else {            alternativeMaxWidth = Math.max(alternativeMaxWidth,                    matchWidthLocally ? margin : measuredWidth);        }        i += getChildrenSkipCount(child, i);    }    if (mTotalLength > 0 && hasDividerBeforeChildAt(count)) {        mTotalLength += mDividerHeight;    }    if (useLargestChild &&            (heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED)) {        mTotalLength = 0;        for (int i = 0; i < count; ++i) {            final View child = getVirtualChildAt(i);            if (child == null) {                mTotalLength += measureNullChild(i);                continue;            }            if (child.getVisibility() == GONE) {                i += getChildrenSkipCount(child, i);                continue;            }            final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)                    child.getLayoutParams();            // Account for negative margins            final int totalLength = mTotalLength;            mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +                    lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));        }    }    // Add in our padding    mTotalLength += mPaddingTop + mPaddingBottom;    int heightSize = mTotalLength;    // Check against our minimum height    heightSize = Math.max(heightSize, getSuggestedMinimumHeight());    // Reconcile our calculated size with the heightMeasureSpec    int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);//  ------heightSizeAndState 确认    heightSize = heightSizeAndState & MEASURED_SIZE_MASK;    // Either expand children with weight to take up available space or    // shrink them if they extend beyond our current bounds. If we skipped    // measurement on any children, we need to measure them now.    int delta = heightSize - mTotalLength;//----11、算出之前没有跳过的所有子View已经占据的空间打小，注意当子View设置为WrapContent weight>0时，此时mTotallenrth中是包含实际按AtMost算出来的大小值的，该处可以说明weight是所有子View计算之后剩余子View的剩余大小再按权重分配的---    //-----12、到该步骤则View大致是对应9.1的条件满足还没有进行过测量的，以及不管是否有weight值，但是已经按照相应的测量模式测量过一次了的    if (skippedMeasure || delta != 0 && totalWeight > 0.0f) {        float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;        mTotalLength = 0;        //----13、循环遍历子View 根据相应的规则进行重新测量        for (int i = 0; i < count; ++i) {            final View child = getVirtualChildAt(i);            if (child.getVisibility() == View.GONE) {                continue;            }            LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();            float childExtra = lp.weight;            if (childExtra > 0) {//14、如果子View的权重值大于0 按以下机制再次计算，------------                // Child said it could absorb extra space -- give him his share                int share = (int) (childExtra * delta / weightSum);//12.计算需要该子View的weight所需要占用的剩余空间                weightSum -= childExtra;                delta -= share;                final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,                        mPaddingLeft + mPaddingRight +                                lp.leftMargin + lp.rightMargin, lp.width);                // TODO: Use a field like lp.isMeasured to figure out if this                // child has been previously measured                if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {//此处逻辑（对应之前跳过没有测量的View）：子View满足lp.weight>0的同时lp.height!=0或者当前LinearLayout的SpecMode不是EXACTLY                 //此处对应一种情况是当weight>0 lp.height为wrapcontent时，当前LinearLayout为EXACTLY时，得到的效果即是，该子View的大小为按照权重得到的剩余空间+上面按照ATMOST已经测量出来的大小。我们可以设置该多个子View的LayoutParamas为WrapContent同时设置其weight都为1，会看到子View的所占的高度是不等的，但是其减去实际占的位置之后，剩余的空间是相等的                    // child was measured once already above...                    // base new measurement on stored values                    int childHeight = child.getMeasuredHeight() + share;//把剩余的空间按照比例添加到子View上                    if (childHeight < 0) {                        childHeight = 0;                    }                    child.measure(childWidthMeasureSpec,                            MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));//重新测量子View                } else {//此处逻辑是子View满足（lp.weight>0&&lp.height==0&&当前Linearlayout的heightSpecMode==EXACTLY）简单的说即是上面直接跳过的没有进行过测量的子View                    // child was skipped in the loop above.                    // Measure for this first time here                     // 一开始跳过的子View此时第一次测量 尺寸大小为根据剩余尺寸和所占的权重计算出来的size大小,SpecMode为EXACTLY                         child.measure(childWidthMeasureSpec,                            MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,                                    MeasureSpec.EXACTLY));                }                // Child may now not fit in vertical dimension.                childState = combineMeasuredStates(childState, child.getMeasuredState()                        & (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));            }            final int margin =  lp.leftMargin + lp.rightMargin;            final int measuredWidth = child.getMeasuredWidth() + margin;            maxWidth = Math.max(maxWidth, measuredWidth);            boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&                    lp.width == LayoutParams.MATCH_PARENT;            alternativeMaxWidth = Math.max(alternativeMaxWidth,                    matchWidthLocally ? margin : measuredWidth);            allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;            final int totalLength = mTotalLength;            mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +                    lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));//再次统计当前Linearlayout的高度        }        // Add in our padding        mTotalLength += mPaddingTop + mPaddingBottom;        // TODO: Should we recompute the heightSpec based on the new total length?    } else {//----如果没有跳过任何子View的测量的则执行以下逻辑----        alternativeMaxWidth = Math.max(alternativeMaxWidth,                                       weightedMaxWidth);        // We have no limit, so make all weighted views as tall as the largest child.        // Children will have already been measured once.        if (useLargestChild && heightMode != MeasureSpec.EXACTLY) {//----15、如果没有跳过任何子View的测量的则执行以下逻辑，且满足设置了使用useLargestChild为true且当前的LinearLayout的测量模式不为MeasureSpec.EXACTLY----            for (int i = 0; i < count; i++) {                final View child = getVirtualChildAt(i);                if (child == null || child.getVisibility() == View.GONE) {                    continue;                }                final LinearLayout.LayoutParams lp =                        (LinearLayout.LayoutParams) child.getLayoutParams();                float childExtra = lp.weight;                if (childExtra > 0) {//如果有权重则再次测量其所占比例                    child.measure(                            MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(),                                    MeasureSpec.EXACTLY),                            MeasureSpec.makeMeasureSpec(largestChildHeight,                                    MeasureSpec.EXACTLY));                }            }        }    }    if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {        maxWidth = alternativeMaxWidth;    }    maxWidth += mPaddingLeft + mPaddingRight;    // Check against our minimum width    maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());    setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),            heightSizeAndState);//----16、当前LinearLayout测量完毕 调用setMeasuredDimension    if (matchWidth) {        forceUniformWidth(count, heightMeasureSpec);    }}

2.5.2、上面我们大致的走了LinearLayout的整体测量流程。我们就来解释一下我们一开始提出的几个问题：

2.5.2.1 在测量中为什么有时measure会调用多次?

对于LinearLayout如果一旦子View设置了weight，并且在当前LinearLayout的SpecMode不为EXACTLY的时候，会首先该子View会首先按照ATMOST+剩余有效空间大小合成子View的SpecMode进行一次测量，然后当所有子View测量完毕之后，会把剩余的空间按照该View占总权重的比例算出一个高度值，并把该值添加到已经测量出的高度值上与MeasureSpec.EXACTLY合成之后再次测量，此时子View的measure就不止调用一次，当让这只是一种情况。但说明measure调用的次数是和具体的测量策略有一定关系的

2.5.2.2 LinearLayout中设置Weight后是怎么测量的？

问题1中也已经回答了该问题，有一个比较特殊的场景可以验证，假设当前LinearLayout高满足测量模式为MeasureSpec.EXACTLY，有三个子View，当把所有子View设置为WrapContent，weight值为1时，如果三个子View的占用高度不同但是加起来当前LinearLayout仍有剩余空间时，则每个子View的实际测量高度为其有效占用高度+剩余空间的1/3,简单的各子View的最终测量出来的大小是不同的。(子View嵌套又有设置了Weight的子View的场景除外)。但是如果三个子View的高度设置为0，则会满足2.4.1中9.1的条件，此时最终子View的测量出来的高度值相同为当前LinearLayout高度的1/3。因此想要用weight值来让子View之间的间距看起来一样的时候，需要设置为WrapContent但是不建议使用此种方法，因为一旦子View中还有子View且设置了Weight值那么就不一样了。

2.5.5.3 什么时候getMeasureWidth（），getMeasureHeight（）才能得到正确的值？

这个我们在跟进代码setMeasuredDimension()之后就能清除看到只有测量完毕调用了该方法之后getMeasureWidth（）和getMeasureHeight（）才能拿到有效的值。

//setMeasuredDimension() 会调用到下面的方法@View.java private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {    mMeasuredWidth = measuredWidth;//给mMeasuredWidth赋值，在这之后getMeasureHeight（）才能拿取到值    mMeasuredHeight = measuredHeight;    mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;}

2.5.5.4什么时候getWidth（）和getHeight（）才能拿到正确的值？

mRight和mLeft则是在onLayout之后才能确定，所以getWidth（）想要拿取到正确的值需要等到layout完毕之后才行

对于这个问题我们看代码：@View.java public final int getWidth() {    return mRight - mLeft;}

Android事件分发和View绘制流程分析(三)