// Step3. 通过反射获取到pluginClassLoader中的pathList字段
Object pluginDexPathList = ReflectUtil.getField(BaseDexClassLoader.class, pluginClassLoader, FIELD_PATH_LIST);
// Step4. 通过反射获取到DexPathList的dexElements字段
Object pluginElements = ReflectUtil.getField(Class.forName(CLASS_DEX_PATH_LIST), pluginDexPathList, FIELD_DEX_ELEMENTS);
// Step5. 通过反射获取到宿主工程中ClassLoader的pathList字段
Object hostDexPathList = ReflectUtil.getField(BaseDexClassLoader.class, hostClassLoader, FIELD_PATH_LIST);
// Step6. 通过反射获取到宿主工程中DexPathList的dexElements字段
Object hostElements = ReflectUtil.getField(Class.forName(CLASS_DEX_PATH_LIST), hostDexPathList, FIELD_DEX_ELEMENTS);
// Step7. 将插件ClassLoader中的dexElements合并到宿主ClassLoader的dexElements
Object array = combineArray(hostElements, pluginElements);
// Step8. 将合并的dexElements设置到宿主ClassLoader
ReflectUtil.setField(Class.forName(CLASS_DEX_PATH_LIST), hostDexPathList, FIELD_DEX_ELEMENTS, array);
}
}
处理插件Activity的启动
在Android中，Activity的启动需要在AndroidManifest.xml中配置，如果没有配置的话，就会报ActivityNotFoundException异常，而插件的Activity无法再宿主AndroidManifest中注册。在上面的Activity的启动流程图，Activity的启动是要经过AMS的校验的，所以就需要对AMS下功夫。
Step1. 在宿主工程的AndroidManifest.xml中预先注册Activity进行占坑。
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=“http://schemas.android.com/apk/res/android”
xmlns:tools=“http://schemas.android.com/tools”
package=“com.github.xch168.plugindemo”>
Step2. 使用占坑Activity绕过AMS验证。
Activity的启动，实际会调用Instrumentation类的execStartActvity方法，所以可以对其进行hook，将启动插件Activity的Intent替换成宿主预注册的插桩Activity，从而绕过ASM的验证。
Instrumentation代理类：
public class InstrumentationProxy extends Instrumentation {
private Instrumentation mInstrumentation;
private PackageManager mPackageManager;
public InstrumentationProxy(Instrumentation instrumentation, PackageManager packageManager) {
mInstrumentation = instrumentation;
mPackageManager = packageManager;
}
public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) {
List infos = mPackageManager.queryIntentActivities(intent, PackageManager.MATCH_ALL);
if (infos == null || infos.size() == 0) {
// 保存要启动的插件Activity的类名
intent.putExtra(HookHelper.TARGET_INTENT, intent.getComponent().getClassName());
// 构建插桩Activity的Intent
intent.setClassName(who, “com.github.xch168.plugindemo.StubActivity”);
}
try {
Method execMethod = Instrumentation.class.getDeclaredMethod(“execStartActivity”, Context.class, IBinder.class, IBinder.class, Activity.class, Intent.class, int.class, Bundle.class);
// 将插桩Activity的Intent传给ASM验证
return (ActivityResult) execMethod.invoke(mInstrumentation, who, contextThread, token, target, intent, requestCode, options);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
Hook:
public class HookHelper {
public static final String TARGET_INTENT = “target_intent”;
public static void hookInstrumentation(Context context) throws Exception {
Class<?> contextImplClass = Class.forName(“android.app.ContextImpl”);
Object activityThread = ReflectUtil.getField(contextImplClass, context, “mMainThread”);
Class<?> activityThreadClass = Class.forName(“android.app.ActivityThread”);
Object mInstrumentation = ReflectUtil.getField(activityThreadClass, activityThread, “mInstrumentation”);
// 用代理Instrumentation来替换mMainThread中的mInstrumentation，从而接管Instrumentation的任务
ReflectUtil.setField(activityThreadClass, activityThread, “mInstrumentation”, new InstrumentationProxy((Instrumentation) mInstrumentation, context.getPackageManager()));
}
}
Step3. 还原插件Activity
上面我们使用插桩Activity来绕过ASM的验证，接下来的步骤会创建StubActivity实例，会找不到类，并且我们要启动的是插件Activity而不是插桩Activity，所以就需要对Intent进行还原。
在Activity启动流程第10步，通过插件的ClassLoader反射创建插件Activity，所以可以在这hook进行还原。
public class InstrumentationProxy extends Instrumentation {
// …
public Activity newActivity(ClassLoader cl, String className, Intent intent) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
// 获取插件Activity的类名
String intentName = intent.getStringExtra(HookHelper.TARGET_INTENT);
if (!TextUtils.isEmpty(intentName)) {
// 创建插件Activity实例
return super.newActivity(cl, intentName, intent);
}
return super.newActivity(cl, className, intent);
}
}
Step4. 在Application中hook Instrumentation。
public class App extends Application {
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(base);
try {
HookHelper.hookInstrumentation(base);
} catch (Exception e) {
e.printStackTrace();
}
}
}
处理插件Activity的生命周期
经过上面的处理后，插件Activity可以启动了，但是是否具有生命周期呢？接下来通过源码来探索一下。
Activity的finish方法可以触发Activity生命周期的变化。
public void finish() {
finish(DONT_FINISH_TASK_WITH_ACTIVITY);
}
private void finish(int finishTask) {
// …
// mToken是该Activity的标识
if (ActivityManager.getService().finishActivity(mToken, resultCode, resultData, finishTask)) {
mFinished = true;
}
}
说明：
《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享
Thread最终会调用performDestroyActivity方法。
public final class ActivityThread extends ClientTransactionHandler {
// …
ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing, int configChanges, boolean getNonConfigInstance, String reason) {
// 获取保存到token的Activity
mInstrumentation.callActivityOnDestroy(r.activity);
}
}
token中的Activity是从何而来呢？解析来我们来看看ActivityThread的performLaunchActivity方法。
public final class ActivityThread extends ClientTransactionHandler {
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// …
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
r.activity = activity;
mActivities.put(r.token, r);
}
}
说明：在performLaunchActivity方法中，会将当前启动的Activity放在token中的activity属性，并将其置于mActivities中，而mInstrumentation的newActivity方法已经被我们hook了，所以该activity即为插件Activity，后续各个生命周期的调用都会通知给插件Activity。
加载插件中的资源
当插件Activity创建的时候会调用setContentView通过id去操作布局，因为凡是通过id去获取资源的方式都是通过Resources去获取的。但是宿主apk不知道到插件apk的存在，所以宿主Resources也无法加载插件apk的资源。因此需要为插件apk构建一个Resources，然后插件apk中都通过这个Resource区获取资源。
public class PluginHelper {
private static Resources sPluginResources;
public static void initPluginResource(Context context) throws Exception {
Class clazz = AssetManager.class;
AssetManager assetManager = clazz.newInstance();
Method method = clazz.getMethod(“addAssetPath”, String.class);
method.invoke(assetManager, context.getExternalFilesDir(“plugin”).listFiles()[0].getAbsolutePath());
sPluginResources = new Resources(assetManager, context.getResources().getDisplayMetrics(), context.getResources().getConfiguration());
}
public static Resources getPluginResources() {
return sPluginResources;
}
}
public class App extends Application {
@Override
public Resources getResources() {
return PluginHelper.getPluginResources() == null ? super.getResources() : PluginHelper.getPluginResources();
}
}
说明：在Application中重写getResources，并返回插件的Resources，因为插件apk中的四大组件实际都是在宿主apk创建的，那么他们拿到的Application实际上都是宿主的，所以它们只需要通过getApplication().getResources()就可以非常方便的拿到插件的Resource。
插件工程
插件工程比较简单，就一个Activity。
public class PluginActivity extends AppCompatActivity {
