前言
上篇文章《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 = https://www.cnblogs.com/BlueSocks/p/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 -
最后，如果覺得本文不錯，「點贊」是對我最好的肯定！
轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/464106.html
標籤：Android
上一篇：【FAQ】接入HMS Core地圖服務程序中常見問題總結
下一篇：RestSharp完全迷失了