apk动态加载机制(二) : 资源加载和activity生命周期管理

转载请注明出处：http://blog.csdn.net/singwhatiwanna/article/details/21829971 (来自singwhatiwanna的博客)

基本原理参考了上面的博客，实践过程中做了些改动

资源管理

       宿主程序调起未安装的apk，一个很大的问题就是资源如何访问，具体来说就是，凡是以R开头的资源都不能访问了，因为宿主程序中并没有插件apk中的资源，所以通过宿主的context来加载资源是行不通的，程序会报错：无法找到某某id所对应的资源。

       针对这个问题，有人提出了2种解决方案：

       1.  将apk中的资源在宿主程序中也copy一份

       这虽然能解决问题，可以一听起来就很奇怪，首先这样会持有两份资源，会增加宿主程序包的大小，其次,每发布一个插件都需要将资源copy到宿主程序中，这样就意味着每发布一个插件都要更新一下宿主程序，这和插件化的思想是相悖的，插件化的目的就是要减小宿主程序apk包的大小同时降低宿主程序的更新频率并做到自由装载模块。所以这种方法并不可行

       2.  将apk中的资源解压出来，然后通过文件流去读取资源

       这样做理论上是可行的，但是实际操作起来还是有很大难度的，首先不同资源有不同的文件流格式，比如图片、xml等，还有就是针对不同设备加载的资源可能是不一样的，如何选择合适的资源也是一个需要解决的问题，基于这两点，这种方法不建议使用，因为它实现起来有难度。

        在activity中有个叫mBase的成员变量.(实际上是父类ContextWrapper这个类中的Context mBase变量，这个变量指向一个ContextImpl实例)。

        继承关系图如下：

       

       Context中有如下两个抽象方法，实际上context就是通过它们来获取资源的，这两个抽象方法的真正实现在ContextImpl中。也即是说，只要我们自己实现这两个方法，就可以解决资源问题了。

        public abstract AssetManager getAssets();

        public abstract Resources getResources();

       平时在activity中获取资源时就是调用this.getResources()方法获取Resources对象，然后通过调用这个对象的不同的方法获取不同的资源的，比如getString。这个方法实际上调用的就是context中的ContextImpl中实现的getResources方法。但是如果是动态加载的话，this指针指向的是当前插件activity的对象，this指针本身不为空。但是mBase成员为空，也就是ContextImpl这个实例是空的。

  @Override
    public Resources getResources()
    {      

               // 在插件apk中直接调用this.getResources的时候mBase为null指针，从而获取不到插件的资源。
               return mBase.getResources();
    }

       

         最重要的就是把要加载的apk的资源生成对应的Resources对象，就可以通过Respurces对象访问对应的资源了。

          加载apk资源的代码如下：(此代码写在代理activity中)

1. protected void loadResources() {  
2.     try { 
   
3.         AssetManager assetManager = AssetManager.class.newInstance();  
4.         Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);  
5.         addAssetPath.invoke(assetManager, mDexPath);  
6.         mAssetManager = assetManager;  
7.     } catch (Exception e) {  
8.         e.printStackTrace();  
9.     } 
   
10.  
    
11.     Resources superRes = super.getResources(); 
    
12.     // 通过AssetManager对象生成插件APK对应的Resources对象
    
13.     mResources = new Resources(mAssetManager, superRes.getDisplayMetrics(),  
14.             superRes.getConfiguration());  
15.     mTheme = mResources.newTheme();  
16.     mTheme.setTo(super.getTheme());  
17. }  

说明：加载的方法是通过反射，通过调用AssetManager中的addAssetPath方法，我们可以将一个apk中的资源加载到Resources中，由于addAssetPath是隐藏api我们无法直接调用，所以只能通过反射，传递的路径可以是zip文件也可以是一个资源目录，而apk就是一个zip，所以直接将apk的路径传给它，资源就加载到AssetManager中了，然后再通过AssetManager来创建一个新的Resources对象，这个对象就是我们可以使用的apk中的资源了，这样我们的问题就解决了。

        根据资源类型调用Resources的不同的方法，参数都是要加载的资源的ID

1.  获得字符串资源

       String str = mResources.getString(mResources.getIdentifier("test_str","string", "com.example.dynamicloadclient"));

       如果使用getIdentifier方法，第一个参数是资源名称，第二个参数是资源类型，第三个参数是离线apk的包名，切记第三个参数。

       或者是

       String strById = mResources.getString(0x7f050001);       //注意，id参照Bundle apk中的R文件

