// ViewRootImpl 
private void performlayout(WindowManager.LayoutParams lp,int desiredWindowWidth, desiredWindowHeight) {
        mLayoutRequested = false;
        mScrollMayChange = true;
        mInLayout = ;

        final View host = mView;
        if (host == null) {
            return;
        }
        if (DEBUG_ORIENTATION || DEBUG_LAYOUT) {
            Log.v(mTag,"Laying out " + host + " to (" +
                    host.getMeasuredWidth() + "," + host.getMeasuredHeight() + ")");
        }

        Trace.traceBegin(Trace.TRACE_TAG_VIEW,"layout");
        try {
　　　　　　　// 根据测量结果进行绘制 
            host.layout(0,0,host.getMeasuredWidth(),host.getMeasuredHeight());

            mInLayout = ;
            int numViewsRequestingLayout = mLayoutRequesters.size();
            if (numViewsRequestingLayout > 0) {
                // requestLayout() was called during layout.
                 If no layout-request flags are set on the requesting views,there is no problem.
                 If some requests are still pending,then we need to clear those flags and do
                 a full request/measure/layout pass to handle this situation.
                ArrayList<View> validLayoutRequesters = getValidLayoutRequesters(mLayoutRequesters,1)">);
                if (validLayoutRequesters != ) {
                     Set this flag to indicate that any further requests are happening during
                     the second pass,which may result in posting those requests to the next
                     frame instead
                    mHandlingLayoutInLayoutRequest = ;

                     Process fresh layout requests,then measure and layout
                    int numValidRequests = validLayoutRequesters.size();
                    for (int i = 0; i < numValidRequests; ++i) {
                        final View view = validLayoutRequesters.get(i);
                        Log.w("View","requestLayout() improperly called by " + view +
                                " during layout: running second layout pass");
                        view.requestLayout();
                    }
                    measureHierarchy(host,lp,mView.getContext().getResources(),desiredWindowWidth,desiredWindowHeight);
                    mInLayout = true;
                    host.layout(0,host.getMeasuredHeight());

                    mHandlingLayoutInLayoutRequest =  Check the valid requests again,this time without checking/clearing the
                     layout flags,since requests happening during the second pass get noop''d
                    validLayoutRequesters = getValidLayoutRequesters(mLayoutRequesters,1)">);
                    ) {
                        final ArrayList<View> finalRequesters = validLayoutRequesters;
                         Post second-pass requests to the next frame
                        getRunQueue().post(new Runnable() {
                            @Override
                            public void run() {
                                 finalRequesters.size();
                                i) {
                                     finalRequesters.get(i);
                                    Log.w("View","requestLayout() improperly called by " + view +
                                            " during second layout pass: posting in next frame");
                                    view.requestLayout();
                                }
                            }
                        });
                    }
                }

            }
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
        mInLayout = ;
    }

 ViewGroup 
final void layout(int l,1)">int t,1)">int r,1)"> b) {
        if (!mSuppressLayout && (mTransition == null || !mTransition.isChangingLayout())) {
            if (mTransition != ) {
                mTransition.layoutChange(this);
            }
            super.layout(l,t,r,b);
        } else {
             record the fact that we noop''d it; request layout when transition finishes
            mLayoutCalledWhileSuppressed = ;
        }
    }

