[关闭]
@dodola 2019-02-15T10:47:40.000000Z 字数 22441 阅读 1691

VirtualAPK 资源篇

dodola

概述

VitrualAPK 是滴滴开源的一款插件化框架

VirtualAPK 地址：https://github.com/didi/VirtualAPK

前两天鸿洋分析了插件的四大组件启动流程，这里针对一些具体的点分析一下。

本篇先从资源下手分析。VirtualAPK的插件资源加载分为两种方式：

一种是插件存在一份独立的 Resources 自己使用，一种是COMBINE_RESOURCES模式，将插件的资源全部添加到宿主的 Resources 里

首先我们要先看一下系统是如何加载资源的。

Android 资源加载

此处简单探讨一下Android系统里资源加载查找的过程，这是插件加载资源的理论基础。

Resources对象的生成

从下向上一直可以追溯到生成Resources对象的地方

  1.     class ContextImpl extends Context {
  2.     //...
  3.         private ContextImpl(ContextImpl container, ActivityThread mainThread,
  4.                 LoadedApk packageInfo, IBinder activityToken, UserHandle user, boolean restricted,
  5.                 Display display, Configuration overrideConfiguration) {
  6.         //....
  7.         Resources resources = packageInfo.getResources(mainThread);
  8.         //....
  9.         }
  11.     //...
  12.     }

这里不去关注packageInfo是如何生成的，直接跟踪到下面去.

  1.     public final class LoadedApk {
  2.         private final String mResDir;
  4.       public LoadedApk(ActivityThread activityThread, ApplicationInfo aInfo,
  5.                 CompatibilityInfo compatInfo, ClassLoader baseLoader,
  6.                 boolean securityViolation, boolean includeCode, boolean registerPackage) {
  7.             final int myUid = Process.myUid();
  8.             aInfo = adjustNativeLibraryPaths(aInfo);
  10.             mActivityThread = activityThread;
  11.             mApplicationInfo = aInfo;
  12.             mPackageName = aInfo.packageName;
  13.             mAppDir = aInfo.sourceDir;
  14.             mResDir = aInfo.uid == myUid ? aInfo.sourceDir : aInfo.publicSourceDir;
  15.             // 注意一下这个sourceDir，这个是我们宿主的APK包在手机中的路径，宿主的资源通过此地址加载。
  16.             // 该值的生成涉及到PMS,暂时不进行分析。
  17.             // Full path to the base APK for this application.
  18.            //....
  19.         }
  23.     //....
  24.        public Resources getResources(ActivityThread mainThread) {
  25.             if (mResources == null) {
  26.                 mResources = mainThread.getTopLevelResources(mResDir, mSplitResDirs, mOverlayDirs,
  27.                         mApplicationInfo.sharedLibraryFiles, Display.DEFAULT_DISPLAY, null, this);
  28.             }
  29.             return mResources;
  30.         }
  31.     //....
  32.     }

进入到ActivityThread.getTopLevelResources()的逻辑中

  1.     public final class ActivityThread {  
  2.       Resources getTopLevelResources(String resDir, CompatibilityInfo compInfo) {  
  3.       //我们暂时只关注下面这一段代码
  5.            AssetManager assets = new AssetManager();  
  6.             if (assets.addAssetPath(resDir) == 0) {  //此处将上面的mResDir，也就是宿主的APK在手机中的路径当做资源包添加到AssetManager里，则Resources对象可以通过AssetManager查找资源，此处见(老罗博客：Android应用程序资源的查找过程分析)
  7.                 return null;  
  8.             }  
  9.             // 创建Resources对象，此处依赖AssetManager类来实现资源查找功能。
  10.            r = new Resources(assets, metrics, getConfiguration(), compInfo);  
  12.      }  
  13.     }

从上面的代码中我们知道了我们常用的Resources是如何生成的了，那么理论上插件也就按照如此方式生成一个Resources对象给自己用就可以了。下面从VirtualAPK的代码里看一下对资源的处理

VirtualAPK 资源加载

在VirtualAPK里插件所有相关的内容都被封装到LoadedPlugin里，插件的加载行为一般都在这个类的构造方法的实现里,我们这里只关注与资源相关部分的代码

