阅读 325

Android自定义控件 | View绘制原理(画多大?)

View绘制就好比画画,抛开Android概念,如果要画一张图,首先会想到哪几个基本问题:

  • 画多大?
  • 画在哪?
  • 怎么画?

Android绘制系统也是按照这个思路对View进行绘制,上面这些问题的答案分别藏在

  • 测量(measure)
  • 定位(layout)
  • 绘制(draw)

这一篇将以源码中的几个关键函数为线索分析“测量(measure)”。

如果想直接看结论可以移步到第三篇末尾。

这是自定义控件系列教程的第一篇,系列文章目录如下:

  1. Android自定义控件 | View绘制原理(画多大?)
  2. Android自定义控件 | View绘制原理(画在哪?)
  3. Android自定义控件 | View绘制原理(画什么?)
  4. Android自定义控件 | 源码里有宝藏之自动换行控件
  5. Android自定义控件 | 小红点的三种实现(上)
  6. Android自定义控件 | 小红点的三种实现(下)
  7. Android自定义控件 | 小红点的三种实现(终结)

View.measure()

“测量”要解决的问题是确定待绘制View的尺寸,以View.measure()为入口,一探究竟:

public class View implements Drawable.Callback, KeyEvent.Callback,AccessibilityEventSource {
    /**
     * <p>
     * This is called to find out how big a view should be. The parent
     * supplies constraint information in the width and height parameters.
     * 这个方法用于决定当前view到底有多大,父亲提供宽高参数起到限制大小的作用
     *
     * The actual measurement work of a view is performed in
     * {@link #onMeasure(int, int)}, called by this method. Therefore, only
     * {@link #onMeasure(int, int)} can and must be overridden by subclasses.
     * 真正的测量工作在onMeasure()中进行
     *
     * @param widthMeasureSpec Horizontal space requirements as imposed by the
     *        parent(父亲施加的宽度要求)
     * @param heightMeasureSpec Vertical space requirements as imposed by the
     *        parent(父亲施加的高度要求)
     *
     * @see #onMeasure(int, int)
     */
    public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
        ...
        onMeasure(widthMeasureSpec, heightMeasureSpec);
        ...
    }
    
    /**
     * Measure the view and its content to determine the measured width and the
     * measured height. This method is invoked by {@link #measure(int, int)} and
     * should be overridden by subclasses to provide accurate and efficient
     * measurement of their contents.
     * View子类应该重载这个方法以定义自己尺寸
     *
     * <strong>CONTRACT:</strong> When overriding this method, you
     * <em>must</em> call {@link #setMeasuredDimension(int, int)} to store the
     * measured width and height of this view. Failure to do so will trigger an
     * <code>IllegalStateException</code>, thrown by
     * {@link #measure(int, int)}. Calling the superclass'
     * {@link #onMeasure(int, int)} is a valid use.
     * 重载方法必须调用 setMeasuredDimension()
     */
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
    }
}
复制代码

从注释中得知这么几个信息:

  1. 真正的测量工作在onMeasure()中进行,View的子类应该重载这个方法以定义自己尺寸。
  2. onMeasure()中必须调用setMeasuredDimension()
  3. View会通过传入的宽高参数对子View的尺寸施加限制。

顺带便看了一下常见控件如何重载onMeasure(),其实套路都一样,不管是TextView还是ImageView,在一系列计算得出宽高值后将传入setMeasuredDimension()。所以,整个测量过程的终点是View.setMeasuredDimension()的调用,它表示着视图大小已经有确定值。

ViewGroup.onMeasure()

View必然依附于一棵“View树”,那父View是如何对子View的尺寸施加影响的?全局搜索View.measure()被调用的地方,在很多ViewGroup类型的控件中发现类似child.measure()的调用,以最简单的FrameLayout为例:

public class FrameLayout extends ViewGroup {
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        //获得孩子数量
        int count = getChildCount();
        ...
        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            //遍历可见孩子或者强制遍历所有孩子
            if (mMeasureAllChildren || child.getVisibility() != GONE) {
                //测量孩子
                measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
                final LayoutParams lp = (LayoutParams) child.getLayoutParams();
                //记忆孩子中最大宽度
                maxWidth = Math.max(maxWidth,
                        child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
                //记忆孩子中最大高度
                maxHeight = Math.max(maxHeight,
                        child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
                childState = combineMeasuredStates(childState, child.getMeasuredState());
                if (measureMatchParentChildren) {
                    if (lp.width == LayoutParams.MATCH_PARENT ||
                            lp.height == LayoutParams.MATCH_PARENT) {
                        mMatchParentChildren.add(child);
                    }
                }
            }
        }

        ...

        //以最孩子中最大的尺寸作为自己的尺寸
        setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                resolveSizeAndState(maxHeight, heightMeasureSpec,
                        childState << MEASURED_HEIGHT_STATE_SHIFT));

        ...
    }
}
复制代码

FrameLayout会遍历所有可见的孩子记忆其中最大宽度和最大高度,并以此作为自己的宽和高(这是FrameLayout的测量算法,其他的ViewGroup应该也有自己独特的测量算法。)

ViewGroup.measureChildWithMargins()

父控件在遍历每个孩子时会调用measureChildWithMargins()来测量孩子:

public abstract class ViewGroup extends View implements ViewParent, ViewManager {
    /**
     * Ask one of the children of this view to measure itself, taking into
     * account both the MeasureSpec requirements for this view and its padding
     * and margins. The child must have MarginLayoutParams The heavy lifting is
     * done in getChildMeasureSpec.
     * 要求孩子自己测量自己(考虑父亲的要求和自己的边距)
     *
     * @param child The child to measure
     * @param parentWidthMeasureSpec The width requirements for this view(来自父亲的宽度要求)
     * @param widthUsed Extra space that has been used up by the parent
     *        horizontally (possibly by other children of the parent)
     * @param parentHeightMeasureSpec The height requirements for this view(来自父亲的高度要求)
     * @param heightUsed Extra space that has been used up by the parent
     *        vertically (possibly by other children of the parent)
     */
    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);
    }
}
复制代码

读到这里应该可以总结出ViewGroup的测量过程: 遍历所有的孩子,通过调用View.measure()触发孩子们测量自己。测量完所有孩子之后,按照自有的测量算法将孩子们的尺寸转换成自己的尺寸并传入View.setMeasuredDimension()

ViewGroup.getChildMeasureSpec()

触发孩子测量自己的时候传入了宽高两个参数,它们是通过ViewGroup.getChildMeasureSpec()产生的:

public abstract class ViewGroup extends View implements ViewParent, ViewManager {
    public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
        ...
        int specMode = MeasureSpec.getMode(spec);
        int specSize = MeasureSpec.getSize(spec);
        ...
        switch (specMode) {
        case MeasureSpec.EXACTLY:
            ...
            break;

        case MeasureSpec.AT_MOST:
            ...
            break;

        case MeasureSpec.UNSPECIFIED:
            ...
            break;
        }
        ...
        return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
    }
}
复制代码

这个函数中有一个陌生的类MeasureSpec,点进去看看:

   /**
     * A MeasureSpec encapsulates the layout requirements passed from parent to child.
     * Each MeasureSpec represents a requirement for either the width or the height.
     * A MeasureSpec is comprised of a size and a mode. There are three possible
     * modes:
     * MeasureSpec包装了父亲对孩子的布局要求,它是尺寸和模式的混合,它包含三种模式
     *
     * MeasureSpecs are implemented as ints to reduce object allocation.
     * MeasureSpec被实现成一个int值为了节约空间
     */
    public static class MeasureSpec {
        //前2位是模式,后30位是尺寸
        private static final int MODE_SHIFT = 30;
        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;
            /**
         * 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;
        ...
    }
复制代码

MeasureSpec用于在View测量过程中描述尺寸,它是一个包含了布局模式和布局尺寸的int值(32位),其中最高的2位代表布局模式,后30位代表布局尺寸。它包含三种布局模式分别是UNSPECIFIEDEXACTLYAT_MOST

结合刚才的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);

        //从父亲尺寸中去除padding
        int size = Math.max(0, specSize - padding);

        int resultSize = 0;
        int resultMode = 0;

        //结合父亲要求和孩子诉求计算出孩子尺寸,父亲有三种类型的要求,孩子有三种类型的诉求,孩子尺寸一共有9种结果。
        switch (specMode) {
        // Parent has imposed an exact size on us(父亲有明确尺寸)
        case MeasureSpec.EXACTLY:
            //如果孩子对自己尺寸有明确要求,只能满足它,不考虑padding
            if (childDimension >= 0) {
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            }
            //如果孩子要求和父亲一样大且父亲有明确尺寸,则孩子尺寸有确定,考虑padding
            else if (childDimension == LayoutParams.MATCH_PARENT) {
                // Child wants to be our size. So be it.
                resultSize = size;
                resultMode = MeasureSpec.EXACTLY;
            }
            //如果孩子要求完全显示自己内容,但它不能超过父亲,考虑padding
            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:
            //如果孩子对自己尺寸有明确要求,只能满足它,不考虑padding
            if (childDimension >= 0) {
                // Child wants a specific size... so be it(父亲其实很无奈)
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            }
            //如果孩子要求和父亲一样大,但父亲只有明确最大尺寸,则孩子也能有明确最大尺寸,考虑padding
            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;
            }
            //如果孩子要求完全显示自己内容,但它不能超过父亲,考虑padding
            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:
            //如果孩子对自己尺寸有明确要求,只能满足它,不考虑padding
            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);
    }
复制代码

这个函数揭示了一个“人间真相”:父亲总是对孩子有要求,但孩子也总是有自己的诉求。最圆满的结局莫过于充分考量两方面的需求并调和之。ViewGroup.getChildMeasureSpec()将3种父亲的要求和3种孩子的诉求进行了调和(详见上述代码及注释)

总结

  • 父控件在测量自己的时候会先遍历所有子控件,并触发它们测量自己。完成孩子测量后,根据孩子的尺寸来确定自己的尺寸。View绘制中的测量是一个从View树开始自顶向下的递归过程,递表示父控件触发子控件测量自己,归表示子控件完成测量后,父控件测量自己。
  • 父控件会将自己的布局要求和子控件的布局诉求结合成一个MeasureSpec对象传递给子控件以指导子控件测量自己。
  • MeasureSpec用于在View测量过程中描述尺寸,它是一个包含了布局模式和布局尺寸的int值(32位),其中最高的2位代表布局模式,后30位代表布局尺寸。
  • 整个测量过程的终点是View.setMeasuredDimension()的调用,它表示着视图大小已经有确定值。