通常，我们会将应用中需要展示的界面内容都写在XML文件中，通过Activity的setContentView()方法设置。
当我们希望动态的添加一个没有被加载的xml布局文件，比如在ViewPager或者是ListView中，就需要使用到View.inflate()方法或者是LayoutInflater这个类。

获取LayoutInflater实例

先来看一下View.inflate()方法的实现：

public static View inflate(Context context, @LayoutRes int resource, ViewGroup root) {
    LayoutInflater factory = LayoutInflater.from(context);
    return factory.inflate(resource, root);
}

实际上是封装了LayoutInflater的from(Context context)方法，并通过获取的LayoutInflater实例来返回View对象

那么如何能获取到LayoutInflater对象的实例呢？通常有三种方式：

LayoutInflater layoutInflater = Activity.this.getLayoutInflater(); // 该方法只能由Activity的实例来调用
LayoutInflater layoutInflater = LayoutInflater.from(Context context);
LayoutInflater layoutInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

第一种方法只能由Activity的实例来调用，内部实际上是调用了Window接口的getLayoutInflater()方法：

public LayoutInflater getLayoutInflater() {
    return getWindow().getLayoutInflater();
}

具体的实现在PhoneWindow类中，通过LayoutInflater.from(Context context)来返回实例

public PhoneWindow(Context context) {
    super(context);
    mLayoutInflater = LayoutInflater.from(context);
}

public LayoutInflater getLayoutInflater() {
    return mLayoutInflater;
}

第二种方法的实现：

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

所以三种方法实际上是以同样的代码来实现的。

从XML到View

首先明确一下，一般在布局文件中，我们都必须给每一个控件添加两个属性：layout_height和layout_width，通过这两个属性来控制控件的宽高。但是为什么有时候，通过inflate()方法将其转换为View之后，两个属性就不起作用了呢？

从inflate()开始

获取到LayoutInflater的实例之后，就可以调用layoutInflater.inflate()方法将XML布局文件转换成View对象了。

inflate()方法有多个重载，先来看看这些重载有什么不同：

public View inflate(@LayoutRes int resource, @Nullable ViewGroup root) {
    return inflate(resource, root, root != null);
}

public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot) {
    final Resources res = getContext().getResources();

    final XmlResourceParser parser = res.getLayout(resource);
    try {
        return inflate(parser, root, attachToRoot);
    } finally {
        parser.close();
    }
}

最终这些重载的方法都调用了inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot)的代码：

//删掉了一些不关心的代码
public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
    synchronized (mConstructorArgs) {
        final Context inflaterContext = mContext;
        final AttributeSet attrs = Xml.asAttributeSet(parser);
        Context lastContext = (Context) mConstructorArgs[0];
        mConstructorArgs[0] = inflaterContext;
        // 1. 先将rootView赋值给result
        View result = root;

        //2. 开始通过Pull解析对XML文件进行解析
        try {
            // 解析根节点，从START_TAG开始解析
            int type;
            while ((type = parser.next()) != XmlPullParser.START_TAG && type != XmlPullParser.END_DOCUMENT) {
            }

            if (type != XmlPullParser.START_TAG) {
                throw new InflateException(parser.getPositionDescription() + ": No start tag found!");
            }

            final String name = parser.getName();

            // XML根标签为<merge>，优化XML时使用
            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 {
                // 将XML文件的根节点转化为View对象，赋值给temp
                final View temp = createViewFromTag(root, name, inflaterContext, attrs);

                ViewGroup.LayoutParams params = null;

                if (root != null) {
                    // 如果root不为null，就根据父控件及XML中配置的属性来生成LayoutParams
                    params = root.generateLayoutParams(attrs);
                    if (!attachToRoot) {
                        // 如果不需要将当前View添加到父控件中，就直接设置参数
                        temp.setLayoutParams(params);
                    }
                }

                // 依次遍历，将XML中所有的控件转换为View对象
                rInflateChildren(parser, temp, attrs, true);

                if (root != null && attachToRoot) {
                    // 如果root不为null，并且要将转换后的View对象添加到父控件中，就直接调用addView()方法
                    root.addView(temp, params);
                }

                // 决定返回的View时root(父控件)或者是XML中换换后的控件
                if (root == null || !attachToRoot) {
                    result = temp;
                }
            }
        } catch(Exception e) {
          ...
        }

        // 3. 返回View对象
        return result;
    }
}

