关于android:Androidhook很危险使用需谨慎

上篇文章《Android 安卓进阶技术分享之 AGP 工作原理》和大家剖析了 AGP(Android Gradle Plugin) 做了哪些事，理解到 AGP 就是为打包这个过程服务的。

那么，本篇文章就和大家聊一聊其中的 Transform，解决一下为什么在 AGP 3.x.x 的版本能够通过反射获取的 transformClassesWithDexBuilderForXXX Task 在 4.0.0 的版本就不灵了？

源码走起！

读本篇文章以前，置信同学们曾经具备 Transform 的应用根底。

置信很多人都看过这张图：

Transform 过程

正如上图中展现的，咱们能够看到：

• 在一个我的项目中，咱们可能既会有自定义的 Transform，也会有零碎的 Transform。

• 在处理过程中，每一个 Transform 的承受流都是接管到上一个 Transform 的输入流，原始的文件流会通过很多 Transform 的解决。

既然咱们曾经理解了整体的流程，再来看一下其中的细节吧。

咱们都晓得，应用 Transform 的目标，是为了批改其中的字节码，那么，这些 Class 文件是哪里来的呢？

间接关上 AGP 的源码，间接跳到创立编译 Task 的时候，这个办法产生在 AGP 创立跟 Variant 相干的 Task 的时候，在 AbstractAppTaskManager 里：

private void createCompileTask(@NonNull VariantPropertiesImpl variantProperties) {ApkCreationConfig apkCreationConfig = (ApkCreationConfig) variantProperties;  
    // 执行 javac  
    TaskProvider<? extends JavaCompile> javacTask = createJavacTask(variantProperties);  
    // 增加 Class 输出流  
    addJavacClassesStream(variantProperties);  
    setJavaCompilerTask(javacTask, variantProperties);  
    // 执行 transform 和 dex 相干的工作  
    createPostCompilationTasks(apkCreationConfig);  
}

尽管只有几个办法，然而每个办法的作用还挺大，先看 javac。

大家对 javac 的命令必定很相熟，它能够将 .java 文件转化成 .class 文件。这个办法的确也是这样：

public TaskProvider<? extends JavaCompile> createJavacTask(@NonNull ComponentPropertiesImpl componentProperties) {  
    // Java 预编译工作，看了一下，次要是解决 Java 注解  
    taskFactory.register(new JavaPreCompileTask.CreationAction(componentProperties));  
    // Java 编译工作  
    final TaskProvider<? extends JavaCompile> javacTask =  
            taskFactory.register(new JavaCompileCreationAction(componentProperties));  
    postJavacCreation(componentProperties);  
    return javacTask;  
}

它的办法正文：

❝

Creates the task for creating *.class files using javac. These tasks are created regardless of whether Jack is used or not, but assemble will not depend on them if it is. They are always used when running unit tests.

❞

很显著，就是为了创立 .class 文件。

这一步中，最重要的一步就是注册了一个名叫 JavaCompile 的工作，也就是将 Java 文件和 Java 注解转变成 .class 的 Task。

JavaCompile 的 Task 的代码比拟绕，间接跟大家说后果了，最终是调用 JDK 上面的 JavaCompiler 类，动静将 .java 转化成 .class 文件。

当然，不仅仅只有 .class 文件，还有其余的诸如 .kt 和 .jar 等，都须要特定的 Task，能力转化成咱们须要的输出源。

回到第一步，进入 addJavacClassesStream 办法：

protected void addJavacClassesStream(@NonNull ComponentPropertiesImpl componentProperties) {  
    // create separate streams for the output of JAVAC and for the pre/post javac  
    // bytecode hooks  
    TransformManager transformManager = componentProperties.getTransformManager();  
    boolean needsJavaResStreams =  
            componentProperties.getVariantScope().getNeedsJavaResStreams();  
    transformManager.addStream(OriginalStream.builder(project, "javac-output")  
                    // Need both classes and resources because some annotation  
                    // processors generate resources  
                    .addContentTypes(  
                            needsJavaResStreams  
                                    ? TransformManager.CONTENT_JARS  
                                    : ImmutableSet.of(DefaultContentType.CLASSES))  
                    .addScope(Scope.PROJECT)  
                    .setFileCollection(project.getLayout().files(javaOutputs))  
                    .build());  
    BaseVariantData variantData = componentProperties.getVariantData();  
    transformManager.addStream(OriginalStream.builder(project, "pre-javac-generated-bytecode")  
                    .addContentTypes(  
                            needsJavaResStreams  
                                    ? TransformManager.CONTENT_JARS  
                                    : ImmutableSet.of(DefaultContentType.CLASSES))  
                    .addScope(Scope.PROJECT)  
                    .setFileCollection(variantData.getAllPreJavacGeneratedBytecode())  
                    .build());  
    transformManager.addStream(OriginalStream.builder(project, "post-javac-generated-bytecode")  
                    .addContentTypes(  
                            needsJavaResStreams  
                                    ? TransformManager.CONTENT_JARS  
                                    : ImmutableSet.of(DefaultContentType.CLASSES))  
                    .addScope(Scope.PROJECT)  
                    .setFileCollection(variantData.getAllPostJavacGeneratedBytecode())  
                    .build());  
}

