是Android的自定义View-绘制流程-测量

作者: redrain39 | 来源:发表于2021-01-26 22:04 被阅读0次

前言

在View的绘制过程中，measure是第一步，View首先需要进行测量才能获取到具体的长宽，这就好比画一张画首先要获得所要进行绘画创作的物体的大致宽高才能进行绘制。

还记得顶层视图中的performTraversals方法吗？

忘记的同学可以先去看一下之前的文章 Android中的View体系

performTraversals这个方法里有将近一千行的代码，这里就不一一展开了，就单纯为了了解View的绘制流程来说也没有必要，主要分析一下绘制相关的核心方法

源码分析

measure的入口

在performTraversals方法中会有这样一个方法：

WindowManager.LayoutParams lp = mWindowAttributes;

// 获取相关的尺寸参数
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

// 顾名思义这是一个执行measure的方法
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

在讲解performMeasure方法前，先要来讲一讲MeasureSpec相关的概念：

关于测量规格MeasureSpec

MeasureSpec 可以理解为一个测量 View 的准则，它是View的一个内部类，它由两部分组成：

测量规格（MeasureSpec） = 测量模式（mode） + 测量大小（size）

测量规格：32位Int类型
测量模式：占测量规格的高2位
测量大小：占测量规格的低30位

有三种测量模式：

规格类型	规格说明
UNSPECIFIED	父视图不约束子视图的大小，一般是列表类控件会用到，不怎么会在自定义View中用到
EXACTLY	父视图为子视图指定一个确定的大小，一般应用于控件是固定尺寸或是match_parent，这种情况下父视图可以直接确定子视图的大小。
AT_MOST	父视图为子视图指定一个最大的尺寸，一般应用于控件是wrap_content，这种情况下父视图无法获取子视图的大小，只能由子视图自己去获取。

所以对于MeasureSpec这个类来说可以理解成对于View尺寸规范的抽象，方便后续的测量计算。

那么接下来就继续我们的流程分析吧。

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    if (mView == null) {
        return;
    }

    try {
        // 这个mView是我们setContentView传递进来我们自己定义的布局
        // 其内部主要是通过View调用的measure方法 --> 分析1.开始measure流程
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

分析1.开始measure流程

// View的measure方法
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
    boolean optical = isLayoutModeOptical(this);
    if (optical != isLayoutModeOptical(mParent)) {
        Insets insets = getOpticalInsets();
        int oWidth  = insets.left + insets.right;
        int oHeight = insets.top  + insets.bottom;
        widthMeasureSpec  = MeasureSpec.adjust(widthMeasureSpec,  optical ? -oWidth  : oWidth);
        heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec, optical ? -oHeight : oHeight);
    }
    
    // 分析2.对measure的响应过程
    onMeasure(widthMeasureSpec, heightMeasureSpec);

    ···
}

在measure开始的这个方法中，首先获取到了宽高的测量规格，然后传给对measure进行响应的方法中。

分析2.对measure的响应过程

// View的onMeasure方法
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    // 设置measure后的尺寸
    // 这个方法的参数就是测量后的宽高，但是获取参数值的方法比较复杂
    // getSuggestedMinimumWidth() & getSuggestedMinimumHeight()方法
    // getDefaultSize(int size, int measureSpec)方法
    // setMeasuredDimension(int measuredWidth, int measuredHeight)方法
    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
            getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}

getSuggestedMinimumWidth() & getSuggestedMinimumHeight()分析

根据是否有背景来获得最小的控件宽高

protected int getSuggestedMinimumWidth() {
    return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}

protected int getSuggestedMinimumHeight() {
    return (mBackground == null) ? mMinHeight : max(mMinHeight, mBackground.getMinimumHeight());
}

getDefaultSize(int size, int measureSpec)分析

// 根据获取的最小宽高和测量准则来获取默认的尺寸
public static int getDefaultSize(int size, int measureSpec) {
    // 最小尺寸
    int result = size;
    // 测量模式
    int specMode = MeasureSpec.getMode(measureSpec);
    // 测量尺寸
    int specSize = MeasureSpec.getSize(measureSpec);

    switch (specMode) {
    case MeasureSpec.UNSPECIFIED:           // 如果不受限制使用最小尺寸
        result = size;
        break;
    case MeasureSpec.AT_MOST:               // 如果设置指定大小或是限定大小则使用测量尺寸
    case MeasureSpec.EXACTLY:
        result = specSize;
        break;
    }
    return result;
}

setMeasuredDimension(int measuredWidth, int measuredHeight)分析

