protected void measureChild(View child, int parentWidthMeasureSpec,
        int parentHeightMeasureSpec) {
        //拿到子元素的 LayoutParams 參數(shù)
    final LayoutParams lp = child.getLayoutParams();

    //創(chuàng)建子元素的 measureSpec 
    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
            mPaddingLeft + mPaddingRight, lp.width);
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
            mPaddingTop + mPaddingBottom, lp.height);

    //將測量傳遞到子元素
    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
    //解析父容器的 measureSpec ，解析出模式和尺寸
    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) {
    // 父容器是精確模式的情況，設(shè)置了精確尺寸。
    case MeasureSpec.EXACTLY:
        if (childDimension >= 0) {
        //子元素本身是設(shè)置的精確尺寸，就是EXACTLY 模式，尺寸就是設(shè)置的尺寸。
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
            // 子元素設(shè)置的 match_content 充滿入容器，就把尺寸設(shè)置為入容器的尺寸，模式設(shè)置為EXACTLY
            resultSize = size;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // 包裹模式下，子元素可以自己設(shè)置尺寸，但是不能超過夫容器的尺寸。模式為AT_MOST，尺寸為父容器的尺寸。
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        }
        break;

    //父容器是最大模式
    case MeasureSpec.AT_MOST:
        if (childDimension >= 0) {
            // 設(shè)置為子元素的尺寸，為精確模式
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
            // 子元素想充滿父容器，應(yīng)該設(shè)置為父容器的尺寸，但是父容器是最大模式，沒有精確尺寸。
            // 所以將子元素設(shè)置為最大模式，不能超過父容器目前的尺寸。
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // 子元素沒有精確尺寸，想包裹自身，這種模式下，設(shè)置為最大模式，不超過父容器尺寸就好。
            // bigger than us.
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        }
        break;

    // 父容器沒有限制，子元素自己發(fā)揮
    case MeasureSpec.UNSPECIFIED:
        if (childDimension >= 0) {
            //子元素自己有設(shè)置的值，就好實用自己的值，設(shè)置為精確模式
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
            // 子元素想充滿父容器，那就找到父容器的尺寸，但父容器的尺寸未知，還是要自己發(fā)揮 UNSPECIFIED。
            resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
            resultMode = MeasureSpec.UNSPECIFIED;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // 只元素是包裹自身，父容器無法給出參考，所以讓子元素自己去隨意發(fā)揮，仍然是UNSPECIFIED
            resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
            resultMode = MeasureSpec.UNSPECIFIED;
        }
        break;
    }
    //使用打包方法，將子元素的模式和尺寸打包并返回
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

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

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:
        //默認 精確模式和最大模式下都是使用后邊的 specSize ,這會導致我們設(shè)置的 wrap_content 無效，始終是充滿父容器。
        result = specSize;
        break;
    }
    return result;
}

protected int getSuggestedMinimumHeight() {
    return (mBackground == null) ? mMinHeight : max(mMinHeight, mBackground.getMinimumHeight());

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

    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 見上面 MeasureSpec 里的代碼。
                measureChild(child, widthMeasureSpec, heightMeasureSpec);
            }
        }
    }