View系列 (二) — MeasureSpec 详解

最新推荐文章于 2022-02-10 18:38:32 发布
最新推荐文章于 2022-02-10 18:38:32 发布
阅读量630 收藏 3
点赞数 1
分类专栏： Android源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Love667767/article/details/105709669
版权

MeasureSpec 详解

一、概述

在 View 的测绘 (measure()) 过程中，会用到 MeasureSpe (测量规格)。

MeasureSpec的作用

确切来说，MeasureSpec 在很大程度上决定了一个 View 的尺寸，因为父容器会影响 子View 的MeasureSpec 创建过程。
在测量过程中，系统会将子 View 的 LayoutParams 根据父容器所施加的规则转换成对应的 MeasureSpec，然后再根据这measureSpec 来测量出View的宽/高。

版本： Android SDK 29
关联文章：

  1. 《View系列 (一) — Android 坐标系》
  2. 《View系列 (二) — MeasureSpec 详解》
  3. 《View系列 (三) — Measure 流程详解》
  4. 《View系列 (四) — Layout 流程详解》
  5. 《View系列 (五) — Draw 流程详解》

二、MeasureSpec 的构成

1. MeasureSpec 中的常量

MeasureSpec.class

// MeasureSpec.class
// int的大小为32位，高两位作为标记位，其余30位表示尺寸大小
private static final int MODE_SHIFT = 30;
// 3向左进位30 = 11 00000000000(11后跟30个0)  
private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

// UNSPECIFIED的模式设置：0向左进位30 = 00后跟30个0，即00 00000000000
public static final int UNSPECIFIED = 0 << MODE_SHIFT;
// EXACTLY的模式设置：1向左进位30 = 01后跟30个0 ，即01 00000000000
public static final int EXACTLY     = 1 << MODE_SHIFT;
// AT_MOST的模式设置：2向左进位30 = 10后跟30个0，即10 00000000000
public static final int AT_MOST     = 2 << MODE_SHIFT;

从 MeasureSpec 的常量可以看出，它代表了32位的 int 值， 其中高 2 位代表了 SpecMode，低30位则代表 SpecSize。SpecMode指的是测量模式， SpecSize指的是测量大小。

SpecMode 分为三类：

UNSPECIFIED： 不对View进行任何限制，要多大给多大，一般用于系统内部。
EXACTLY： 对应 LayoutParams 中的 match_parent 和 具体数值这两种模式。检测到 View 所需要的精确大小，这时候View的最终大小就是SpecSize所指定的值，
AT_MOST： 对应 LayoutParams 中的 wrap_content。子View 不能大于其父容器的大小。

2. MeasureSpec 提供的方法

既然 MeasureSpec 由两部分组成，那么在 MeasureSpec 中就会提供获取这两部分值的方法，以及将这两部分值合成 MeasureSpec 的方法。

  1. 获取 SpecMode： getSize(int measureSpec)
  2. 获取 SpecSize： getMode(int measureSpec)
  3. 合成 MeasureSpec ： makeSafeMeasureSpec(int size, int mode)
public static class MeasureSpec {
	// 根据传入的View的测量模式和测量值大小来生成一个 MeasureSpec。
    public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
                                      @MeasureSpecMode int mode) {
        if (sUseBrokenMakeMeasureSpec) {
            return size + mode;
        } else {
            return (size & ~MODE_MASK) | (mode & MODE_MASK);
        }
    }

    @UnsupportedAppUsage
    public static int makeSafeMeasureSpec(int size, int mode) {
        if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {
            return 0;
        }
        return makeMeasureSpec(size, mode);
    }
	
	// 通过位运算，获取View的测量模式 
    @MeasureSpecMode
    public static int getMode(int measureSpec) {
        //noinspection ResourceType
        return (measureSpec & MODE_MASK);
    }

	// 通过位运算，获取View的测量值大小 
    public static int getSize(int measureSpec) {
        return (measureSpec & ~MODE_MASK);
    }

    static int adjust(int measureSpec, int delta) {
        final int mode = getMode(measureSpec);
        int size = getSize(measureSpec);
        if (mode == UNSPECIFIED) {
            // No need to adjust size for UNSPECIFIED mode.
            return makeMeasureSpec(size, UNSPECIFIED);
        }
        size += delta;
        if (size < 0) {
            Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +
                    ") spec: " + toString(measureSpec) + " delta: " + delta);
            size = 0;
        }
        return makeMeasureSpec(size, mode);
    }
}

