深入学习-Gradle-自动化构建技术（四）自定义-Gradle-插件

writer.append(line + ‘\r\n’)
} else if (index == lengths) {
writer.append(‘\r\r\n’ + sw.toString() + ‘\r\n’)
writer.append(lines.get(tlengths))
}
}
}
}
}
}

首先，在注释1处，我们 在构造器中配置了该 Task 对应的 Task group，即 Task 组，并为其添加上了对应的描述信息。接着，在注释2处，我们 使用了 @TaskAction 注解标注了 doAction 方法，这样它就会在 gradle 执行阶段执行。在注释3处，我们 使用了 project.extensions.releaseInfo.xxx 一系列 API 从 realeaseInfo Extension 属性中了获取相应的版本信息。最后，注释4处，就是用来 实现该 task 的核心功能，即将实体对象写入到 xml 文件中。

可以看到，一般的插件 task 都会遵循前三个步骤，最后一个步骤就是用来实现插件的核心功能。

当然，最后别忘了在我们的 CustomGradlePlugin 的 apply 方法中加入下面代码去创建 ReleaseInfoTask 实例，代码如下所示：

// 创建用于更新版本信息的 task
project.tasks.create(“releaseInfoTask”, ReleaseInfoTask.class)

四、变体（Variants）的作用

要理解 Variants 的作用，就必须先了解 flavor、dimension 与 variant 这三者之间的关系。在 android gradle plugin V3.x 之后，每个 flavor 必须对应一个 dimension，可以理解为 flavor 的分组，然后不同 dimension 里的 flavor 会组合成一个 variant。示例代码如下所示：

flavorDimensions “size”, “color”

productFlavors {
JsonChao {
dimension “size”
}
small {
dimension “size”
}
blue {
dimension “color”
}
red {
dimension “color”
}
}

在 Android 对 Gradle 插件的扩展支持之中，其中最常用的便是 利用变体（Variants）来对构建过程中的各个默认的 task 进行 hook。关于 Variants 共有 三种类型，如下所示：

• 1）、applicationVariants：只适用于 app plugin。
• 2）、libraryVariants：只适用于 library plugin。
• 3）、testVariants：在 app plugin 与 libarary plugin 中都适用。

1、使用 applicationVariants

为了讲解 applicationVariants 的作用，我们需要先在 app moudle 的 build.gradle 文件中配置几个 flavor，代码如下所示：

productFlavors {
douyin {}
weixin {}
google {}
}

1、使用 applicationVariants.all 在配置阶段之后去获取所有 variant 的 name 与 baseName

然后，我们可以 使用 applicationVariants.all 在配置阶段之后去获取所有 variant 的 name 与 baseName。代码如下所示：

this.afterEvaluate {
this.android.applicationVariants.all { variant ->
def name = variant.name
def baseName = variant.baseName
println “name: $name, baseName: $baseName”
}
}

最后，执行 gradle clean task，其输出信息如下所示：

Configure project :app
name: douyinDebug, baseName: douyin-debug
name: douyinRelease, baseName: douyin-release
name: weixinDebug, baseName: weixin-debug
name: weixinRelease, baseName: weixin-release
name: googleDebug, baseName: google-debug
name: googleRelease, baseName: google-release

可以看到，name 与 baseName 的区别：baiduDebug 与 baidu-debug 。

2、使用 applicationVariants.all 在配置阶段之后去修改输出的 APK 名称

this.afterEvaluate {
this.android.applicationVariants.all { variant ->
variant.outputs.each {
// 由于我们当前的变体是 application 类型的，所以
// 这个 output 就是我们 APK 文件的输出路径，我们
// 可以通过重命名这个文件来修改我们最终输出的 APK 文件
outputFileName = “app-$variant.baseName-${variant.versionName}.apk”
println outputFileName
}
}
}

执行 gradle clean task，其输出信息如下所示：

Configure project :app
app-debug-1.0.apk
app-release-1.0.apk

3、对 applicationVariants 中的 Task 进行 Hook

我们可以在 android.applicationVariants.all 的闭包中通过 variant.task 来获取相应的 Task。代码如下所示：

this.afterEvaluate {
this.android.applicationVariants.all { variant ->
def task = variant.checkManifest
println task.name
}
}

然后，执行 gradle clean task，其输出信息如下所示：

checkDebugManifest
checkReleaseManifest

