MENU

⾃定义布局流程

January 25, 2021 • Read: 507 • Android

⾃定义布局流程

布局过程

  • 确定每个 View 的位置和尺⼨
  • 作⽤:为绘制和触摸范围做⽀持
  • 绘制:知道往哪⾥绘制
  • 触摸反馈:知道⽤户点的是哪⾥–

流程

从整体看

  • 测量流程:从根 View 递归调⽤每⼀级⼦ View 的 measure() ⽅法,对它们进⾏测量
  • 布局流程:从根 View 递归调⽤每⼀级⼦ View 的 layout() ⽅法,把测量过程得出的⼦ View

的位置和尺⼨传给⼦ View,⼦ View 保存

  • 为什么要分两个流程?

从个体看,对于每个 View:

  1. 运⾏前,开发者在 xml ⽂件⾥写⼊对 View 的布局要求 layout_xxx
  2. ⽗ View 在⾃⼰的 onMeasure() 中,根据开发者在 xml 中写的对⼦ View 的要求,和⾃⼰的可⽤空间,得出对⼦ View 的具体尺⼨要求
  3. ⼦ View 在⾃⼰的 onMeasure() 中,根据⾃⼰的特性算出⾃⼰的期望尺⼨
  • 如果是 ViewGroup,还会在这⾥调⽤每个⼦ View 的 measure() 进⾏测量
  1. ⽗ View 在⼦ View 计算出期望尺⼨后,得出⼦ View 的实际尺⼨和位置
  2. ⼦ View 在⾃⼰的 layout() ⽅法中,将⽗ View 传进来的⾃⼰的实际尺⼨位置保存
  • 如果是 ViewGroup,还会在 onLayout() ⾥调⽤每个字 View 的 layout() 把它们的尺⼨

位置传给它们

具体开发

继承已有的 View,简单改写它们的尺⼨:重写 onMeasure():SquareImageView

  1. 重写 onMeasure()
  2. ⽤ getMeasuredWidth() 和 getMeasuredSize() 获取到测量出的尺⼨
  3. 计算出最终要的尺⼨
  4. ⽤ setMeasuredDimension(width, height) 把结果保存
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);

    int width = getMeasuredWidth();
    int height = getMeasuredHeight();
    int size = Math.min(width, height);

    setMeasuredDimension(size, size);
}

对⾃定义 View 完全进⾏⾃定义尺⼨计算:重写 onMeasure():CircleView

  1. 重写 onMeasure()
  2. 计算出⾃⼰的尺⼨
  3. ⽤ resolveSize() 或者 resolveSizeAndState() 修正结果

    • resolveSize() / resolveSizeAndState() 内部实现(⼀定读⼀下代码,这个极少需要⾃⼰写,但⾯试时很多时候会考):

      • ⾸先⽤ MeasureSpec.getMode(measureSpec) 和MeasureSpec.getSize(measureSpec) 取出⽗ 对⾃⼰的尺⼨限制类型和具体限制尺⼨;
      • 如果 measure spec 的 mode 是 EXACTLY,表示⽗ View 对⼦ View 的尺⼨做出了精确限制,所以就放弃计算出的 size,直接选⽤ measure spec 的 size;
      • 如果 measure spec 的 mode 是 AT_MOST,表示⽗ View 对⼦ View 的尺⼨只限制了上限,需要看情况:

        • 如果计算出的 size 不⼤于 spec 中限制的 size,表示尺⼨没有超出限制,所以选⽤计算出的 size;
        • ⽽如果计算出的 size ⼤于 spec 中限制的 size,表示尺⼨超限了,所以选⽤spec 的 size,并且在 resolveSizeAndState() 中会添加标志
        • MEASURED_STATE_TOO_SMALL(这个标志可以辅助⽗ View 做测量和布局的计算;
      • 如果 measure spec 的 mode 是 UNSPECIFIED,表示⽗ View 对⼦ View 没有任何尺⼨限制,所以直接选⽤计算出的 size,忽略 spec 中的 size。
  4. 使⽤ setMeasuredDimension(width, height) 保存结果
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

    int width = (int) ((PADDING + RADIUS) * 2);
    int height = (int) ((PADDING + RADIUS) * 2)
    setMeasuredDimension(resolveSizeAndState(width, widthMeasureSpec,0),
    resolveSizeAndState(height, heightMeasureSpec, 0));

}

⾃定义 Layout:重写 onMeasure() 和 onLayout():TagLayout

  1. 重写 onMeasure()

    • 遍历每个⼦ View,⽤ measureChildWidthMargins() 测量⼦ View需要重写 generateLayoutParams() 并返回 MarginLayoutParams 才能使⽤measureChildWithMargins() ⽅法
    • 有些⼦ View 可能需要重新测量(⽐如换⾏处)
    • 测量完成后,得出⼦ View 的实际位置和尺⼨,并暂时保存
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

for (int i = 0; i < getChildCount(); i++) {
    View child = getChildAt(i);

    Rect childBounds = childrenBounds[i];

    // 测量⼦ View

    measureChildWithMargins(child, widthMeasureSpec,

    widthUsed,

    heightMeasureSpec, heightUsed);

    // 保存⼦ View 的位置和尺⼨

    childBounds.set(childlLeft, childTop, childLeft

    + child.getMeasuredWidth(), chiltTop

    + child.getMeasuredHeight());

    ......

}

