android 通过代理activity的方式实现插件化

前言：

一直以来就对插件化这技术推崇已久，在去年也写过两篇关于插件化基础的文章：
Java中的ClassLoader 动态加载机制
Android中的动态加载
都是关于classLoader如何加载外部apk中的代码，在"android中的动态加载"这篇博客末尾，提了下如何打开插件的activity，所以这篇文章就是谈如何通过代理Activity实现打开插件中的activity的。由于插件化的技术现在相对而言已经很成熟了，很多公司都已经运用在项目中，网上也有许多关于插件化的介绍，只是看到网上很多资料都写的不是很完整(可能我技术层面还没到达)，只说了一些片面的代码或者是一些基础原理，并没有真正意义上的demo实现。原理是这么回事，但是真正到自己实现起来就发现知道原理并不能立马做好项目。网上也有许多demo是错误的，对初学者学习插件化造成了很大的困扰，在参考了许多资料之后，才决定写一篇关于如何实现插件化的文章。(这里对于宿主如何访问插件的资源、dexclassloader等就不再叙述了，这些基础知识网上有很多资料都有介绍)

参考资料：https://github.com/singwhatiwanna/dynamic-load-apk

实现代理activity的两种方式：(如何管理插件activity的生命周期)

1.通过反射方式实现代理activity。

2.通过接口方式实现代理activity

接下来就会分别使用以上两种方式实现插件化，先来看下运行结果。



了解过apk的安装都知道或者说了解PackageManagerService的都应该清楚，(如果不知道的可以看下我这篇博客：android apk安装过程源码解析)在安装过程中apk会被解析，然后apk中的信息比如四大组件都会被封装到一个package对象中，这样我们启动一个activity就只要从这个package对象中获取这个activity的信息就可以启动了。但是要启动一个插件中的activity(这个apk在外部，并没有被注册到我们的package中)，这样的方式就行不通了。所以就需要在宿主activity中创建一个代理activity来管理插件activity的生命周期，而我们插件中的activity就相当于一个普通的类了。

先看下插件项目的目录结构：



可以看到我们的插件项目仅仅2个Activity以及一个接口，(这个接口是用来)其实从运行结果也能看到，插件就一个需要显示的activity，并且内容也仅仅是一个textview。接下来就来看下我们插件中的3个类的内容。

PluginInterface:
声明activity的生命周期方法，通过接口的方式来管理activity的生命周期，避免反射减少性能消耗。

package com.example.lujianxin.proxy;

import android.app.Activity;
import android.os.Bundle;

/**
* Created by lujianxin on 2017/7/14.
*/

public interface PluginInterface {
public void onStart();
public void onResume();
public void onPause();
public void onStop();
public void onDestroy();
public void onCreate(Bundle savedInstanceState);
public void setProxy(Activity proxyActivity);

}

这里仅仅只为demo服务，所以没有写另外的方法了，如果有需要可以根据自己的项目来添加.

BaseActivity:

package com.example.lujianxin.proxy;

import android.app.Activity;
import android.os.Bundle;
import android.support.annotation.LayoutRes;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

/**
* Created by lujianxin on 2017/7/13.
*/

public class BaseActivity extends Activity implements PluginInterface {
public Activity mProxyActivity;

@Override
public void onCreate(Bundle savedInstanceState) {
}

@Override
public void setContentView(@LayoutRes int layoutResID) {
if(mProxyActivity != null && mProxyActivity instanceof Activity){
mProxyActivity.setContentView(layoutResID);
TextView tv = (TextView) mProxyActivity.findViewById(R.id.proxy_tv);
tv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(mProxyActivity, "this is proxy activity!", Toast.LENGTH_LONG).show();
}
});
}
}

@Override
public void onStart() {
}

@Override
public void onResume() {
}

@Override
public void onPause() {
}

@Override
public void onStop() {
}

@Override
public void onDestroy() {
}

@Override
public void setProxy(Activity proxyActivity) {
mProxyActivity = proxyActivity;
}

}

