Android XML布局到View对象创建流程分析

写作背景

在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方法：

```java
 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) {
           
            
            //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();

            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)) {
                       
                        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();

    
                        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树上的对象就全部被创建出来了，最后就会被调用显示在我们的视野中。