LoadedPlugin.java

  1.     LoadedPlugin(PluginManager pluginManager, Context context, File apk) throws PackageParser.PackageParserException {
  2.         //需要注意context是宿主的Context
  3.         //apk 指的是插件的路径
  4.         this.mResources = createResources(context, apk);
  5.         this.mAssets = this.mResources.getAssets();
  6.     }
  9.         private static AssetManager createAssetManager(Context context, File apk) {
  10.             try {
  11.                 //这里参照系统的方式生成AssetManager，并通过反射将插件的apk路径添加到AssetManager里
  12.                 //这里只适用于资源独立的情况，如果需要调用宿主资源，则需要插入到宿主的AssetManager里
  13.                 AssetManager am = AssetManager.class.newInstance();
  14.                 ReflectUtil.invoke(AssetManager.class, am, "addAssetPath", apk.getAbsolutePath());
  15.                 return am;
  16.             } catch (Exception e) {
  17.                 e.printStackTrace();
  18.                 return null;
  19.             }
  20.         }
  22.         @WorkerThread
  23.         private static Resources createResources(Context context, File apk) {
  24.             if (Constants.COMBINE_RESOURCES) {
  25.                 //如果插件资源合并到宿主里面去的情况，插件可以访问宿主的资源
  26.                 Resources resources = new ResourcesManager().createResources(context, apk.getAbsolutePath());
  27.                 ResourcesManager.hookResources(context, resources);
  28.                 return resources;
  29.             } else {
  30.                 //插件使用独立的Resources，不与宿主有关系，无法访问到宿主的资源
  31.                 Resources hostResources = context.getResources();
  32.                 AssetManager assetManager = createAssetManager(context, apk);
  33.                 return new Resources(assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration());
  34.             }
  35.         }

如果将宿主和插件隔离，我们只需要生成一个独立的Resources对象给插件使用，如果要调用宿主资源则需要将宿主的APK和插件的APK一起添加到同一个AssetManager里。进入到ResourcesManager的逻辑里

ResourcesManager.java

  1.      public static synchronized Resources createResources(Context hostContext, String apk) {
  2.             // hostContext 为宿主的Context
  3.             Resources hostResources = hostContext.getResources();
  4.             //获取到宿主的Resources对象
  5.             Resources newResources = null;
  6.             AssetManager assetManager;
  7.             try {
  9.                 //-----begin---
  10.                 //这块的代码涉及到的内容比较多，详情见①
  11.                 if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
  12.                     assetManager = AssetManager.class.newInstance();
  13.                     ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", hostContext.getApplicationInfo().sourceDir);
  14.                 } else {
  15.                     assetManager = hostResources.getAssets();
  16.                 }
  17.                 //------end----
  19.                 //------begin---
  20.                 ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", apk);
  21.                 List<LoadedPlugin> pluginList = PluginManager.getInstance(hostContext).getAllLoadedPlugins();
  22.                 for (LoadedPlugin plugin : pluginList) {
  23.                     ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", plugin.getLocation());
  24.                 }
  26.                 //------end----
  28.                 //-----begin-----
  29.                 //此处针对机型的兼容代码是可以避开的，详情见③
  30.                 if (isMiUi(hostResources)) {
  31.                     newResources = MiUiResourcesCompat.createResources(hostResources, assetManager);
  32.                 } else if (isVivo(hostResources)) {
  33.                     newResources = VivoResourcesCompat.createResources(hostContext, hostResources, assetManager);
  34.                 } else if (isNubia(hostResources)) {
  35.                     newResources = NubiaResourcesCompat.createResources(hostResources, assetManager);
  36.                 } else if (isNotRawResources(hostResources)) {
  37.                     newResources = AdaptationResourcesCompat.createResources(hostResources, assetManager);
  38.                 } else {
  39.                     // is raw android resources
  40.                     newResources = new Resources(assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration());
  41.                 }
  42.                 //-----end-----
  43.             } catch (Exception e) {
  44.                 e.printStackTrace();
  45.             }
  47.             return newResources;
  49.         }
  51.         public static void hookResources(Context base, Resources resources) {
  52.             if (Build.VERSION.SDK_INT >= 24) {
  53.                 return;
  54.             }
  56.             try {
  57.                 ReflectUtil.setField(base.getClass(), base, "mResources", resources);
  58.                 Object loadedApk = ReflectUtil.getPackageInfo(base);
  59.                 ReflectUtil.setField(loadedApk.getClass(), loadedApk, "mResources", resources);
  61.                 Object activityThread = ReflectUtil.getActivityThread(base);
  62.                 Object resManager = ReflectUtil.getField(activityThread.getClass(), activityThread, "mResourcesManager");
  63.                 Map<Object, WeakReference<Resources>> map = (Map<Object, WeakReference<Resources>>) ReflectUtil.getField(resManager.getClass(), resManager, "mActiveResources");
  64.                 Object key = map.keySet().iterator().next();
  65.                 map.put(key, new WeakReference<>(resources));
  66.             } catch (Exception e) {
  67.                 e.printStackTrace();
  68.             }
  69.         }

①：此处针对系统版本的区分涉及到资源加载时候的兼容性问题

