本文介绍 Plugin 的编写以及 bulidSrc 的使用

Plugin基本的写法

在 build.gradle 下

  1. class PluginDemo implements Plugin<Project> {
  3.     @Override
  4.     void apply(Project project) {
  5.         println 'hi !!!'
  6.     }
  8. }
  10. apply plugin: PluginDemo

Terminal 窗口执行 ./gradlew 得到如下结果
image.png

Extension

同样在 build.gradle 下

  1. class ExtensionDemo {
  2.     def extensionName = 'test'
  3. }

总体代码：

  1. class PluginDemo implements Plugin<Project> {
  3.     @Override
  4.     void apply(Project project) {
  5.         def extension = project.extensions.create('testExtension',
  6.                 ExtensionDemo)
  7.        println "hi ${extension.extensionName}!"
  8.     }
  10. }
  12. class ExtensionDemo {
  13.     def extensionName = 'test'
  14. }
  16. apply plugin: PluginDemo

执行 ./gradlew 得出结果
image.png
这时就可以在gradle文件下引用 testExtension 了

  1. // 在project.extensions.create()方法中注册了testExtension这个扩展
  2. // 这段代码在apply plugin: PluginDemo后面
  3. testExtension {
  4.     extensionName 'new test'
  5. }

这时候执行，会发现在 Terminal 窗口里打印的依然是 hi test! 而不是 hi new test！

这是因为代码执行顺序问题，赋予新的值的时候已经执行完println，所以无法打印hi new test！

只需要加上afterEvaluate{}便可：

  1. def extension = project.extensions.create('testExtension',
  2.                 ExtensionDemo)
  3. // 表示在最后执行
  4. project.afterEvaluate {
  5.     println "hi ${extension.extensionName}!"
  6. }

image.png

插件写在 buildSrc 下

如果每一个插件都像上述这种写法，必然会无法管理和难读（假设项目要定义起码三个插件）
所以插件应该写在 buildSrc 下

插件的本质：把逻辑独立的代码抽取和封装

关于buildSrc目录

  • 这是 gradle 的一个特殊目录，这个目录的 build.gradle 会自动被执行，即使不配置进 settings.gradle。(实际上在 gradle 的 6.0 之后， buildSrc 已经成为了一个保留字，你在 settings.gradle 里配置的项目已经不允许叫 buildSrc )

  • buildSrc 所配置出来的 Plugin 会被自动添加到编译过程中的每一个 project 的 classpath，因此它们才可以直接使用 apply plugin: ‘xxx’ 的方式来便捷应用这些 plugin

在项目新建一个 Module 取名为 bulidSrc
新建后一般会报错 ‘buildSrc’ cannot be used as a project name as it is a reserved name
需要在 settings.gradke里把 include ':buildSrc'去掉即可
image.png

  1. 把之前写的 PluginDemo 和 ExtensionDemo 写在 bulidSrc 下
  2. 在 main 目录下新建 *.properties 文件
  3. 把 main 下的 java 目录改成 groovy

