Replugin编译时期注入流程

2018-01-12 本文已影响94人做实事的人

Replugin编译时期注入流程

ReClassTransform核心

了解过Replugin框架的都知道编译时期会改动一些代码，比如Activity动态替换，那么来详细了解一下流程

目标：熟悉每一个细节流程，并更根据自己的需求改动。或则能自己实现一下更好。

@Override
    void transform(Context context,
                   Collection<TransformInput> inputs,
                   Collection<TransformInput> referencedInputs,
                   TransformOutputProvider outputProvider,
                   boolean isIncremental) throws IOException, TransformException, InterruptedException {

        welcome()

        /* 读取用户配置 */
        def config = project.extensions.getByName('repluginPluginConfig')


        File rootLocation = null
        try {
            rootLocation = outputProvider.rootLocation
        } catch (Throwable e) {
            //android gradle plugin 3.0.0+ 修改了私有变量，将其移动到了IntermediateFolderUtils中去
            rootLocation = outputProvider.folderUtils.getRootFolder()
        }
        if (rootLocation == null) {
            throw new GradleException("can't get transform root location")
        }
        println ">>> rootLocation: ${rootLocation}"
        // Compatible with path separators for window and Linux, and fit split param based on 'Pattern.quote'
        def variantDir = rootLocation.absolutePath.split(getName() + Pattern.quote(File.separator))[1]
        println ">>> variantDir: ${variantDir}"

        CommonData.appModule = config.appModule
        CommonData.ignoredActivities = config.ignoredActivities

        def injectors = includedInjectors(config, variantDir)
        if (injectors.isEmpty()) {
            println "injectors null"
            copyResult(inputs, outputProvider) // 跳过 reclass
        } else {
            println "injectors not null"
            doTransform(inputs, outputProvider, config, injectors) // 执行 reclass
        }
    }

代码里输出的一下日志如下，不想知道就略过

rootLocation: /Users/aniu/Downloads/RePlugin-2.2.0/replugin-sample/plugin/plugin-demo1/app/build/intermediates/transforms/ReClass/debug

variantDir: debug

上面代码一堆，但是核心的是doTransform方法，所以这个方法主要就是了解一下它的参数

void transform(Context context,
                   Collection<TransformInput> inputs,
                   Collection<TransformInput> referencedInputs,
                   TransformOutputProvider outputProvider,
                   boolean isIncremental)

五个参数

outputProvider 转换完整以后提供的输出路径参数上面的rootLocation就是里面的一个参数
inputs （可以不读：）简单来说就是你需要转换的class 与 jar的路径的集合，这里值得注意的是TransformInput这个对象，里面有两个参数，一个是jar包文件getJarInputs，一个是文件目录路径getDirectoryInputs，这里比较蛋疼的是这两个方法，都是获取出一个集合，但是transform方法里，inputs也获取出来是一个集合，为什么不直接传一个TransformInput对象呢？这里比较让人费解，不太好理解，还有TransformInput对象里面的注解中It is mostly composed of a list of {@link JarInput} and a list of {@link DirectoryInput}.，说TransformInput主要由JarInput与DirectoryInput组成，这个意思我原本以为TransformInput一定会包含JarInput与DirectoryInput的路径，但是通过自己打印验证，不是这样的，可以只有JarInput或DirectoryInput的路径，所以上面的注释估计说的是TransformInput这个类是由JarInput与DirectoryInput组成的。（必须读：）上面我啦啦啦的说了一堆，只是我在精读的时候一些思考，如果你不想理会也是可以的，应用的话很简单，就是inputs这个参数传过来就是你编译以后的class输入，这些class当然就包括你自己写的代码，和第三方jar包，然后这些肯定是你需要的东西，因为你就是想编译时期去改动你自己的代码。最后下面附上了inputs里面打印出来的路径给你参考

