【Android】View的绘制原理

一、View绘制总入口

ActivityThread中,首先创建Activity,然后通过attach方法初始化对应的mWindow,然后将顶级视图DecorView添加到Windows中,并创建ViewRootImpl对象,这个对象就是沟通WindowManager和DecorView之间的桥梁,也是View绘制的开始。

View的绘制流程首先开始于ViewRootImpl的performTraversals()方法。依次经过三大过程,measure、layout、draw,performTraversals会依次调用performMeasure、performLayout、performDraw方法。其中measure用来对View进行测量,layout来确定子元素在父元素中的位置即真实宽高以及四个顶点位置,draw负责将View绘制出来。

说的接地气一点,measure就是给个建议值,View多大合适;layout就是去放View的外框,放在哪里,具体多大;draw就是去画View里面的内容。

measure过程得到的测量宽高可以通过getMeasureWidth和getMeasureHeight得到,其值不一定就是实际宽高,实际宽高是layout之后,可以通过getWidth和getHeight获得。

二、measure

1、MeasureSpec

测量过程需要提到一个类,叫MeasureSpec,“测量规格”。MeasureSpec是View定义的一个内部类。MeasureSpec代表一个32位的int,高两位代表SpecMode,测量模式,第30位代表SpecSize,在某种测量模式下的规格大小。

MeasureSpec提供打包和解包的方法,可以将一组SpecMode和SpecSize通过makeMeasureSpec方法打包成MeasureSpec,也可以将一个MeasureSpec通过getMode和getSize进行解包获得对应的值。

SpecMode测量模式包含三种,含义如下:

SpecMode值 含义
UNSPECIFIED 父容器没有对View有任何限制,要多大给多大
EXACTLY 父容器能得到View的精确的值,这时候View的测量大小就是SpecSize的值,对应于View的LayoutParams中为match_parent或具体的值的情况。
AT_MOST 父容器指定了一个可用大小SpecSize,View的大小不定,但是不能大于这个值,这个对应于View的LayoutParams的wrap_content。

系统需要通过MeasureSpec对View进行测量。View的MeasureSpec需要由父容器的MeasureSpec和View的View的layoutParams一起决定,然后根据View的MeasureSpec确定View的宽和高。

由于DecorView是顶级视图,所以它的测量方法比较特殊,具体下面一一看下DecorView和普通View的MeasureSpec的计算。

(1)DecorView的MeasureSpec值计算,DecorView是最先被测量的,可以从ViewRootImpl的performMeasure方法看出。

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
    try {
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

这里的mView就是DecorView。往前搜传入的两个MeasureSpec的值。

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

可以看见调用了getRootMeasureSpec方法,传入了两个值,第一个值是屏幕尺寸,第二个值lp是LayoutParams 长宽的参数。所以,DecorView的MeasureSpec的值是由屏幕尺寸和它的LayoutParams 决定的。接下来看具体的关系getRootMeasureSpec。

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;
}

可以看见如果是MATCH_PARENT的话,就是精确的模式,大小就是窗口的大小,如果是WRAP_CONTENT,就是AT_MOST模式,即大小不定,但是最大为窗口大小。
(2)普通View的MeasureSpec值计算。
前面说到DecorView首先被测量,调用了mView.measure(childWidthMeasureSpec, childHeightMeasureSpec),由于DecorView继承自FrameLayout继承自ViewGroup继承自View,可以看见View里面的measure方法是一个final方法,即不可被重写。

public final void measure(int widthMeasureSpec, int heightMeasureSpec)

这个方法其实是去调用了onMeasure方法,这个方法是各个子类可以重写的。

跟踪这个方法,可以看见在View的measure是由ViewGroup传递过来的,具体是在ViewGroup里面的measureChildWithMargins方法。

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);
}

可以看见,首先获取View的LayoutParams,然后调用getChildMeasureSpec方法获取View的MeasureSpec,再调用View的measure进行测量,测量后面说,先说View的MeasureSpec的计算。看getChildMeasureSpec方法。

先看传入的三个参数:

  • 第一个参数parentWidthMeasureSpec即父容器的MeasureSpec
  • 第二个参数mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin + widthUsed,这些都是啥呢?这些分别是父容器设置的padding和View设置的margin和父容器已经被占用的大小。所以这些值加起来就是父容器中不能被View使用的长度。可以看见源码中函数参数名字就是padding,虽然不很确切,但是也可以说明就是不能被View使用的部分。
    第三个参数是View的LayoutParams。确切地说就是XML中layout_width和layout_height。