既然可以获取到变体中的 Task，我们就可以根据不同的 Task 类型来做特殊处理。例如，我们可以利用 variants 去解决插件化开发中的痛点：编写一个对插件化项目中的各个插件自动更新的脚本，其核心代码如下所示：

this.afterEvaluate {
this.android.applicationVariants.all { variant ->
// checkManifest 这个 Task 在 Task 容器中
// 靠前的位置，我们可以在这里预先更新插件。
def checkTask = variant.checkManifest
checkTask.doFirst {
def bt = variant.buildType.name
if (bt == ‘qa’ || bt == ‘preview’
|| bt == ‘release’) {
update_plugin(bt)
}
}
}
}

至于 update_plugin 的实现，主要就是一些插件安全校验与下载的逻辑，这部分其实跟 Gradle 没有什么联系，如果有需要，可以在 Awesome-WanAndroid 项目下查看。

五、Transform

众所周知，Google 官方在 Android Gradle V1.5.0 版本以后提供了 Transfrom API, 允许第三方 Plugin 在打包成 .dex 文件之前的编译过程中操作 .class 文件，我们需要做的就是实现 Transform 来对 .class 文件遍历以拿到所有方法，修改完成后再对原文件进行替换即可。

总的来说，Gradle Transform 的功能就是把输入的 .class 文件转换为目标字节码文件。

下面，我们来了解一下 Transform 的两个基础概念。

1、TransformInput

TransformInput 可认为是所有输入文件的一个抽象，它主要包括两个部分，如下所示：

• 1）、DirectoryInput 集合：表示以源码方式参与项目编译的所有目录结构与其目录下的源码文件。
• 2）、JarInput 集合：表示以 jar 包方式参与项目编译的所有本地 jar 包和远程 jar 包。需要注意的是，这个 jar 所指也包括 aar。

2、TransformOutputProvider

表示 Transform 的输出，利用它我们可以 获取输出路径等信息。

3、实现 Transform

1、首先，配置 Android DSL 相关的依赖：

// 由于 buildSrc 的执行时机要早于任何一个 project，因此需要⾃⼰添加仓库
repositories {
google()
jcenter()
}

dependencies {
// Android DSL
implementation ‘com.android.tools.build:gradle:3.6.2’
}

2、然后，继承 com.android.build.api.transform.Transform ，创建⼀个 Transform 的子类：

其创建步骤可以细分为五步，如下所示：

• 1）、重写 getName 方法：返回对应的 Task 名称。
• 2）、重写 getInputTypes 方法：确定对那些类型的结果进行转换。
• 3）、重写 getScopes 方法：指定插件的适用范围。
• 4）、重写 isIncremental 方法：表示是否支持增量更新。
• 5）、重写 transform 方法：进行具体的转换过程。

下面👇，我们来分别来进行详细讲解。

1、重写 getName 方法：返回对应的 Task 名称

每一个 Transform 都有一个与之对应的 Transform task，这里便是返回的 task name。它会出现在 app/build/intermediates/transforms 目录下。其代码如下所示：

/**

• 每一个 Transform 都有一个与之对应的 Transform task，
• 这里便是返回的 task name。它会出现在
• app/build/intermediates/transforms 目录下
• @return Transform Name
  */
  @Override
  String getName() {
  return “MyCustomTransform”
  }

2、重写 getInputTypes 方法：确定对那些类型的结果进行转换

getInputTypes 方法用于确定我们需要对哪些类型的结果进行转换：如字节码、资源⽂件等等。目前 ContentType 有六种枚举类型，通常我们使用比较频繁的有前两种，如下所示：

• 1、CONTENT_CLASS：表示需要处理 java 的 class 文件。
• 2、CONTENT_JARS：表示需要处理 java 的 class 与 资源文件。
• 3、CONTENT_RESOURCES：表示需要处理 java 的资源文件。
• 4、CONTENT_NATIVE_LIBS：表示需要处理 native 库的代码。
• 5、CONTENT_DEX：表示需要处理 DEX 文件。
• 6、CONTENT_DEX_WITH_RESOURCES：表示需要处理 DEX 与 java 的资源文件。

因为我们需要修改的是字节码，所以直接返回 TransformManager.CONTENT_CLASS 即可，代码如下所示：

