Android插件化实现原理及方案
插件化实现主要分为三部，和把大象关进冰箱的步骤一样多。第一步动态加载插件，第二步hook系统启动四大组件过程来启动插件中的组件，第三步插件中的资源加载。下面依照步骤来依次介绍。
第一步 动态加载插件
大家都知道Android打包编译过程中会把所有Java源文件，编译成Class文件，然后经过字节码优化处理打包到dex文件中。在App执行时，又会从dex文件中加载Class文件到JVM中执行。通常一个dex文件最多能容纳65535个方法，但是由于目前App的业务增加以及第三方库的依赖一个App中的方法数远远超过65535个方法，因此google推出Muldex策略来兼容，实现原理是用一个数组存放多个dex文件。了解了这个特性后我们就可以以此为切入点，在App启动运行时把我们的插件种的dex列表与宿主App的dex列表合并到一起来加载插件。
要实现插件的加载，需要先了解Android中类加载机制。
Android中使用到的类加载主要用到以下几个类。
DexClassLoader,PathClassLoader,BaseDexClassLoader,BootClassLoader,ClassLoader。他们的关系如下图：
ClassLoader为基类，loadClass方法在基类中实现
BootClassLoader加载SDK中类
PathClassLoader与DexClassLoader继承BaseDexClassLoader，两个类的构造方法中都调用BaseDexClassLoader，不同之处是两个类的参数不一样，其实Android8.0以后两个类实现的功能是完全一致的。BaseDexClassLoader具体实现 findClass过程。
loadClass方法如下（SDKVersion=26）：
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
c = findClass(name);
}
}
return c;
}
我们来看一下具体实现，首先执行findLoadedClass（）方法，如果类已经加载过直接返回，如果没有加载过会首先判断parent是否为空，如果不为空用parent实例来递归加载类（这里是双亲委派机制），如果parent为空加载Android sdk中的系统类，如果最后还为空会才会调用 findClass方法，findClass方法ClassLoader为空实现，具体实现在BaseDexClassLoader中。我们继续看一下findClass方法实现
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
Class c = pathList.findClass(name, suppressedExceptions);
if (c == null) {
ClassNotFoundException cnfe = new ClassNotFoundException(
"Didn't find class \"" + name + "\" on path: " + pathList);
for (Throwable t : suppressedExceptions) {
cnfe.addSuppressed(t);
}
throw cnfe;
}
return c;
}
我们看到实现中调用了 DexPathList的findCLass方法，我们再进去看pathList.findClass实现
public Class<?> findClass(String name, List<Throwable> suppressed) {
for (Element element : dexElements) {
Class<?> clazz = element.findClass(name, definingContext, suppressed);
if (clazz != null) {
return clazz;
}
}
if (dexElementsSuppressedExceptions != null) {
suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
}
return null;
}
方法里调用循环一个Element数组，Element类中findClass来具体查找Class，我们再看一下Element实现
static class Element {
、
、
、
private final DexFile dexFile;
、
、
、
public Element(DexFile dexFile, File dexZipPath) {
this.dexFile = dexFile;
this.path = dexZipPath;
}
、
、
、
public Class<?> findClass(String name, ClassLoader definingContext,
List<Throwable> suppressed) {
return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed)
: null;
}
、
、
、
我们可以看到一个Element对象对应一个dex文件，到此我们找到了类的整个加载过程，现在就可以想办法把我们插件中的dex加载到宿主中。由于我们需求修改的类都是private或是protect方法，只能通过反射读取来实现，具体实现如下：
public static void loadPlugin(Context context){
try{
//读取DexPathList中的dexElements字段
Class dexPathListClass = Class.forName("dalvik.system.DexPathList");
Field dexElementsFiled = dexPathListClass.getDeclaredField("dexElements");
dexElementsFiled.setAccessible(true);
//读取BaseDexClassLoader中的pathList字段
Class dexClassLoaderClass = Class.forName("dalvik.system.BaseDexClassLoader");
Field dexPathListFiled = dexClassLoaderClass.getDeclaredField("pathList");
dexPathListFiled.setAccessible(true);
//获取宿主ClassLoader实例，并根据ClassLoader实例获取 pathList字段实例，再根据pathList实例获取dexElements数组实例
ClassLoader hostClassLoader = context.getClassLoader();
Object hostDexPathListObject = dexPathListFiled.get(hostClassLoader);// 宿主pathList 字段对象实例
Object[] hostDexElementsObject = (Object[])dexElementsFiled.get(hostDexPathListObject); //dexElements 字段对象实例
//根据插件Apk的存放路径来创建插件ClassLoader,并获取插件classLoader的pathList实例与插件dexElements实例
DexClassLoader pluginClassLoader = new DexClassLoader(pluginApkPath,context.getCacheDir().getAbsolutePath(),null,hostClassLoader);
Object pluginDexPathListObject = dexPathListFiled.get(pluginClassLoader);// 插件pathList 字段对象实例
Object[] pluginDexElementsObject = (Object[])dexElementsFiled.get(pluginDexPathListObject); //插件dexElements 字段对象实例
// 创建一个新Element数组 合并宿主与插件的dexElements并赋值给宿主的dexElements
Object[] newElement = (Object[]) Array.newInstance(
hostDexElementsObject.getClass().getComponentType(),
hostDexElementsObject.length + pluginDexElementsObject.length);
System.arraycopy(hostDexElementsObject, 0, newElement,
0, hostDexElementsObject.length);
System.arraycopy(pluginDexElementsObject, 0,
newElement, hostDexElementsObject.length, pluginDexElementsObject.length);
dexElementsFiled.set(hostDexPathListObject,newElement);
}catch (Exception e){
e.printStackTrace();
}
第一步完成。
第二步启动插件中的Activity
需要启动插件中的Activity需要了解Activity的启动流程，Activity启动流程分析是一项大工程涉及到当前进程去系统进程ActivityManagerService通信交互这里不详细解析，只介绍一下大致流程。当前App进程调用startActivity时会通过IBinder机制与AMS通信，AMS接收消息处理启动后会再通过IBinder机制告诉当前App进程启动Activity。
那我们怎样启动我们插件中的组件呢，答案是绕过系统来启动。具体实现方式是先在宿主中建立一个ProxyActivity，当我们启动插件Activity过程中在当前App进程与Ams进程 通信前把启动插件Activity的Intent换成启动宿主中ProxyActivity的Intent，当Ams启动完成与当前App进程通信时再拦截消息把Intent中的ProxyActivity的Intent还原为插件的Activity的Intent。（好骚的操作）
具体实现通过反射与动态代理Ams 实现intent替换。经Activity的startActivity方法我们可以看到 Instrumentation.execStartActivity()方法中调用ActivityTaskManager.getService()方法来实现，在ActivityTaskManager.getService()方法中获取 IActivityTaskManagerSingleton实例，由于此实例是静态变量并且类加载时已经初始化正好可以用反射读取实例。以下是部分代码实现
当前进程与Ams进程交互之前
Instrumentation.java
@UnsupportedAppUsage
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
、、、
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityTaskManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
ActivityManager .java
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
通过分析代码实现hook拦截替换参数中的Intent改变为ProxyActivity
/**
* 启动插件 Activity 在系统交互前替换插件Activity的Intent 为 代理Activity的Intent
*/
private static void hookAmsReplacePluginIntent(){
try {
Class activityManagerClass = Class.forName("android.app.ActivityManager");
Field activityManagerField = activityManagerClass.getDeclaredField("IActivityManagerSingleton");
activityManagerField.setAccessible(true);
Object activityManagerObject = activityManagerField.get(null);
Class singletonClass = Class.forName("android.util.Singleton");
Field singletonField = singletonClass.getDeclaredField("mInstance");
singletonField.setAccessible(true);
final Object mInstance = singletonField.get(activityManagerObject);
Class iActivityManagerClass = Class.forName("android.app.IActivityManager");
Object proxyClass = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{iActivityManagerClass}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("startActivity".equals(method.getName())){
int index = 0;
for (int i = 0; i < args.length; i++) {
if (args[i] instanceof Intent) {
index = i;
break;
}
}
//拿到了 intent --》 插件：1
Intent intent = (Intent) args[index];
// 替换
Intent proxyIntent = new Intent();
proxyIntent.setClassName("com.spw.pluginsample",
"com.spw.pluginsample.ProxyActivity");
proxyIntent.putExtra(TARGET_INTENT, intent);
//代理替换了插件的
args[index] = proxyIntent;
}
return method.invoke(mInstance,args);
}
});
singletonField.set(activityManagerObject,proxyClass);
}catch (Exception e){
e.printStackTrace();
}
}
当Ams完成启动请求处理与当前进App进程交互还原Intent
在ActivityThread中 Handler类型 mH参数来接消息并处理系统消息
在ActivityThread中发现处理activity启动部分代码实现如下：
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case RELAUNC
找到了方法我们就可以在此处拦截消息再把我们的Intent改为插件中的Activity,具体实现如下：
···
private static void hookActivityThreadReStorePluginIntent(){
try {
Class actThreadClazz = Class.forName("android.app.ActivityThread");
Field currentActivityThreadField = actThreadClazz.getDeclaredField("sCurrentActivityThread");
currentActivityThreadField.setAccessible(true);
Object currentActivityThreadObject = currentActivityThreadField.get(null);
Field handerField = actThreadClazz.getDeclaredField("mH");
handerField.setAccessible(true);
Object handlerObject = handerField.get(currentActivityThreadObject);
Class handlerClazz = Class.forName("android.os.Handler");
Field handlerCallbackField = handlerClazz.getDeclaredField("mCallback");
handlerCallbackField.setAccessible(true);
Object handlerCallbackObject = new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
switch (msg.what){
case 100:
try {
// 替换的：Intent intent; --》 ActivityClientRecord的对象 == msg.obj
Field intentField = msg.obj.getClass().getDeclaredField("intent");
intentField.setAccessible(true);
// 代理的
Intent proxyIntent = (Intent) intentField.get(msg.obj);
// 获取插件的
Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
//替换
if (intent != null) {
intentField.set(msg.obj, intent);
}
} catch (Exception e) {
e.printStackTrace();
}
break;
default:
break;
}
return false;
}
};
handlerCallbackField.set(handlerObject,handlerCallbackObject);
}catch (Exception e){
e.printStackTrace();
}
}
···
实现原理反射拿的ActivityThread实例 sCurrentActivityThread,再根据此实例拿到mH的Handler实例，Handler中的callback参数实际是做消息拦截处理的，由于mH默认没有此参数，我们可以创建callback对象并赋值给mH,在callback中我们正好做消息拦截处理把启动插件的Intent还原来启动我们插件的Activity。
第三步插件中资源加载
这一步实现比较简单，我们采取宿主资源和插件资源隔离方式，让插件统一加载插件资源。因为插件加载都是通过Resources类进行加载，能过源代码我们又能知道Resources其实也是依赖AssetManager来加载。这样我们就可以把插件的资源读取出来，新建Resources实例。下面见代码实现
public static Resources loadResources(Context context) {
try {
AssetManager assetManager = AssetManager.class.newInstance();
Method addAssetPathMethod = assetManager.getClass().getDeclaredMethod("addAssetPath", String.class);
addAssetPathMethod.setAccessible(true);
addAssetPathMethod.invoke(assetManager, apkPath);
// AssetManager 加载的资源路径 是插件的
Resources resources = context.getResources();
return new Resources(assetManager, resources.getDisplayMetrics(),
resources.getConfiguration());
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
所有插件中的Activity都重写 getResources方法来加载插件中的资源文件，可以实现一个BasePluginActivity来重写此方法，所有插件中的Activity都继承BasePluginActivity。
@Override
public Resources getResources() {
Resources resources = LoadResourceUtil.getResources(getApplication());
return resources == null ? super.getResources() : resources;
}
}
到此，一个简单的插件加载过程就完成了。本文是以sdk 为26的版本为例实现，其它版本在启动Activity有略不有空，需要根据版本做不同的hook处理。其原理是一样的,如有问题，欢迎大家指证！
