本文共 16478 字，大约阅读时间需要 54 分钟。

        这里就只是分析Activity中的，对于AppCompatActivity中的，虽实现方式有一些不一样，但原理一样。

        这里先看一下Activity中的setContentView()方法

public void setContentView(@LayoutRes int layoutResID) {    getWindow().setContentView(layoutResID);    initWindowDecorActionBar();}

可以看出，getWindow()返回的是Window对象，我们可以看一下Activity的attach()方法，Wondow对象就是在这里进行赋值的：

mWindow = new PhoneWindow(this, window, activityConfigCallback);

从这我们知道setContentView()实际调用的就是PhoneWindow的方法，如果你对Window比较了解的话，那就应该知道Window是一个抽象类，它的唯一实现类就是PhoneWindow。

        PhoneWindow的setContentView()方法：

public void setContentView(int layoutResID) {    if (mContentParent == null) {        //这里实际上就是创建整个窗口的顶层view，其实是DecorView，        //其中mContentParent就是所要填充view的父布局        installDecor();    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {        mContentParent.removeAllViews();    }    if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {        final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,                getContext());        transitionTo(newScene);    } else {        //这里就是填充出传进来layoutResId的view，并作为没ContentParent的子view        mLayoutInflater.inflate(layoutResID, mContentParent);    }    mContentParent.requestApplyInsets();    final Callback cb = getCallback();    if (cb != null && !isDestroyed()) {        //如果你想在填充完后坐点什么，可以直接重写Activity的onContentChanged()这个方法        //Activity实现了Window.Callback这个接口        cb.onContentChanged();    }    mContentParentExplicitlySet = true;}

对于installDecor()这个方法，如果你感兴趣，可以去看看，平时我们在主题中设置的属性，在这个方法里就有用到。mLayoutInflater实际上是PhoneLayoutInflater实例，继承自LayoutInflater，主要是重写了monCreateView这个方法，我们这里还是来看看LayoutInflater.inflate()这个方法：

public View inflate(XmlPullParser parser, @Nullable ViewGroup root) {    return inflate(parser, root, root != null);}public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot) {    final Resources res = getContext().getResources();    if (DEBUG) {        Log.d(TAG, "INFLATING from resource: \"" + res.getResourceName(resource) + "\" ("                + Integer.toHexString(resource) + ")");    }    //这里拿到xml解析器    final XmlResourceParser parser = res.getLayout(resource);    try {        return inflate(parser, root, attachToRoot);    } finally {        parser.close();    }}/** * parser xml解析器，对于我们传进来的xml的操作主要是通过这个解析器 * root  结合后面attachToRoot这个参数决定是否将生成的view作为root的子view *       如果attachToRoot这个参数为true，root作为xml的父view，如果为false，那么就将 *       root的ViewGroup.LayoutParams参数赋值给xml生成的view * */public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {    synchronized (mConstructorArgs) {        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate");        final Context inflaterContext = mContext;        //获得view的属性集合，就是我们xml中布局view的属性        final AttributeSet attrs = Xml.asAttributeSet(parser);        Context lastContext = (Context) mConstructorArgs[0];        mConstructorArgs[0] = inflaterContext;        View result = root;        try {            // Look for the root node.            int type;            //通过parse拿到xml中的根标签            while ((type = parser.next()) != XmlPullParser.START_TAG &&                    type != XmlPullParser.END_DOCUMENT) {                // Empty            }            if (type != XmlPullParser.START_TAG) {                throw new InflateException(parser.getPositionDescription()                        + ": No start tag found!");            }            //拿到xml中view的标签名            final String name = parser.getName();            if (DEBUG) {                System.out.println("**************************");                System.out.println("Creating root view: "                        + name);                System.out.println("**************************");            }            //标签名是merge时执行            if (TAG_MERGE.equals(name)) {                if (root == null || !attachToRoot) {                    throw new InflateException("
    can be used only with a valid "                            + "ViewGroup root and attachToRoot=true");                }                rInflate(parser, root, inflaterContext, attrs, false);            } else {                // Temp is the root view that was found in the xml                //实例化xml布局中最外层的view                final View temp = createViewFromTag(root, name, inflaterContext, attrs);                ViewGroup.LayoutParams params = null;                if (root != null) {                    if (DEBUG) {                        System.out.println("Creating params from root: " +                                root);                    }                    // Create layout params that match root, if supplied                    //根据root生成LayoutParams，其实就是root的宽高属性                    params = root.generateLayoutParams(attrs);                    if (!attachToRoot) {                        // Set the layout params for temp if we are not                        // attaching. (If we are, we use addView, below)                        //将root的LayoutParams设置到temp中，在测量时会用到                        temp.setLayoutParams(params);                    }                }                if (DEBUG) {                    System.out.println("-----> start inflating children");                }                // Inflate all children under temp against its context.                //实例化剩下的所有view                rInflateChildren(parser, temp, attrs, true);                if (DEBUG) {                    System.out.println("-----> done inflating children");                }                // We are supposed to attach all the views we found (int temp)                // to root. Do that now.                //如果root不为null，并且attachToRoot为true，将实例化出来的view添加到root中                if (root != null && attachToRoot) {                    root.addView(temp, params);                }                // Decide whether to return the root that was passed in or the                // top view found in xml.                if (root == null || !attachToRoot) {                    result = temp;                }            }        } catch (XmlPullParserException e) {            final InflateException ie = new InflateException(e.getMessage(), e);            ie.setStackTrace(EMPTY_STACK_TRACE);            throw ie;        } catch (Exception e) {            final InflateException ie = new InflateException(parser.getPositionDescription()                    + ": " + e.getMessage(), e);            ie.setStackTrace(EMPTY_STACK_TRACE);            throw ie;        } finally {            // Don't retain static reference on context.            mConstructorArgs[0] = lastContext;            mConstructorArgs[1] = null;            Trace.traceEnd(Trace.TRACE_TAG_VIEW);        }        return result;    }}

这里有一个很重要的参数，也是我们平时容易忽视的参数，那就是LayoutParams，这里面存放的是是view的layout_width、layout_heigth、margin等，对view的测量有很大影响。

        上面的生成view的流程主要分为以下几步：

        1、拿到xml的根标签；

        2、判断根标签是否是merge标签，如果是，那么就将merger下的所有view添加到根标签中；

        3、如果只是普通标签，那么就调用createViewFromTag()进行解析生成这个根view；

        4、调用rInflater进行解析，将根view下的所有子view全部实例化。

看下createViewFromTag()是如何根据标签生成view的：

View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,                       boolean ignoreThemeAttr) {    if (name.equals("view")) {        name = attrs.getAttributeValue(null, "class");    }    // Apply a theme wrapper, if allowed and one is specified.    if (!ignoreThemeAttr) {        final TypedArray ta = context.obtainStyledAttributes(attrs, ATTRS_THEME);        final int themeResId = ta.getResourceId(0, 0);        if (themeResId != 0) {            context = new ContextThemeWrapper(context, themeResId);        }        ta.recycle();    }    if (name.equals(TAG_1995)) {        // Let's party like it's 1995!        return new BlinkLayout(context, attrs);    }    try {        View view;        if (mFactory2 != null) {            view = mFactory2.onCreateView(parent, name, context, attrs);        } else if (mFactory != null) {            view = mFactory.onCreateView(name, context, attrs);        } else {            view = null;        }        if (view == null && mPrivateFactory != null) {            view = mPrivateFactory.onCreateView(parent, name, context, attrs);        }        if (view == null) {            final Object lastContext = mConstructorArgs[0];            mConstructorArgs[0] = context;            try {                //如果我们没有去设置mFactory2,mFactory,mPrivateFactory这几个工厂，默认都是为null的                //所以一般都会执行到这里，而对于name，这里做个假设，如果我们的根标签是LinearLayout，                //那么这个name就是"LinearLayout",所以name.indexOf('.')=-1                if (-1 == name.indexOf('.')) {                    view = onCreateView(parent, name, attrs);                } else {                    view = createView(name, null, attrs);                }            } finally {                mConstructorArgs[0] = lastContext;            }        }        return view;    } catch (InflateException e) {        throw e;    } catch (ClassNotFoundException e) {        final InflateException ie = new InflateException(attrs.getPositionDescription()                + ": Error inflating class " + name, e);        ie.setStackTrace(EMPTY_STACK_TRACE);        throw ie;    } catch (Exception e) {        final InflateException ie = new InflateException(attrs.getPositionDescription()                + ": Error inflating class " + name, e);        ie.setStackTrace(EMPTY_STACK_TRACE);        throw ie;    }}

这里会根据name进行解析，如果name中不包含 '.' ，那么就会认为是内置的，这样的话就要给他加上前缀，接下来就来看看是如何给这个name加前缀的：

protected View onCreateView(View parent, String name, AttributeSet attrs)        throws ClassNotFoundException {    return onCreateView(name, attrs);}

这里的onCreateView(name,attrs)实际上调用的就是PhoneLayoutInflater中的方法：

private static final String[] sClassPrefixList = {        "android.widget.",        "android.webkit.",        "android.app."};@Override protected View onCreateView(String name, AttributeSet attrs) throws ClassNotFoundException {    for (String prefix : sClassPrefixList) {        try {            //加上前缀后会通过反射来获取view，如果返回为null，则会使用下一个前缀，直到拿到view            View view = createView(name, prefix, attrs);            if (view != null) {                return view;            }        } catch (ClassNotFoundException e) {            // In this case we want to let the base class take a crack            // at it.        }    }    //这里是调用了父类的方法，其实就是加“android.view”这个前缀    return super.onCreateView(name, attrs);}

这里我们知道会尝试加多个前缀来获取view，如果拿到了那就返回。现在就来看看createView(name,prefix,attrs)这个方法是如何生成view的：

public final View createView(String name, String prefix, AttributeSet attrs)        throws ClassNotFoundException, InflateException {    //从缓存中取出构造函数    Constructor
    constructor = sConstructorMap.get(name);    if (constructor != null && !verifyClassLoader(constructor)) {        constructor = null;        sConstructorMap.remove(name);    }    Class
    clazz = null;    try {        Trace.traceBegin(Trace.TRACE_TAG_VIEW, name);        //缓存中的构造函数为null        if (constructor == null) {            // Class not found in the cache, see if it's real, and try to add it            //通过类加载器去加载这个类            clazz = mContext.getClassLoader().loadClass(                    prefix != null ? (prefix + name) : name).asSubclass(View.class);            if (mFilter != null && clazz != null) {                boolean allowed = mFilter.onLoadClass(clazz);                if (!allowed) {                    failNotAllowed(name, prefix, attrs);                }            }            //获取构造函数，并将构造函数缓存起来            constructor = clazz.getConstructor(mConstructorSignature);            constructor.setAccessible(true);            sConstructorMap.put(name, constructor);        } else {            // If we have a filter, apply it to cached constructor            if (mFilter != null) {                // Have we seen this name before?                Boolean allowedState = mFilterMap.get(name);                if (allowedState == null) {                    // New class -- remember whether it is allowed                    clazz = mContext.getClassLoader().loadClass(                            prefix != null ? (prefix + name) : name).asSubclass(View.class);                    boolean allowed = clazz != null && mFilter.onLoadClass(clazz);                    mFilterMap.put(name, allowed);                    if (!allowed) {                        failNotAllowed(name, prefix, attrs);                    }                } else if (allowedState.equals(Boolean.FALSE)) {                    failNotAllowed(name, prefix, attrs);                }            }        }        Object lastContext = mConstructorArgs[0];        if (mConstructorArgs[0] == null) {            // Fill in the context if not already within inflation.            mConstructorArgs[0] = mContext;        }        Object[] args = mConstructorArgs;        args[1] = attrs;        //通过反射拿到这个view        final View view = constructor.newInstance(args);        if (view instanceof ViewStub) {            // Use the same context when inflating ViewStub later.            final ViewStub viewStub = (ViewStub) view;            viewStub.setLayoutInflater(cloneInContext((Context) args[0]));        }        mConstructorArgs[0] = lastContext;        return view;    } catch (NoSuchMethodException e) {        final InflateException ie = new InflateException(attrs.getPositionDescription()                + ": Error inflating class " + (prefix != null ? (prefix + name) : name), e);        ie.setStackTrace(EMPTY_STACK_TRACE);        throw ie;    } catch (ClassCastException e) {        // If loaded class is not a View subclass        final InflateException ie = new InflateException(attrs.getPositionDescription()                + ": Class is not a View " + (prefix != null ? (prefix + name) : name), e);        ie.setStackTrace(EMPTY_STACK_TRACE);        throw ie;    } catch (ClassNotFoundException e) {        // If loadClass fails, we should propagate the exception.        throw e;    } catch (Exception e) {        final InflateException ie = new InflateException(                attrs.getPositionDescription() + ": Error inflating class "                        + (clazz == null ? "
   
    " : clazz.getName()), e);        ie.setStackTrace(EMPTY_STACK_TRACE);        throw ie;    } finally {        Trace.traceEnd(Trace.TRACE_TAG_VIEW);    }}
   

这个方法还是挺长的，其实这个里面做可以分为以下几步：

        1、从缓存中去拿到这个根view的构造器；

        2、如果这个构造器为null，就说明这个类之前没有加载过，那么就通过类加载器将这个类加载进来；

        3、拿到这个构造器后就开始实例化这个view并返回。

到这里，就拿到了xml中的根view了，那么xml中的子view又是如何拿到的呢？那就是交给rInflateChildren()来处理了：

final void rInflateChildren(XmlPullParser parser, View parent, AttributeSet attrs,                            boolean finishInflate) throws XmlPullParserException, IOException {    rInflate(parser, parent, parent.getContext(), attrs, finishInflate);}void rInflate(XmlPullParser parser, View parent, Context context,              AttributeSet attrs, boolean finishInflate) throws XmlPullParserException, IOException {    final int depth = parser.getDepth();    int type;    boolean pendingRequestFocus = false;    //将同一层级的view全部实例化，如果有子view，则递归调用rInflateChildren()    while (((type = parser.next()) != XmlPullParser.END_TAG ||            parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {        if (type != XmlPullParser.START_TAG) {            continue;        }        final String name = parser.getName();        if (TAG_REQUEST_FOCUS.equals(name)) {            pendingRequestFocus = true;            consumeChildElements(parser);        } else if (TAG_TAG.equals(name)) {            parseViewTag(parser, parent, attrs);        } else if (TAG_INCLUDE.equals(name)) {            if (parser.getDepth() == 0) {                throw new InflateException("
    cannot be the root element");            }            parseInclude(parser, context, parent, attrs);        } else if (TAG_MERGE.equals(name)) {            throw new InflateException("
    must be the root element");        } else {            final View view = createViewFromTag(parent, name, context, attrs);            final ViewGroup viewGroup = (ViewGroup) parent;            final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);            rInflateChildren(parser, view, attrs, true);            //将子view加入父view中            viewGroup.addView(view, params);        }    }    if (pendingRequestFocus) {        parent.restoreDefaultFocus();    }    if (finishInflate) {        parent.onFinishInflate();    }}

这里使用递归的方式来构造view树，平级的view那么就直接在循环遍历完，如果view下面有子view那么就会调用rInflateChildren()，直到将view树全部遍历完。这样，整个xml就构建完成一个完整的view树了。这里只是将view实例化，但并没有对view进行测量，view的测量是在onResume()中完成的，之后会分析到。

        下一篇我们来看看LayoutParams是如何作用的。

转载地址：http://izhai.baihongyu.com/