码迷,mamicode.com
首页 > 移动开发 > 详细

Android中measure过程、WRAP_CONTENT详解以及 xml布局文件解析流程浅析

时间:2015-02-26 18:24:16      阅读:367      评论:0      收藏:0      [点我收藏+]

标签:

转自:http://www.uml.org.cn/mobiledev/201211221.asp

 

今天,我着重讲解下如下三个内容:

  1. measure过程
  2. WRAP_CONTENT、MATCH_PARENT/FILL_PARENT属性的原理说明
  3. xml布局文件解析成View树的流程分析。

希望对大家能有帮助。- - 分析版本基于Android 2.3 。

1、WRAP_CONTENT、MATCH_PARENT/FILL_PARENT

初入Android殿堂的同学们,对这三个属性一定又爱又恨。爱的是使用起来挺爽地---照葫芦画瓢即可,恨的

却是时常混淆这几个属性地意义,需要三思而后行。在带着大家重温下这几个属性的用法吧(希望我没有啰嗦)。

这三个属性都用来适应视图的水平或垂直大小,一个以视图的内容或尺寸为基础的布局比精确地指定视图范围

更加方便。

① fill_parent

设置一个视图的布局为fill_parent将强制性地使视图扩展至父元素大小。

② match_parent

Android 中match_parent和fill_parent意思一样,但match_parent更贴切,于是从2.2开始两个词都可以

用,但2.3版本后建议使用match_parent。

③ wrap_content

自适应大小,强制性地使视图扩展以便显示其全部内容。以TextView和ImageView控件为例,设置为

wrap_content将完整显示其内部的文本和图像。布局元素将根据内容更改大小。

可不要重复造轮子,以上摘自<<Android fill_parent、wrap_content和match_parent的区别>>。

当然,我们可以设置View的确切宽高,而不是由以上属性指定。

01.android:layout_weight="wrap_content"   //自适应大小  
02.android:layout_weight="match_parent"   //与父视图等高  
03.android:layout_weight="fill_parent"    //与父视图等高  
04.android:layout_weight="100dip"         //精确设置高度值为 100dip  

接下来,我们需要转换下视角,看看ViewGroup.LayoutParams类及其派生类。

2、ViewGroup.LayoutParams类及其派生类

2.1、 ViewGroup.LayoutParams类说明

Android API中如下介绍:

LayoutParams are used by views to tell their parents how they want to be laid out.

意思大概是说: View通过LayoutParams类告诉其父视图它想要地大小(即,长度和宽度)。

因此,每个View都包含一个ViewGroup.LayoutParams类或者其派生类,View类依赖于ViewGroup.LayoutParams。

路径:frameworks\base\core\java\android\view\View.java

01.public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource {  
02.  ...  
03.  /** 
04.   * The layout parameters associated with this view and used by the parent 
05.   * {@link android.view.ViewGroup} to determine how this view should be 
06.   * laid out. 
07.   * {@hide} 
08.   */  
09.  //该View拥有的 LayoutParams属性,父试图添加该View时,会为其赋值,特别注意,其类型为ViewGroup.LayoutParams。  
10.  protected ViewGroup.LayoutParams mLayoutParams;    
11.  ...  
12.}  

2.2、 ViewGroup.LayoutParams源码分析

路径位于:frameworks\base\core\java\android\view\ViewGroup.java

01.public abstract class ViewGroup extends View implements ViewParent, ViewManager {  
02.    ...  
03.     public static class LayoutParams {  
04.        /** 
05.         * Special value for the height or width requested by a View. 
06.         * FILL_PARENT means that the view wants to be as big as its parent, 
07.         * minus the parent‘s padding, if any. This value is deprecated 
08.         * starting in API Level 8 and replaced by {@link #MATCH_PARENT}. 
09.         */  
10.        @Deprecated  
11.        public static final int FILL_PARENT = -1;  // 注意值为-1,Android2.2版本不建议使用  
12.        /** 
13.         * Special value for the height or width requested by a View. 
14.         * MATCH_PARENT means that the view wants to be as big as its parent, 
15.         * minus the parent‘s padding, if any. Introduced in API Level 8. 
16.         */  
17.        public static final int MATCH_PARENT = -1; // 注意值为-1  
18.        /** 
19.         * Special value for the height or width requested by a View. 
20.         * WRAP_CONTENT means that the view wants to be just large enough to fit 
21.         * its own internal content, taking its own padding into account. 
22.         */  
23.        public static final int WRAP_CONTENT = -2; // 注意值为-2  
24.        /** 
25.         * Information about how wide the view wants to be. Can be one of the 
26.         * constants FILL_PARENT (replaced by MATCH_PARENT , 
27.         * in API Level 8) or WRAP_CONTENT. or an exact size. 
28.         */  
29.        public int width;  //该View的宽度,可以为WRAP_CONTENT/MATCH_PARENT 或者一个具体值  
30.        /** 
31.         * Information about how tall the view wants to be. Can be one of the 
32.         * constants FILL_PARENT (replaced by MATCH_PARENT , 
33.         * in API Level 8) or WRAP_CONTENT. or an exact size. 
34.         */  
35.        public int height; //该View的高度,可以为WRAP_CONTENT/MATCH_PARENT 或者一个具体值  
36.        /** 
37.         * Used to animate layouts. 
38.         */  
39.        public LayoutAnimationController.AnimationParameters layoutAnimationParameters;  
40.        /** 
41.         * Creates a new set of layout parameters. The values are extracted from 
42.         * the supplied attributes set and context. The XML attributes mapped 
43.         * to this set of layout parameters are:、 
44.         */  
45.        public LayoutParams(Context c, AttributeSet attrs) {  
46.            TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.ViewGroup_Layout);  
47.            setBaseAttributes(a,  
48.                    R.styleable.ViewGroup_Layout_layout_width,  
49.                    R.styleable.ViewGroup_Layout_layout_height);  
50.            a.recycle();  
51.        }  
52.  
53.        /** 
54.         * Creates a new set of layout parameters with the specified width 
55.         * and height. 
56.         */  
57.        public LayoutParams(int width, int height) {  
58.            this.width = width;  
59.            this.height = height;  
60.        }  
61.        /** 
62.         * Copy constructor. Clones the width and height values of the source. 
63.         * 
64.         * @param source The layout params to copy from. 
65.         */  
66.        public LayoutParams(LayoutParams source) {  
67.            this.width = source.width;  
68.            this.height = source.height;  
69.        }  
70.        /** 
71.         * Used internally by MarginLayoutParams. 
72.         * @hide 
73.         */  
74.        LayoutParams() {  
75.        }  
76.        /** 
77.         * Extracts the layout parameters from the supplied attributes. 
78.         * 
79.         * @param a the style attributes to extract the parameters from 
80.         * @param widthAttr the identifier of the width attribute 
81.         * @param heightAttr the identifier of the height attribute 
82.         */  
83.        protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {  
84.            width = a.getLayoutDimension(widthAttr, "layout_width");  
85.            height = a.getLayoutDimension(heightAttr, "layout_height");  
86.        }  
87.}  

我们发现FILL_PARENT/MATCH_PARENT值为 -1 ,WRAP_CONETENT值为-2,是不是有点诧异? 将值

设置为负值的目的是为了区别View的具体值(an exact size) 总是大于0的。

ViewGroup子类可以实现自定义LayoutParams,自定义LayoutParams提供了更好地扩展性,例如LinearLayout

就有LinearLayout. LayoutParams自定义类(见下文)。整个LayoutParams类家族还是挺复杂的。

ViewGroup.LayoutParams及其常用派生类的类图(部分类图)如下:

技术分享

该类图是在太庞大了,大家有兴趣的去看看Android API吧。

前面我们说过,每个View都包含一个ViewGroup.LayoutParams类或者其派生类,下面我们的疑问是Android框架

中时如何为View设置其LayoutParams属性的。

有两种方法会设置View的LayoutParams属性:

1、 直接添加子View时,常见于如下几种方法:ViewGroup.java

01.//Adds a child view.      
02.void addView(View child, int index)  
03.//Adds a child view with this ViewGroup‘s default layout parameters   
04.//and the specified width and height.  
05.void addView(View child, int width, int height)  
06.//Adds a child view with the specified layout parameters.         
07.void addView(View child, ViewGroup.LayoutParams params)  

三个重载方法的区别只是添加View时构造LayoutParams对象的方式不同而已,稍后我们探寻一下它们的源码。

2、 通过xml布局文件指定某个View的属性为:android:layout_heigth=””以及android:layout_weight=”” 时。

总的来说,这两种方式都会设定View的LayoutParams属性值----指定的或者Default值。

方式1流程分析:

直接添加子View时,比较容易理解,我们先来看看这种方式设置LayoutParams的过程:

路径:\frameworks\base\core\java\android\view\ViewGroup.java

01.public abstract class ViewGroup extends View implements ViewParent, ViewManager {  
02.    ...  
03.    /** 
04.     * Adds a child view. If no layout parameters are already set on the child, the 
05.     * default parameters for this ViewGroup are set on the child. 
06.     * 
07.     * @param child the child view to add 
08.     * 
09.     * @see #generateDefaultLayoutParams() 
10.     */  
11.    public void addView(View child) {  
12.        addView(child, -1);  
13.    }  
14.    /** 
15.     * Adds a child view. If no layout parameters are already set on the child, the 
16.     * default parameters for this ViewGroup are set on the child. 
17.     * 
18.     * @param child the child view to add 
19.     * @param index the position at which to add the child 
20.     * 
21.     * @see #generateDefaultLayoutParams() 
22.     */  
23.    public void addView(View child, int index) {  
24.        LayoutParams params = child.getLayoutParams();  
25.        if (params == null) {  
26.            params = generateDefaultLayoutParams(); //返回默认地LayoutParams类,作为该View的属性值  
27.            if (params == null) {//如果不能获取到LayoutParams对象,则抛出异常。  
28.                throw new IllegalArgumentException("generateDefaultLayoutParams() cannot return null");  
29.            }  
30.        }  
31.        addView(child, index, params);  
32.    }  
33.    /** 
34.     * Adds a child view with this ViewGroup‘s default layout parameters and the 
35.     * specified width and height. 
36.     * 
37.     * @param child the child view to add 
38.     */  
39.    public void addView(View child, int width, int height) {  
40.        //返回默认地LayoutParams类,作为该View的属性值  
41.        final LayoutParams params = generateDefaultLayoutParams();   
42.        params.width = width;   //重新设置width值  
43.        params.height = height; //重新设置height值  
44.        addView(child, -1, params); //这儿,我们有指定width、height的大小了。  
45.    }  
46.    /** 
47.     * Adds a child view with the specified layout parameters. 
48.     * 
49.     * @param child the child view to add 
50.     * @param params the layout parameters to set on the child 
51.     */  
52.    public void addView(View child, LayoutParams params) {  
53.        addView(child, -1, params);  
54.    }  
55.    /** 
56.     * Adds a child view with the specified layout parameters. 
57.     * 
58.     * @param child the child view to add 
59.     * @param index the position at which to add the child 
60.     * @param params the layout parameters to set on the child 
61.     */  
62.    public void addView(View child, int index, LayoutParams params) {  
63.        ...  
64.        // addViewInner() will call child.requestLayout() when setting the new LayoutParams  
65.        // therefore, we call requestLayout() on ourselves before, so that the child‘s request  
66.        // will be blocked at our level  
67.        requestLayout();  
68.        invalidate();  
69.        addViewInner(child, index, params, false);  
70.    }  
71.    /** 
72.     * Returns a set of default layout parameters. These parameters are requested 
73.     * when the View passed to {@link #addView(View)} has no layout parameters 
74.     * already set. If null is returned, an exception is thrown from addView. 
75.     * 
76.     * @return a set of default layout parameters or null 
77.     */  
78.    protected LayoutParams generateDefaultLayoutParams() {  
79.        //width 为 WRAP_CONTENT大小 , height 为WRAP_CONTENT   
80.        //ViewGroup的子类可以重写该方法,达到其特定要求。稍后会以LinearLayout类为例说明。  
81.        return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);  
82.    }  
83.    private void addViewInner(View child, int index, LayoutParams params,  
84.            boolean preventRequestLayout) {  
85.  
86.        if (!checkLayoutParams(params)) { //params对象是否为null  
87.            params = generateLayoutParams(params); //如果params对象是为null,重新构造个LayoutParams对象  
88.        }  
89.        //preventRequestLayout值为false  
90.        if (preventRequestLayout) {    
91.            child.mLayoutParams = params; //为View的mLayoutParams属性赋值  
92.        } else {  
93.            child.setLayoutParams(params);//为View的mLayoutParams属性赋值,但会调用requestLayout()请求重新布局  
94.        }  
95.        //if else 语句会设置View为mLayoutParams属性赋值  
96.        ...  
97.    }  
98.    ...  
99.}  

