shadow插件运行原理

其实，用shadow来运行我们的业务插件已经很长一段时间了，但是呢，因为shadow这一块是开源了，而我们使用的版本维护者经常不on call，所以有种受制于人的赶脚。还是想抽出时间自己上手分析一遍，这样遇到问题也可以快速响应解决了。

首先看一下，一般情况下是如何实现插件能力的。 ps.这里，我将不再在文章内部贴太多实现代码，我希望可以先理清整体的思路，当然，所有相关代码我都会放在最后以供取阅。

既然是插件，那么就需要和宿主应用保持一定的距离，不能参与宿主的打包和安装，却要在宿主需要的时候出现。但是如果不参与宿主的编译打包安装，那么系统便无法感知有这么个插件的存在，继而想要通过系统方法调用插件的能力也不太可能，毕竟系统也没有承认过它呀。这也引申出插件化技术的几个关键技术点

1. 类加载/资源 加载

插件和宿主既然是两个独立的apk，那么他们的上下文也是隔离开来的。宿主无法通过自己的classLoader找到插件apk中的信息，反之亦然。同样需要使插件能够加载到插件包内的资源，同时做好与宿主资源的隔离。

2. 与系统、宿主应用的通信

没有在系统中进行安装，也就无法实现安卓中四大组件的功能。插件的activity等信息都没有向系统注册过，也就无法被系统启动从而注册上一系列生命周期了。

shadow接入指引可以看这篇文章，写的很详细

Android Tencent Shadow 插件接入指南 - cps666 - 博客园

那么依次看下，传统插件思路和shadow是如何解决这些问题的

1. 类加载/资源 加载

1.1类加载

了解在JVM中，java代码被编译成.class文件，然后交给jvm来执行。 一般的，类加载分为：加载、链接、初始化\color{red}{加载、链接、初始化}加载、链接、初始化三个过程

在安卓系统中，提供DexClassLoader，支持 传入apk地址或者dex文件地址，即可以加载类文件。

所以，如果我们需要加载插件的class，那么就需要告诉ClassLoader插件的dex文件地址。

// 创建DexClassLoader实例
   val dexClassLoader = DexClassLoader(
          apkFile.path,  // APK文件的路径
          optimizedDexOutputPath,  // 优化后的DEX文件存放路径
          null,  // 库文件搜索路径，通常为null
          parentClassLoader // 父ClassLoader
                )

但是，宿主也有自己的classLoader，如何让宿主apk启动插件时用插件的classLoader呢？

我们通过阅读BaseClassLoader\color{red}{BaseClassLoader}BaseClassLoader的findClass方法可以得出，classLoader会通过遍历pathList中的dexElements来完成类的查找，那么我们只需要将插件的dexList添加到其中，也就能够通过宿主的classLoader加载到插件的类了。很多安卓的热修复/补丁 方案也是基于这个原理来实现的。

这样也有弊端，比如当插件和宿主依赖了同一个库的不同版本时，可能会存在版本冲突导致异常。

当然，也可以重新实现一份插件的classLoader，实现多classLoader架构，使得插件apk总是使用插件的loader来加载。不过这种方式比较麻烦，需要向系统的packages中添加插件apk信息，而常规情况该信息的添加是由系统来处理的，因此需要hook很多系统操作。

shadow采用的方案也是重新实现一份插件的classloader，并将宿主的loader作为插件的父loader

//创建插件loader
    PluginClassLoader(
            apk.absolutePath, // dex文件地址
            odexDir, // odex优化后路径
            installedApk.libraryPath, //库文件搜索路径，通常为null
            hostClassLoader, //宿主loader
            hostParentClassLoader,
            loadParameters.hostWhiteList // 宿主配置白名单
                )

在插件的基类中，重写getClassloader修改为自定义实现的classloader

      @Override
      public ClassLoader getClassLoader() {
        if (hostActivityDelegate != null) {
          return hostActivityDelegate.getClassLoader();
        } else {
          return super.getClassLoader();
        }
      }

1.2资源加载：

处理完上面的问题后，我们已经可以成功在宿主中启动插件apk的actvity了，马上又会发现，展示插件内容时，插件引用的R资源文件会抛出Not found\color{red}{Not found}Not found的错误。这也很好理解，因为我们是用宿主来启动的插件，所以系统加载资源时，会用宿主的resource来进行查找。但是不建议将插件资源放到宿主中去，这样一来耦合过重，二来也会有资源冲突的问题。

一般方案是在插件中，重新定义resource，使得插件apk执行时总是用处理过的resource进行资源加载。反射的做法是调用AssetManager中的addAssetPath传入插件的apk路径

