Android LinearLayout(7.1) 源码解析

最新推荐文章于 2024-04-22 04:54:04 发布
最新推荐文章于 2024-04-22 04:54:04 发布
阅读量321 收藏
点赞数
分类专栏： android 软件开发 文章标签： android 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenshuwan/article/details/70258789
版权

这一节，将分析LinearLayout的onMeasure和onLayout两个方法
1、onMeasure由measureVertical 和measureHorizontal两个方法组成
2、onLayout由layoutVertical 和layoutHorizontal两个方法组成
下面，只分别分析measureVertical 和onLayoutVertical这两个方法

先来看一下onMeasureVertical

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
        mTotalLength = 0;
        int maxWidth = 0;
        int childState = 0;
        int alternativeMaxWidth = 0;
        int weightedMaxWidth = 0;
        boolean allFillParent = true;
        float totalWeight = 0;

        final int count = getVirtualChildCount();

        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        boolean matchWidth = false;
        boolean skippedMeasure = false;

        final int baselineChildIndex = mBaselineAlignedChildIndex;        
        final boolean useLargestChild = mUseLargestChild;

        int largestChildHeight = Integer.MIN_VALUE;
        int consumedExcessSpace = 0;

        // See how tall everyone is. Also remember max width.
        for (int i = 0; i < count; ++i) {
            final View child = getVirtualChildAt(i);
            if (child == null) {
                mTotalLength += measureNullChild(i);
                continue;
            }

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

            if (hasDividerBeforeChildAt(i)) {
                mTotalLength += mDividerHeight;
            }

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

            totalWeight += lp.weight;

            final boolean useExcessSpace = lp.height == 0 && lp.weight > 0;
            if (heightMode == MeasureSpec.EXACTLY && useExcessSpace) {
                // Optimization: don't bother measuring children who are only
                // laid out using excess space. These views will get measured
                // later if we have space to distribute.
                final int totalLength = mTotalLength;
                mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
                skippedMeasure = true;
            } else {
                if (useExcessSpace) {
                    // The heightMode is either UNSPECIFIED or AT_MOST, and
                    // this child is only laid out using excess space. Measure
                    // using WRAP_CONTENT so that we can find out the view's
                    // optimal height. We'll restore the original height of 0
                    // after measurement.
                    lp.height = LayoutParams.WRAP_CONTENT;
                }

                // Determine how big this child would like to be. If this or
                // previous children have given a weight, then we allow it to
                // use all available space (and we will shrink things later
                // if needed).
                final int usedHeight = totalWeight == 0 ? mTotalLength : 0;
                measureChildBeforeLayout(child, i, widthMeasureSpec, 0,
                        heightMeasureSpec, usedHeight);

                final int childHeight = child.getMeasuredHeight();
                if (useExcessSpace) {
                    // Restore the original height and record how much space
                    // we've allocated to excess-only children so that we can
                    // match the behavior of EXACTLY measurement.
                    lp.height = 0;
                    consumedExcessSpace += childHeight;
                }

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

                if (useLargestChild) {
                    largestChildHeight = Math.max(childHeight, largestChildHeight);
                }
            }

            /**
             * If applicable, compute the additional offset to the child's baseline
             * we'll need later when asked {@link #getBaseline}.
             */
            if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {
               mBaselineChildTop = mTotalLength;
            }

            // if we are trying to use a child index for our baseline, the above
            // book keeping only works if there are no children above it with
            // weight.  fail fast to aid the developer.
            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.");
            }

            boolean matchWidthLocally = false;
            if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {
                // The width of the linear layout will scale, and at least one
                // child said it wanted to match our width. Set a flag
                // indicating that we need to remeasure at least that view when
                // we know our width.
                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) {
                /*
                 * Widths of weighted Views are bogus if we end up
                 * remeasuring, so keep them separate.
                 */
                weightedMaxWidth = Math.max(weightedMaxWidth,
                        matchWidthLocally ? margin : measuredWidth);
            } else {
                alternativeMaxWidth = Math.max(alternativeMaxWidth,
                        matchWidthLocally ? margin : measuredWidth);
            }

            i += getChildrenSkipCount(child, i);
        }

        if (mTotalLength > 0 && hasDividerBeforeChildAt(count)) {
            mTotalLength += mDividerHeight;
        }

        if (useLargestChild &&
                (heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED)) {
            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();
                // Account for negative margins
                final int totalLength = mTotalLength;
                mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +
                        lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
            }
        }

        // Add in our padding
        mTotalLength += mPaddingTop + mPaddingBottom;

        int heightSize = mTotalLength;

        // Check against our minimum height
        heightSize = Math.max(heightSize, getSuggestedMinimumHeight());

        // Reconcile our calculated size with the heightMeasureSpec
        int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
        heightSize = heightSizeAndState & MEASURED_SIZE_MASK;

        // Either expand children with weight to take up available space or
        // shrink them if they extend beyond our current bounds. If we skipped
        // measurement on any children, we need to measure them now.
        int remainingExcess = heightSize - mTotalLength
                + (mAllowInconsistentMeasurement ? 0 : consumedExcessSpace);
        if (skippedMeasure || remainingExcess != 0 && totalWeight > 0.0f) {
            float remainingWeightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;

            mTotalLength = 0;

            for (int i = 0; i < count; ++i) {
                final View child = getVirtualChildAt(i);
                if (child == null || child.getVisibility() == View.GONE) {
                    continue;
                }

                final LayoutParams lp = (LayoutParams) child.getLayoutParams();
                final float childWeight = lp.weight;
                if (childWeight > 0) {
                    final int share = (int) (childWeight * remainingExcess / remainingWeightSum);
                    remainingExcess -= share;
                    remainingWeightSum -= childWeight;

                    final int childHeight;
                    if (mUseLargestChild && heightMode != MeasureSpec.EXACTLY) {
                        childHeight = largestChildHeight;
                    } else if (lp.height == 0 && (!mAllowInconsistentMeasurement
                            || heightMode == MeasureSpec.EXACTLY)) {
                        // This child needs to be laid out from scratch using
                        // only its share of excess space.
                        childHeight = share;
                    } else {
                        // This child had some intrinsic height to which we
                        // need to add its share of excess space.
                        childHeight = child.getMeasuredHeight() + share;
                    }

                    final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                            Math.max(0, childHeight), MeasureSpec.EXACTLY);
                    final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                            mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin,
                            lp.width);
                    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

                    // Child may now not fit in vertical dimension.
                    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));
            }

            // Add in our padding
            mTotalLength += mPaddingTop + mPaddingBottom;
            // TODO: Should we recompute the heightSpec based on the new total length?
        } else {
            alternativeMaxWidth = Math.max(alternativeMaxWidth,
                                           weightedMaxWidth);


            // We have no limit, so make all weighted views as tall as the largest child.
            // Children will have already been measured once.
            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;

        // Check against our minimum width
        maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

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

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

上面code的主要功能如下：
1、判断每一个subchild之前是否有divider
2、计算每一个subchild的宽和高
3、如果subchild设置了weight，根据weight来计算subchild的高
4、是否使用useLargestChild，是的话则找出subchild中height最大的一个value，然后设置每一个subchild的height都为这个value
5、测量linearLayout本身的宽和高

下面我们一点一点的分析measureVertical方法里面的code

        mTotalLength = 0;
        int maxWidth = 0;
        int childState = 0;
        int alternativeMaxWidth = 0;
        int weightedMaxWidth = 0;
        boolean allFillParent = true;
        float totalWeight = 0;

        final int count = getVirtualChildCount();

        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        boolean matchWidth = false;
        boolean skippedMeasure = false;

        final int baselineChildIndex = mBaselineAlignedChildIndex;        
        final boolean useLargestChild = mUseLargestChild;

        int largestChildHeight = Integer.MIN_VALUE;
        int consumedExcessSpace = 0;

这里主要是一些初始化的变量，在后面使用的时候我们再来具体讲解其作用

for (int i = 0; i < count; ++i) {
    final View child = getVirtualChildAt(i);
    if (child == null) {
        mTotalLength += measureNullChild(i);
        continue;
    }

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

    if (hasDividerBeforeChildAt(i)) {
        mTotalLength += mDividerHeight;
    }

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

    totalWeight += lp.weight;

    final boolean useExcessSpace = lp.height == 0 && lp.weight > 0;
    if (heightMode == MeasureSpec.EXACTLY && useExcessSpace) {
        // Optimization: don't bother measuring children who are only
        // laid out using excess space. These views will get measured
        // later if we have space to distribute.
        final int totalLength = mTotalLength;
        mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
        skippedMeasure = true;
    } else {
        if (useExcessSpace) {
            // The heightMode is either UNSPECIFIED or AT_MOST, and
            // this child is only laid out using excess space. Measure
            // using WRAP_CONTENT so that we can find out the view's
            // optimal height. We'll restore the original height of 0
            // after measurement.
            lp.height = LayoutParams.WRAP_CONTENT;
        }

        // Determine how big this child would like to be. If this or
        // previous children have given a weight, then we allow it to
        // use all available space (and we will shrink things later
        // if needed).
        final int usedHeight = totalWeight == 0 ? mTotalLength : 0;
        measureChildBeforeLayout(child, i, widthMeasureSpec, 0,
                heightMeasureSpec, usedHeight);

        final int childHeight = child.getMeasuredHeight();
        if (useExcessSpace) {
            // Restore the original height and record how much space
            // we've allocated to excess-only children so that we can
            // match the behavior of EXACTLY measurement.
            lp.height = 0;
            consumedExcessSpace += childHeight;
        }

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

        if (useLargestChild) {
            largestChildHeight = Math.max(childHeight, largestChildHeight);
        }
    }

    /**
     * If applicable, compute the additional offset to the child's baseline
     * we'll need later when asked {@link #getBaseline}.
     */
    if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {
       mBaselineChildTop = mTotalLength;
    }

    // if we are trying to use a child index for our baseline, the above
    // book keeping only works if there are no children above it with
    // weight.  fail fast to aid the developer.
    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.");
    }

    boolean matchWidthLocally = false;
    if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {
        // The width of the linear layout will scale, and at least one
        // child said it wanted to match our width. Set a flag
        // indicating that we need to remeasure at least that view when
        // we know our width.
        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) {
        /*
         * Widths of weighted Views are bogus if we end up
         * remeasuring, so keep them separate.
         */
        weightedMaxWidth = Math.max(weightedMaxWidth,
                matchWidthLocally ? margin : measuredWidth);
    } else {
        alternativeMaxWidth = Math.max(alternativeMaxWidth,
                matchWidthLocally ? margin : measuredWidth);
    }

    i += getChildrenSkipCount(child, i);
}