主要功能就是在添加子View时为其构建了一个LayoutParams对象。但更重要的是,ViewGroup的子类可以重载上面的几个方法,返回特定的LayoutParams对象,例如:对于LinearLayout而言,则是LinearLayout.LayoutParams对象。这么做地目的是,能在其他需要它的地方,可以将其强制转换成LinearLayout.LayoutParams对象。

LinearLayout重写函数地实现为:

01.public class LinearLayout extends ViewGroup {  
02.    ...  
03.    @Override  
04.    public LayoutParams generateLayoutParams(AttributeSet attrs) {  
05.        return new LinearLayout.LayoutParams(getContext(), attrs);  
06.    }  
07.    @Override  
08.    protected LayoutParams generateDefaultLayoutParams() {  
09.        //该LinearLayout是水平方向还是垂直方向  
10.        if (mOrientation == HORIZONTAL) {   
11.            return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);  
12.        } else if (mOrientation == VERTICAL) {  
13.            return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);  
14.        }  
15.        return null;  
16.    }  
17.    @Override  
18.    protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {  
19.        return new LayoutParams(p);  
20.    }  
21.    /** 
22.     * Per-child layout information associated with ViewLinearLayout. 
23.     *  
24.     * @attr ref android.R.styleable#LinearLayout_Layout_layout_weight 
25.     * @attr ref android.R.styleable#LinearLayout_Layout_layout_gravity 
26.     */ //自定义的LayoutParams类  
27.    public static class LayoutParams extends ViewGroup.MarginLayoutParams {  
28.        /** 
29.         * Indicates how much of the extra space in the LinearLayout will be 
30.         * allocated to the view associated with these LayoutParams. Specify 
31.         * 0 if the view should not be stretched. Otherwise the extra pixels 
32.         * will be pro-rated among all views whose weight is greater than 0. 
33.         */  
34.        @ViewDebug.ExportedProperty(category = "layout")  
35.        public float weight;      //  见于属性,android:layout_weight=""  ;  
36.        /** 
37.         * Gravity for the view associated with these LayoutParams. 
38.         * 
39.         * @see android.view.Gravity 
40.         */  
41.        public int gravity = -1;  // 见于属性, android:layout_gravity=""  ;   
42.        /** 
43.         * {@inheritDoc} 
44.         */  
45.        public LayoutParams(Context c, AttributeSet attrs) {  
46.            super(c, attrs);  
47.            TypedArray a =c.obtainStyledAttributes(attrs, com.android.internal.R.styleable.LinearLayout_Layout);  
48.            weight = a.getFloat(com.android.internal.R.styleable.LinearLayout_Layout_layout_weight, 0);  
49.            gravity = a.getInt(com.android.internal.R.styleable.LinearLayout_Layout_layout_gravity, -1);  
50.  
51.            a.recycle();  
52.        }  
53.        /** 
54.         * {@inheritDoc} 
55.         */  
56.        public LayoutParams(int width, int height) {  
57.            super(width, height);  
58.            weight = 0;  
59.        }  
60.        /** 
61.         * Creates a new set of layout parameters with the specified width, height 
62.         * and weight. 
63.         * 
64.         * @param width the width, either {@link #MATCH_PARENT}, 
65.         *        {@link #WRAP_CONTENT} or a fixed size in pixels 
66.         * @param height the height, either {@link #MATCH_PARENT}, 
67.         *        {@link #WRAP_CONTENT} or a fixed size in pixels 
68.         * @param weight the weight 
69.         */  
70.        public LayoutParams(int width, int height, float weight) {  
71.            super(width, height);  
72.            this.weight = weight;  
73.        }  
74.        public LayoutParams(ViewGroup.LayoutParams p) {  
75.            super(p);  
76.        }  
77.        public LayoutParams(MarginLayoutParams source) {  
78.            super(source);  
79.        }  
80.    }  
81.    ...  
82.} 

LinearLayout.LayoutParams类继承至ViewGroup.MarginLayoutParams类,添加了对android:layout_weight以及 android:layout_gravity这两个属性的获取和保存。而且它的重写函数返回的都是LinearLayout.LayoutParams类型。这样,我们可以再对子View进行其他操作时,可以将将其强制转换成LinearLayout.LayoutParams对象进行使用。

例如,LinearLayout进行measure过程,使用了LinearLayout.LayoutParam对象,有如下代码:

01.public class LinearLayout extends ViewGroup {  
02.    ...  
03.    @Override  //onMeasure方法。  
04.    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
05.        //判断是垂直方向还是水平方向,这儿我们假设是VERTICAL垂直方向,  
06.        if (mOrientation == VERTICAL) {  
07.            measureVertical(widthMeasureSpec, heightMeasureSpec);  
08.        } else {  
09.            measureHorizontal(widthMeasureSpec, heightMeasureSpec);  
10.        }  
11.    }  
12.     /** 
13.     * Measures the children when the orientation of this LinearLayout is set 
14.     * to {@link #VERTICAL}. 
15.     * 
16.     * @param widthMeasureSpec Horizontal space requirements as imposed by the parent. 
17.     * @param heightMeasureSpec Vertical space requirements as imposed by the parent. 
18.     * 
19.     * @see #getOrientation() 
20.     * @see #setOrientation(int) 
21.     * @see #onMeasure(int, int) 
22.     */  
23.      void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {  
24.            mTotalLength = 0;  
25.            ...  
26.            // See how tall everyone is. Also remember max width.  
27.            for (int i = 0; i < count; ++i) {  
28.                final View child = getVirtualChildAt(i); //获得索引处为i的子VIew     
29.                ...  
30.                //注意,我们将类型为 ViewGroup.LayoutParams的实例对象强制转换为了LinearLayout.LayoutParams,  
31.                //即父对象转换为了子对象,能这样做的原因就是LinearLayout的所有子View的LayoutParams类型都为  
32.                //LinearLayout.LayoutParams  
33.                LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();  
34.                ...  
35.        }  
36.    ...  
37.}  

超类ViewGroup.LayoutParams强制转换为了子类LinearLayout.LayoutParams,因为LinearLayout的每个”直接“子View的LayoutParams属性都是LinearLayout.LayoutParams类型,因此可以安全转换。

PS : Android 2.3源码Launcher2中也实现了自定义的LayoutParams类,在IDLE界面的每个View至少包含如下

信息:所在X方向的单元格索引和高度、所在Y方向的单元格索引和高度等。

路径: packages\apps\Launcher2\src\com\android\launcher2\CellLayout.java

01.public class CellLayout extends ViewGroup {  
02.    ...   
03.    public static class LayoutParams extends ViewGroup.MarginLayoutParams {  
04.            /** 
05.             * Horizontal location of the item in the grid. 
06.             */  
07.            public int cellX;   //X方向的单元格索引  
08.            /** 
09.             * Vertical location of the item in the grid. 
10.             */  
11.            public int cellY;   //Y方向的单元格索引  
12.            /** 
13.             * Number of cells spanned horizontally by the item. 
14.             */  
15.            public int cellHSpan;  //水平方向所占高度  
16.            /** 
17.             * Number of cells spanned vertically by the item. 
18.             */  
19.            public int cellVSpan;  //垂直方向所占高度  
20.            ...  
21.            public LayoutParams(Context c, AttributeSet attrs) {  
22.                super(c, attrs);  
23.                cellHSpan = 1;  //默认为高度 1  
24.                cellVSpan = 1;  
25.            }  
26.  
27.            public LayoutParams(ViewGroup.LayoutParams source) {  
28.                super(source); //默认为高度 1  
29.                cellHSpan = 1;  
30.                cellVSpan = 1;  
31.            }  
32.              
33.            public LayoutParams(int cellX, int cellY, int cellHSpan, int cellVSpan) {  
34.                super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);  
35.                this.cellX = cellX;  
36.                this.cellY = cellY;  
37.                this.cellHSpan = cellHSpan;  
38.                this.cellVSpan = cellVSpan;  
39.            }  
40.            ...  
41.        }  
42.    ...  
43.}  

对该自定义CellLayout.LayoutParams类的使用可以参考LinearLayout.LayoutParams类,我也不再赘述了。

方法2流程分析:

使用属性android:layout_heigth=””以及android:layout_weight=”” 时,为某个View设置LayoutParams值。

其实这种赋值方法其实也如同前面那种,只不过它需要一个前期孵化过程---需要利用XML解析将布局文件解析成一个完整的View树,可别小看它了,所有Xxx.xml的布局文件都需要解析成一个完整的View树。下面,我们就来仔细走这个过程,重点关注如下两个方面

①、xml布局是如何解析成View树的 ;

②、android:layout_heigth=””和android:layout_weight=””的解析。

PS: 一直以来,我都想当然android:layout_heigth以及android:layout_weight这两个属性的解析过程是在View.java内部完成的,但当我真正去找寻时,却一直没有在View.java类或者ViewGroup.java类找到。直到一位网友的一次提问,才发现它们的藏身之地。

3、布局文件解析流程分析

解析布局文件时,使用的类为LayoutInflater。 关于该类的使用请参考如下博客:

<android中LayoutInflater的使用 >>

主要有如下API方法:

public View inflate (XmlPullParser parser, ViewGroup root, boolean attachToRoot)

public View inflate (int resource, ViewGroup root)

public View inflate (int resource, ViewGroup root, boolean attachToRoot)

这三个类主要迷惑之处在于地三个参数attachToRoot,即是否将该View树添加到root中去。具体可看这篇博客:

<<关于inflate的第3个参数>>

当然还有LayoutInflater的inflate()的其他重载方法,大家可以自行了解下。

我利用下面的例子给大家走走这个流程 :