/**

• 需要处理的数据类型，目前 ContentType
• 有六种枚举类型，通常我们使用比较频繁的有前两种：

•  1、CONTENT_CLASS：表示需要处理 java 的 class 文件。
  

•  2、CONTENT_JARS：表示需要处理 java 的 class 与 资源文件。
  

•  3、CONTENT_RESOURCES：表示需要处理 java 的资源文件。
  

•  4、CONTENT_NATIVE_LIBS：表示需要处理 native 库的代码。
  

•  5、CONTENT_DEX：表示需要处理 DEX 文件。
  

•  6、CONTENT_DEX_WITH_RESOURCES：表示需要处理 DEX 与 java 的资源文件。 
  

• @return
  */
  @Override
  Set<QualifiedContent.ContentType> getInputTypes() {
  // 用于确定我们需要对哪些类型的结果进行转换：如字节码、资源⽂件等等。
  // return TransformManager.RESOURCES
  return TransformManager.CONTENT_CLASS
  }

3、重写 getScopes 方法：指定插件的适用范围

getScopes 方法则是用于确定插件的适用范围：目前 Scope 有 五种基本类型，如下所示：

• 1、PROJECT：只有项目内容。
• 2、SUB_PROJECTS：只有子项目。
• 3、EXTERNAL_LIBRARIES：只有外部库，
• 4、TESTED_CODE：由当前变体（包括依赖项）所测试的代码。
• 5、PROVIDED_ONLY：只提供本地或远程依赖项。

此外，还有一些复合类型，它们是都是由这五种基本类型组成，以实现灵活确定自定义插件的范围，这里通常是指定整个 project，也可以指定其它范围，其代码如下所示：

/**

• 表示 Transform 要操作的内容范围，目前 Scope 有五种基本类型：

•  1、PROJECT                   只有项目内容
  

•  2、SUB_PROJECTS              只有子项目
  

•  3、EXTERNAL_LIBRARIES        只有外部库
  

•  4、TESTED_CODE               由当前变体（包括依赖项）所测试的代码
  

•  5、PROVIDED_ONLY             只提供本地或远程依赖项
  

•  SCOPE_FULL_PROJECT 是一个 Scope 集合，包含 Scope.PROJECT,
  

Scope.SUB_PROJECTS, Scope.EXTERNAL_LIBRARIES 这三项，即当前 Transform
的作用域包括当前项目、子项目以及外部的依赖库
*

• @return
  */
  @Override
  Set<? super QualifiedContent.Scope> getScopes() {
  // 适用范围：通常是指定整个 project，也可以指定其它范围
  return TransformManager.SCOPE_FULL_PROJECT
  }

4、重写 isIncremental 方法：表示是否支持增量更新

isIncremental 方法用于确定是否支持增量更新，如果返回 true，TransformInput 会包含一份修改的文件列表，如果返回 false，则会进行全量编译，并且会删除上一次的输出内容。

@Override
boolean isIncremental() {
// 是否支持增量更新
// 如果返回 true，TransformInput 会包含一份修改的文件列表
// 如果返回 false，会进行全量编译，删除上一次的输出内容
return false
}

5、重写 transform 方法：进行具体的转换过程

在 transform 方法中，就是用来给我们进行具体的转换过程的。其实现代码如下所示：

/**

• 进行具体的转换过程
• @param transformInvocation
  */
  @Override
  void transform(TransformInvocation transformInvocation) throws
  TransformException, InterruptedException, IOException {
  super.transform(transformInvocation)
  println '--------------- MyTransform visit start --------------- ’
  def startTime = System.currentTimeMillis()
  def inputs = transformInvocation.inputs
  def outputProvider = transformInvocation.outputProvider
  // 1、删除之前的输出
  if (outputProvider != null)
  outputProvider.deleteAll()
  // Transform 的 inputs 有两种类型，一种是目录，一种是 jar
  包，要分开遍历
  inputs.each { TransformInput input ->
  // 2、遍历 directoryInputs（本地 project 编译成的多个 class
  ⽂件存放的目录）
  input.directoryInputs.each { DirectoryInput directoryInput ->
  handleDirectory(directoryInput, outputProvider)
  }
  // 3、遍历 jarInputs（各个依赖所编译成的 jar 文件）
  input.jarInputs.each { JarInput jarInput ->
  handleJar(jarInput, outputProvider)
  }
  }
  def cost = (System.currentTimeMillis() - startTime) / 1000
  println '--------------- MyTransform visit end --------------- ’
  println “MyTransform cost ： $cost s”
  }

