LinearLayout属性用法和源码分析

转载自：http://www.jianshu.com/p/650c3fd7e6ab

 

一、 LinearLayout的属性和用法

LinearLayout对于开发来说，是使用最常用的布局控件之一，但是对于LinearLayout我们究竟有多了解呢？最近在看LinearLayout的源码，看源码过程中发现其实有很多东西自己并没有使用到，对于LinearLayout的了解也是并没有那么足，那么这篇文章就对LinearLayout进行更加详细与深入的了解，从使用到源码，一一进行解析！ 一.LinearLayout属性 1)基准线对齐 xml属性 : android:baselineAligned; 设置方法 : setBaselineAligned(boolean b); 作用 : 如果该属性为false, 就会阻止该布局管理器与其子元素的基准线对齐; 要知道这个属性是干嘛的首先要知道什么是基准线，如下图 图1 基准线 1.基准点是baseline 2.ascent：是baseline之上至字符最高处的距离 3.descent：是baseline之下至字符最低处的距离 4.leading：是上一行字符的descent到下一行的ascent之间的距离,也就是相邻行间的空白距离 5.top：是指的是最高字符到baseline的值,即ascent的最大值 6.bottom：是指最低字符到baseline的值,即descent的最大值 其实基准线对于对自定义View有一定了解的小伙伴都会比较熟悉 所以设置基准线对齐有什么区别呢？ 上代码 分别设置android:baselineAligned 为true 与false 运行如图 图2 android:baselineAligned为true 图3 android:baselineAligned为false 2)基准线对齐对象 xml属性 : android:baselineAlignedChildIndex; 设置方法 : setBaselineAlignedChildIndex(int i); 作用 : 设置文字基线对齐的子控件; 基准线对其上面有介绍过，那么这个基准线对齐对象其实就是设置文字基线对齐的子控件 接下来直接上代码 三个相同的布局分别设置基准线为第一个，第二个和第三个控件 运行如图 图4 baselineAlignedChildIndex 3)设分隔条 xml属性 : android:divider="@drawable/shape"      android:showDividers="middle|beginning|end" 设置方法 : setDividerDrawable(Drawable);      setShowDividers(int showDividers) 作用 : 设置布局中两个按钮之间的分隔条; 分割线如果是图片那就直接使用图片就行，如果要使用颜色就必须使用shape来显示，直接使用颜色或Color是没有用的 使用shape的时候要注意设置size属性不设置宽高分割线就不会显示出来，如果使用line那填充颜色只能使用stroke来显示颜色 space_divider.xml 运行如下 图5 setShowDividers设置为middle 图6 setShowDividers设置为end与beginning 4)权重最小尺寸 xml属性 : android:measureWithLargestChild; 设置方法 : setMeasureWithLargestChildEnable(boolean b); 作用 : 该属性为true的时候, 所有带权重的子元素都会具有最大子元素的最小尺寸; 代码如下 运行如图 图7 权重最小尺寸设置为true 可以看出设置与没有设置的区别还是很大的,当我们设置权重最小尺寸时，系统会把最大控件的最小尺寸作为其他子控件的尺寸，所以看到图中上半部分的控件的大小其实都是一样的 5)设置权重总和 xml属性 : android:weightSum; 设置方法 : setWeightSum(float weightSum); 作用 : 设置权重的总和。(默认是全部子控件权重之和); 定义weight总和的最大值。如果未指定该值，以所有子视图的layout_weight属性的累加值作为总和的最大值。 这个权重总和可能大家觉得并不是很有用，但是对于有些场景很有用，比如我们需要一个布局在总布局的3/4的位置 如下所示 图8 例子图 如果不使用权重总和这个属性的话，实现起来就只能用动态布局通过屏幕的尺寸来重新布局子View了 而使用权重总和就可以很优雅的解决这个问题了 代码如下 这里其实就是设置父Layout的权重总和为1，子layout的权重为3/4 运行如下 图9 权重总和 6)对齐方式(控制内部子元素) xml属性 : android:gravity; 设置方法 : setGravity(int); 作用 : 设置布局管理器内组件(子元素)的对齐方式, 支持的属性 : top, bottom, left, right, center_vertical(垂直方向居中), center_horizontal(水平方向居中), fill_vertical(垂直方向拉伸), fill_horizontal(水平方向拉伸), center, fill, clip_vertical, clip_horizontal; 可以同时指定多种对齐方式 : 如 left|center_vertical 左侧垂直居中; 关于对齐方式就不做详细的介绍了，因为我相信大家都很了解

