理解 MeasureSpec

理解 MeasureSpec在开始本篇文章之前,我们先看一段代码:@OverrideprotectedvoidonMeasure(intwidthMeasureSpec,intheightMeasureSpec){intexpendSpec=MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE>>2,MeasureS…

在开始本篇文章之前,我们先看一段代码:

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int expendSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
        super.onMeasure(widthMeasureSpec, expendSpec);
    }

是不是很熟悉,没错,它就是我们在 ScrollView 嵌套 ListView 的时候,重写 ListView 来处理 ListView 数据显示不全的问题,那么为什么要这么写呢,而 MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST) 又是什么意思呢,别着急,重头戏马上到来。

1. MeasureSpec 是干什么的

确切的说,MeasureSpec 在很大程度上决定了一个 View 的尺寸规格,之所以说很大程度上是因为这个过程还受父容器的影响,因为父容器影响 View 的 MeasureSpec 创建过程,在测量过程中,系统会将 View 的 LayoutParams 根据父容器所施加的规转换成对应的 MeasureSpec,然后再根据这个 MeasureSpec 来测量出 View 的宽高,上面提到过,这里的宽高是测量的宽高,不一定等于 View 的最终宽高,MeasureSpec 看起来有点复杂,其实他的实现还是很简单的,下面会详细的分析MeasureSpec 

2. MeasureSpec 的原理

理解 MeasureSpec

先来看一张图,带着问题来解读接下来要说的内容。

MeasureSpec 代表一个32为的 int 值,高两位是 SpecMode,低30位是 SpecSize,SpecMode 是指测量模式,而 SpecMode 是指在某种测量模式下的规格大小,下面先看下 MeasureSpec 内部的一些常量的定义,通过下面的代码,应该不难理解 MeasureSpec 的工作原理:

        private static final int MODE_SHIFT = 30;
        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

        /** @hide */
        @IntDef({UNSPECIFIED, EXACTLY, AT_MOST})
        @Retention(RetentionPolicy.SOURCE)
        public @interface MeasureSpecMode {}

        /**
         * Measure specification mode: The parent has not imposed any constraint
         * on the child. It can be whatever size it wants.
         */
        public static final int UNSPECIFIED = 0 << MODE_SHIFT;

        /**
         * Measure specification mode: The parent has determined an exact size
         * for the child. The child is going to be given those bounds regardless
         * of how big it wants to be.
         */
        public static final int EXACTLY     = 1 << MODE_SHIFT;

        /**
         * Measure specification mode: The child can be as large as it wants up
         * to the specified size.
         */
        public static final int AT_MOST     = 2 << MODE_SHIFT;

        /**
         * Creates a measure specification based on the supplied size and mode.
         *
         * The mode must always be one of the following:
         * <ul>
         *  <li>{@link android.view.View.MeasureSpec#UNSPECIFIED}</li>
         *  <li>{@link android.view.View.MeasureSpec#EXACTLY}</li>
         *  <li>{@link android.view.View.MeasureSpec#AT_MOST}</li>
         * </ul>
         *
         * <p><strong>Note:</strong> On API level 17 and lower, makeMeasureSpec's
         * implementation was such that the order of arguments did not matter
         * and overflow in either value could impact the resulting MeasureSpec.
         * {@link android.widget.RelativeLayout} was affected by this bug.
         * Apps targeting API levels greater than 17 will get the fixed, more strict
         * behavior.</p>
         *
         * @param size the size of the measure specification
         * @param mode the mode of the measure specification
         * @return the measure specification based on size and mode
         */
        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);
            }
        }

        /**
         * Like {@link #makeMeasureSpec(int, int)}, but any spec with a mode of UNSPECIFIED
         * will automatically get a size of 0. Older apps expect this.
         *
         * @hide internal use only for compatibility with system widgets and older apps
         */
        public static int makeSafeMeasureSpec(int size, int mode) {
            if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {
                return 0;
            }
            return makeMeasureSpec(size, mode);
        }

        /**
         * Extracts the mode from the supplied measure specification.
         *
         * @param measureSpec the measure specification to extract the mode from
         * @return {@link android.view.View.MeasureSpec#UNSPECIFIED},
         *         {@link android.view.View.MeasureSpec#AT_MOST} or
         *         {@link android.view.View.MeasureSpec#EXACTLY}
         */
        @MeasureSpecMode
        public static int getMode(int measureSpec) {
            //noinspection ResourceType
            return (measureSpec & MODE_MASK);
        }

        /**
         * Extracts the size from the supplied measure specification.
         *
         * @param measureSpec the measure specification to extract the size from
         * @return the size in pixels defined in the supplied measure specification
         */
        public static int getSize(int measureSpec) {
            return (measureSpec & ~MODE_MASK);
        }