// View   
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,b) : setFrame(l,b);
　　　　　// 发生了改变，或者是需要重新 layout，那么就会进入 onLayout 逻辑
        if (changed || (mPrivateFlags & PFLAG_LAYOUT_required) == PFLAG_LAYOUT_required) {
            // 开始
            onLayout(changed,l,b);

            if (shouldDrawRoundScrollbar()) {
                if(mRoundScrollbarRenderer == ) {
                    mRoundScrollbarRenderer = new RoundScrollbarRenderer();
                }
            }  {
                mRoundScrollbarRenderer = ;
            }
　　　　　　　// 清除请求 layout 的标记
            mPrivateFlags &= ~PFLAG_LAYOUT_required;

            ListenerInfo li = mListenerInfo;
            if (li != null && li.mOnLayoutchangelisteners != ) {
                ArrayList<OnLayoutchangelistener> listenerscopy =
                        (ArrayList<OnLayoutchangelistener>)li.mOnLayoutchangelisteners.clone();
                int numListeners = listenerscopy.size();
                int i = 0; i < numListeners; ++i) {
                    listenerscopy.get(i).onLayoutChange(boolean wasLayoutValid = isLayoutValid();

        mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
        mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;

        if (!wasLayoutValid && isFocused()) {
            mPrivateFlags &= ~PFLAG_WANTS_FOCUS;
             (canTakeFocus()) {
                 We have a robust focus,so parents should no longer be wanting focus.
                clearParentsWantFocus();
            } else if (getViewRootImpl() == getViewRootImpl().isInLayout()) {
                 This is a weird case. Most-likely the user,rather than ViewRootImpl,called
                 layout. In this case,there''s no guarantee that parent layouts will be evaluated
                 and thus the safest action is to clear focus here.
                clearFocusInternal(null,1)">/* propagate */ true,1)"> refocus );
                clearParentsWantFocus();
            } if (!hasParentWantsFocus()) {
                 original requestFocus was likely on this view directly,so just clear focus
                clearFocusInternal( otherwise,we let parents handle re-assigning focus during their layout passes.
        } if ((mPrivateFlags & PFLAG_WANTS_FOCUS) != 0) {
            mPrivateFlags &= ~PFLAG_WANTS_FOCUS;
            View focused = findFocus();
            if (focused !=  Try to restore focus as close as possible to our starting focus.
                if (!restoreDefaultFocus() && !hasParentWantsFocus()) {
                     Give up and clear focus once we''ve reached the top-most parent which wants
                     focus.
                    focused.clearFocusInternal();
                }
            }
        }

        if ((mPrivateFlags3 & PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT) != 0) {
            mPrivateFlags3 &= ~PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT;
            notifyEnterOrExitForAutoFillIfNeeded();
        }
    }

protected boolean setFrame(int left,1)">int top,1)">int right,1)"> bottom) {
        boolean changed =  (DBG) {
            Log.d(VIEW_LOG_TAG,1)">this + " View.setFrame(" + left + "," + top + ","
                    + right + "," + bottom + ")");
        }
　　　　　// 有一个不一样说明发生了改变
        if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {
            changed = ;

             Remember our drawn bit
            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 our old position
            invalidate(sizeChanged);

            mLeft = left;
            mTop = top;
            mRight = right;
            mBottom = bottom;
            mRenderNode.setLeftTopRightBottom(mLeft,mTop,mRight,mBottom);
　　　　　　　// 做好标记
            mPrivateFlags |= PFLAG_HAS_BOUNDS;

　　　　　　　// size 改变的回调
             (sizeChanged) {
                sizeChange(newWidth,newHeight,oldWidth,oldHeight);
            }

            if ((mViewFlags & VISIBILITY_MASK) == VISIBLE || mGhostView !=  If we are visible,force the DRAWN bit to on so that
                 this invalidate will go through (at least to our parent).
                 This is because someone may have invalidated this view
                 before this call to setFrame came in,thereby clearing
                 the DRAWN bit.
                mPrivateFlags |= PFLAG_DRAWN;
                invalidate(sizeChanged);
                 parent display list may need to be recreated based on a change in the bounds
                 of any child
                invalidateParentCaches();
            }

             Reset drawn bit to original value (invalidate turns it off)
            mPrivateFlags |= drawn;

            mBackgroundSizeChanged = ;
            mDefaultFocusHighlightSizeChanged = if (mForegroundInfo != ) {
                mForegroundInfo.mBoundsChanged = ;
            }

            notifySubtreeAccessibilityStateChangedIfNeeded();
        }
         changed;
    }

  void sizeChange(int newWidth,1)">int newHeight,1)">int oldWidth,1)"> oldHeight) {
        onSizeChanged(newWidth,oldHeight);
    　　......
}

子 View Layout 流程

当 DecorView 确定好了自己的位置之后，开始调用 onLayout 来确定子 view 的位置。对于 onLayout 方法，View 和 ViewGroup 类是空实现，接下来看 FrameLayout 的实现：

 FrameLayout 
void onLayout(boolean changed,1)"> bottom) {
        layoutChildren(left,top,right,bottom,1)">false  no force left gravity */);
    }

 FrameLaout   
void layoutChildren(int bottom,1)">boolean forceLeftGravity) {
        int count = getChildCount();
　　　　　// 获取 DecoverView 剩余的空间范围
        int parentLeft = getPaddingLeftWithForeground();
        int parentRight = right - left - getPaddingRightWithForeground();

        int parentTop = getPaddingTopWithForeground();
        int parentBottom = bottom - top - getPaddingBottomWithForeground();

        int i = 0; i < count; i++final View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                final LayoutParams lp = (LayoutParams) child.getLayoutParams();

                int width = child.getMeasuredWidth();
                int height = child.getMeasuredHeight();

                 childLeft;
                 childTop;

　　　　　　　　　　// DEFAULT_CHILD_GraviTY = Gravity.TOP | Gravity.START 默认是在左上角

int gravity = lp.gravity;
                if (gravity == -1) {
                    gravity = DEFAULT_CHILD_GraviTY;
                }

                int layoutDirection = getLayoutDirection();
                int absoluteGravity = Gravity.getAbsoluteGravity(gravity,layoutDirection);
                int verticalGravity = gravity & Gravity.VERTICAL_GraviTY_MASK;
　　　　　　　　　 // 确定左边起始点
                switch (absoluteGravity & Gravity.HORIZONTAL_GraviTY_MASK) {
                    case Gravity.CENTER_HORIZONTAL:
                        childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
                        lp.leftMargin - lp.rightMargin;
                        break;
                     Gravity.RIGHT:
                        forceLeftGravity) {
                            childLeft = parentRight - width - lp.rightMargin;
                            ;
                        }
                     Gravity.LEFT:
                    default:
                        childLeft = parentLeft + lp.leftMargin;
                }
　　　　　　　　　　// 确定上边起始点
                switch (verticalGravity) {
                     Gravity.TOP:
                        childTop = parentTop + lp.topMargin;
                         Gravity.CENTER_VERTICAL:
                        childTop = parentTop + (parentBottom - parentTop - height) / 2 +
                        lp.topMargin - lp.bottomMargin;
                         Gravity.BottOM:
                        childTop = parentBottom - height -:
                        childTop = parentTop + lp.topMargin;
                }

                child.layout(childLeft,childTop,childLeft + width,childTop + height);
            }
        }
    }

 bottom) {

}

 performDraw() {
...
fullRedrawNeeded，它的作用是判断是否需要重新绘制全部视图
draw(fullRedrawNeeded);
...
}

