2. 程式人生 > >轉老羅 Android應用程式資源的查詢過程分析

轉老羅 Android應用程式資源的查詢過程分析

阿新 • • 發佈：2018-11-23

原文地址  http://blog.csdn.net/luoshengyang/article/details/8806798   轉載請說明

 

 

我們知道，在Android系統中，每一個應用程式一般都會配置很多資源，用來適配不同密度、大小和方向的螢幕，以及適配不同的國家、地區和語言等等。這些資源是在應用程式執行時自動根據裝置的當前配置資訊進行適配的。這也就是說，給定一個相同的資源ID，在不同的裝置配置之下，查詢到的可能是不同的資源。這個資源查詢過程對應用程式來說，是完全透明的。在本文中，我們就詳細分析資源管理框架是如何根據ID來查詢資源的。

        從前面Android應用程式資源管理器（Asset Manager）的建立過程分析一文可以知道，Android資源管理框架實際就是由AssetManager和Resources兩個類來實現的。其中，Resources類可以根據ID來查詢資源，而AssetManager類根據檔名來查詢資源。事實上，如果一個資源ID對應的是一個檔案，那麼Resources類是先根據ID來找到資原始檔名稱，然後再將該檔名稱交給AssetManager類來開啟對應的檔案的，這個過程如圖1所示。


圖1 應用程式查詢資源的過程示意圖

        在圖1中，Resources類根據資源ID來查到資源名稱實際上也是要通過AssetManager類來實現的，這是因為資源ID與資源名稱的對應關係是由打包在APK裡面的resources.arsc檔案中的。當Resources類查詢的資源對應的是一個檔案的時候，它就會再次將資源名稱交給AssetManager，以便後者可以開啟對應的檔案，否則的話，上一步找到的資源名稱就是最終的查詢結果。

        從前面Android應用程式資源的編譯和打包過程分析

一文可以知道，APK包裡面的resources.arsc檔案是在編譯應用程式資源的時候生成的，然後連同其它被編譯的以及原生的資源一起打包在一個APK包裡面。

        從前面Android資源管理框架（Asset Manager）簡要介紹和學習計劃一文又可以知道，Android應用程式資源是可以劃分是很多類別的，但是從資源查詢的過程來看，它們可以歸結為兩大類。第一類資源是不對應有檔案的，而第二類資源是對應有檔案的，例如，字串資源是直接編譯在resources.arsc檔案中的，而介面佈局資源是在APK包裡面是對應的單獨的檔案的。如上所述，不對應檔案的資源只需要執行從資源ID到資源名稱的轉換即可，而對應有檔案的資源還需要根據資源名稱來開啟對應的檔案。在本文中，我們就以介面佈局資源的查詢過程為例，來說明Android資源管理框架查詢資源的過程。

       我們知道，每一個Activity元件建立的時候，它的成員函式onCreate都會被呼叫，而在Activity元件的成員函式onCreate中，我們基本上都無一例外地呼叫setContentView來設定Activity元件的介面。在呼叫Activity元件的成員函式setContentView的時候，需要指定一個layout型別的資源ID，以便Android資源管理框架可以找到指定的Xml資原始檔來填充（inflate）為Activity元件的介面。接下來，我們就從Activity類的成員函式setContentView開始，分析Android資源管理框架查詢layout資源的過程，如圖2所示。


圖2 型別為layout的資源的查詢過程

        這個過程可以分為22個步驟，接下來我們就詳細分析每一個步驟。

        Step 1. Activity.setContentView

[java] view plain copy print ?
  1. public class Activity extends ContextThemeWrapper 
  2.         implements LayoutInflater.Factory, 
  3.         Window.Callback, KeyEvent.Callback, 
  4.         OnCreateContextMenuListener, ComponentCallbacks { 
  5.     ...... 
  6.  
  7.     private Window mWindow; 
  8.     ...... 
  9.  
  10.     public Window getWindow() { 
  11.         return mWindow; 
  12.     } 
  13.  
  14.     ..... 
  15.  
  16.     public void setContentView(int layoutResID) { 
  17.         getWindow().setContentView(layoutResID); 
  18.     } 
  19.  
  20.     ...... 
  21. }  
