自定义控件总结---onMeasure onLayout onDraw深入解析

          对于一个Android开发来说，不管你有多不喜欢自定义控件，你都得和她谈一场恋爱。所以我主动谈了这场很费脑子的恋爱，因为阅读源码的能力不好，在寻根抛底的找线索的过程中，搞得反胃，不过最后还是把来龙去脉都捋了一遍。当然今天的角不是常用且高效的组合型自定义控件，而是纯粹绘制出来的View或者重新定义规则的一个ViewGroup。

    简述1： 启动Activity的时候会创建一个PhoneWindow和DectorView，并将DectorView放进PhoneWindow中。这个DectorView（继承FrameLayout的控件View）的资源布局是根据Theme来确定的，这个布局一般是LinearLayout的上下布局，上面是一个title标题栏，下面是一个content的内容栏。我们一般在onCreate中的setContentView（resID）,就是往这个内容栏里面放布局。   

    简述2：DectorView和PhoneWindow都有了，布局也setContentView了。 那么是谁启动的测量，布局，绘制这些绘制流程的呢？     答案是ViewRootImp这个类。   还是简单的捋一捋吧：

       1.ActivityThread收到RESUME_ACTIVITY消息，执行handleResumeActivity（）方法：将DectorView添加进Window中。

      代码： wm.addView(decor, l);

       2.然后会在WindowManagerGlobal类中调用addView方法：创建ViewrootImp，并将DectorView传进去。

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

    root.setView(view, wparams, panelParentView);

      3.然后在ViewRootImp的setView中触发requestLayout（）方法，并执行scheduleTraversals（）；

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

      4.然后scheduleTraversals（）这个方法就是发送一个消息去执行一个线程，这个线程中便是真正开启执行测量，最终调用的是performTraversals方法：

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

   void doTraversal() {
       if (mTraversalScheduled) {
            mTraversalScheduled = false;
            mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

            if (mProfile) {
                Debug.startMethodTracing("ViewAncestor");
            }

            performTraversals();

            if (mProfile) {
               Debug.stopMethodTracing();
               mProfile = false;
            }
        }
    }

5.然后在这个方法里面调用测量  布局  绘制图  这些方法。performMeasure（） performLayout（） performDraw();

上面说了这么多就是为了更好的理解这个流程，而不至于一头雾水的留下为啥会调用这些方法，谁最先开启的这些方法等等有头无尾的疑问。  

      简述3：MeasureSpec是Mode和Size共同产生的一个值，32位。前两位是Mode模式，后面30位才是View实实在在的尺寸值。   一般情况下 一个View或者说ViewGroup的MeasureSpec是由父类ViewGroup和自己共同决定的。如下图：

1.  EXACTLY  ：这个模式，精确模式，就是我能确定了它的具体值了。

              a.给View 设置了具体的值，100dp   200dp  等

              b.match_parenter:填充父窗体意思。如果父窗体是EXACTLY模式，即是一个确定的，那这个View就和他爹一样大。

2. AT_MOST  ：这个模式代表最大不超过某个值的模式。wrap_content.。自适应大小，但是最大不超过他爹的最大值。

3. UNSPECIFIED： 父容器不对View有任何限制，给它想要的任何尺寸。一般用于系统内部，表示一种测量状态。

  一：测量  

      1.  ViewRootImp进行测量的初始  performTraversals（）此方法，这里面我们测量了根布局DectorView的宽和高childWidthMeasureSpec 和 childHeightMeasureSpec ，需要注意的是Dedctorview就是老祖宗，没有爹的限制，自己是啥就是啥。而实际上他的 宽高都是match_parent。所以就是EXACTLY+屏幕的尺寸。

          对应的源码是：

     int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
     int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

     2.  然后  

----->  performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
----->  mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
----->  onMeasure(widthMeasureSpec, heightMeasureSpec);

      3.  onMeasure(widthMeasureSpec, heightMeasureSpec)：首先判断这个View是否重写了onMeasure方法，如果重写了则调用重写的，否则就调用View.java 的。    这个方法View.java有，但是ViewGroup.java是没有的，因为继承他的自定义控件是一个容器，所以他的大小与子View的排列有关。因此继承ViewGroup 的自定义控件需要自己重写onMeasure来重新定义子View在其内部的排列规则。虽然View.java是有onMeasure方法，但是自己绘制的自定义View，他默认不处理padding设置的值，另外AT_MOST和MATCH_PARENT模式得到的尺寸是一样的，所以一般也是需要重写onmeasure()方法。下面我们就先看看View.java中的onMeasure()的源码      

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