shadow这里采用了一种非反射的做法，即直接获取插件apk的resource，然后修改插件基类的getResource方法。

        // 获取插件apk的resource
    val archiveFilePath = File(this.getFileStreamPath("tool-debug.apk").path).path
    // getPackageArchiveInfo 它用于从 APK 文件中检索包信息，而不需要安装该 APK。
                val packageArchiveInfo = packageManager.getPackageArchiveInfo( 
                    archiveFilePath,
                    PackageManager.GET_ACTIVITIES
                            or PackageManager.GET_META_DATA
                            or PackageManager.GET_SERVICES
                            or PackageManager.GET_PROVIDERS
                            or PackageManager.GET_SIGNATURES
                )
                mPluginResources = packageArchiveInfo?.let { it1 -> packageManager.getResourcesForApplication(it1.applicationInfo) }

2. 与系统的通信（以activity为例）

常规的我们启动一个activity，需要先实现该activity，然后在AndroidManifest.xml中注册相关信息，然后再通过intent来启动。（又可分显式和隐式）

整个启动流程很复杂，简单概括下就是 通过intent设置要启动的activity，然后由AMS找到该activity的相关信息，反射创建一个实例出来，然后再通过生命周期派发，再由WMS将该activity显示到屏幕界面上

如果没有注册，那么AMS则不会启动该activity。常见的是通过一些hook和代理技术，在通知AMS启动和创建时，用一个已经注册的代理activity替换非法activity，从而达到“狸猫换太子”的效果。

建议实际实现一次，可以对整个activity的启动流程有更深入的了解.\color{red}{建议实际实现一次，可以对整个activity的启动流程有更深入的了解.}建议实际实现一次，可以对整个activity的启动流程有更深入的了解.

同时这里还涉及到实际需要启动的插件Activity在另外的plugin.apk中，即1. 类加载中的相关问题，不再赘述。

这种方案也是主流的插件hook方案，不过缺点也显而易见，即使用反射无可避免的兼容性问题。

反观shadow在这里的实现，则更为巧妙。同样的也是使用 一个ProxyActivity来让系统启动，但无需图中两次替换操作，即减少两次反射hook，代理的ProxyActivity也真正的被启动起来了。

这时你肯定会想，那插件的activity呢？

当代理activity启动后，再从插件apk中找到入口activity，直接实例化后add到页面上展示。如果你试过直接new activity，会发现实际根本无法在业务层直接创建activity，activity需要由系统来创建，并完成状态、资源、上下文等的初始化和分配。\color{red}{状态、资源、上下文等的初始化和分配。}状态、资源、上下文等的初始化和分配。然而，shadow通过修改插件编译生成的字节码的方式（gradle插件），将插件APK内的业务activity 都修改继承自shadow框架的ShadowActivity，不同于正常的ac，插件内的ac已经不再继承自安卓系统的ac，所以可以直接new出来展示。

自然，ShadowActivity也需要添加系统ac常用的生命周期方法，当我们操作插件ac时，实际上操作的是ShadowActivity，而相关操作又会被 ProxyActivity接收并发送给系统进行处理；当系统通知 ProxyActivity相关回调时， ProxyActivity又会将消息发送给ShadowActivity，进而再通知的插件内的activity。这是一种很好的委托模式。

基于activity梳理的插件加载运行流程基本就是这样。

3. 总结

概括一下，常见的插件通过hook AMS与handler，绕开系统检查，启动了一个非法的activity（未安装/注册），同时通过修改classloader和resource来实现插件类/资源的加载。而shadow与之的一个最主要的区别则是，通过修改字节码的方式，让插件内的activity不再继承安卓系统的activity，而真正成为一个可以被手动create的对象，再利用委托模式使其通过壳容器与系统、宿主进行交互。

–附

hook 启动插件activity时，需要将其替换为 已注册的代理activity

/**
 * 使用代理的Activity替换需要启动的未注册的Activity
 * 在启动startActivity和AMS检测启动的页面之间，将未注册的Activity替换为已注册的Activity
 */