熟悉整个源码之后，我们再回头来看一看就清晰明了了：

inflate(resource, null) : 如果root为null，那么不论第三个参数存在与否、是否为true，在XML文件中设置的关于布局的属性就都不会生效
inflate(resource, root, false) : 如果root不为null，但是不将XML转换的View添加到root下，那么XML文件中设置的属性生效，返回的是XML的根节点生成的View对象
inflate(resource, root, true) : 如果root不为null，并且将转换的View添加到root下，那么返回的是添加View对象后的root

此外，从源码中我们可以知道，如果在一个XML布局文件中，我们将根节点设置为<merge>的话，必须存在一个父控件将其包裹，否则就会抛出异常

createViewFromTag()的实现

在inflate()中，是通过createViewFromTag()将XML中的标签转换为一个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) {
        // 在布局文件中我们可以将标签设置为<view>，通过class属性设置具体的控件
        if (name.equals("view")) {
            name = attrs.getAttributeValue(null, "class");
        }

        if (!ignoreThemeAttr) {
            // 从Theme中获取属性
        }

        try {
            View view;
            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;
        } catch (Exception e) {
            ...
        }
    }

分别调用了onCreateView()和createView()方法，而最终调用的是createView(String name, String prefix, AttributeSet attrs)中的代码：

// 删掉了一些不关心的代码
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);
}

public final View createView(String name, String prefix, AttributeSet attrs)
        throws ClassNotFoundException, InflateException {
    Constructor<? extends View> constructor = sConstructorMap.get(name);
    Class<? extends View> clazz = null;

    try {
        if (constructor == null) {
            clazz = mContext.getClassLoader().loadClass(prefix != null ? (prefix + name) : name).asSubclass(View.class);

            constructor = clazz.getConstructor(mConstructorSignature);
            constructor.setAccessible(true);
            sConstructorMap.put(name, constructor);
        } else {
            ...
        }

        Object[] args = mConstructorArgs;
        args[1] = attrs;

        final View view = constructor.newInstance(args);
        if (view instanceof ViewStub) {
            final ViewStub viewStub = (ViewStub) view;
            viewStub.setLayoutInflater(cloneInContext((Context) args[0]));
        }
        return view;
    } catch (Exception e) {
        ...
    }
}

static final Class<?>[] mConstructorSignature = new Class[] {Context.class, AttributeSet.class};

其实核心代码还是比较简单的，就是通过反射来获取两个参数（mConstructorSignature）的构造器，再调用newInstance()方法构造出需要的View对象。这也是为什么如果我们使用自定义控件时，如果需要通过XML文件来使用必须复写有两个参数的构造函数的原因。

rInflateChildren()的实现

通过createViewFromTag()将XML文件中的标签转换为View对象后，就要调用rInflateChildren()将布局文件中其他子控件转换为View：

// 删掉了一些不关心的代码
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;

    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 (...) {
            ...
        } else {
            // 调用 createViewFromTag()
            final View view = createViewFromTag(parent, name, context, attrs);
            final ViewGroup viewGroup = (ViewGroup) parent;
            final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
            // 调用rInflateChildren()
            rInflateChildren(parser, view, attrs, true);
            // 将生成的View添加父控件中
            viewGroup.addView(view, params);
        }
    }

    if (finishInflate) {
        parent.onFinishInflate();
    }
}

可以清楚的看到，由rInflateChildren开始，形成了一个循环：rInflateChildren -> rInflate -> createViewFromTag -> rInflateChildren。通过循环遍历所有的子控件，直到整个布局文件结束

此外，在最后可以看到，当rInflate()方法执行到最后时，会回调parent.onFinishInflate()方法，我们可以在重写这个回调方法获取View的属性

文章目录

获取LayoutInflater实例

从XML到View

从inflate()开始

createViewFromTag()的实现

rInflateChildren()的实现