LayoutInflater 佈局渲染工具原理分析

時間 2019-12-01

標籤 layoutinflater 佈局渲染工具原理分析简体版

原文原文鏈接

LayoutInflater實際上是一個佈局渲染工具，其本質就只是一個工具，說白了LayoutInflater的做用就是根據xml佈局文件構建View樹，自定義View的時候常常用到，經常使用的作法以下：android

View tmpView= LayoutInflater.from(context).inflate(R.layout.content,container,false);
複製代碼

首先經過LayoutInflater.from靜態函數得到一個LayoutInflater實例，實際上是是個PhoneLayoutInflater對象，跟蹤源碼看一下：緩存

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服務是什麼

這裏的context.getSystemService能夠直接去ContextImpl中找，其中，LAYOUT_INFLATER_SERVICE服務跟AMS、WMS等服務不一樣，它徹底是APP端本身虛擬的一個服務，主要做用是：在本地，爲調用者建立PhoneLayoutInflater工具對象，ContextImpl在註冊這個「服務」的時候，將工做委託給PolicyManager，利用其makeNewLayoutInflater構建LayoutInflater框架

registerService(LAYOUT_INFLATER_SERVICE, new ServiceFetcher() {
    public Object createService(ContextImpl ctx) {
        return PolicyManager.makeNewLayoutInflater(ctx.getOuterContext());
    }});
    
public static LayoutInflater makeNewLayoutInflater(Context context) {
    return sPolicy.makeNewLayoutInflater(context);
}        
複製代碼

而PolicyManager進一步調用com.android.internal.policy.impl.Policy對象的makeNewLayoutInflater構建PhoneLayoutInflater。ide

private static final String POLICY_IMPL_CLASS_NAME =
"com.android.internal.policy.impl.Policy";

public LayoutInflater makeNewLayoutInflater(Context context) {
    return new PhoneLayoutInflater(context);
}   
複製代碼

也就是說，這裏獲取的服務嚴格來講其實就是一個本地工具對象PhoneLayoutInflater，接下來看看，這個PhoneLayoutInflater如何建立View樹的呢？函數

LayoutInflater如何構建View樹

先從直觀理解一下LayoutInflater的工做原理，LayoutInflater如何根據佈局文件的id構建View樹呢？有如下幾個方面工具

解析xml獲取xml信息（應該有緩存，由於這些數據是靜態不變的）
根據xml中的tag標籤逐層構建View （經過反射建立View）
遞歸構建其中的子View，並將子View添加到父ViewGroup中

LayoutInflater源碼中也確實是按照上面的流程來構建View的，只是添加了些特殊標籤的處理邏輯，好比merge、include、stubview等，下面簡單跟蹤下源碼：佈局

public View inflate(int resource, ViewGroup root, boolean attachToRoot) {
    XmlResourceParser parser = getContext().getResources().getLayout(resource);
    try {
        return inflate(parser, root, attachToRoot);
    } finally {
        parser.close();
    }
}    
複製代碼

XmlResourceParser其實就包含了xml文件信息的一個對象，以後經過XmlResourceParser將tag的信息取出，遞歸建立View，具體XmlResourceParser對象的建立以下，ui

public XmlResourceParser getLayout(int id) throws NotFoundException {
    return loadXmlResourceParser(id, "layout");
}   
複製代碼

注意這裏解析的xml文件是layout，this

XmlResourceParser loadXmlResourceParser(int id, String type)
        throws NotFoundException {
    synchronized (mAccessLock) {
        TypedValue value = mTmpValue;
        <!--獲取一個TypedValue-->
        if (value == null) {
            mTmpValue = value = new TypedValue();
        }
        <!--利用id 查詢layout，並填充TypedValue-->
        getValue(id, value, true);
        <!--根據佈局文件的路徑，返回解析xml文件-->
        if (value.type == TypedValue.TYPE_STRING) {
            return loadXmlResourceParser(value.string.toString(), id,
                    value.assetCookie, type);
        }
    }
}    
複製代碼

TypedValue是與xml定義的資源對應的值，xml是固定的，非動態的，所以只須要一份，因此能夠有緩存機制，看一下getValue如何獲取對應xml資源：spa