MeasureSpec 通过将 SpecMode 和 SpecSize 打包成一个 int 值来避免过多的对象内存分配,为了方便操作,其提供了打包和解包的方法。SpecMode 和 SpecSize 也是一个 int 值,一组 SpecMode 和 SpecSize 可以打包成一个 MeasureSpec,而一个 MeasureSpec 可以通过解包的方法来得出原始的 SpecMode 和 SpecSize,需要注意的是这里提到的 MeasureSpec 是值 MeasureSpec 所代表的 int 值,而并非 MeasureSpec 本身。

3. MeasureSpec 的三种模式

(1)UNSPECIFIEND

父容易不对 View 有任何影响,要多大给多大,这种情况一般用于系统内部,表示一种测量模式(我也不是太懂,有懂的大佬指点下)

(2)EXACTLY

父容器已经检测出 View 所需要的精确大小,这个时候 View 的最终大小就是 MeasureSpec 所指定的值,它对应于 LayoutParams 的 match_parent 和具体的数值两种模式。(如果是重写控件,慎用该模式,不然你会发现一件很神奇的事情,想知道的可以自己动手试试)

(3)AT_MOST

父容器指定一个大小即 SpecSize,View 的大小不能大于这个值,具体是什么值要看不同 View 的具体实现,它对应于 LayoutParams 的warp_content。

4.MeasureSpec 和 LayoutParams 对应关系

上面提到,系统内部是通过 MeasureSpec 来进行 View 的测量的,但是正常情况下我们使用 View 指定 MeasureSpec,尽管如此,但是我们给 View 设置 LayoutParams,在 View 测量的时候,系统会将 LayoutParams 在父容器的约束下转换成 MeasureSpec,然后在根据  MeasureSpec 来确定 View 测量后的宽高,需要注意的是 MeasureSpec 不是唯一有 LayoutParams 决定的,LayoutParams 需要和父容器一起才能决定 View 的 MeasureSpec,从而进一步决定 View 的宽高。另外,对于顶级 View(DecorView)和普通 View 来说,MeasureSpec 的转换过程略有不同,其 MeasureSpec 有窗口的尺寸和其自身的 LayoutParams 来共同决定;对于普通的 View,其 MeasureSpec 由父容器的 MeasureSpec 和 自身的 LayoutParams 决定,MeasureSpec 一旦确定后,onMeasure 中就可以确定 View 的测量宽高。
对于 DecorView 来说,在RootViewImpl 中的 measureHierarcly 方法中 有如下一段代码,它展示了 DecorView 的 MeasureSpec 的创建过程,其中 desiredWindowWidth 和 desiredWindowHeight 是屏幕的尺寸大小:

        childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
        childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

接着再看一下 getRootMeasureSpec 方法实现:

/**
     * Figures out the measure spec for the root view in a window based on it's
     * layout params.
     *
     * @param windowSize
     *            The available width or height of the window
     *
     * @param rootDimension
     *            The layout params for one dimension (width or height) of the
     *            window.
     *
     * @return The measure spec to use to measure the root 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;
    }

根据上述代码, DecorView 的 MeasureSpec 的产生过程就很明了了,具体来说遵守如下规则,根据它的 LayoutParams 中的宽高的参数来划分:

(1)LayoutParams.MATCH_PARENT:精确模式,大小就是窗口大小;
(2)LayoutParams.WARP_CONTENT:最大模式,大小不定,但是不能超过窗口的大小
(3)固定大小(不如100DP):精确模式,大小为 LayoutParams 中指定的大小。
对于 View 来说,这里是指我们布局中的 View,View 的 measure 过程由 ViewGroup 传递过来,先看一下 ViewGroup 的 measureChildWithMargins2 方法:

    // Note: padding has already been removed from the supplied specs
    private void measureChildWithMargins2(View child, int parentWidthSpec, int parentHeightSpec,
                                          int childWidth, int childHeight) {
        int childWidthSpec = getChildMeasureSpec(parentWidthSpec,
                getTotalMargin(child, true), childWidth);
        int childHeightSpec = getChildMeasureSpec(parentHeightSpec,
                getTotalMargin(child, false), childHeight);
        child.measure(childWidthSpec, childHeightSpec);
    }

上述方法会对子元素进行 measure,在调用子元素的 measure 方法之前会先调通过 getChildMeasureSpec 的创建与父容器的 MeasureSpec 和子元素本身的 LayoutParams 有关,此外还和 View 的 margins 及 padding 有关,具体情况可以看一下 ViewGroup 的 getChildMeasureSpec 方法,如下所示:

   /**
     * Does the hard part of measureChildren: figuring out the MeasureSpec to
     * pass to a particular child. This method figures out the right MeasureSpec
     * for one dimension (height or width) of one child view.
     *
     * The goal is to combine information from our MeasureSpec with the
     * LayoutParams of the child to get the best possible results. For example,
     * if the this view knows its size (because its MeasureSpec has a mode of
     * EXACTLY), and the child has indicated in its LayoutParams that it wants
     * to be the same size as the parent, the parent should ask the child to
     * layout given an exact size.
     *
     * @param spec The requirements for this view
     * @param padding The padding of this view for the current dimension and
     *        margins, if applicable
     * @param childDimension How big the child wants to be in the current
     *        dimension
     * @return a MeasureSpec integer for the child
     */
    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 同时结合 View 本身的 LayoutParams 来确定子元素的 MeasureSpec ,参数中的 padding 是指父容器中已经占用的空间大小,因此子元素可用的大小为父容器的尺寸减去 padding ,具体代码如下:

    int specSize = MeasureSpec.getSize(spec);
    int size = Math.max(0, specSize - padding);

getChildMeasureSpec 清楚展示了普通 View 的 MeasureSpec 的创建规则。这个整个过程正好对应了文章开头那个表格,然后咱们再回来看下这个表格:
理解 MeasureSpec

针对上图,这里再做下说明,前面已经提到,对于普通的 View,其 MeasureSpec 有父容器的 MeasureSpec 和自身的 LayoutParams 来决定的,那么针对不同的父容器和 View 本身不同的 LayoutParams,View 就可以有多张 MeasureSpec。这里简单说一下,当 View 采用固定宽高的时候,不管父容器的 MeasureSpec 是什么,View 的 MeasureSpec 都是精确模式并且大小遵循 LayoutParams 中的大小,当 View 中的宽高是 match_parent 时,如果父容器的模式是精准模式,那么 View 也是精准模式,其大小是父容器的剩余空间,如果父容器是最大模式,那么 View 也是最大模式但大小不会超过父容器的剩余空间。当 View 的宽高是 warp_content 时,不管父容器的模式是精准还是最大模式, View 的模式总是最大模式但大小不会超过父容器的剩余空间。至于 UNSPECIFIEND 模式,我是真的不知道有啥用,等以后弄明白了再补充吧,或者哪位大神知道,可以说下,谢谢!!
通过上边的表格可以看出,我们知道了父容器的 MeasureSpec 和子元素的 LayoutParams,就可以快速地确定出子元素的 MeasureSpec 了,有了 MeasureSpec 就可以进一步确定出子元素测量后的大小了。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/36443.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注