这个 transformManager 就是解决 Transform 的，它在建设第一个 Transform 的原始数据流。

仔细的同学可能发现了，第一个数据流的 contentType 至多也是 DefaultContentType.CLASSES，scope 是 Scope.PROJECT，自定义过 Transform 的同学必定晓得，这样设置咱们自定义的 Transform 可能接管到原始数据流。

回到第一步中的 createPostCompilationTasks 办法，它用来创立编译后的工作：

public void createPostCompilationTasks(@NonNull ApkCreationConfig creationConfig) {  
    //...  
    TransformManager transformManager = componentProperties.getTransformManager();  
    // ...  
    // java8 脱糖  
    maybeCreateDesugarTask(  
            componentProperties,  
            componentProperties.getMinSdkVersion(),  
            transformManager,  
            isTestCoverageEnabled);  
    BaseExtension extension = componentProperties.getGlobalScope().getExtension();  
    // Merge Java Resources.  
    createMergeJavaResTask(componentProperties);  
    // ----- External Transforms -----  
    // apply all the external transforms.  
    List<Transform> customTransforms = extension.getTransforms();  
    List<List<Object>> customTransformsDependencies = extension.getTransformsDependencies();  
    boolean registeredExternalTransform = false;  
    for (int i = 0, count = customTransforms.size(); i < count; i++) {Transform transform = customTransforms.get(i);  
  
        List<Object> deps = customTransformsDependencies.get(i);  
        registeredExternalTransform |=  
                transformManager  
                        .addTransform(  
                                taskFactory,  
                                componentProperties,  
                                transform,  
                                null,  
                                task -> {if (!deps.isEmpty()) {task.dependsOn(deps);  
                                    }  
                                },  
                                taskProvider -> {  
                                    // if the task is a no-op then we make assemble task depend on it.  
                                    if (transform.getScopes().isEmpty()) {  
                                        TaskFactoryUtils.dependsOn(  
                                                componentProperties  
                                                        .getTaskContainer()  
                                                        .getAssembleTask(),  
                                                taskProvider);  
                                    }  
                                })  
                        .isPresent();}  
  
    // Add a task to create merged runtime classes if this is a dynamic-feature,  
    // or a base module consuming feature jars. Merged runtime classes are needed if code  
    // minification is enabled in a project with features or dynamic-features.  
    if (componentProperties.getVariantType().isDynamicFeature()  
            || variantScope.consumesFeatureJars()) {taskFactory.register(new MergeClassesTask.CreationAction(componentProperties));  
    }  
    // ----- Minify next -----  
    // 混同  
    // ----- Multi-Dex 反对...  
    // 创立 dex  
    createDexTasks(creationConfig, componentProperties, dexingType, registeredExternalTransform);  
    // ... 资源压缩等  
}

在进行 Transform 之前，它还会进行一些 java8 的脱糖以及合并 java 资源的 Task，这些都是会被增加到原始的数据流中。

首先，咱们得明确，每一种 Transform 其实有两种类型：

1. 消费型 ：须要将数据源输入给下一个 Transform。

2. 援用型 ：只须要读取，不须要输入。

接下来就到了咱们关怀的解决 Transform 的逻辑了。

从下面的办法咱们能够看出，零碎会为咱们找到所有曾经在 BaseExtension 注册的 Transform 并遍历，应用 transformManager 通过 addTransform 做解决:

public <T extends Transform> Optional<TaskProvider<TransformTask>> addTransform(  
        @NonNull TaskFactory taskFactory,  
        @NonNull ComponentPropertiesImpl componentProperties,  
        @NonNull T transform,  
        @Nullable PreConfigAction preConfigAction,  
        @Nullable TaskConfigAction<TransformTask> configAction,  
        @Nullable TaskProviderCallback<TransformTask> providerCallback) {  
    //... 省略  
    List<TransformStream> inputStreams = Lists.newArrayList();  
    String taskName = componentProperties.computeTaskName(getTaskNamePrefix(transform));  
    // get referenced-only streams  
    List<TransformStream> referencedStreams = grabReferencedStreams(transform);  
    // find input streams, and compute output streams for the transform.  
    IntermediateStream outputStream =  
            findTransformStreams(  
                    transform,  
                    componentProperties,  
                    inputStreams,  
                    taskName,  
                    componentProperties.getGlobalScope().getBuildDir());  
    // ... 检测工作  
    transforms.add(transform);  
    TaskConfigAction<TransformTask> wrappedConfigAction =  
            t -> {t.getEnableGradleWorkers()  
                        .set(  
                                componentProperties  
                                        .getGlobalScope()  
                                        .getProjectOptions()  
                                        .get(BooleanOption.ENABLE_GRADLE_WORKERS));  
                if (configAction != null) {configAction.configure(t);  
                }  
            };  
    // create the task...  
    return Optional.of(  
            taskFactory.register(  
                    new TransformTask.CreationAction<>(componentProperties.getName(),  
                            taskName,  
                            transform,  
                            inputStreams,  
                            referencedStreams,  
                            outputStream,  
                            recorder),  
                    preConfigAction,  
                    wrappedConfigAction,  
                    providerCallback));  
}

这里呢，先定义了一个 taskName，规定是：

transform${inputType}With${transformName}For${BuildType}

对于 taskName 规定先放这儿，前面咱们会用到！

下面代码中的 referencedStreams 用来解决援用型的 Transform，所以咱们着重看 outputStream，outputStream 是通过办法 findTransformStreams 办法生成的，对于数据流向的问题这个办法外面讲的特地明确：

private final List<TransformStream> streams = Lists.newArrayList();  
private IntermediateStream findTransformStreams(  
        @NonNull Transform transform,  
        @NonNull ComponentPropertiesImpl componentProperties,  
        @NonNull List<TransformStream> inputStreams,  
        @NonNull String taskName,  
        @NonNull File buildDir) {  
    //...  
    // 生产数据流，inputStreams 增加须要生产的数据流  
    // 1. inputStreams 会生产掉 streams 能够生产的数据流  
    consumeStreams(requestedScopes, requestedTypes, inputStreams);  
  
    Set<ContentType> outputTypes = transform.getOutputTypes();  
    File outRootFolder =  
            FileUtils.join(  
                    buildDir,  
                    StringHelper.toStrings(  
                            AndroidProject.FD_INTERMEDIATES,  
                            FD_TRANSFORMS,  
                            transform.getName(),  
                            componentProperties.getVariantDslInfo().getDirectorySegments()));  
    // 创立输入流  
    IntermediateStream outputStream =  
            IntermediateStream.builder(  
                    project,  
                    transform.getName() + "-" + componentProperties.getName(),  
                    taskName)  
                    .addContentTypes(outputTypes)  
                    .addScopes(requestedScopes)  
                    .setRootLocation(outRootFolder)  
                    .build();  
    // 2. 为下一个 Transform 增加生成的数据流  
    streams.add(outputStream);  
    return outputStream;  
}

流程如图：

数据生产

意思就是每一个 Transform 都要走一遍图中的流程，对于大部分 Transform 来说，每一个的输出源就是上一个 Transform 的输入源。

所以对于开发者来说，如果咱们定义 Transform 却不将生成的文件增加到输入目录，这就会导致前面的 Transform 找不到输出源，编译器就只能报错了。

这个谬误我最近才犯过。

回到这一步的开始，taskFactory 最终为咱们注册了一个 TransformTask。

进入 TransformTask 这个类，外面有一个办法 transform 增加了 @TaskAction 注解，所以，一旦该 Task 执行了，这个办法就会被调用。

