// 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) {

  }