一步步带你解析View的工作原理(一)

前言

大三了。好久没有写博客了,之前学java时,一直将博客当做学习时的零散笔记本。而最近在看《安卓开发艺术探索》一书,想结合一些博客的阅读,对view的工作原理,进行一个梳理,总结。

这个总结系列分为两方面的内容:

1.介绍View的工作原理。

2.介绍自定义View的实现方式。

 

学习View的工作原理,是为了更好的理解自定义view做准备的,我们要学的内容有:View的三大流程、常见的回调方法、一些特殊的自定义view的冲突处理等等。

在介绍View的三大流程 【测量(measure)、布局(layout)、绘制(draw)】之前,先了解一些基本概念:

1.DecorView

2.ViewRoot (对应于ViewRootImpl类)(View的三大流程都是通过其完成)

3.MeasureSpec

 

1.DecorView与ViewRoot

DecorView是什么?

是Windows中的View的最顶层的view,下面的图能帮我们很好的理解:

一步步带你解析View的工作原理(一)_第1张图片

知识点在图中已经体现的非常直观,要说的就是一个小点:顶级View中包含一个LinearLayout,LinearLayout的下半部分即内容栏,我们在活动中通过setContentView所设置的布局文件其实就是加到此内容栏中的,因此也不能理解为Activity指定布局的方法叫setContentView。

DecorView和ViewRoot的关系?

书中原话说:“在ActivityThread中,当Activity对象被创建完毕后,会将DecorView添加到Windows中,同时会创建ViewRootImpl对象,并将ViewRootImpl和DecorView相关联。”

这是怎样一个过程呢?查阅源码ActivityThread的handleResumeActivity方法:

final void handleResumeActivity(IBinder token,
    boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason){
         ..........................
if (r.window == null && !a.mFinished && willBeVisible) {
                //获取当前活动的Window
                r.window = r.activity.getWindow();
                //获取DecorView对象
                View decor = r.window.getDecorView();
                //可见度设置
                decor.setVisibility(View.INVISIBLE);
                //获取windowmanager对象
                ViewManager wm = a.getWindowManager();
                WindowManager.LayoutParams l = r.window.getAttributes();
                a.mDecor = decor;
                l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
                l.softInputMode |= forwardBit;
                if (r.mPreserveWindow) {
                    a.mWindowAdded = true;
                    r.mPreserveWindow = false;
                    // Normally the ViewRoot sets up callbacks with the Activity
                    // in addView->ViewRootImpl#setView. If we are instead reusing
                    // the decor view we have to notify the view root that the
                    // callbacks may have changed.
                    ViewRootImpl impl = decor.getViewRootImpl();
                    if (impl != null) {
                        impl.notifyChildRebuilt();
                    }
                }
                if (a.mVisibleFromClient) {
                    if (!a.mWindowAdded) {
                        a.mWindowAdded = true; 
                        //将DecorView添加到Window中
                        wm.addView(decor, l);
                    }
                ..........................
}

可以看到,这个方法:

1.获取了DecorView对象 

2.将DecorViewt添加到Window中

我们继续跟踪addView方法:

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

        ............

        ViewRootImpl root;
        View panelParentView = null;

        ............

        //获得ViewRootImpl对象root
         root = new ViewRootImpl(view.getContext(), display);

        ...........

        // do this last because it fires off messages to start doing things
        try {
            //将传进来的参数DecorView设置到root中
            root.setView(view, wparams, panelParentView);
        } catch (RuntimeException e) {
          ...........
        }
    }

这个方法:

1.创建了VIewRootImpl对象

2.通过root的setView方法将顶层view设置到了root中。

我们通过继续的跟踪,可以发现:DecorView从ViewRootImpl的setview这个方法传入之后,会经过requestLayout()方法、scheduleTraversals()方法、doTraversal()方法,然后进入到performTraversals()方法。,而performTraversals()方法非常关键,它会依次调用performMeasure()方法,performLayout()方法,performDraw()方法对我们的DecorView进行测量、布局、绘制。这便是DecorView和ViewRootImpl之间的关系了。

介绍到这里,我们也可以清楚地了解到ViewRoot起的作用:View的绘制过程,是从ViewRoot的performTraversals方法开始的。有些同学会问:“你这只是一个DecorView,怎么就扩展到了所有的View呢?”

我们可以回头看看文章的第一个图:DecorView作为顶层视图,我们在xml内容布局中的添加的所有布局会解析成View树形结构添加到DecorView顶层视图中id为content的FrameLayout父容器上面,就是图里那个下半部分的框框。

所以,我们要理解:DecorView不是一个人光秃秃的跑进performTraversals()方法的,他是一个View树。简单说,DecorView作为老大哥,带了一大群小弟跑进performTraversals(),然后大家都通过测量、布局、绘制到我们的屏幕上了。

还有一个细节就是:既然这是一个View树,先让所有元素都经过measure、layout、draw。那就离不开递归,事实也正是如此:perforMeasure中会调用measure方法,在measure方法中又会调用onMeasure方法,在onMeasure方法中则会对所有的子元素进行measure过程,这时候measure流程就从父容器传到子元素当中了,接着子元素会重复父容器的measure过程。。。如此反复,完成遍历。另一个布局流程和绘制流程亦然。

好了,DecorView和ViewRootImpl就介绍到这里。接下来我们看看MeasureSpec。

 

2.MeasureSpec

字面上看,MeasureSpec就是“测量规格”,但我更喜欢将其理解为“测量约束+规格”

我们来看我们不断提到的performTraversals()方法:

private void performTraversals() {
        // cache mView since it is used so much below...
        //mView就是DecorView根布局
        final View host = mView;
        //成员变量mAdded之前赋值为true,因此条件不成立
        if (host == null || !mAdded)
            return;
        //是否正在遍历
        mIsInTraversal = true;
        //是否马上绘制View
        mWillDrawSoon = true;

        .............
        //顶层视图DecorView所需要窗口的宽度和高度
        int desiredWindowWidth;
        int desiredWindowHeight;

        .....................
        //在构造方法中mFirst已经设置为true,表示是否是第一次绘制DecorView
        if (mFirst) {
            mFullRedrawNeeded = true;
            mLayoutRequested = true;
         //如果窗口的类型是有状态栏的,那么顶层视图DecorView所需要窗口的宽度和高度就是除了状态栏
            if (lp.type == WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL
                    || lp.type == WindowManager.LayoutParams.TYPE_INPUT_METHOD) {
                // NOTE -- system code, won't try to do compat mode.
                Point size = new Point();
                mDisplay.getRealSize(size);
                desiredWindowWidth = size.x;
                desiredWindowHeight = size.y;
            } else {//否则顶层视图DecorView所需要窗口的宽度和高度就是整个屏幕的宽高
                DisplayMetrics packageMetrics =
                    mView.getContext().getResources().getDisplayMetrics();
                desiredWindowWidth = packageMetrics.widthPixels;
                desiredWindowHeight = packageMetrics.heightPixels;
            }
    }
............
//获得view宽高的测量规格,mWidth和mHeight表示窗口的宽高,lp.widthhe和lp.height表示DecorView根布局宽和高
 int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
 int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

  // Ask host how big it wants to be
  //执行测量操作
  performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

........................
//执行布局操作
 performLayout(lp, desiredWindowWidth, desiredWindowHeight);

.......................
//执行绘制操作
performDraw();

}

我们可以在倒数第三四五行(不算省略号和大括号!)可以清楚的看到:MeasureSpec参与了view的测量。

那么,我们先问一个问题,为什么要用到MeasureSpec?

我们知道,我们是可以给View设置LayoutParams的,但是,我们设置的LayoutParams如果不在父容器约束之下,那岂不是乱套了吗?简单说,就是父容器的大小是50,而你给他的小弟却设置了51,这怎么行呢?是吧?

其次,我们还要知道一点:只有View的MeasureSpec确定后,onMeasure中才可以确定view的测量宽/高。

那该如何确定某个View的MeasureSpec呢?

首先,我们要知道,MeasureSpec其实是一个32位int值,高两位代表SpecMode,低30位表示SpecSize。并且,它是由View的LayoutParams和这个View的父容器的MeasureSpec协商决定的。他们协商之后,会将LayoutParams在父容器的约束之下,转换成对应的MeasureSpec。

SpecMode有三类

1.UNSPECIFIED  随便模式

2.EXACTLY          具体值模式

3.AT_MOST         最大值模式

 

先拿DecorView来作例子:DecorView已经是顶级View了,那么它的父容器是什么呢?——窗口。

正如上面的代码:(我又截取到这了)

//如果窗口的类型是有状态栏的,那么顶层视图DecorView所需要窗口的宽度和高度就是除了状态栏
            if (lp.type == WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL
                    || lp.type == WindowManager.LayoutParams.TYPE_INPUT_METHOD) {
                // NOTE -- system code, won't try to do compat mode.
                Point size = new Point();
                mDisplay.getRealSize(size);
                desiredWindowWidth = size.x;
                desiredWindowHeight = size.y;
            } else {//否则顶层视图DecorView所需要窗口的宽度和高度就是整个屏幕的宽高
                DisplayMetrics packageMetrics =
                    mView.getContext().getResources().getDisplayMetrics();
                desiredWindowWidth = packageMetrics.widthPixels;
                desiredWindowHeight = packageMetrics.heightPixels;
            }
............
//获得view宽高的测量规格,mWidth和mHeight表示窗口的宽高,lp.widthhe和lp.height表示DecorView根布局宽和高
 int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
 int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

DecorView的MeasureSpec是由窗口和DecorView的宽高共同决定的。(他们都传入了getRootMeasureSpe方法)

那我们再跟踪getRootMeasureSpe方法:

 private static int getRootMeasureSpec(int windowSize, int rootDimension) {
        int measureSpec;
        switch (rootDimension) {
      //匹配父容器时,测量模式为MeasureSpec.EXACTLY,测量大小直接为屏幕的大小,也就是充满整个屏幕
        case ViewGroup.LayoutParams.MATCH_PARENT:
            // Window can't resize. Force root view to be windowSize.
            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
            break;


        //包裹内容时,测量模式为MeasureSpec.AT_MOST,测量大小直接为屏幕大小,也就是充满整个屏幕
        case ViewGroup.LayoutParams.WRAP_CONTENT:
            // Window can resize. Set max size for root view.
            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
            break;


        //其他情况时,测量模式为MeasureSpec.EXACTLY,测量大小为DecorView顶层视图布局设置的大小。
        default:
            // Window wants to be an exact size. Force root view to be that size.
            measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
            break;
        }
        return measureSpec;
    }

好了,通过以上代码,DecorView的MeasureSpec的产生过程就非常清晰了。

对于普通View来说,View的measure过程由ViewGroup传递而来,先看一下ViewGroup的measureChildWithMargins方法:


    protected void measureChildWithMargins(View child,
            int parentWidthMeasureSpec, int widthUsed,
            int parentHeightMeasureSpec, int heightUsed) {

        //调用child.getLayoutParams()获得子视图的LayoutParams属性
        final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
        
        //调用两次 getChildMeasureSpec()函数,分别计算出孩子视图的宽度和高度的 Spec
        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()函数,确定子视图的最终布局大小。
        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }

每一行代码我都加了详细的注释,很显然,子元素的MeasureSpec的创建也是由父容器的MeasureSpec和子元素本身的layoutParams决定的,此外,因为这是measureChildWithMargins方法,View的margin和padding也参与了决定。源码中还有measureChildren(),measureChild() 可以参考阅读。

很明显,getChildMeasureSpec()返回了我们子元素宽高的MeasureSpec,胜利在望了!我们继续跟踪!

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
        //通过父类传进的MeasureSpec确定父类的mode和size
        int specMode = MeasureSpec.getMode(spec);
        int specSize = MeasureSpec.getSize(spec);
           
        //因为有padding 因此子元素的可用空间是父类的size - padding
        int size = Math.max(0, specSize - padding);
        
        //子类size的初始化
        int resultSize = 0;
        //子类mode的初始化
        int resultMode = 0;
        
        //传进父类的mode
        switch (specMode) {

        // Parent has imposed an exact size on us
        case MeasureSpec.EXACTLY: //父类说:我是精确值模式的,你也得是精确值模式
            if (childDimension >= 0) {//子类说: 好啊 反正我刚好设置了具体值
                resultSize = childDimension;   //将size设置为设定的值
                resultMode = MeasureSpec.EXACTLY; //将mode设置为精确值模式
            } else if (childDimension == LayoutParams.MATCH_PARENT) {//另一种情况 子类说:卧槽我没设置过具体值啊 我设置的match_parent 我想和你一样大!
                // Child wants to be our size. So be it. //这句英文看的懂吧
                resultSize = size;//父类说:你既然想和我一样大 那剩余空间都给你了 (size是父类的剩余空间)
                resultMode = MeasureSpec.EXACTLY;//这也是精确值模式 因为size是个具体值
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {//又一种情况 子类说:卧槽我没设置过具体值啊 我设置的是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);
    }

代码不难,也标有英文的注解,我也加了中文的注释,它的主要作用就是通过父与子的协商确定子元素的size和mode,然后将size和mode打包成MeasureSpec,我之前说了,MeasureSpec就是size和mode打包成的。

看完了注释,MeasureSpec由父子协商决定的意思也很明确了。

总结一下:这里分别将了DecorView的MeasureSpec的决定过程,还有普通view的MeasureSpec的决定过程。知道了MeasureSpec的决定之后,我们接下来就能进行View的measure和layout还有draw这三大流程啦!(下次再见)

 

你可能感兴趣的:(Android原理)