@TaskAction  
void transform(final IncrementalTaskInputs incrementalTaskInputs)  
        throws IOException, TransformException, InterruptedException {  
  
    // 设置增量编译  
    isIncremental.setValue(transform.isIncremental() && incrementalTaskInputs.isIncremental());  
    // ...  
    recorder.record(  
            ExecutionType.TASK_TRANSFORM_PREPARATION,  
            preExecutionInfo,  
            getProjectPath().get(),  
            getVariantName(),  
            new Recorder.Block<Void>() {  
                @Override  
                public Void call() throws Exception {  
                    // ... 针对增量编译对文件解决  
                    return null;  
                }  
            });  
    GradleTransformExecution executionInfo =  
            preExecutionInfo.toBuilder().setIsIncremental(isIncremental.getValue()).build();  
    recorder.record(  
            ExecutionType.TASK_TRANSFORM,  
            executionInfo,  
            getProjectPath().get(),  
            getVariantName(),  
            new Recorder.Block<Void>() {  
                @Override  
                public Void call() throws Exception {  
                    // ...  
                    transform.transform(new TransformInvocationBuilder(context)  
                                    .addInputs(consumedInputs.getValue())  
                                    .addReferencedInputs(referencedInputs.getValue())  
                                    .addSecondaryInputs(changedSecondaryInputs.getValue())  
                                    .addOutputProvider(  
                                            outputStream != null  
                                                    ? outputStream.asOutput()  
                                                    : null)  
                                    .setIncrementalMode(isIncremental.getValue())  
                                    .build());  
  
                    if (outputStream != null) {outputStream.save();  
                    }  
                    return null;  
                }  
            });  
}

recorder 不必管，它只是一个执行器，最终会执行 Block 中的代码。

如果是增量编译的 Task，它会解决文件，通知咱们哪些文件变动了。

之后，就执行 Transform 的 transform 办法，整个 Transform 就完结了。

回到第四步，AGP 会咱们先后注册了混同和多 Dex 反对的 Task，之后就到了创立 Dex 的 Task：

private void createDexTasks(  
        @NonNull ApkCreationConfig apkCreationConfig,  
        @NonNull ComponentPropertiesImpl componentProperties,  
        @NonNull DexingType dexingType,  
        boolean registeredExternalTransform) {  
    // ...  
    taskFactory.register(  
            new DexArchiveBuilderTask.CreationAction(  
                    dexOptions,  
                    enableDexingArtifactTransform,  
                    componentProperties));  
    //...  
}

DexArchiveBuilderTask 就是名为 dexBuilder 的工作，它的正文：

❝

Task that converts CLASS files to dex archives

❞

它就是创立 dex 文件的 Task。

如果想要对 Dex 有进一步的理解，能够浏览：

❝

《浅谈 Android Dex 文件》

https://tech.youzan.com/qian-…

❞

到了这一步，咱们的源码剖析就完结了。

之前我始终说 AGP 3.x.x 的时候能够 hook 到 transformClassesWithDexBuilderForXXX 的 task，到了 AGP 4.x.x 就不行了。

Transform

认真看一下我下面提到 taskName 命名规定，就会发现，在 3.x.x 之前，transformClassesWithDexBuilderForXXX 其实是一个 Transform，我记得对应的类 DexTransform，它会帮忙 AGP 生成 .dex 文件。

而在 4.1.1 的代码中，这个工作交给了 DexArchiveBuilderTask，曾经不是一个 Transform 了。

所以啊，常常看到安卓开发者骂骂咧咧的说：卧槽，AGP 版本升级了，我的这个办法不能用了！

因而，得出结论，在 AGP 上，最好还是不要去 hook 源码，倡议应用官网举荐的接口去解决。

本篇文章的内容其实是对下面 Transform 流程的验证，置信大家曾经对 Transform 流程有了整体的把握！

如有什么争议的内容，欢送评论区留言，如果感觉本文不错，「点赞」是对本文最大的必定！

文章援用：

❝

《一起玩转 Android 我的项目中的字节码》

❞

转自：九心

– EOF –

最初，如果感觉本文不错，「点赞」是对我最好的必定！

关于android:Androidhook很危险使用需谨慎

前言

Transform 的流程

Transform 源码剖析

第一步 Transform 的终点

第二步执行 javac

第三步建设原始的输出流

第四步创立编译后的工作

第五步为 Transfrom 创立 Task

第六步 TransformTask 做了什么

第七步 DexBuild

解决问题

总结

Just My Socks（注册教程内含优惠码）

关于android:Androidhook很危险使用需谨慎

前言

Transform 的流程

Transform 源码剖析

第一步 Transform 的终点

第二步 执行 javac

第三步 建设原始的输出流

第四步 创立编译后的工作

第五步 为 Transfrom 创立 Task

第六步 TransformTask 做了什么

第七步 DexBuild

解决问题

总结

Just My Socks（注册教程 内含优惠码）

第二步执行 javac

第三步建设原始的输出流

第四步创立编译后的工作

第五步为 Transfrom 创立 Task

Just My Socks（注册教程内含优惠码）