1、13～15行是判断subchild之前是否有divider，如果有的话，计算divider的高度，divider可以通过设置android:divider属性
这里写图片描述
2、21～29行判断subchild当height为0并且有设置weight大小时，用useExcessSpace来表示true/false，可理解为 是否要使用LinearLayout余下的空间，当linearLayout大小确定时，我们选择跳过该subchild的测量，等到后面通过weight来计算subchild的大小；当linearLayout大小不确定时，30～37的lp.height = LayoutParams.WRAP_CONTENT这样做是为了后面紧接着的测量用的，测量该subchild的内容应该的大小
3、44行的measureChildBeforeLayout方法是测量subchild大小的
4、48～54行，当subchild被测量并且有设置weight大小，此时用consumedExcessSpace 来保存所有这样的subchild的高的总和
5、60～62行找出所有subchild里面height的value最大的
6、83～110这之间主要是为了找出subchild中width最大的value，以给最后的LinearLayout自己测量用的

if (useLargestChild &&
        (heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED)) {
    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();
        // Account for negative margins
        final int totalLength = mTotalLength;
        mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +
                lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
    }
}
假如1～2行的条件满足的话，直接看组后21～22行，此时LinearLayout会把每一个subchild的height都当成是largestChildHeight 来统计

// Add in our padding
mTotalLength += mPaddingTop + mPaddingBottom;

