从源码解析-Android中View的绘制流程及performTraversals方法

浅浅的花香味﹌ 2022-05-21 10:51 224阅读 0赞

[谈谈Activity的setContentView是怎么加载XML视图的][Activity_setContentView_XML]  
[谈谈Activity的View怎么与View绘制工具ViewRootImpl关联的][Activity_View_View_ViewRootImpl]  
在前面两篇文章中分析了View是如何跟绘制工具ViewRootImpl关联的，setContentView是如何把我们编写的xml视图添加到Activity中的，那今天就要分析下绘制工具ViewRootImpl是如何绘制我们Activity当中的View的。

**首先要了解View是什么：**

> View代表了用户界面组件的基本构建块。一个View在屏幕上占据一个矩形区域，并负责绘图和事件处理。View是窗口小部件的基类，它是用于创建交互式的用户界面组件（按钮，文本等）

从前面两篇文章可知

1.  Activity的attach方法会构造一个PhoneWindow实例
2.  我们在onCreate里通过setContentView将我们的xml添加到了DecorView
3.  ActivityThread在后续过程中会将DecorView添加到Activity的窗口中，也就是添加到PhoneWindow
4.  WindowManagerGlobal通过ViewRootImpl的setView方法将DecorView传递到ViewRootImpl进行绘制