// 计算⾃⼰的尺⼨,并保存

int width = ...;

int height = ...;

    setMeasuredDimension(resolveSizeAndState(width,widthMeasureSpec, 0),resolveSizeAndState(height, heightMeasureSpec,0));

}
  • measureChildWidthMargins() 的内部实现(最好读⼀下代码,这个极少需要⾃⼰写,但⾯试时很多时候会考):

    • 通过 getChildMeasureSpec(int spec, int padding, int childDimension) ⽅法计算出⼦ View 的 widthMeasureSpec 和 heightMeasureSpec,然后调⽤ child.measure() ⽅法来让⼦ View ⾃我测量;
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);  
}
  • getChildMeasureSpec(int spec, int padding, int childDimension) ⽅法的内部实现是,结合开发者设置的 LayoutParams 中的 width 和 height 与⽗ View ⾃⼰的剩余可⽤空间,综合得出⼦ View 的尺⼨限制,并使⽤MeasureSpec.makeMeasureSpec(size, mode) 来求得结果:
    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);
    }

注意:源码中的分类⽅式是先⽐较⾃⼰的 MeasureSpec 中的 mode,再

⽐较开发者设置的 layout_width 和 layout_height,⽽我给出的判断⽅式
(下⾯的这⼏段内容)是先⽐较 layout_width 和 layout_height,再⽐较
⾃⼰ MeasureSpec 中的 mode。两种分类⽅法都能得出正确的结果,但
源码中的分类⽅法在逻辑上可能不够直观,如果你读源码理解困难,可以
尝试⽤我上⾯的这种⽅法来理解。

  • 如果开发者写了具体值(例如 layout_width="24dp"),就不⽤再考虑⽗View 的剩余空间了,直接⽤ LayoutParams.width / height 来作为⼦ View的限制 size,⽽限制 mode 为 EXACTLY(为什么?课堂上说过,因为软件的直接开发者——即 xml 布局⽂件的编写者——的意⻅最重要,发⽣冲突的时候应该以开发者的意⻅为准。换个⻆度说,如果真的由于冲突导致界⾯不正确,开发者可以通过修改 xml ⽂件来解决啊,所以开发者的意⻅是第⼀位,但你如果设计成冲突时开发者的意⻅不在第⼀位,就会导致软件的可配置性严重降低);
  • 如果开发者写的是 MATCH_PARENT,即要求填满⽗控件的可⽤空间,那么由于⾃⼰的可⽤空间和⾃⼰的两个 MeasureSpec 有关,所以需要根据⾃⼰的 widthMeasureSpec 或 heightMeasureSpec 中的 mode 来分情况判断

    1. 如果⾃⼰的 spec 中的 mode 是 EXACTLY 或者 AT_MOST,说明⾃⼰的尺⼨有上限,那么把 spec 中的 size 减去⾃⼰的已⽤宽度或⾼度,就是⾃⼰可以给⼦ View 的 size;⾄于 mode,就⽤ EXACTLY(注意:就算⾃⼰的 mode 是 AT_MOST,传给⼦ View 的也是EXACTLY,想不通的话好好琢磨⼀下)
    2. 如果⾃⼰的 spec 中的 mode 是 UNSPECIFIED,说明⾃⼰的尺⼨没有上限,那么让⼦ View 填满⾃⼰的可⽤空间就⽆从说起,因此选⽤退让⽅案:给⼦ View 限制的 mode 就设置为 UNSPECIFIED,size 写 0 就好
  • 如果开发者写的是 WRAP_CONTENT,即要求⼦ View 在不超限制的前提下⾃我测量,那么同样由于⾃⼰的可⽤空间和⾃⼰的两个 MeasureSpec 有关,所以也需要根据⾃⼰的 widthMeasureSpec 和 heightMeasureSpec中的 mode 来分情况判断:

    1. 如果⾃⼰的 spec 中的 mode 是 EXACTLY 或者 AT_MOST,说明⾃⼰的尺⼨有上限,那么把 spec 中的 size 减去⾃⼰的已⽤宽度或⾼度,就是⾃⼰可以给⼦ View 的尺⼨上限;⾄于 mode,就⽤AT_MOST(注意,就算⾃⼰的 mode 是 EXACTLY,传给⼦ View 的也是 AT_MOST,想不通的话好好琢磨⼀下;
    2. 如果⾃⼰的 spec 中的 mode 是 UNSPECIFIED,说明⾃⼰的尺⼨没上限,那么也就不必限制⼦ View 的上限,因此给⼦ View 限制的mode 就设置为 UNSPECIFIED,size 写 0 就好
  • 测量出所有⼦ View 的位置和尺⼨后,计算出⾃⼰的尺⼨,并⽤setMeasuredDimension(width, height) 保存
  • 重写 onLayout()

    • 遍历每个⼦ View,调⽤它们的 layout() ⽅法来将位置和尺⼨传给它们
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    for (int i = 0; i < getChildCount(); i++) {
        View child = getChildAt(i);
        Rect childBounds = childrenBounds[i];
        // 将每个⼦ View 的位置和尺⼨传递给它
        child.layout(childBounds.left, childBounds.top,
        childBounds.right, childBounds.bottom);
     }
}