由于资源做过分区，则在Android L后直接将插件包的apk地址addAssetPath之后就可以，但是在Android L之前，addAssetPath只是把补丁包加入到资源路径列表里，但是资源的解析其实是在很早的时候就已经执行完了，问题出现在这部分代码：

AssetManager.cpp

  1.     const ResTable* AssetManager::getResTable(bool required) const
  2.     {
  3.         ResTable* rt = mResources;
  4.         if (rt) {
  5.             return rt;
  6.         }
  7.         //....
  9.     }

mResources指向的是一个ResTable对象，如果它的值不等于NULL，那么就说明当前应用程序已经解析过它使用的资源包里面的resources.arsc文件，因此，这时候AssetManager类的成员函数getResources就可以直接将该ResTable对象返回给调用者。如果还没有初始化 mResources 则按照一定步骤遍历当前应用所使用的每个资源包进而生成 mResources 。

具体的初始化过程见老罗的博客

由于有系统资源的存在，mResources 的初始化在很早就初始化了，所以我们就算通过addAssetPath方法将 apk 添加到mAssetPaths里，在查找资源的时候也不会找到这部分的资源，因为在旧的 mResources 里没有这部分的 id。

所以在 Android L 之前是需要想办法构造一个新的AssetManager里的 mResources 才行，这里有两种方案，VirtualAPK 用的是类似 InstantRun 的那种方案，构造一个新的 AssetManager，将宿主和加载过的插件的所有 apk 全都添加一遍，然后再调用hookResources方法将新的 Resources 替换回原来的，这样会引起两个问题，一个是每次加载新的插件都会重新构造一个 AssetManger 和 Resources，然后重新添加所有资源，这样涉及到很多机型的兼容(因为部分厂商自己修改了 Resources 的类名)，一个是需要有一个替换原来Resources的过程，这样就需要涉及到很多地方，从hookResources的实现里看，替换了四处地方，在尽量少的 hook 原则下这样的情况还是尽量避免的。

另外一种方案在淘宝发布的《深入探索 Android 热修复技术原理》的文档里有说明，这里引用过来介绍一下。

在 AssetManager 里有一个方法叫做destroy方法

AssetManager.java

  1.     public final class AssetManager {
  2.         //....
  3.         private native final void destroy();
  4.         //....
  5.     }

对应的 native 代码如下

android_util_AssetManager.cpp

  1.     static void android_content_AssetManager_destroy(JNIEnv* env, jobject clazz)
  2.     {
  3.         AssetManager* am = (AssetManager*)
  4.             (env->GetIntField(clazz, gAssetManagerOffsets.mObject));
  5.         ALOGV("Destroying AssetManager %p for Java object %p\n", am, clazz);
  6.         if (am != NULL) {
  7.             delete am;
  8.             env->SetIntField(clazz, gAssetManagerOffsets.mObject, 0);
  9.         }
  10.     }

这里直接 delete am ，会导致调用 AssetManager 的析构函数

AssetManager.cpp

  1.     AssetManager::~AssetManager(void)
  2.     {
  3.         int count = android_atomic_dec(&gCount);
  4.         //ALOGI("Destroying AssetManager in %p #%d\n", this, count);
  5.         delete mConfig;
  6.         delete mResources;
  7.         // don't have a String class yet, so make sure we clean up
  8.         delete[] mLocale;
  9.         delete[] mVendor;
  10.     }

这里delete mResources了

现在我们可以通过调用他的init方法，重新初始化

android_util_AssetManager.cpp

  1.     static void android_content_AssetManager_init(JNIEnv* env, jobject clazz)
  2.     {
  3.         AssetManager* am = new AssetManager();
  4.         if (am == NULL) {
  5.             jniThrowException(env, "java/lang/OutOfMemoryError", "");
  6.             return;
  7.         }
  8.         am->addDefaultAssets();
  9.         ALOGV("Created AssetManager %p for Java object %p\n", am, clazz);
  10.         env->SetIntField(clazz, gAssetManagerOffsets.mObject, (jint)am);
  11.     }

此时在资源查找的时候发现 mResources 没有初始化就将所有的资源 add 一遍。