我们来看下setView方法

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
         synchronized (this) {
             if (mView == null) {
                 mView = view;
                 ……
                 requestLayout();;
             }
         }
     }
     @Override
        public void requestLayout() {
            if (!mHandlingLayoutInLayoutRequest) {
                checkThread();
                mLayoutRequested = true;
                scheduleTraversals();
            }
        }
        void scheduleTraversals() {
            if (!mTraversalScheduled) {
                mTraversalScheduled = true;
                mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
                mChoreographer.postCallback(
                        Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
                if (!mUnbufferedInputDispatch) {
                    scheduleConsumeBatchedInput();
                }
                notifyRendererOfFramePending();
                pokeDrawLockIfNeeded();
            }
        }

可以看到这里post了一个mTraversalRunnable，我们看看这个runnable做了啥事

final class TraversalRunnable implements Runnable {
            @Override
            public void run() {
                doTraversal();
            }
        }
        final TraversalRunnable mTraversalRunnable = new TraversalRunnable();
        void doTraversal() {
            if (mTraversalScheduled) {
                mTraversalScheduled = false;
                mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
    
                if (mProfile) {
                    Debug.startMethodTracing("ViewAncestor");
                }
    
                performTraversals();
    
                if (mProfile) {
                    Debug.stopMethodTracing();
                    mProfile = false;
                }
            }
        }

终于找到View绘制的最终入口了，也就是这个方法**performTraversals()**

## performTraversals() ##

首先我们看这个方法名，**perform是执行的意思，而Traversals是遍历循环的意思**；所以这个方法看方法名就知道他是在遍历Activity的根布局DecorView里（或者其它窗口比如Dialog）的每一个View。

如果把Android中的View框架比作一个人，那我觉得这个方法就是人的心脏，非常重要。WMS的窗口属性变化，来自控件树的尺寸变化、重绘请求等都引发performTraversals()的调用，并在其中完成处理。View类及其子类中的\*\*onMeasure()、onLayout()以及onDraw()\*\*等回调也都是在performTraversals()的执行过程中直接或间接地引发。也正是如此，一次次的performTraversals()调用驱动着控件树有条不紊地工作着，一旦此方法无法正常执行，整个控件树都将处于僵死状态。

**performTraversals**方法可以说是我目前见到的Android源码中的几个最庞大的方法之一了，将近800行，如果你是第一次看这个肯定会迷糊的，没事，像我这样有时间看它个十几二十遍，你就会对它有个差不多的认识了。鉴于此方法太长，只能分段来看：

## 第一段： ##

//这个mView是通过setView方法传进来的,也就是Activity的根布局DecorView，使用final修饰，以防在遍历过程中被修改
            final View host = mView;
    
            if (DBG) {
                System.out.println("======================================");
                System.out.println("performTraversals");
                host.debug();
            }
            //mAdded在setView方法修改为true，表明Decorview已经添加到了PhoneWindow
            if (host == null || !mAdded)
                return;
            //是否正在遍历
            mIsInTraversal = true;
            //是否需要马上绘制
            mWillDrawSoon = true;
            //视图大小改变
            boolean windowSizeMayChange = false;
            //新视图
            boolean newSurface = false;
            //视图改变
            boolean surfaceChanged = false;
            WindowManager.LayoutParams lp = mWindowAttributes;
    
            //Activity窗口的宽度和高度
            int desiredWindowWidth;
            int desiredWindowHeight;
    		//DecorView是否可见
            final int viewVisibility = getHostVisibility();
            final boolean viewVisibilityChanged = !mFirst
                    && (mViewVisibility != viewVisibility || mNewSurfaceNeeded);
    
            WindowManager.LayoutParams params = null;
            if (mWindowAttributesChanged) {
                mWindowAttributesChanged = false;
                surfaceChanged = true;
                params = lp;
            }
            CompatibilityInfo compatibilityInfo =
                    mDisplay.getDisplayAdjustments().getCompatibilityInfo();
            if (compatibilityInfo.supportsScreen() == mLastInCompatMode) {
                params = lp;
                mFullRedrawNeeded = true;
                mLayoutRequested = true;
                if (mLastInCompatMode) {
                    params.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
                    mLastInCompatMode = false;
                } else {
                    params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
                    mLastInCompatMode = true;
                }
            }
    
            mWindowAttributesChangesFlag = 0;
    		//用来保存窗口宽度和高度，来自于全局变量mWinFrame，这个mWinFrame保存了窗口最新尺寸
            Rect frame = mWinFrame;
            //构造方法里mFirst赋值为true，意思是第一次执行遍历吗	
            if (mFirst) {
            	//是否需要重绘
                mFullRedrawNeeded = true;
                //是否需要重新确定Layout
                mLayoutRequested = true;
                //判断要绘制的窗口是否包含状态栏，有就去掉，然后确定要绘制的Decorview的高度和宽度
                if (shouldUseDisplaySize(lp)) {
                    // NOTE -- system code, won't try to do compat mode.
                    Point size = new Point();
                    mDisplay.getRealSize(size);
                    desiredWindowWidth = size.x;
                    desiredWindowHeight = size.y;
                } else {
                    //宽度和高度为整个屏幕的值
                    Configuration config = mContext.getResources().getConfiguration();
                    desiredWindowWidth = dipToPx(config.screenWidthDp);
                    desiredWindowHeight = dipToPx(config.screenHeightDp);
                }
    
                /**
                 * 因为第一次遍历，View树第一次显示到窗口
                 * 然后对mAttachinfo进行一些赋值
                 * AttachInfo是View类中的静态内部类AttachInfo类的对象
                 * 它主要储存一组当View attach到它的父Window的时候视图信息
                 */
                mAttachInfo.mUse32BitDrawingCache = true;//使用32位绘图缓存
                mAttachInfo.mHasWindowFocus = false;//视图窗口当前不具有焦点。
                mAttachInfo.mWindowVisibility = viewVisibility;//当前窗口不可见
                mAttachInfo.mRecomputeGlobalAttributes = false;//ViewAncestor应在下次执行遍历时触发全局布局更改
                mLastSystemUiVisibility = mAttachInfo.mSystemUiVisibility;
                // 如果之前未设置布局方向，则设置布局方向（View.LAYOUT_DIRECTION_INHERIT 是默认值）
                if (mViewLayoutDirectionInitial == View.LAYOUT_DIRECTION_INHERIT) {
                    host.setLayoutDirection(mLastConfiguration.getLayoutDirection());
                }
                host.dispatchAttachedToWindow(mAttachInfo, 0);
                mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange(true);
                dispatchApplyInsets(host);
                //Log.i(mTag, "Screen on initialized: " + attachInfo.mKeepScreenOn);
    
            } else {
             		//如果不是第一次进来这个方法，它的当前宽度和高度就从之前的mWinFrame获取
                desiredWindowWidth = frame.width();
                desiredWindowHeight = frame.height();
                /**
                 * mWidth和mHeight是由WindowManagerService服务计算出的窗口大小，
                 * 如果这次测量的窗口大小与这两个值不同，说明WMS单方面改变了窗口的尺寸
                 */
                if (desiredWindowWidth != mWidth || desiredWindowHeight != mHeight) {
                    if (DEBUG_ORIENTATION) Log.v(mTag, "View " + host + " resized to: " + frame);
                    //需要进行完整的重绘以适应新的窗口尺寸
                    mFullRedrawNeeded = true;
                    //需要对控件树进行重新布局
                    mLayoutRequested = true;
                    //window窗口大小改变
                    windowSizeMayChange = true;
                }
            }
           
    		//如果窗口可见性变了，进行判断
            if (viewVisibilityChanged) {
                mAttachInfo.mWindowVisibility = viewVisibility;
                host.dispatchWindowVisibilityChanged(viewVisibility);
                host.dispatchVisibilityAggregated(viewVisibility == View.VISIBLE);
                if (viewVisibility != View.VISIBLE || mNewSurfaceNeeded) {
                	//不可见就结束调整大小事件，释放相关硬件资源
                    endDragResizing();
                    destroyHardwareResources();
                }
                //如果窗口不可见，就修改标志位
                if (viewVisibility == View.GONE) {
                    // After making a window gone, we will count it as being
                    // shown for the first time the next time it gets focus.
                    mHasHadWindowFocus = false;
                }
            }
    
            // 如果窗口不可见了，去掉可访问性焦点
            if (mAttachInfo.mWindowVisibility != View.VISIBLE) {
                host.clearAccessibilityFocus();
            }
    
            /**
             * 执行HandlerActionQueue中HandlerAction数组保存的Runnable
             * 我们平时会通过View.post()或View.postDelayed()方法将一个Runnable对象发送到主线程执行
             * 其实就是通过这个mHandler去执行
             * public void executeActions(Handler handler) {
                 synchronized (this) {
                     final HandlerAction[] actions = mActions;
                     for (int i = 0, count = mCount; i < count; i++) {
                         final HandlerAction handlerAction = actions[i];
                         handler.postDelayed(handlerAction.action, handlerAction.delay);
                     }
                     mActions = null;
                     mCount = 0;
                 }
               }
             */
            getRunQueue().executeActions(mAttachInfo.mHandler);
    
            boolean insetsChanged = false;
    
            boolean layoutRequested = mLayoutRequested && (!mStopped || mReportNextDraw);
            //进行预测量
            if (layoutRequested) {
    
                final Resources res = mView.getContext().getResources();
    
                if (mFirst) {
                    // 视图窗口当前是否处于触摸模式。
                    mAttachInfo.mInTouchMode = !mAddedTouchMode;
                    //确保这个Window的触摸模式已经被设置
                    ensureTouchModeLocally(mAddedTouchMode);
                } else {
                		/**
                     * 判断一下几个insects的值和上一次相比有没有什么变化，不同的话就改变insetsChanged
                     * mOverscanInsets 记录屏幕中的 overscan 区域               见贴图中相应描述区域
                     * mContentInsets  记录了屏幕中的控件在布局时必须预留的空间   见贴图中相应描述区域
                     * mStableInsets   记录了Stable区域，比mContentInsets区域大  见贴图中相应描述区域
                     * mVisibleInsets  记录了被遮挡的区域，如正在进行输入的TextView等不被遮挡，这样VisibleInsets的变化并不会导致重新布局，
                     *                 所以这里仅仅是将VisibleInsets保存到mAttachInfo中，以便绘制时使用
                     */
                    if (!mPendingOverscanInsets.equals(mAttachInfo.mOverscanInsets)) {
                        insetsChanged = true;
                    }
                    if (!mPendingContentInsets.equals(mAttachInfo.mContentInsets)) {
                        insetsChanged = true;
                    }
                    if (!mPendingStableInsets.equals(mAttachInfo.mStableInsets)) {
                        insetsChanged = true;
                    }
                    if (!mPendingVisibleInsets.equals(mAttachInfo.mVisibleInsets)) {
                        mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
                        if (DEBUG_LAYOUT) Log.v(mTag, "Visible insets changing to: "
                                + mAttachInfo.mVisibleInsets);
                    }
                    if (!mPendingOutsets.equals(mAttachInfo.mOutsets)) {
                        insetsChanged = true;
                    }
                    if (mPendingAlwaysConsumeNavBar != mAttachInfo.mAlwaysConsumeNavBar) {
                        insetsChanged = true;
                    }
                     /**
                     * 如果当前窗口的根布局的width或height被指定为WRAP_CONTENT时，
                     * 比如Dialog，那我们还是给它尽量大的长宽，这里是将屏幕长宽赋值给它
                     */
                    if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT
                            || lp.height == ViewGroup.LayoutParams.WRAP_CONTENT) {
                        windowSizeMayChange = true;
     					//判断要绘制的窗口是否包含状态栏，有就去掉，然后确定要绘制的Decorview的高度和宽度
                        if (shouldUseDisplaySize(lp)) {
                            // NOTE -- system code, won't try to do compat mode.
                            Point size = new Point();
                            mDisplay.getRealSize(size);
                            desiredWindowWidth = size.x;
                            desiredWindowHeight = size.y;
                        } else {
                            Configuration config = res.getConfiguration();
                            desiredWindowWidth = dipToPx(config.screenWidthDp);
                            desiredWindowHeight = dipToPx(config.screenHeightDp);
                        }
                    }
                }
    
                // 进行预测量窗口大小，以达到更好的显示大小
                windowSizeMayChange |= measureHierarchy(host, lp, res,
                        desiredWindowWidth, desiredWindowHeight);
            }

