插件化笔记

2020-12-25

框架	dynamic-load-apk	DynamicAPK	Small	DroidPlugin	VirtualAPK
作者	任玉刚	携程	林光亮	360手机助手	滴滴
是否支持四大组件	只支持Activity	只支持Activity	只支持Activity	全支持	全支持
组件是否要在宿主中注册	√	×	√	√	√
插件是否可以依赖宿主	√	√	√	×	√
支持PendingIntent	×	×	×	√	√
Android特性支持	大部分	大部分	大部分	几乎全部	几乎全部
兼容性适配	一般	一般	中等	高	高
插件构建	无	部署aapt	Gradle插件	无	Gradle插件

如何加载插件的类

关于反射

反射会对性能有一定的影响：

因为在使用过程中会产生大量的临时对象，会造成GC
会检查可见性，private还是public
会生成没有优化的字节码
类型转换，封箱拆箱

关于安卓的类加载

之前写过一篇 Android虚拟机和类加载机制，这里需要补充点东西。

PathClassLoader和DexClassLoader

我们以前认为PathClassLoader只能加载已经安装到系统中的apk的一些class文件，DexClassLoader加载未安装过的jar/apk/dex。其实这种说法是不可靠的。

在8.0之前，它们唯一的区别是DexClassLoader多了一个必传参数optimizedDirectory，这个参数的意思是生成的odex(优化的dex)存放的路径。而8.0及以后，这个参数置null了，所以二者没有什么区别。

BootClassLoader和PathClassLoader

PathClassLoader的parent是BootClassLoader，而BootClassLoader没有parent。**这里parent指的是ClassLoader类型的对象，不是指的父类**！

PathClassLoader加载应用的类，像我们自己写的比如MainActivity，还有依赖的第三方库，比如Glide、AppCompatActivity ；BootClassLoader加载SD K的类，并不是说加载FrameWork的类，比如Activity属于SDK的，就是BootClassLoader加载的。

如何加载一个类

dex文件生成命令

//利用Sdk/build-tools/xxx/dx.bat工具
dx --dex --output=output.dex input.class

//比如我们有个文件com.gxh.plugin.Test.class要生成test.dex
dx --dex --output=test.dex com/gxh/plugin/Test.class


//Test代码
public class Test {
    private static void print(){
        //...
    }
}

加载上面生成的dex中的Test类

//用PathClassLoader其实也可以
DexClassLoader dexClassLoader=new DexClassLoader(
        "/sdcard/test.dex",
        MainActivity.this.getCacheDir().getAbsolutePath(),
        null,
        MainActivity.this.getClassLoader()
);
try {
    Class<?> clazz=dexClassLoader.loadClass("com.gxh.plugin.Test.class");
    Method method =clazz.getMethod("print");
    //这个参数表示这个method是哪个对象的
    //因为print是静态的，所以这里传null
    method.invoke(null);
} catch (Exception e) {
    e.printStackTrace();
}

加载插件apk中的普通类

public class LoadUtil {

    private static String apkPath="";