实现代码如下：

  1.         public static synchronized Resources createResources(Context hostContext, String apk) {
  2.             Resources hostResources = hostContext.getResources();
  3.             try {
  4.                 AssetManager assetManager = hostResources.getAssets();
  6.                 if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
  7.                                     //我们需要将应用原来加载的地址取出来，详情见①
  8.                     List<String> cookieNames = new ArrayList<>();
  9.                     int stringBlockCount =
  10.                         (int) ReflectUtil.invoke(AssetManager.class, assetManager, "getStringBlockCount");
  12.                     Method getCookieNameMethod = AssetManager.class.getDeclaredMethod("getCookieName", Integer.TYPE);
  13.                     getCookieNameMethod.setAccessible(true);
  15.                     for (int i = 0; i < stringBlockCount; i++) {
  16.                         String cookieName =
  17.                             (String) getCookieNameMethod.invoke(assetManager, new Object[] {i + 1});
  18.                         cookieNames.add(cookieName);
  19.                     }
  20.                     ReflectUtil.invoke(AssetManager.class, assetManager, "destroy");
  21.                     ReflectUtil.invoke(AssetManager.class, assetManager, "init");
  22.                     ReflectUtil.setField(AssetManager.class, assetManager, "mStringBlocks", null);//②
  23.                                     //将原来的assets添加进去，有了此步骤就不用刻意添加sourceDir了
  24.                     for (String path : cookieNames) {
  25.                         ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", path);
  26.                     }
  27.                     //插入插件的资源地址
  28.                     ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", apk);
  29.                     List<LoadedPlugin> pluginList = PluginManager.getInstance(hostContext).getAllLoadedPlugins();
  30.                     for (LoadedPlugin plugin : pluginList) {
  31.                         ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", plugin.getLocation());
  32.                     }
  34.                     ReflectUtil.invoke(AssetManager.class, assetManager, "ensureStringBlocks");//③
  35.                     hostResources.updateConfiguration(hostResources.getConfiguration(), hostResources.getDisplayMetrics());//此行代码非常重要④
  36.                 } else {
  37.                     ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", apk);
  38.                     List<LoadedPlugin> pluginList = PluginManager.getInstance(hostContext).getAllLoadedPlugins();
  39.                     for (LoadedPlugin plugin : pluginList) {
  40.                         ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", plugin.getLocation());
  41.                     }
  42.                 }
  44.                             //省去了兼容性的验证
  45.                 //            if (isMiUi(hostResources)) {
  46.                 //                newResources = MiUiResourcesCompat.createResources(hostResources, assetManager);
  47.                 //            } else if (isVivo(hostResources)) {
  48.                 //                newResources = VivoResourcesCompat.createResources(hostContext, hostResources,
  49.                 // assetManager);
  50.                 //            } else if (isNubia(hostResources)) {
  51.                 //                newResources = NubiaResourcesCompat.createResources(hostResources, assetManager);
  52.                 //            } else if (isNotRawResources(hostResources)) {
  53.                 //                newResources = AdaptationResourcesCompat.createResources(hostResources, assetManager);
  54.                 //            } else {
  55.                 // is raw android resources
  56.                 //            newResources =
  57.                 //                new Resources(assetManager, hostResources.getDisplayMetrics(), hostResources
  58.                 // .getConfiguration());
  59.                 //            }
  60.             } catch (Exception e) {
  61.                 e.printStackTrace();
  62.             }
  64.             return hostResources;
  66.         }

注：上面的代码我测试了几款手机,Mi3(4.4.4)、坚果Pro(7.1.1)、Nubia(6.0.0)、Nexus 6P(8.0)，（4.2-5.0）模拟器均表现正常,但待深度实验测试

①：取出原assets地址

由于我们将host的AssetManager已经destroy后，需要还原原来的地址，否则就会发生找不到资源的情况，此时需要提前将host加载的资源路径全部取出来，理论上，这个过程系统是做了一部分的，当我们调用init方法的时候：

android_util_AssetManager.cpp

  1.     static void android_content_AssetManager_init(JNIEnv* env, jobject clazz)
  2.     {
  3.         AssetManager* am = new AssetManager();
  4.         if (am == NULL) {
  5.             jniThrowException(env, "java/lang/OutOfMemoryError", "");
  6.             return;
  7.         }
  8.         am->addDefaultAssets();//注意这行代码
  9.         ALOGV("Created AssetManager %p for Java object %p\n", am, clazz);
  10.         env->SetIntField(clazz, gAssetManagerOffsets.mObject, (jint)am);
  11.     }

AssetManager.cpp

  1.     static const char* kSystemAssets = "framework/framework-res.apk";
  3.     bool AssetManager::addDefaultAssets()
  4.     {
  5.         const char* root = getenv("ANDROID_ROOT");
  6.         LOG_ALWAYS_FATAL_IF(root == NULL, "ANDROID_ROOT not set");
  7.         String8 path(root);
  8.         path.appendPath(kSystemAssets);//framework/framework-res.apk
  9.         return addAssetPath(path, NULL);
  10.     }

但是此处只添加了framework-res.apk，还有宿主的apk需要添加，而且如果之前添加了其他的apk此处如果自己没有记录的话就会漏掉，所以还是从原来的AssetManager里取出来比较稳妥