![这里写图片描述][700]

到这里主要计算出控件树为显示其内容所需的尺寸，即期望的窗口尺寸。

**注意：**

通过上面的代码可以看到desiredWindowWidth和desiredWindowHeight是经过一系列代码考核得到的值，讲道理整个View树是可以按照这个值去测量的，但是我们不仅只是测量和布局，还要尽可能舒适的一个UI去展示给用户

比如在大屏幕上，Dialog的width修饰为WRAP\_CONTENT，按照上面的代码，其实desiredWindowWidth还是给了尽量大的值，就是屏幕宽度；但是Dialog可能就是为了显示几个字，那结果就是整个dialog的布局就被拉伸铺满屏幕；显然这种UI是不美丽的，那就需要通过measureHierarchy方法去优化，尝试下更小的宽度是否合适。就这样来到了measureHierarchy方法。

## measureHierarchy ##

private boolean measureHierarchy(final View host, final WindowManager.LayoutParams lp,
                final Resources res, final int desiredWindowWidth, final int desiredWindowHeight) {
            //用于描述宽度的MeasureSpec
            int childWidthMeasureSpec;
            //用于描述高度的MeasureSpec
            int childHeightMeasureSpec;
            //表示测量结果是否可能导致窗口的尺寸发生变化
            boolean windowSizeMayChange = false;
    
            if (DEBUG_ORIENTATION || DEBUG_LAYOUT) Log.v(mTag,
                    "Measuring " + host + " in display " + desiredWindowWidth
                    + "x" + desiredWindowHeight + "...");
            //表示测量是否能满足控件树充分显示内容的要求
            boolean goodMeasure = false;
            //其实测量协商仅仅发生在width被指定为WRAP_CONTENT情况
            if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT) {
                // 进入到这里就让窗口的大小不以屏幕大小去布局，而是给一个固定的值看看是否合适
                final DisplayMetrics packageMetrics = res.getDisplayMetrics();
                res.getValue(com.android.internal.R.dimen.config_prefDialogWidth, mTmpValue, true);
                int baseSize = 0;
                if (mTmpValue.type == TypedValue.TYPE_DIMENSION) {
                    //取出一个固定值来用，来自于config_prefDialogWidth
                    baseSize = (int)mTmpValue.getDimension(packageMetrics);
                }
                if (DEBUG_DIALOG) Log.v(mTag, "Window " + mView + ": baseSize=" + baseSize
                        + ", desiredWindowWidth=" + desiredWindowWidth);
    
                //假设上面config_prefDialogWidth值是320dp
                if (baseSize != 0 && desiredWindowWidth > baseSize) {
                    //使用getRootMeasureSpec()函数组合SPEC_MODE与SPEC_SIZE为一个MeasureSpec
                    childWidthMeasureSpec = getRootMeasureSpec(baseSize, lp.width);
                    childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
                    //第一次测量
                    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    
                    if (DEBUG_DIALOG) Log.v(mTag, "Window " + mView + ": measured ("
                            + host.getMeasuredWidth() + "," + host.getMeasuredHeight()
                            + ") from width spec: " + MeasureSpec.toString(childWidthMeasureSpec)
                            + " and height spec: " + MeasureSpec.toString(childHeightMeasureSpec));
    
                    /**
                     * 控件树的测量结果可以通过mView的getmeasuredWidthAndState()方法获取。
                     * 如果控件树对这个测量结果不满意，则会在返回值中添加MEASURED_STATE_TOO_SMALL位
                     */
                    if ((host.getMeasuredWidthAndState()&View.MEASURED_STATE_TOO_SMALL) == 0) {
                        goodMeasure = true;
                    } else {
                        /**
                         * 走到这里说明上面的尺寸不适合View树
                         * 需要对宽度再进行放松，使用上面的预期值与最大值的平均值作为新的宽度
                         */
                        baseSize = (baseSize+desiredWindowWidth)/2;
                        if (DEBUG_DIALOG) Log.v(mTag, "Window " + mView + ": next baseSize="
                                + baseSize);
                        //重新获取MeasureSpec
                        childWidthMeasureSpec = getRootMeasureSpec(baseSize, lp.width);
                        //第二次测量
                        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                        if (DEBUG_DIALOG) Log.v(mTag, "Window " + mView + ": measured ("
                                + host.getMeasuredWidth() + "," + host.getMeasuredHeight() + ")");
                        //再次判断View树对新的结果是否满意
                        if ((host.getMeasuredWidthAndState()&View.MEASURED_STATE_TOO_SMALL) == 0) {
                            if (DEBUG_DIALOG) Log.v(mTag, "Good!");
                            goodMeasure = true;
                        }
                    }
                }
            }
    
            /**
             * 如果上面两次尝试测量结果，View树都不满意
             * 那老哥也没办法了，做不了优化了，只能以屏幕宽高去给View树测量了
             * 这是第三次也是最后一次测量了
             */
            if (!goodMeasure) {
                childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
                childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
                performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                //如果测量得出的结果与当前窗口值不一样，就需要调整窗口大小了
                if (mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight()) {
                    windowSizeMayChange = true;
                }
            }
    
            if (DBG) {
                System.out.println("======================================");
                System.out.println("performTraversals -- after measure");
                host.debug();
            }
    
            return windowSizeMayChange;
        }

