源码分析：View的工作流程

简介

View的工作流程主要是指measure、layout、draw这三大流程。其中measure确定View的测量宽高，layout确定View的最终宽高和四个顶点的位置，draw则将View绘制到屏幕上。

View的工作流程入口

在开始三大流程之前，还有一些其他工作，例如将DecorView加载到Window中。并且三大流程的开始是通过ViewRootImpl来调用的。

DecorView被加载到Window中

当在Activity的onCreate中调用setContentView方法时，将会创建DecorView。当DecorView创建完毕后，要加载到Window中。这一过程需要从Activity的创建过程说起，先看ActivityThread的handleLaunchActivity方法：

ActivityThread#handleLaunchActivity

    private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
        //...

        Activity a = performLaunchActivity(r, customIntent);   //该方法会调用onCreate   

        if (a != null) {
            //...
            
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason); 

        } else {
            //...
        }
    }

（1）处的performLaunchActivity将会调用onCreate方法，从而完成DecorView的创建。现在看handleResumeActivity方法：

ActivityThread#handleResumeActivity

final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        ActivityClientRecord r = mActivities.get(token);
        //...
        
        r = performResumeActivity(token, clearHide, reason);    //调用onResume

        if (r != null) {
            final Activity a = r.activity;

            //...
            
            if (r.window == null && !a.mFinished && willBeVisible) {
                r.window = r.activity.getWindow();
                View decor = r.window.getDecorView();       //得到DecorView
                decor.setVisibility(View.INVISIBLE);
                ViewManager wm = a.getWindowManager();
                WindowManager.LayoutParams l = r.window.getAttributes();

                //...
        
                if (a.mVisibleFromClient && !a.mWindowAdded) {
                    //由于WindowManager的实现类是WindowManagerImpl，所以实际
                    //调用的是WindowManagerImpl的addView方法
                    wm.addView(decor, l);   
                }

            } 
            
            //...
        }
    }

继续看WindowManagerImpl的addView方法：

WindowManagerImpl#addView

    @Override
    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        //mGlobal是一个WindowManagerGlobal对象
        mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
    }

继续看WindowManagerGlobal的addView方法：

WindowManagerGlobal#addView

    public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
        //...

        ViewRootImpl root;

        synchronized (mLock) {
            //...

            root = new ViewRootImpl(view.getContext(), display);    

            view.setLayoutParams(wparams);

            mViews.add(view);
            mRoots.add(root);
            mParams.add(wparams);

            try {
                root.setView(view, wparams, panelParentView);
            } 
            //...
        }
    }

通过ViewRootImpl的setView方法，ViewRootImpl和DecorView建立联系，并将DecorView加载到Window中。

小结

在Activity创建过程中，在onCreate中通过setContentView方法可以完成DecorView的创建。之后在调用完onResume后，需要将DecorView加载到Window中。这个过程需要ViewRootImpl的帮助，ViewRootImpl是连接WindowManager和DecorView的桥梁。通过ViewRootImpl的setView方法，ViewRootImpl和DecorView建立联系，并将DecorView加载到Window中。

开始View的工作流程

通过ViewRootImpl的performTraversals方法开始View的工作流程

ViewRootImpl#performTraversals

    private void performTraversals() {

        //...
    
                if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth()
                        || mHeight != host.getMeasuredHeight() || contentInsetsChanged ||
                        updatedConfiguration) {

                    //调用DecorView的measure方法
                    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

                    boolean measureAgain = false;

                    if (lp.horizontalWeight > 0.0f) {
                        measureAgain = true;
                    }
                    if (lp.verticalWeight > 0.0f) {
                        measureAgain = true;
                    }

                    //需要重新measure
                    if (measureAgain) {
                        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                    }

                }                    

        //...
    
        if (didLayout) {
            //调用DecorView的layout方法
            performLayout(lp, mWidth, mHeight);

            //...
        }

        //...

        if (!cancelDraw && !newSurface) {
            //...

            //调用View的draw方法
            performDraw();
        } 
        
        //...
    }

可以看到，在performTraversals方法中，ViewRootImpl先后执行了performMeasure、performLayout和performDraw方法，这三个方法分别调用了顶级View的measure、layout和draw方法。

measure过程

measure过程要分情况来看，如果是一个View，那么通过measure方法就完成了测量。如果是一个ViewGroup，那么除了完成自己的测量外，还要遍历所有子元素并调用其measure方法。