如图：
image.png

  • resources/META-INF/gradle-plugins/*.properties 中的 是插件的名称，例如 `.properties是com.tongsr.plugindemo.properties` ，最终在应用插件是的代码就应该是: ```groovy apply plugin: ‘com.tongsr.plugindemo’

testExtension { extensionName ‘new test~’ }

  2. - *.properties 中只有一行，格式是: 
  3. ```groovy
  4. implementation-class=com.tongsr.buildsrc.PluginDemo

  • Plugin 和 Extension 写法和在 build.gradle 里的写法一样

    运行结果：
    image.png

    Transform

  • 是什么：是由 Android 提供了，在项目构建过程中把编译后的文件(jar 文件和 class 文件)添加自定义的中间处理过程的工具

  • 怎么写

    • 先加上依赖 ```groovy // 因为 buildSrc 需要自己添加仓库 repositories { google() jcenter() }

dependencies { implementation ‘com.android.tools.build:gradle:7.0.4’ }

  2.    - 然后继承 `com.android.build.api.transform.Transform` ，创建 一个子类: 
  3. ```groovy
  4. class TransformDemo extends Transform {
  6.     // 构造方法
  7.     TransformDemo() {
  9.     }
  11.     // 对应的 task 名 @Override
  12.     String getName() {
  13.         return 'tongsrTransform'
  14.     }
  16.     // 你要对那些类型的结果进行转换(是字节码还是资源文件?)
  17.     @Override
  18.     Set<QualifiedContent.ContentType> getInputTypes() {
  19.         return TransformManager.CONTENT_CLASS
  20.     }
  22.     // 适用范围包括什么(整个 project 还是别的什么?)
  23.     @Override
  24.     Set<? super QualifiedContent.Scope> getScopes() {
  25.         return TransformManager.SCOPE_FULL_PROJECT
  26.     }
  28.     @Override
  29.     boolean isIncremental() {
  30.         return false
  31.     }
  33.     // 具体的「转换」过程
  34.     @Override
  35.     void transform(TransformInvocation transformInvocation) throws TransformException,
  36.             InterruptedException, IOException {
  37.         def inputs = transformInvocation.inputs
  38.         def outputProvider = transformInvocation.outputProvider
  39.         inputs.each {
  40.             // jarInputs:各个依赖所编译成的 jar 文件
  41.             it.jarInputs.each {
  42.                 // dest: /app/build/intermediates/transforms/tongsrTransform/ ...
  43.                 File dest = outputProvider.getContentLocation(it.name, it.contentTypes,
  44.                         it.scopes, Format.JAR)
  45.                 FileUtils.copyFile(it.file, dest)
  46.             }
  47.             // derectoryInputs:本地 project 编译成的多个 class 文件存放的目录
  48.             it.directoryInputs.each {
  49.                 // dest: /app/build/intermediates/transforms/tongsrTransform/ ...
  50.                 File dest = outputProvider.getContentLocation(it.name, it.contentTypes,
  51.                         it.scopes, Format.DIRECTORY)
  52.                 FileUtils.copyDirectory(it.file, dest)
  53.             }
  54.         }
  55.     }
  57. }
  • 还能做什么：修改字节码 上面的这段代码只是把编译完的内容原封不动搬运到目标位置，没有实际用处。要修改字节码，需要引入其他工具，例如 javassist。 javassist 的使用教程在网上有很多，可以搜索一下

用buildSrc管理项目版本

目的：管理项目第三方SDK以及Module之间的版本号等

  1. 新建一个 buildSrc，和前文叙述无差别
  2. 把 build.gradle 改成 build.gradle.kts
  3. 在 java 目录下新建一个 Dependencies 类 ```kotlin object Libs { const val CORE = “androidx.core:core-ktx:1.7.0” }

object Version { const val MIN_SDK = 21 }

  2. 4. Sync项目后，在 app 的 build.gradle 引用定义好的 Libs 和 Version，这里做个简单示例
  3. ```groovy
  4. android {
  5.     compileSdk 31
  7.     defaultConfig {
  8.         applicationId "com.tongsr.mytest"
  9.         minSdk Version.MIN_SDK // 注意这里
  10.         targetSdk 31
  11.         versionCode 1
  12.         versionName "1.0"
  14.         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
  15.     }
  16. }
  18. dependencies {
  19.     implementation Libs.CORE // 注意这里
  20.     implementation 'androidx.appcompat:appcompat:1.4.1'
  21.     implementation 'com.google.android.material:material:1.5.0'
  22.     implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
  23.     testImplementation 'junit:junit:4.+'
  24.     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
  25.     androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
  26. }

附上buildSrc参考链接

用Kotlin DSL构建Android项目

同样也是利用 buildSrc 来管理项目，不同的点是用 Kotlin DSL 代替 Groovy

把所有的 .gradle 文件换成 .kts 文件。把 Groovy 的语法换成 Kotlin 语法

附上Kotlin DSL参考链接