这里不属于三大流程，只是一个确定显示窗口的大小。

可以看到这个方法进行了两次优化处理，如果两次优化处理还是不满意，就使用给定的desiredWindowWidth/desiredWindowHeight进行测量；这里也表明了一点，performMeasure方法可能会被调用多次，那onMeasure()方法同样会被回调多次，这样我们在自定义View的时候，就不要在这个回调方法里做过多的new内存操作。

注意到方法里会调用到**getRootMeasureSpec**这么一个方法，说到这个方法就得先谈下**MeasureSpec**这个类，它是View类的一个静态内部类：

*  MeasureSpec封装了从父级传递给子级的布局要求
 *  每个MeasureSpec代表宽度或高度的要求
 *  MeasureSpec由大小和模式组成。 有三种可能
    
    **1.UNSPECIFIED** ：父View没有对子View做任何限制，子View可以是自己想要的尺寸；像我们平时在xml中写View的时候没有设置宽高，这种情况比较少见。它的值是0 << 30 = 0  
    **2.EXACTLY**：父View决定了子View确切大小，子View将被限定在给定的边界里；像xml中子view如果是填充父窗体(match\_parent)或者确定大小，说明父View已经明确知道子控件想要多大的尺寸了。它的值是1 << 30 = 1073741824  
    **3.AT\_MOST**：子View可以是它所期望的尺寸，但是不能大于specSize；在布局设置wrap\_content，父控件并不知道子控件到底需要多大尺寸（具体值）， 需要子控件在measure测量之后再让父控件给他一个尽可能大的尺寸以便让内容全部显示；如果在onMeasure没有指定控件大小，默认会填充父窗体，因为在view的measure源码中， AT\_MOST（相当于wrap\_content ）和EXACTLY （相当于match\_parent ）两种情况返回的测量宽高都是specSize， 而这个specSize正是父控件剩余的宽高，所以默认measure方法中wrap\_content 和match\_parent 的效果是一样的，都是填充剩余的空间。它的值是2 << 30 = -2147483648