1. 获得Drawable资源

       Drawable drawable = mResources.getDrawable(0x7f020000);     //注意，id参照Bundle apk中的R文件

       imageView.setImageDrawable(drawable);

1.   获取layout布局资源

       View view =LayoutInflater.from(context).inflate(R.layout.main_fragment, null);

       这里重点是如何生成插件apk的Context?

       直接传当前的 context是不行的，当前的context是宿主APK的环境，所以资源指向的是宿主的资源文件，肯定找不到要获取的插件中的这个资源，需要让context指向插件APK的资源文件。

       方法：通过反射，直接替换当前context的mResources私有成员变量

      // 通过反射获取Context类中的成员变量mResources

      Field field = Context.class.getDeclaredField("mResources");

      field.setAccessible(true);

      // 替换变量的内容

      field.set(context, mResources);  // 这样context指向的就是加载的插件apk的资源环境。可以通过R来获取资源

     setContentView(view)

     问题： 替换以后如果宿主其他的地方需要使用本身context 的资源呢？

     答： 不影响。这个方法是在插件activity中使用的，用来动态创建view. 替换的只是当前activity对象中的资源对象。

    

其次是要实现那两个抽象方法

这2个方法也是写在代理activity中的。 用来提供接口供插件APK获取自己的资源使用

[java] view plain copy

1. @Override  
2. public AssetManager getAssets() {  
3.         return mAssetManager == null ? super.getAssets() : mAssetManager;  
4. }  
5.   
6. @Override  
7. public Resources getResources() {  
8.         return mResources == null ? super.getResources() : mResources;  
9. } 
   

因为获取插件资源的代码是写在代理activity中的，如果在代理activity中要使用插件apk中的资源，可以直接使用mResurces.

如果在插件APK中要显示自己的资源，则就通过上面重写的方法获取自己的资源：

Resources res = mProxyActivity.getResources(); （mProxyActivity是BaseActivity存放的代理activity的实例，通过代理activity中重写的getResources方法返回插件apk的资源mResources）

// 获取布局文件的id。显示插件apk的布局。

setContentView(res.getIdentifier("activity","layout", "com.example.dynamicloadclient"));  （res就是插件apk的资源，在这个资源里通过getIdentifier获取资源的id.而不能直接通过R.layout.activity来获取。这种方法和上面讲的获取layout布局资源，动态生成view效果是一样的。）

activity生命周期的管理

apk被宿主程序调起以后，apk中的activity其实就是一个普通的对象，不具有activity的性质，因为系统启动activity是要做很多初始化工作的，而我们在应用层通过反射去启动activity是很难完成系统所做的初始化工作的，所以activity的大部分特性都无法使用包括activity的生命周期管理，这就需要我们自己去管理。谈到activity生命周期，其实就是那几个常见的方法：onCreate、onStart、onResume、onPause等，由于apk中的activity不是真正意义上的activity（没有在宿主程序中注册且没有完全初始化），所以这几个生命周期的方法系统就不会去自动调用了。针对此类问题，采用Fragment是一个不错的方法，Fragment从3.0引入，通过support-v4包，可以兼容3.0以下的android版本。Fragment既有类似于Activity的生命周期，又有类似于View的界面，将Fragment加入到Activity中，activity会自动管理Fragment的生命周期，通过第一篇文章我们知道，apk中的activity是通过宿主程序中的代理activity启动的，将Fragment加入到代理activity内部，其生命周期将完全由代理activity来管理，但是采用这种方法，就要求apk尽量采用Fragment来实现，还有就是在做页面跳转的时候有点麻烦，本文不采用Fragment而是通过反射去手动管理activity的生命周期。

我们要在代理activity（注册在宿主里，由系统管理声明周期）中去反射apk中activity所有生命周期的方法，然后将activity的生命周期和代理activity的生命周期进行同步。首先，反射activity生命周期的所有方法，还反射了onActivityResult这个方法，尽管它不是典型的生命周期方法，但是它很有用。

重点：  在系统调用代理activity的生命周期时同步调用到插件activity中的生命周期即可。

[java] view plain copy
         //  通过反射建立所有生命周期函数的映射关系，存在mActivityLifecircleMethods中