void draw( fullRedrawNeeded) {
 ...
 获取mDirty，该值表示需要重绘的区域
 final Rect dirty = mDirty;
 if (mSurfaceHolder != ) {
   The app owns the surface,we won''t draw.
  dirty.setEmpty();
   (animating) {
   if (mScroller != ) {
    mScroller.abortAnimation();
   }
   disposeResizeBuffer();
  }
  ;
 }

 如果fullRedrawNeeded为真，则把dirty区域置为整个屏幕，表示整个视图都需要绘制
 第一次绘制流程，需要绘制所有视图
  (fullRedrawNeeded) {
  mAttachInfo.mIgnoreDirtyState = ;
  dirty.set(0,(int) (mWidth * appScale + 0.5f),1)">int) (mHeight * appScale + 0.5f));
 }
 ...
 drawSoftware(surface,mAttachInfo,xOffset,yOffset,scalingrequired,dirty)) {
    ;
  }
}

boolean drawSoftware(Surface surface,AttachInfo attachInfo,1)">int xoff,1)"> yoff,1)"> scalingrequired,Rect dirty) {
 final Canvas canvas;
  锁定canvas区域，由dirty区域决定
  这个canvas就是我们想在上面绘制东西的画布
  canvas = mSurface.lockCanvas(dirty);
  ...
 画布支持位图的密度，和手机分辨率相关
  canvas.setDensity(mDensity);
 ...
   if (!canvas.isOpaque() || yoff != 0 || xoff != 0) {
                canvas.drawColor(0yoff);
   ...
   正式开始绘制
   mView.draw(canvas);
  ...
 提交需要绘制的东西
  surface.unlockCanvasAndPost(canvas);
}

   draw(Canvas canvas) {
        .draw(canvas);

        if (mMenuBackground != ) {
            mMenuBackground.draw(canvas);
        }
    }

    int privateFlags = mPrivateFlags;
        boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
                (mAttachInfo == mAttachInfo.mIgnoreDirtyState);
        mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;

        
         * Draw traversal performs several drawing steps which must be executed
         * in the appropriate order:
         *
         *      1. Draw the background
         *      2. If necessary,save the canvas'' layers to prepare for fading
         *      3. Draw view''s content
         *      4. Draw children
         *      5. If necessary,draw the fading edges and restore layers
         *      6. Draw decorations (scrollbars for instance)
         */

         Step 1,draw the background,if needed
         saveCount;

        绘制背景
        dirtyOpaque) {
            drawBackground(canvas);
        }

         如果可以跳过2和5步
        int viewFlags = mViewFlags;
      判断是否有绘制衰退边缘的标示
        boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
        boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
      如果没有绘制衰退边缘只需要3,4,6步
        if (!verticalEdges && !horizontalEdges) {
             Step 3,draw the content
            dirtyOpaque) onDraw(canvas);

             Step 4,draw the children
            dispatchDraw(canvas);

             Overlay is part of the content and draws beneath Foreground
            if (mOverlay != null && !mOverlay.isEmpty()) {
                mOverlay.getoverlayView().dispatchDraw(canvas);
            }

             Step 6,draw decorations (foreground,scrollbars)
            onDrawForeground(canvas);

             we''re done...
            ;
        }

        
         * Here we do the full fledged routine...
         * (this is an uncommon case where speed matters less,* this is why we repeat some of the tests that have been
         * done above)
         boolean drawTop = boolean drawBottom = boolean drawLeft = boolean drawRight = float topFadeStrength = 0.0ffloat bottomFadeStrength = 0.0ffloat leftFadeStrength = 0.0ffloat rightFadeStrength = 0.0f Step 2,save the canvas'' layers
        int paddingLeft = mPaddingLeft;

        boolean offsetrequired = isPaddingOffsetrequired();
         (offsetrequired) {
            paddingLeft += getLeftPaddingOffset();
        }

        int left = mScrollX + paddingLeft;
        int right = left + mRight - mLeft - mPaddingRight -int top = mScrollY + getFadetop(offsetrequired);
        int bottom = top + getFadeHeight(offsetrequired);

         (offsetrequired) {
            right += getRightPaddingOffset();
            bottom += getBottomPaddingOffset();
        }

        final ScrollabilityCache scrollabilityCache = mScrollCache;
        float fadeHeight = scrollabilityCache.fadingEdgeLength;
        int length = () fadeHeight;

         clip the fade length if top and bottom fades overlap
         overlapping fades produce odd-looking artifacts
        if (verticalEdges && (top + length > bottom - length)) {
            length = (bottom - top) / 2 also clip horizontal fades if necessary
        if (horizontalEdges && (left + length > right - length)) {
            length = (right - left) / 2 (verticalEdges) {
            topFadeStrength = Math.max(0.0f,Math.min(1.0f;
            bottomFadeStrength = Math.max(0.0f,getBottomFadingEdgeStrength()));
            drawBottom = bottomFadeStrength * fadeHeight > 1.0f (horizontalEdges) {
            leftFadeStrength = Math.max(0.0f,getLeftFadingEdgeStrength()));
            drawLeft = leftFadeStrength * fadeHeight > 1.0f;
            rightFadeStrength = Math.max(0.0f,getRightFadingEdgeStrength()));
            drawRight = rightFadeStrength * fadeHeight > 1.0f;
        }

        saveCount = canvas.getSaveCount();

        int solidColor = getSolidColor();
        if (solidColor == 0int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;

             (drawTop) {
                canvas.saveLayer(left,top + length,flags);
            }

             (drawBottom) {
                canvas.saveLayer(left,bottom - length,1)"> (drawLeft) {
                canvas.saveLayer(left,left + length,1)"> (drawRight) {
                canvas.saveLayer(right - length,flags);
            }
        }  {
            scrollabilityCache.setFadeColor(solidColor);
        }

        dirtyOpaque) onDraw(canvas);

                dispatchDraw(canvas);

         Step 5,draw the fade effect and restore layers
        final Paint p = scrollabilityCache.paint;
        final Matrix matrix = scrollabilityCache.matrix;
        final Shader fade = scrollabilityCache.shader;

         (drawTop) {
            matrix.setScale(1,fadeHeight * topFadeStrength);
            matrix.postTranslate(left,top);
            fade.setLocalMatrix(matrix);
            p.setShader(fade);
            canvas.drawRect(left,top + length,p);
        }

         (drawBottom) {
            matrix.setScale(1,1)"> bottomFadeStrength);
            matrix.postRotate(180);
            matrix.postTranslate(left,bottom);
            fade.setLocalMatrix(matrix);
            p.setShader(fade);
            canvas.drawRect(left,bottom - (drawLeft) {
            matrix.setScale(1,1)"> leftFadeStrength);
            matrix.postRotate(-90 (drawRight) {
            matrix.setScale(1,1)"> rightFadeStrength);
            matrix.postRotate(90);
            matrix.postTranslate(right,top);
            fade.setLocalMatrix(matrix);
            p.setShader(fade);
            canvas.drawRect(right -etoCount(saveCount);

         Overlay is part of the content and draws beneath Foreground
        mOverlay.isEmpty()) {
            mOverlay.getoverlayView().dispatchDraw(canvas);
        }

                onDrawForeground(canvas);
    }

可以看到，draw过程比较复杂，但是逻辑十分清晰，而官方注释也清楚地说明了每一步的做法。我们首先来看一开始的标记位 dirtyOpaque，该标记位的作用是判断当前 View 是否是透明的，如果 View 是透明的，那么根据下面的逻辑可以看出，将不会执行一些步骤，比如绘制背景、绘制内容等。这样很容易理解，因为一个 View 既然是透明的，那就没必要绘制它了。接着是绘制流程的六个步骤，这里先小结这六个步骤分别是什么，然后再展开来讲。绘制流程的六个步骤：

1. 对 View 的背景进行绘制

2. 保存当前的图层信息(可跳过)

3. 绘制 View 的内容

4. 对 View 的子 View 进行绘制(如果有子 View )

5. 绘制 View 的褪色的边缘，类似于阴影效果(可跳过)

6. 绘制 View 的装饰（例如：滚动条）

其中第2步和第5步是可以跳过的，我们这里不做分析，我们重点来分析其它步骤。

ViewGroup子类默认情况下就是不执行 onDraw 方法的，在 ViewGroup 源码中的 initViewGroup() 方法中设置了一个标记，源码如下：

 initViewGroup() {
         ViewGroup doesn''t draw by default
        debugDraw()) {
            setFlags(WILL_NOT_DRAW,DRAW_MASK);
        }
        ......
}

看第二行注释也知道，ViewGroup 默认情况下是不会 draw 的。第四行调用 setFlags 方法设置标记 WILL_NOT_DRAW，在回到 View 中 draw 方法看第2行代码：

1   mPrivateFlags;
2  boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
3      (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);

setFlags 方法就是对 View中mPrivateFlags 值进行相应改变，我们设置标记 WILL_NOT_DRAW 那么 dirtyOpaque 得到的值就为 true，从而 if (!dirtyOpaque) 不成立，也就不会执行onDraw 方法。

     drawBackground(Canvas canvas) {
       获取背景的Drawable，没有就不需要绘制
        final Drawable background = mBackground;
        if (background == ;
        }
       确定背景Drawable边界
        setBackgroundBounds();
        ...

       如果有偏移量先偏移画布再将drawable绘制上去
        int scrollX = mScrollX;
        int scrollY = mScrollY;
        if ((scrollX | scrollY) == 0) {
            background.draw(canvas);
        }  {
            canvas.translate(scrollX,scrollY);
            此处会执行各种Drawable对应的draw方法
            background.draw(canvas);
            把画布的原点移回去，drawable在屏幕上的位置不动
            canvas.translate(-scrollX,1)">scrollY);
        }
    }

 　　 onDraw(Canvas c) {
        .onDraw(c);

        mBackgroundFallback.draw(
   onDraw(Canvas canvas) {

  }

// ViewRootImpl 类
private void performTraversals() {
     这个方法代码非常多，但是重点就是执行这三个方法
     执行测量
    performMeasure(childWidthMeasureSpec,childHeightMeasureSpec);
     执行布局（ViewGroup）中才会有
    performlayout(lp,mWidth,mHeight);
     执行绘制
    performDraw();
}

/**  
 * 三种SpecMode： 
 * 1.UNSPECIFIED 
 * 父 ViewGroup 没有对子View施加任何约束，子 view 可以是任意大小。这种情况比较少见,主要用于系统内部多次measure的情形，
 * 用到的一般都是可以滚动的容器中的子view，比如ListView、GridView、RecyclerView中某些情况下的子view就是这种模式。
 * 一般来说，我们不需要关注此模式。
 * 2.EXACTLY 
 * 该 view 必须使用父 ViewGroup 给其指定的尺寸。对应 match_parent 或者具体数值（比如30dp）
 * 3.AT_MOST 
 * 该 View 最大可以取父ViewGroup给其指定的尺寸。对应wrap_content
 *  
 * MeasureSpec使用了二进制去减少对象的分配。 
 */  
public class MeasureSpec {  
         进位大小为2的30次方(int的大小为32位，所以进位30位就是要使用int的最高位和第二高位也就是32和31位做标志位)  
        private static final int MODE_SHIFT = 30;  
 
         运算遮罩，0x3为16进制，10进制为3，二进制为11。3向左进位30，就是11 00000000000(11后跟30个0)  
         (遮罩的作用是用1标注需要的值，0标注不要的值。因为1与任何数做与运算都得任何数，0与任何数做与运算都得0）  
        int MODE_MASK  = 0x3 << MODE_SHIFT;  
 
         0向左进位30，就是00 00000000000(00后跟30个0)  
        int UNSPECIFIED = 0 << MODE_SHIFT;  
         1向左进位30，就是01 00000000000(01后跟30个0)  
        int EXACTLY     = 1 << 2向左进位30，就是10 00000000000(10后跟30个0)  
        int AT_MOST     = 2 << 
         * 根据提供的size和mode得到一个详细的测量结果 
           
         第一个return：
         measureSpec = size + mode；   (注意：二进制的加法，不是十进制的加法！)  
         这里设计的目的就是使用一个32位的二进制数，32和31位代表了mode的值，后30位代表size的值  
         例如size=100(4)，mode=AT_MOST，则measureSpec=100+10000...00=10000..00100  
         
         第二个return：
         size &; ~MODE_MASK就是取size 的后30位，mode &amp; MODE_MASK就是取mode的前两位，最后执行或运算，得出来的数字，前面2位包含代表mode，后面30位代表size
        int makeMeasureSpec(int size, int mode) {  
            if (sUsebrokenMakeMeasureSpec) {
                return size + mode;
            } else {
                return (size & ~MODE_MASK) | (mode &  MODE_MASK);
            }
        }  
 
         
         * 获得SpecMode
          mode = measureSpec &amp; MODE_MASK;  
         MODE_MASK = 11 00000000000(11后跟30个0)，原理是用MODE_MASK后30位的0替换掉measureSpec后30位中的1,再保留32和31位的mode值。  
         例如10 00..00100 & 11 00..00(11后跟30个0) = 10 00..00(AT_MOST)，这样就得到了mode的值  
        int getMode( measureSpec) {  
            return (measureSpec & MODE_MASK);  
        }  
 
         
         * 获得Specsize 
          size = measureSpec &  ~MODE_MASK;  
         原理同上，不过这次是将MODE_MASK取反，也就是变成了00 111111(00后跟30个1)，将32,31替换成0也就是去掉mode，保留后30位的size  
        int getSize(return (measureSpec &  ~MODE_MASK);  
        }  
}  

       
         * Special value for the height or width requested by a View.
         * MATCH_PARENT means that the view wants to be as big as its parent,* minus the parent''s padding,if any. Introduced in API Level 8.
         */
        public static final int MATCH_PARENT = -1;

        
         * Special value for the height or width requested by a View.
         * WRAP_CONTENT means that the view wants to be just large enough to fit
         * its own internal content,taking its own padding into account.
         int WRAP_CONTENT = -2;

Activity窗口的宽度和高度
 desiredWindowWidth;
 desiredWindowHeight;
...
用来保存窗口宽度和高度，来自于全局变量mWinFrame，这个mWinFrame保存了窗口最新尺寸
Rect frame = mWinFrame;
构造方法里mFirst赋值为true，意思是第一次执行遍历吗    
 (mFirst) {
    是否需要重绘
    mFullRedrawNeeded = true;
    是否需要重新确定Layout
    mLayoutRequested = ;
    
    // 这里又包含两种情况：是否包括状态栏
    
    判断要绘制的窗口是否包含状态栏，有就去掉，然后确定要绘制的Decorview的高度和宽度
     (shouldUsedisplaySize(lp)) {
         NOTE -- system code,won''t try to do compat mode.
        Point size = new Point();
        mdisplay.getRealSize(size);
        desiredWindowWidth = size.x;
        desiredWindowHeight = size.y;
    }  {
        宽度和高度为整个屏幕的值
        Configuration config = mContext.getResources().getConfiguration();
        desiredWindowWidth = dipToPx(config.screenWidthDp);
        desiredWindowHeight = dipToPx(config.screenHeightDp);
    }
    ...
 else{
    
        // 这是window的长和宽改变了的情况，需要对改变的进行数据记录
    
        如果不是第一次进来这个方法，它的当前宽度和高度就从之前的mWinFrame获取
        desiredWindowWidth = frame.width();
        desiredWindowHeight = frame.height();
        
         * mWidth和mHeight是由WindowManagerService服务计算出的窗口大小，
         * 如果这次测量的窗口大小与这两个值不同，说明WMS单方面改变了窗口的尺寸
         if (desiredWindowWidth != mWidth || desiredWindowHeight != mHeight) {
            if (DEBUG_ORIENTATION) Log.v(mTag,"View " + host + " resized to: " + frame);
            需要进行完整的重绘以适应新的窗口尺寸
            mFullRedrawNeeded = ;
            需要对控件树进行重新布局
            mLayoutRequested = window窗口大小改变
            windowSizeMayChange = ;
        }
 }
    ...
    // 进行预测量
     (layoutRequested){
        ...
         (mFirst) {
             视图窗口当前是否处于触摸模式。
            mAttachInfo.mInTouchMode = !mAddedTouchMode;
            确保这个Window的触摸模式已经被设置
            ensuretouchModeLocally(mAddedTouchMode);
        }  {
            六个if语句，判断insects值和上一次比有什么变化，不同的话就改变insetsChanged
            insects值包括了一些屏幕需要预留的区域、记录一些被遮挡的区域等信息
            if (!mPendingOverscanInsets.equals(mAttachInfo.mOverscanInsets)) {
                    insetsChanged = ;
            }
            ...
            
          //  这里有一种情况，我们在写dialog时，会手动添加布局，当设定宽高为Wrap_content时，会把屏幕的宽高进行赋值，给出尽量长的宽度
            
            
             * 如果当前窗口的根布局的width或height被指定为 WRAP_CONTENT 时，
             * 比如Dialog，那我们还是给它尽量大的长宽，这里是将屏幕长宽赋值给它
             */
            if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT
                    || lp.height == ViewGroup.LayoutParams.WRAP_CONTENT) {
                windowSizeMayChange = ;
                判断要绘制的窗口是否包含状态栏，有就去掉，然后确定要绘制的Decorview的高度和宽度
                 (shouldUsedisplaySize(lp)) {
                     Point();
                    mdisplay.getRealSize(size);
                    desiredWindowWidth = size.x;
                    desiredWindowHeight = size.y;
                }  {
                    Configuration config = res.getConfiguration();
                    desiredWindowWidth = dipToPx(config.screenWidthDp);
                    desiredWindowHeight = dipToPx(config.screenHeightDp);
                }
            }
        }
    }
}

  Ask host how big it wants to be
  windowSizeMayChange |= measureHierarchy(host,lp,res,desiredWindowWidth,desiredWindowHeight); 

    boolean measureHierarchy(final View host,final WindowManager.LayoutParams lp,final Resources res,1)">int desiredWindowWidth,1)"> desiredWindowHeight) {
         childWidthMeasureSpec;
         childHeightMeasureSpec;
        boolean windowSizeMayChange = false;boolean goodMeasure = ;
　　　　　// 说明是 dialog
         ViewGroup.LayoutParams.WRAP_CONTENT) {
             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.
            final displayMetrics packageMetrics = res.getdisplayMetrics();
            res.getValue(com.android.internal.R.dimen.config_prefDialogWidth,mTmpValue,1)">);
            int baseSize = 0　　　　　　　// 获取一个基本的尺寸 
            if (mTmpValue.type == TypedValue.TYPE_DIMENSION) {
                baseSize = ()mTmpValue.getDimension(packageMetrics);
            }
            if (DEBUG_DIALOG) Log.v(mTag,"Window " + mView + ": baseSize=" + baseSize
                    + ",desiredWindowWidth=" + desiredWindowWidth);
　　　　　　　// 如果大于基本尺寸
            if (baseSize != 0 && desiredWindowWidth > baseSize) {
                childWidthMeasureSpec = getRootMeasureSpec(baseSize,lp.width);
                childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight,lp.height);
                performMeasure(childWidthMeasureSpec,childHeightMeasureSpec);
                 host.getMeasuredHeight()
                        + ") from width spec: " + MeasureSpec.toString(childWidthMeasureSpec)
                        + " and height spec: " + MeasureSpec.toString(childHeightMeasureSpec));
　　　　　　　　　　// 判断测量是否准确
                if ((host.getMeasuredWidthAndState()&View.MEASURED_STATE_TOO_SMALL) == 0) {
                    goodMeasure = ;
                }  {
                     Didn''t fit in that size... try expanding a bit.
                    baseSize = (baseSize+desiredWindowWidth)/2;
                     baseSize);
                    childWidthMeasureSpec =                    performMeasure(childWidthMeasureSpec,childHeightMeasureSpec);
                    );
                    ) {
                        );
                        goodMeasure = ;
                    }
                }
            }
        }