所以这个类是SPEC\_SIZE和SPEC\_MODE的组合，结构如下

**SPEC\_MODE(32,31) - SPEC\_SIZE(30,…,1)**

也就是高两位表示模式（在父View中是如何定义的），低30位表示大小（父View的建议尺寸）

再来看下performMeasure方法，它有两个参数，一个是包含View的宽度度量规范，一个是包含View的高度度量规范，然后根据这两个宽高的度量规范去测量View所需的大小；那这两个信息怎么来呢，就是通过getRootMeasureSpec获取，这个方法会调用MeasureSpec类的makeMeasureSpec方法，根据给定的大小和模式返回一个度量规范

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

既然宽高的度量规范出来了，那就开始测量了，调用performMeasure方法

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

这里会直接调用View的measure方法

## measure ##

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
    
            //判断当前View是否是以可见边界布局的ViewGroup
            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);
            }
    
            // Suppress sign extension for the low bytes
            long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;
            if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);
    
            final boolean forceLayout = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;
    
            // Optimize layout by avoiding an extra EXACTLY pass when the view is
            // already measured as the correct size. In API 23 and below, this
            // extra pass is required to make LinearLayout re-distribute weight.
            final boolean specChanged = widthMeasureSpec != mOldWidthMeasureSpec
                    || heightMeasureSpec != mOldHeightMeasureSpec;
            final boolean isSpecExactly = MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY
                    && MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY;
            final boolean matchesSpecSize = getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec)
                    && getMeasuredHeight() == MeasureSpec.getSize(heightMeasureSpec);
            final boolean needsLayout = specChanged
                    && (sAlwaysRemeasureExactly || !isSpecExactly || !matchesSpecSize);
    
            if (forceLayout || needsLayout) {
                // 先清除测量尺寸标记
                // PFLAG_MEASURED_DIMENSION_SET标记用于检查控件在onMeasure()方法中是否通过
                //调用setMeasuredDimension()将测量结果存储下来
                mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
                //解析所有与RTL相关的属性，比如背景，字体，padding等属性设置
                resolveRtlPropertiesIfNeeded();
    
                int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);
                if (cacheIndex < 0 || sIgnoreMeasureCache) {
                    //对自己进行测量， 每个View子类都需要重写这个方法以便正确地对自身进行测量
                    onMeasure(widthMeasureSpec, heightMeasureSpec);
                    mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
                } else {
                    long value = mMeasureCache.valueAt(cacheIndex);
                    // Casting a long to int drops the high 32 bits, no mask needed
                    setMeasuredDimensionRaw((int) (value >> 32), (int) value);
                    mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
                }
    
                /**
                 * 检查View子类的onMeasure()是否调用了setMeasuredDimension()
                 * setMeasuredDimension()会将PFLAG_MEASURED_DIMENSION_SET标记重新加入mPrivateFlags中。
                 * 之所以做这样的检查，是由于onMeasure()的实现可能由开发者完成，
                 * 而在Android看来，开发者是不可信的
                 */
                if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
                    throw new IllegalStateException("View with id " + getId() + ": "
                            + getClass().getName() + "#onMeasure() did not set the"
                            + " measured dimension by calling"
                            + " setMeasuredDimension()");
                }
    
                mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
            }
            //记录父控件给予的MeasureSpec，用以检查之后的测量操作是否有必要进行
            mOldWidthMeasureSpec = widthMeasureSpec;
            mOldHeightMeasureSpec = heightMeasureSpec;
    
            mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
                    (long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
        }

可以看到其实这个方法并没有做任何的测量工作，真正的测量过程交给了**onMeasure**方法去做，它的作用在于引发onMeasure()的调用，并对onMeasure()行为的正确性进行检查。另外，在控件系统看来，一旦控件执行了测量操作，那么随后必须进行布局操作，因此在完成测量之后，将PFLAG\_LAYOUT\_REQUIRED标记加入mPrivateFlags，以便View.layout()方法可以顺利进行

## onMeasure ##

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

可以看到这个方法实现很简单，只调用了setMeasuredDimension()方法保存测量结果，具体的实现由子类去重写，提供更加合理、高效的实现

## setMeasuredDimension ##

必须通过onMeasure调用此方法来存储测量的宽度和测量的高度。  
如果不这样做，将在测量时触发异常

protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
            boolean optical = isLayoutModeOptical(this);
            if (optical != isLayoutModeOptical(mParent)) {
                Insets insets = getOpticalInsets();
                int opticalWidth  = insets.left + insets.right;
                int opticalHeight = insets.top  + insets.bottom;
    
                measuredWidth  += optical ? opticalWidth  : -opticalWidth;
                measuredHeight += optical ? opticalHeight : -opticalHeight;
            }
            setMeasuredDimensionRaw(measuredWidth, measuredHeight);
        }
        private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
            //保存测量的宽度
            mMeasuredWidth = measuredWidth;
            //保存测量的高度
            mMeasuredHeight = measuredHeight;
            //向mPrivateFlags中添加PFALG_MEASURED_DIMENSION_SET，以此证明onMeasure()保存了测量结果
            mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
        }

其实这里的逻辑就是我们自定义View的时候，重写onMeasure方法，我们自己实现测量过程，测量结束后然后调用setMeasuredDimension方法将测量结果传入进行保存。  
两个测量结果可以通过getMeasuredWidthAndState()与getMeasuredHeightAndState()两个方法获得。测量结果不仅仅是一个尺寸，而是一个测量状态与尺寸的复合整型值。其低30位表示了测量结果的尺寸，而高两位则表示了控件对测量结果是否满意，即父控件给予的MeasureSpec是否可以使得子控件完整地显示其内容。当控件对测量结果满意时，直接将尺寸传递给setMeasuredDimension()即可，注意要保证高两位为0。倘若对测量结果不满意，则使用View.MEASURED\_STATE\_TOO\_SMALL | measuredSize 作为参数传递给setMeasuredDimension()以告知父控件对MeasureSpec进行可能的调整。回看measureHierarchy方法能看到调用getMeasuredWidthAndState，来判断是否对测量结果是否满意。

执行完**measureHierarchy**方法后，ViewRootImpl就知道了View树需要的大小，并同时修改windowSizeMayChange的值，它的表示有可能需要改变窗口大小以适应View树的大小要求，接下来的一段代码就正式确定是否需要改变窗口大小

/**
             * 用于确定是否需要更改窗口大小用来适用View树的空间要求
             * layoutRequested 为true，说明view正在调用自身的requestLayout，自身内容变化要求重新布局，
             * 随后此方法会沿着控件树向根部回溯，最终调用到ViewRootImp.requestLayout()
             * windowSizeMayChange 为true ，它有多处赋值，说明View树所需大小与窗口大小不一致
             * (mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight() 判断上面测量后View树的大小与窗口大小值是否相等
             * 最后的条件是如果窗口width或height被设置成WRAP_CONTENT，计算出来的窗口大小desiredWindowWidth/desiredWindowHeight 与上一次测量保存的frame.width()/frame.height()
             * 同时与WindowManagerService服务计算的宽度mWidth和高度mHeight也不一致，那也说明窗口大小变化了
             */
            boolean windowShouldResize = layoutRequested && windowSizeMayChange
                && ((mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight())
                    || (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT &&
                            frame.width() < desiredWindowWidth && frame.width() != mWidth)
                    || (lp.height == ViewGroup.LayoutParams.WRAP_CONTENT &&
                            frame.height() < desiredWindowHeight && frame.height() != mHeight));
    
            windowShouldResize |= mDragResizing && mResizeMode == RESIZE_MODE_FREEFORM;
    
            // If the activity was just relaunched, it might have unfrozen the task bounds (while
            // relaunching), so we need to force a call into window manager to pick up the latest
            // bounds.
            //如果Activity重新启动，需要强制通过wms获取最新的值
            windowShouldResize |= mActivityRelaunched;

## 第二阶段 ##