作者：前世小书童
链接：http://www.jianshu.com/p/650c3fd7e6ab
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

 

 

二、LInearLayout源码分析

对于一个View(ViewGroup)来说实现无非于三个流程，onMeasure(测量)，onLayout(定位)，onDraw(绘制)，接下来就对这三个部分一一分析

但是首先还是对LinearLayout变量进行介绍

1.LinearLayout变量

其实LinearLayout变量与上篇属性篇中关联比较大,这里就直接上代码和注释了

//基准线对齐变量，默认为true
private boolean mBaselineAligned = true;
//基准线对齐的对象index
private int mBaselineAlignedChildIndex = -1;
//baseline额外的偏移量
private int mBaselineChildTop = 0;
//linearlayout的排列方式
private int mOrientation;
//linearlayout的对齐方式
private int mGravity = Gravity.START | Gravity.TOP;
//测量的时候通过累加得到所有子控件的高度和（Vertical）或者宽度和（Horizontal） ;
private int mTotalLength;
//权重总和变量
private float mWeightSum;
//权重最小尺寸的对象
private boolean mUseLargestChild;

//基准线对其相关
private int[] mMaxAscent;
private int[] mMaxDescent;

//分隔条相关
private Drawable mDivider;
private int mDividerWidth;
private int mDividerHeight;
private int mShowDividers;
private int mDividerPadding;

2.measure流程

 @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mOrientation == VERTICAL) {
            measureVertical(widthMeasureSpec, heightMeasureSpec);
        } else {
            measureHorizontal(widthMeasureSpec, heightMeasureSpec);
        }
    }

当我们设置不同的orientation就会进入不同的测量流程，我们以其中的一个测量流程为例子进行说明，那么另外的测量流程也就不难理解了

我们以measureVertical为例来分析

由于代码相对比较长，所以根据不同的功能分段分析

(1).变量

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {

        //mTotalLength为 LinearLayout的成员变量，在这里指的是所有子控件的高度和
        mTotalLength = 0;

        //所有子控件中宽度最大的值
        int maxWidth = 0;

        //子控件的测量状态
        int childState = 0;

        //子控件中layout_weight<=0的View最大高度
        int alternativeMaxWidth = 0;

        //子控件中layout_weight>0的View最大高度
        int weightedMaxWidth = 0;

        //子控件是否全是match_parent
        boolean allFillParent = true;

        //子控件所有layout_weight的和
        float totalWeight = 0;

        //获取子控件数量
        final int count = getVirtualChildCount();

        //获取测量模式
        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        //当子控件为match_parent的时候，该值为ture
        boolean matchWidth = false;

        boolean skippedMeasure = false;

        //基准线对齐的对象index
        final int baselineChildIndex = mBaselineAlignedChildIndex;
        //权重最小尺寸的对象
        final boolean useLargestChild = mUseLargestChild;
        //子View中最高高度
        int largestChildHeight = Integer.MIN_VALUE;
}

(2).测量Part1

其实这段代码前面自带的注释就很好说明接下来这一段代码做的事情了，

See how tall everyone is. Also remember max width.