　　　　　// 这里就是一般 DecorView 会走的逻辑
        goodMeasure) {
            childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth,lp.width);
            childHeightMeasureSpec =            performMeasure(childWidthMeasureSpec,childHeightMeasureSpec);
　　　　　　　// 与之前的尺寸进行对比，看看是否相等，不想等，说明尺寸可能发生了变化
            if (mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight()) {
                windowSizeMayChange = ;
            }
        }
      return windowSizeMayChange;
    }

    int getRootMeasureSpec(int windowSize,1)"> rootDimension) {
         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;
         ViewGroup.LayoutParams.WRAP_CONTENT:
             Window can resize. Set max size for root view.
            measureSpec =default:
             Window wants to be an exact size. Force root view to be that size.
            measureSpec = MeasureSpec.makeMeasureSpec(rootDimension,1)">;
        }
        return measureSpec;
    }

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

 * 调用这个方法来算出一个View应该为多大。参数为父View对其宽高的约束信息。
 * 实际的测量工作在onMeasure()方法中进行
 */
void measure(int widthMeasureSpec,1)"> heightMeasureSpec) {
  ......

  // Suppress sign extension for the low bytes
   long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;
   if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);

 若mPrivateFlags中包含PFLAG_FORCE_LAYOUT标记，则强制重新布局
   比如调用View.requestLayout()会在mPrivateFlags中加入此标记
  boolean forceLayout = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;
  boolean specChanged = widthMeasureSpec != mOldWidthMeasureSpec
      || heightMeasureSpec != mOldHeightMeasureSpec;
  boolean isspecExactly = MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY
      && MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY;
  boolean matchesSpecsize = getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec)
      && getMeasuredHeight() == MeasureSpec.getSize(heightMeasureSpec);
  boolean needsLayout = specChanged
      && (sAlwaysRemeasureExactly || !isspecExactly || !matchesSpecsize);

   需要重新布局  
  if (forceLayout || needsLayout) {

    // first clears the measured dimension flag 标记为未测量状态
    mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
    // 对阿拉伯语、希伯来语等从右到左书写、布局的语言进行特殊处理
    resolveRtlPropertiesIfNeeded();

 先尝试从缓从中获取，若forceLayout为true或是缓存中不存在或是
     忽略缓存，则调用onMeasure()重新进行测量工作
    int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);
    if (cacheIndex < 0 || sIgnoreMeasureCache) {
       measure ourselves,this should set the measured dimension flag back
      onMeasure(widthMeasureSpec,heightMeasureSpec);
      . . .
    }  {
       缓存命中，直接从缓存中取值即可，不必再测量
      long value = mMeasureCache.valueAt(cacheIndex);
       Casting a long to int drops the high 32 bits,no mask needed
      setMeasuredDimensionRaw((int) (value >> 32),() value);
      mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;

    }