之前想的方案是通过JNI找到AssetManager对象的实例，从里面取出mAssetPaths传递给Java层使用

  1.     AssetManager* assetManagerForJavaObject(JNIEnv* env, jobject obj)
  2.     {
  3.         AssetManager* am = (AssetManager*)env->GetIntField(obj, gAssetManagerOffsets.mObject);
  4.         if (am != NULL) {
  5.             return am;
  6.         }
  7.         jniThrowException(env, "java/lang/IllegalStateException", "AssetManager has been finalized!");
  8.         return NULL;
  9.     }

但此方法相对比较复杂一些，通过AssetManager的代码我们可以找到一些其他的方法。看下面这个方法，在第一次查找资源的时候

  1.     const ResTable* AssetManager::getResTable(bool required) const
  2.     {
  3.         ResTable* rt = mResources;
  4.         if (rt) {
  5.             return rt;
  6.         }
  7.         // Iterate through all asset packages, collecting resources from each.
  8.         AutoMutex _l(mLock);
  9.         if (mResources != NULL) {
  10.             return mResources;
  11.         }
  12.         if (required) {
  13.             LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
  14.         }
  15.         if (mCacheMode != CACHE_OFF && !mCacheValid)
  16.             const_cast<AssetManager*>(this)->loadFileNameCacheLocked();
  17.         const size_t N = mAssetPaths.size();
  18.         for (size_t i=0; i<N; i++) {
  19.             Asset* ass = NULL;
  20.             ResTable* sharedRes = NULL;
  21.             bool shared = true;
  22.             const asset_path& ap = mAssetPaths.itemAt(i);
  23.             MY_TRACE_BEGIN(ap.path.string());
  24.             Asset* idmap = openIdmapLocked(ap);
  25.             ALOGV("Looking for resource asset in '%s'\n", ap.path.string());
  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.                 //......
  34.             if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) {
  35.                 if (rt == NULL) {
  36.                     mResources = rt = new ResTable();
  37.                     updateResourceParamsLocked();
  38.                 }
  39.                 ALOGV("Installing resource asset %p in to table %p\n", ass, mResources);
  40.                 if (sharedRes != NULL) {
  41.                     ALOGV("Copying existing resources for %s", ap.path.string());
  42.                     rt->add(sharedRes);//注意
  43.                 } else {
  44.                     ALOGV("Parsing resources for %s", ap.path.string());
  45.                     rt->add(ass, (void*)(i+1), !shared, idmap);//注意
  46.                 }
  47.                 if (!shared) {
  48.                     delete ass;
  49.                 }
  50.             }
  51.             if (idmap != NULL) {
  52.                 delete idmap;
  53.             }
  54.             MY_TRACE_END();
  55.         }
  56.         if (required && !rt) ALOGW("Unable to find resources file resources.arsc");
  57.         if (!rt) {
  58.             mResources = rt = new ResTable();
  59.         }
  60.         return rt;
  61.     }

从上面的代码可以看到，在初始化ResTable的时候，遍历了一下mAssetPaths，将每个地址解析后add到ResTable里，看一下这几个add方法

ResourceTypes.cpp

  1.     status_t ResTable::add(const void* data, size_t size, void* cookie, bool copyData,
  2.                            const void* idmap)
  3.     {
  4.         return add(data, size, cookie, NULL, copyData, reinterpret_cast<const Asset*>(idmap));
  5.     }
  6.     status_t ResTable::add(Asset* asset, void* cookie, bool copyData, const void* idmap)
  7.     {
  8.         const void* data = asset->getBuffer(true);
  9.         if (data == NULL) {
  10.             ALOGW("Unable to get buffer of resource asset file");
  11.             return UNKNOWN_ERROR;
  12.         }
  13.         size_t size = (size_t)asset->getLength();
  14.         return add(data, size, cookie, asset, copyData, reinterpret_cast<const Asset*>(idmap));
  15.     }
  16.     status_t ResTable::add(ResTable* src)
  17.     {
  18.         mError = src->mError;
  20.         for (size_t i=0; i<src->mHeaders.size(); i++) {
  21.             mHeaders.add(src->mHeaders[i]);//注意
  22.         }
  24.         for (size_t i=0; i<src->mPackageGroups.size(); i++) {
  25.             PackageGroup* srcPg = src->mPackageGroups[i];
  26.             PackageGroup* pg = new PackageGroup(this, srcPg->name, srcPg->id);
  27.             for (size_t j=0; j<srcPg->packages.size(); j++) {
  28.                 pg->packages.add(srcPg->packages[j]);
  29.             }
  30.             pg->basePackage = srcPg->basePackage;
  31.             pg->typeCount = srcPg->typeCount;
  32.             mPackageGroups.add(pg);
  33.         }
  35.         memcpy(mPackageMap, src->mPackageMap, sizeof(mPackageMap));
  37.         return mError;
  38.     }
  39.     status_t ResTable::add(const void* data, size_t size, void* cookie,//注意此处的cookie值
  40.                            Asset* asset, bool copyData, const Asset* idmap)
  41.     {
  42.         if (!data) return NO_ERROR;
  43.         Header* header = new Header(this);
  44.         header->index = mHeaders.size();
  45.         header->cookie = cookie;
  46.         if (idmap != NULL) {
  47.             const size_t idmap_size = idmap->getLength();
  48.             const void* idmap_data = const_cast<Asset*>(idmap)->getBuffer(true);
  49.             header->resourceIDMap = (uint32_t*)malloc(idmap_size);
  50.             if (header->resourceIDMap == NULL) {
  51.                 delete header;
  52.                 return (mError = NO_MEMORY);
  53.             }
  54.             memcpy((void*)header->resourceIDMap, idmap_data, idmap_size);
  55.             header->resourceIDMapSize = idmap_size;
  56.         }
  57.         mHeaders.add(header);//注意
  58.        //...
  59.     }