看下具体的getChildMeasureSpec方法。

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);
}

一句句看下来,首先,获取父容器的specMode和specSize,然后计算size = Math.max(0, specSize - padding),这里size就是说是父容器留给View的最大长度,如果specSize < padding,说明没有空间给View了,所以是0,否则能给View的剩余空间就是specSize - padding,这个比较好理解。

然后判断父容器specMode。根据父容器的specMode和View的LayoutParams值(match_parent、具体值、wrap_content)来决定。具体的逻辑非常简单,代码容易看懂。

总结成如下表:

View的LayoutParams\父容器的测量模式specMode EXACTLY AT_MOST UNSPECIFIED
具体的值 EXACTLY childsize EXACTLY childsize EXACTLY childsize
match_parent EXACTLY parentsize AT_MOST parentsize UNSPECIFIED 0
wrap_content AT_MOST parentsize AT_MOST parentsize UNSPECIFIED 0

这里的parentsize就是父容器可用剩余空间。

2、View的measure过程

首先,View的measure过程是由measure方法完成,看下View的measure方法。可以看见是个final方法,即不可被重写。

public final void measure(int widthMeasureSpec, int heightMeasureSpec) 

measure方法会调用onMeasure方法,看onMeasure方法的实现。

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
            getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}

setMeasuredDimension即设置View的测量宽高的值。计算方法是调用getDefaultSize,传入两个参数,先看这两个参数。
第二个参数是MeasureSpec,即前面说的,通过父MeasureSpec和View的LayoutParams以及父容器已经占用的空间进行计算得到。
看下第一个参数getSuggestedMinimumWidth()。

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

思路比较简单,如果没有背景,则直接返回mMinWidth,mMinWidth即View的android:minWidth的设置值,默认为0;如果有背景,则返回max(mMinWidth, mBackground.getMinimumWidth(),mBackground.getMinimumWidth()为背景的尺寸,默认也是0。
现在看下getDefaultSize方法。

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;
}

思路也是比较简单的,如果测量模式是UNSPECIFIED,返回第一个参数,如果是AT_MOST和EXACTLY,直接返回View的MeasureSpec的规格大小。

从上面的分析可以发现,直接继承View的时候,需要重写onMeasure方法,并设置wrap_content时候的大小,否则会和match_parent的时候效果一直。比如当View设置为wrap_content的时候,此时View的MeasureSpec为AT_MOST,parentsize。当View设置为match_parent的时候,其测量值最后的结果也为parentsize。

3、ViewGroup的measure过程

ViewGroup除了完成自己的measure过程外,还会去遍历所有的子元素的measure方法,各个子元素再去递归这个过程。ViewGroup是个抽象类,其onMeasure方法是个抽象方法,需要子类去实现它,因为不同的ViewGroup有不一样的布局特性,所以导致他们的测量细节不一样。

ViewGroup提供一个遍历的方法measureChildren。

protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
    final int size = mChildrenCount;
    final View[] children = mChildren;
    for (int i = 0; i < size; ++i) {
        final View child = children[i];
        if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
            measureChild(child, widthMeasureSpec, heightMeasureSpec);
        }
    }
}

遍历所有的View,如果可见的话调用measureChild进行测量。getChildMeasureSpec的实现前面已经讲过了。得到之后调用子元素的measure方法。

protected void measureChild(View child, int parentWidthMeasureSpec,
        int parentHeightMeasureSpec) {
    final LayoutParams lp = child.getLayoutParams();

    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
            mPaddingLeft + mPaddingRight, lp.width);
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
            mPaddingTop + mPaddingBottom, lp.height);

    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

4、measure结果的获取

有的业务需要,需要获取测量结果,但是有个问题,measure的测量和Activity的各个生命周期没有关系,所以在什么生命周期里面都有可能得到的measure测量值为0,即还没测量结束。从源码可以看见performTraversals是另开一个线程执行的。

final class TraversalRunnable implements Runnable {
    @Override
    public void run() {
        doTraversal();
    }
}

如果保证能获取到呢?有几个方法:
(1)为View添加onWindowFocusChanged监听,这个监听会在每次Activity的窗口获得和失去焦点的时候被调用,而View绘制成功的时候也是一次获得焦点的过程,所以也会调用。