01.public class MainActivity extends Activity {  
02.    /** Called when the activity is first created. */  
03.    @Override  
04.    public void onCreate(Bundle savedInstanceState) {  
05.        super.onCreate(savedInstanceState);  
06.        //1、该方法最终也会调用到 LayoutInflater的inflate()方法中去解析。  
07.        setContentView(R.layout.main);  
08.          
09.        //2、使用常见的API方法去解析xml布局文件,  
10.        LayoutInflater layoutInflater = (LayoutInflater)getSystemService();  
11.        View root = layoutInflater.inflate(R.layout.main, null);  
12.    }  
13.}  

Step 1、获得LayoutInflater的引用。

路径:\frameworks\base\core\java\android\app\ContextImpl.java

01./** 
02. * Common implementation of Context API, which provides the base 
03. * context object for Activity and other application components. 
04. */  
05.class ContextImpl extends Context {  
06.    if (WINDOW_SERVICE.equals(name)) {  
07.        return WindowManagerImpl.getDefault();  
08.    } else if (LAYOUT_INFLATER_SERVICE.equals(name)) {  
09.        synchronized (mSync) {  
10.            LayoutInflater inflater = mLayoutInflater;  
11.            //是否已经赋值,如果是,直接返回引用  
12.            if (inflater != null) {  
13.                return inflater;  
14.            }  
15.            //返回一个LayoutInflater对象,getOuterContext()指的是我们的Activity、Service或者Application引用  
16.            mLayoutInflater = inflater = PolicyManager.makeNewLayoutInflater(getOuterContext());  
17.            return inflater;  
18.        }  
19.    } else if (ACTIVITY_SERVICE.equals(name)) {  
20.        return getActivityManager();  
21.    }...  
22.}  

继续去PolicyManager查询对应函数,看看内部实现。

路径:frameworks\base\core\java\com\android\internal\policy\PolicyManager.java

01.public final class PolicyManager {  
02.    private static final String POLICY_IMPL_CLASS_NAME = "com.android.internal.policy.impl.Policy";  
03.    private static final IPolicy sPolicy;   // 这可不是Binder机制额,这只是是一个接口,别想多啦  
04.    static {  
05.        // Pull in the actual implementation of the policy at run-time  
06.        try {  
07.            Class policyClass = Class.forName(POLICY_IMPL_CLASS_NAME);  
08.            sPolicy = (IPolicy)policyClass.newInstance();  
09.        }  
10.        ...  
11.    }  
12.    ...  
13.    public static LayoutInflater makeNewLayoutInflater(Context context) {  
14.        return sPolicy.makeNewLayoutInflater(context); //继续去实现类中去查找  
15.    }  
16.}  

IPolicy接口的实现对为Policy类。路径:/frameworks/base/policy/src/com/android/internal/policy/impl/Policy.java

01.//Simple implementation of the policy interface that spawns the right  
02.//set of objects  
03.public class Policy implements IPolicy{  
04.    ...  
05.    public PhoneLayoutInflater makeNewLayoutInflater(Context context) {  
06.        //实际上返回的是PhoneLayoutInflater类。  
07.        return new PhoneLayoutInflater(context);  
08.    }  
09.}  
10.//PhoneLayoutInflater继承至LayoutInflater类  
11.public class PhoneLayoutInflater extends LayoutInflater {  
12.    ...  
13.    /** 
14.     * Instead of instantiating directly, you should retrieve an instance 
15.     * through {@link Context#getSystemService} 
16.     *  
17.     * @param context The Context in which in which to find resources and other 
18.     *                application-specific things. 
19.     *  
20.     * @see Context#getSystemService 
21.     */  
22.    public PhoneLayoutInflater(Context context) {  
23.        super(context);  
24.    }  
25.    ...  
26.}  

LayoutInflater是个抽象类,实际上我们返回的是PhoneLayoutInflater类,但解析过程的操作基本上是在

LayoutInflater中完成地。

Step 2、调用inflate()方法去解析布局文件。

 01.public abstract class LayoutInflater {  
02.    ...  
03.    public View inflate(int resource, ViewGroup root) {  
04.        //继续看下个函数,注意root为null  
05.        return inflate(resource, root, root != null);   
06.    }  
07.      
08.    public View inflate(int resource, ViewGroup root, boolean attachToRoot) {  
09.        //获取一个XmlResourceParser来解析XML文件---布局文件。  
10.        //XmlResourceParser类以及xml是如何解析的,大家自己有兴趣找找。  
11.        XmlResourceParser parser = getContext().getResources().getLayout(resource);  
12.        try {  
13.            return inflate(parser, root, attachToRoot);  
14.        } finally {  
15.            parser.close();  
16.        }  
17.    }  
18.}  
19./** 
20. * The XML parsing interface returned for an XML resource.  This is a standard 
21. * XmlPullParser interface, as well as an extended AttributeSet interface and 
22. * an additional close() method on this interface for the client to indicate 
23. * when it is done reading the resource. 
24. */  
25.public interface XmlResourceParser extends XmlPullParser, AttributeSet {  
26.    /** 
27.     * Close this interface to the resource.  Calls on the interface are no 
28.     * longer value after this call. 
29.     */  
30.    public void close();  
31.}  

我们获得了一个当前应用程序环境的XmlResourceParser对象,该对象的主要作用就是来解析xml布局文件的。XmlResourceParser类是个接口类,

Step 3 、真正地开始解析工作 。

01.public abstract class LayoutInflater {  
02.    ...  
03.    /** 
04.     * Inflate a new view hierarchy from the specified XML node. Throws 
05.     * {@link InflateException} if there is an error. 
06.     */  
07.    //我们传递过来的参数如下: root 为null , attachToRoot为false 。  
08.    public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {  
09.        synchronized (mConstructorArgs) {  
10.            final AttributeSet attrs = Xml.asAttributeSet(parser);  
11.            Context lastContext = (Context)mConstructorArgs[0];  
12.            mConstructorArgs[0] = mContext;  //该mConstructorArgs属性最后会作为参数传递给View的构造函数  
13.            View result = root;  //根View  
14.  
15.            try {  
16.                // Look for the root node.  
17.                int type;  
18.                while ((type = parser.next()) != XmlPullParser.START_TAG &&  
19.                        type != XmlPullParser.END_DOCUMENT) {  
20.                    // Empty  
21.                }  
22.                ...  
23.                final String name = parser.getName();  //节点名,即API中的控件或者自定义View完整限定名。  
24.                if (TAG_MERGE.equals(name)) { // 处理标签  
25.                    if (root == null || !attachToRoot) {  
26.                        throw new InflateException(" can be used only with a valid "  
27.                                + "ViewGroup root and attachToRoot=true");  
28.                    }  
29.                    //将标签的View树添加至root中,该函数稍后讲到。  
30.                    rInflate(parser, root, attrs);  
31.                } else {  
32.                    // Temp is the root view that was found in the xml  
33.                    //创建该xml布局文件所对应的根View。  
34.                    View temp = createViewFromTag(name, attrs);   
35.  
36.                    ViewGroup.LayoutParams params = null;  
37.  
38.                    if (root != null) {  
39.                        // Create layout params that match root, if supplied  
40.                        //根据AttributeSet属性获得一个LayoutParams实例,记住调用者为root。  
41.                        params = root.generateLayoutParams(attrs);   
42.                        if (!attachToRoot) { //重新设置temp的LayoutParams  
43.                            // Set the layout params for temp if we are not  
44.                            // attaching. (If we are, we use addView, below)  
45.                            temp.setLayoutParams(params);  
46.                        }  
47.                    }  
48.                    // Inflate all children under temp  
49.                    //添加所有其子节点,即添加所有字View  
50.                    rInflate(parser, temp, attrs);  
51.                      
52.                    // We are supposed to attach all the views we found (int temp)  
53.                    // to root. Do that now.  
54.                    if (root != null && attachToRoot) {  
55.                        root.addView(temp, params);  
56.                    }  
57.                    // Decide whether to return the root that was passed in or the  
58.                    // top view found in xml.  
59.                    if (root == null || !attachToRoot) {  
60.                        result = temp;  
61.                    }  
62.                }  
63.            }   
64.            ...  
65.            return result;  
66.        }  
67.    }  
68.      
69.    /* 
70.     * default visibility so the BridgeInflater can override it. 
71.     */  
72.    View createViewFromTag(String name, AttributeSet attrs) {  
73.        //节点是否为View,如果是将其重新赋值,形如   
74.        if (name.equals("view")) {    
75.            name = attrs.getAttributeValue(null, "class");  
76.        }  
77.        try {  
78.            View view = (mFactory == null) ? null : mFactory.onCreateView(name,  
79.                    mContext, attrs);  //没有设置工厂方法  
80.  
81.            if (view == null) {  
82.                //通过这个判断是Android API的View,还是自定义View  
83.                if (-1 == name.indexOf(‘.‘)) {  
84.                    view = onCreateView(name, attrs); //创建Android API的View实例  
85.                } else {  
86.                    view = createView(name, null, attrs);//创建一个自定义View实例  
87.                }  
88.            }  
89.            return view;  
90.        }   
91.        ...  
92.    }  
93.    //获得具体视图的实例对象  
94.    public final View createView(String name, String prefix, AttributeSet attrs) {  
95.        Constructor constructor = sConstructorMap.get(name);  
96.        Class clazz = null;  
97.        //以下功能主要是获取如下三个类对象:  
98.        //1、类加载器  ClassLoader  
99.        //2、Class对象  
100.        //3、类的构造方法句柄 Constructor  
101.        try {  
102.            if (constructor == null) {  
103.            // Class not found in the cache, see if it‘s real, and try to add it  
104.            clazz = mContext.getClassLoader().loadClass(prefix != null ? (prefix + name) : name);  
105.            ...  
106.            constructor = clazz.getConstructor(mConstructorSignature);  
107.            sConstructorMap.put(name, constructor);  
108.        } else {  
109.            // If we have a filter, apply it to cached constructor  
110.            if (mFilter != null) {  
111.                ...     
112.            }  
113.        }  
114.            //传递参数获得该View实例对象  
115.            Object[] args = mConstructorArgs;  
116.            args[1] = attrs;  
117.            return (View) constructor.newInstance(args);  
118.        }   
119.        ...  
120.    }  
121.  
122.}  

这段代码的作用是获取xml布局文件的root View,做了如下两件事情

1、获取xml布局的View实例,通过createViewFromTag()方法获取,该方法会判断节点名是API 控件

还是自定义控件,继而调用合适的方法去实例化View。

2、判断root以及attachToRoot参数,重新设置root View值以及temp变量的LayoutParams值。

如果仔细看着段代码,不知大家心里有没有疑惑:当root为null时,我们的temp变量的LayoutParams值是为

null的,即它不会被赋值?有个View的LayoutParams值为空,那么,在系统中不会报异常吗?见下面部分

代码:

01.//我们传递过来的参数如下: root 为null , attachToRoot为false 。  
02.public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {  
03.    synchronized (mConstructorArgs) {  
04.        ...  
05.        try {  
06.              
07.            ...  
08.            if (TAG_MERGE.equals(name)) { // 处理标签  
09.                ...  
10.            } else {  
11.                // Temp is the root view that was found in the xml  
12.                //创建该xml布局文件所对应的根View。  
13.                View temp = createViewFromTag(name, attrs);   
14.                ViewGroup.LayoutParams params = null;  
15.  
16.                //注意!!! root为null时,temp变量的LayoutParams属性不会被赋值的。  
17.                if (root != null) {  
18.                    // Create layout params that match root, if supplied  
19.                    //根据AttributeSet属性获得一个LayoutParams实例,记住调用者为root。  
20.                    params = root.generateLayoutParams(attrs);   
21.                    if (!attachToRoot) { //重新设置temp的LayoutParams  
22.                        // Set the layout params for temp if we are not  
23.                        // attaching. (If we are, we use addView, below)  
24.                        temp.setLayoutParams(params);  
25.                    }  
26.                }  
27.                ...  
28.            }  
29.        }   
30.        ...  
31.    }  
32.}  

关于这个问题的详细答案,我会在后面讲到。这儿我简单说下,任何View树的顶层View被添加至窗口时,一般调用WindowManager.addView()添加至窗口时,在这个方法中去做进一步处理。即使,LayoutParams值为空,UI框架每次measure()时都忽略该View的LayoutParams值,而是直接传递MeasureSpec值至View树。

接下来,我们关注另外一个函数,rInflate(),该方法会递归调用每个View下的子节点,以当前View作为根View形成一个View树。

01./** 
02. * Recursive method used to descend down the xml hierarchy and instantiate 
03. * views, instantiate their children, and then call onFinishInflate(). 
04. */  
05.//递归调用每个字节点  
06.private void rInflate(XmlPullParser parser, View parent, final AttributeSet attrs)  
07.        throws XmlPullParserException, IOException {  
08.  
09.    final int depth = parser.getDepth();  
10.    int type;  
11.  
12.    while (((type = parser.next()) != XmlPullParser.END_TAG ||  
13.            parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {  
14.  
15.        if (type != XmlPullParser.START_TAG) {  
16.            continue;  
17.        }  
18.        final String name = parser.getName();  
19.          
20.        if (TAG_REQUEST_FOCUS.equals(name)) { //处理标签  
21.            parseRequestFocus(parser, parent);  
22.        } else if (TAG_INCLUDE.equals(name)) { //处理标签  
23.            if (parser.getDepth() == 0) {  
24.                throw new InflateException(" cannot be the root element");  
25.            }  
26.            parseInclude(parser, parent, attrs);//解析节点  
27.        } else if (TAG_MERGE.equals(name)) { //处理标签  
28.            throw new InflateException(" must be the root element");  
29.        } else {  
30.            //根据节点名构建一个View实例对象  
31.            final View view = createViewFromTag(name, attrs);   
32.            final ViewGroup viewGroup = (ViewGroup) parent;  
33.            //调用generateLayoutParams()方法返回一个LayoutParams实例对象,  
34.            final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);  
35.            rInflate(parser, view, attrs); //继续递归调用  
36.            viewGroup.addView(view, params); //OK,将该View以特定LayoutParams值添加至父View中  
37.        }  
38.    }  
39.    parent.onFinishInflate();  //完成了解析过程,通知....  
40.}  

值得注意的是,每次addView前都调用了viewGroup.generateLayoutParams(attrs)去构建一个LayoutParams

实例,然后在addView()方法中为其赋值。参见如下代码:ViewGroup.java

01.public abstract class ViewGroup extends View implements ViewParent, ViewManager {  
02.    ...  
03.      
04.    public LayoutParams generateLayoutParams(AttributeSet attrs) {  
05.        return new LayoutParams(getContext(), attrs);  
06.    }  
07.    public static class LayoutParams {  
08.        ... //会调用这个构造函数  
09.        public LayoutParams(Context c, AttributeSet attrs) {  
10.            TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.ViewGroup_Layout);  
11.            setBaseAttributes(a,  
12.                    R.styleable.ViewGroup_Layout_layout_width,  
13.                    R.styleable.ViewGroup_Layout_layout_height);  
14.            a.recycle();  
15.        }  
16.        protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {  
17.            width = a.getLayoutDimension(widthAttr, "layout_width");  
18.            height = a.getLayoutDimension(heightAttr, "layout_height");  
19.        }  
20.      
21.}  

好吧 ~~ 我们还是探寻根底,去TypeArray类的getLayoutDimension()看看。

路径:/frameworks/base/core/java/android/content/res/TypedArray.java

01.public class TypedArray {  
02.    ...  
03.    /** 
04.     * Special version of {@link #getDimensionPixelSize} for retrieving 
05.     * {@link android.view.ViewGroup}‘s layout_width and layout_height 
06.     * attributes.  This is only here for performance reasons; applications 
07.     * should use {@link #getDimensionPixelSize}. 
08.     *  
09.     * @param index Index of the attribute to retrieve. 
10.     * @param name Textual name of attribute for error reporting. 
11.     *  
12.     * @return Attribute dimension value multiplied by the appropriate  
13.     * metric and truncated to integer pixels. 
14.     */  
15.    public int getLayoutDimension(int index, String name) {  
16.        index *= AssetManager.STYLE_NUM_ENTRIES;  
17.        final int[] data = mData;  
18.        //获得属性对应的标识符 , Identifies,目前还没有仔细研究相关类。  
19.        final int type = data[index+AssetManager.STYLE_TYPE];  
20.        if (type >= TypedValue.TYPE_FIRST_INT  
21.                && type <= TypedValue.TYPE_LAST_INT) {  
22.            return data[index+AssetManager.STYLE_DATA];  
23.        } else if (type == TypedValue.TYPE_DIMENSION) { //类型为dimension类型  
24.            return TypedValue.complexToDimensionPixelSize(  
25.                data[index+AssetManager.STYLE_DATA], mResources.mMetrics);  
26.        }  
27.        //没有提供layout_weight和layout_height会来到此处 ,这儿会报异常!  
28.        //因此布局文件中的View包括自定义View必须加上属性layout_weight和layout_height。  
29.        throw new RuntimeException(getPositionDescription()  
30.                + ": You must supply a " + name + " attribute.");  
31.    }  
32.    ...  
33.}  

从上面得知, 我们将View的AttributeSet属性传递给generateLayoutParams()方法,让其构建合适地LayoutParams对象,并且初始化属性值weight和height。同时我们也得知 布局文件中的View包括自定义View必须加上属性layout_weight和layout_height,否则会报异常。

Step 3 主要做了如下事情:

首先,获得了了布局文件地root View,即布局文件中最顶层的View。

其次,通过递归调用,我们形成了整个View树以及设置了每个View的LayoutParams对象。

总结:通过对布局文件的解析流程的学习,也就是转换为View树的过程,我们明白了解析过程的个中奥妙,以及

设置ViewLayoutParams对象的过程。但是,我们这儿只是简单的浮光掠影,更深层次的内容希望大家能深入学习。

本来是准备接下去往下写的,但无奈贴出来的代码太多,文章有点长而且自己也有点凌乱了,因此决定做两篇博客发表吧。下篇内容包括如下方面:

  1. MeasureSpec类说明 ;
  2. measure过程中如何正确设置每个View的长宽 ;
  3. UI框架正确设置顶层View的LayoutParams对象,对Activity而言,顶层View则是DecorView,其他的皆是普通View了。

上篇文章中,我们了解了View树的转换过程以及如何设置View的LayoutParams的。本文继续沿着既定轨迹继续未完成的job。

主要知识点如下:

  1. MeasureSpc类说明
  2. measure过程详解(揭秘其细节);
  3. root View被添加至窗口时,UI框架是如何设置其LayoutParams值得。

在讲解measure过程前,我们非常有必要理解MeasureSpc类的使用,否则理解起来也只能算是囫囵吞枣。

1、MeasureSpc类说明

1.1 SDK 说明如下

A MeasureSpec encapsulates the layout requirements passed from parent to child. Each MeasureSpec represents a requirement for either the width or the height. A MeasureSpec is comprised of a size and a mode.

即:

MeasureSpc类封装了父View传递给子View的布局(layout)要求。每个MeasureSpc实例代表宽度或者高度(只能是其一)要求。 它有三种模式:

①、UNSPECIFIED(未指定),父元素部队自元素施加任何束缚,子元素可以得到任意想要的大小;

②、EXACTLY(完全),父元素决定自元素的确切大小,子元素将被限定在给定的边界里而忽略它本身大小;

③、AT_MOST(至多),子元素至多达到指定大小的值。

常用的三个函数:

static int getMode(int measureSpec) : 根据提供的测量值(格式)提取模式(上述三个模式之一)

static int getSize(int measureSpec) : 根据提供的测量值(格式)提取大小值(这个大小也就是我们通常所说的大小)

static int makeMeasureSpec(int size,int mode) : 根据提供的大小值和模式创建一个测量值(格式)

1.2 MeasureSpc类源码分析 其为View.java类的内部类,路径:\frameworks\base\core\java\android\view\View.java

 

01.public class View implements ... {  
02.     ...  
03.     public static class MeasureSpec {  
04.        private static final int MODE_SHIFT = 30; //移位位数为30  
05.        //int类型占32位,向右移位30位,该属性表示掩码值,用来与size和mode进行"&"运算,获取对应值。  
06.        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;  
07.  
08.        //向右移位30位,其值为00 + (30位0)  , 即 0x0000(16进制表示)  
09.        public static final int UNSPECIFIED = 0 << MODE_SHIFT;  
10.        //向右移位30位,其值为01 + (30位0)  , 即0x1000(16进制表示)  
11.        public static final int EXACTLY     = 1 << MODE_SHIFT;  
12.        //向右移位30位,其值为02 + (30位0)  , 即0x2000(16进制表示)  
13.        public static final int AT_MOST     = 2 << MODE_SHIFT;  
14.  
15.        //创建一个整形值,其高两位代表mode类型,其余30位代表长或宽的实际值。
           可以是WRAP_CONTENT、MATCH_PARENT或具体大小exactly size  
16.        public static int makeMeasureSpec(int size, int mode) {  
17.            return size + mode;  
18.        }  
19.        //获取模式  ,与运算  
20.        public static int getMode(int measureSpec) {  
21.            return (measureSpec & MODE_MASK);  
22.        }  
23.        //获取长或宽的实际值 ,与运算  
24.        public static int getSize(int measureSpec) {  
25.            return (measureSpec & ~MODE_MASK);  
26.        }  
27.  
28.    }  
29.    ...  
30.}  

MeasureSpec类的处理思路是:

①、右移运算,使int 类型的高两位表示模式的实际值,其余30位表示其余30位代表长或宽的实际值----可以是

WRAP_CONTENT、MATCH_PARENT或具体大小exactly size。

②、通过掩码MODE_MASK进行与运算 “&”,取得模式(mode)以及长或宽(value)的实际值。

2、measure过程详解

2.1 measure过程深入分析

之前的一篇博文<< Android中View绘制流程以及invalidate()等相关方法分析>>,我们从”二B程序员”的角度简单 解了measure过程的调用过程。过了这么多,我们也该升级了,- - 。现在请开始从”普通程序员”角度去理解这个过程。我们重点查看measure过程中地相关方法。

我们说过,当UI框架开始绘制时,皆是从ViewRoot.java类开始绘制的。ViewRoot类简要说明: 任何显示在设备中的窗口,例如:Activity、Dialog等,都包含一个ViewRoot实例,该类主要用来与远端 WindowManagerService交互以及控制(开始/销毁)绘制。

Step 1、 开始UI绘制 , 具体绘制方法则是:

 

01.路径:\frameworks\base\core\java\android\view\ViewRoot.java  
02.public final class ViewRoot extends Handler implements ViewParent,View.AttachInfo.Callbacks {  
03.    ...  
04.    //mView对象指添加至窗口的root View ,对Activity窗口而言,则是DecorView对象。  
05.    View mView;      
06.      
07.    //开始View绘制流程  
08.    private void performTraversals(){  
09.        ...  
10.        //这两个值我们在后面讨论时,在回过头来看看是怎么赋值的。现在只需要记住其值MeasureSpec.
 makeMeasureSpec()构建的。  
11.        int childWidthMeasureSpec; //其值由MeasureSpec类构建 , makeMeasureSpec  
12.        int childHeightMeasureSpec;//其值由MeasureSpec类构建 , makeMeasureSpec  
13.          
14.  
15.        // Ask host how big it wants to be  
16.        host.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
17.        ...  
18.    }  
19.    ...  
20.}  

这儿,我并没有说出childWidthMeasureSpec和childHeightMeasureSpec类的来由(为了避免额外地开销,等到

第三部分时我们在来攻克它,现在只需要记住其值MeasureSpec.makeMeasureSpec()构建的。

Step 2 、调用measure()方法去做一些前期准备

measure()方法原型定义在View.java类中,final修饰符修饰,其不能被重载:

01.public class View implements ... {  
02.    ...  
03.    /** 
04.     * This is called to find out how big a view should be. The parent 
05.     * supplies constraint information in the width and height parameters. 
06.     * 
07.     * @param widthMeasureSpec Horizontal space requirements as imposed by the 
08.     *        parent 
09.     * @param heightMeasureSpec Vertical space requirements as imposed by the 
10.     *        parent 
11.     * @see #onMeasure(int, int) 
12.     */  
13.    public final void measure(int widthMeasureSpec, int heightMeasureSpec) {  
14.        //判断是否为强制布局,即带有“FORCE_LAYOUT”标记 以及 widthMeasureSpec或heightMeasureSpec发生了改变  
15.        if ((mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT ||  
16.                widthMeasureSpec != mOldWidthMeasureSpec ||  
17.                heightMeasureSpec != mOldHeightMeasureSpec) {  
18.  
19.            // first clears the measured dimension flag  
20.            //清除MEASURED_DIMENSION_SET标记   ,该标记会在onMeasure()方法后被设置  
21.            mPrivateFlags &= ~MEASURED_DIMENSION_SET;   
22.  
23.            // measure ourselves, this should set the measured dimension flag back  
24.            // 1、 测量该View本身的大小 ; 2 、 设置MEASURED_DIMENSION_SET标记,否则接写来会报异常。  
25.            onMeasure(widthMeasureSpec, heightMeasureSpec);  
26.  
27.            // flag not set, setMeasuredDimension() was not invoked, we raise  
28.            // an exception to warn the developer  
29.            if ((mPrivateFlags & MEASURED_DIMENSION_SET) != MEASURED_DIMENSION_SET) {  
30.                throw new IllegalStateException("onMeasure() did not set the"  
31.                        + " measured dimension by calling" + " setMeasuredDimension()");  
32.            }  
33.  
34.            mPrivateFlags |= LAYOUT_REQUIRED;  //下一步是layout了,添加LAYOUT_REQUIRED标记  
35.        }  
36.  
37.        mOldWidthMeasureSpec = widthMeasureSpec;   //保存值  
38.        mOldHeightMeasureSpec = heightMeasureSpec; //保存值  
39.    }  
40.    ...  
41.}  

参数widthMeasureSpec和heightMeasureSpec 由父View构建,表示父View给子View的测量要求。其值地构建

会在下面步骤中详解。

measure()方法显示判断是否需要重新调用设置改View大小,即调用onMeasure()方法,然后操作两个标识符:

①、重置MEASURED_DIMENSION_SET : onMeasure()方法中,需要添加该标识符,否则,会报异常;

②、添加LAYOUT_REQUIRED : 表示需要进行layout操作。

最后,保存当前的widthMeasureSpec和heightMeasureSpec值。

Step 3 、调用onMeasure()方法去真正设置View的长宽值,其默认实现为:

01./** 
02.   * Measure the view and its content to determine the measured width and the 
03.   * measured height. This method is invoked by {@link #measure(int, int)} and 
04.   * should be overriden by subclasses to provide accurate and efficient 
05.   * measurement of their contents. 
06.   *  
07.   * @param widthMeasureSpec horizontal space requirements as imposed by the parent. 
08.   *                         The requirements are encoded with 
09.   * @param heightMeasureSpec vertical space requirements as imposed by the parent. 
10.   *                         The requirements are encoded with 
11.   */  
12.  //设置该View本身地大小  
13.  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
14.      setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),  
15.              getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));  
16.  }  
17.    
18.  /** 
19.   * Utility to return a default size. Uses the supplied size if the 
20.   * MeasureSpec imposed no contraints. Will get larger if allowed 
21.   * by the MeasureSpec. 
22.   * 
23.   * @param size Default size for this view 
24.   * @param measureSpec Constraints imposed by the parent 
25.   * @return The size this view should be. 
26.   */  
27.  //@param size参数一般表示设置了android:minHeight属性或者该View背景图片的大小值  
28.  public static int getDefaultSize(int size, int measureSpec) {  
29.      int result = size;    
30.      int specMode = MeasureSpec.getMode(measureSpec);  
31.      int specSize =  MeasureSpec.getSize(measureSpec);  
32.  
33.      //根据不同的mode值,取得宽和高的实际值。  
34.      switch (specMode) {  
35.      case MeasureSpec.UNSPECIFIED:  //表示该View的大小父视图未定,设置为默认值  
36.          result = size;  
37.          break;  
38.      case MeasureSpec.AT_MOST:      //表示该View的大小由父视图指定了  
39.      case MeasureSpec.EXACTLY:  
40.          result = specSize;  
41.          break;  
42.      }  
43.      return result;  
44.  }  
45.  //获得设置了android:minHeight属性或者该View背景图片的大小值, 最为该View的参考值  
46.  protected int getSuggestedMinimumWidth() {  
47.      int suggestedMinWidth = mMinWidth;  //  android:minHeight  
48.  
49.      if (mBGDrawable != null) { // 背景图片对应地Width。  
50.          final int bgMinWidth = mBGDrawable.getMinimumWidth();  
51.          if (suggestedMinWidth < bgMinWidth) {  
52.              suggestedMinWidth = bgMinWidth;  
53.          }  
54.      }  
55.  
56.      return suggestedMinWidth;  
57.  }  
58.  //设置View在measure过程中宽和高  
59.  protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {  
60.      mMeasuredWidth = measuredWidth;  
61.      mMeasuredHeight = measuredHeight;  
62.  
63.      mPrivateFlags |= MEASURED_DIMENSION_SET;  //设置了MEASURED_DIMENSION_SET标记  
64.  }  