每次add 都会添加到mHeaders中，可以认为每个地址对应一个Header,mHeaders的数量就是mAssetPath地址的数量，这样我们就可以得出已经添加了多少个资源进去

  1.     size_t ResTable::getTableCount() const
  2.     {
  3.         return mHeaders.size();
  4.     }

回溯到android_util_AssetManager.cpp代码中可以发现

  1.     static jint android_content_AssetManager_getStringBlockCount(JNIEnv* env, jobject clazz)
  2.     {
  3.         AssetManager* am = assetManagerForJavaObject(env, clazz);
  4.         if (am == NULL) {
  5.             return 0;
  6.         }
  7.         return am->getResources().getTableCount();
  8.     }

很明显我们可以通过java里的AssetManager.getStringBlockCount()获得资源数量

得到数量就需要取出这些地址，从AssetManager.cpp的代码中看它是对外提供了一个获取地址的方法：

  1.     String8 AssetManager::getAssetPath(void* cookie) const
  2.     {
  3.         AutoMutex _l(mLock);
  4.         const size_t which = ((size_t)cookie)-1;
  5.         if (which < mAssetPaths.size()) {
  6.             return mAssetPaths[which].path;
  7.         }
  8.         return String8();
  9.     }

然后通过搜索发现一个可以调用到的地方

  1.     static jstring android_content_AssetManager_getCookieName(JNIEnv* env, jobject clazz,
  2.                                                            jint cookie)
  3.     {
  4.         AssetManager* am = assetManagerForJavaObject(env, clazz);
  5.         if (am == NULL) {
  6.             return NULL;
  7.         }
  8.         String8 name(am->getAssetPath((void*)cookie));
  9.         if (name.length() == 0) {
  10.             jniThrowException(env, "java/lang/IndexOutOfBoundsException", "Empty cookie name");
  11.             return NULL;
  12.         }
  13.         jstring str = env->NewStringUTF(name.string());
  14.         return str;
  15.     }

很明显，我们知道了数量，遍历的时候从 i+1 到 count依次取出就可以。

②③引用：它记录了之前加载过的所有资源包中的String Pool，很多时候访问字符串是从此处来的，如果不重新构造就会导致崩溃。

④：过程中很重要的一步，因为后面在资源查找的时候是需要通过一个ResTable_config来获取当前手机的一些配置从而获取到准确的资源，如果不进行初始化则会出现找不到资源的崩溃

  1.     public class Resources {  
  3.         private final Configuration mConfiguration = new Configuration();  
  5.         public void updateConfiguration(Configuration config,  
  6.                 DisplayMetrics metrics) {  
  7.             synchronized (mTmpValue) {  
  8.               //....
  9.                 mAssets.setConfiguration(mConfiguration.mcc, mConfiguration.mnc,  
  10.                         locale, mConfiguration.orientation,  
  11.                         mConfiguration.touchscreen,  
  12.                         (int)(mMetrics.density*160), mConfiguration.keyboard,  
  13.                         keyboardHidden, mConfiguration.navigation, width, height,  
  14.                         mConfiguration.screenLayout, mConfiguration.uiMode, sSdkVersion);  
  15.       //...
  16.             }  
  18.         }  
  20.     }