public class Activity extends ContextThemeWrapper
        implements LayoutInflater.Factory,
        Window.Callback, KeyEvent.Callback,
        OnCreateContextMenuListener, ComponentCallbacks {
    ......

    private Window mWindow;
    ......

    public Window getWindow() {
        return mWindow;
    }

    .....

    public void setContentView(int layoutResID) {
        getWindow().setContentView(layoutResID);
    }

    ......
}

        這個函式定義在檔案frameworks/base/core/java/android/app/Activity.java中。

        從前面Android應用程式視窗（Activity）的視窗物件（Window）的建立過程分析一文可以知道，Activity類的成員變數mWindow指向的是一個PhoneWindow物件，因此，Activity類的成員函式setContentView實際上是呼叫PhoneWindow類的成員函式setContentView來進一步操作。

        Step 2. PhoneWindow.setContentView

[java] view plain copy print ?
  1. public class PhoneWindow extends Window implements MenuBuilder.Callback { 
  2.     ...... 
  3.  
  4.     // This is the view in which the window contents are placed. It is either 
  5.     // mDecor itself, or a child of mDecor where the contents go. 
  6.     private ViewGroup mContentParent; 
  7.     ...... 
  8.  
  9.     private LayoutInflater mLayoutInflater; 
  10.     ...... 
  11.  
  12.     @Override 
  13.     public void setContentView(int layoutResID) { 
  14.         if (mContentParent == null) { 
  15.             installDecor(); 
  16.         } else { 
  17.             mContentParent.removeAllViews(); 
  18.         } 
  19.         mLayoutInflater.inflate(layoutResID, mContentParent); 
  20.         final Callback cb = getCallback(); 
  21.         if (cb != null) { 
  22.             cb.onContentChanged(); 
  23.         } 
  24.     } 
  25.  
  26.     ...... 
  27. }  
public class PhoneWindow extends Window implements MenuBuilder.Callback {
    ......

    // This is the view in which the window contents are placed. It is either
    // mDecor itself, or a child of mDecor where the contents go.
    private ViewGroup mContentParent;
    ......

    private LayoutInflater mLayoutInflater;
    ......

    @Override
    public void setContentView(int layoutResID) {
        if (mContentParent == null) {
            installDecor();
        } else {
            mContentParent.removeAllViews();
        }
        mLayoutInflater.inflate(layoutResID, mContentParent);
        final Callback cb = getCallback();
        if (cb != null) {
            cb.onContentChanged();
        }
    }

    ......
}
        這個函式定義在檔案frameworks/base/policy/src/com/android/internal/policy/impl/PhoneWindow.java中。

        PhoneWindow類的成員變數mContentParent用來描述一個型別為DecorView的檢視物件，或者這個型別為DecorView的檢視物件的一個子檢視物件，用作UI容器。當它的值等於null的時候，就說明當前正在處理的Activity元件的檢視物件還沒有建立。在這種情況下，就會呼叫成員函式installDecor來建立當前正在處理的Activity元件的檢視物件。否則的話，就說明是要重新設定當前正在處理的Activity元件的檢視。在重新設定之前，首先呼叫成員變數mContentParent所描述的一個ViewGroup物件來移除原來的UI內容。

        PhoneWindow類的成員變數mLayoutInflater指向的是一個PhoneLayoutInflater物件。PhoneLayoutInflater類是從LayoutInflater類繼續下來的，同時它也繼承了LayoutInflater類的成員函式inflate。通過呼叫PhoneWindow類的成員變數mLayoutInflater所指向的一個PhoneLayoutInflater物件的成員函式inflate，也就是從父類繼承下來的成員函式inflate，就可以將引數layoutResID所描述的一個UI佈局設定到mContentParent所描述的一個檢視容器中去。這樣就可以將當前正在處理的Activity元件的UI創建出來。

        最後，PhoneWindow類的成員函式還會呼叫一個Callback介面的成員函式onContentChanged來通知當前正在處理的Activity元件，它的檢視內容發生改變了。從前面Android應用程式視窗（Activity）的視窗物件（Window）的建立過程分析一文可以知道，每一個Activity元件都實現了一個Callback介面，並且將這個Callback介面設定到了與它所關聯的PhoneWindow的內部去，因此，最後呼叫的實際上是Activity類的成員函式onContentChanged。

        接下來，我們就繼續分析LayoutInflater類的成員函式inflate的實現，以便可以瞭解Android資源管理框架是如何找到引數layoutResID所描述的UI佈局檔案的。

        Step 3. LayoutInflater.inflate