主要功能就是根据该View属性(android:minWidth和背景图片大小)和父View对该子View的"测量要求",设置该 View的 mMeasuredWidth 和 mMeasuredHeight 值。

这儿只是一般的View类型地实现方法。一般来说,父View,也就是ViewGroup类型,都需要在重写onMeasure() 方法,遍历所有子View,设置每个子View的大小。基本思想如下:遍历所有子View,设置每个子View的大小。伪代码表示为:

01.//某个ViewGroup类型的视图  
02.protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
03.  //必须调用super.ononMeasure()或者直接调用setMeasuredDimension()方法设置该View大小,否则会报异常。  
04.  super.onMeasure(widthMeasureSpec , heightMeasureSpec)  
05.     //setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),  
06.     //        getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));  
07.       
08.  //遍历每个子View  
09.  for(int i = 0 ; i < getChildCount() ; i++){  
10.    View child = getChildAt(i);  
11.    //调用子View的onMeasure,设置他们的大小。childWidthMeasureSpec , childHeightMeasureSpec ?  
12.    child.onMeasure(childWidthMeasureSpec, childHeightMeasureSpec);  
13.  }  
14.}  

Step 2、Step 3 代码也比较好理解,但问题是我们示例代码中widthMeasureSpec、heightMeasureSpec是如何确定的呢?父View是如何设定其值的?

要想回答这个问题,我们看是去源代码里找找答案吧。在ViewGroup.java类中,为我们提供了三个方法,去设置每个子View的大小,基本思想也如同我们之前描述的思想:遍历所有子View,设置每个子View的大小。

主要有如下方法:

01./** 
02. * Ask all of the children of this view to measure themselves, taking into 
03. * account both the MeasureSpec requirements for this view and its padding. 
04. * We skip children that are in the GONE state The heavy lifting is done in 
05. * getChildMeasureSpec. 
06. */  
07.//widthMeasureSpec 和  heightMeasureSpec 表示该父View的布局要求  
08.//遍历每个子View,然后调用measureChild()方法去实现每个子View大小  
09.protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {  
10.    final int size = mChildrenCount;  
11.    final View[] children = mChildren;  
12.    for (int i = 0; i < size; ++i) {  
13.        final View child = children[i];  
14.        if ((child.mViewFlags & VISIBILITY_MASK) != GONE) { // 不处于 “GONE” 状态  
15.            measureChild(child, widthMeasureSpec, heightMeasureSpec);  
16.        }  
17.    }  
18.}  
19.     
20./** 
21. * Ask one of the children of this view to measure itself, taking into 
22. * account both the MeasureSpec requirements for this view and its padding. 
23. * The heavy lifting is done in getChildMeasureSpec. 
24. * 
25. * @param child The child to measure 
26. * @param parentWidthMeasureSpec The width requirements for this view 
27. * @param parentHeightMeasureSpec The height requirements for this view 
28. */  
29.//测量每个子View高宽时,清楚了该View本身的边距大小,即android:padding属性 或android:paddingLeft等属性标记  
30.protected void measureChild(View child, int parentWidthMeasureSpec,  
31.        int parentHeightMeasureSpec) {  
32.    final LayoutParams lp = child.getLayoutParams(); // LayoutParams属性  
33.    //设置子View的childWidthMeasureSpec属性,去除了该父View的边距值  mPaddingLeft + mPaddingRight  
34.    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,  
35.            mPaddingLeft + mPaddingRight, lp.width);  
36.    //设置子View的childHeightMeasureSpec属性,去除了该父View的边距值  mPaddingTop + mPaddingBottom  
37.    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,  
38.            mPaddingTop + mPaddingBottom, lp.height);  
39.  
40.    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
41.}  

measureChildren()方法:遍历所有子View,调用measureChild()方法去设置该子View的属性值。

measureChild() 方法 : 获取特定子View的widthMeasureSpec、heightMeasureSpec,调用measure()方法设置子View的实际宽高值。

getChildMeasureSpec()就是获取子View的widthMeasureSpec、heightMeasureSpec值。

