View绘制

之前感觉自己知道什么是View绘制，但是又有点模糊。这里就当作笔记来记录一下。
View绘制是从根类ViewRootImpl.java的performTraversals()方法开始的。依次经过measure、layout、draw三个过程，最终完成整个View的绘制。
先来看看源码:

private void performTraversals() {
        final View host = mView;
        //................
        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
        //................
        performLayout(lp, mWidth, mHeight);
        //................
        performDraw();
        //................
}

接下来看看上面三个方法的源码:

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
            //重点
       mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}


private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,int desiredWindowHeight) {
        //重点
        host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
}

private void performDraw() {
    ......
    //下面这个是重点，通过查看源码，其内部调用的是drawSoftware()，最终调用的是mView.draw(canvas);
    draw(fullRedrawNeeded);
    ......
}

一句话，三个过程也就是通过measure()，layout()，draw()三个方法实现的。

一、measure过程
先看View类的measure方法源码：

//这个方法是final的，不能被重写
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
    //...............
    //回调onMeasure方法
    onMeasure(widthMeasureSpec, heightMeasureSpec);
    //...............
}

分析源码可知，这个方法用来计算整个View树的大小，然后设置实际的宽高尺寸，其中，每个子View的大小是由其父视图的MeasureSpec和自身的LayoutParams共同决定的。实际测量过程是由onMeasure方法实现的，所以如果View的子类想要实现自己的测量逻辑，就需要重写onMeasure方法，而不是measure方法，因为这个方法是final的，不能被重写。

measure方法的两个参数都是父视图传递过来的，表示的是父视图的规格。MeasureSpec：测量规格，是一个32位的int型值，高两位表示规格model，后30位表示父视图的size。有三种类型：MeasureSpec.EXACTLY表示确定大小， MeasureSpec.AT_MOST表示最大大小， MeasureSpec.UNSPECIFIED表示大小不确定。对于根View，也就是DecorView来说，model一般为MeasureSpec.EXACTLY，size就是屏幕的物理尺寸。其他子view的大小是父视图和自身共同决定的。

接着看onMeasure的源码：

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

setMeasuredDimension方法用来设置View的测量宽高，如果不重写此方法，默认调用getDefaultSize获取尺寸。至此，对于普通View来说，已经算是完成了measure过程。当然了，也可以重写onMeasure方法并调用setMeasuredDimension方法来设置任意大小的布局(视图).

onMeasure方法的默认实现仅仅是调用setMeasuredDimension方法，所以setMeasuredDimension方法至关重要，它对View的成员变量mMeasuredWidth 和 mMeasuredHeight赋值，measure的主要目的就是给View树中的每个View的这两个成员变量赋值，所以一旦这两个变量被赋值，意味着测量工作结束。

接着看源码：

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

由以上代码可知，正常情况下（SpecMode为AT_MOST或EXACTLY），getDefaultSize获取的尺寸大小即为specSize，也就是系统默认的规格。由以上代码还可知道，直接继承View的自定义控件需要重写onMeasure方法并设置wrap_content时的自身大小，否则在布局中使用wrap_content就相当于使用match_parent的效果。

至此，一个普通View的measure过程算是结束了。

一般情况下，View是被ViewGroup嵌套的，ViewGroup中定义了measureChildren, measureChild, measureChildWithMargins方法来对子视图进行测量，measureChildren内部实质只是循环调用measureChild，measureChild和measureChildWithMargins的区别就是是否把margin和padding也作为子视图的大小。
通过源码可知，

//调用子View的measure方法，子View的measure中会回调子View的onMeasure方法
    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

ViewGroup中的测量最终是通过调用子View的measure方法，最终回调onMeasure方法实现的。所以一般自定义View是继承自ViewGroup类型时，会重写onMeasure实现自己的测量逻辑。

二、layout过程

当ViewRootImpl中performTraversals()上面的measure过程结束后，接着会执行mView.layout()，源码如下：

//调用的还是View中的layout方法
host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());

四个参数：左,上,右,下。分别代表相对父视图的坐标位置。其中，左上都是0，右下分别为上面测量出来的width 和 height。

接下来回到View中的layout方法：

public void layout(int l, int t, int r, int b) {
    int oldL = mLeft;
    int oldT = mTop;
    int oldB = mBottom;
    int oldR = mRight;
    //View的位置是否发生变化，导致的结果就是是否需要layout。这里的实质是通过setFrame方法将参数分别赋值给mLeft,mTop,mBottom,mRight
    boolean changed = isLayoutModeOptical(mParent) ?
  setOpticalFrame(l, t, r, b) :   setFrame(l, t, r, b);
    //需要重新layout
    if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
        //重点，回调onLayout
        onLayout(changed, l, t, r, b);
        .........
        //设置需要layout的标记
        mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
        .........
    }
}

接下来看回调的View中的onLayout方法:

 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
 }

ok，可以看到竟然是空实现的，那就没什么好说的啦。因为对子View布局的工作只能由容器View来做，也就是ViewGroup。

接下来看ViewGroup中的源码:

@Override
public final void layout(int l, int t, int r, int b) {
        ......
        //这里回调的还是View中的layout方法
        super.layout(l, t, r, b);
        ......
}