[java] view plain copy print ?
  1. public abstract class LayoutInflater { 
  2.     ...... 
  3.  
  4.     public View inflate(int resource, ViewGroup root) { 
  5.         return inflate(resource, root, root != null); 
  6.     } 
  7.  
  8.     ...... 
  9.  
  10.     public View inflate(int resource, ViewGroup root, boolean attachToRoot) { 
  11.         ...... 
  12.         XmlResourceParser parser = getContext().getResources().getLayout(resource); 
  13.         try { 
  14.             return inflate(parser, root, attachToRoot); 
  15.         } finally { 
  16.             parser.close(); 
  17.         } 
  18.     } 
  19.  
  20.     ...... 
  21. }  
public abstract class LayoutInflater {
    ......

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

    ......

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

    ......
}

        這個函式定義在檔案frameworks/base/core/java/android/view/LayoutInflater.java中。

        LayoutInflater類兩個引數版本的成員函式inflate通過呼叫三個引數版本的成員函式inflate來查詢引數resource所描述的UI佈局檔案。

        在LayoutInflater類三個引數版本的成員函式inflate中，首先是獲得用來描述當前執行上下文環境的一個Resources物件，然後接呼叫這個Resources物件的成員函式getLayout來查詢引數resource所描述的UI佈局檔案。

        Resources類的成員函式getLayout找到了指定的UI佈局檔案之後，就會開啟它。由於Android系統的UI佈局檔案是一個Xml檔案，因此，Resources類的成員函式getLayout開啟它之後，得到的是一個XmlResourceParser物件。有了這個XmlResourceParser物件之後，LayoutInflater類三個引數版本的成員函式inflate就將它傳遞給另外一個三個引數版本的成員函式inflate，以便後者可以通過它來建立一個UI介面。

        接下來，我們就首先分析Resources類的成員函式getLayout的實現，然後再分析LayoutInflater類的另外一個三個引數版本的成員函式inflate的實現。

        Step 4. Resources.getLayout

[java] view plain copy print ?
  1. public class Resources { 
  2.     ...... 
  3.  
  4.     public XmlResourceParser getLayout(int id) throws NotFoundException { 
  5.         return loadXmlResourceParser(id, "layout"); 
  6.     } 
  7.  
  8.     ...... 
  9. }  
public class Resources {
    ......

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

    ......
}
        這個函式定義在檔案frameworks/base/core/java/android/content/res/Resources.java中。

        Resources類的成員函式getLayout的實現很簡單，它通過呼叫另外一個成員函式loadXmlResourceParser來查詢並且開啟由引數id所描述的一個UI佈局檔案。

        Step 5. Resources.loadXmlResourceParser

[java] view plain copy print ?
  1. public class Resources { 
  2.     ...... 
  3.  
  4.     /*package*/ XmlResourceParser loadXmlResourceParser(int id, String type) 
  5.             throws NotFoundException { 
  6.         synchronized (mTmpValue) { 
  7.             TypedValue value = mTmpValue; 
  8.             getValue(id, value, true); 
  9.             if (value.type == TypedValue.TYPE_STRING) { 
  10.                 return loadXmlResourceParser(value.string.toString(), id, 
  11.                         value.assetCookie, type); 
  12.             } 
  13.             throw new NotFoundException( 
  14.                     "Resource ID #0x" + Integer.toHexString(id) + " type #0x" 
  15.                     + Integer.toHexString(value.type) + " is not valid"); 
  16.         } 
  17.     } 
  18.  
  19.     ...... 
  20. }  
public class Resources {
    ......

