写作背景
在Android源码实现部分，很多人都应该分析过View的绘制流程，measure，layout，draw三个过程也许已经十分熟悉了，但是相信有很多小伙伴和笔者一样并不知道到xml布局到底是如何被解析然后转换成View的，今天笔者将和大家一起来学习这个流程(基于Android API 28源码)。
View加载的调用
在Android开发过程中，使用XML文件编写UI界面后，通常我们会调用setContentView(resId)或者LayoutInflater.inflate(resId,...)的方式把布局文件加载到Activity中，并实现视图与逻辑的绑定与开发。
Activity的setContentView
setContentView方法大家都已经非常熟悉了，无论是系统原生的Activity还是V7或V4包下的其他子类Activity，在onCreate方法中一般都会调用到这个方法，下面来看看源码：
public void setContentView(@LayoutRes int layoutResID) {
getWindow().setContentView(layoutResID);
initWindowDecorActionBar();
}
public Window getWindow() {
return mWindow;
}
由于之前已经分析过Window，所以这里就不再赘述，我们关注本文的重点部分setContentView，在Activity的setContentView方法里传递给了PhoneWindow的setContentView方法来执行布局的加载。
getWindow()方法返回的是一个Window对象，具体是其实现类PhoneWindow对象，对应的是mWindow字段。这里简单提一下，不清楚的可以看笔者的这篇文章
现在继续关注PhoneWindow的setContentView源码：
@Override
public void setContentView(int layoutResID) {
// Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
// decor, when theme attributes and the like are crystalized. Do not check the feature
// before this happens.
if (mContentParent == null) {
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 {
// 将View添加到DecorView的mContentParent中
// 调用LayoutInflater的inflate方法解析布局文件，并生成View树，mContentParent为View树的根节点
mLayoutInflater.inflate(layoutResID, mContentParent);
}
mContentParent.requestApplyInsets();
//回调Activity的onContentChanged方法通知视图发生改变
final Callback cb = getCallback();
if (cb != null && !isDestroyed()) {
cb.onContentChanged();
}
mContentParentExplicitlySet = true;
}
这里也比较清楚，当我们没有设置转场动画的会执行mLayoutInflater.inflate(layoutResID, mContentParent)，而这个mLayoutInflater是在PhoneWindow的构造方法中被实例的：
public PhoneWindow(Context context) {
super(context);
mLayoutInflater = LayoutInflater.from(context);
}
所以我们可以得出结论Activity的setContentView方法最终就是通过 LayoutInflater.from(context).inflate(resId, ……) 来实现布局的解析然后加载出来的.而其他子类Activity虽然可能复写了setContentView方法，但还是可以发现其最终的实现方式是一样的，这里看一下v7包下的AppCompatActivty的setContentView方法：
@Override
public void setContentView(@LayoutRes int layoutResID) {
getDelegate().setContentView(layoutResID);
}
//android.support.v7.app.AppCompatDelegateImplV9.setContentView(resId)
@Override
public void setContentView(int resId) {
ensureSubDecor();
ViewGroup contentParent = (ViewGroup) mSubDecor.findViewById(android.R.id.content);
contentParent.removeAllViews();
LayoutInflater.from(mContext).inflate(resId, contentParent);
mOriginalWindowCallback.onContentChanged();
}
果然不出意外，这里又出现了了LayoutInflater的身影。所以进一步得出结论：xml文件是用LayoutInflater的inflate方法来实现解析与加载的。
LayoutInflater如何实例化
看一下源码中的LayoutInflater是怎样介绍的：
/**
* Instantiates a layout XML file into its corresponding {@link android.view.View}
* objects. It is never used directly. Instead, use
* {@link android.app.Activity#getLayoutInflater()} or
* {@link Context#getSystemService} to retrieve a standard LayoutInflater instance
* that is already hooked up to the current context and correctly configured
* for the device you are running on.
*
* <p>
* To create a new LayoutInflater with an additional {@link Factory} for your
* own views, you can use {@link #cloneInContext} to clone an existing
* ViewFactory, and then call {@link #setFactory} on it to include your
* Factory.
*
* <p>
* For performance reasons, view inflation relies heavily on pre-processing of
* XML files that is done at build time. Therefore, it is not currently possible
* to use LayoutInflater with an XmlPullParser over a plain XML file at runtime;
* it only works with an XmlPullParser returned from a compiled resource
* (R.<em>something</em> file.)
*/
@SystemService(Context.LAYOUT_INFLATER_SERVICE)
public abstract class LayoutInflater {···}
从注释的第一行我们也可以发现LayoutInflater是用来实例化一个XML
文件到对应的View对象的一个类，并且并不希望被直接使用，而是通过Activity的getLayoutInflater()方法或者Context的getSystemService()来或取一个标准的LayoutInflater对象。在类上面的注释我们也可以发现使用Context.LAYOUT_INFLATER_SERVICE通过getSystemService方法来获取。最后再看这个类，发现是一个抽象类，抽象类是不能够被实例化的，所以这也就会出现注释中所写的两种方法来获取实例了：
Activity的getLayoutInflater
public LayoutInflater getLayoutInflater() {
return getWindow().getLayoutInflater();
}
这里就可以发现Activity获取LayoutInflater是通过PhoneWindow的getLayutInflater方法来获取的，最终的到的对象就是PhoneWindow中的mLayoutInflater；而这个mLayoutInflater上文也介绍过，是通过LayoutInflater.from(context)方法来创建的：
/**
* Obtains the LayoutInflater from the given context.
*/
public static LayoutInflater from(Context context) {
LayoutInflater LayoutInflater =
(LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
if (LayoutInflater == null) {
throw new AssertionError("LayoutInflater not found.");
}
return LayoutInflater;
}
首先看方法的注释：从给定的上下文中获取LayoutInflater，然后在看代码的具体实现。看过这段代码相信大家已经有了答案。没错，事实的真相只有一个，那就是通过服务获取LayoutInflater实例对象。那么现在该继续深入context.getSystemService(Context.LAYOUT_INFLATER_SERVICE)方法的具体实现了：
由于Context的实现类是ContextImpl，所以实际调用的是它的方法：
@Override
public Object getSystemService(String name) {
return SystemServiceRegistry.getSystemService(this, name);
}
//SystemServiceRegistry.class
/**
* Gets a system service from a given context.
*/
public static Object getSystemService(ContextImpl ctx, String name) {
ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
return fetcher != null ? fetcher.getService(ctx) : null;
}
在ContextImpl的getSystemService方法中调用了SystemServiceRegistry的getSystemService方法，根据这个类的命名可以猜测这是一个提供系统服务注册的类，在这个类的代码中我们发现非常多的服务的注册工作，就像这样：
static {
registerService(Context.ACCESSIBILITY_SERVICE, AccessibilityManager.class,
new CachedServiceFetcher<AccessibilityManager>() {
@Override
public AccessibilityManager createService(ContextImpl ctx) {
return AccessibilityManager.getInstance(ctx);
}});
registerService(Context.CAPTIONING_SERVICE, CaptioningManager.class,
new CachedServiceFetcher<CaptioningManager>() {
@Override
public CaptioningManager createService(ContextImpl ctx) {
return new CaptioningManager(ctx);
}});
···
}
/**
* Statically registers a system service with the context.
* This method must be called during static initialization only.
*/
private static <T> void registerService(String serviceName, Class<T> serviceClass,
ServiceFetcher<T> serviceFetcher) {
SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
}
这里有大量的服务注册工作，所以省略了大量代码，现在来看看要通过Context.LAYOUT_INFLATER_SERVICE获取的服务是如何被注册的：
···
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher<LayoutInflater>() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
return new PhoneLayoutInflater(ctx.getOuterContext());
}});
···
显然我们想要获取的服务就是这里提前注册过的服务，也就是一个PhoneLayoutInflater对象，之前就说过LayoutInflater是一个抽象类，现在终于找到了它的实现类了。
LayoutInflater读取xml文件并创建View
通过LayoutInflater.from(context)获取到了LayoutInflater实例后，现在要调用它的inflate方法来实现xml文件的读取与View的创建：
public View inflate(@LayoutRes int resource, @Nullable ViewGroup root) {
return inflate(resource, root, root != null);
}
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) + ")");
}
final XmlResourceParser parser = res.getLayout(resource);
try {
return inflate(parser, root, attachToRoot);
} finally {
parser.close();
}
}
可以看到这里有三个inflate的重载方法，但是比较重要的就是后一个，主要是通过Resourse对象通过getLayout方法将resId转换成一个XmlResourceParser对象，然后又调用了一个inflate方法：
public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
synchronized (mConstructorArgs) {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate");
final Context inflaterContext = mContext;
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;
while ((type = parser.next()) != XmlPullParser.START_TAG &&
type != XmlPullParser.END_DOCUMENT) {
// Empty
}
```
final String name = parser.getName();
···
//第一部分merge标签
//内部静态常量private static final String TAG_MERGE = "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
final View temp = createViewFromTag(root, name, inflaterContext, attrs);
ViewGroup.LayoutParams params = null;
if (root != null) {
···
// Create layout params that match root, if supplied
params = root.generateLayoutParams(attrs);
if (!attachToRoot) {
// Set the layout params for temp if we are not
// attaching. (If we are, we use addView, below)
temp.setLayoutParams(params);
}
}
···
// Inflate all children under temp against its context.
rInflateChildren(parser, temp, attrs, true);
···
// We are supposed to attach all the views we found (int temp)
// to root. Do that now.
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) {
···
} finally {
// Don't retain static reference on context.
mConstructorArgs[0] = lastContext;
mConstructorArgs[1] = null;
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
return result;
}
}
这一个inflater方法也就是最重要的inflater方法了，首先遍历XmlPullParser对象，寻找根节点，并赋值给type。找到根节点后的实现比较长，这里分成了两个部分来讲，分别是merge部分和其他view部分。
merge标签
首先根据标签名判断是否是merge标签，如果是merge标签则根节点不能为null并且attachToRoot必须为true，否则抛出异常，这很容易理解因为使用merge标签的xml布局需要依附在一个父布局之下，然后会调用rInflater方法：
void rInflate(XmlPullParser parser, View parent, Context context,
AttributeSet attrs, boolean finishInflate) throws XmlPullParserException, IOException {
//获取View树的深度 深度优先遍历
final int depth = parser.getDepth();
int type;
boolean pendingRequestFocus = false;
//依次解析
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();
// 内部定义的静态常量：
//private static final String TAG_REQUEST_FOCUS = "requestFocus";
if (TAG_REQUEST_FOCUS.equals(name)) {
pendingRequestFocus = true;
consumeChildElements(parser);
// private static final String TAG_TAG = "tag";
} else if (TAG_TAG.equals(name)) {
parseViewTag(parser, parent, attrs);
// 解析include标签
} else if (TAG_INCLUDE.equals(name)) {
if (parser.getDepth() == 0) {
throw new InflateException("<include /> cannot be the root element");
}
parseInclude(parser, context, parent, attrs);
//如果是merge标签 抛出异常 因为merge标签必须为根视图
} 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);
viewGroup.addView(view, params);
}
}
if (pendingRequestFocus) {
parent.restoreDefaultFocus();
}
if (finishInflate) {
parent.onFinishInflate();
}
}
首先会遍历整个节点，子节点会有"requestFocus"、"tag"、""、"include"，但是不能有"merge",因为merge标签只能为这里的根元素，除此之外的View标签会通过createViewFromTag方法创建View，实际上"include"标签也会创建view，我们看parseInclude方法：
private void parseInclude(XmlPullParser parser, Context context, View parent,
AttributeSet attrs) throws XmlPullParserException, IOException {
int type;
if (parent instanceof ViewGroup) {
// Apply a theme wrapper, if requested. This is sort of a weird
// edge case, since developers think the <include> overwrites
// values in the AttributeSet of the included View. So, if the
// included View has a theme attribute, we'll need to ignore it.
//private static final int[] ATTRS_THEME = new int[] {
com.android.internal.R.attr.theme };
final TypedArray ta = context.obtainStyledAttributes(attrs, ATTRS_THEME);
final int themeResId = ta.getResourceId(0, 0);
final boolean hasThemeOverride = themeResId != 0;
if (hasThemeOverride) {
context = new ContextThemeWrapper(context, themeResId);
}
ta.recycle();
// If the layout is pointing to a theme attribute, we have to
// massage the value to get a resource identifier out of it.
int layout = attrs.getAttributeResourceValue(null, ATTR_LAYOUT, 0);
if (layout == 0) {
final String value = attrs.getAttributeValue(null, ATTR_LAYOUT);
if (value == null || value.length() <= 0) {
throw new InflateException("You must specify a layout in the"
+ " include tag: <include layout=\"@layout/layoutID\" />");
}
// Attempt to resolve the "?attr/name" string to an attribute
// within the default (e.g. application) package.
layout = context.getResources().getIdentifier(
value.substring(1), "attr", context.getPackageName());
}
// The layout might be referencing a theme attribute.
if (mTempValue == null) {
mTempValue = new TypedValue();
}
if (layout != 0 && context.getTheme().resolveAttribute(layout, mTempValue, true)) {
layout = mTempValue.resourceId;
}
if (layout == 0) {
final String value = attrs.getAttributeValue(null, ATTR_LAYOUT);
throw new InflateException("You must specify a valid layout "
+ "reference. The layout ID " + value + " is not valid.");
} else {
final XmlResourceParser childParser = context.getResources().getLayout(layout);
try {
final AttributeSet childAttrs = Xml.asAttributeSet(childParser);
while ((type = childParser.next()) != XmlPullParser.START_TAG &&
type != XmlPullParser.END_DOCUMENT) {
// Empty.
}
if (type != XmlPullParser.START_TAG) {
throw new InflateException(childParser.getPositionDescription() +
": No start tag found!");
}
final String childName = childParser.getName();
if (TAG_MERGE.equals(childName)) {
// The <merge> tag doesn't support android:theme, so
// nothing special to do here.
rInflate(childParser, parent, context, childAttrs, false);
} else {
final View view = createViewFromTag(parent, childName,
context, childAttrs, hasThemeOverride);
final ViewGroup group = (ViewGroup) parent;
final TypedArray a = context.obtainStyledAttributes(
attrs, R.styleable.Include);
final int id = a.getResourceId(R.styleable.Include_id, View.NO_ID);
final int visibility = a.getInt(R.styleable.Include_visibility, -1);
a.recycle();
// We try to load the layout params set in the <include /> tag.
// If the parent can't generate layout params (ex. missing width
// or height for the framework ViewGroups, though this is not
// necessarily true of all ViewGroups) then we expect it to throw
// a runtime exception.
// We catch this exception and set localParams accordingly: true
// means we successfully loaded layout params from the <include>
// tag, false means we need to rely on the included layout params.
ViewGroup.LayoutParams params = null;
try {
params = group.generateLayoutParams(attrs);
} catch (RuntimeException e) {
// Ignore, just fail over to child attrs.
}
if (params == null) {
params = group.generateLayoutParams(childAttrs);
}
view.setLayoutParams(params);
// Inflate all children.
rInflateChildren(childParser, view, childAttrs, true);
if (id != View.NO_ID) {
view.setId(id);
}
switch (visibility) {
case 0:
view.setVisibility(View.VISIBLE);
break;
case 1:
view.setVisibility(View.INVISIBLE);
break;
case 2:
view.setVisibility(View.GONE);
break;
}
group.addView(view);
}
} finally {
childParser.close();
}
}
} else {
throw new InflateException("<include /> can only be used inside of a ViewGroup");
}
LayoutInflater.consumeChildElements(parser);
}
这个方法跟上面的inflate()方法很相似，具体逻辑就不看了，主要也是调用了createViewFromTag()方法来创建View，这就是上面为什么说include标签也会创建view的原因，至此我们已经知道了createViewFromTag方法用于创建View。
其他View标签
上面我们看完了inflate里的merge标签实现，现在继续看看后面的实现：
···
// Temp is the root view that was found in the xml
final View temp = createViewFromTag(root, name, inflaterContext, attrs);
ViewGroup.LayoutParams params = null;
if (root != null) {
···
// Create layout params that match root, if supplied
params = root.generateLayoutParams(attrs);
if (!attachToRoot) {
// Set the layout params for temp if we are not
// attaching. (If we are, we use addView, below)
temp.setLayoutParams(params);
}
}
···
// Inflate all children under temp against its context.
rInflateChildren(parser, temp, attrs, true);
···
// We are supposed to attach all the views we found (int temp)
// to root. Do that now.
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;
}
···
首先这里还是调用了createViewFromTag方法用于创建view，然后当根View不为空时，则加载根View的LayoutParams属性，然后如果attachToRoot为false，则调用setLayoutParams为创建的View设置属性，如果为true则直接调用addView方法添加到根View中。然后会调用rInflateChildren方法来实现子view的创建与添加。最后如果根View不为空并且attachToRoot为true，则返回根View，否则返回的是创建的xml根标签指定的View。
createViewFromTag创建View
现在知道了createViewFromTag用于创建View，那么现在需要了解一下它的实现细节：
private View createViewFromTag(View parent, String name, Context context, AttributeSet attrs) {
return createViewFromTag(parent, name, context, attrs, false);
}
View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
boolean ignoreThemeAttr) {
···
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);
}
//注释1
if (view == null) {
final Object lastContext = mConstructorArgs[0];
mConstructorArgs[0] = context;
try {
if (-1 == name.indexOf('.')) {
view = onCreateView(parent, name, attrs);
} else {
view = createView(name, null, attrs);
}
} finally {
mConstructorArgs[0] = lastContext;
}
}
return view;
}
···
}
这里首先会使用mFactory2，mFactory，mPrivateFactory这三个对象按先后顺序创建view，但那如果这三个对象都为空的话，则会默认流程来创建View，最后返回View。通常来讲这三个Factory都为空，如果我们想要控制View的创建过程就可以利用这一机制来定制自己的factory。现在我们先来分析一下注释1的代码：
if (view == null) {
final Object lastContext = mConstructorArgs[0];
mConstructorArgs[0] = context;
try {
//String的indexOf()方法如果没有找到给定的字符则返回-1
if (-1 == name.indexOf('.')) {
view = onCreateView(parent, name, attrs);
} else {
view = createView(name, null, attrs);
}
} finally {
mConstructorArgs[0] = lastContext;
}
}
首先会判断名字中是否含有点，这主要是为了区分系统自带View和自定义View。因为系统View是直接使用类名不用写全包名的，而自定义View在使用的时候一定要写全包名，相信大家可以很容易的理解到这一点，然后如果是自定义View则调用createView来创建View，否则调用onCreateView方法。
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);
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 {
···
}
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;
//注释1
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) {
···
} finally {
···
}
}
LayoutInflater内部维护了一个Map用于缓存构造器，然后在这里首先会从这个map中获取构造器否则创建后再放至map中；当获取了构造器之后，在注释1处通过反射创建了View。然后我们再看创建系统View：
在LayoutInflater中我们找到了对应的方法：
protected View onCreateView(View parent, String name, AttributeSet attrs)
throws ClassNotFoundException {
return onCreateView(name, attrs);
}
protected View onCreateView(String name, AttributeSet attrs)
throws ClassNotFoundException {
return createView(name, "android.view.", attrs);
}
原来在LayoutInflater的onCreateView方法创建系统View最终的实现也是交给了createView方法，只是传入了一个字符串android.view.，这样在创建构造器时就会与View的名字拼接到一起获取对应的Class对象，使最终能够成功创建对应的View。现在到PhoneLayoutInflater里找一下这个方法：
private static final String[] sClassPrefixList = {
"android.widget.",
"android.webkit.",
"android.app."
};
/** Override onCreateView to instantiate names that correspond to the
widgets known to the Widget factory. If we don't find a match,
call through to our super class.
*/
@Override protected View onCreateView(String name, AttributeSet attrs) throws ClassNotFoundException {
for (String prefix : sClassPrefixList) {
try {
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.
}
}
return super.onCreateView(name, attrs);
}
主要完成的是遍历一个存放了三个包名字符串的数组，然后调用createView方法创建View，只要这三次创建View有一次成功，那么就返回创建的View，否则最终返回的还是父类传入"android.view."时创建的View。现在再看看createView的具体实现：
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);
//没有缓存的构造器
if (constructor == null) {
// Class not found in the cache, see if it's real, and try to add it
//通过传入的prefix构造出完整的类名 并加载该类
clazz = mContext.getClassLoader().loadClass(
prefix != null ? (prefix + name) : name).asSubclass(View.class);
//省略部分代码
//从class对象中获取构造器
constructor = clazz.getConstructor(mConstructorSignature);
constructor.setAccessible(true);
//存入缓存器中
sConstructorMap.put(name, constructor);
} else {
//代码省略
}
//代码省略
//通过反射创建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;
}
//省略各种try catch代码
}
这里就创建了View对象，结合之前调用的rInflate方法构建整个View树，整个View树上的对象就全部被创建出来了，最后就会被调用显示在我们的视野中。
网友评论