ClassPath:
/Users/aniu/Documents/adt-bundle-mac-x86_64-20140702/sdk/platforms/android-25/android.jar
/Users/aniu/Downloads/RePlugin-2.2.0/replugin-sample/plugin/plugin-demo1/app/build/intermediates/exploded-aar/13b7411d90986f1b83ab173b7fa3ce6d60b640ac/class
/Users/aniu/Downloads/RePlugin-2.2.0/replugin-sample/plugin/plugin-demo1/app/build/intermediates/exploded-aar/45394728b652d85f1c08991304f697dd38f11644/class
/Users/aniu/Downloads/RePlugin-2.2.0/replugin-sample/plugin/plugin-demo1/app/build/intermediates/classes/debug

referencedInputs 这个参数，不懂干嘛用的，集合也是空，查了一下也没有特别详细的讲解，如果有知道的请指导一下
isIncremental 这是一个可以改变的boolean值，重写方法以后就可以改动了。但是这个不是主要的，主要的是这个参数的意义可能很有用，因为他是用于做一些增量操作的，因为我们如果编译时期不想每次都去大批量处理class文件，就需要这样的操作，这里为什么是用不确定的语气来描述呢，那是因为目前没有一个比较好的用例来介绍怎么更好的使用。还有就是这个变量是一定需要子类来复写的。那就意味着，要做增量编译的改动，估计得自己实现核心逻辑了。说白了，这个变量没什么卵用！我不会自己加个变量来判断么？

Injectors.values().each {
            if (it.nickName in injectors) {
                println ">>> Do: ${it.nickName}"
                // 将 NickName 的第 0 个字符转换成小写，用作对应配置的名称
                def configPre = Util.lowerCaseAtIndex(it.nickName, 0)
                doInject(inputs, pool, it.injector, config.properties["${configPre}Config"])
            } else {
                println ">>> Skip: ${it.nickName}"
            }
        }

/**
     * 执行注入操作
     */
    def doInject(Collection<TransformInput> inputs, ClassPool pool,
                 IClassInjector injector, Object config) {
        try {
            inputs.each { TransformInput input ->
                input.directoryInputs.each {
                    handleDir(pool, it, injector, config)
                }
                input.jarInputs.each {
                    handleJar(pool, it, injector, config)
                }
            }
        } catch (Throwable t) {
            println t.toString()
        }
    }

传入要处理的jar文件路径以及jar包路径如下：

Handle Dir: /Users/aniu/Downloads/RePlugin-2.2.0/replugin-sample/plugin/plugin-demo1/app/build/intermediates/classes/debug

Handle Jar: /Users/aniu/.android/build-cache/a25a6da84de16636bcfa2b2b359204c3eb5d32c9/output/jars/classes.jar

/**
     * 处理目录中的 class 文件
     */
    def handleDir(ClassPool pool, DirectoryInput input, IClassInjector injector, Object config) {
        println ">>> Handle Dir: ${input.file.absolutePath}"
        injector.injectClass(pool, input.file.absolutePath, config)
    }

injectClass四大组件都有注入的实现，可以先看一下Activity的注入类：LoaderActivityInjector

 @Override
    def injectClass(ClassPool pool, String dir, Map config) {
        init()

        /* 遍历程序中声明的所有 Activity */
        //每次都new一下，否则多个variant一起构建时只会获取到首个manifest
        new ManifestAPI().getActivities(project, variantDir).each {
            // 处理没有被忽略的 Activity
            if (!(it in CommonData.ignoredActivities)) {
                handleActivity(pool, it, dir)
            }
        }
    }

继续看