01./** 
02. * Does the hard part of measureChildren: figuring out the MeasureSpec to 
03. * pass to a particular child. This method figures out the right MeasureSpec 
04. * for one dimension (height or width) of one child view. 
05. * 
06. * The goal is to combine information from our MeasureSpec with the 
07. * LayoutParams of the child to get the best possible results. 
08. */  
09.// spec参数       表示该父View本身所占的widthMeasureSpec 或  heightMeasureSpec值  
10.// padding参数  表示该父View的边距大小,见于android:padding属性 或android:paddingLeft等属性标记  
11.// childDimension参数  表示该子View内部LayoutParams属性的值,可以是wrap_content、match_parent、
一个精确指(an exactly size),  
12.//           例如:由android:width指定等。  
13.public static int getChildMeasureSpec(int spec, int padding, int childDimension) {  
14.    int specMode = MeasureSpec.getMode(spec);  //获得父View的mode  
15.    int specSize = MeasureSpec.getSize(spec);  //获得父View的实际值  
16.  
17.    int size = Math.max(0, specSize - padding); //父View为子View设定的大小,减去边距值,  
18.  
19.    int resultSize = 0;    //子View对应地 size 实际值 ,由下面的逻辑条件赋值  
20.    int resultMode = 0;    //子View对应地 mode 值 , 由下面的逻辑条件赋值  
21.  
22.    switch (specMode) {  
23.    // Parent has imposed an exact size on us  
24.    //1、父View是EXACTLY的 !  
25.    case MeasureSpec.EXACTLY:   
26.        //1.1、子View的width或height是个精确值 (an exactly size)  
27.        if (childDimension >= 0) {            
28.            resultSize = childDimension;         //size为精确值  
29.            resultMode = MeasureSpec.EXACTLY;    //mode为 EXACTLY 。  
30.        }   
31.        //1.2、子View的width或height为 MATCH_PARENT/FILL_PARENT   
32.        else if (childDimension == LayoutParams.MATCH_PARENT) {  
33.            // Child wants to be our size. So be it.  
34.            resultSize = size;                   //size为父视图大小  
35.            resultMode = MeasureSpec.EXACTLY;    //mode为 EXACTLY 。  
36.        }   
37.        //1.3、子View的width或height为 WRAP_CONTENT  
38.        else if (childDimension == LayoutParams.WRAP_CONTENT) {  
39.            // Child wants to determine its own size. It can‘t be  
40.            // bigger than us.  
41.            resultSize = size;                   //size为父视图大小  
42.            resultMode = MeasureSpec.AT_MOST;    //mode为AT_MOST 。  
43.        }  
44.        break;  
45.  
46.    // Parent has imposed a maximum size on us  
47.    //2、父View是AT_MOST的 !      
48.    case MeasureSpec.AT_MOST:  
49.        //2.1、子View的width或height是个精确值 (an exactly size)  
50.        if (childDimension >= 0) {  
51.            // Child wants a specific size... so be it  
52.            resultSize = childDimension;        //size为精确值  
53.            resultMode = MeasureSpec.EXACTLY;   //mode为 EXACTLY 。  
54.        }  
55.        //2.2、子View的width或height为 MATCH_PARENT/FILL_PARENT  
56.        else if (childDimension == LayoutParams.MATCH_PARENT) {  
57.            // Child wants to be our size, but our size is not fixed.  
58.            // Constrain child to not be bigger than us.  
59.            resultSize = size;                  //size为父视图大小  
60.            resultMode = MeasureSpec.AT_MOST;   //mode为AT_MOST  
61.        }  
62.        //2.3、子View的width或height为 WRAP_CONTENT  
63.        else if (childDimension == LayoutParams.WRAP_CONTENT) {  
64.            // Child wants to determine its own size. It can‘t be  
65.            // bigger than us.  
66.            resultSize = size;                  //size为父视图大小  
67.            resultMode = MeasureSpec.AT_MOST;   //mode为AT_MOST  
68.        }  
69.        break;  
70.  
71.    // Parent asked to see how big we want to be  
72.    //3、父View是UNSPECIFIED的 !  
73.    case MeasureSpec.UNSPECIFIED:  
74.        //3.1、子View的width或height是个精确值 (an exactly size)  
75.        if (childDimension >= 0) {  
76.            // Child wants a specific size... let him have it  
77.            resultSize = childDimension;        //size为精确值  
78.            resultMode = MeasureSpec.EXACTLY;   //mode为 EXACTLY  
79.        }  
80.        //3.2、子View的width或height为 MATCH_PARENT/FILL_PARENT  
81.        else if (childDimension == LayoutParams.MATCH_PARENT) {  
82.            // Child wants to be our size... find out how big it should  
83.            // be  
84.            resultSize = 0;                        //size为0! ,其值未定  
85.            resultMode = MeasureSpec.UNSPECIFIED;  //mode为 UNSPECIFIED  
86.        }   
87.        //3.3、子View的width或height为 WRAP_CONTENT  
88.        else if (childDimension == LayoutParams.WRAP_CONTENT) {  
89.            // Child wants to determine its own size.... find out how  
90.            // big it should be  
91.            resultSize = 0;                        //size为0! ,其值未定  
92.            resultMode = MeasureSpec.UNSPECIFIED;  //mode为 UNSPECIFIED  
93.        }  
94.        break;  
95.    }  
96.    //根据上面逻辑条件获取的mode和size构建MeasureSpec对象。  
97.    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);  
98.}  

为了便于分析,我将上面的逻辑判断语句使用列表项进行了说明.

getChildMeasureSpec()方法的主要功能如下:

根据父View的measureSpec值(widthMeasureSpec,heightMeasureSpec)值以及子View的子View内部LayoutParams属性值,共同决定子View的measureSpec值的大小。主要判断条件主要为MeasureSpec的mode类型以及LayoutParams的宽高实际值(lp.width,lp.height),见于以上所贴代码中的列表项: 1、 1.1 ; 1.2 ; 1.3 ; 2、2.1等。

例如,分析列表3:假设当父View为MeasureSpec.UNSPECIFIED类型,即未定义时,只有当子View的width或height指定时,其mode才为MeasureSpec.EXACTLY,否者该View size为 0 ,mode为MeasureSpec.UNSPECIFIED时,即处于未指定状态。

由此可以得出, 每个View大小的设定都事由其父View以及该View共同决定的。但这只是一个期望的大小,每个View在测量时最终大小的设定是由setMeasuredDimension()最终决定的。因此,最终确定一个View的“测量长宽“是由以下几个方面影响:

  1. 父View的MeasureSpec属性;
  2. 子View的LayoutParams属性 ;
  3. setMeasuredDimension()或者其它类似设定 mMeasuredWidth 和 mMeasuredHeight 值的方法。

setMeasuredDimension()原型:

01.//设置View在measure过程中宽和高  
02.protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {  
03.    mMeasuredWidth = measuredWidth;  
04.    mMeasuredHeight = measuredHeight;  
05.  
06.    mPrivateFlags |= MEASURED_DIMENSION_SET;  //设置了MEASURED_DIMENSION_SET标记  
07.}

将上面列表项转换为表格为:

技术分享

这张表格更能帮助我们分析View的MeasureSpec的确定条件关系。

为了帮助大家理解,下面我们分析某个窗口使用地xml布局文件,我们弄清楚该xml布局文件中每个View的

MeasureSpec值的组成。

 

01.<?xml version="1.0" encoding="utf-8"?>  
02.<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
03.    android:id="@+id/llayout"  
04.       android:orientation="vertical"   
05.    android:layout_width="match_parent"  
06.       android:layout_height="match_parent">  
07.      
08.      
09.    <TextView android:id="@+id/tv"   
10.        android:layout_width="match_parent"  
11.        android:layout_height="wrap_content"  
12.        android:text="@string/hello" />  
13.  
14.</LinearLayout> 

该布局文件共有两个View: ①、id为llayout的LinearLayout布局控件 ;②、id为tv的TextView控件。

假设LinearLayout的父View对应地widthSpec和heightSpec值皆为MeasureSpec.EXACTLY类型(Activity窗口的父View为DecorView,具体原因见第三部分说明)。

对LinearLayout而言比较简单,由于 android:layout_width="match_parent",因此其width对应地widthSpec mode值为MeasureSpec.EXACTLY , size由父视图大小指定 ; 由于android:layout_height = "match_parent",因此其height对应地heightSpec mode值为MeasureSpec.EXACTLY,size由父视图大小指定 ;

对TextView而言 ,其父View为LinearLayout的widthSpec和heightSpec值皆为MeasureSpec.EXACTLY类型,由于android:layout_width="match_parent" , 因此其width对应地widthSpec mode值为MeasureSpec.EXACTLY,size由父视图大小指定 ; 由于android:layout_width="wrap_content" , 因此其height对应地widthSpec mode值为MeasureSpec.AT_MOST,size由父视图大小指定 。

我们继续窥测下LinearLayout类是如何进行measure过程的:

01. public class LinearLayout extends ViewGroup {  
02....  
03.@Override  //onMeasure方法。  
04.protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
05.    //判断是垂直方向还是水平方向,这儿我们假设是VERTICAL垂直方向,  
06.    if (mOrientation == VERTICAL) {  
07.        measureVertical(widthMeasureSpec, heightMeasureSpec);  
08.    } else {  
09.        measureHorizontal(widthMeasureSpec, heightMeasureSpec);  
10.    }  
11.}  
12.//垂直方向布局  
13.   void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {  
14.       mTotalLength = 0;         //该LinearLayout测量子View时的总高度。  
15.    float totalWeight = 0;    //所有子View的权重和 , android:layout_weight  
16.    int maxWidth = 0;         //保存子View中最大width值  
17.       ...  
18.       final int count = getVirtualChildCount();  //子View的个数  
19.         
20.       final int widthMode = MeasureSpec.getMode(widthMeasureSpec);  
21.       final int heightMode = MeasureSpec.getMode(heightMeasureSpec);  
22.          ...  
23.       // See how tall everyone is. Also remember max width.  
24.       for (int i = 0; i < count; ++i) {  
25.           final View child = getVirtualChildAt(i);  
26.              ...  
27.           LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();  
28.  
29.           totalWeight += lp.weight;    
30.           //满足该条件地View会在该LinearLayout有剩余高度时,才真正调用measure()  
31.           if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {  
32.               ...  
33.           } else {  
34.               int oldHeight = Integer.MIN_VALUE;  
35.               //如果View的hight值为0,并且设置了android:layout_weight属性,重新纠正其height值为WRAP_CONTENT  
36.               if (lp.height == 0 && lp.weight > 0) {  
37.                   oldHeight = 0;  
38.                   lp.height = LayoutParams.WRAP_CONTENT;  
39.               }  
40.               // Determine how big this child would like to be. If this or  
41.               // previous children have given a weight, then we allow it to  
42.               // use all available space (and we will shrink things later  
43.               // if needed).  
44.               //对每个子View调用measure()方法  
45.               measureChildBeforeLayout(  
46.                      child, i, widthMeasureSpec, 0, heightMeasureSpec,  
47.                      totalWeight == 0 ? mTotalLength : 0);  
48.                 
49.               //这三行代码做了如下两件事情:  
50.               //1、获得该View的measuredHeight值,每个View都会根据他们地属性正确设置值  > 0 ;  
51.               //2、更新mTotalLength值:取当前高度mTotalLength值与mTotalLength + childHeight 的最大值  
52.               // 于是对于android:layout_height="wrap_height"属性地LinearLayout控件也就知道了它的确切高度值了。  
53.               final int childHeight = child.getMeasuredHeight();  
54.               final int totalLength = mTotalLength;  
55.               mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +  
56.                      lp.bottomMargin + getNextLocationOffset(child));  
57.               ...  
58.           }  
59.           final int margin = lp.leftMargin + lp.rightMargin;  
60.           final int measuredWidth = child.getMeasuredWidth() + margin;  
61.           maxWidth = Math.max(maxWidth, measuredWidth);  
62.           ...  
63.       }  
64.          //后续还有很多处理,包括继续measure()某些符合条件地子View  
65.       ...  
66.   }  
67.   void measureChildBeforeLayout(View child, int childIndex,  
68.           int widthMeasureSpec, int totalWidth, int heightMeasureSpec,  
69.           int totalHeight) {  
70.    //调用measureChildWithMargins()方法去设置子View大小  
71.       measureChildWithMargins(child, widthMeasureSpec, totalWidth,  
72.               heightMeasureSpec, totalHeight);  
73.   }  
74....  