　　 // 如果自定义的View重写了onMeasure方法，但是没有调用setMeasuredDimension()方法就会在这里抛出错误；

　　 // flag not set,setMeasuredDimension() was not invoked,we raise
　　 // an exception to warn the developer
　　 if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
    　　 throw new IllegalStateException("View with id " + getId() + ": "
            　　+ getClass().getName() + "#onMeasure() did not set the"
            　　+ " measured dimension by calling"
            　　+ " setMeasuredDimension()");
　　 } 

 　　 mPrivateFlags |= PFLAG_LAYOUT_required;

  }
  mOldWidthMeasureSpec = widthMeasureSpec;
  mOldHeightMeasureSpec = heightMeasureSpec;
 // 保存到缓存中
  mMeasureCache.put(key,((long) mMeasuredWidth) << 32 |
      (long) mMeasuredHeight & 0xffffffffL);  suppress sign extension
}

 protected void onMeasure( heightMeasureSpec) {
　　　　  // 获取子view的个数
        int count = getChildCount();

        boolean measureMatchParentChildren =
                MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
                MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
        mMatchParentChildren.clear();

        int maxHeight = 0int maxWidth = 0int childState = 0for (int i = 0; i < count; i++final View child = getChildAt(i);
　　　　　　　// mMeasureAllChildren 默认为FALSE，表示是否全部子 view 都要测量，子view不为GONE就要测量
            if (mMeasureAllChildren || child.getVisibility() != GONE) {
                // 测量子view
                measureChildWithMargins(child,widthMeasureSpec,0,heightMeasureSpec,0);
                // 获取子view的布局参数
                final LayoutParams lp = (LayoutParams) child.getLayoutParams();
                // 记录子view的最大宽度和高度
                maxWidth = Math.max(maxWidth,child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
                maxHeight = Math.max(maxHeight,child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
                childState = combineMeasuredStates(childState,child.getMeasuredState());
                // 记录所有跟父布局有着相同宽或高的子view
                 (measureMatchParentChildren) {
                    if (lp.width == LayoutParams.MATCH_PARENT ||
                            lp.height == LayoutParams.MATCH_PARENT) {
                        mMatchParentChildren.add(child);
                    }
                }
            }
        }

         Account for padding too  子view的最大宽高计算出来后，还要加上父View自身的padding
        maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
        maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();

         Check against our minimum height and width
        maxHeight = Check against our foreground''s minimum height and width
        final Drawable drawable = getForeground();
        if (drawable != ) {
            maxHeight =　　　　　// 确定父 view 的宽高
        setMeasuredDimension(resolveSizeAndState(maxWidth,childState),resolveSizeAndState(maxHeight,childState << MEASURED_HEIGHT_STATE_SHIFT));

        count = mMatchParentChildren.size();
        if (count > 1) {
                 mMatchParentChildren.get(i);
                final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

                 childWidthMeasureSpec;
　　　　　　　　　　// 如果子view的宽是MATCH_PARENT,那么宽度 = 父view的宽 - 父Padding - 子Margin
                 LayoutParams.MATCH_PARENT) {
                    int width = Math.max(0,getMeasuredWidth()
                            - getPaddingLeftWithForeground() - getPaddingRightWithForeground()
                            - lp.leftMargin - lp.rightMargin);
                    childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
                            width,MeasureSpec.EXACTLY);
                }  {
                    childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
                            lp.leftMargin + lp.rightMargin,lp.width);
                }

                 childHeightMeasureSpec;
　　　　　　　　　　// 同理
                if (lp.height ==int height = Math.max(0 getPaddingBottomWithForeground()
                            - lp.topMargin - lp.bottomMargin);
                    childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                            height,1)"> {
                    childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
                            lp.topMargin + lp.bottomMargin,lp.height);
                }

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

     * Ask one of the children of this view to measure itself,taking into
     * account both the MeasureSpec requirements for this view and its padding
     * and margins. The child must have MarginLayoutParams The heavy lifting is
     * done in getChildMeasureSpec.
     *
     * @param child The child to measure
     *  parentWidthMeasureSpec The width requirements for this view
     *  widthUsed Extra space that has been used up by the parent
     *        horizontally (possibly by other children of the parent)
     *  parentHeightMeasureSpec The height requirements for this view
     *  heightUsed Extra space that has been used up by the parent
     *        vertically (possibly by other children of the parent)
     */
     measureChildWithMargins(View child,1)">int parentWidthMeasureSpec,1)"> widthUsed,1)">int parentHeightMeasureSpec,1)"> heightUsed) {
         (MarginLayoutParams) child.getLayoutParams();

        int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
                        +int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
                        + heightUsed,lp.height);

        child.measure(childWidthMeasureSpec,childHeightMeasureSpec);
    }

 int getChildMeasureSpec(int spec,1)">int padding,1)"> childDimension) {
        // 父 view 的 mode 和 size
        int specMode = MeasureSpec.getMode(spec);
        int specsize = MeasureSpec.getSize(spec);
　　　　　// 去掉 padding
        int size = Math.max(0,specsize - padding);

        int resultSize = 0int resultMode = 0 (specMode) {
         Parent has imposed an exact size on us
         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 = LayoutParams.WRAP_CONTENT) {
                 Child wants to determine its own size. It can''t be
                 bigger than us.
                resultSize = MeasureSpec.AT_MOST;
            }
             Parent has imposed a maximum size on us
         MeasureSpec.AT_MOST:
             Child wants a specific size... so be it
                resultSize = Child wants to be our size,but our size is not fixed.
                 Constrain child to not be bigger than us.
                resultSize = MeasureSpec.AT_MOST;
            }  Parent asked to see how big we want to be
         MeasureSpec.UNSPECIFIED:
             Child wants a specific size... let him have it
                resultSize = Child wants to be our size... find out how big it should
                 be
                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                resultMode = MeasureSpec.UNSPECIFIED;
            }  Child wants to determine its own size.... find out how
                 big it should be
                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 MeasureSpec.UNSPECIFIED;
            }
            noinspection ResourceType
         MeasureSpec.makeMeasureSpec(resultSize,resultMode);
    }

 protected int heightMeasureSpec) {
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(),widthMeasureSpec),getDefaultSize(getSuggestedMinimumHeight(),heightMeasureSpec));
    }

  getSuggestedMinimumWidth() {
        return (mBackground == null) ? mMinWidth : max(mMinWidth,mBackground.getMinimumWidth());
    }

 R.styleable.View_minWidth:
     mMinWidth = a.getDimensionPixelSize(attr,1)">);
     break;

