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

简单模式中，使用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. }

其次，同步生命周期，主要看一下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. }

把插件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);

在代理类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();
}
...

通过以上两种方式，就可以解决插件Activity的生命周期的问题，现在一般推荐第二种方式。

参考文章：http://blog.csdn.net/singwhatiwanna/article/details/23387079