    /*package*/ XmlResourceParser loadXmlResourceParser(int id, String type)
            throws NotFoundException {
        synchronized (mTmpValue) {
            TypedValue value = mTmpValue;
            getValue(id, value, true);
            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");
        }
    }

    ......
}
        這個函式定義在檔案frameworks/base/core/java/android/content/res/Resources.java中。

        引數id描述的是一個資源ID，Resources類的成員函式loadXmlResourceParser首先呼叫另外一個成員函式getValue來獲得該資源ID所對應的資源值，並且儲存在一個型別為TypedValue的變數value中。在我們這個情景中，引數id描述的是一個型別為layout的資源ID，從前面Android應用程式資源的編譯和打包過程分析一文可以知道，型別為layout的資源ID對應的資源值即為一個UI佈局檔名稱。有了這個UI佈局檔名稱之後，Resources類的成員函式loadXmlResourceParser接著再呼叫另外一個四個引數版本的成員函式loadXmlResourceParser來載入對應的UI佈局檔案，並且得到一個XmlResourceParser物件返回給呼叫者。

        注意，如果Resources類的成員函式getValue沒有找到與引數id所描述的資源，或者找到的資源的值不是字串型別的，那麼Resources類的成員函式loadXmlResourceParser就會丟擲一個型別為NotFoundException的異常。

        接下來，我們就首先分析Resources類的成員函式getValue的實現，接著再分析Resources類四個引數版本的成員函式loadXmlResourceParser的實現。

        Step 6. Resources.getValue

[java] view plain copy print ?
  1. public class Resources { 
  2.     ...... 
  3.  
  4.     /*package*/ final AssetManager mAssets; 
  5.     ...... 
  6.  
  7.     public void getValue(int id, TypedValue outValue, boolean resolveRefs) 
  8.             throws NotFoundException { 
  9.         boolean found = mAssets.getResourceValue(id, outValue, resolveRefs); 
  10.         if (found) { 
  11.             return; 
  12.         } 
  13.         throw new NotFoundException("Resource ID #0x" 
  14.                                     + Integer.toHexString(id)); 
  15.     } 
  16.  
  17.     ...... 
  18. }  
public class Resources {
    ......

    /*package*/ final AssetManager mAssets;
    ......

    public void getValue(int id, TypedValue outValue, boolean resolveRefs)
            throws NotFoundException {
        boolean found = mAssets.getResourceValue(id, outValue, resolveRefs);
        if (found) {
            return;
        }
        throw new NotFoundException("Resource ID #0x"
                                    + Integer.toHexString(id));
    }

    ......
}

        這個函式定義在檔案frameworks/base/core/java/android/content/res/Resources.java中。

        Resources類的成員變數mAssets指向的是一個AssetManager物件，Resources類的成員函式getValue通過呼叫它的成員函式getResourceValue來獲得與引數id所對應的資源的值。注意，如果AssetManager類的成員函式getResourceValue查詢不到與引數id所對應的資源，那麼Resources類的成員函式getValue就會丟擲一個型別為NotFoundException的異常。

        接下來，我們就繼續分析AssetManager類的成員函式getResourceValue的實現。

        Step 7. AssetManager.getResourceValue

[java] view plain copy print ?
  1. public final class AssetManager { 
  2.     ...... 
  3.  
  4.     private StringBlock mStringBlocks[] = null; 
  5.     ...... 
  6.  
  7.     /*package*/ final boolean getResourceValue(int ident, 
  8.                                                TypedValue outValue, 
  9.                                                boolean resolveRefs) 
  10.     { 
  11.         int block = loadResourceValue(ident, outValue, resolveRefs); 
  12.         if (block >= 0) { 
  13.             if (outValue.type != TypedValue.TYPE_STRING) { 
  14.                 return true; 
  15.             } 
  16.             outValue.string = mStringBlocks[block].get(outValue.data); 
  17.             return true; 
  18.         } 
  19.         return false; 
  20.     } 
  21.  
  22.     ...... 
  23. }  
public final class AssetManager {
    ......

    private StringBlock mStringBlocks[] = null;
    ......