public static void hookAMS() {
    // Android10之前要适配
    try {
        //反射
        Class<?> clazz = Class.forName("android.app.ActivityTaskManager");
        Field singletonField = clazz.getDeclaredField("IActivityTaskManagerSingleton");

        singletonField.setAccessible(true);
        Object singleton = singletonField.get(null);

        Class<?> singletonClass = Class.forName("android.util.Singleton");
        Field mInstanceField = singletonClass.getDeclaredField("mInstance");
        mInstanceField.setAccessible(true);
        Method getMethod = singletonClass.getMethod("get");
        Object mInstance = getMethod.invoke(singleton);

        Class IActivityTaskManagerClass = Class.forName("android.app.IActivityTaskManager");
        //动态代理
        Object mInstanceProxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class[]{IActivityTaskManagerClass}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        if ("startActivity".equals(method.getName())) {
                            Log.i("Cath","拦截到调用startActivity方法");

                            // 获取 Intent 参数在 args 数组中的index值
                            for (int i = 0; i < args.length; i++) {
                                Log.i("Cath","第"+i+"个参数是："+args[i]);
                                if (args[i] instanceof Intent) {
                                    Intent intent = (Intent) args[i];
                                    // 获取假的activity，在intent中的componentName对象中
                                    ComponentName componentName = intent.getComponent();
                                    Log.i("Cath","要跳转的目标Activity："+componentName.getClassName());
                                    // 获取代理的activity名称，这个ac是真的有注册过的
                                    ComponentName proxyComponentName =intent.getParcelableExtra("proxyComponentName");
                                    if (proxyComponentName != null) {
                                        Log.i("Cath","拿来伪造的Activity："+proxyComponentName.getClassName());
                                        intent.putExtra("realComponentName", componentName); // 真正想打开的插件activity也要记录一下
                                        intent.setComponent(proxyComponentName); // 把代理的activity信息设置进去
                                    }


                                    break;
                                }
                            }
                        }

                        // 原来流程
                        return method.invoke(mInstance, args);
                    }
                });

        // 用代理的对象替换系统的对象
        mInstanceField.set(singleton, mInstanceProxy);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

hook AMS通知展示代理activity时，需要再次替换回插件的activity

/**
 * 需要启动的未注册的Activity 替换回来  ProxyActivity
 * 在AMS检测启动的Activity之后，Activity执行生命周期之前，将已注册页面替换成未注册的页面即可
 */