/**
     * 处理 Activity
     *
     * @param pool
     * @param activity Activity 名称
     * @param classesDir class 文件目录
     */
    private def handleActivity(ClassPool pool, String activity, String classesDir) {
        def clsFilePath = classesDir + File.separatorChar + activity.replaceAll('\\.', '/') + '.class'
        if (!new File(clsFilePath).exists()) {
            return
        }

        println ">>> Handle $activity"

        def stream, ctCls
        try {
            stream = new FileInputStream(clsFilePath)
            ctCls = pool.makeClass(stream);
/*
             // 打印当前 Activity 的所有父类
            CtClass tmpSuper = ctCls.superclass
            while (tmpSuper != null) {
                println(tmpSuper.name)
                tmpSuper = tmpSuper.superclass
            }
*/
            // ctCls 之前的父类
            def originSuperCls = ctCls.superclass

            /* 从当前 Activity 往上回溯，直到找到需要替换的 Activity */
            def superCls = originSuperCls
            while (superCls != null && !(superCls.name in loaderActivityRules.keySet())) {
                // println ">>> 向上查找 $superCls.name"
                ctCls = superCls
                superCls = ctCls.superclass
            }

            // 如果 ctCls 已经是 LoaderActivity，则不修改
            if (ctCls.name in loaderActivityRules.values()) {
                // println "    跳过 ${ctCls.getName()}"
                return
            }

            /* 找到需要替换的 Activity, 修改 Activity 的父类为 LoaderActivity */
            if (superCls != null) {
                def targetSuperClsName = loaderActivityRules.get(superCls.name)
                // println "    ${ctCls.getName()} 的父类 $superCls.name 需要替换为 ${targetSuperClsName}"
                CtClass targetSuperCls = pool.get(targetSuperClsName)

                if (ctCls.isFrozen()) {
                    ctCls.defrost()
                }
                ctCls.setSuperclass(targetSuperCls)

                // 修改声明的父类后，还需要方法中所有的 super 调用。
                ctCls.getDeclaredMethods().each { outerMethod ->
                    outerMethod.instrument(new ExprEditor() {
                        @Override
                        void edit(MethodCall call) throws CannotCompileException {
                            if (call.isSuper()) {
                                if (call.getMethod().getReturnType().getName() == 'void') {
                                    call.replace('{super.' + call.getMethodName() + '($$);}')
                                } else {
                                    call.replace('{$_ = super.' + call.getMethodName() + '($$);}')
                                }
                            }
                        }
                    })
                }

                ctCls.writeFile(CommonData.getClassPath(ctCls.name))
                println "    Replace ${ctCls.name}'s SuperClass ${superCls.name} to ${targetSuperCls.name}"
            }

        } catch (Throwable t) {
            println "    [Warning] --> ${t.toString()}"
        } finally {
            if (ctCls != null) {
                ctCls.detach()
            }
            if (stream != null) {
                stream.close()
            }
        }
    }

过滤不是Activity的类
根据ManifestAPI 中的Activity对照传过来的class路径，拼装路径： def clsFilePath = classesDir + File.separatorChar + activity.replaceAll('\.', '/') + '.class'
如果路径存在就开始注入替换Activity的父类了
使用正确的class文件路径就可以利用 ctCls = pool.makeClass(stream);来获取class文件的对象实例了
superCls对象会不停向上寻找父类，比如：我们开发的时候有WelcomeActivity extends Activity ，就会去找到Activity然后替换成PluginActivity，这里有一个while的目的就是会一直找到Activity的最终父类。
ctCls.setSuperclass(targetSuperCls)这里就是替换了Activity成PluginActivity的语句，targetSuperCls有一个Activity的替换对应列表，非常的清晰明了

/* LoaderActivity 替换规则 */
    def private static loaderActivityRules = [
            'android.app.Activity'                    : 'com.qihoo360.replugin.loader.a.PluginActivity',
            'android.app.TabActivity'                 : 'com.qihoo360.replugin.loader.a.PluginTabActivity',
            'android.app.ListActivity'                : 'com.qihoo360.replugin.loader.a.PluginListActivity',
            'android.app.ActivityGroup'               : 'com.qihoo360.replugin.loader.a.PluginActivityGroup',
            'android.support.v4.app.FragmentActivity' : 'com.qihoo360.replugin.loader.a.PluginFragmentActivity',
            'android.support.v7.app.AppCompatActivity': 'com.qihoo360.replugin.loader.a.PluginAppCompatActivity',
            'android.preference.PreferenceActivity'   : 'com.qihoo360.replugin.loader.a.PluginPreferenceActivity',
            'android.app.ExpandableListActivity'      : 'com.qihoo360.replugin.loader.a.PluginExpandableListActivity'
    ]

7.最后把修改完成以后的类输出保存就完成整个替换的流程了ctCls.writeFile(CommonData.getClassPath(ctCls.name))

Replugin编译时期注入流程

Replugin编译时期注入流程

ReClassTransform核心

猜你喜欢

热点阅读