对比View的layout方法 和 ViewGroup中的layout方法，View中的layout方法可以被重写，而ViewGroup中的layout方法是final的，不能被重写。所以说ViewGroup只能通过重写onLayout方法实现布局放置。

再来看ViewGroup的onLayout方法：

@Override
protected abstract void onLayout(boolean changed,
            int l, int t, int r, int b);

明显的，这个方法是抽象的，也就意味着它的子类必须实现这个方法。所以在自定义ViewGroup控件中，需要重写onMeasure方法和onLayout方法，这样可以实现一些复杂的布局。自定义View一般就是先调用onMeasure()进行测量，然后调用onLayout()来获取子View 和 子View的测量大小，然后进行layout布局。重写onLayout就是为了安排子View在其父View中的位置。

这里需要提一下getWidth() 、getHeight()、getMeasuredWidth()、getMeasuredHeight()这几个方法：
都是View的测量宽高。getMeasuredWidth()、getMeasuredHeight()需要在onMeasure之后使用，getWidth() 、getHeight()需要在onLayout之后使用。

好吧，到此处layout算是完事儿啦。

注：measure过程得到是每个View经测量后的measuredWidth 和 measuredHeight，而layout过程得到是对每个View进行位置分配后的mLeft，mTop，mRight，mBottom，这些相对父视图来说的。

三、draw过程
draw过程也是在ViewRootImpl的performTraversals()中调用的，在measure 和 layout之后调用。

canvas = mSurface.lockCanvas(dirty);
......
//调用View的draw方法来执行绘制
mView.draw(canvas);

接下来就来看看View中的draw源码:

public void draw(Canvas canvas) {
        final int privateFlags = mPrivateFlags;
        final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
                (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
        mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;

/*
         * Draw traversal performs several drawing steps which must be executed
         * in the appropriate order:
         *
         *1. Draw the background---绘制背景
         *2. If necessary, save the canvas' layers to prepare for fading---如果需要绘制渐变框，这里会做一些准备
         *3. Draw view's content---绘制自身内容
         *4. Draw children---绘制子View
         *5. If necessary, draw the fading edges and restore layers---如果需要，这里开始绘制渐变框
         *6. Draw decorations (scrollbars for instance)---绘制滚动条
         */

// Step 1, draw the background, if needed
        int saveCount;

        if (!dirtyOpaque) {
            drawBackground(canvas);
        }

        // skip step 2 & 5 if possible (common case)
        final int viewFlags = mViewFlags;
        boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
        boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
        if (!verticalEdges && !horizontalEdges) {
            // Step 3, draw the content
            if (!dirtyOpaque) onDraw(canvas);

            // Step 4, draw the children
            dispatchDraw(canvas);

            // Overlay is part of the content and draws beneath Foreground
            if (mOverlay != null && !mOverlay.isEmpty()) {
                mOverlay.getOverlayView().dispatchDraw(canvas);
            }

  // Step 6, draw decorations (foreground, scrollbars)
            onDrawForeground(canvas);

  // we're done...
            return;
}

可以看到，draw过程分为6个步骤，上面有写注释。

先来看步骤3，也就是绘制View自身，调用的是View的onDraw()：

protected void onDraw(Canvas canvas) {
}

额，竟然是个空实现方法。其实是由于每个View的内容各不相同，所以交给子类去实现各自的绘制逻辑。

步骤4，绘制子View。

看看View的dispatchDraw方法：

/**
     * Called by draw to draw the child views. This may be overridden
     * by derived classes to gain control just before its children are drawn
     * (but after its own view has been drawn).
     * @param canvas the canvas on which to draw the view
     */
protected void dispatchDraw(Canvas canvas) {

}

好吧，又是一个空实现的方法。注释上写的很清楚，如果View包含子View就需要重写这个方法。所以就需要看看ViewGroup的dispatchDraw方法：

@Override
protected void dispatchDraw(Canvas canvas) {
    ......
    //遍历子View
    for (int i = 0; i < childrenCount; i++) {
        if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||transientChild.getAnimation() != null) {

    more |= drawChild(canvas, transientChild, drawingTime);
        }
    }
    ......

    // Draw any disappearing views that have animations
        if (mDisappearingChildren != null) {
            final ArrayList<View> disappearingChildren = mDisappearingChildren;
            final int disappearingCount = disappearingChildren.size() - 1;
            // Go backwards -- we may delete as animations finish
            for (int i = disappearingCount; i >= 0; i--) {
                final View child = disappearingChildren.get(i);
                more |= drawChild(canvas, child, drawingTime);
            }
        }
        ......
}

重点就是drawChild这个方法：

    protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
         //调用的是View的draw方法
        return child.draw(canvas, this, drawingTime);
    }

也就是说，ViewGroup重写了父类View的dispatchDraw方法，该方法内部通过遍历并调用各个子View的draw方法来实现绘制。重要的是可以知道，ViewGroup内部已经重写了dispatchDraw方法，所以我们一般不需要重写dispatchDraw方法了，但是可以重载这个方法来实现具体的功能。

ok，draw过程结束！！！

到此为止，measure，layout，draw三个过程就结束了，也就是说整个View的绘制结束。后面还是得看看源码，太精深，，，