    public static void loadClass(Context context){
        //创建宿主的 类加载器
        ClassLoader pathClassLoader=context.getClassLoader();

        //创建插件的 类加载器
        ClassLoader dexClassLoader=new DexClassLoader(
                apkPath,
                context.getCacheDir().getAbsolutePath(),
                null,
                pathClassLoader
        );


        try {
            //BaseDexClassLoader
            Class<?> clazz=Class.forName("dalvik.system.BaseDexClassLoader");
            Field pathListField =clazz.getDeclaredField("pathList");
            pathListField.setAccessible(true);

            //宿主BaseDexClassLoader中pathList字段的值
            Object hostPathList=pathListField.get(pathClassLoader);
            //插件BaseDexClassLoader中pathList字段的值
            Object pluginPathList=pathListField.get(dexClassLoader);

            //DexPathList
            Class<?> dexPathListClass=Class.forName("dalvik.system.DexPathList");
            Field dexElementsField=dexPathListClass.getDeclaredField("dexElements");
            dexElementsField.setAccessible(true);

            //宿主DexPathList 中dexElements的值
            Object[] hostDexElements= (Object[]) dexElementsField.get(hostPathList);
            //插件DexPathList 中dexElements的值
            Object[] pluginDexElements= (Object[]) dexElementsField.get(pluginPathList);

            //合并
            Object[] newDexElements= (Object[]) Array.newInstance(hostDexElements.getClass(),hostDexElements.length+pluginDexElements.length);
            //newDexElements的赋值
            System.arraycopy(
                  hostDexElements,0,
                  newDexElements,0,hostDexElements.length
            );
            System.arraycopy(
                    pluginDexElements,0,
                    newDexElements,hostDexElements.length,pluginDexElements.length
            );

            //给hostDexElements赋新值
            dexElementsField.set(hostPathList,newDexElements);


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//使用
LoadUtil.loadClass(this);
try {
    Class<?> clazz=Class.forName("com.gxh.plugin.Test");
    Method print=clazz.getMethod("print");
    print.invoke(null);
} catch (Exception e) {
    e.printStackTrace();
}

如何启动插件的四大组件

主要实现如何利用动态代理技术Hook掉系统的AMS服务，来实现拦截Activity的启动流程，在宿主中启动插件的MainActivity。

因为MainActivity是没有在宿主清单文件注册的，AMS会检测清单文件，这个时候就会异常的，我们希望有个已经注册过的ProxyActivity替代MainActivity来进行被检测，等检测完了再用MainActivity替换掉ProxyActivity。
启动插件MainActivity

如何用ProxyActivity替代MainActivity

我们跟着startActivity(intent)看一下源码，发现在Instrumentation类的下面方法execStartActivity启动Activity的。

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    Uri referrer = target != null ? target.onProvideReferrer() : null;
    if (referrer != null) {
        intent.putExtra(Intent.EXTRA_REFERRER, referrer);
    }
    if (mActivityMonitors != null) {
        synchronized (mSync) {
            final int N = mActivityMonitors.size();
            for (int i=0; i<N; i++) {
                final ActivityMonitor am = mActivityMonitors.get(i);
                ActivityResult result = null;
                if (am.ignoreMatchingSpecificIntents()) {
                    result = am.onStartActivity(intent);
                }
                if (result != null) {
                    am.mHits++;
                    return result;
                } else if (am.match(who, null, intent)) {
                    am.mHits++;
                    if (am.isBlocking()) {
                        return requestCode >= 0 ? am.getResult() : null;
                    }
                    break;
                }
            }
        }
    }
    try {
        intent.migrateExtraStreamToClipData();
        intent.prepareToLeaveProcess(who);
        //我们找到的就是这里，重点看这里
        int result = ActivityManager.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.getService()就是IActivityManager，IActivityManager的创建是在Singleton类里。而AMS实现了IActivityManager这个接口，这里是AIDL技术，所以最终ActivityManager.getService().startActivity()就是相当于调用的AMS的startActivity()

public static IActivityManager getService() {
    return IActivityManagerSingleton.get();
}

private static final Singleton<IActivityManager> IActivityManagerSingleton =
    new Singleton<IActivityManager>() {
        @Override
        protected IActivityManager create() {
            //得到AMS的IBinder接口
            final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
            //转化成IActivityManager对象。AMS实现了这个接口，所以可以直接调用这个
            final IActivityManager am = IActivityManager.Stub.asInterface(b);
            return am;
        }
    };

综上，我们想通过动态代理去代理iActivityManager类，来拦截它的startActivity方法，修改intent，替换成宿主中已经注册的ProxyActivity。实现的代码：

public static void hookAMS() {
    try {
        // 获取 singleton 对象
        Field singletonField = null;
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { // 小于8.0
            Class<?> clazz = Class.forName("android.app.ActivityManagerNative");
            singletonField = clazz.getDeclaredField("gDefault");
        } else {
            Class<?> clazz = Class.forName("android.app.ActivityManager");
            singletonField = clazz.getDeclaredField("IActivityManagerSingleton");
        }

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

        // 获取 系统的 IActivityManager 对象
        Class<?> singletonClass = Class.forName("android.util.Singleton");
        Field mInstanceField = singletonClass.getDeclaredField("mInstance");
        mInstanceField.setAccessible(true);
        final Object mInstance = mInstanceField.get(singleton);

        Class<?> iActivityManagerClass = Class.forName("android.app.IActivityManager");

        // 创建动态代理对象
        Object proxyInstance = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class[]{iActivityManagerClass}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        /**
                         * IActivityManager类的方法
                         * startActivity(whoThread, who.getBasePackageName(), intent,
                         *                         intent.resolveTypeIfNeeded(who.getContentResolver()),
                         *                         token, target != null ? target.mEmbeddedID : null,
                         *                         requestCode, 0, null, options)
                         */
                        // 过滤
                        if ("startActivity".equals(method.getName())) {
                            int index = -1;

                            for (int i = 0; i < args.length; i++) {
                                if (args[i] instanceof Intent) {
                                    index = i;
                                    break;
                                }
                            }
                            // 启动插件的
                            Intent intent = (Intent) args[index];

                            Intent proxyIntent = new Intent();
                            proxyIntent.setClassName("com.gxh.plugin",
                                    "com.gxh.plugin.ProxyActivity");

                            proxyIntent.putExtra(TARGET_INTENT, intent);

                            args[index] = proxyIntent;
                        }

                        // args  method需要的参数  --- 不改变原有的执行流程
                        // mInstance 系统的 IActivityManager 对象
                        return method.invoke(mInstance, args);
                    }
                });

        // ActivityManager.getService() 替换成 proxyInstance
        mInstanceField.set(singleton, proxyInstance);

    } catch (Exception e) {
        e.printStackTrace();
    }
}

如何用MainActivity替换掉ProxyActivity

我们需要在AMS检测清单文件之后，在真的启动Activity之前把我们想启动的MainActivity替换回来，不然就真的启动ProxyActivity了。而启动Activity是由Handler消息机制参与的，我们看一下源码：

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

我们根据Handler的源码可以知道，当mCallback != null的时候我们可以让它进入Callback的handleMessage(msg)方法，这个方法返回false的话，还是会接着执行Handler的handleMessage(msg)方法的，这样既可以拦截到msg，也不会影响原有的执行流程。

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

而系统的Hander创建的时候是没有传入Callback的,所以我们想的办法就是创建一个Callback，来拦截系统的Handler消息流程。

1 2	//H是Handler子类 final H mH = new H();

实现的代码：

public static void hookHandler() {
    try {
        // 获取 ActivityThread 类的 Class 对象
        Class<?> clazz = Class.forName("android.app.ActivityThread");

        // 获取 ActivityThread 对象
        Field activityThreadField = clazz.getDeclaredField("sCurrentActivityThread");
        activityThreadField.setAccessible(true);
        Object activityThread = activityThreadField.get(null);

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

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

        // 创建的 callback
        Handler.Callback callback = new Handler.Callback() {

            @Override
            public boolean handleMessage(@NonNull Message msg) {
                // 通过msg  可以拿到 Intent，可以换回执行插件的Intent

                // 找到 Intent的方便替换的地方  --- 在这个类里面 ActivityClientRecord --- Intent intent 非静态
                // msg.obj == ActivityClientRecord
                switch (msg.what) {
                    case 100:
                        try {
                            Field intentField = msg.obj.getClass().getDeclaredField("intent");
                            intentField.setAccessible(true);
                            // 启动代理Intent
                            Intent proxyIntent = (Intent) intentField.get(msg.obj);
                            // 启动插件的 Intent
                            Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
                            if (intent != null) {
                                intentField.set(msg.obj, intent);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        break;
                    case 159:
                        try {
                            // 获取 mActivityCallbacks 对象
                            Field mActivityCallbacksField = msg.obj.getClass()
                                    .getDeclaredField("mActivityCallbacks");

                            mActivityCallbacksField.setAccessible(true);
                            List mActivityCallbacks = (List) mActivityCallbacksField.get(msg.obj);

                            for (int i = 0; i < mActivityCallbacks.size(); i++) {
                                if (mActivityCallbacks.get(i).getClass().getName()
                                        .equals("android.app.servertransaction.LaunchActivityItem")) {
                                    Object launchActivityItem = mActivityCallbacks.get(i);

                                    // 获取启动代理的 Intent
                                    Field mIntentField = launchActivityItem.getClass()
                                            .getDeclaredField("mIntent");
                                    mIntentField.setAccessible(true);
                                    Intent proxyIntent = (Intent) mIntentField.get(launchActivityItem);

                                    // 目标 intent 替换 proxyIntent
                                    Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
                                    if (intent != null) {
                                        mIntentField.set(launchActivityItem, intent);
                                    }
                                }
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        break;
                }
                // 必须 return false
                return false;
            }
        };

        // 替换系统的 callBack
        mCallbackField.set(mH, callback);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

如何加载插件的资源

资源加载主要包括assets、res两个目录下的。Resources 类也是通过 AssetManager 类来访问那些被编译过的应用程序资源文件的，不过在访问之前，它会先根据资源 ID 查找得到对应的资源文件名。而 AssetManager 对象既可以通过文件名访问那些被编译过的，也可以访问没有被编译过的应用程序资源文件。

raw文件夹和assets文件夹有什么区别

raw：Android会自动为这目录中的所有资源文件生成一个ID，这意味着很容易就可以访问到这个资源，甚至在xml中也可以访问，使用ID访问速度是最快的。

assets：不会生成ID，只能通过AssetManager访问，xml中不能访问，访问速度会慢些，不过操作更加方便。

加载插件的资源实现方式有两种：

插件的资源和宿主的资源直接合并，但是会造成资源id冲突，不过可以用aapt解决。
专门创建一个Resource/AssetManager加载插件的资源，这里主要介绍这种方法。

加载插件资源之错误实践

创建插件Resources

public class LoadUtil {
    private final static String apkPath = "/sdcard/plugin-debug.apk";

    public static Resources loadResource(Context context) {
        // assets.addAssetPath(key.mResDir)
        try {
            AssetManager assetManager = AssetManager.class.newInstance();
            // 让 这个 AssetManager对象 加载的 资源为插件的
            Method addAssetPathMethod = AssetManager.class.getMethod("addAssetPath", String.class);
            addAssetPathMethod.invoke(assetManager, apkPath);

            Resources resources = context.getResources();

            // 加载插件的资源的 resources
            return new Resources(assetManager, resources.getDisplayMetrics(), resources.getConfiguration());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

将插件Reources暴露给插件

public class MyApplication extends Application {

    private Resources mResources;

    @Override
    public void onCreate() {
        super.onCreate();
        mResources = LoadUtil.loadResource(this);

    }

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

3.插件中使用

//插件BaseActivity中
@Override
public Resources getResources() {
    if (getApplication() != null && getApplication().getResources() != null) {
        return getApplication().getResources();
    }
    return super.getResources();
}

至此，插件资源正常加载，但是存在以下问题：

现在宿主和插件中的Resources都是插件Resources了
现在宿主的获取到的Application是宿主的，插件自定义Application也不会执行

所以这种写法是不行滴。

接下来继续，既然Resources是给插件用，那么我们就在插件中创建行不行呢？

//放在插件中
public class LoadUtil {
    private final static String apkPath = "/sdcard/plugin-debug.apk";

    private static Resources mResources;

    public static Resources getResources(Context context) {
        if (mResources == null) {
            mResources = loadResource(context);
        }
        return mResources;
    }

    private static Resources loadResource(Context context) {
        // assets.addAssetPath(key.mResDir)
        try {
            AssetManager assetManager = AssetManager.class.newInstance();
            // 让 这个 AssetManager对象 加载的 资源为插件的
            Method addAssetPathMethod = AssetManager.class.getMethod("addAssetPath", String.class);
            addAssetPathMethod.invoke(assetManager, apkPath);

            Resources resources = context.getResources();

            // 加载插件的资源的 resources
            return new Resources(assetManager, resources.getDisplayMetrics(), resources.getConfiguration());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

//插件中BaseActivity中
@Override
public Resources getResources() {
    Resources resources = LoadUtil.getResources(getApplication());
    // 如果插件作为一个单独的app，返回 super.getResources()
    return resources == null ? super.getResources() : resources;
}

这种方式可以解决上面存在的两种问题，但是会出现新的问题，就是资源冲突，所以不行。

加载插件资源之正确实践

创建插件Resources

public class LoadUtil {
    private final static String apkPath = "/sdcard/plugin-debug.apk";

    private static Resources mResources;

    public static Resources getResources(Context context) {
        if (mResources == null) {
            mResources = loadResource(context);
        }
        return mResources;
    }

    private static Resources loadResource(Context context) {
        // assets.addAssetPath(key.mResDir)
        try {
            AssetManager assetManager = AssetManager.class.newInstance();
            // 让 这个 AssetManager对象 加载的 资源为插件的
            Method addAssetPathMethod = AssetManager.class.getMethod("addAssetPath", String.class);
            addAssetPathMethod.invoke(assetManager, apkPath);

            Resources resources = context.getResources();

            // 加载插件的资源的 resources
            return new Resources(assetManager, resources.getDisplayMetrics(), resources.getConfiguration());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

创建插件Context

Resources resources = LoadUtil.getResources(getApplication());
mContext = new ContextThemeWrapper(getBaseContext(), 0);

Class<? extends Context> clazz = mContext.getClass();
try {
    Field mResourcesField = clazz.getDeclaredField("mResources");
    mResourcesField.setAccessible(true);
    mResourcesField.set(mContext, resources);
} catch (Exception e) {
    e.printStackTrace();
}

使用

public class MainActivity extends BaseActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //mContext是我们创建的插件的Context
        View view = LayoutInflater.from(mContext).inflate(R.layout.activity_main, null);
        setContentView(view);
    }
}

结束语

圣诞节快乐！

黑白了落夜

插件化笔记

相关概念

插件化是怎么出现的

插件化优势

插件化相关概念

插件化与动态更新

插件化框架介绍