就不对这句话进行翻译了，接下来看这一段代码做了什么事情

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
    //...接上面的变量
    for (int i = 0; i < count; ++i) {
        final View child = getVirtualChildAt(i);

        //这个不解释了，measureNullChild获得的结果是0
        if (child == null) {
            mTotalLength += measureNullChild(i);
            continue;
        }

        //这个也不解释了
        if (child.getVisibility() == View.GONE) {
           i += getChildrenSkipCount(child, i);
           continue;
        }

        // 根据showDivider的值（before/middle/end）来决定遍历到当前子控件时，高度是否需要加上divider的高度
        // 比如showDivider为before，那么只会在第0个子控件测量时加上divider高度，其余情况下都不加
        //这里测量不包括end的情况
        if (hasDividerBeforeChildAt(i)) {
            mTotalLength += mDividerHeight;
        }

        LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();

        //根据子控件的权重得到总权重
        totalWeight += lp.weight;

         // 测量模式有三种：
         // * UNSPECIFIED：父控件对子控件无约束
         // * Exactly：父控件对子控件强约束，子控件永远在父控件边界内，越界则裁剪。如果要记忆的话，可以记忆为有对应的具体数值或者是Match_parent
         // * AT_Most：子控件为wrap_content的时候，测量值为AT_MOST。

        if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
            //父控件高度为match_parent且子控件高度为0，weight>0情况下
            // 测量到这里的时候，会给个标志位，稍后再处理。此时会计算总高度
            final int totalLength = mTotalLength;
            mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
            skippedMeasure = true;
        } else {

            int oldHeight = Integer.MIN_VALUE;

            if (lp.height == 0 && lp.weight > 0) {
                //子控件高度为0并且weight>0,并且父控件是wrap_content，或者mode为UNSPECIFIED
                //这时候父控件的高度是wrap_content，所以随着子控件的高度进行变化的
                //顾强制将子控件高度设置为wrap_content，防止子控件高度为0
                oldHeight = 0;
                lp.height = LayoutParams.WRAP_CONTENT;
            }

            //方法名可知是对子控件进行测量
            measureChildBeforeLayout(
                   child, i, widthMeasureSpec, 0, heightMeasureSpec,
                   totalWeight == 0 ? mTotalLength : 0);

            if (oldHeight != Integer.MIN_VALUE) {
               lp.height = oldHeight;
            }

            final int childHeight = child.getMeasuredHeight();
            final int totalLength = mTotalLength;

            //比较child测量前后的总高度，取大值
            mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                   lp.bottomMargin + getNextLocationOffset(child));

            //当设置权重最小尺寸的对象为true，获取子View中最高高度
            if (useLargestChild) {
                largestChildHeight = Math.max(childHeight, largestChildHeight);
            }
        }

        //计算baseline额外的偏移量，后面会用到
        if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {
           mBaselineChildTop = mTotalLength;
        }

        //当设置的基准线对齐的对象index 大于 子对象的Index 并且 weight > 0 会报异常
        if (i < baselineChildIndex && lp.weight > 0) {
            throw new RuntimeException("A child of LinearLayout with index "
                    + "less than mBaselineAlignedChildIndex has weight > 0, which "
                    + "won't work.  Either remove the weight, or don't set "
                    + "mBaselineAlignedChildIndex.");
        }

        // 当父类（LinearLayout）不是match_parent或者精确值的时候，但子控件却是一个match_parent
        // 那么matchWidthLocally和matchWidth置为true
        // 意味着这个控件将会占据父类（水平方向）的所有空间
        boolean matchWidthLocally = false;
        if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {
            matchWidth = true;
            matchWidthLocally = true;
        }

        final int margin = lp.leftMargin + lp.rightMargin;
        final int measuredWidth = child.getMeasuredWidth() + margin;
        //后面几个就是给变量赋值
        maxWidth = Math.max(maxWidth, measuredWidth);
        childState = combineMeasuredStates(childState, child.getMeasuredState());

        allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;
        if (lp.weight > 0) {
            weightedMaxWidth = Math.max(weightedMaxWidth,
                    matchWidthLocally ? margin : measuredWidth);
        } else {
            alternativeMaxWidth = Math.max(alternativeMaxWidth,
                    matchWidthLocally ? margin : measuredWidth);
        }
        i += getChildrenSkipCount(child, i);
    }
}