这里我们主要是做了三步处理，如下所示：

• 1）、删除之前的输出。
• 2）、遍历 directoryInputs（本地 project 编译成的多个 class ⽂件存放的目录）。
• 3）、遍历 jarInputs（各个依赖所编译成的 jar 文件）。

在 handleDirectory 与 handleJar 方法中则是进行了相应的 文件处理 && ASM 字节码修改。这里我直接放出 Transform 的通用模板代码，代码如下所示：

class MyTransform extends Transform {

/**

• 每一个 Transform 都有一个与之对应的 Transform task，
• 这里便是返回的 task name。它会出现在 app/build/intermediates/transforms 目录下
• @return Transform Name
  */
  @Override
  String getName() {
  return “MyCustomTransform”
  }

/**

• 需要处理的数据类型，目前 ContentType 有六种枚举类型，通常我们使用比较频繁的有前两种：

•  1、CONTENT_CLASS：表示需要处理 java 的 class 文件。
  

•  2、CONTENT_JARS：表示需要处理 java 的 class 与 资源文件。
  

•  3、CONTENT_RESOURCES：表示需要处理 java 的资源文件。
  

•  4、CONTENT_NATIVE_LIBS：表示需要处理 native 库的代码。
  

•  5、CONTENT_DEX：表示需要处理 DEX 文件。
  

•  6、CONTENT_DEX_WITH_RESOURCES：表示需要处理 DEX 与 java 的资源文件。
  

• @return
  */
  @Override
  Set<QualifiedContent.ContentType> getInputTypes() {
  // 用于确定我们需要对哪些类型的结果进行转换：如字节码、资源⽂件等等。
  // return TransformManager.RESOURCES
  return TransformManager.CONTENT_CLASS
  }

/**

• 表示 Transform 要操作的内容范围，目前 Scope 有五种基本类型：

•  1、PROJECT                   只有项目内容
  

•  2、SUB_PROJECTS              只有子项目
  

•  3、EXTERNAL_LIBRARIES        只有外部库
  

•  4、TESTED_CODE               由当前变体（包括依赖项）所测试的代码
  

•  5、PROVIDED_ONLY             只提供本地或远程依赖项
  

•  SCOPE_FULL_PROJECT 是一个 Scope 集合，包含 Scope.PROJECT, Scope.SUB_PROJECTS, Scope.EXTERNAL_LIBRARIES 这三项，即当前 Transform 的作用域包括当前项目、子项目以及外部的依赖库
  

• @return
  */
  @Override
  Set<? super QualifiedContent.Scope> getScopes() {
  // 适用范围：通常是指定整个 project，也可以指定其它范围
  return TransformManager.SCOPE_FULL_PROJECT
  }

@Override
boolean isIncremental() {
// 是否支持增量更新
// 如果返回 true，TransformInput 会包含一份修改的文件列表
// 如果返回 false，会进行全量编译，删除上一次的输出内容
return false
}

/**

• 进行具体的转换过程
• @param transformInvocation
  */
  @Override
  void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
  super.transform(transformInvocation)
  println '--------------- MyTransform visit start --------------- ’
  def startTime = System.currentTimeMillis()
  def inputs = transformInvocation.inputs
  def outputProvider = transformInvocation.outputProvider
  // 删除之前的输出
  if (outputProvider != null)
  outputProvider.deleteAll()

// Transform 的 inputs 有两种类型，一种是目录，一种是 jar 包，要分开遍历
inputs.each { TransformInput input ->
// 遍历 directoryInputs（本地 project 编译成的多个 class ⽂件存放的目录）
input.directoryInputs.each { DirectoryInput directoryInput ->
handleDirectory(directoryInput, outputProvider)
}

// 遍历 jarInputs（各个依赖所编译成的 jar 文件）
input.jarInputs.each { JarInput jarInput ->
handleJar(jarInput, outputProvider)
}
}

def cost = (System.currentTimeMillis() - startTime) / 1000
println '--------------- MyTransform visit end --------------- ’
println “MyTransform cost ： $cost s”
}