三、MeasureSpec 的使用

下面来说一下子View的大小到底如何确定下来的，这里要分两种情况讨论：根View (即：DecorView) 和 非根View。

  1. 根View 的大小： 由 自身的LayoutParams 和 窗口的尺寸 来决定。
  2. 非根View的大小： 由自身的LayoutParams 和 父容器的 MeasureSpec 决定。

1. 根 View 大小的测量

已知每个视图都有一个根节点 (即 DecorView) ，它最终在 ViewRootImpl 中触发了 DecorView 的测量操作。
在这里插入图片描述

// ViewRootImpl.class
private void performTraversals() {
	//...省略...
	WindowManager.LayoutParams lp = mWindowAttributes;
	//...省略...
	if (layoutRequested) {
		//...省略...
	   	// 这里执行了测量操作
	   	windowSizeMayChange |= measureHierarchy(host, lp, res, desiredWindowWidth, desiredWindowHeight);
	}
}

private boolean measureHierarchy(final View host, final WindowManager.LayoutParams lp,
		final Resources res, final int desiredWindowWidth, final int desiredWindowHeight) {
    int childWidthMeasureSpec;
    int childHeightMeasureSpec;
    boolean windowSizeMayChange = false;
    //...省略...
    
	// 测量 根View 的大小，lp为根View的LayoutParams
    childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
    childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
    // 从根View开始，触发View的测量操作
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
   
	//...省略...
    return windowSizeMayChange;
}

// 这是计算根View大小的核心逻辑：根据窗口大小和根节点的LayoutParams，来获取根View的尺寸大小
private static int getRootMeasureSpec(int windowSize, int rootDimension) {
    int measureSpec;
    switch (rootDimension) {

    case ViewGroup.LayoutParams.MATCH_PARENT:
        // Window can't resize. Force root view to be windowSize.
        measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
        break;
    case ViewGroup.LayoutParams.WRAP_CONTENT:
        // Window can resize. Set max size for root view.
        measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
        break;
    default:
        // Window wants to be an exact size. Force root view to be that size.
        measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
        break;
    }
    return measureSpec;
}

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
	// 开始从根View进行测量，此处 mView 即为 DecorView
    mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
View 自身的 LayoutParams模式 + 尺寸
LayoutParams.MATCH_PARENTMeasureSpec.EXACTLY + 窗口尺寸
LayoutParams.WRAP_CONTENTMeasureSpec.AT_MOST + 窗口尺寸
固定的尺寸(如50dp)MeasureSpec.EXACTLY + View自身的尺寸

2. 非根 View 大小的测量

非根View的大小： 由自身的LayoutParams 和 父容器的 MeasureSpec 决定。
在这里插入图片描述

这里，我们选取 DecorView 下的子视图 View (非根 View) 来作为分析。步骤如下所述：

  1. 根View计算结束后，会返回根View的宽高和测量模式 (childWidthMeasureSpec、childHeightMeasureSpec)。
  2. 执行 ViewRootImpl.performMeasure() 方法，其内部调用了 mView.measure() 方法会触发 View.measure() 方法。
  3. 在 View.measure() 方法中，会触发 View.onMeasure() 方法，由于 步骤2 中的 mView 代表的是 DecorView，而 DecorView 是 FrameLayout 的子类，且 FrameLayout 重写了 onMeasure() 方法，所以真正触发的是 FrameLayout.onMeasure() 方法。
  4. 在 FrameLayout.onMeasure() 方法中会触发 ViewGroup.measureChildWithMargins() 方法。
  5. 在 ViewGroup.measureChildWithMargins() 方法中，最终会调用 ViewGroup.getChildMeasureSpec() 方法，获取每个子 View 的大小。

下面看一下步骤5中涉及的代码：

// ViewGroup.class
protected void measureChildWithMargins(View child,
        int parentWidthMeasureSpec, int widthUsed,
        int parentHeightMeasureSpec, int heightUsed) {
    // 1.获取子View的LayoutParams
    final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
	// 2.根据父容器的MeasureSpec和子View的LayoutParams来计算子View的MeasureSpec
    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);
	// 3.子View继续进行测量
    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