View的measure过程

View#measure

View的measure过程由其measure方法开始：

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
        //...

        if (forceLayout || needsLayout) {
            //...
            
            if (cacheIndex < 0 || sIgnoreMeasureCache) {
                onMeasure(widthMeasureSpec, heightMeasureSpec);
            }

            //...
        }

        //...
    }

可以看到，measure是一个final方法，意味着子类不能重写该方法。measure方法继续调用onMeasure方法：

View#onMeasure

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

其中，setMeasuredDimension方法设置View宽高的测量值，getDefaultSize方法得到宽高的测量值。来看下getDefaultSize方法：

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

该方法根据传入的MeasureSpec的SpecMode来确定，AT_MOST和EXACTLY模式返回的值都是MeasureSpec的SpecSize。所以一般来说SpecSize就是测量后的大小。

至于UNSPECIFIED模式，一般是用于系统内部的测量过程。这种情况下宽高的测量值是由getSuggestedMinimumWidth和getSuggestedMinimumHeigh方法决定的。两个方法同理，这里只分析下getSuggestedMinimumWidth方法：

View#getSuggestedMinimumWidth

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

其中mMinWidth对应于android:minWidth属性指定的值，如果没有指定该属性，mMinWidth默认为0。mBackground.getMinimumWidth()返回的是背景Drawable的原始宽度。

所以该方法的逻辑是：如果没有设置背景，则返回minWidth属性对应的值。否则返回minWidth属性对应的值和背景Drawable的原始宽度中的较大值。

小结

View的measure过程从measure方法开始，调用onMeasure方法确定测量宽高。测量宽高的确定取决于宽高的MeasureSpec。如果SpecMode为AT_MOST或EXACTIY，测量大小为SpecSize。如果SpecMode为UNSPECIFIED，需要判断有无背景，如果没有设置背景，测量大小为minWidth属性对应的值；否则测量大小为minWidth属性对应的值和背景Drawable的原始宽度中的较大值。但是UNSPECIFIED模式一般是用于系统内部的测量过程，所以我们平常使用的View的测量大小就是SpecSize。

注意

直接继承View的自定义控件需要重写onMeasure()方法，并设置wrap_content时的自身大小，否则在布局中使用wrap_content就相当于使用match_parent。

这是因为在当View使用wrap_content是，他的specMode是AT_MOST，而且View的specSize是parentSize,既父容器的当前剩余空间大小，这与match_parent一致。

如何解决这个问题？需要重写onMeasure方法，代码如下：

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);

    int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
    int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
    int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
    int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);

    if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
        setMeasuredDimension(mWidth, mHeight);
    } else if (widthSpecMode == MeasureSpec.AT_MOST) {
        setMeasuredDimension(mWidth, heightSpecSize);
    } else if (heightSpecMode == MeasureSpec.AT_MOST) {
        setMeasuredDimension(widthSpecSize, mHeight);
    }
}

我们只需要给View指定一个宽高（mWidth, mHeight），并在wrap_content时设置此宽高即可。至于这个宽高如何确定，需要根据View的类型灵活确定。对于非wrap_content的情形，我们仍使用系统的测量值。

ViewGroup的measure过程

ViewGroup#measureChildren

ViewGroup是一个抽象类，它并没有重写onMeasure方法，而是交由各个实现类来重写。但是它提供了一个measureChildren方法来测量每个子View，实现如下：

    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方法来测量单个子View

ViewGroup#measureChild

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

该方法先得到子View宽高的MeasureSpec，然后调用子View的measure方法进行测量

小结

ViewGrop本身是一个抽象类，其内部并没有重写View的onMeasure方法，但提供了一个measureChildren()方法来对每一个子元素进行measure。之所以没有重写onMeasure方法，是因为ViewGroup的子类具有各种不同的布局特性，所以测量方式不同，这需要子类自己重写onMeasure方法来定义测量规则。

注意

View的measure完成之后，通过getMeasuredWidth、getMeasuredHeight方法就可以获得View的测量宽高。需要注意的是，在某些极端情况下，系统可能要多次measure才能获得最终的测量宽高，这时在onMeasure方法获得的测量宽高可能是不准确的。一个比较好的习惯是在onLayout方法中去获取View的测量宽高。

layout过程

View#layout

