Android获取到inflate服务的方式及inflate的解析过程

Android获取到inflate服务总共有三种方式：
1、使用getSystemService(Context.LAYOUT_INFLATER_SERVICE)

mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);mInflater.inflate(R.layout.main,parent, false);

2、使用LayoutInflater的静态方法

mInflater = (LayoutInflater)LayoutInflater.from(context);mInflater.inflate(R.layout.main,parent, false);

3、最简单的一种，直接使用View的inflate

View.inflate(context, R.layout.main, null);

下面看看它们直接的关系：
首先看看第二种方式的源码实现：

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

可以清楚的看到它的本质就是第一种方式。

接着看看第三种方式的源码实现：

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

可以看到它的本质就是第二种方式，而第二种方式的本质是第一种方式，只是它们直接层层进行了封装而已。

下面主要看看两点：

1、context.getSystemService(Context.LAYOUT_INFLATER_SERVICE)是怎样得到的。

关于这个可以看看这篇文章：浅析getSystemService获取系统服务

2、mInflater.inflate(R.layout.main,parent, false)的工作过程。

下面我们就来看看这个函数的工作过程，直接进入inflate函数，它在LayoutInflater里面。

public View inflate(int resource, ViewGroup root, boolean attachToRoot) {    if (DEBUG) System.out.println("INFLATING from resource: " + resource);    // 1、根据指定的id读取xml布局文件，最终返回一个Xml资源解析器    XmlResourceParser parser = getContext().getResources().getLayout(resource);    try {        // 2、对这个布局文件进行解析        return inflate(parser, root, attachToRoot);    } finally {        parser.close();    }}

下面我们来看看上面两步里面的内容：
（1）getContext().getResources().getLayout(resource)

我们直接进入Resources类里面的getLayout方法：

public XmlResourceParser getLayout(int id) throws NotFoundException {    return loadXmlResourceParser(id, "layout");}/*package*/ XmlResourceParser loadXmlResourceParser(int id, String type)        throws NotFoundException {    synchronized (mAccessLock) {        TypedValue value = mTmpValue;        if (value == null) {            mTmpValue = value = new TypedValue();        }        // 1、得到指定ID的xml资源，输出到value中        getValue(id, value, true);        // 2、如果value的类型为String类型，调用loadXmlResourceParser进行解析        if (value.type == TypedValue.TYPE_STRING) {            return loadXmlResourceParser(value.string.toString(), id,                    value.assetCookie, type);        }        throw new NotFoundException(                "Resource ID #0x" + Integer.toHexString(id) + " type #0x"                + Integer.toHexString(value.type) + " is not valid");    }}

我们主要来看看第二步，因为一般情况上面都为true：

/*package*/ XmlResourceParser loadXmlResourceParser(String file, int id,        int assetCookie, String type) throws NotFoundException {    if (id != 0) {        try {            // These may be compiled...            synchronized (mCachedXmlBlockIds) {                // 首先看这个block是否在缓存中                // 如果在缓存中，就直接返回它的parser                final int num = mCachedXmlBlockIds.length;                for (int i=0; i<num; i++) {                    if (mCachedXmlBlockIds[i] == id) {                        //System.out.println("**** REUSING XML BLOCK!  id="                        //                   + id + ", index=" + i);                        return mCachedXmlBlocks[i].newParser();                    }                }                // 如果不在缓存中，则需要创建一个，并且将它缓存起来                // 最终返回一个XmlPullParser                XmlBlock block = mAssets.openXmlBlockAsset(                        assetCookie, file);                if (block != null) {                    int pos = mLastCachedXmlBlockIndex+1;                    if (pos >= num) pos = 0;                    mLastCachedXmlBlockIndex = pos;                    XmlBlock oldBlock = mCachedXmlBlocks[pos];                    if (oldBlock != null) {                        oldBlock.close();                    }                    mCachedXmlBlockIds[pos] = id;                    mCachedXmlBlocks[pos] = block;                    //System.out.println("**** CACHING NEW XML BLOCK!  id="                    //                   + id + ", index=" + pos);                    return block.newParser();                }            }        } catch (Exception e) {            NotFoundException rnf = new NotFoundException(                    "File " + file + " from xml type " + type + " resource ID #0x"                    + Integer.toHexString(id));            rnf.initCause(e);            throw rnf;        }    }    throw new NotFoundException(            "File " + file + " from xml type " + type + " resource ID #0x"            + Integer.toHexString(id));}

其实的过程其实就是得到xml布局文件的Pull解析器，LayoutInflater其实就是使用Android提供的pull解析方式来解析布局文件的。下面我们来看看整个xml文件的解析过程。

（2）inflate(parser, root, attachToRoot)

public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {    synchronized (mConstructorArgs) {        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate");        final AttributeSet attrs = Xml.asAttributeSet(parser);        Context lastContext = (Context)mConstructorArgs[0];        mConstructorArgs[0] = mContext;        View result = root;        try {            // Look for the root node.            int type;            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!");            }            final String name = parser.getName();            if (DEBUG) {                System.out.println("**************************");                System.out.println("Creating root view: "                        + name);                System.out.println("**************************");            }            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, attrs, false);            } else {                // Temp is the root view that was found in the xml                View temp;                if (TAG_1995.equals(name)) {                    temp = new BlinkLayout(mContext, attrs);                } else {                    temp = createViewFromTag(root, name, 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                    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);                    }                }                if (DEBUG) {                    System.out.println("-----> start inflating children");                }                // Inflate all children under temp                rInflate(parser, temp, attrs, true);                if (DEBUG) {                    System.out.println("-----> done inflating children");                }                // 如果它的父布局不为null,并且attachToRoot为true                //这样就会把整个布局文件加到父布局中去                //从这里也可以看到inflate的第三个参数attachToRoot的作用                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) {            InflateException ex = new InflateException(e.getMessage());            ex.initCause(e);            throw ex;        } catch (IOException e) {            InflateException ex = new InflateException(                    parser.getPositionDescription()                    + ": " + e.getMessage());            ex.initCause(e);            throw ex;        } finally {            // Don't retain static reference on context.            mConstructorArgs[0] = lastContext;            mConstructorArgs[1] = null;        }        Trace.traceEnd(Trace.TRACE_TAG_VIEW);        return result;    }}

使用过Pull解析器的应该对这个过程比较熟悉。在上面它会解析每一个节点，基本过程如下：
1、判断最外层的是否为merge标签，如果是，则直接使用rInflate来解析里面的所有子元素。
2、如果最外层不是merger标签，通过createViewFromTag()这个方法，并把节点名和参数传了进去，节点名来创建View对象，这个就是最外层的布局对象。
3、创建了最外层的布局对象，接着通过rInflate来解析它里面的所以子元素。

下面我们可以看看它解析子元素的过程，看看rInflate源码。

void rInflate(XmlPullParser parser, View parent, final 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 (TAG_REQUEST_FOCUS.equals(name)) {            parseRequestFocus(parser, parent);        } else if (TAG_INCLUDE.equals(name)) {            if (parser.getDepth() == 0) {                throw new InflateException("<include /> cannot be the root element");            }            parseInclude(parser, parent, attrs);        } else if (TAG_MERGE.equals(name)) {            throw new InflateException("<merge /> must be the root element");        } else if (TAG_1995.equals(name)) {            final View view = new BlinkLayout(mContext, attrs);            final ViewGroup viewGroup = (ViewGroup) parent;            final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);            rInflate(parser, view, attrs, true);            viewGroup.addView(view, params);                        } else {            final View view = createViewFromTag(parent, name, attrs);            final ViewGroup viewGroup = (ViewGroup) parent;            final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);            rInflate(parser, view, attrs, true);            viewGroup.addView(view, params);        }    }    if (finishInflate) parent.onFinishInflate();}

从这里我们可以看到，它就是一步一步递归来对这个布局文件的各个标签进行解析，根据标签的名字来进行不同的操作，所以他上面进行了一系列的判断，对应的会创建不同的View对象，然后把它们加入到父布局中。这样的话，把整个布局文件都解析完成后就形成了一个完整的DOM结构，最终会把最顶层的根布局返回，至此inflate()过程全部结束。