Android开发插件化来龙去脉

前言

随着Android的发展，国内一线企业的项目模块越来越多，用户体验要求也越来越高，想实现小步快跑、快速迭代的目的越来越难，还有65535，应用之间的互相调用等等问题，从而催生了插件化技术的产生。

2012年插件化概念被提出，到2016年的时候，插件化技术百家争鸣，被一线大厂广泛使用。插件化技术几乎引领了Android技术的进步

插件技术可以给项目开发带来巨大的好处，比如：并行高效开发、模块解耦、解除单个dex函数不能超过65535的限制、动态更新升级、按需加载等等。

本文的目的是从一个典型的复杂项目中总结出较为全面与完整的安卓插件技术。

掌握好插件技术，需要如下的安卓基础和相关知识，例如：

1. Android应用程序安装，加载过程

2. Android应用运行机制，生命周期调用原理

3. Android应用资源编译打包原理

4. Android应用读取资源原理  ： Android中资源管理机制详细分析

5. Android系统AMS、PMS、NMS等系统服务的运作原理

6. 增量更新

7. HOOK等技术

插件技术知识领域如图：

这些技术中每一个点都需要大篇幅内容才能完全讲清楚。不过，好在Android是开源的，每一个插件技术涉及到的技术点都可以翻阅源码进行进一步的研究

 

插件化原理

插件化要解决三个核心问题：类加载、资源加载、组件生命周期管理。

类加载

Android中常用的两种类加载器：PathClassLoader、DexClassLoader，他们都继承于BaseDexClassLoader。

// PathClassLoader.java
public class PathClassLoader extends BaseDexClassLoader {
    public PathClassLoader(String dexPath, ClassLoader parent) {
        super(dexPath, null, null, parent);
    }
    
    public PathClassLoader(String dexPath, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
}

// DexClassLoader.java
public class DexClassLoader extends BaseDexClassLoader {
    public DexClassLoader(String dexPath, String optimizedDirectory, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
}

说明：

1. DexClassLoader的构造函数比PathClassLoader多了一个参数optimizedDirectory，用来指定dex的优化产物odex的路径，在源码注释中，指出这个参数从API 26后就弃用了。
2. DexClassLoader用来加载未安装apk的dex。
3. PathClassLoader主要用来加载系统类和应用程序的类，在ART虚拟机上就可以加载未安装的dex，在Dalvik不行。

资源加载

Android系统通过Resource对象加载资源，因此只需要添加资源（即apk文件）所在路径到AssetManager中，即可实现对插件资源的访问。

// 创建AssetManager对象
AssetManager assetManager = new AssetManager();
// 将apk路径添加到AssetManager中
if (assetManager.addAssetPath(apkPath) == 0) {
    return null;
}
// 创建插件Resource对象
Resources pluginResources = new Resources(assetManager, metrics, getConfiguration());

说明：

由于AssetManager的构造方法是hide的，需要通过反射去创建。

组件生命周期管理

对于Android来说，并不是说类加载进来就可以使用了，很多组件都是有”生命“的，因此，这些有血有肉的类，必须给他们注入活力，也就是所谓的  组件生命周期管理。

在解决插件中组件的生命周期，通常的做法是通过 Hook 相应的系统对象，实现欺上瞒下，后面将通过Activity的插件化来进行讲解。

Activity插件化

四大组件的插件化是插件化技术的核心知识点，而Activity插件化更是重中之重，Activity插件化的主流实现方式是通过Hook技术实现的。

Activity的启动过程 

 参考：Android的Activity启动流程分析

上图列出的是启动一个Activity的主要过程，具体步骤如下：

1、Activity1调用startActivity，实际上会调用Instrumentation类的execStractivity方法，Instrumentation是系统用来监控Activity运行的一个类，Activity的整个生命周期都有它的影子。

2、通过跨进程的binder调用，进入到ActivityManagerService（AMS）中，其内部会处理Activity栈。之后又通过跨进程调用进入到Activity2所在进程中。

3、ApplicationThread是一个binder对象，其运行在binder线程池中，内部包含一个H类，该类继承于Handler。ApplicationThread将启动Activity2的信息通过H对象发送给主线程。

4、主线程拿到Activity2的信息后，调用Instrumentation类的newActivity方法，其内部通过ClassLoader创建Activity2实例。

加载插件中的类

public class PluginHelper {

    private static final String TAG = "PluginHelper";

    private static final String CLASS_DEX_PATH_LIST = "dalvik.system.DexPathList";
    private static final String FIELD_PATH_LIST = "pathList";
    private static final String FIELD_DEX_ELEMENTS = "dexElements";
    
       private static void loadPluginClass(Context context, ClassLoader hostClassLoader) throws Exception {
        // Step1. 获取到插件apk，通常都是从网络上下载，这里为了演示，直接将插件apk push到手机
        File pluginFile = context.getExternalFilesDir("plugin");
        Log.i(TAG, "pluginPath:" + pluginFile.getAbsolutePath());
        if (pluginFile == null || !pluginFile.exists() || pluginFile.listFiles().length == 0) {
            Toast.makeText(context, "插件文件不存在", Toast.LENGTH_SHORT).show();
            return;
        }
        pluginFile = pluginFile.listFiles()[0];
        // Step2. 创建插件的DexClassLoader
        DexClassLoader pluginClassLoader = new DexClassLoader(pluginFile.getAbsolutePath(), null, null, hostClassLoader);
        // 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进行占坑。

step2、使用占坑Activity绕过AMS验证

Activity的启动，实际会调用Instrumentation类的execStartActivity方法，所以可以对其进行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;
    }
}

说明：

1. 调用ASM的finishActivity方法，接着ASM通过ApplicationThread调用ActivityThread。
2. ActivityThread最终会调用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的performLauncherActivity方法

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);
    }
}

说明：

在performLauncherActivity方法中，会将当前启动的Activity放在token中的activity属性，将其置于mActivities中，而mInstrumentation的newActivity方法已经被我们hook了，所以该activity即为插件Activity，后续生命周期的调用都会通知给插件Activity。

加载插件中的资源

当插件Activity创建的时候会调用setContentView通过id去操作布局，因为凡是通过id去获取资源的方式都是通过Resource去获取的，但是宿主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 {

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

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

说明：

重写getResource方法，并返回插件Resources，因为需要通过插件Resources才能用id去操作资源文件。

测试

Step1. 将插件项目打包成apk；

Step2. 通过adb命令adb push 将apk推送到手机；

Step3. 宿主应用加载插件apk。

总结

插件化要处理的细节非常多，不仅要适配不同的版本的Android系统，还要适配国产的各种ROM，要深入学习插件化的各种解决方法，可以去探索开源的插件化框架。

2018年Android 9.0上Android开始对私有API的使用进行限制，所以后面插件化可能退出历史主流，但是了解插件化涉及到的知识和技术，可以更好的理解Android系统。

Demo地址：https://github.com/xch168/PluginDemo

Android插件化原理解析 https://www.jianshu.com/p/d3231a15afee

参考链接

1. 《Android插件化技术——原理篇》
2. Android插件化初体验
3. Android apk动态加载机制的研究
4. VirtualAPK资源加载原理解析
5. Android插件化原理（一）Activity插件化
6. Android 插件化：从入门到放弃
7. 自己动手写Android插件化框架
8. 插件化之代码调用与加载资源
9. Android插件化原理解析——概要
10. Android 插件技术实战总结