继续看看measureChildWithMargins()方法,该方法定义在ViewGroup.java内,基本流程同于measureChild()方法,但添加了对子View Margin的处理,即:android:margin属性或者android:marginLeft等属性的处理。

measureChildWithMargins@ViewGroup.java

 01./** 
02. * Ask one of the children of this view to measure itself, taking into 
03. * account both the MeasureSpec requirements for this view and its padding 
04. * and margins. The child must have MarginLayoutParams The heavy lifting is 
05. * done in getChildMeasureSpec. 
06. */  
07.//基本流程同于measureChild()方法,但添加了对子View Margin的处理,
即:android:margin属性或者android:marginLeft等属性的处理  
08.//widthUsed参数  表示该父View已经使用的宽度  
09.//heightUsed参数  表示该父View已经使用的高度  
10.protected void measureChildWithMargins(View child,  
11.        int parentWidthMeasureSpec, int widthUsed,  
12.        int parentHeightMeasureSpec, int heightUsed) {  
13.    final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();  
14.  
15.    //获得子View的childWidthMeasureSpec和childHeightMeasureSpec值  
16.    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,  
17.            mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin  
18.                    + widthUsed, lp.width);  
19.    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,  
20.            mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin  
21.                    + heightUsed, lp.height);  
22.  
23.    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
24.} 

measure()过程时,LinearLayout类做了如下事情 :

1、遍历每个子View,对其调用measure()方法;

2、子View measure()完成后,需要取得该子View地宽高实际值,继而做处理(例如:LinearLayout属性为android:widht="wrap_content"时,LinearLayout的实际width值则是每个子View的width值的累加值)。

2.2 WRAP_CONTENT、MATCH_PARENT以及measure动机揭秘子View地宽高实际值 ,即child.getMeasuredWidth()值得返回最终会是一个确定值? 难道WRAP_CONTENT(其值为-2) 、MATCH_PARENT(值为-1)或者说一个具体值(an exactly size > 0)。前面我们说过,View最终“测量”值的确定是有三个部分组成地:

①、父View的MeasureSpec属性;

②、子View的LayoutParams属性 ;

③、setMeasuredDimension()或者其它类似设定 mMeasuredWidth 和 mMeasuredHeight 值的方法。

因此,一个View必须以某种合适地方法确定它地最终大小。例如,如下自定义View:

01.//自定义View     
02.public Class MyView extends View {  
03.      
04.     //针对不同地mode值,设置本View地大小  
05.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){  
06.         //获得父View传递给我们地测量需求  
07.         int widthMode = MeasureSpec.getMode(widthMeasureSpec);  
08.         int heightMode = MeasureSpec.getMode(heightMeasureSpec);  
09.           
10.         int width = 0 ;  
11.         int height = 0 ;  
12.         //对UNSPECIFIED 则抛出异常  
13.         if(widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED)  
14.             throw new RuntimeException("widthMode or heightMode cannot be UNSPECIFIED");  
15.          
16.         //精确指定  
17.         if(widthMode == MeasureSpec.EXACTLY){  
18.             width = 100 ;  
19.         }  
20.         //模糊指定  
21.         else if(widthMode == MeasureSpec.AT_MOST )  
22.             width = 50 ;   
23.           
24.          //精确指定  
25.         if(heightMode == MeasureSpec.EXACTLY){  
26.             height = 100 ;  
27.         }  
28.         //模糊指定  
29.         else if(heightMode == MeasureSpec.AT_MOST )  
30.             height = 50 ;  
31.           
32.         setMeasuredDimension(width , height) ;  
33.     }  
34.}  

该自定义View重写了onMeasure()方法,根据传递过来的widthMeasureSpec和heightMeasureSpec简单设置了该View的mMeasuredWidth 和 mMeasuredHeight值。

对于TextView而言,如果它地mode不是Exactly类型 , 它会根据一些属性,例如:android:textStyle、android:textSizeandroid:typeface等去确定TextView类地需要占用地长和宽。

因此,如果你地自定义View必须手动对不同mode做出处理。否则,则是mode对你而言是无效的。

Android框架中提供地一系列View/ViewGroup都需要去进行这个measure()过程地 ,因为在layout()过程中,父View需要调用getMeasuredWidth()或getMeasuredHeight()去为每个子View设置他们地布局坐标,只有确定布局坐标后,才能真正地将该View 绘制(draw)出来,否则该View的layout大小为0,得不到期望效果。我们继续看看LinearLayout的layout布局过程:

01.public class LinearLayout extends ViewGroup {  
02.    ...  
03.    @Override  //layout 过程  
04.    protected void onLayout(boolean changed, int l, int t, int r, int b) {  
05.        //假定是垂直方向布局  
06.        if (mOrientation == VERTICAL) {  
07.            layoutVertical();  
08.        } else {  
09.            layoutHorizontal();  
10.        }  
11.    }  
12.    //对每个子View调用layout过程  
13.    void layoutVertical() {  
14.        ...  
15.        final int count = getVirtualChildCount();  
16.        ...  
17.        for (int i = 0; i < count; i++) {  
18.            final View child = getVirtualChildAt(i);  
19.            if (child == null) {  //一般为非null  
20.                childTop += measureNullChild(i);  
21.            } else if (child.getVisibility() != GONE) {  
22.                //获得子View测量时的实际宽高值,  
23.                final int childWidth = child.getMeasuredWidth();  
24.                final int childHeight = child.getMeasuredHeight();  
25.                  
26.                ...  
27.                //  封装了child.layout()方法,见如下  
28.                setChildFrame(child, childLeft, childTop + getLocationOffset(child),  
29.                        childWidth, childHeight);   
30.                childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);  
31.  
32.                i += getChildrenSkipCount(child, i);  
33.            }  
34.        }  
35.    }  
36.    //width = getMeasuredWidth() ; height = childHeight(); View的大小就是测量大小  
37.    private void setChildFrame(View child, int left, int top, int width, int height) {  
38.          
39.        child.layout(left, top, left + width, top + height);  
40.    }  
41.    ...  
42.}  

对一个View进行measure操作地主要目的就是为了确定该View地布局大小,见上面所示代码。但measure操作通常是耗时的,因此对自定义ViewGroup而言,我们可以自由控制measure、layout过程,如果我们知道如何layout一个View,我们可以跳过该ViewGroup地measure操作(onMeasure()方法中measure所有子View地),直接去layout

在前面一篇博客<<Android中滑屏初探 ---- scrollTo 以及 scrollBy方法使用说明>>中,我们自定义了一个 ViewGroup, 并且重写了onMeasure()和onLayout()方法去分别操作每个View。就该ViewGroup而言,我们只需要重写onLayout()操作即可,因为我们知道如何layout每个子View。如下代码所示:

01.//自定义ViewGroup , 包含了三个LinearLayout控件,存放在不同的布局位置  
02.public class MultiViewGroup extends ViewGroup {  
03.    private void init() {  
04.        // 初始化3个 LinearLayout控件  
05.        LinearLayout oneLL = new LinearLayout(mContext);  
06.        oneLL.setBackgroundColor(Color.RED);  
07.        addView(oneLL);  
08.        ...  
09.    }  
10.    @Override  
11.    // 我们知晓每个子View的layout布局大小,因此我们不需要为每个子View进行measure()操作了。  
12.//  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
13.//      setMeasuredDimension(width, height);  
14.//      // 设置该ViewGroup的大小  
15.//      int width = MeasureSpec.getSize(widthMeasureSpec);  
16.//      int height = MeasureSpec.getSize(heightMeasureSpec);  
17.//      int childCount = getChildCount();  
18.//      for (int i = 0; i < childCount; i++) {  
19.//          View child = getChildAt(i);  
20.//          // 设置每个子视图的大小 , 即全屏  
21.//          child.measure(MultiScreenActivity.screenWidth, MultiScreenActivity.scrrenHeight);  
22.//      }  
23.    }  
24.  
25.    // layout过程  
26.    @Override  
27.    protected void onLayout(boolean changed, int l, int t, int r, int b) {  
28.        // TODO Auto-generated method stub  
29.        Log.i(TAG, "--- start onLayout --");  
30.        int startLeft = 0; // 每个子视图的起始布局坐标  
31.        int startTop = 10; // 间距设置为10px 相当于 android:marginTop= "10px"  
32.        int childCount = getChildCount();  
33.        Log.i(TAG, "--- onLayout childCount is -->" + childCount);  
34.        for (int i = 0; i < childCount; i++) {  
35.            View child = getChildAt(i);  
36.            child.layout(startLeft, startTop,   
37.                    startLeft + MultiScreenActivity.screenWidth,   
38.                    startTop + MultiScreenActivity.scrrenHeight);  
39.            startLeft = startLeft + MultiScreenActivity.screenWidth ; //校准每个子View的起始布局位置  
40.            //三个子视图的在屏幕中的分布如下 [0 , 320] / [320,640] / [640,960]  
41.        }  
42.    }  
43.}  

3、root View被添加至窗口时,UI框架是如何设置其LayoutParams值

老子道德经有言:“道生一,一生二,二生三,三生万物。” UI绘制也就是个递归过程。理解其基本架构后,也就“掌握了一个中心点”了。在第一节中,我们没有说明开始UI绘制时 ,没有说明mView.measure()参数地由来,参数也就是我们本节需要弄懂的“道” --- root View的 widthMeasureSpec和heightMeasureSpec 是如何确定的。

对于如下布局文件: main.xml

01.<?xml version="1.0" encoding="utf-8"?>  
02.<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
03.    android:orientation="vertical"  
04.    android:layout_width="fill_parent"  
05.    android:layout_height="fill_parent"  
06.    >  
07.<TextView    
08.    android:layout_width="fill_parent"   
09.    android:layout_height="wrap_content"   
10.    android:text="@string/hello"  
11.    />  
12.</LinearLayout>  

当使用LayoutInflater类解析成View时 ,LinearLayout对象的LayoutParams参数为null 。具体原因请参考上篇博文

任何一个View被添加至窗口时,都需要利用WindowManager类去操作。例如,如下代码:

01.//显示一个悬浮窗吧 , just so so   
02.public void showView()  
03.{  
04.    //解析布局文件  
05.    LayoutInflater layoutInflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
06.    //rootView对应地LayoutParams属性值为null,将会在UI绘制时设定其值  
07.    View rootView = layoutInflater.inflate(R.layout.main, null);  
08.      
09.    WindowManager windowManager = (WindowManager)getSystemService(Context.WINDOW_SERVICE);  
10.    //设置WindowManager.LayoutParams参数值,作为该窗口的各种属性  
11.    WindowManager.LayoutParams winparams = WindowManager.LayoutParams();  
12.     // 以屏幕左上角为原点,设置x、y初始值  
13.    winparams.x = 0;  
14.    winparams.y = 0;  
15.  
16.    //设置悬浮窗口长宽数据  
17.    winparams.width = WindowManager.LayoutParams.WRAP_CONTENT;;  
18.    winparams.height = WindowManager.LayoutParams.WRAP_CONTENT;;  
19.       
20.    windowManager.addView(rootView, winparams);  
21.}  

下面,我们从获得WindowManager对象引用开始,一步步观察addView()做了一些什么事情。

Step 1 、获得WindowManager对象服务 ,具体实现类在ContextImpl.java内中

路径: /frameworks/base/core/java/android/app/ContextImpl.java

01.@Override  
02.public Object getSystemService(String name) {  
03.    if (WINDOW_SERVICE.equals(name)) {  
04.        return WindowManagerImpl.getDefault();  
05.    }  
06.    ...  
07.} 

WindowManager是个接口,具体返回对象则是WindowManagerImpl的单例对象。

Step 2 、 获得WindowManagerImpl的单例对象,以及部分源码分析

路径: /frameworks/base/core/java/android/view/WindowManagerImpl.java

01.public class WindowManagerImpl implements WindowManager{  
02.         
03.   public static WindowManagerImpl getDefault()  
04.   {  
05.       return mWindowManager;  
06.   }  
07.   //以特定Window属性添加一个窗口  
08.   public void addView(View view, ViewGroup.LayoutParams params)  
09.   {  
10.       addView(view, params, false);  
11.   }  
12.   //参数nest表示该窗口是不是一个字窗口  
13.   private void addView(View view, ViewGroup.LayoutParams params, boolean nest)  
14.   {   ...  
15.       final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;  
16.         
17.       ViewRoot root;  
18.       View panelParentView = null;    //该子窗口对应地父窗口View  
19.         
20.       synchronized (this) {  
21.            
22.           ...//需要对传递过来地参数进行检测...  
23.             
24.           //对每个窗口皆构建一个ViewRoot对象  
25.           root = new ViewRoot(view.getContext());  
26.           root.mAddNesting = 1;  
27.           //设置root View 的LayoutParams为wparams,即WindowManager.LayoutParams类型  
28.           view.setLayoutParams(wparams);  
29.           ...//对参数检测,以及拷贝原有数组...  
30.             
31.           //将窗口对应地view、root、wparams保存在属性集合中  
32.           mViews[index] = view;  
33.           mRoots[index] = root;  
34.           mParams[index] = wparams;  
35.       }  
36.       // do this last because it fires off messages to start doing things  
37.       // 调用ViewRoot对象去通知系统添加一个窗口  
38.       root.setView(view, wparams, panelParentView);  
39.   }  
40.   ...  
41.   //这三个数组分别保存了一个窗口对应地属性  
42.   private View[] mViews;         //root View对象 , View类型  
43.   private ViewRoot[] mRoots;     //ViewRoot类型 , 与WMS通信  
44.   private WindowManager.LayoutParams[] mParams;  //窗口属性  
45.     
46.   //WindowManagerImpl实现了单例模式  
47.   private static WindowManagerImpl mWindowManager = new WindowManagerImpl();  
48.}  

WindowManagerImpl类的三个数组集合保存了每个窗口相关属性,这样我们可以通过这些属性去操作特定的窗口(例如,可以根据View去更新/销毁该窗口)。当参数检查成功时,构建一个ViewRoot对象,并且设置设置root View 的LayoutParams为wparams,即WindowManager.LayoutParams类型。最后调用root.setView()方法去通知系统需要创建该窗口。我们接下来往下看看ViewRoot类相关操作。

Step 3、

01.public final class ViewRoot extends Handler implements ViewParent,View.AttachInfo.Callbacks {  
02.         
03.    View mView;   //所有窗口地root View     
04.    final WindowManager.LayoutParams mWindowAttributes = new WindowManager.LayoutParams();    
05.  
06.    ...  
07.     /** 
08.     * We have one child 
09.     */  
10.    public void setView(View view, WindowManager.LayoutParams attrs,  
11.            View panelParentView) {  
12.        synchronized (this) {  
13.            if (mView == null) {  
14.                mView = view;  
15.                mWindowAttributes.copyFrom(attrs); //保存WindowManager.LayoutParams属性值  
16.                attrs = mWindowAttributes;  
17.                ...  
18.                  
19.                mAdded = true;  
20.                int res; /* = WindowManagerImpl.ADD_OKAY; */  
21.  
22.                // Schedule the first layout -before- adding to the window  
23.                // manager, to make sure we do the relayout before receiving  
24.                // any other events from the system.  
25.                requestLayout();   //请求UI开始绘制。  
26.                mInputChannel = new InputChannel();  //创建一个InputChannel对象,接受消息  
27.                try {  
28.                    //通知WindowManagerService添加一个窗口  
29.                    res = sWindowSession.add(mWindow, mWindowAttributes,  
30.                            getHostVisibility(), mAttachInfo.mContentInsets,  
31.                            mInputChannel);  
32.                }   
33.                ...  
34.                view.assignParent(this);  //将root View的父View设置为该ViewRoot对象(实现了ViewParent接口)  
35.                ...  
36.            }  
37.        }  
38.    }  
39.}  

说明:ViewRoot类继承了Handler,实现了ViewParent接口

setView()方法地主要功能如下:

  1. 保存相关属性值,例如:mView、mWindowAttributes等;
  2. 调用requestLayout()方法请求UI绘制,由于ViewRoot是个Handler对象,异步请求;
  3. 通知WindowManagerService添加一个窗口;
  4. 注册一个事件监听管道,用来监听:按键(KeyEvent)和触摸(MotionEvent)事件。

我们这儿重点关注 requestLayout()方法请求UI绘制地流程。

Step 4、异步调用请求UI绘制

01./** 
02. * {@inheritDoc} 
03. */  
04.public void requestLayout() {  
05.    checkThread();        //检查是不是UI线程调用,如果不是UI线程,会报异常  
06.    mLayoutRequested = true;   //置为真,表示需要进行measure和layout过程  
07.    scheduleTraversals();    
08.}  
09.//开始UI绘制流程  
10.public void scheduleTraversals() {  
11.    if (!mTraversalScheduled) {  
12.        mTraversalScheduled = true;       //防止多次调用  
13.        sendEmptyMessage(DO_TRAVERSAL);   //异步请求UI绘制  
14.    }  
15.}  
16.@Override  
17.public void handleMessage(Message msg) {  
18. switch (msg.what) {  
19.        case DO_TRAVERSAL:  
20.             performTraversals();  //开始UI绘制  
21.             break;  
22. }  
23.}  

由于performTraversals()方法比较复杂,我们侧重于第一次设置root View的widhtSpecSize以及

heightSpecSize值。

01.private void performTraversals() {  
02.    // cache mView since it is used so much below...  
03.    final View host = mView;  
04.  
05.    mTraversalScheduled = false;           
06.    boolean surfaceChanged = false;  
07.    WindowManager.LayoutParams lp = mWindowAttributes;    
08.  
09.    int desiredWindowWidth;              //表示该窗口期望width值  
10.    int desiredWindowHeight;             //表示该窗口期望width值  
11.    int childWidthMeasureSpec;           //保存root View的widthMeasureSpec  
12.    int childHeightMeasureSpec;          //保存root View的heightMeasureSpec  
13.  
14.    final View.AttachInfo attachInfo = mAttachInfo;  
15.  
16.    final int viewVisibility = getHostVisibility();  
17.    boolean viewVisibilityChanged = mViewVisibility != viewVisibility  
18.            || mNewSurfaceNeeded;  
19.  
20.    float appScale = mAttachInfo.mApplicationScale;  
21.  
22.    WindowManager.LayoutParams params = null;  
23.    if (mWindowAttributesChanged) {  
24.        mWindowAttributesChanged = false;  
25.        surfaceChanged = true;  
26.        params = lp;  
27.    }  
28.    Rect frame = mWinFrame;  
29.    if (mFirst) {   //mFirst表示是否是第一次绘制该Window  
30.        fullRedrawNeeded = true;  
31.        mLayoutRequested = true;  
32.  
33.        DisplayMetrics packageMetrics =  
34.            mView.getContext().getResources().getDisplayMetrics();  
35.        //第一次绘制时desiredWindowWidth,desiredWindowHeight 值大小为屏幕大小  
36.        desiredWindowWidth = packageMetrics.widthPixels;  
37.        desiredWindowHeight = packageMetrics.heightPixels;  
38.        ...  
39.    } else {   //不是第一次绘制,则desiredWindowWidth值为frame保存大小,frame值会由WMS填充  
40.        desiredWindowWidth = frame.width();  
41.        desiredWindowHeight = frame.height();  
42.        ...  
43.    }  
44.    ...  
45.    boolean insetsChanged = false;  
46.  
47.    if (mLayoutRequested) {  
48.        ...//获得root View的widthMeasureSpec 和 heightMeasureSpec值  
49.        childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);  
50.        childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);  
51.        //开始measure过程  
52.        host.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
53.    }  
54.    ...  
55.    final boolean didLayout = mLayoutRequested;  
56.      
57.    boolean triggerGlobalLayoutListener = didLayout  
58.            || attachInfo.mRecomputeGlobalAttributes;  
59.    if (didLayout) {  
60.        ... //layout过程  
61.       host.layout(0, 0, host.mMeasuredWidth, host.mMeasuredHeight);  
62.        ...  
63.    }  
64.    ...  
65.    if (!cancelDraw && !newSurface) {  
66.        mFullRedrawNeeded = false;  
67.        draw(fullRedrawNeeded);  
68.        ...  
69.}  

 

01./** 
02.  * @param windowSize  The available width or height of the window 
03.  * 
04.  * @param rootDimension The layout params for one dimension (width or height) of the window. 
05. */  
06. private int getRootMeasureSpec(int windowSize, int rootDimension) {  
07.     int measureSpec;  
08.     switch (rootDimension) {  
09.     case ViewGroup.LayoutParams.MATCH_PARENT:  
10.         // Window can‘t resize. Force root view to be windowSize.  
11.         measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);  
12.         break;  
13.     case ViewGroup.LayoutParams.WRAP_CONTENT:  
14.         // Window can resize. Set max size for root view.  
15.         measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);  
16.         break;  
17.     default:  
18.         // Window wants to be an exact size. Force root view to be that size.  
19.         measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);  
20.         break;  
21.     }  
22.     return measureSpec;  
23. } 

调用root View的measure()方法时,其参数是由getRootMeasureSpec()设置的,基本思路同我们前面描述的

差不多。贴出来的代码只是简简单单列出了measure 、layout 、 draw 过程的调用点,里面有很多逻辑处理,

Android中measure过程、WRAP_CONTENT详解以及 xml布局文件解析流程浅析

标签:

原文地址:http://www.cnblogs.com/duanweishi/p/4301742.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!