最终调用到

  1.     static void android_content_AssetManager_setConfiguration(JNIEnv* env, jobject clazz,   jint mcc, jint mnc,  jstring locale, jint orientation, jint touchscreen, jint density,   jint keyboard, jint keyboardHidden, jint navigation, jint screenWidth, jint screenHeight, jint screenLayout, jint uiMode, jint sdkVersion)  
  2.     {  
  3.         AssetManager* am = assetManagerForJavaObject(env, clazz);  
  4.         if (am == NULL) {  
  5.             return;  
  6.         }  
  8.         ResTable_config config;  
  9.         memset(&config, 0, sizeof(config));  
  11.         const char* locale8 = locale != NULL ? env->GetStringUTFChars(locale, NULL) : NULL;  
  13.         config.mcc = (uint16_t)mcc;  
  14.         config.mnc = (uint16_t)mnc;  
  15.         config.orientation = (uint8_t)orientation;  
  16.         config.touchscreen = (uint8_t)touchscreen;  
  17.         config.density = (uint16_t)density;  
  18.         config.keyboard = (uint8_t)keyboard;  
  19.         config.inputFlags = (uint8_t)keyboardHidden;  
  20.         config.navigation = (uint8_t)navigation;  
  21.         config.screenWidth = (uint16_t)screenWidth;  
  22.         config.screenHeight = (uint16_t)screenHeight;  
  23.         config.screenLayout = (uint8_t)screenLayout;  
  24.         config.uiMode = (uint8_t)uiMode;  
  25.         config.sdkVersion = (uint16_t)sdkVersion;  
  26.         config.minorVersion = 0;  
  27.         am->setConfiguration(config, locale8);  
  29.         if (locale != NULL) env->ReleaseStringUTFChars(locale, locale8);  
  30.     }

具体查找资源时候是如何使用这个config的请看老罗的博客

Activity 启动过程中对资源的处理

上面介绍了插件资源创建的过程，下面看一些在启动过程中需要对资源这部分做的特殊处理

  1.     @Override
  2.         public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
  3.             try {
  4.                 cl.loadClass(className);
  5.             } catch (ClassNotFoundException e) {
  6.                 LoadedPlugin plugin = this.mPluginManager.getLoadedPlugin(intent);
  7.                 String targetClassName = PluginUtil.getTargetActivity(intent);
  9.                 Log.i(TAG, String.format("newActivity[%s : %s]", className, targetClassName));
  11.                 if (targetClassName != null) {
  12.                     Activity activity = mBase.newActivity(plugin.getClassLoader(), targetClassName, intent);
  13.                     activity.setIntent(intent);
  15.                     try {
  16.                         // for 4.1+
  17.                         ReflectUtil.setField(ContextThemeWrapper.class, activity, "mResources", plugin.getResources());//注意此处的代码
  18.                     } catch (Exception ignored) {
  19.                         // ignored.
  20.                     }
  22.                     return activity;
  23.                 }
  24.             }
  26.             return mBase.newActivity(cl, className, intent);
  27.         }
  29. 这部分的处理在很多插件框架中都有存在，原来系统的代码只是做了这个操作`cl.loadClass(className);` 并没有做针对资源的处理，这里对资源做了一次赋值的缘由需要探讨一下。
  31. 跟踪到新建Activity对象的地方，也就是出现问题的地方,这里通过4.4的代码解释一下，后面版本的代码虽然变化大但也会出现问题，追溯到底的原因是一样的。
  33.      private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  34.     //.....
  35.             Activity activity = null;
  36.             try {
  37.                 java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
  38.                 activity = mInstrumentation.newActivity(
  39.                         cl, component.getClassName(), r.intent);
  40.                 StrictMode.incrementExpectedActivityCount(activity.getClass());
  41.                 r.intent.setExtrasClassLoader(cl);
  42.                 if (r.state != null) {
  43.                     r.state.setClassLoader(cl);
  44.                 }
  45.             } catch (Exception e) {
  46.                 if (!mInstrumentation.onException(activity, e)) {
  47.                     throw new RuntimeException(
  48.                         "Unable to instantiate activity " + component
  49.                         + ": " + e.toString(), e);
  50.                 }
  51.             }
  53.             try {
  54.                 Application app = r.packageInfo.makeApplication(false, mInstrumentation);
  56.                 if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
  57.                 if (localLOGV) Slog.v(
  58.                         TAG, r + ": app=" + app
  59.                         + ", appName=" + app.getPackageName()
  60.                         + ", pkg=" + r.packageInfo.getPackageName()
  61.                         + ", comp=" + r.intent.getComponent().toShortString()
  62.                         + ", dir=" + r.packageInfo.getAppDir());
  64.                 if (activity != null) {
  65.                     Context appContext = createBaseContextForActivity(r, activity);//出现问题的地点
  66.                     CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
  67.                     Configuration config = new Configuration(mCompatConfiguration);
  68.                     if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
  69.                             + r.activityInfo.name + " with config " + config);
  70.                     activity.attach(appContext, this, getInstrumentation(), r.token,
  71.                             r.ident, app, r.intent, r.activityInfo, title, r.parent,
  72.                             r.embeddedID, r.lastNonConfigurationInstances, config);
  74.                     if (customIntent != null) {
  75.                         activity.mIntent = customIntent;
  76.                     }
  77.                     r.lastNonConfigurationInstances = null;
  78.                     activity.mStartedActivity = false;
  79.                     int theme = r.activityInfo.getThemeResource();
  80.                     if (theme != 0) {
  81.                         activity.setTheme(theme);
  82.                     }
  84.                     activity.mCalled = false;
  85.                     mInstrumentation.callActivityOnCreate(activity, r.state);//此处调用了onCreate方法，如果不进行资源处理则在此出现找不到资源的crash
  86.                     if (!activity.mCalled) {
  87.                         throw new SuperNotCalledException(
  88.                             "Activity " + r.intent.getComponent().toShortString() +
  89.                             " did not call through to super.onCreate()");
  90.                     }
  91.                     ......
  93.             return activity;
  94.         }
  97.         private Context createBaseContextForActivity(ActivityClientRecord r,
  98.                 final Activity activity) {
  99.             ContextImpl appContext = new ContextImpl();
  100.             appContext.init(r.packageInfo, r.token, this);
  101.             appContext.setOuterContext(activity);
  103.             Context baseContext = appContext;
  105.             return baseContext;
  106.         }