(3).测量Part2

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
    //...接上面的方法
    //判断showDivider值是否为end，是的情况下加上divider的高度
    if (mTotalLength > 0 && hasDividerBeforeChildAt(count)) {
        mTotalLength += mDividerHeight;
    }

    if (useLargestChild &&
            (heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED)) {

        //当设置权重最小尺寸的对象为true
        //并且LinearLayout是wrap_content，或者mode为UNSPECIFIED
        //计算新的mTotalLength，因为这时候所有子控件都是用最大控件的最小值
        mTotalLength = 0;

        for (int i = 0; i < count; ++i) {
            final View child = getVirtualChildAt(i);

            if (child == null) {
                mTotalLength += measureNullChild(i);
                continue;
            }

            if (child.getVisibility() == GONE) {
                i += getChildrenSkipCount(child, i);
                continue;
            }

            final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)
                    child.getLayoutParams();
            final int totalLength = mTotalLength;
            mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +
                    lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
        }
    }

    //下面是计算屏幕除去所有子控件所占高度剩余的高度
    //为了定义权重的子控件计算高度
    mTotalLength += mPaddingTop + mPaddingBottom;
    int heightSize = mTotalLength;
    heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
    int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
    heightSize = heightSizeAndState & MEASURED_SIZE_MASK;
    int delta = heightSize - mTotalLength;
}

(3).测量Part3

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
    //...接上面的方法
     if (skippedMeasure || delta != 0 && totalWeight > 0.0f) {
     //这里skippedMeasure是接的上面测量Part1，当父控件为match_parent,子控件height =0 ,weight>0的情况下skippedMeasure为true
        //这里获取总权重，当我们设置了总权重则用我们设置的权重值，如果没有设置，则用子控件权重相加的和
        float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;

        mTotalLength = 0;

        for (int i = 0; i < count; ++i) {
          //遍历子View，根据权重对子View进行测量
            final View child = getVirtualChildAt(i);

            if (child.getVisibility() == View.GONE) {
                continue;
            }

            LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();

            float childExtra = lp.weight;
            if (childExtra > 0) {
             //当子控件的weight大于0时
                int share = (int) (childExtra * delta / weightSum);
                weightSum -= childExtra;
                delta -= share;

                final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                        mPaddingLeft + mPaddingRight +
                                lp.leftMargin + lp.rightMargin, lp.width);

                if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {
                    int childHeight = child.getMeasuredHeight() + share;
                    if (childHeight < 0) {
                        childHeight = 0;
                    }
                    //定义权重子控件重新测量，这时候childWidth是子控件本身的高度加上通过权重计算的额外高度
                    child.measure(childWidthMeasureSpec,
                            MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));
                } else {
                //没有定义权重子控件重新测量，当额外高度大于0，则以这个额外高度为子控件的高度
                    child.measure(childWidthMeasureSpec,
                            MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,
                                    MeasureSpec.EXACTLY));
                }

                childState = combineMeasuredStates(childState, child.getMeasuredState()
                        & (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));
            }

            final int margin =  lp.leftMargin + lp.rightMargin;
            final int measuredWidth = child.getMeasuredWidth() + margin;
            maxWidth = Math.max(maxWidth, measuredWidth);

            boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&
                    lp.width == LayoutParams.MATCH_PARENT;

            alternativeMaxWidth = Math.max(alternativeMaxWidth,
                    matchWidthLocally ? margin : measuredWidth);

            allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;

            final int totalLength = mTotalLength;
            mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +
                    lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
        }

        mTotalLength += mPaddingTop + mPaddingBottom;
    } else {
        alternativeMaxWidth = Math.max(alternativeMaxWidth,
                                       weightedMaxWidth);

       //当设置了权重最小尺寸
        if (useLargestChild && heightMode != MeasureSpec.EXACTLY) {
            for (int i = 0; i < count; i++) {
                final View child = getVirtualChildAt(i);

                if (child == null || child.getVisibility() == View.GONE) {
                    continue;
                }

                final LinearLayout.LayoutParams lp =
                        (LinearLayout.LayoutParams) child.getLayoutParams();

                float childExtra = lp.weight;
                //子控件设置权重后，就会以最大子元素的最小尺寸作为高度
                if (childExtra > 0) {
                    child.measure(
                            MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(),
                                    MeasureSpec.EXACTLY),
                            MeasureSpec.makeMeasureSpec(largestChildHeight,
                                    MeasureSpec.EXACTLY));
                }
            }
        }
    }

    if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {
        maxWidth = alternativeMaxWidth;
    }

    maxWidth += mPaddingLeft + mPaddingRight;

    maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

    setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
            heightSizeAndState);

    if (matchWidth) {
        forceUniformWidth(count, heightMeasureSpec);
    }
}