=====>根据measureSpec的mode来确定view真正的size（注意看了，上面我们说的WRAP_CONTENT和MATCH_PARENT模式得到的宽高尺寸是一样的，并且这个size是父窗体去掉自身的padding值后，最大可用尺寸，所以结果都是填充父窗体，所以得重写onMeasure方法，并且处理AT_MOST的这种情况）

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

    switch (specMode) {
    case MeasureSpec.UNSPECIFIED:   //这种情况几乎不会遇到
        result = size;
        break;
    case MeasureSpec.AT_MOST:   //所以看他
    case MeasureSpec.EXACTLY:
        result = specSize;
        break;
    }
    return result;
}

=======>将这个真正的size设置进去

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

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

=====》在onLayout 中或者其他地方,我们想使用测量值的宽或者高的时候就可以调用：

   view.getMeasuredWidth()  或者 view.geMeasureHeight()获取到我们设置进去的具体的实际尺寸值。

       所以如果是绘制的自定义View,最多就是重写onMesure方法，对padding以及AT_MOST这种情况进行处理即可。 如果自定义的是ViewGroup 这种情况则需要重新写onMeasure方法，按自己的规则排列规则来设置其尺寸。

measureChild():测量的子View的宽高，是父ViewGroup去掉padding值后，给留给子View的最大可用尺寸。此时子View设置margin值会不起作用。

measureChildWithMargins():测量的子View的宽高，是父ViewGroup去掉其padding值以及子View的margin值后，给留给子View的最大可用尺寸。一般使用它，因为这样可控性会更好。

下面是ViewGroup提供的方法：

//遍历子View，并调用measureChild()方法对每个子View进行测量

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);
        }
    }
}

 //父View去掉padding 之后的可用最大size值

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);
}

//父View 去掉padding以及子View的margin之后 可用的最大size值

protected void measureChildWithMargins(View child,
        int parentWidthMeasureSpec, int widthUsed,
        int parentHeightMeasureSpec, int heightUsed) {
    final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

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

    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

  //下面这段源码 就是最上面的表格表达的内容：

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;
    }
    //noinspection ResourceType
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

所以在自定义的ViewGroup容器的时候，需要重写onMeasure()，里面实现的东西是：

    1.遍历子View-->2.子View调用measureChildWithMargins() 进行测量-->3.通过childView.getLayoutParams()获取这个子View的去除自身margin值之后的width,以及margin值--->4.然后再根据自定义容器的规则去计算宽高，并设置。

  二：Layout 这个就简单，一般就是讲按规则测量的值设置即可，另外在onLayout（）中将所有子View，按照规则进行排列设置即可。

1.performLayout-->host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());-->onLayout(changed, l, t, r, b);  规则也都是重写的就掉用重写的，没重写就调用View.java 中的，具体可以自行跟踪和measure类似。

2.如果重写，则遍历子View，获取每一个子View的宽高，margin值然后按规则进行计算，并且调用childView.layout(l,t,r,b)方法进行放置。

三：Draw也很简单：

performDraw()-->draw(fullRedrawNeeded);-->drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)--->mView.draw(canvas);--->View.java的draw（）方法。