public void getValue(int id, TypedValue outValue, boolean resolveRefs)
        throws NotFoundException {
    boolean found = mAssets.getResourceValue(id, 0, outValue, resolveRefs);
}
複製代碼

這裏牽扯到Android的資源管理內容，mAssets是一個AssetManager對象，

final boolean getResourceValue(int ident,int density, TypedValue outValue, boolean resolveRefs) {
   <!--加載資源-->
    int block = loadResourceValue(ident, (short) density, outValue, resolveRefs);
    if (block >= 0) {
        if (outValue.type != TypedValue.TYPE_STRING) {
            return true;
        }
        outValue.string = mStringBlocks[block].get(outValue.data);
        return true; }  return false;  }
複製代碼

AssetManager進而會經過native函數加載xml文件信息，

static jint android_content_AssetManager_loadResourceValue(JNIEnv* env, jobject clazz, jint ident,jshort density,jobject outValue,jboolean resolve){
    ...<!--獲取native AssetManager對象-->
    AssetManager* am = assetManagerForJavaObject(env, clazz);
    <!--獲取ResTable資源表，這裏應該有緩存 不能每次都弄一次吧？ 全部資源的惟一表嗎？-->
    const ResTable& res(am->getResources());
    Res_value value;
    ResTable_config config;
    uint32_t typeSpecFlags;
    <!--經過ResTable獲取資源-->
    ssize_t block = res.getResource(ident, &value, false, density, &typeSpecFlags, &config);
   ...
    uint32_t ref = ident;
    if (resolve) {
    <!--是否須要二次解析資源-->
        block = res.resolveReference(&value, block, &ref, &typeSpecFlags, &config);
    ...
    }
    return block >= 0 ? copyValue(env, outValue, &res, value, ref, block, typeSpecFlags, &config) : block;
}
複製代碼

以上代碼就是如何獲取資源的，其中res.getResource並非是每次都加載一遍，第一次加載後就能得到單利ResTable，後面用的都是這個緩存，只不過ResTable不會緩存所有資源，對於佈局、圖像資源等，緩存的都是引用，因此，若是是真實資源的引用話，還須要經過res.resolveReference來解析真正的資源。資源加載不是這裏重點，重點是LayoutInflater如何建立View樹，只簡單看一下資源加載：

const ResTable* AssetManager::getResTable(bool required) const{

	<!--緩存 ResTable，若是非空直接返回-->
    ResTable* rt = mResources;
    if (rt) {  return rt;   }
   ...<!--多個apk的話，會有多個-->
    const size_t N = mAssetPaths.size();
    for (size_t i=0; i<N; i++) {
        Asset* ass = NULL;
        ResTable* sharedRes = NULL;
        bool shared = true;
        <!--找到Asset的路徑-->
        const asset_path& ap = mAssetPaths.itemAt(i);
        Asset* idmap = openIdmapLocked(ap);
        <!--這裏的路徑通常都不是目錄-->
        if (ap.type != kFileTypeDirectory) {   
        		if (i == 0) {
            	  <!--第一個通常是框架層的系統資源，用的較多，不想每次都解析，須要緩存-->
                sharedRes = const_cast<AssetManager*>(this)->mZipSet.getZipResourceTable(ap.path);
            }
            if (sharedRes == NULL) {
                ass = const_cast<AssetManager*>(this)->mZipSet.getZipResourceTableAsset(ap.path);
                if (ass == NULL) {
                <!--打開resources.arsc文件-->
                    ass = const_cast<AssetManager*>(this)->openNonAssetInPathLocked("resources.arsc",  Asset::ACCESS_BUFFER,  ap);
                    if (ass != NULL && ass != kExcludedAsset) {
                        ass = const_cast<AssetManager*>(this)->mZipSet.setZipResourceTableAsset(ap.path, ass);
                    }}
                if (i == 0 && ass != NULL) {
                    <!--緩存第一個asset-->
                    sharedRes = new ResTable();
                    sharedRes->add(ass, (void*)(i+1), false, idmap);
                    sharedRes = const_cast<AssetManager*>(this)->mZipSet.setZipResourceTable(ap.path, sharedRes);
                } } } 
        ...	        
        if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) {
            if (rt == NULL) {
                mResources = rt = new ResTable();
                updateResourceParamsLocked();
            }
            if (sharedRes != NULL) {
                rt->add(sharedRes);
            } else {
                rt->add(ass, (void*)(i+1), !shared, idmap);
            }  }  .. }
    return rt;
}
複製代碼