// 参数说明：measuredWidth & measuredHeight —— 经过测量的宽和高
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
    // 判断是否是 ViewGroup
    boolean optical = isLayoutModeOptical(this);
    // 判断父布局是否是 ViewGroup
    if (optical != isLayoutModeOptical(mParent)) {
        // 获取视觉宽高（根据是否有背景）
        Insets insets = getOpticalInsets();
        int opticalWidth  = insets.left + insets.right;
        int opticalHeight = insets.top  + insets.bottom;
        // 根据是否是 ViewGroup 进一步进行计算
        measuredWidth  += optical ? opticalWidth  : -opticalWidth;
        measuredHeight += optical ? opticalHeight : -opticalHeight;
    }
    // 将最终的测量宽高传入 setMeasuredDimensionRaw 方法
    setMeasuredDimensionRaw(measuredWidth, measuredHeight);
}

setMeasuredDimensionRaw(int measuredWidth, int measuredHeight)分析

// View获取测量的宽高
private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
    mMeasuredWidth = measuredWidth;
    mMeasuredHeight = measuredHeight;

    mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
}

至此，View完成了测量的过程，获得了测量的mMeasuredWidth和mMeasuredHeight，就可以进入下一步布局过程了，不过在此之前我们还要了解一下ViewGroup的measure过程。

ViewGroup的绘制过程

ViewGroup 的 onMeasure 方法是通过子类去实现的，以 FrameLayout 为例：

onMeasure

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    // 获取子元素的数量
    int count = getChildCount();

    final boolean measureMatchParentChildren =
            MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
            MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
    mMatchParentChildren.clear();

    // 最大宽度和高度
    int maxHeight = 0;
    int maxWidth = 0;
    int childState = 0;

    // 对 Margins 进行测量
    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);
                }
            }
        }
    }

    // 对 padding 进行测量
    maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
    maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();

    // 将现有的宽高和背景进行比较，获取较大的值
    maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
    maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

    // 将现有的宽高和前景进行比较，获取较大的值
    final Drawable drawable = getForeground();
    if (drawable != null) {
        maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
        maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
    }

    // 将测量的宽高传入
    setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
            resolveSizeAndState(maxHeight, heightMeasureSpec,
                    childState << MEASURED_HEIGHT_STATE_SHIFT));

    // 遍历子元素进行测量
    count = mMatchParentChildren.size();
    if (count > 1) {
        for (int i = 0; i < count; i++) {
            final View child = mMatchParentChildren.get(i);
            final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

            final int childWidthMeasureSpec;
            if (lp.width == LayoutParams.MATCH_PARENT) {
                final int width = Math.max(0, getMeasuredWidth()
                        - getPaddingLeftWithForeground() - getPaddingRightWithForeground()
                        - lp.leftMargin - lp.rightMargin);
                childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
                        width, MeasureSpec.EXACTLY);
            } else {
                childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                        getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
                        lp.leftMargin + lp.rightMargin,
                        lp.width);
            }

            final int childHeightMeasureSpec;
            if (lp.height == LayoutParams.MATCH_PARENT) {
                final int height = Math.max(0, getMeasuredHeight()
                        - getPaddingTopWithForeground() - getPaddingBottomWithForeground()
                        - lp.topMargin - lp.bottomMargin);
                childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                        height, MeasureSpec.EXACTLY);
            } else {
                childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
                        getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
                        lp.topMargin + lp.bottomMargin,
                        lp.height);
            }
            
            // 子控件进行测量操作
            child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        }
    }
}

需要注意的是并使所有的ViewGroup的测量顺序都相同，不同的布局测量子控件和测量自身的顺序可能会根据具体的逻辑改变，在这就不一一列举，如果需要实现自定义的ViewGroup可以先进到源码中了解一下相似的ViewGroup是怎么进行计算的。

总结

总的来说View的measure可以分为两类：

View的Measure
ViewGroup的Measure

View的Measure

View的Measure过程就是在onMeasure中根据测量规格来计算View的宽高并进行存储。

ViewGroup的Measue

ViewGroup的Measure过程在onMeasure根据不同的ViewGroup的逻辑遍历子View，通过对子View的遍历measure，最终确定ViewGroup自己的宽高并进行存储。

在我们日常的自定义View开发中，一般的会去复写 onMeasure 方法，就可以拿到测量的宽高，如果不想使用父类的方法，就需要我们自己去实现其中的具体逻辑，但是最终必须调用setMeasuredDimension方法设置测量宽高

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    // 可以拿到测量时的宽高
}