public void draw(Canvas canvas) {
    final int privateFlags = mPrivateFlags;
    final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
            (mAttachInfo == null || !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
    int saveCount;

    if (!dirtyOpaque) {
        drawBackground(canvas);
    }

    // skip step 2 & 5 if possible (common case)
    final int viewFlags = mViewFlags;
    boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
    boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
    if (!verticalEdges && !horizontalEdges) {
        // Step 3, draw the content
        if (!dirtyOpaque) onDraw(canvas);

        // Step 4, draw the children
        dispatchDraw(canvas);

        drawAutofilledHighlight(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);

        // Step 7, draw the default focus highlight
        drawDefaultFocusHighlight(canvas);

        if (debugDraw()) {
            debugDrawFocus(canvas);
        }

        // we're done...
        return;
    }

下面我就简单的仿写一个Linearlayout：

/**
 * 设计一个Linearlayout 包括水平，竖直情况（手动修改参数可以验证水平，竖直，原理一样的）。
 */
public class MyLinearLayout extends ViewGroup {

    Context mContext;

    // 布局方向，-1 水平   -2竖直

    public static final int HORIZONTAL = 0;
    public static final int VERTICAL = 1;
    public static final int mOrientation = 0;


    //自定义View的padding值
    public int mPaddingLeft;
    public int mPaddingRight;
    public int mPaddingTop;
    public int mPaddingBottom;

    //子View的个数
    public int childCount;

    public int mTotalWidth = 0;//子View+方向  确定

    public int mTotlaHeight = 0;//子View+方向  确定


    public MyLinearLayout(Context context) {
        this(context, null);

    }

    public MyLinearLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public MyLinearLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mContext = context;


    }

    int widthMode;
    int widthSize;
    int heightMode;
    int heightSize;

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        //1.获取自定义ViewGroup的宽高的模式以及参考尺寸
        //2.然后子根据子View的模式以及尺寸，来最终确定自定义ViewGroup的尺寸
        widthMode = MeasureSpec.getMode(widthMeasureSpec);
        widthSize = MeasureSpec.getMode(widthMeasureSpec);
        heightMode = MeasureSpec.getMode(heightMeasureSpec);
        heightSize = MeasureSpec.getMode(heightMeasureSpec);

        mPaddingLeft = getPaddingLeft();
        mPaddingRight = getPaddingRight();
        mPaddingTop = getPaddingTop();
        mPaddingBottom = getPaddingBottom();

        childCount = getChildCount();
        if (mOrientation == HORIZONTAL) {
            measureHorizontal(widthMeasureSpec, heightMeasureSpec);
        } else {
            measureVertical(widthMeasureSpec, heightMeasureSpec);
        }

    }

    private void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {

        int maxWidth = 0;
        mTotlaHeight=0;

        for (int i = 0; i < childCount; i++) {
            View childView = getChildAt(i);
            if (childView.getVisibility() == GONE) {
                continue;
            }
            measureChildWithMargins(childView, widthMeasureSpec, 0, heightMeasureSpec, 0);
            MarginLayoutParams marginLayoutParams = (MarginLayoutParams) childView.getLayoutParams();
            int childWidth = childView.getMeasuredWidth();
            int childHigth = childView.getMeasuredHeight();

            //水平方向（计算每一个子View的width并取最大的）
            int cuurWeight = marginLayoutParams.leftMargin + childWidth + marginLayoutParams.rightMargin;
            maxWidth = Math.max(maxWidth, cuurWeight);

            //竖直方向计算(计算所有子View总的长度)
            mTotlaHeight = mTotlaHeight+marginLayoutParams.topMargin + childHigth +           marginLayoutParams.bottomMargin;

        }

         //计算完毕之后，再根据父类框架的Mode  来最终确定父类ViewGroup的宽高
        if (widthMode == MeasureSpec.AT_MOST) {
            //如果AT_MOST 我测量的所有子View加起来  就是父类的宽
            maxWidth =maxWidth+ mPaddingLeft + mPaddingRight;
            widthMeasureSpec = MeasureSpec.makeMeasureSpec(maxWidth, MeasureSpec.EXACTLY);
        }

        if (heightMode == MeasureSpec.AT_MOST) {
            //如果AT_MOST 我取子View中最大的高 作为父类的高
            mTotlaHeight =mTotlaHeight+ mPaddingTop + mPaddingBottom;
            heightMeasureSpec = MeasureSpec.makeMeasureSpec(mTotlaHeight, MeasureSpec.EXACTLY);
        }

        //将处理好的在size和mode设置给自定义的ViewGroup里面
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
    }


    private void measureHorizontal(int widthMeasureSpec, int heightMeasureSpec) {
        int maxHeight = 0;

        for (int i = 0; i < childCount; i++) {
            View childView = getChildAt(i);
            if (childView.getVisibility() == GONE) {
                continue;
            }
            measureChildWithMargins(childView, widthMeasureSpec, 0, heightMeasureSpec, 0);
            MarginLayoutParams marginLayoutParams = (MarginLayoutParams) childView.getLayoutParams();
            int childWidth = childView.getMeasuredWidth();
            int childHigth = childView.getMeasuredHeight();
            //水平方向计算(计算所有子View总的长度)
            mTotalWidth += marginLayoutParams.leftMargin + childWidth + marginLayoutParams.rightMargin;
            //竖直方向（计算每一个子View的height并取最大的）
            int cuurHeight = marginLayoutParams.topMargin + childHigth + marginLayoutParams.bottomMargin;
            maxHeight = Math.max(maxHeight, cuurHeight);
        }
        //计算完毕之后，再根据父类框架的Mode  来最终确定父类ViewGroup的宽高
        if (widthMode == MeasureSpec.AT_MOST) {
            //如果AT_MOST 我测量的所有子View加起来  就是父类的宽
            mTotalWidth = mTotalWidth+mPaddingLeft + mPaddingRight;
            widthMeasureSpec = MeasureSpec.makeMeasureSpec(mTotalWidth, MeasureSpec.EXACTLY);
        }
        if (heightMode == MeasureSpec.AT_MOST) {
            //如果AT_MOST 我取子View中最大的高 作为父类的高
            maxHeight =maxHeight+ mPaddingTop + mPaddingBottom;
            heightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.EXACTLY);
        }

        //将处理好的在size和mode设置给自定义的ViewGroup里面
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
    }

    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        if (mOrientation == HORIZONTAL) {
            layoutHorizontal(l, t, r, b);
        } else {
            layoutVertical(l, t, r, b);
        }
        layout(l,t,r,b);
    }

    private void layoutVertical(int l, int t, int r, int b) {
        int mTop = mPaddingTop;
        for (int i = 0; i < childCount; i++) {
            View childAtView = getChildAt(i);
            MarginLayoutParams layoutParams = (MarginLayoutParams) childAtView.getLayoutParams();
            int left = mPaddingLeft + layoutParams.leftMargin;
            mTop = mTop + layoutParams.topMargin;
            int right = left + childAtView.getMeasuredWidth();
            int bottom = mTop + childAtView.getMeasuredHeight();
            childAtView.layout(left, mTop, right, bottom);
            mTop =bottom+ layoutParams.topMargin;
        }
    }

    private void layoutHorizontal(int l, int t, int r, int b) {
        int mleft = mPaddingLeft;
        for (int i = 0; i < childCount; i++) {
            View childAtView = getChildAt(i);
            MarginLayoutParams layoutParams = (MarginLayoutParams) childAtView.getLayoutParams();
            mleft = mleft + layoutParams.leftMargin;
            int top = mPaddingTop + layoutParams.topMargin;
            int right = mleft + childAtView.getMeasuredWidth();
            int bottom = top + childAtView.getMeasuredHeight();
            childAtView.layout(mleft, top, right, bottom);
            mleft = right+layoutParams.rightMargin;
        }


    }


    /**
     * 重写获取的默认的LayoutParams，否则或出现强转异常
     *
     * @return
     */
    @Override
    public LayoutParams generateLayoutParams(AttributeSet attrs) {
        return new MyLayoutParams(getContext(), attrs);
    }

    @Override
    protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) {
        return new MyLayoutParams(lp);
    }

    @Override
    protected LayoutParams generateDefaultLayoutParams() {
        return new MyLayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
    }

    public static class MyLayoutParams extends MarginLayoutParams {

        public MyLayoutParams(Context c, AttributeSet attrs) {
            super(c, attrs);
        }

        public MyLayoutParams(int width, int height) {
            super(width, height);
        }

        public MyLayoutParams(LayoutParams lp) {
            super(lp);
        }
    }


}

总结：本篇很长，因为你涉及了一些源码。主要分成两大部分：

1.Activity的内部视图结构以及如何去触发测量，布局，绘制的。

2.具体分析测量，布局，绘制流程。

注意事项：

1.measureChild()和measureChildWithmargin()区别，以及如何使用。上面给出了解释。

2.如果使用measureChildWithmargin()需要重写getLayoutparams()，否则会类型转换异常。

3.系统默认不处理padding值，WRAP_CONTENT和MATCH_PARENET得到的结果是一样的，所以需要重写onMeasure()进行处理。

4. getMeasureWidth()或者getMeasureHeight.()  得到的尺寸是onMeasure测量尺寸。

    getWidth()和getHeight()获取的是onLayout()设置位置之后的尺寸，也就是显示在屏幕中的最终尺寸。

   getWidth=right-left;