Skip to content

Latest commit

 

History

History
253 lines (201 loc) · 13 KB

插件化.md

File metadata and controls

253 lines (201 loc) · 13 KB
Raw

什么是插件化

将一个模块单独打成apk，放在服务器上，需要进入此模块的时候再下载下来动态加载进来，然后进去此模块，这就是插件化

插件化作用

  • 早期是为了解决dex 65535问题。后来谷歌也出了multidex来专门解决
  • 懒加载可以减少软件启动时间（可能，如果那个模块初始化需要时间的话）
  • 减小安装包体积
  • 项目结构拆分，依赖完全隔离，方便多团队开发和测试，解决组件化耦合度太高的问题。（也不一定，使用模块化就能解决这个问题）
  • 动态部署
  • bug热修复（插件是放服务器上的，可以随时更换）

插件化基础：反射

在说插件化之前先得说说反射，没有反射的话，插件化寸步难行。

有一个问题，Java已经提供了public、private等可见性关键字来限制代码之间的可见性，为什么还需要提供反射这种东西？

  • 可见性是为了程序开发的简洁性，不容易写出bug，不是为了代码不被坏人使用
  • 反射的支持可以让开发者在可见性的例外场景中，突破可见性限制来调用自己需要的API，这是建立在开发者已经足够了解的情况下
  • 可见性的支持不是为了防止外来入侵，因此反射功能的支持是合理的

dex

  • class： Java编译后的文件，每个类对应一个class文件（内部类啥的也会有一个class文件）
  • dex：Dalvik Executable把class打包在一起，一个dex可以包含多个class文件
  • odex：Optimized dex针对系统的优化。（例如某个方法的调用指令，会把虚拟的调用转换为使用具体的index，这样在执行的时候就不用再查找了）
  • oat：Optimized Android file Type。使用AOT策略对dex预先编译（解释）成本地指令，这样在运行阶段就不需要再经历一次解释过程了，程序运行更快

插件化原理：动态加载

通过自定义ClassLoader来加载dex文件，从而让原本程序中没有的类可以被使用，这就是插件化。

加载插件包里面的普通类

这个比较简单，自定义一个ClassLoader，然后load该插件包。然后通过该ClassLoader去加载某个class，通过反射调用该class里面的方法。

private lateinit var dexClassLoader: DexClassLoader

fun loadPluginApk(view: View) {
    lifecycleScope.launch(Dispatchers.IO) {
        //构建一个DexClassLoader 用来加载插件包里面的class
        val inputStream = assets.open("plugin_app.apk")
        val file = File("${cacheDir}/plugin_app.apk")
        val outputStream = FileOutputStream(file)
        inputStream.copyTo(outputStream)
        dexClassLoader = DexClassLoader(file.path， cacheDir.path， null， classLoader)
    }
}

fun loadPluginApkNormalMethod(view: View) {
    //找插件里面的类，然后获取构造方法，构建对象
    val loadClazz = dexClassLoader.load("com.xfhy.pluginapkdemo.PluginPeople")
    val constructor = loadClazz.declaredConstructors[0]
    constructor.isAccessible = true
    val pluginPeople = constructor.newInstance()

    //调用对象的方法
    val printLogMethod = loadClazz.getDeclaredMethod("printLog")
    printLogMethod.isAccessible = true
    printLogMethod.invoke(pluginPeople)
}

打开插件包里面的Activity

打开Activity就比较麻烦了，需要考虑很多兼容性问题。因为Activity正常情况下是需要在清单文件中注册的，插件包里面的Activity肯定是没有在宿主App里面注册的（不然就达不到动态的特性了），那就需要在宿主清单文件里面注册一个占坑的Activity。每次打开插件包里面的Activity时，先打开这个占坑的Activity以达到欺骗AMS的目的，当通过AMS验证之后，再想个办法将占坑的Activity替换成插件包里面的Activity。也就达到了未注册Activity，也能打开Activity的效果。

这里假设待打开的Activity是TargetActivity，占坑的Activity是StubActivity。