// 这是计算非根View大小的核心逻辑：根据父容器的MeasureSpec和子View自身的LayoutParams，来获取子View的尺寸大小
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
	// 1.父容器的测量模式和尺寸大小
    int specMode = MeasureSpec.getMode(spec);
    int specSize = MeasureSpec.getSize(spec);
	// 2.计算子控件可用的最大尺寸(父容器-父容器内边距)
    int size = Math.max(0, specSize - padding);

    int resultSize = 0;
    int resultMode = 0;
    
	// 根据下面9种情况来设置子View的MeasureSpec(3种父容器的测量模式 * 3种子View的LayoutParams参数)
    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
    // 将上面获取到的子View测量模式和测量大小合成一个MeasureSpec
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

小结：
针对 ViewGroup.getChildMeasureSpec() 种的9种情况，作如下归纳：

子View的LayoutParams参数(纵坐标)
/
父容器测量模式(横坐标)		EXACTLYAT_MOSTUNSPECIFIED
具体数值(如50dp)EXACTLY + childSizeEXACTLY + childSizeEXACTLY + childSize
MATCH_PARENTEXACTLY + parentSize
(父容器剩余空间)		AT_MOST + parentSize
(父容器剩余空间)		UNSPECIFIED + 0
WRAP_CONTENTAT_MOST + parentSize
(父容器剩余空间)		AT_MOST + parentSize
(父容器剩余空间)		UNSPECIFIED + 0

根据上面的表格可知：

  1. 当子View的大小是确定值时，子View的MeasureSpec值恒为EXACTLY + childSize。
  2. 当子View的大小为MATCH_PARENT时，子View的测量模式与父容器保持一致。