/**
             * 开始进入三大阶段的第一个阶段了 6个条件只要满足一个就进入
             * mFirst true 说明是第一次执行测量布局绘制操作
             * windowShouldResize true 即Activity窗口大小需要改变
             * insetsChanged true 说明此次窗口overscan等一些边衬区域发生了改变，与上次不一样
             * viewVisibilityChanged 说明View的可见性发生了变化
             * params 即窗口属性发生了变化，指向了mWindowAttributes
             * mForceNextWindowRelayout true 即ViewRootHandler接收到消息MSG_RESIZED_REPORT，即size改变了
             */
            final boolean isViewVisible = viewVisibility == View.VISIBLE;
            if (mFirst || windowShouldResize || insetsChanged ||
                    viewVisibilityChanged || params != null || mForceNextWindowRelayout) {
                mForceNextWindowRelayout = false;
    
                ......
                ......
    
                try {
    
                    //请求WMS计算Activity窗口大小及边衬区域大小
                    relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
    
                    ......
                		......
    
                    /**
                     * mPendingOverscanInsets等rect在relayoutWindow方法里保存了最新窗口大小值
                     * 再与上一次测量的保存在mAttachInfo中的值进行比较
                     */
                    final boolean overscanInsetsChanged = !mPendingOverscanInsets.equals(
                            mAttachInfo.mOverscanInsets);
                    boolean contentInsetsChanged = !mPendingContentInsets.equals(
                            mAttachInfo.mContentInsets);
                    final boolean visibleInsetsChanged = !mPendingVisibleInsets.equals(
                            mAttachInfo.mVisibleInsets);
                    final boolean stableInsetsChanged = !mPendingStableInsets.equals(
                            mAttachInfo.mStableInsets);
                    final boolean outsetsChanged = !mPendingOutsets.equals(mAttachInfo.mOutsets);
                    final boolean surfaceSizeChanged = (relayoutResult
                            & WindowManagerGlobal.RELAYOUT_RES_SURFACE_RESIZED) != 0;
                    final boolean alwaysConsumeNavBarChanged =
                            mPendingAlwaysConsumeNavBar != mAttachInfo.mAlwaysConsumeNavBar;
                    //如果改变了，就重新将最新值保存在mAttachInfo中
                    if (contentInsetsChanged) {
                        mAttachInfo.mContentInsets.set(mPendingContentInsets);
                        if (DEBUG_LAYOUT) Log.v(mTag, "Content insets changing to: "
                                + mAttachInfo.mContentInsets);
                    }
                    if (overscanInsetsChanged) {
                        mAttachInfo.mOverscanInsets.set(mPendingOverscanInsets);
                        if (DEBUG_LAYOUT) Log.v(mTag, "Overscan insets changing to: "
                                + mAttachInfo.mOverscanInsets);
                        // Need to relayout with content insets.
                        contentInsetsChanged = true;
                    }
                    if (stableInsetsChanged) {
                        mAttachInfo.mStableInsets.set(mPendingStableInsets);
                        if (DEBUG_LAYOUT) Log.v(mTag, "Decor insets changing to: "
                                + mAttachInfo.mStableInsets);
                        // Need to relayout with content insets.
                        contentInsetsChanged = true;
                    }
                    if (alwaysConsumeNavBarChanged) {
                        mAttachInfo.mAlwaysConsumeNavBar = mPendingAlwaysConsumeNavBar;
                        contentInsetsChanged = true;
                    }
                    if (contentInsetsChanged || mLastSystemUiVisibility !=
                            mAttachInfo.mSystemUiVisibility || mApplyInsetsRequested
                            || mLastOverscanRequested != mAttachInfo.mOverscanRequested
                            || outsetsChanged) {
                        mLastSystemUiVisibility = mAttachInfo.mSystemUiVisibility;
                        mLastOverscanRequested = mAttachInfo.mOverscanRequested;
                        mAttachInfo.mOutsets.set(mPendingOutsets);
                        mApplyInsetsRequested = false;
                        dispatchApplyInsets(host);
                    }
                    if (visibleInsetsChanged) {
                        mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
                        if (DEBUG_LAYOUT) Log.v(mTag, "Visible insets changing to: "
                                + mAttachInfo.mVisibleInsets);
                    }
    
                    ......
                		......
    
                // !!FIXME!! This next section handles the case where we did not get the
                // window size we asked for. We should avoid this by getting a maximum size from
                // the window session beforehand.
                //从window session获取最大size作为当前窗口大小
                if (mWidth != frame.width() || mHeight != frame.height()) {
                    mWidth = frame.width();
                    mHeight = frame.height();
                }
    
                ......
                ......
    
                /**
                 * mStopped true 说明当前窗口的所有者 比如activity处于暂停状态
                 * mReportNextDraw true 即ViewRootHandler接收到消息MSG_RESIZED_REPORT ，需要绘制
                 */
                if (!mStopped || mReportNextDraw) {
    
                    //确定当前窗口处于触摸模式，也就是获取焦点
                    boolean focusChangedDueToTouchMode = ensureTouchModeLocally(
                            (relayoutResult&WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE) != 0);
    
                    if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth()
                            || mHeight != host.getMeasuredHeight() || framesChanged ||
                            updatedConfiguration) {
    
                        //获取宽高的度量规范
                        int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
                        int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
    
                        if (DEBUG_LAYOUT) Log.v(mTag, "Ooops, something changed!  mWidth="
                                + mWidth + " measuredWidth=" + host.getMeasuredWidth()
                                + " mHeight=" + mHeight
                                + " measuredHeight=" + host.getMeasuredHeight()
                                + " framesChanged=" + framesChanged);
    
                         // 执行测量操作
                        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    
                        // Implementation of weights from WindowManager.LayoutParams
                        // We just grow the dimensions as needed and re-measure if
                        // needs be
                        //获取测量后的View的真是宽度和高度
                        int width = host.getMeasuredWidth();
                        int height = host.getMeasuredHeight();
                        //是否需要重新测量标志
                        boolean measureAgain = false;
                        //如果测量出来的水平宽度需要拉伸 需要重新测量
                        if (lp.horizontalWeight > 0.0f) {
                            width += (int) ((mWidth - width) * lp.horizontalWeight);
                            childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width,
                                    MeasureSpec.EXACTLY);
                            measureAgain = true;
                        }
                        if (lp.verticalWeight > 0.0f) {
                            height += (int) ((mHeight - height) * lp.verticalWeight);
                            childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height,
                                    MeasureSpec.EXACTLY);
                            measureAgain = true;
                        }
                        //再次测量
                        if (measureAgain) {
                            if (DEBUG_LAYOUT) Log.v(mTag,
                                    "And hey let's measure once more: width=" + width
                                    + " height=" + height);
                            performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                        }
    
                        layoutRequested = true;
                    }
                }
            } else {
                // 判断窗口有没有移动，如果移动就执行移动动画
                maybeHandleWindowMove(frame);
            }

