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

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

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

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

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)  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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> 

01. public class LinearLayout extends ViewGroup {
02....
[email protected]  //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....  

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

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

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

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

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>  

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

[email protected]
02.public Object getSystemService(String name) {
03.    if (WINDOW_SERVICE.equals(name)) {
04.        return WindowManagerImpl.getDefault();
05.    }
06.    ...
07.} 

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

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

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.}
[email protected]
17.public void handleMessage(Message msg) {
18. switch (msg.what) {
19.        case DO_TRAVERSAL:
20.             performTraversals();  //开始UI绘制
21.             break;
22. }
23.}  

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