谨慎hook，一个hook Transform源码导致的错误_failed to hook updatetransform

前言

上篇文章《总听说AGP，它到底做了什么？》和大家分析了 AGP(Android Gradle Plugin) 做了哪些事，了解到 AGP 就是为打包这个过程服务的。

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

源码走起！

一、Transform的流程

读本篇文章以前，相信同学们已经具备 Transform 的使用基础。

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

正如上图中展示的，我么可以看到：

• 在一个项目中，我们可能既会有自定义的 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);
}
1
2
3
4
5
6
7
8
9
10

虽然只有几个方法，但是每个方法的作用还挺大，先看 javac。

第二步 执行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;
}
1
2
3
4
5
6
7
8
9
10

它的方法注释：

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());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

这个 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);
    // ... 资源压缩等
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

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

第五步 为Transfrom创建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));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

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

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

关于 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

流程如图：

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

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

这个错误我最近才犯过。

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

第六步 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;
                }
            });
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

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

如果是增量编译的 Task，它会处理文件，告诉我们哪些文件变化了。

之后，就执行 Transform 的 transform 方法，整个 Transform 就结束了。

第七步 DexBuild

回到第四步，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));
    //...
}
1
2
3
4
5
6
7
8
9
10
11
12
13

DexArchiveBuilderTask 就是名为 dexBuilder 的任务，它的注释：

Task that converts CLASS files to dex archives

它就是创建 dex 文件的 Task。

如果想要对 Dex 有进一步的了解，可以阅读：

《浅谈 Android Dex 文件》

到了这一步，我们的源码分析就结束了。

三、解决问题

之前我一直说 AGP 3.x.x 的时候可以 hook 到 transformClassesWithDexBuilderForXXX 的 task，到了 AGP 4.x.x 就不行了。

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

而在 4.1.1 的代码中，这个任务交给了 DexArchiveBuilderTask，已经不是一个 Transform 了。

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

因此，得出结论，在 AGP 上，最好还是不要去 hook 源码，建议使用官方推荐的接口去处理。

总结

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

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

文章引用：

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