这个类也简单，接受一个activity代理对象，通过这个代理对象来管理插件中的activity生命周期。然后重写setcontentview()方法，让这个代理对象来执行这个setcontentview()方法。并且实现接口为"接口方式管理activity生命周期"提供服务的。

MainActivity:

package com.example.lujianxin.proxy;

import android.os.Bundle;
import android.util.Log;

public class MainActivity extends BaseActivity implements PluginInterface {

private static final String TAG = "MainActivity";

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

@Override
public void onStart() {
Log.d(TAG, "plugin-onStart");
}

@Override
public void onResume() {
Log.d(TAG, "plugin-onResume");
}

@Override
public void onPause() {
Log.d(TAG, "plugin-onPause");
}

@Override
public void onStop() {
Log.d(TAG, "plugin-onStop");
}

@Override
public void onDestroy() {
Log.d(TAG, "plugin-onDestroy");
}

}

MainActivity仅仅只是在调用oncreate的时候执行父类的setcontentview()方法。本来在这之前我是没准备写BaseActivity的，所以这里MainActivity也实现了接口，这里可以去掉。

可以看到，插件还是很简单的，只是我们在应用的时候，应该把插件中的activity看成是一个类，而不是android中的activity。

宿主目录结构：



从上面可以看到，宿主有4个类加一个接口：
1.MainActivity就是我们结果展示的两个button页面
2.BaseActivity中处理插件资源的访问
3.PlugProxyActivity中通过接口的方式管理插件activity的生命周期。
4.ProxyActivity中通过反射的方式管理插件activity的生命周期。
5.PluginInterface和我们插件的一样，这样包名也需要一样。

在具体分析宿主之前，要说下的是我这里没有把插件放到服务器上，直接通过复制到/data/data/宿主包名/cache下。



可以通过以上命令来把我们的apk放入到该目录下，这里测试的话用模拟器就行了，如果是真机的话，就需要root了。

先来看下BaseActivity：

package com.example.lujianxin.myapplication;

import android.app.Activity;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;

import java.lang.reflect.Method;

/**
* Created by lujianxin on 2017/7/13.
*/

public class BaseActivity extends Activity {

protected AssetManager mAssetManager;
protected Resources mResources;
protected Resources.Theme mTheme;
private ActivityInfo mActivityInfo;
private PackageInfo packageInfo;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
//访问插件中的资源
protected void loadResources(String dexPath, Activity mProxyActivity) {
initializeActivityInfo(dexPath);
try {
AssetManager assetManager = AssetManager.class.newInstance();
Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
addAssetPath.invoke(assetManager, dexPath);
mAssetManager = assetManager;
} catch (Exception e) {
Log.i("inject", "loadResource error:"+Log.getStackTraceString(e));
e.printStackTrace();
}
Resources superRes = super.getResources();
superRes.getDisplayMetrics();
superRes.getConfiguration();

if (mActivityInfo.theme > 0) {
mProxyActivity.setTheme(mActivityInfo.theme);
}
Resources.Theme superTheme = mProxyActivity.getTheme();
mResources = new Resources(mAssetManager, superRes.getDisplayMetrics(),superRes.getConfiguration());
mTheme = mResources.newTheme();
mTheme.setTo(superTheme);
try {
mTheme.applyStyle(mActivityInfo.theme, true);
} catch (Exception e) {
e.printStackTrace();
}
}

@Override
public AssetManager getAssets() {
return mAssetManager == null ? super.getAssets() : mAssetManager;
}

@Override
public Resources getResources() {
return mResources == null ? super.getResources() : mResources;
}

private void initializeActivityInfo(String dexPath) {
packageInfo = getApplicationContext().getPackageManager().getPackageArchiveInfo(dexPath,
PackageManager.GET_ACTIVITIES | PackageManager.GET_SERVICES);
if ((packageInfo.activities != null) && (packageInfo.activities.length > 0)) {
//            if (mClass == null) {
//                mClass = packageInfo.activities[0].name;
//            }

//Finals 修复主题BUG
int defaultTheme = packageInfo.applicationInfo.theme;
for (ActivityInfo a : packageInfo.activities) {
//                if (a.name.equals(mClass)) {
mActivityInfo = a;
// Finals ADD 修复主题没有配置的时候插件异常
if (mActivityInfo.theme == 0) {
if (defaultTheme != 0) {
mActivityInfo.theme = defaultTheme;
} else {
if (Build.VERSION.SDK_INT >= 14) {
mActivityInfo.theme = android.R.style.Theme_DeviceDefault;
} else {
mActivityInfo.theme = android.R.style.Theme;
}
}
//                    }
}
}

}
}

@Override
public Resources.Theme getTheme() {
return mTheme == null ? super.getTheme() : mTheme;
}

}