•  第二种是在调用 View 的 setMinimumWidth 方法为 mMinWidth 赋值

void setMinimumWidth( minWidth) {
    mMinWidth = minWidth;
    requestLayout();
}

    int getDefaultSize(int size,1)"> measureSpec) {
        int result = size;
         MeasureSpec.getMode(measureSpec);
         MeasureSpec.getSize(measureSpec);

         MeasureSpec.UNSPECIFIED:
            result = size;
             MeasureSpec.AT_MOST:
         MeasureSpec.EXACTLY:
            result = specsize;
             result;
    }

protected void onMeasure(int widthMeasureSpec,1)"> heightMeasureSpec){
  super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  取得父ViewGroup指定的宽高测量模式和尺寸
  int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
  int widthSpecsize = MeasureSpec.getSize(widthMeasureSpec);
  int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
  int heightSpecsize = MeasureSpec.getSize(heightMeasureSpec);
  if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
    如果宽高都是AT_MOST的话，即都是wrap_content布局模式，就用View自己想要的宽高值
        setMeasuredDimension(mWidth, mHeight);
  }else if (widthSpecMode ==如果只有宽度都是AT_MOST的话，即只有宽度是wrap_content布局模式，宽度就用View自己想要的宽度值，高度就用父ViewGroup指定的高度值
pecsize);
  }if (heightSpecMode ==如果只有高度都是AT_MOST的话，即只有高度是wrap_content布局模式，高度就用View自己想要的宽度值，宽度就用父ViewGroup指定的高度值
        setMeasuredDimension(widthSpecsize, mHeight);
  }
}

    // View    
    protected void setMeasuredDimension(int measuredWidth,1)"> 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);
    }

    void setMeasuredDimensionRaw( measuredHeight) {
        mMeasuredWidth = measuredWidth;
        mMeasuredHeight = measuredHeight;
        mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
    }