由于ViewGroup也是调用父类View的layout方法，所有先从View的layout方法看起：

    public void layout(int l, int t, int r, int b) {
        //...

        //初始化四个顶点的值
        boolean changed = isLayoutModeOptical(mParent) ?
                setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);

        //如果视图的大小和位置发生变化，调用onLayout
        if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
            onLayout(changed, l, t, r, b);

            //...
        }

        //...
    }

该方法的步骤是：先初始化四个顶点的值，确定View在其父容器中的位置。如果发现View的大小和位置发生了变化，会继续调用onLayout方法确定子元素的位置。

View和ViewGroup都没有实现onLayout，而是交由具体的ViewGroup来实现。下面看下LinearLayout的onLayout方法：

LinearLayout#onLayout

    @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方法

LinearLayout#layoutVertical

    void layoutVertical(int left, int top, int right, int bottom) {
        //...

        final int count = getVirtualChildCount();

        //...

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

                //...
                
                //确定子元素的位置
                setChildFrame(child, childLeft, childTop + getLocationOffset(child),
                        childWidth, childHeight);
                        
                childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);

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

该方法遍历子元素，并通过setChildFrame方法确定子元素的位置

LinearLayout#setChildFrame

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

可以看出，setChildFrame方法又是调用子元素的layout方法来确定子元素的位置

小结

View只需确定自己四个顶点的位置即可确定自己的位置，而ViewGroup除了要确定自己的位置，如果发现自己的大小和位置发生了变化，还要调用onLayout重新确定子元素的位置。而在确定子元素位置的时候，又会调用其layout方法，直到所有的View都确定位置。

注意

在View的默认实现中，View的测量宽高和最终宽高是相等的，只不过测量宽高形成于View的measure过程，而最终宽高形成于View的layout过程。因此，一般情况下，我们可以认为View的测量宽高等于最终宽高，但是在某些特殊情况会导致两者不一样：

第一种情况如下：

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

上面重写了View的layout方法，将导致会View的最终宽高比测量宽高大100px，虽然这样做会导致View显示不正常并且也没有实际意义。

另一种情况是在某些情况，View需要多次measure才能确定自己的测量宽高，那么可能前几次得出的测量宽高和最终宽高不一致，但最终的测量宽高还是和最终宽高相同。

draw过程

View#draw

由于ViewGroup并没有重写draw方法，所以只需看View的draw方法即可：

   public void draw(Canvas canvas) {
        //...

        //绘制背景
        if (!dirtyOpaque) {
            drawBackground(canvas);
        }

        //...
        if (!verticalEdges && !horizontalEdges) {
          
            //绘制自己
            if (!dirtyOpaque) onDraw(canvas);   //View的onDraw方法是一个空方法，需要子类自己实现

            //绘制子元素
            dispatchDraw(canvas);   //在View中是一个空方法，ViewGroup重写了该方法

            //绘制装饰（foreground, scrollbars）
            onDrawForeground(canvas);

            //...
        }

        //...
    }

可以看出，View的绘制过程步骤如下：

1. 绘制背景：调用背景Drawable的draw方法
2. 绘制自己：调用onDraw方法，这是一个空方法，需要子类自己实现
3. 绘制子元素：调用dispatchDraw方法，该方法在View中是一个空方法，ViewGroup重写了该方法
4. 绘制装饰：调用onDrawForeground方法，绘制foreground, scrollbars等

注意

View有一个特殊的方法setWillNotDraw：

    /**
     * If this view doesn't do any drawing on its own, set this flag to
     * allow further optimizations. By default, this flag is not set on
     * View, but could be set on some View subclasses such as ViewGroup.
     *
     * Typically, if you override {@link #onDraw(android.graphics.Canvas)}
     * you should clear this flag.
     *
     * @param willNotDraw whether or not this View draw on its own
     */
    public void setWillNotDraw(boolean willNotDraw) {
        setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
    }

从注释可以看出，如果一个View不需要绘制任何内容，那么设置这个标志位为true后，系统会进行相应的优化。默认情况下，View没有启用这个标志位，但是ViewGroup会默认启用这个优化标志位。

这个标志位的意义是：当我们自定义的控件继承与ViewGroup并且自身不具备绘制功能（没有重写onDraw）时，就可以开启这个标志位从而便于系统进行后续的优化。相反，当我们需要重写ViewGroup的onDraw方法来绘制内容时，就需要显示地关闭这个标志位。

参考

• 《Android 开发艺术探索》
• 《Android 进阶之光》