Android插件化学习之路（五）之代理Activity

最新推荐文章于 2024-03-08 16:20:53 发布

火山石

最新推荐文章于 2024-03-08 16:20:53 发布

阅读量700

点赞数

分类专栏： Android

Android 专栏收录该内容

225 篇文章

订阅专栏

最近在项目中做插件化，在研究插件化开源框架和代码。转一篇别人的先积累下。

简单模式中，使用ClassLoader加载外部的Dex或Apk文件，可以加载一些本地APP不存在的类，从而执行一些新的代码逻辑。但是使用这种方法却不能直接启动插件里的Activity。

启动插件中Activity的两个主要问题

Activity等组件是需要在Manifest中注册后才能以标准Intent的方式启动的，通过ClassLoader加载并实例化的Activity实例只是一个普通的Java对象，能调用对象的方法，但是它没有生命周期，而且Activity等系统组件是需要Android的上下文环境的（Context等资源），没有这些东西Activity根本无法工作。

使用插件APK里的Activity需要解决两个问题：
1. 如何使插件APK里的Activity具有生命周期；
2. 如何使插件APK里的Activity具有上下文环境（使用R资源）；
代理Activity模式为解决这两个问题提供了一种思路。

代理Activity模式

这种模式的特点是：主项目APK注册一个代理Activity（命名为ProxyActivity），ProxyActivity是一个普通的Activity，但只是一个空壳，自身并没有什么业务逻辑。每次打开插件APK里的某一个Activity的时候，都是在主项目里使用标准的方式启动ProxyActivity，再在ProxyActivity的生命周期里同步调用插件中的Activity实例的生命周期方法，从而执行插件APK的业务逻辑。

ProxyActivity + 没注册的Activity = 标准的Activity

第二个问题，我们在上一篇博客中已经解决了，下面我们来分析使插件APK里的Activity具有生命周期的问题

处理插件Activity的生命周期

目前还真的没什么办法能够处理这个问题，一个Activity的启动，如果不采用标准的Intent方式，没有经历过Android系统Framework层级的一系列初始化和注册过程，它的生命周期方法是不会被系统调用的（除非你能够修改Android系统的一些代码，而这已经是另一个领域的话题了，这里不展开）。

那我们可以在主项目里创建一个ProxyActivity，再由它去代理调用插件Activity的生命周期方法（这也是代理模式叫法的由来）。用ProxyActivity（一个标准的Activity实例）的生命周期同步控制插件Activity（普通类的实例）的生命周期，同步的方式可以有下面两种：

• 在ProxyActivity生命周期里用反射调用插件Activity相应生命周期的方法，简单粗暴。
• 把插件Activity的生命周期抽象成接口，在ProxyActivity的生命周期里调用。另外，多了这一层接口，也方便主项目控制插件Activity。

用反射调用插件Activity相应生命周期

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

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.     for (String methodName : methodNames) {  
11.         Method method = null;  
12.         try {  
13.             method = localClass.getDeclaredMethod(methodName, new Class[] { });  
14.             method.setAccessible(true);  
15.         } catch (NoSuchMethodException e) {  
16.             e.printStackTrace();  
17.         }  
18.         mActivityLifecircleMethods.put(methodName, method);  
19.     }  
20.   
21.     Method onCreate = null;  
22.     try {  
23.         onCreate = localClass.getDeclaredMethod("onCreate", new Class[] { Bundle.class });  
24.         onCreate.setAccessible(true);  
25.     } catch (NoSuchMethodException e) {  
26.         e.printStackTrace();  
27.     }  
28.     mActivityLifecircleMethods.put("onCreate", onCreate);  
29.   
30.     Method onActivityResult = null;  
31.     try {  
32.         onActivityResult = localClass.getDeclaredMethod("onActivityResult",  
33.                 new Class[] { int.class, int.class, Intent.class });  
34.         onActivityResult.setAccessible(true);  
35.     } catch (NoSuchMethodException e) {  
36.         e.printStackTrace();  
37.     }  
38.     mActivityLifecircleMethods.put("onActivityResult", onActivityResult);  
39. }  

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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

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

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

把插件Activity的生命周期抽象成接口，在ProxyActivity的生命周期里调用

采用反射去管理activity的生命周期，这样存在一些不便，比如反射代码写起来复杂，并且过多使用反射有一定的性能开销。针对这个问题，可以采用接口机制，将activity的大部分生命周期方法提取出来作为一个接口（DLPlugin），然后通过代理activity（DLProxyActivity）去调用插件activity实现的生命周期方法，这样就完成了插件activity的生命周期管理，并且没有采用反射，当我们想增加一个新的生命周期方法的时候，只需要在接口中声明一下同时在代理activity中实现一下即可.

public interface DLPlugin {

    public void onStart();
    public void onRestart();
    public void onActivityResult(int requestCode, int resultCode, Intent data);
    public void onResume();
    public void onPause();
    public void onStop();
    public void onDestroy();
    public void onCreate(Bundle savedInstanceState);
    public void setProxy(Activity proxyActivity, String dexPath);
    public void onSaveInstanceState(Bundle outState);
    public void onNewIntent(Intent intent);
    public void onRestoreInstanceState(Bundle savedInstanceState);
    public boolean onTouchEvent(MotionEvent event);
    public boolean onKeyUp(int keyCode, KeyEvent event);
    public void onWindowAttributesChanged(LayoutParams params);
    public void onWindowFocusChanged(boolean hasFocus);

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在代理类DLProxyActivity中的实现

...
    @Override
    protected void onStart() {
        mRemoteActivity.onStart();
        super.onStart();
    }

    @Override
    protected void onRestart() {
        mRemoteActivity.onRestart();
        super.onRestart();
    }

    @Override
    protected void onResume() {
        mRemoteActivity.onResume();
        super.onResume();
    }

    @Override
    protected void onPause() {
        mRemoteActivity.onPause();
        super.onPause();
    }

    @Override
    protected void onStop() {
        mRemoteActivity.onStop();
        super.onStop();
    }
...

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32