这里就只是分析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("<merge /> 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<? extends View> constructor = sConstructorMap.get(name); if (constructor != null && !verifyClassLoader(constructor)) { constructor = null; sConstructorMap.remove(name); } Class<? extends View> 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 ? "<unknown>" : 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("<include /> cannot be the root element"); } parseInclude(parser, context, parent, attrs); } else if (TAG_MERGE.equals(name)) { throw new InflateException("<merge /> 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是如何作用的。