static void handleJar(JarInput jarInput, TransformOutputProvider outputProvider) {
if (jarInput.file.getAbsolutePath().endsWith(“.jar”)) {
// 截取文件路径的 md5 值重命名输出文件，避免出现同名而覆盖的情况出现
def jarName = jarInput.name
def md5Name = DigestUtils.md5Hex(jarInput.file.getAbsolutePath())
if (jarName.endsWith(“.jar”)) {
jarName = jarName.substring(0, jarName.length() - 4)
}
JarFile jarFile = new JarFile(jarInput.file)
Enumeration enumeration = jarFile.entries()
File tmpFile = new File(jarInput.file.getParent() + File.separator + “classes_temp.jar”)
// 避免上次的缓存被重复插入
if (tmpFile.exists()) {
tmpFile.delete()
}
JarOutputStream jarOutputStream = new JarOutputStream(new FileOutputStream(tmpFile))
while (enumeration.hasMoreElements()) {
JarEntry jarEntry = (JarEntry) enumeration.nextElement()
String entryName = jarEntry.getName()
ZipEntry zipEntry = new ZipEntry(entryName)
InputStream inputStream = jarFile.getInputStream(jarEntry)
if (checkClassFile(entryName)) {
// 使用 ASM 对 class 文件进行操控
println ‘----------- deal with “jar” class file <’ + entryName + ‘> -----------’
jarOutputStream.putNextEntry(zipEntry)
ClassReader classReader = new ClassReader(IOUtils.toByteArray(inputStream))
ClassWriter classWriter = new ClassWriter(classReader, org.objectweb.asm.ClassWriter.COMPUTE_MAXS)
ClassVisitor cv = new MyCustomClassVisitor(classWriter)
classReader.accept(cv, EXPAND_FRAMES)
byte[] code = classWriter.toByteArray()
jarOutputStream.write(code)
} else {
jarOutputStream.putNextEntry(zipEntry)
jarOutputStream.write(IOUtils.toByteArray(inputStream))
}
jarOutputStream.closeEntry()
}
jarOutputStream.close()
jarFile.close()

// 生成输出路径 dest：./app/build/intermediates/transforms/xxxTransform/…
def dest = outputProvider.getContentLocation(jarName + md5Name,
jarInput.contentTypes, jarInput.scopes, Format.JAR)
// 将 input 的目录复制到 output 指定目录
FileUtils.copyFile(tmpFile, dest)
tmpFile.delete()
}
}

static void handleDirectory(DirectoryInput directoryInput, TransformOutputProvider outputProvider) {
// 在增量模式下可以通过 directoryInput.changedFiles 方法获取修改的文件
// directoryInput.changedFiles
if (directoryInput.file.size() == 0)
return
if (directoryInput.file.isDirectory()) {
/*遍历以某一扩展名结尾的文件/
directoryInput.file.traverse(type: FileType.FILES, nameFilter: ~/.*.class/) {
File classFile ->
def name = classFile.name
if (checkClassFile(name)) {
println ‘----------- deal with “class” file <’ + name + ‘> -----------’
def classReader = new ClassReader(classFile.bytes)
def classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS)
def classVisitor = new MyCustomClassVisitor(classWriter)
classReader.accept(classVisitor, EXPAND_FRAMES)
byte[] codeBytes = classWriter.toByteArray()
FileOutputStream fileOutputStream = new FileOutputStream(
classFile.parentFile.absolutePath + File.separator + name
)
fileOutputStream.write(codeBytes)
fileOutputStream.close()
}
}
}
/// 获取 output 目录 dest：./app/build/intermediates/transforms/hencoderTransform/
def destFile = outputProvider.getContentLocation(
directoryInput.name,
directoryInput.contentTypes,
directoryInput.scopes,
Format.DIRECTORY
)
// 将 input 的目录复制到 output 指定目录
FileUtils.copyDirectory(directoryInput.file, destFile)
}

/**

• 检查 class 文件是否需要处理
• @param fileName
• @return class 文件是否需要处理
  */
  static boolean checkClassFile(String name) {

最后

对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长。而不成体系的学习效果低效漫长且无助。时间久了，付出巨大的时间成本和努力，没有看到应有的效果，会气馁是再正常不过的。

所以学习一定要找到最适合自己的方式，有一个思路方法，不然不止浪费时间，更可能把未来发展都一起耽误了。

如果你是卡在缺少学习资源的瓶颈上，那么刚刚好我能帮到你。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！