public static void hookHandler() {
    try {
        Class<?> clazz = Class.forName("android.app.ActivityThread");
        Field activityThreadField = clazz.getDeclaredField("sCurrentActivityThread");
        activityThreadField.setAccessible(true);
        Object activityThread = activityThreadField.get(null);

        Field mHField = clazz.getDeclaredField("mH");
        mHField.setAccessible(true);
        // 获取handler
        final Handler mH = (Handler) mHField.get(activityThread);

        Field mCallbackField = Handler.class.getDeclaredField("mCallback");
        mCallbackField.setAccessible(true);

        mCallbackField.set(mH, new Handler.Callback() {

            @Override
            public boolean handleMessage(Message msg) {
                if (msg.what == 159) {
                    Log.i("Cath", "拦截在handleMessage中启动Activity的消息 ");
                    // msg.obj = ClientTransaction
                    try {
                        // 获取 List<ClientTransactionItem> mActivityCallbacks 对象
                        Field mActivityCallbacksField = msg.obj.getClass()
                                .getDeclaredField("mActivityCallbacks");
                        mActivityCallbacksField.setAccessible(true);
                        List mActivityCallbacks = (List) mActivityCallbacksField.get(msg.obj); //根据源码得知，这个msg.obj就是ActivityClientRecord实例

                        for (int i = 0; i < mActivityCallbacks.size(); i++) {
                            // 打印 mActivityCallbacks 的所有item:
                            //android.app.servertransaction.WindowVisibilityItem
                            //android.app.servertransaction.LaunchActivityItem

                            // 如果是 LaunchActivityItem，则获取该类中的 mIntent 值，即 proxyIntent
                            if (mActivityCallbacks.get(i).getClass().getName()
                                    .equals("android.app.servertransaction.LaunchActivityItem")) {
                                Object launchActivityItem = mActivityCallbacks.get(i);
                                Field mIntentField = launchActivityItem.getClass()
                                        .getDeclaredField("mIntent");
                                mIntentField.setAccessible(true);
                                Intent proxyIntent = (Intent) mIntentField.get(launchActivityItem);

                                // 获取启动插件的 Intent，并替换回来
                                ComponentName realComponentName = proxyIntent.getParcelableExtra("realComponentName");
                                // java.lang.ClassNotFoundException: Didn't find class "com.example.tool.MainActivity" on path: DexPathList
                                Log.i("Cath", "替换回插件的intent" + realComponentName);
                                if (realComponentName != null) {
                                    proxyIntent.setComponent(realComponentName);
                                }
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        Log.i("Cath", " 获取启动activity的int值 " + e.getMessage());
                    }
                }
                return false;
            }
        });
    } catch (Exception e) {
        e.printStackTrace();
        Log.i("Cath", " 获取启动activity的int值 " + e.getMessage());
    }
}

将插件的dex文件合并到宿主中

    /**
     * 插件中的Element融入到宿主中
     */
    public static void pluginToAppAction(Activity activity, ClassLoader classLoader, ClassLoader parentClassLoader) throws Exception{
        //1. 找到宿主中的dexElements数组
        PathClassLoader pathClassLoader = (PathClassLoader) classLoader;
        Class<?> baseDexClassLoaderClass = Class.forName("dalvik.system.BaseDexClassLoader");
        Field pathListField = baseDexClassLoaderClass.getDeclaredField("pathList");
        pathListField.setAccessible(true);
        Object dexPathList = pathListField.get(pathClassLoader);

        Field dexElementsField = dexPathList.getClass().getDeclaredField("dexElements");
        dexElementsField.setAccessible(true);
        Object appDexElements = dexElementsField.get(dexPathList);
        //2.  找到插件中的dexElements数组
        File pluginFile = new File(activity.getFileStreamPath("tool-debug.apk").getPath());
        Log.d("Cath", activity.getFileStreamPath("tool-debug.apk").getPath());
        if (!pluginFile.exists()) {
            Log.i("Cath","插件包不存在");
            return;
        }
        String pluginPath = pluginFile.getAbsolutePath();
        File pluginDir = activity.getDir("pluginDir",MODE_PRIVATE);
        DexClassLoader dexClassLoader = new DexClassLoader(pluginPath,pluginDir.getAbsolutePath(),null, parentClassLoader);

        Class<?> pluginBaseDexClassLoaderClass = Class.forName("dalvik.system.BaseDexClassLoader");
        Field pluginPathListField = pluginBaseDexClassLoaderClass.getDeclaredField("pathList");
        pluginPathListField.setAccessible(true);
        Object pluginDexPathList = pluginPathListField.get(dexClassLoader);
        Field dexElementsFieldPlugin = pluginDexPathList.getClass().getDeclaredField("dexElements");
        dexElementsFieldPlugin.setAccessible(true);
        Object pluginDexElements = dexElementsFieldPlugin.get(pluginDexPathList);

        //3. 把两个数组合并成一个新的数组 newElement
        int appLength = Array.getLength(appDexElements);
        int pluginLength = Array.getLength(pluginDexElements);
        int sum = appLength+pluginLength;
        //创建一个新的数组 两个参数，一个是类型  一个是长度
        Object newDexElement = Array.newInstance(appDexElements.getClass().getComponentType(), sum);
        //进行融合
        for (int i = 0; i < sum; i++) {
            if(i<appLength){
                Array.set(newDexElement,i,Array.get(appDexElements,i));
            }else {
                Array.set(newDexElement,i,Array.get(pluginDexElements,i-appLength));
            }
        }
        //4. 把新的数组设置回宿主中
        dexElementsField.set(dexPathList,newDexElement);

        //5. 处理布局文件
        handlePluginLayout(activity);
    }
    private static void handlePluginLayout(Activity activity) throws Exception{
        AssetManager assetManager = AssetManager.class.newInstance();

        // 把插件的路径 给 AssetManager
        File pluginFile = new File(activity.getFileStreamPath("tool-debug.apk").getPath());
        if (!pluginFile.exists()) {
            Log.i("Cath","插件包不存在");
            return;
        }
        String pluginPath = pluginFile.getAbsolutePath();

        //执行addAssetPath方法吧路径添加进去 assetManager才能加载资源
        Method addAssetPathMethod = assetManager.getClass().getDeclaredMethod("addAssetPath",String.class);
        addAssetPathMethod.setAccessible(true);
        addAssetPathMethod.invoke(assetManager,pluginPath);

//        //宿主的Resources
//        Resources r = getResources();
//        //创建新的resources用来加载插件中的资源
//        resources = new Resources(assetManager,r.getDisplayMetrics(),r.getConfiguration());

    }

替换宿主的classLoader，需要自定义一份寻找插件类的classLoader

public static boolean hookPackageClassLoader(Context context, ClassLoader appClassLoaderNew) {
    try {
        Field packageInfoField = Class.forName("android.app.ContextImpl").getDeclaredField("mPackageInfo");
        packageInfoField.setAccessible(true);
        Object loadedApkObject = packageInfoField.get(context);
        Class LoadedApkClass = Class.forName("android.app.LoadedApk");
        Method getClassLoaderMethod = LoadedApkClass.getDeclaredMethod("getClassLoader");
        ClassLoader appClassLoaderOld = (ClassLoader) getClassLoaderMethod.invoke(loadedApkObject);
        Field appClassLoaderField = LoadedApkClass.getDeclaredField("mClassLoader");
        appClassLoaderField.setAccessible(true);
        appClassLoaderField.set(loadedApkObject, appClassLoaderNew);
        return true;
    } catch (Throwable ignored) {
        Log.d("Cath", "hookPackageClassLoader " + ignored.getMessage());
    }
    return false;
}

如果你看到了这里，觉得文章写得不错就给个赞呗？
更多Android进阶指南 可以扫码 解锁更多Android进阶资料


敲代码不易，关注一下吧。ღ( ´･ᴗ･` )