1. protected void instantiateLifecircleMethods(Class<?> localClass) {  
2.     String[] methodNames = new String[] {  
3.             "onRestart",  
4.             "onStart",  
5.             "onResume",  
6.             "onPause",  
7.             "onStop",  
8.             "onDestory"  
9.     }; 
   
10.     
    
11.     //  这些方法都不需要参数放一起
    
12.     for (String methodName : methodNames) {  
13.         Method method = null;  
14.         try {  
15.             method = localClass.getDeclaredMethod(methodName, new Class[] { });  
16.             method.setAccessible(true);  
17.         } catch (NoSuchMethodException e) {  
18.             e.printStackTrace();  
19.         }  
20.         mActivityLifecircleMethods.put(methodName, method);  
21.     } 
    
22. 
    
23.     //  这2个方法单独拿出来反射不放在for循环中因为需要参数
    
24.     Method onCreate = null;  
25.     try {  
26.         onCreate = localClass.getDeclaredMethod("onCreate", new Class[] { Bundle.class });  
27.         onCreate.setAccessible(true);  
28.     } catch (NoSuchMethodException e) {  
29.         e.printStackTrace();  
30.     }  
31.     mActivityLifecircleMethods.put("onCreate", onCreate);  
32.   
33.     Method onActivityResult = null;  
34.     try {  
35.         onActivityResult = localClass.getDeclaredMethod("onActivityResult",  
36.                 new Class[] { int.class, int.class, Intent.class });  
37.         onActivityResult.setAccessible(true);  
38.     } catch (NoSuchMethodException e) {  
39.         e.printStackTrace();  
40.     }  
41.     mActivityLifecircleMethods.put("onActivityResult", onActivityResult);  
42. }  

其次，同步生命周期，主要看一下onResume和onPause，其他方法是类似的。看如下代码，很好理解，就是当系统调用代理activity生命周期方法的时候，就通过反射去显式调用插件apk中activity的对应的生命周期方法。

[java] view plain copy

1. @Override  
2. protected void onResume() {  
3.     super.onResume();  
4.     Method onResume = mActivityLifecircleMethods.get("onResume");  
5.     if (onResume != null) {  
6.         try {  
7.             onResume.invoke(mRemoteActivity, new Object[] { });  
8.         } catch (Exception e) {  
9.             e.printStackTrace();  
10.         }  
11.     }  
12. }  
13.   
14. @Override  
15. protected void onPause() {  
16.     Method onPause = mActivityLifecircleMethods.get("onPause");  
17.     if (onPause != null) {  
18.         try {  
19.             onPause.invoke(mRemoteActivity, new Object[] { });  
20.         } catch (Exception e) {  
21.             e.printStackTrace();  
22.         }  
23.     }  
24.     super.onPause();  
25. } 
    

插件apk的开发规范

文章开头提到，要想成为一个插件apk，是要满足一定条件的，如下是采用本文机制开发插件apk所需要遵循的规范：

1. 不能用this：因为this指向的是当前对象，即apk中的activity，但是由于activity已经不是常规意义上的activity，所以this是没有意义的。（正常启动的actitivy会初始化mBase这个成员变量，什么时候初始化的要看源码，而反射调用的话这个变量为null,就无法用来获取资源等）

2. 使用that：既然this不能用，那就用that，that是apk中activity的基类BaseActivity中的一个成员，它在apk安装运行的时候指向this，而在未安装的时候指向宿主程序中的代理activity，anyway，that is better than this。

3. 不能直接调用activity的成员方法：而必须通过that去调用，由于that的动态分配特性，通过that去调用activity的成员方法，在apk安装以后仍然可以正常运行。

4. 启动新activity的约束：启动外部activity不受限制，启动apk内部的activity有限制，首先由于apk中的activity没注册，所以不支持隐式调用，其次必须通过BaseActivity中定义的新方法startActivityByProxy和startActivityForResultByProxy，还有就是不支持LaunchMode。

5. 目前暂不支持Service、BroadcastReceiver等需要注册才能使用的组件。

后续工作

1. DLIntent的定义，通过自定义的intent，来完成activity的无约束调起

2. 采用Fragment的生命周期管理

3. Service、BroadcastReceiver等组件的调起

4. 性能优化

效果

首先宿主程序运行后，会把位于/mnt/sdcard/DynamicLoadHost目录下的所有apk都加载进来，然后点击列表就可以调起对应的apk，本文中的demo和第一篇文章中的demo看起来差不多，实际是有区别的，区别有两点：activity具有生命周期、加载资源可以用R，具体的代码实现请大家参见源码。

源码下载：https://github.com/singwhatiwanna/dynamic-load-apk