int heightSize = mTotalLength;

// Check against our minimum height
heightSize = Math.max(heightSize, getSuggestedMinimumHeight());

// Reconcile our calculated size with the heightMeasureSpec
int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
heightSize = heightSizeAndState & MEASURED_SIZE_MASK;

// Either expand children with weight to take up available space or
// shrink them if they extend beyond our current bounds. If we skipped
// measurement on any children, we need to measure them now.
int remainingExcess = heightSize - mTotalLength
        + (mAllowInconsistentMeasurement ? 0 : consumedExcessSpace);
 上面几行是计算LinearLayout的height大小的，最后16～17行计算所有subchild之外，LinearLayout剩余的未使用的垂直方向的空间大小。

if (skippedMeasure || remainingExcess != 0 && totalWeight > 0.0f) {
    float remainingWeightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;

    mTotalLength = 0;

    for (int i = 0; i < count; ++i) {
        final View child = getVirtualChildAt(i);
        if (child == null || child.getVisibility() == View.GONE) {
            continue;
        }

        final LayoutParams lp = (LayoutParams) child.getLayoutParams();
        final float childWeight = lp.weight;
        if (childWeight > 0) {
            final int share = (int) (childWeight * remainingExcess / remainingWeightSum);
            remainingExcess -= share;
            remainingWeightSum -= childWeight;

            final int childHeight;
            if (mUseLargestChild && heightMode != MeasureSpec.EXACTLY) {
                childHeight = largestChildHeight;
            } else if (lp.height == 0 && (!mAllowInconsistentMeasurement
                    || heightMode == MeasureSpec.EXACTLY)) {
                // This child needs to be laid out from scratch using
                // only its share of excess space.
                childHeight = share;
            } else {
                // This child had some intrinsic height to which we
                // need to add its share of excess space.
                childHeight = child.getMeasuredHeight() + share;
            }

            final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                    Math.max(0, childHeight), MeasureSpec.EXACTLY);
            final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                    mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin,
                    lp.width);
            child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

            // Child may now not fit in vertical dimension.
            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));
    }

    // Add in our padding
    mTotalLength += mPaddingTop + mPaddingBottom;
    // TODO: Should we recompute the heightSpec based on the new total length?
} else {

1、上面的if-else满足的添加是之前有subchild有跳过测量，或者是有sunchild设置了weight的值并且LinearLayout垂直方向的空间没有被使用完。
2、这里需要注意的是，假如一共有3个subchild且都有设置weight ，分别为3、2、1，我们假设剩余的space为120，则第一个view的大小为120 * 3/（3+2+1）=60，第二个view的大小为（120-60）*2/（2+1）=40，第3个view的大小为（60-40）*1/1 = 20
3、上面其余的code就不多解释了，通过前面code的分析这里因该可以看的明白

else {
    alternativeMaxWidth = Math.max(alternativeMaxWidth,
                                   weightedMaxWidth);


    // We have no limit, so make all weighted views as tall as the largest child.
    // Children will have already been measured once.
    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));
            }
        }
    }
}