这里重点要关注的是Theme，与网上的很多资料不同，这里是直接拿DL框架中的代码过来的，如果用网上的资料来进行资源处理，会造成bug。

MainActivity：

package com.example.lujianxin.myapplication;

import android.app.Activity;
import android.content.Intent;
import android.os.Environment;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity {
private static final String TAG = "MainActivity";
private Button interfaceBtn, reflexBtn;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Toast.makeText(this, Environment.getExternalStorageDirectory().getAbsolutePath(), Toast.LENGTH_LONG).show();
interfaceBtn = (Button) findViewById(R.id.interface_btn);
reflexBtn = (Button) findViewById(R.id.reflex_btn);

reflexBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
//通过反射方式处理
Intent intent = new Intent(MainActivity.this, ProxyActivity.class);
startActivity(intent);
}
});

interfaceBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
//通过接口的方式处理
Intent intent = new Intent(MainActivity.this, PlugProxyActivity.class);
startActivity(intent);
}
});
}

}

这里就起一个跳转的作用。

PlugProxyActivity：

package com.example.lujianxin.myapplication;
import android.os.Bundle;
import android.util.Log;
import com.example.lujianxin.proxy.PluginInterface;
import java.io.File;
import java.lang.reflect.Constructor;
import dalvik.system.DexClassLoader;

/**
* Created by lujianxin on 2017/7/14.
*/