系统在创建完Activity对象后，紧接着创建Activity所附着的Context，从最上面的创建Resources 一部分内容可知，在createBaseContextForActivity 方法中创建出来的ContextImpl appContext 使用的是宿主的Resources，如果不进行处理紧接着Activity会走入onCreate的生命周期中，此时插件加载资源的时候还是使用的宿主的资源，而不是我们特意为插件所创建出来的Resources对象，则会发生找不到资源的问题，这里用了一个很机智的方式解决这个问题。

ContextThemeWrapper.java

  1.         @Override
  2.         public Resources getResources() {
  3.             if (mResources != null) {//我们提前设置了mResources 所以不会走到下面去
  4.                 return mResources;
  5.             }
  6.             if (mOverrideConfiguration == null) {
  7.                 mResources = super.getResources();
  8.                 return mResources;
  9.             } else {
  10.                 Context resc = createConfigurationContext(mOverrideConfiguration);
  11.                 mResources = resc.getResources();
  12.                 return mResources;
  13.             }
  14.         }

我们调用getResources方法的时候会走进这里，由于我们提前设置了mResources对象，所以系统所创建的Resources对象其实是用不到的。

另：如果采用上述所说的AssetManager销毁的方法，则无需在创建Activity后设置Resources对象，因为此处全局都是宿主+插件的资源。

插件调用宿主的资源

在宿主开启了COMBINE_RESOURCES模式下，插件是可以调用宿主的资源的，理论上也是可以调用其他插件资源的(需要修改打包)，但是不推荐这么做。这个问题可以看一下Replugin踩过的坑。

此处需要注意两个问题，如果宿主升级那么需要保证原来插件调用的资源id不能改变，否则宿主升级后，加载的插件还是拿取的旧版本资源id，可能会导致资源找不到和错乱情况，所以宿主要从使用插件起保证每个版本被插件所使用的资源不能变化id。

这里用官方例子做一个简单的例子说明一下如何调用宿主资源。

  1. 首先我们需要将能被插件访问到的资源提取到一个公共模块中去

    然后修改配置，将comm_res这个模块引用到宿主模块中

  2. 切回我们的插件模块，将common_res也引用到插件模块中

  3. 这样就可以在插件直接引用这个资源了，我直接在一个Activity中引用了这个资源

       <ImageView android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:src="@drawable/newsplash"
      />

  4. 打包验证,调用插件可以看到这个图片是被引用到了

  5. 验证资源是否来自宿主中，首先先看一下插件里是否存在这个图片的资源

    可以看到，插件里并没有打包到插件里，下一步看一下此资源的id是否和宿主中的资源id一致

    插件里的id

    宿主里的id

    验证通过

  6. 此处验证一下公共资源的增加和变动是否会引起旧版本的插件调用资源错误

    验证方式比较简单，增加几张图片

    然后重新打包宿主，运行，发现此时运行旧的插件，已经发生错误了

    查一下宿主的资源id，发现此时已经发生资源变更

  7. 要解决这个问题，需要注意两个地方，1，旧的资源不能删除，2，需要保持旧版本资源的id不变，具体见Tinker的实现

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注