到这里测量Vertical就结束了，接下来介绍下Layout的过程

2.layout流程

与measure一样layout同样是分两个流程

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

同样我们取layoutVertical来进行分析，layoutVertical相对代码不是很多，就不拆分分析了

  void layoutVertical(int left, int top, int right, int bottom) {
        final int paddingLeft = mPaddingLeft;

        int childTop;
        int childLeft;

        final int width = right - left;
        int childRight = width - mPaddingRight;

        //子控件可用的空间
        int childSpace = width - paddingLeft - mPaddingRight;

        final int count = getVirtualChildCount();

        final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
        final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;

        //根据LinearLayout的对其方式，设置第一个子控件的Top值
        switch (majorGravity) {
           case Gravity.BOTTOM:
               childTop = mPaddingTop + bottom - top - mTotalLength;
               break;

           case Gravity.CENTER_VERTICAL:
               childTop = mPaddingTop + (bottom - top - mTotalLength) / 2;
               break;

           case Gravity.TOP:
           default:
               childTop = mPaddingTop;
               break;
        }

        for (int i = 0; i < count; i++) {
            final View child = getVirtualChildAt(i);
            if (child == null) {
                childTop += measureNullChild(i);
            } else if (child.getVisibility() != GONE) {
                final int childWidth = child.getMeasuredWidth();
                final int childHeight = child.getMeasuredHeight();

                final LinearLayout.LayoutParams lp =
                        (LinearLayout.LayoutParams) child.getLayoutParams();

                int gravity = lp.gravity;
                if (gravity < 0) {
                    gravity = minorGravity;
                }
                final int layoutDirection = getLayoutDirection();
                final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);

                //根据子控件的对其方式设置left值
                switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                    case Gravity.CENTER_HORIZONTAL:
                        childLeft = paddingLeft + ((childSpace - childWidth) / 2)
                                + lp.leftMargin - lp.rightMargin;
                        break;

                    case Gravity.RIGHT:
                        childLeft = childRight - childWidth - lp.rightMargin;
                        break;

                    case Gravity.LEFT:
                    default:
                        childLeft = paddingLeft + lp.leftMargin;
                        break;
                }

                //当有设置分隔条，需要加上分隔条的高度
                if (hasDividerBeforeChildAt(i)) {
                    childTop += mDividerHeight;
                }

                //子控件top递增
                childTop += lp.topMargin;

                //用setChildFrame()方法设置子控件控件的在父控件上的坐标轴
                setChildFrame(child, childLeft, childTop + getLocationOffset(child),
                        childWidth, childHeight);
                childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);

                i += getChildrenSkipCount(child, i);
            }
        }
    }

3.draw流程

最后说下draw流程，draw流程相对来说没有什么内容，

protected void onDraw(Canvas canvas) {
    if (mDivider == null) {
        return;
    }

    if (mOrientation == VERTICAL) {
        drawDividersVertical(canvas);
    } else {
        drawDividersHorizontal(canvas);
    }
}

measure和layout将子控件的位置和大小确定后当有设置分隔条则分为两种流程绘制分隔条

void drawDividersVertical(Canvas canvas) {
    final int count = getVirtualChildCount();
    //当分割线位置设置begin与middle走下面流程
    for (int i = 0; i < count; i++) {
        final View child = getVirtualChildAt(i);

        if (child != null && child.getVisibility() != GONE) {
            if (hasDividerBeforeChildAt(i)) {
                final LayoutParams lp = (LayoutParams) child.getLayoutParams();
                final int top = child.getTop() - lp.topMargin - mDividerHeight;
                drawHorizontalDivider(canvas, top);
            }
        }
    }
    //当分割线位置设置end走下面流程
    if (hasDividerBeforeChildAt(count)) {
        final View child = getLastNonGoneChild();
        int bottom = 0;
        if (child == null) {
            bottom = getHeight() - getPaddingBottom() - mDividerHeight;
        } else {
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
            bottom = child.getBottom() + lp.bottomMargin;
        }
        drawHorizontalDivider(canvas, bottom);
    }
}

至此，LinearLayout的核心代码就分析完成了