    /*package*/ final boolean getResourceValue(int ident,
                                               TypedValue outValue,
                                               boolean resolveRefs)
    {
        int block = loadResourceValue(ident, outValue, resolveRefs);
        if (block >= 0) {
            if (outValue.type != TypedValue.TYPE_STRING) {
                return true;
            }
            outValue.string = mStringBlocks[block].get(outValue.data);
            return true;
        }
        return false;
    }

    ......
}

        這個函式定義在檔案frameworks/base/core/java/android/content/res/AssetManager.java中。

        AssetManager類的成員函式getResourceValue通過呼叫另外一個成員函式loadResourceValue來載入引數ident所描述的資源。如果載入成功，那麼結果就會儲存在引數outValue所描述的一個TypedValue物件中，並且AssetManager類的成員函式loadResourceValue的返回值block大於等於0。

        從前面Android應用程式資源管理器（Asset Manager）的建立過程分析一文可以知道，AssetManager類的成員變數mStringBlock描述的是一個StringBlock陣列。這個StringBlock陣列中的每一個StringBlock物件描述的都是當前應用程式使用的每一個資源索引表的資源項值字串資源池。關於資源索引表的格式以及生成過程，可以參考前面Android應用程式資源的編譯和打包過程分析一文。

        瞭解了上述背景之後，我們就可以知道，當AssetManager類的成員函式loadResourceValue的返回值block大於等於0的時候，實際上就表示引數ident所描述的資源項在當前應用程式使用的第block個資源索引表中，而當引數ident所描述的資源項是一個字串時，那麼就可以在第block個資源索引表的資源項值字串資源池中找到對應的字串，並且儲存在引數outValue所描述的一個TypedValue物件的成員變數string中，以便返回給呼叫者使用。注意，最終得到的字串在第block個資源索引表的資源項值字串資源池中的位置就儲存在引數outValue所描述的一個TypedValue物件的成員變數data中。

        接下來，我們就繼續分析AssetManager類的成員函式loadResourceValue的實現。

        Step 8. AssetManager.loadResourceValue

[java] view plain copy print ?
  1. public final class AssetManager { 
  2.     ...... 
  3.  
  4.     /** Returns true if the resource was found, filling in mRetStringBlock and
  5.      *  mRetData. */ 
  6.     private native final int loadResourceValue(int ident, TypedValue outValue, 
  7.                                                boolean resolve); 
  8.  
  9.     ...... 
  10. }  
public final class AssetManager {
    ......

    /** Returns true if the resource was found, filling in mRetStringBlock and
     *  mRetData. */
    private native final int loadResourceValue(int ident, TypedValue outValue,
                                               boolean resolve);

    ......
}
        這個函式定義在檔案frameworks/base/core/java/android/content/res/AssetManager.java中。

        AssetManager類的成員函式loadResourceValue是一個JNI方法，它是由C++層的函式android_content_AssetManager_loadResourceValue來實現的，如下所示：

[cpp] view plain copy print ?
  1. static jint android_content_AssetManager_loadResourceValue(JNIEnv* env, jobject clazz, 
  2.                                                            jint ident, 
  3.                                                            jobject outValue, 
  4.                                                            jboolean resolve) 
  5. { 
  6.     AssetManager* am = assetManagerForJavaObject(env, clazz); 
  7.     if (am == NULL) { 
  8.         return 0; 
  9.     } 
  10.     const ResTable& res(am->getResources()); 
  11.  
  12.     Res_value value; 
  13.     ResTable_config config; 
  14.     uint32_t typeSpecFlags; 
  15.     ssize_t block = res.getResource(ident, &value, false, &typeSpecFlags, &config); 
  16.     ...... 
  17.  
  18.     uint32_t ref = ident; 
  19.     if (resolve) { 
  20.         block = res.resolveReference(&value, block, &ref); 
  21.         ...... 
  22.     } 
  23.     return block >= 0 ? copyValue(env, outValue, &res, value, ref, block, typeSpecFlags, &config) : block; 
  24. }  