public void onWindowFocusChanged(boolean hasWindowFocus) {
    super.onWindowFocusChanged(hasWindowFocus);
    if (hasWindowFocus) {
        int height = view.getMeasureHeight();
        int width = view.getMeasureWidth();
    }
}

(2)view.post
通过post将一个runnable投递到消息队列尾部,然后调用的时候,说明View已经初始化好了。

view.post(new Runnable() {
    @Override
    public void run() {
        int height = view.getMeasureHeight();
        int width = view.getMeasureWidth();
    }
});

(3)view.measure(int widthMeasureSpec, int heightMeasureSpec)
这个是最直接的方法,直接触发计算。这个一般是用在具体的值上,因为parentsize不知道。

比如宽高都是100px的。

int widthMeasureSpec = MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY);
int heightMeasureSpec = MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY);
view.measure(widthMeasureSpec, heightMeasureSpec);

二、layout

layout的作用是ViewGroup用来确定子元素的位置。首先调用setFrame初始化View的四个顶点,接着调用onLayout方法。

public void layout(int l, int t, int r, int b) {
    if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
        onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
        mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
    }

    int oldL = mLeft;
    int oldT = mTop;
    int oldB = mBottom;
    int oldR = mRight;

    boolean changed = isLayoutModeOptical(mParent) ?
            setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
    ...
}

onLayout由于不同的子类实现细节都不一样,所以onLayout在View和ViewGroup中都没有具体实现,都在子类中实现。以LinearLayout为例。

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    if (mOrientation == VERTICAL) {
        layoutVertical(l, t, r, b);
    } else {
        layoutHorizontal(l, t, r, b);
    }
}

其中layoutVertical关键代码如下。

for (int i = 0; i < count; i++) {
    final View child = getVirtualChildAt(i);
    if (child == null) {
        childTop += measureNullChild(i);
    } else if (child.getVisibility() != GONE) {
        final int childWidth = child.getMeasuredWidth();
        final int childHeight = child.getMeasuredHeight();
        
        final LinearLayout.LayoutParams lp =
                (LinearLayout.LayoutParams) child.getLayoutParams();
        
        int gravity = lp.gravity;
        if (gravity < 0) {
            gravity = minorGravity;
        }
        final int layoutDirection = getLayoutDirection();
        final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
        switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
            case Gravity.CENTER_HORIZONTAL:
                childLeft = paddingLeft + ((childSpace - childWidth) / 2)
                        + lp.leftMargin - lp.rightMargin;
                break;

            case Gravity.RIGHT:
                childLeft = childRight - childWidth - lp.rightMargin;
                break;

            case Gravity.LEFT:
            default:
                childLeft = paddingLeft + lp.leftMargin;
                break;
        }

        if (hasDividerBeforeChildAt(i)) {
            childTop += mDividerHeight;
        }

        childTop += lp.topMargin;
        setChildFrame(child, childLeft, childTop + getLocationOffset(child),
                childWidth, childHeight);
        childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);

        i += getChildrenSkipCount(child, i);
    }
}

可以看见是一个逐渐往下的过程。在父容器完成定位后,调用setChildFrame调用子元素的layout。

private void setChildFrame(View child, int left, int top, int width, int height) {        
    child.layout(left, top, left + width, top + height);
}

这里的width和height就是测量宽高。

final int childWidth = child.getMeasuredWidth();
final int childHeight = child.getMeasuredHeight();

看下最后真正的宽高的计算方法如下:

public final int getWidth() {
    return mRight - mLeft;
}
public final int getHeight() {
    return mBottom - mTop;
}

显然这个地方得到的值就是width和height。所以说在View的默认实现中,View的measure的结果测量宽高和layout的结果最终宽高是相等的。除非重新View,使得两者不一致。比如下面这样,但是这个没有什么意义。

public void layout(int l, int t, int r, int b) {
    super.layout(l, t, r + 100, b + 100);
}

三、draw

draw的过程就是将View绘制在屏幕上面。从Android源码的注释也可以看见绘制分为四个步骤,在View的draw方法中。
(1)绘制背景

drawBackground(canvas)

(2)绘制自己的内容

onDraw(canvas)

(3)绘制children

dispatchDraw(canvas);

(4)绘制装饰

onDrawForeground(canvas);

其中View的绘制通过dispatchDraw来遍历子元素并调用其draw方法,将draw事件一层层传递下去。

你可能感兴趣的:(【Android】View的绘制原理)