int combineMeasuredStates(int curState,1)"> newState) {
        return curState | newState;
    }

 
     * Return only the state bits of {@link #getMeasuredWidthAndState()}
     * and { #getMeasuredHeightAndState()},combined into one integer.
     * The width component is in the regular bits { #MEASURED_STATE_MASK}
     * and the height component is at the shifted bits
     * { #MEASURED_HEIGHT_STATE_SHIFT}>>{ #MEASURED_STATE_MASK}.
      getMeasuredState() {
        return (mMeasuredWidth&MEASURED_STATE_MASK)
                | ((mMeasuredHeight>>MEASURED_HEIGHT_STATE_SHIFT)
                        & (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));
    }

        // 确定父 View 的宽高
        setMeasuredDimension(resolveSizeAndState(maxWidth,1)">resolveSizeAndState(maxHeight,childState << MEASURED_HEIGHT_STATE_SHIFT));

 View 的静态方法
int resolveSizeAndState(int measureSpec,1)"> childMeasuredState) {
         MeasureSpec.getSize(measureSpec);
         result;
         (specMode) {
             MeasureSpec.AT_MOST:
                if (specsize < size) {
                    result = specsize | MEASURED_STATE_TOO_SMALL;
                }  {
                    result = size;
                }
                 MeasureSpec.EXACTLY:
                result = specsize;
                :
                result = size;
        }
        return result | (childMeasuredState & MEASURED_STATE_MASK);
    }