static jint android_content_AssetManager_loadResourceValue(JNIEnv* env, jobject clazz,
                                                           jint ident,
                                                           jobject outValue,
                                                           jboolean resolve)
{
    AssetManager* am = assetManagerForJavaObject(env, clazz);
    if (am == NULL) {
        return 0;
    }
    const ResTable& res(am->getResources());

    Res_value value;
    ResTable_config config;
    uint32_t typeSpecFlags;
    ssize_t block = res.getResource(ident, &value, false, &typeSpecFlags, &config);
    ......

    uint32_t ref = ident;
    if (resolve) {
        block = res.resolveReference(&value, block, &ref);
        ......
    }
    return block >= 0 ? copyValue(env, outValue, &res, value, ref, block, typeSpecFlags, &config) : block;
}
        這個函式定義在檔案frameworks/base/core/jni/android_util_AssetManager.cpp中。

        函式android_content_AssetManager_loadResourceValue主要是執行以下五個操作：

        1. 呼叫函式assetManagerForJavaObject來將引數clazz所描述的一個Java層的AssetManager物件的成員變數mObject轉換為一個C++層的AssetManager物件。

        2. 呼叫上述得到的C++層的AssetManager物件的成員函式getResources來獲得一個ResTable物件，這個ResTable物件描述的是一個資源表。

        3. 呼叫上述得到的ResTable物件的成員函式getResource來獲得與引數ident所對應的資源項值及其配置資訊，並且儲存在型別為Res_value的變數value以及型別為ResTable_config的變數config中。

        4. 如果引數resolve的值等於true，那麼就繼續呼叫上述得到的ResTable物件的成員函式resolveReference來解析前面所得到的資源項值。

        5. 呼叫函式copyValue將上述得到的資源項值及其配置資訊拷貝到引數outValue所描述的一個Java層的TypedValue物件中去，返回呼叫者可以獲得與引數ident所對應的資源項內容。

        接下來，我們就主要分析第2~4操作，即AssetManager物件的成員函式getResources以及ResTable類的成員函式getResource和resolveReference的實現，以便可以瞭解Android應用程式資源的查詢過程。

        Step 9. AssetManager.getResources

[cpp] view plain copy print ?
  1. const ResTable& AssetManager::getResources(bool required) const 
  2. { 
  3.     const ResTable* rt = getResTable(required); 
  4.     return *rt; 
  5. }  
const ResTable& AssetManager::getResources(bool required) const
{
    const ResTable* rt = getResTable(required);
    return *rt;
}
        這個函式定義在檔案frameworks/base/libs/utils/AssetManager.cpp中。

        AssetManager類的成員函式getResources通過呼叫另外一個成員函式getResTable來獲得當前應用程式所使用的資源表，後者的實現如下所示：

