Android：hook很“危險”，使用需謹慎。

前言上篇文章《Android安卓進階技術分享之AGP工作原理》和大家分析了 AGP(Android Gradle Plugin) 做了哪些事，瞭解到 AGP 就是為打包這個過程服務的。那麼，本篇文章就和大家聊一聊其中的 Transform，解決一下為什麼在 AGP 3.x.x 的版本可以通過反射 ...

前言

上篇文章《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 的處理。

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

大家對 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，這些都是會被添加到原始的數據流中。

第五步為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));  
}

這裡呢，先定義了一個 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做了什麼

進入 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 就結束了。

第七步 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));  
    //...  
}

DexArchiveBuilderTask 就是名為 dexBuilder 的任務，它的註釋：

❝

Task that converts CLASS files to dex archives

❞

它就是創建 dex 文件的 Task。

如果想要對 Dex 有進一步的瞭解，可以閱讀：

❝

《淺談 Android Dex 文件》

https://tech.youzan.com/qian-tan-android-dexwen-jian/

❞

到了這一步，我們的源碼分析就結束了。

解決問題

之前我一直說 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 -

最後，如果覺得本文不錯，「點贊」是對我最好的肯定！