hook IActivityManager

直接启动插件里面的Activity是不行的，通不过AMS的检查，所以需要在宿主app里面弄一个占坑的Activity，然后再hook系统流程，把StubActivity拿给AMS去检查，然后在ActivityThread这边，hook H拦截消息，在创建Activity时再替换成TargetActivity进行创建。

startActivity流程:

  • ContextImpl.startActivity->Instrumentation.execStartActivity->
  • 8.0以下 ActivityManagerNative.getDefault()->startActivity
  • 8.0以上ActivityManager.getService()->startActivity
  • 10.0以上 ActivityTaskManager.getService()->startActivity

出现三个分支，hook时需要注意一下。10.0以下都hook IActivityManager，10.0及以上hook IActivityTaskManager，一旦是有人调用startActivity方法，那么判断一下是否在调用插件内的Activity，如果是，那么先把Intent替换成StubActivity，然后继续走。

此时已经到AMS那边去了，AMS检查啥的完成之后，再通知ApplicationThread这边去创建该Activity，ApplicationThread->ActivityThread->H->handleMessage。

通过hook H的mCallback，从而知道是create Activity的时机。(9.0以前message是多个，分开的case，9.0之后是一个EXECUTE_TRANSACTION，Activity生命周期都走这一个case。这个点在处理时也需要单独处理。)

H收到这个消息时，将SubActivity还原成TargetActivity，即可实现偷天换日，瞒天过海。

以下是关键代码：

const val TARGET_INTENT = "target_intent"

fun hookAMS() {
    //此处没有处理Android 10的情况
    val defaultSingleton = if (Build.VERSION.SDK_INT >= 26) {
        //拿到IActivityManager
        val activityManagerClazz = Class.forName("android.app.ActivityManager")
        FieldUtil.getFieldValue(activityManagerClazz, null, "IActivityManagerSingleton")
    } else {
        val activityManagerNativeClazz = Class.forName("android.app.ActivityManagerNative")
        //获取ActivityManagerNative中的gDefault字段
        FieldUtil.getFieldValue(activityManagerNativeClazz, null, "gDefault")
    }

    val SingletonClazz = Class.forName("android.util.Singleton")
    val mInstanceField = FieldUtil.getField(SingletonClazz, "mInstance")
    val IActivityManager = mInstanceField.get(defaultSingleton)
    log("获取到了IActivityManager")

    //设置动态代理
    val IActivityManagerClazz = Class.forName("android.app.IActivityManager")
    val proxy =
        Proxy.newProxyInstance(Thread.currentThread().contextClassLoader, arrayOf(IActivityManagerClazz), IActivityManagerProxy(IActivityManager))
    mInstanceField.set(defaultSingleton, proxy)
    log("设置动态代理IActivityManager成功")
}

fun hookHandler() {
    //hook ActivityThread里面的H的mCallback,拦截Activity launch事件,将intent参数替换成之前保存在TARGET_INTENT里面的intent
    val ActivityThreadClazz = Class.forName("android.app.ActivityThread")
    val sCurrentActivityThread = FieldUtil.getFieldValue(ActivityThreadClazz, null, "sCurrentActivityThread")
    val mH = FieldUtil.getFieldValue(ActivityThreadClazz, sCurrentActivityThread, "mH") as Handler
    val HandlerClazz = Class.forName("android.os.Handler")
    FieldUtil.setField(HandlerClazz, mH, "mCallback", HCallback(mH))
}