[cpp] view plain copy print ?
  1. const ResTable* AssetManager::getResTable(bool required) const 
  2. { 
  3.     ResTable* rt = mResources; 
  4.     if (rt) { 
  5.         return rt; 
  6.     } 
  7.  
  8.     // Iterate through all asset packages, collecting resources from each. 
  9.  
  10.     AutoMutex _l(mLock); 
  11.  
  12.     if (mResources != NULL) { 
  13.         return mResources; 
  14.     } 
  15.  
  16.     ...... 
  17.  
  18.     const size_t N = mAssetPaths.size(); 
  19.     for (size_t i=0; i<N; i++) { 
  20.         Asset* ass = NULL; 
  21.         ResTable* sharedRes = NULL; 
  22.         bool shared = true; 
  23.         const asset_path& ap = mAssetPaths.itemAt(i); 
  24.         Asset* idmap = openIdmapLocked(ap); 
  25.         ...... 
  26.         if (ap.type != kFileTypeDirectory) { 
  27.             if (i == 0) { 
  28.                 // The first item is typically the framework resources, 
  29.                 // which we want to avoid parsing every time. 
  30.                 sharedRes = const_cast<AssetManager*>(this)-> 
  31.                     mZipSet.getZipResourceTable(ap.path); 
  32.             } 
  33.             if (sharedRes == NULL) { 
  34.                 ass = const_cast<AssetManager*>(this)-> 
  35.                     mZipSet.getZipResourceTableAsset(ap.path); 
  36.                 if (ass == NULL) { 
  37.                     ...... 
  38.                     ass = const_cast<AssetManager*>(this)-> 
  39.                         openNonAssetInPathLocked("resources.arsc", 
  40.                                                  Asset::ACCESS_BUFFER, 
  41.                                                  ap); 
  42.                     if (ass != NULL && ass != kExcludedAsset) { 
  43.                         ass = const_cast<AssetManager*>(this)-> 
  44.                             mZipSet.setZipResourceTableAsset(ap.path, ass); 
  45.                     } 
  46.                 } 
  47.  
  48.                 if (i == 0 && ass != NULL) { 
  49.                     // If this is the first resource table in the asset 
  50.                     // manager, then we are going to cache it so that we 
  51.                     // can quickly copy it out for others. 
  52.                     LOGV("Creating shared resources for %s", ap.path.string()); 
  53.                     sharedRes = new ResTable(); 
  54.                     sharedRes->add(ass, (void*)(i+1), false, idmap); 
  55.                     sharedRes = const_cast<AssetManager*>(this)-> 
  56.                         mZipSet.setZipResourceTable(ap.path, sharedRes); 
  57.                 } 
  58.             } 
  59.         } else { 
  60.             ...... 
  61.             Asset* ass = const_cast<AssetManager*>(this)-> 
  62.                 openNonAssetInPathLocked("resources.arsc", 
  63.                                          Asset::ACCESS_BUFFER, 
  64.                                          ap); 
  65.             shared = false; 
  66.         } 
  67.         if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) { 
  68.             if (rt == NULL) { 
  69.                 mResources = rt = new ResTable(); 
  70.                 updateResourceParamsLocked(); 
  71.             }&nb

相關推薦

轉老羅 Android應用程式資源的查詢過程分析

原文地址  http://blog.csdn.net/luoshengyang/article/details/8806798   轉載請說明     我們知道，在Android系統中，每一個應用程式一般都會配置很多資源，用來適配不同密

轉自老羅 Android應用程式資源的編譯和打包過程分析

原文地址   http://blog.csdn.net/luoshengyang/article/details/8744683 轉載自老羅，轉載請說明   我們知道，在一個APK檔案中，除了有程式碼檔案之外，還有很多資原始檔。這些資原始檔是通過An

轉自 老羅 Android應用程式資源管理器（Asset Manager）的建立過程分析

原文地址在 http://blog.csdn.net/luoshengyang/article/details/8791064 原創老羅，轉載請說明     在前面一篇文章中，我們分析了Android應用程式資源的編譯和打包過程，最終得到的應用程式資源就與

Android應用程式資源的編譯和打包過程分析

   我們知道，在一個APK檔案中，除了有程式碼檔案之外，還有很多資原始檔。這些資原始檔是通過Android資源打包工具aapt（Android Asset Package Tool）打包到APK檔案裡面的。在打包之前，大部分文字格式的XML資原始檔還會被編譯

Android應用程式程序啟動過程（前篇）

前言 在此前我講過Android系統的啟動流程，系統啟動後，我們就比較關心應用程式是如何啟動的，這一篇我們來一起學習Android7.0 應用程式程序啟動過程，需要注意的是“應用程式程序啟動過程”，而不是應用程式啟動過程。關於應用程式啟動過程，我會在後

Android應用程式的啟動過程

前言 在Android系統中，Activity和Service是應用程式的核心元件，它們以鬆藕合的方式組合在一起構成了一個完整的應用程式，這得益於應用程式框架層提供了一套完整的機制來協助應用程式啟動這些Activity和Service，以及提供Binder機制幫

Android應用程式程序啟動過程（後篇）

前言 在前篇中我們講到了Android應用程式程序啟動過程，這一篇我們來講遺留的知識點：在應用程式程序建立過程中會啟動Binder執行緒池以及在應用程式程序啟動後會建立訊息迴圈。 1.Binder執行緒池啟動過程 我們首先來看RuntimeInit

[筆記]Android應用程式程序啟動過程的理解

疑問： 1.Process.fork是啥意思？類似new嗎？ 2.接著1問，新APP程序和ActivityThread類是怎麼關聯起來的？是zygote程序呼叫執行的ActivityThread類的main方法，怎麼就執行在了新APP程序中？ 3.UI主執行緒是啥時候建

Android應用程式包解析過程淺析

       我在上一篇檔案中Android應用程式安裝過程淺析粗略分析了一下Android應用程式安裝過程，其中有一步說到了apk包的解析，但是沒有詳細分析，這裡我們就來粗略分析一下包的解析過程。 流程圖 執行過程        從上面的流程

老羅的Android之旅——Android應用程式的Activity啟動過程簡要介紹和學習計劃

在Android系統中，Activity和Service是應用程式的核心元件，它們以鬆藕合的方式組合在一起構成了一個完整的應用程式，這得益於應用程式框架層提供了一套完整的機制來協助應用程式啟動這些Activity和Service，以及提供Binder機制幫助它們相

Android原始碼解析之應用程式資源管理器（Asset Manager）的建立過程分析

轉載自：https://blog.csdn.net/luoshengyang/article/details/8791064 我們分析了Android應用程式資源的編譯和打包過程，最終得到的應用程式資源就與應用程式程式碼一起打包在一個APK檔案中。Android應用程式在執行的過程中，是通過一個

android應用程式的混淆打包(轉)

target=android-8 proguard.config=proguard.cfg Eclipse會通過此配置在工程目錄生成proguard.cfg檔案  2 . 生成keystore (如已有可直接利用) 按照下面的命令列 在D:\Program 

Android應用程式的記憶體分析（翻譯）（轉）

作者：Tim Bray Dalvik虛擬機器支援垃圾收集，但是這不意味著你可以不用關心記憶體管理。你應該格外注意移動裝置的記憶體使用，在上面記憶體空間是受到限制的。在這篇 文章裡面，我們來看看Android SDK裡面的一些記憶體剖析工具（profiling tools）

Android應用程式外掛化研究之資源衝突

最近在研究Android應用的外掛化開發，  外掛化都是在解決以下幾個問題： 本章我們來研究最後一個問題：資源共享與衝突。在《Android應用程式外掛化研究之AssertManager》中，我們實現了載入外掛apk中資源問題，實際上我們是單獨建立了用於訪問外掛資源的Ass

Android 應用程式之間的跳轉

作者：handsomedylan Sending the User to Another App Android最重要的特性之一就是：一個應用可以基於不同的 action,把使用者推送到其他應用中去。比如說，如果你想在你的應用中顯示一張帶有商店地址的地圖，你並不需要在自己的應用中去實現一個顯示地圖的Act

android 應用程式間跳轉

Sending the User to Another App Android最重要的特性之一就是：一個應用可以基於不同的 action,把使用者推送到其他應用中去。比如說，如果你想在你的應用中顯示一張帶有商店地址的地圖，你並不需要在自己的應用中去實現一個顯示地圖的Act

瀏覽器判別下載安裝/開啟Android應用程式

摘要: 通過手機瀏覽器直接開啟Android應用程式。 如果本地已經安裝了指定Android應用，就直接開啟它； 如果沒有安裝，則直接下載該應用的安裝檔案（也可以跳轉到下載頁面）。 之前寫過一篇blog，介紹如何通過點選手機瀏覽器中的連結，直接開啟本地Android App。 實現方式

Android應用程式框架講解

在我們的android的程式中會有很多的檔案，那麼這些檔案到底是有什麼作用呢？ 我們編譯android專案，可以使用eclipse和AS，首先介紹一下eclipse中的框架 1、src檔案：存放的是應用程式使用到的java檔案 2、gen檔案：系統自動生成的目錄。不需要程式設計師進行

android應用程式的介面程式設計

要點 android的介面與view元件 view元件和viewgroup元件 android控制程式的三種方式 通過繼承view開發自定義view android常見的佈局管理器 文字框元件：textview和edittext 按鈕元件：button 特殊按鈕元件:radiobut

Android應用程式進行系統簽名

有時寫一個程式需要呼叫系統的庫，如果許可權不夠，是用不了庫裡面一些方法的 。這時就需要將apk進行系統簽名。  簡單常用的方法：                 1，在apk的AndroidMani