第二阶段也就是我们View绘制三大流程第一步了，具体测量代码分析在第一阶段已经分析了，就不在赘述

## 第三阶段 ##

//通过这几个值来确定是不是要重新布局
            final boolean didLayout = layoutRequested && (!mStopped || mReportNextDraw);
            boolean triggerGlobalLayoutListener = didLayout
                    || mAttachInfo.mRecomputeGlobalAttributes;
            if (didLayout) {
                performLayout(lp, mWidth, mHeight);
    
                // By this point all views have been sized and positioned
                // We can compute the transparent area
                //计算透明区域
                if ((host.mPrivateFlags & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) != 0) {
                    // start out transparent
                    // TODO: AVOID THAT CALL BY CACHING THE RESULT?
                    host.getLocationInWindow(mTmpLocation);
                    mTransparentRegion.set(mTmpLocation[0], mTmpLocation[1],
                            mTmpLocation[0] + host.mRight - host.mLeft,
                            mTmpLocation[1] + host.mBottom - host.mTop);
    
                    host.gatherTransparentRegion(mTransparentRegion);
                    if (mTranslator != null) {
                        mTranslator.translateRegionInWindowToScreen(mTransparentRegion);
                    }
    
                    if (!mTransparentRegion.equals(mPreviousTransparentRegion)) {
                        mPreviousTransparentRegion.set(mTransparentRegion);
                        mFullRedrawNeeded = true;
                        // reconfigure window manager
                        try {
                            mWindowSession.setTransparentRegion(mWindow, mTransparentRegion);
                        } catch (RemoteException e) {
                        }
                    }
                }  
    }

performLayout方法会调用View的layout方法，在layout方法中回调onLayout方法，开发者可以重写这个方法，这个具体分析与measure类似

## 第四阶段 ##

boolean cancelDraw = mAttachInfo.mTreeObserver.dispatchOnPreDraw() || !isViewVisible;
            //没有取消绘制 也没有重新创建Surface
            if (!cancelDraw && !newSurface) {
                //执行动画效果
                if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
                    for (int i = 0; i < mPendingTransitions.size(); ++i) {
                        mPendingTransitions.get(i).startChangingAnimations();
                    }
                    mPendingTransitions.clear();
                }
                //开始绘制
                performDraw();
            }

在View的Draw方法里绘制一个View分一下几步

*  drawBackground 绘制背景
 *  保存画布图层
 *  onDraw(canvas) 回调 绘制内容 由子类去实现
 *  dispatchDraw(canvas) 有子view 就绘制子view
 *  绘制淡入淡出效果并恢复图层
 *  onDrawForeground(canvas) 画装饰 比如前景色 滚动条

**在draw过程中有两个比较容易混淆的方法：**

*  invalidate()：view的invalidate会导致当前view被重绘,由于mLayoutRequested为false，不会导致onMeasure和onLayout被调用，而OnDraw会被调用
 *  requestLayout()：view的requestLayout会直接递归调用父窗口的requestLayout，直到ViewRootImpl,然后触发peformTraversals，由于mLayoutRequested为true，会导致onMeasure和onLayout被调用，不一定会触发OnDraw；requestLayout触发onDraw可能是因为在在layout过程中发现l,t,r,b和以前不一样，那就会触发一次invalidate，所以触发了onDraw

这里就谈下我们的Activity，Activity启动后，它的DecorView会被ViewRootImpl类的performTraversals方法去操作；

1.  首先就是performMeasure的过程，这个方法会调用到View类的measure方法，这里并没有具体的测量实现，而是调用到了onMeasure，需要子类去实现；要知道DecorView其实就是个FrameLayout，是一个ViewGroup，重写onMeasure方法，去循环遍历子View的measure过程；根据自己的MeasureSpec和子View的LayoutParams来决定子View的测量规格，根据获得的测量规格得到子view的宽高，然后一层一层向下遍历，子类也会重写onMeasure方法，测量自己的大小
2.  这样所有的View测量结束，第二步就是performLayout了，默认是调用到了View类layout方法；如果是ViewGroup，就调用ViewGroup的layout方法，但是这个方法没有具体实现，还是调用到了View类的layout方法；View类的layout方法回调onLayout方法，要怎么确定位置由子类重写onlayout方法实现；这里DecorView去重写，自己实现，循环调用每个子View的layout方法，将上下左右坐标值传递给子View，确定子View的位置
3.  接下来就是最后的绘制过程了，也就是第三步performDraw，继续走到ViewTreeObserver的dispatchOnDraw方法，通知所有注册了OnDrawListener接口的View去调用自己的onDraw()方法，绘制自己；DecorView因为是个ViewGroup，重写了dispatchDraw方法，循环调用每个子View的draw方法；最后就是每个子View重写onDraw方法绘制自身

[Activity_setContentView_XML]: https://blog.csdn.net/qq_30993595/article/details/80915131
[Activity_View_View_ViewRootImpl]: https://blog.csdn.net/qq_30993595/article/details/80927524
[700]: /images/20220521/df5c8af923b144d6aa8a29d1790af496.png