class IActivityManagerProxy(private val mActivityManager: Any) : InvocationHandler {
    override fun invoke(proxy: Any?, method: Method, args: Array<Any>?): Any? {
        //如果IActivityManager的startActivity被调用
        if ("startActivity" == method.name) {
            var intent: Intent? = null
            var index = 0
            args?.forEachWithIndex { i, any ->
                if (any is Intent) {
                    intent = any
                    index = i
                }
            }
            //取出参数中的Intent中的包名  判断请求的Activity是否是插件包里面的
            intent?.component?.className?.contains("com.xfhy.pluginapkdemo")?.let {
                if (it) {
                    //如果是,那么临时将目标Activity改为占坑Activity StubActivity
                    val subIntent = Intent()
                    subIntent.setClassName("com.xfhy.allinone", "com.xfhy.allinone.actual.plugin.StubActivity")
                    //记录下来,待会儿方便 打开这个Activity
                    subIntent.putExtra(HookHelper.TARGET_INTENT, intent)
                    //Intent改好之后,还回去
                    args?.set(index, subIntent)
                }
            }
        }
        if (args != null) {
            return method.invoke(mActivityManager, *args)
        }
        return method.invoke(mActivityManager, null)
    }

}

const val LAUNCH_ACTIVITY = 100

class HCallback(private val handler: Handler) : Handler.Callback {

    //28以上是EXECUTE_TRANSACTION

    override fun handleMessage(msg: Message): Boolean {
        if (msg.what == LAUNCH_ACTIVITY) {
            val r = msg.obj
            try {
                //得到消息中的Intent(启动SubActivity的Intent)
                val intent = FieldUtil.getFieldValue(r.javaClass, r, "intent") as Intent
                //得到此前保存起来的Intent(启动TargetActivity的Intent)
                val target = intent.getParcelableExtra<Intent>(HookHelper.TARGET_INTENT)
                //为空  则不管,说明不是插件的Activity
                target?.let {
                    //将启动SubActivity的Intent替换成启动TargetActivity的Intent
                    intent.component = it.component
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        handler.handleMessage(msg)
        return true
    }
}
hook Instrumentation

上面那种方式稍微有点麻烦，这种方式清爽一些。首先ContextImpl.startActivity->Instrumentation.execStartActivity->AMS的时候用占坑Activity。然后hook Instrumentation, 在ActivityThread的performLaunchActivity里面用Instrumentation的newActivity时,替换成自己的TargetActivity。

核心代码如下：

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<ResolveInfo> infos = mPackageManager.queryIntentActivities(intent, PackageManager.MATCH_ALL);
        if (infos == null || infos.size() == 0) {
            intent.putExtra(HookHelper.TARGET_INTENsT_NAME, intent.getComponent().getClassName());//1
            intent.setClassName(who, "com.example.liuwangshu.pluginactivity.StubActivity");//2
        }
        try {
            Method execMethod = Instrumentation.class.getDeclaredMethod("execStartActivity",
                    Context.class, IBinder.class, IBinder.class, Activity.class, Intent.class, int.class, Bundle.class);
            return (ActivityResult) execMethod.invoke(mInstrumentation, who, contextThread, token,
                    target, intent, requestCode, options);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException,
        IllegalAccessException, ClassNotFoundException {
        String intentName = intent.getStringExtra(HookHelper.TARGET_INTENT_NAME);
        if (!TextUtils.isEmpty(intentName)) {
            return super.newActivity(cl, intentName, intent);
        }
        return super.newActivity(cl, className, intent);
    }
}

public static void hookInstrumentation(Context context) throws Exception {
      Class<?> contextImplClass = Class.forName("android.app.ContextImpl");
      Field mMainThreadField  =FieldUtil.getField(contextImplClass,"mMainThread");//1
      Object activityThread = mMainThreadField.get(context);//2
      Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
      Field mInstrumentationField=FieldUtil.getField(activityThreadClass,"mInstrumentation");//3
      FieldUtil.setField(activityThreadClass,activityThread,"mInstrumentation",new InstrumentationProxy((Instrumentation) mInstrumentationField.get(activityThread),
              context.getPackageManager()));
  }
小结

两种方式都需要通过占坑Activity来欺骗AMS，通过校验，然后在合适的时机再换回来。还有一个小细节上面没有说到，当Instrumentation通过反射调用TargetActivity的构造方法创建实例时，默认的PathClassLoader肯定是找不到TargetActivity这个类的，这不是宿主app里面的dex里面的类。那怎么办呢？通过热修复时学到的知识，将插件包dex放到dexElements的最前面（具体源码）。