这一段code就不分析了，都很简单

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

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

最后，设置LinearLayout的size大小和状态，如果LinearLayout有设置width为match_parent的话，将会调用forceUniformWidth再测量一次所有的subchild，这里主要是测量subchild的width大小

下面我们继续分析LayoutVertical方法

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

        int childTop;
        int childLeft;

        // Where right end of child should go
        final int width = right - left;
        int childRight = width - mPaddingRight;

        // Space available for child
        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;

        switch (majorGravity) {
           case Gravity.BOTTOM:
               // mTotalLength contains the padding already
               childTop = mPaddingTop + bottom - top - mTotalLength;
               break;

               // mTotalLength contains the padding already
           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);
                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;
                }

                childTop += lp.topMargin;
                setChildFrame(child, childLeft, childTop + getLocationOffset(child),
                        childWidth, childHeight);
                childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);

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

上面的code的大体功能如下：
1、LinearLayout里面所有的subChild作为一个整体，判断是处于LinearLayout的top、bottom还是center_vertical
2、循环遍历subChild来设置child在LinearLayout中的位置，code很简单，细心看很容易明白
3、setChildFrame方法最终是调用了child.layout 方法

ok，关于LienarLayout方面的分析到此结束！

chenshuwan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinearLayout源码详解，移动端开发技术选型
m0_64319496的博客
11-18 196
measureVertical(widthMeasureSpec, heightMeasureSpec); } else { measureHorizontal(widthMeasureSpec, heightMeasureSpec); } } 在onMeasure中，根据orientation的值来进行纵向的测量或者是横向的测量，纵向和横向测量的逻辑相识，所以我们只需要选取其中一个来进行分析，这里，我们只分析纵向的测量 //记录了内部已经被使用的高度 mTotalLength = 0; //childVi
Android7.0 InCallUI 源码分析
xiaoge0103的博客
04-12 2805
Android7.0InCallUI源码分析 AndroidManifest.xml 源码路径：packages\apps\Dialer\InCallUI 注：android7.0之前packages\apps\InCallUI InCallUI\AndroidManifest.xml <manifest xmlns:android="http://schemas....
android linearlayout源码
11-05
android linearlayout 学习
Android的LinearLayout源码分析
qq602298560的专栏
06-19 748
首先给大家介绍一个源码查看网址：http://www.grepcode.com/，不需要翻墙就可以查看源码。 首先View的工作过程包括：measure（测量），layout（布局），draw（绘制）三大流程。ViewGroup则增加了对子View的处理。可以通过查看LinearLayout的实现源码更直观了解到View的工作原理。 主要内容： 1. LinearLayut初始化 2. Line
Android 8.0 LinearLayout 源码解析
陈宇明
04-16 194
码个蛋(codeegg)第598次推文作者：lijiankun24博客：https://www.jianshu.com/p/1fa113b7ff64一. 开篇在最开始接触Andro...
Android View系列(三)——LinearLayout源码分析
hesheng1024的博客
04-13 308
title: Android View系列(三)——LinearLayout源码分析 tag: Android源码 category: Android date: 2019-04-29 文章目录LinearLayout 源码分析简介onMeasureonLayoutonDrawFrameLayout、LinearLayout和RelativeLayout的性能对比特别鸣谢 LinearLay...
Google Android SDK开发范例大全(完整版附部分源码).pdf
09-01
包含部分书中源码 目录 第1章 了解.深入.动手做. 1.1 红透半边天的Android 1.2 本书目的及涵盖范例范围 1.3 如何阅读本书 1.4 使用本书范例 1.5 参考网站 第2章 Android初体验 2.1 安装AndroidSDK与ADTplug...
Android 低功耗蓝牙开发（扫描、连接）
最新发布
2401_84123094的博客
04-22 729
由于本文罗列的知识点是根据我自身总结出来的，并且由于本人水平有限，无法全部提及，欢迎大神们能补充~将来我会对上面的知识点一个一个深入学习，也希望有童鞋跟我一起学习，一起进阶。提升架构认知不是一蹴而就的，它离不开刻意学习和思考。**这里，笔者分享一份从架构哲学的层面来剖析的视频及资料分享给大家，**梳理了多年的架构经验，筹备近1个月最新录制的，相信这份视频能给你带来不一样的启发、收获。，第一时间获取最新知识点Android架构师之路很漫长，一起共勉吧！
Android7.0 Voicemail (1) Voicemail的下载流程
ZhangJian的博客
11-03 6246
今天接到一个任务，需要解决同事在美国测试Voicemail功能时，出现的下载失败问题。目前，国内的运营商似乎没有支持Voicemail功能，因此资料相对较少。自己以前对这块流程也不太熟悉，没有解决过相应的bug。 不得已，只好根据同事提供的截图，从界面开始一步一步分析整个Voicemail的下载流程。
从零开始学Android3（保姆级笔记）活动Activity
Gisele_CJPwoke的博客
03-20 789
声明：编译器使用的是Android Studio，以及我是跟随B站的up动脑学院的课程学习的~ 【书接上回】 文章目录一、启停活动页面1.Activity 的启动和结束2.Activity的生存周期3.Activity的启动模式二、在活动之间传递消息1.显式Intent和隐式Intent（意图动作）2.向下一个Activity发送数据3.向上一个Activity返回数据三、为活动补充附加信息1.利用资源文件配置字符串2.利用元数据传递配置信息3.给应用页面注册快捷方式 一、启停活动页面 1.Activity
Android应用源码之10._LinearLayout学习.zip
12-04
Android 应用开发源码 参考与学习使用
Android开发完全讲义（第二版)第四文章之linearlayout源代码
09-20
Android开发完全讲义（第二版)第四文章之linearlayout源代码 作者：李宁
Android学习笔记——LinearLayout源码分析
Mr_Gintoki的博客
07-19 956
一、构造函数 public LinearLayout(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); TypedArray a = context.obtainStyledAttributes(attrs,
LinearLayout源码简单查看
qq_16965811的博客
06-07 409
绘制过程  view的绘制过程无非是onmeasure(),onLayout(),onDraw()。LinearLayout的三个过程： 1，通过weight， gravity，测量模式 测量view和子view的大小。  2，通过 gravity确定子view的位置  3，通过 在onDraw绘制divider 接下来我们一起看下onMeasure()方法： {CSDN:
Linearlayout 测量过程源码解析
北极冰神殿的博客
12-28 488
LinearLayout， onMeasure
android gui源码分析,Android View 相关源码分析之四 LinearLayout源码分析
weixin_33595018的博客
05-26 123
LinearLayout 源码分析measure过程主要过程根据布局方向选择measure过程分支初始化相关变量对View进行第一次测量mTotalLength的再次测量二次测量部分View和对为测量的子View进行测量protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {//判断布局方向if (mOrient...
LinearLayout源码解析
TonyW的专栏
06-17 7790
为什么学习自从学了Android自定义控件的一些知识，总是处于似懂非懂状态，说都说了上来，自己在项目里封装了一些自定义控件，但是还是缺乏一个很直观的了解。所以去了解学习下Android是如何封装控件的，就从简单的入手，分析下LinearLayout是如何实现的什么是LinearLayout作为最基础的布局，所以从事过Android开发的同学都应该非常了解 中文解释应该叫做线性布局，相比如Relat
Android RelativeLayout(7.1) 源码解析
chenshuwan的博客
04-18 575
RelativeLayout onMeasure and onLayout
Android通讯录应用源码解析
这些布局文件使用了不同的布局组件，如LinearLayout、RelativeLayout和ListView，展示了如何在Android中创建用户界面。 - `Main.xml` 是应用的主要布局，可能包含了应用的主视图和导航菜单。 - `addnew.xml` 可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值