簡而言之：經過上面的操做，完成了resources.arsc文件的解析，得到了一個ResTable對象，該對象包含了應用程序的所有資源信息（動態加載的先不考慮），以後，就能夠經過ResTable的getResource來得到指定資源，而對於xml佈局文件，這裏得到的就是一個引用，須要res.resolveReference二次解析，以後就獲得了id對應的資源項。這裏的xml佈局文件對應的資源項的值是一個字符串，實際上是一個佈局文件路徑，它指向一個通過編譯的二進制格式保存的Xml資源文件。有了這個Xml資源文件的路徑以後，會再次經過loadXmlResourceParser來對該Xml資源文件進行解析，從而獲得佈局文件解析對象XmlResourceParser。

XmlResourceParser loadXmlResourceParser(String file, int id,
        int assetCookie, String type) throws NotFoundException {
    if (id != 0) {
        try {...
        		  <!--解析xml文件-->
                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;
                    <!--返回-->
                    return block.newParser();
         ...
複製代碼

經過上一步，返回一個 XmlResourceParser對象，對外而言，XmlResourceParser是這樣一個對象：它包含解析後xml佈局信息，經過它，能夠得到xml中各類標籤的信息，甚至你能夠簡化的看作是一個包含xml格式字符串的緩存對象。到這裏，就獲取了XmlResourceParser ，也能夠說，到這裏就知道了id對應的xml文件到底包含了什麼View，那麼下一步就是根據這份緩存來實例化各類View:

public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {
    synchronized (mConstructorArgs) {
        final AttributeSet attrs = Xml.asAttributeSet(parser);
        Context lastContext = (Context)mConstructorArgs[0];
        mConstructorArgs[0] = mContext;
        View result = root;
        try {
            int type;
            final String name = parser.getName();
            <!--Merge標籤的根佈局不能直接用LayoutInflater進行inflate-->
            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 {
                View temp;
                if (TAG_1995.equals(name)) {
                    temp = new BlinkLayout(mContext, attrs);
                } else {
                <!--利用tag建立View-->
                    temp = createViewFromTag(root, name, attrs);
                }
                ViewGroup.LayoutParams params = null;
                if (root != null) {
                    <!--是否有container來輔助，或者添加到container中，或者輔助生成佈局參數-->
                    params = root.generateLayoutParams(attrs);
                    if (!attachToRoot) {
                        temp.setLayoutParams(params);
                    }
                }
                <!--若是有必要，遞歸生成子View，並添加到temp容器中-->
                rInflate(parser, temp, attrs, true);
					<!--是否須要添加到root的container容器總-->
                if (root != null && attachToRoot) {
                    root.addView(temp, params);
                }
                <!--若是不添加root中，返回結果就是infate出的根佈局View，不然就是root根佈局-->
                if (root == null || !attachToRoot) {
                    result = temp;
                }
            }

        } ...
        return result; 
        }}
複製代碼

inflate的主要做用是生成layout的跟佈局文件，而且根據參數看看是否須要添加container容器中，以後根據需求調用rInflate遞歸生成子View。

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)) {
                // inclue標籤，不能用在getDepth() == 0
                if (parser.getDepth() == 0) {
                    throw new InflateException("<include /> cannot be the root element");
                }
                parseInclude(parser, parent, attrs);
            } else if (TAG_MERGE.equals(name)) {
               <!--merge標籤必須是佈局的根元素，所以merge使用方式必定是被inclue-->
                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 {
                <!--建立View，若是有必要，接着遞歸-->
                final View view = createViewFromTag(parent, name, attrs);
                final ViewGroup viewGroup = (ViewGroup) parent;
                final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
                rInflate(parser, view, attrs, true);
                <!--添加View-->
                viewGroup.addView(view, params);
            }
        }
        if (finishInflate) parent.onFinishInflate();
    }
複製代碼

rInflate主要做用是開啓遞歸遍歷，生成View樹，createViewFromTag的主要做用是利用反射生成View對象，以上就是LayoutInflater的簡易分析。