Elson_6
关注
专栏目录
通过自定义View了解MeasureSpecMode
HYM BLOG
11-21 2024
一、自定义View的基本步骤 本篇文章的核心知识点，并不是自定义View的全部讲解，主要是通过一个简单的demo了解自定义View的MeasureSpecMode模式。 自定义View基本分为自定义View和自定义ViewGroup。 自定义View的步骤： 继承View重写构造方法(有四个构造方法，不同的使用场景可以了解下) 自定义属性，在构造方法中初始化属性 重写onMeasure方法测量宽高 重写onDraw方法绘制控件 关于View的绘制流程中，三个核心的回调方法onMeasure、onLayo
Android中自定义View的MeasureSpec使用
赵铮的专栏
02-14 171
有时，Android系统控件无法满足我们的需求，因此有必要自定义View。具体方法参见官方开发文档：http://developer.android.com/guide/topics/ui/custom-components.html 一般来说，自定义控件都会去重写View的onMeasure方法，因为该方法指定该控件在屏幕上的大小。 protected void onMeasure (i...
MeasureSpec介绍及使用详解
热门推荐
kaixinbingju的专栏
03-08 5万+
一个MeasureSpec封装了父布局传递给子布局的布局要求，每个MeasureSpec代表了一组宽度和高度的要求。一个MeasureSpec由大小和模式组成。它有三种模式：UNSPECIFIED(未指定),父元素部队自元素施加任何束缚，子元素可以得到任意想要的大小；EXACTLY(完全)，父元素决定自元素的确切大小，子元素将被限定在给定的边界里而忽略它本身大小；AT_MOST(至多)，子元素至多
View系列 - MeasureSpec全面解析
haoxl1994的博客
11-03 581
前言 兵马未动，粮草先行。在View的整个measure过程中，MeasureSpec就是这场战争的后勤补给军，贯穿了整场战争。要想真正理解measure的过程，就必须要百分之百的掌握MeasureSpec！相信很多人在学习MeasureSpec源码的时候，经常会看到这样的东西: private static final int MODE_MASK = 0x3 << MODE_SHI...
MeasureSpec
i_lovefish的专栏
10-14 399
一般来说，自定义控件都会去重写View的onMeasure方法，因为该方法指定该控件在屏幕上的大小。 protected void onMeasure (int widthMeasureSpec, int heightMeasureSpec) onMeasure传入的两个参数是由上一层控件传入的大小，有多种情况，重写该方法时需要对计算控件的实际大小，然后调用setMeasuredDim
Android View测量详解：MeasureSpec与布局模式
总结来说，掌握Android View的测量机制是构建高效、灵活UI的关键，理解和熟练运用MeasureSpec及其不同的模式能够帮助开发者实现精准且适应性强的界面设计。通过结合实际应用场景，如瞎子画画的游戏比喻，我们可以更...
Android MeasureSpec的理解和源码的解析
08-29
二、MeasureSpec的SpecMode MeasureSpec的SpecMode有三种： 1. MeasureSpec.EXACTLY：父容器已经检测出子View所需要的精确大小，该子View的最终测量大小即为SpecSize。 2. MeasureSpec.AT_MOST：父容器指定了子...
MeasureSpec三种测量模式详解例子
02-18
在这个详解例子中，我们将深入探讨MeasureSpec的三种测量模式以及它们如何影响Android UI布局。 1. **UNSPECIFIED模式** UNSPECIFIED模式是最宽松的模式，它表示父视图不对子视图有任何尺寸上的限制。子视图可以...
Android View.onMeasure方法详解及实例
08-30
Android View.onMeasure 方法详解及实例 Android View.onMeasure 方法是 View 类中非常重要的一个方法，它主要用于测量 View 的尺寸。在安卓系统中，View 在屏幕上显示之前需要经过测量（measure）和布局（layout）...
Android屏幕及view的截图实例详解
01-20
view.measure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED), MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)); view.layout(0, 0, view.getMeasuredWidth(), view.getMeasuredHeight());...
android如何获取view在布局中的高度与宽度详解
08-26
Android 获取 View 在布局中的高度与宽度详解 在 Android 开发中，获取 View 的宽度和高度是非常常见的需求。然而，很多开发者可能不知道如何正确地获取 View 的宽度和高度。今天，我们将详细介绍四种获取 View 在...
View.MeasureSpec
lygsust的博客
09-20 338
一：MeasureSpec介绍        MeasureSpec 是Android对外提供的获取控件测绘的工具类,它用于View的,onMeasure()测绘的时候，它对外提供三个主要方法：          //获取控件的模式         int getMode(int measureSpec) ;        //获取控件的大小         int getSize(in
View的工作原理(一)：MeasureSpec
cangely的专栏
05-05 458
ViewRoot 和 DecorView View的绘制流程是从ViewRoot的performTraversals方法开始的。它经过measure、layout和draw三个过程才能最终将一个View绘制出来。 measure：测量View的宽和高 layout：确定View在父容器的位置 draw：将View绘制在屏幕上。 performTraversals的工作流程： 父容器在o...
View 的测量 MeasureSpec
xyTianZhao
07-30 258
View 的测量 MeasureSpec 我们平常自定义都是重写 view 的 onMeasure(int widthMeasureSpec, int heightMeasureSpec)方法，而这个方法传入的宽和高都是一个32位 int 值。下面我们揭开这层神秘的面纱。 MeasureSpec 解析 MeasureSpec 是位于 View 类中的一个静态类，也就 100 行左右。我们先来看其中...
View体系（七）理解 MeasureSpec
droidYu
02-10 368
MeasureSpec是View的内部类，MeasureSpec 封装了从父级传递到子级的测量要求。每个 MeasureSpec 代表对宽度或高度的要求。 MeasureSpec 由大小和模式两部分组成。 更详细的说明请看 Google官方文档 下面是MeasureSpec的源码：（基于Android 12） public static class MeasureSpec { private static final int MODE_SHIFT = 30; priv
MeasureSpec介绍
任俊杰的专栏
08-31 6775
在自定义View和ViewGroup的时候，我们经常会遇到int型的MeasureSpec来表示一个组件的大小，这个变量里面不仅有组件的尺寸大小，还有大小的模式。 这个大小的模式，有点难以理解。在系统中组件的大小模式有三种： 1.精确模式 在这种模式下，尺寸的值是多少，那么这个组件的长或宽就是多少。 2.最大模式
Android视图测量详解：View的onMeasure与MeasureSpec
MeasureSpec是View类中的一个静态内部类，它封装了父View对子View的尺寸约束。MeasureSpec由specSize和specMode两个部分组成，specSize表示期望的尺寸，而specMode则决定了尺寸的约束条件，主要有三种： 1. ...
详解安卓MeasureSpec及其和match_parent、wrap_content的关系
zhaoqinmuxue的博客
09-08 1432
在安卓View的measure过程中，measureSpec扮演着重要的作用。MeasureSpec是一个32位的int，前2位代表模式，其中00代表UNSPECIFIED，01代表EXACTLY，10代表ATMOST，后30位代表具体大小，例如1073741824模式为EXACTLY,大小为1080。这三种模式的具体意思如下图 在ViewGroup中有一个getChildMeasureSp...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值