public class PlugProxyActivity extends BaseActivity {
private static final String TAG = "ProxyActivity";

private static final String  dexPath = "/data/data/com.example.lujianxin.myapplication/cache/proxy1.apk";
private static final String activityName = "com.example.lujianxin.proxy.MainActivity";
// dex解压之后存放的路径,如果是一个固定的路径运行程序的时候会报错：optimizedDirectory not readable/writable
private File dexOutputDir;

private Class<?> clazz;

private PluginInterface mPluginInterface;

@Override
protected void onCreate(Bundle savedInstanceState) {
loadResources(dexPath, this);
super.onCreate(savedInstanceState);
try {
DexClassLoader loader = initClassLoader();

//动态加载插件Activity
clazz = loader.loadClass(activityName);
Constructor<?> localConstructor = clazz.getConstructor(new Class[] {});
//拿到我们的activity 强转成它实现的接口PluginInterface
mPluginInterface = (PluginInterface) localConstructor.newInstance(new Object[] {});

mPluginInterface.setProxy(this);

Bundle bundle = new Bundle();
mPluginInterface.onCreate(bundle);

} catch (Exception e) {
Log.d(TAG, e.toString());
}
}

private DexClassLoader initClassLoader(){

dexOutputDir = getApplicationContext().getDir("dex", 0);
String filesDir = this.getCacheDir().getAbsolutePath();
String libPath = filesDir + File.separator +"proxy1.apk";
Log.i(TAG, "file-exist-PlugProxyActivity:"+new File(libPath).exists());

DexClassLoader loader = new DexClassLoader(libPath, dexOutputDir.getAbsolutePath(), null, getClass().getClassLoader());
return loader;
}

@Override
protected void onDestroy() {
mPluginInterface.onDestroy();
super.onDestroy();
}

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

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

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

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

这里的重点就是，插件与宿主都存在一个包名相同的接口，同时插件activity要实现这个接口，然后我们通过classloader加载到插件中的activity的时候，就可以强壮成这个接口，然后通过这个接口来管理插件中的activity的生命周期。

ProxyActivity：

package com.example.lujianxin.myapplication;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import dalvik.system.DexClassLoader;

/**
* Created by lujianxin on 2017/7/12.
*/

public class ProxyActivity extends BaseActivity {

private static final String TAG = "ProxyActivity";

private static final String  dexPath = "/data/data/com.example.lujianxin.myapplication/cache/proxy1.apk";
private static final String activityName = "com.example.lujianxin.proxy.MainActivity";
// dex解压之后存放的路径,如果是一个固定的路径运行程序的时候会报错：optimizedDirectory not readable/writable
private File dexOutputDir;
private Class<?> clazz;

private Object pluginActivity;

@Override
protected void onCreate(Bundle savedInstanceState) {
loadResources(dexPath, this);
super.onCreate(savedInstanceState);
try {
DexClassLoader loader = initClassLoader();

//获取插件activity实例
clazz = loader.loadClass(activityName);
Constructor<?> localConstructor = clazz.getConstructor(new Class[] {});
pluginActivity = localConstructor.newInstance(new Object[] {});

//将代理对象设置给插件Activity
Method setProxy = clazz.getMethod("setProxy",new Class[] { Activity.class });
setProxy.setAccessible(true);
setProxy.invoke(pluginActivity, new Object[] { this });

//调用它的onCreate方法
Method onCreate = clazz.getDeclaredMethod("onCreate",
new Class[] { Bundle.class });
onCreate.setAccessible(true);
onCreate.invoke(pluginActivity, new Object[] { new Bundle() });

} catch (Exception e) {
Log.i(TAG, e.toString());
}
}

private DexClassLoader initClassLoader(){
dexOutputDir = getApplicationContext().getDir("dex", 0);
String filesDir = this.getCacheDir().getAbsolutePath();
String libPath = filesDir + File.separator +"proxy1.apk";
Log.i(TAG, "file-exist-proxyActivity:"+new File(libPath).exists());

DexClassLoader loader = new DexClassLoader(libPath, dexOutputDir.getAbsolutePath(), null, getClass().getClassLoader());
return loader;
}

@Override
protected void onDestroy() {
super.onDestroy();
;
try {
Method method = clazz.getDeclaredMethod("onDestroy");
method.setAccessible(true);
method.invoke(pluginActivity, new Object[]{});
} catch(Exception e){
Log.d(TAG, e.toString());
}

}

@Override
protected void onPause() {
super.onPause();
try {
Method method = clazz.getDeclaredMethod("onPause");
method.setAccessible(true);
method.invoke(pluginActivity, new Object[]{});
} catch(Exception e){
Log.d(TAG, e.toString());
}
}

@Override
protected void onResume() {
super.onResume();
try {
Method method = clazz.getDeclaredMethod("onResume");
method.setAccessible(true);
method.invoke(pluginActivity, new Object[]{});
} catch(Exception e){
Log.d(TAG, e.toString());
}
}

@Override
protected void onStart() {
super.onStart();
try {
Method method = clazz.getDeclaredMethod("onStart");
method.setAccessible(true);
method.invoke(pluginActivity, new Object[]{});
} catch(Exception e){
Log.d(TAG, e.toString());
}
}

@Override
protected void onStop() {
super.onStop();
try {
Method method = clazz.getDeclaredMethod("onStop");
method.setAccessible(true);
method.invoke(pluginActivity, new Object[]{});
} catch(Exception e){
Log.d(TAG, e.toString());
}
}

}

这里的实现就简单明了了，通过反射机制来调起插件activity的生命周期方法。

以上就是整个demo的实现，末尾会添加demo的链接。通过代理activity实现插件化，我们应该把插件中的所有类都看成是没有android特有的生命周期的类，运行的还是我们自己宿主中的activity，只是我们宿主activity的生命周期中运行的内容就是插件中的内容。前段时间看到有篇博客说的蛮不错的，这种方式就相当于牵线木偶，而我们的插件就相当于这个木偶，我们加载插件就相当于操作这个木偶；这种方式并不需要过多的涉及底层，另外还有一种Hook的方式实现-360DroidPlugin,想了解的可以去看看，对于framework层的了解有很大帮助。

插件化demo下载