Plugging into the Gradle Matrix (Droidcon London 2022)

Whether consolidating build script logic, writing convention plugins, or adding tooling to your apps, Gradle plugins are powerful ways to extend your build.

This talk will show how to develop your plugins safely while avoiding some of the pitfalls you might otherwise encounter, especially the ones that can negatively impact your build speed!

We'll analyze various plugins in the wild and explore:
* how to manage cacheability - build and configuration!
* deferring task creation until they're actually needed
* working with properties, providers, and file collections
* how convention plugins can help you scale your app builds sanely
* what APIs you should stop using now!

Co-Presented with @AutonomousApps.

Transcript

1. Plugging into the Gradle Matrix Tony Robalik John Rodriguez
2. apply plugin: 'com.android.library' apply plugin: 'org.jetbrains.kotlin.android' apply plugin: 'org.jetbrains.kotlin.kapt' apply plugin: 'org.jetbrains.kotlin.plugin.parcelize' apply plugin: 'app.cash.paparazzi' apply plugin: 'app.cash.treehouse'
3. Section Title apply plugin: 'java-library'
4. apply plugin: 'com.android.library'
6. Tasks https://bit.ly/3SAfQja
7. JavaCompile task
8. JavaCompile task class files
9. JavaCompile task class files source files
10. JavaCompile task class files source files target sdk
11. JavaCompile task class files source files target sdk max heap size
12. task task outputs task inputs
13. task task outputs task inputs UP-TO-DATE (aka incremental build)
14. JavaCompile task class files source files target sdk max heap size
15. JavaCompile task A.class A.java JDK 11 4 GB
16. JavaCompile task A.class A.java JDK 11 4 GB EXECUTED
17. JavaCompile task A.class, B.class A.java, B.java JDK 11 4 GB
18. JavaCompile task A.class, B.class A.java, B.java JDK 11 4 GB EXECUTED
19. JavaCompile task A.class, B.class A.java, B.java JDK 11 4 GB UP-TO-DATE x 2
20. JavaCompile task A.class A.java JDK 11 4 GB
21. JavaCompile task A.class A.java JDK 11 4 GB CACHED echo “org.gradle.caching=true” >> gradle.properties
22. Configuration Avoidance https://bit.ly/3SAfQja
23. test { testLogging { showStandardStreams = true exceptionFormat = 'full' } } Eager configuration
24. tasks .​ named('test') { testLogging { showStandardStreams = true exceptionFormat = 'full' } }
25. tasks .​ withType(Test )​​​ { testLogging { showStandardStreams = true exceptionFormat = 'full' } } Eager configuration
26. tasks .​ withType(Test )​ .​ configureEach { testLogging { showStandardStreams = true exceptionFormat = 'full' } }
27. task helloa{ doLasta{ printlna"Hello!" }a }b
28. task helloa{ doLasta{ printlna"Hello!" }a }b tasks.create("hello") { doLast { println "Hello!" } } Task immediately created
29. tasks.register("hello") { doLast { println "Hello!" } }
30. public interface TaskContainer extends TaskCollection<Task>, ... { ... @Override <T extends Task> T create( String name, Class<T> type, Action<? super T> configuration ) throws InvalidUserDataException; @Override TaskProvider<Task> register( String name, Action<? super Task> configurationAction ) throws InvalidUserDataException; ... }
31. public interface TaskContainer extends TaskCollection<Task>, ... { ... @Override <T extends Task> T create( String name, Class<T> type, Action<? super T> configuration ) throws InvalidUserDataException; @Override TaskProvider<Task> register( String name, Action<? super Task> configurationAction ) throws InvalidUserDataException; ... }
33. tasks.register("hello") { doLast { println "Hello!" } }
34. def taskProvider = tasks.register("hello") { doLast { println "Hello!" } } def task = taskProvider.get()
39. Properties
40. public interface Provider<T> { T get(); <S> Provider<S> map(Transformer<S, T> transformer); <S> Provider<S> flatMap(Transformer<Provider<S>, T> transformer); ... } Read-only
41. public interface Property<T> extends Provider<T> { void set(@Nullable T value); void set(Provider<T> provider); Property<T> value(T value); Property<T> value(Provider<T> provider); ... } Mutable
42. public interface ConfigurableFileCollection extends FileCollection public interface ConfigurableFileTree extends FileTree public interface RegularFileProperty extends Property<RegularFile> public interface DirectoryProperty extends Property<Directory> public interface FileCollection extends Iterable<File> public interface FileTree extends FileCollection Read-only Mutable
43. abstract class Producer : DefaultTask() { @get:OutputFile abstract val outputFile: RegularFileProperty @TaskAction fun produce() { outputFile.get().asFile.writeText("...") } } abstract class Consumer : DefaultTask() { @get:InputFile abstract val inputFile: RegularFileProperty @TaskAction fun consume() { val message = inputFile.get().asFile.readText() } }
44. val producer = project.tasks.register<Producer>("producer") val consumer = project.tasks.register<Consumer>("consumer") consumer { inputFile.set(producer.flatMap { it.outputFile }) } producer { outputFile.set(project.layout.buildDirectory.file(“file.txt")) }
45. val producer = project.tasks.register<Producer>("producer") val consumer = project.tasks.register<Consumer>("consumer") consumer { inputFile.set(producer.flatMap { it.outputFile }) } producer { outputFile.set(project.layout.buildDirectory.file(“file.txt”)) dependsOn(consumer) }
46. val producer = project.tasks.register<Producer>("producer") val consumer = project.tasks.register<Consumer>("consumer") consumer { inputFile.set(producer.flatMap { it.outputFile }) } producer { outputFile.set(project.layout.buildDirectory.file(“file.txt")) }
47. val producer = project.tasks.register<Producer>("producer") val consumer = project.tasks.register<Consumer>("consumer") consumer { inputFile.set(producer.flatMap { it.outputFile }) } producer { outputFile.set(project.layout.buildDirectory.file(“file.txt")) } Using Provider-based task outputs as task inputs will implicitly add the correct task dependencies!
48. val recordTaskProvider = project.tasks.register<PaparazziTask>(“recordPaparazzi") val verifyTaskProvider = project.tasks.register<PaparazziTask>("verifyPaparazzi") val isRecordRun = project.objects.property(Boolean::class.java) val isVerifyRun = project.objects.property(Boolean::class.java) project.gradle.taskGraph.whenReady { graph -> isRecordRun.set(grap h​ .hasTask(recordTaskProvide r​ .get())) isVerifyRun.set(grap h​ .hasTask(verifyTaskProvide r​ .get())) }
49. val recordTaskProvider = project.tasks.register<PaparazziTask>(“recordPaparazzi") val verifyTaskProvider = project.tasks.register<PaparazziTask>("verifyPaparazzi") val isRecordRun = project.objects.property(Boolean::class.java) val isVerifyRun = project.objects.property(Boolean::class.java) project.gradle.taskGraph.whenReady { graph -> isRecordRun.set(recordTaskProvide r​ .map { graph .​ hasTask(it) }) isVerifyRun.set(verifyTaskProvide r​ .map { graph .​ hasTask(it) }) }
52. Task Dependencies
53. val producer = project.tasks.register<Producer>("producer") val consumer = project.tasks.register<Consumer>("consumer") consumer { inputFile.set(producer.flatMap { it.outputFile }) } producer { outputFile.set(project.layout.buildDirectory.file(“file.txt")) }
54. project.plugins.withType(JavaBasePlugin::class.java) { project.tasks.named("compile${testVariantSlug}JavaWithJavac") .configure { it.dependsOn(writeResourcesTask) } } project.plugins.withType(KotlinAndroidPluginWrapper::class.java) { project.tasks.named("compile${testVariantSlug}Kotlin") .configure { it.dependsOn(writeResourcesTask) } } project.plugins.withType(KotlinMultiplatformPluginWrapper::class.java) { project.tasks.named("compile${testVariantSlug}KotlinAndroid") .configure { it.dependsOn(writeResourcesTask) } }
55. variants.all { variant -> val mergeResourcesOutputDir = variant.mergeResourcesProvider.flatMap { it.outputDir } val writeResourcesTask = project.tasks.register( "preparePaparazzi${variantSlug}Resources", PrepareResourcesTask::class.java ) { task -> task.mergeResourcesOutput.set(mergeResourcesOutputDir) ... } }
56. variants.all { variant -> val packageAwareArtifacts = project.configurations .getByName("${variant.name}RuntimeClasspath") .incoming .artifactView { it.attributes.attribute( ARTIFACT_TYPE_ATTRIBUTE, “android-symbol-with-package-name" ) } .artifacts val writeResourcesTask = project.tasks.register( "preparePaparazzi${variantSlug}Resources", PrepareResourcesTask::class.java ) { task -> task.artifactFiles.from(packageAwareArtifacts.artifactFiles) ... } }
57. abstract class DisplayApksTask : DefaultTask() { @get:InputFiles abstract valaapkFolder:aDirectoryProperty @get:Internal abstract valabuiltArtifactsLoader:aProperty<BuiltArtifactsLoader> @TaskAction fun taskAction() { val apks = builtArtifactsLoader.get().load(apkFolder.get()) apks.elements.forEach { println("Got an APK at ${it.outputFile}") } } } https://github.com/android/gradle-recipes/blob/agp-7.4/Kotlin/getApksTest/app/build.gradle.kts
58. abstract class DisplayApksTask : DefaultTask() { ... @TaskAction fun taskAction() { val apks = builtArtifactsLoader.get().load(apkFolder.get()) apks.elements.forEach { println("Got an APK at ${it.outputFile}") } } } androidComponents { onVariants { variant -> project.tasks.register(“${variant.name}DisplayApks”) { val artifacts = variant.artifacts apkFolder.set(artifacts.get(SingleArtifact.APK)) builtArtifactsLoader.set(artifacts.getBuiltArtifactsLoader()) } } }
59. fun Project.publishArtifact( configurationName: String, output: Provider<RegularFile> ): Configuration { return configurations.getByName(configurationName) { outgoing.variants.create(MY_ARTIFACT_TYPE) { isCanBeResolved = false isCanBeConsumed = true isVisible = false attributes { attribute(ARTIFACT_TYPE_ATTR, MY_ARTIFACT_TYPE) ... } artifact(output) { type = MY_ARTIFACT_TYPE } } } }
60. fun Project.createResolvableConfiguration( configurationName: String, baseConfigurationName: String ): Configuration = configurations.create(configurationName) { isCanBeResolved = true isCanBeConsumed = false isVisible = false extendsFrom(configurations[baseConfigurationName]) attributes { attribute(ARTIFACT_TYPE_ATTR, MY_ARTIFACT_TYPE) } } https://tinyurl.com/58m8hk54
61. $./gradlew producer:outgoingVariants --variant runtimeElements Attributes - org.gradle.category = library - org.gradle.dependency.bundling = external - org.gradle.jvm.version = 11 - org.gradle.libraryelements = jar - org.gradle.usage = java-runtime $./gradlew consumer:resolvableConfigurations --configuration testRuntimeClasspath Attributes - org.gradle.category = library - org.gradle.dependency.bundling = external - org.gradle.jvm.version = 11 - org.gradle.libraryelements = instrumented-jar - org.gradle.usage = java-runtime
62. $./gradlew producer:outgoingVariants --variant runtimeElements Attributes - org.gradle.category = library - org.gradle.dependency.bundling = external - org.gradle.jvm.version = 11 - org.gradle.libraryelements = jar - org.gradle.usage = java-runtime $./gradlew consumer:resolvableConfigurations --configuration testRuntimeClasspath Attributes - org.gradle.category = library - org.gradle.dependency.bundling = external - org.gradle.jvm.version = 11 - org.gradle.libraryelements = instrumented-jar - org.gradle.usage = java-runtime
63. Worker API
64. https://bit.ly/3SBlzFj abstract class CheckBestPracticesTask @Inject constructor( private val workerExecutor: WorkerExecutor ) : DefaultTask() { }a
65. abstract class CheckBestPracticesTask @Inject constructor( private val workerExecutor: WorkerExecutor ) : DefaultTask() { interface Parametersb:bWorkParameters {b valbclassesDirs:bConfigurableFileCollectionb valboutput:bRegularFilePropertyb }b abstractbclassbActionb:bWorkAction<Parameters> {b override funbexecute()b{b valbclassesDirs = parameters.classesDirs valboutput = parameters.output ... }b }b }a
66. abstract class CheckBestPracticesTask @Inject constructor( private val workerExecutor: WorkerExecutor ) : DefaultTask() { @get:PathSensitive(PathSensitivity.NONE) @get:InputFiles abstract val classesDirs: ConfigurableFileCollection @get:OutputFile abstract val output: RegularFileProperty @TaskAction fun action() { workerExecutor.noIsolation().submit(Action::class.java) { it.classesDirs.setFrom(classesDirs) it.output.set(output) } } interface Parametersb:bWorkParameters {b
67. • Good news: almost unnecessary if you use the configuration cache. • Lots of boilerplate, but helps with parallelization during execution phase. • Enforces best practices as a side effect. https://bit.ly/3sEQzJW
68. Build Services
69. abstract class InMemoryCache : BuildService<InMemoryCache.Params> { interface Params : BuildServiceParameters { val cacheSize: Property<Long> } ...don't forget to actually do stuff... internal companion object { fun register(project: Project): Provider<InMemoryCache> = project .gradle .sharedServices .registerIfAbsent("inMemoryCache", InMemoryCache::class.java) { parameters.cacheSize.set(project.cacheSize(-1L)) } } } https://tinyurl.com/bdhax5nz
70. class MyPlugin : Plugin<Project> { override fun apply(target: Project): Unit = target.run { val cache = InMemoryCache.register(this) val myTask = tasks.register<MyTask>("myTask") { inMemoryCache.set(cache) usesService(cache) // stupid but (currently) necessary } } } abstract class MyTask : DefaultTask() { @get:Internal abstract val inMemoryCache: Property<InMemoryCache> }
71. https://tinyurl.com/yfv2rja7 • The only safe way to share in-memory data. • Never ever ever use static variables.
73. class BuildMetadataPlugin : Plugin<Project> { override fun apply(project: Project) { val androidComponents = project.extensions.getByType(AndroidComponentsExtension) androidComponents .onVariants { variant -> val commitShaProvider = project.tasks.register<GitCommitShaTask>( "commitSha${variant.name}" ) { task -> task.sha.set(File(project.buildDir, "commit-sha.txt")) task.doNotTrackState("Git already tracks state!") } variant.resValues.put( variant.makeResValueKey(“string", "commit_sha"), commitShaProvider.flatMap { sha }.map { file -> ResValue(
74. class BuildMetadataPlugin : Plugin<Project> { override fun apply(project: Project) { val androidComponents = project.extensions.getByType(AndroidComponentsExtension) androidComponents .onVariants { variant -> val commitShaProvider = project.tasks.register<GitCommitShaTask>( "commitSha${variant.name}" ) { task -> task.sha.set(File(project.buildDir, "commit-sha.txt")) task.doNotTrackState("Git already tracks state!") } variant.resValues.put( variant.makeResValueKey(“string", "commit_sha"), commitShaProvider.flatMap { sha }.map { file -> ResValue(
75. class BuildMetadataPlugin : Plugin<Project> { override fun apply(project: Project) { val androidComponents = project.extensions.getByType(AndroidComponentsExtension) androidComponents .onVariants { variant -> val commitShaProvider = project.tasks.register<GitCommitShaTask>( "commitSha${variant.name}" ) { task -> task.sha.set(File(project.buildDir, "commit-sha.txt")) task.doNotTrackState("Git already tracks state!") } variant.resValues.put( variant.makeResValueKey(“string", "commit_sha"), commitShaProvider.flatMap { sha }.map { file -> ResValue(
76. class BuildMetadataPlugin : Plugin<Project> { override fun apply(project: Project) { ... androidComponents .onVariants { variant -> val commitShaProvider = ... variant.resValues.put( variant.makeResValueKey(“string", "commit_sha"), commitShaProvider.flatMap { sha }.map { file -> ResValue( file.asFile.readText(), "Value from default config." ) } ) } } }
77. abstract class GitCommitShaTask : DefaultTask() { @get:OutputFile abstract val sha: RegularFileProperty @TaskAction fun taskAction() { val p = ProcessBuilder("git","rev-parse","--short","HEAD").start() p.waitFor() val gitCommitSha = p.inputStream.readString() // calculate whether git status is dirty val p2 = ProcessBuilder("git","status","--porcelain").start() p2.waitFor() val dirtyFilesOutput = p2.inputStream.readString() val outFile = sha().asFile outFile.writeText(gitCommitSha) if (dirtyFilesOutput.isNotEmpty()) { outFile.appendText(“-DIRTY") } } }
78. Why do we care?
79. Section Title
80. COMPOSITE BUILD
81. COMPOSITE BUILD WHOOPS
82. KGP 1.7.0 COMPOSITE BUILD WHOOPS
83. KGP 1.7.0 COMPOSITE BUILD KGP 1.7.10 WHOOPS
84. KGP 1.7.0 COMPOSITE BUILD KGP 1.7.10 WHOOPS CC
85. Number one top secret build performance pro-tip...
86. Java > Kotlin
87. Convention Plugins https://tinyurl.com/y3yeem2x
88. apply plugin: 'com.android.library' apply plugin: 'org.jetbrains.kotlin.android' android { compileSdkVersion versions.compileSdk defaultConfig { minSdkVersion versions.minSdk } buildFeatures { compose true } composeOptions { kotlinCompilerExtensionVersion versions.composeCompiler } compileOptions { sourceCompatibility versions.sourceCompatibility targetCompatibility versions.targetCompatibility } lintOptions { lintConfig file('lint.xml') textOutput 'stdout' textReport true // https://github.com/square/okhttp/issues/896 ignore 'InvalidPackage' } } dependencies {a compileOnly deps.androidxAnnotations implementation deps.androidxCore implementation deps.androidxCursorAdapter implementation deps.androidxFragment implementation deps.androidxStartup implementation deps.drawablePainter implementation deps.composeUi implementation deps.runtime implementation deps.foundation implementation deps.material }a
89. apply plugin: 'com.android.library' apply plugin: 'org.jetbrains.kotlin.android' android { compileSdkVersion versions.compileSdk defaultConfig { minSdkVersion versions.minSdk } buildFeatures { compose true } composeOptions { kotlinCompilerExtensionVersion versions.composeCompiler } compileOptions { sourceCompatibility versions.sourceCompatibility
90. composeOptions { kotlinCompilerExtensionVersion versions.composeCompiler } compileOptions { sourceCompatibility versions.sourceCompatibility targetCompatibility versions.targetCompatibility } lintOptions { lintConfig file('lint.xml') textOutput 'stdout' textReport true // https://github.com/square/okhttp/issues/896 ignore 'InvalidPackage' } } dependencies {a compileOnly deps.androidxAnnotations implementation deps.androidxCore
91. apply plugin: 'com.android.library' apply plugin: 'org.jetbrains.kotlin.android' android { compileSdkVersion versions.compileSdk defaultConfig { minSdkVersion versions.minSdk } buildFeatures { compose true } composeOptions { kotlinCompilerExtensionVersion versions.composeCompiler } compileOptions { sourceCompatibility versions.sourceCompatibility
92. apply plugin: 'org.example.conventions.android' dependencies {a compileOnly deps.androidxAnnotations implementation deps.androidxCore implementation deps.androidxCursorAdapter implementation deps.androidxFragment implementation deps.androidxStartup implementation deps.drawablePainter implementation deps.composeUi implementation deps.runtime implementation deps.foundation implementation deps.material }a
93. object PluginId { object Convention { const val CASH_ANDROID_BASE_PLUGIN = “...” const val CASH_ANDROID_APPLICATION_PLUGIN = “...” const val CASH_ANDROID_LIBRARY_PLUGIN = “...” const val CASH_ANDROID_MODULES_PRESENTERS_PLUGIN = “...” const val CASH_ANDROID_MODULES_VIEWS_PLUGIN = “...” const val CASH_ANDROID_MODULES_SAMPLE_APPLICATION_PLUGIN = “...” } object External { const val KOTLIN_ANDROID_PLUGIN = "org.jetbrains.kotlin.android" const val AGP_ANDROID_APP_PLUGIN = "com.android.application" const val AGP_ANDROID_LIBRARY_PLUGIN = "com.android.library" const val PAPARAZZI_PLUGIN = "app.cash.paparazzi" const val JACOCO_PLUGIN = "jacoco" } }
94. class AndroidApplicationPlugin : Plugin<Project> { companion object { const val ID = CASH_ANDROID_APPLICATION_PLUGIN } override fun apply(target: Project): Unit = target.run { pluginManager.apply(Convention.CASH_ANDROID_BASE_PLUGIN) pluginManager.apply(External.AGP_ANDROID_APPLICATION_PLUGIN) pluginManager.apply(External.KOTLIN_ANDROID_PLUGIN) // configure stuff here } }
95. class AndroidViewsPlugin : Plugin<Project> { companion object { const val ID = CASH_ANDROID_MODULES_VIEWS_PLUGIN } override fun apply(target: Project): Unit = target.run { pluginManager.apply(CASH_ANDROID_LIBRARY_PLUGIN) pluginManager.apply(PAPARAZZI_PLUGIN) // configure stuff here } }
96. Kotlin DSL? meh
97. // build.gradle plugins { id "com.squareup.android.app" } <convention> { ... } dependencies { ... }
98. // build.gradle buildscript { dependencies { classpath 'io.ratpack:ratpack-groovy:2.0.0-rc-1' classpath 'org.slf4j:slf4j-simple:1.7.36' } } ratpack.core.server.RatpackServer.start(server -> server.handlers(chain -> chain .get(ctx -> ctx.render('Hello World!')) .get(':name', ctx -> ctx.render("Hello ${ctx.getPathTokens().get(‘name')}!") ) ) )
100. // build.gradle plugins { id "com.squareup.android.app" } <convention> { ... } dependencies { ... }
101. Case study: Dependency Analysis Gradle Plugin (DAGP) https://tinyurl.com/2ybm46s7 • Finds unused dependencies • Finds used transitive dependencies • Finds mis-declared dependencies • Works on Android and the JVM (Java, Kotlin, Groovy, Scala...)
102. Avoid afterEvaluate Bad afterEvaluate { if (plugins.hasPlugin("com.android.library")) { /* do thing */ } }
103. Avoid afterEvaluate Bad afterEvaluate { if (plugins.hasPlugin("com.android.library")) { /* do thing */ } } Good pluginManager.withPlugin("com.android.library") { /* do thing lazily */ }
105. VisitableURLClassLoader(groovy-script-/Users/trobalik/my-project/common/development-app/demo-tictactoe/build.gradle-loader) VisitableURLClassLoader(ClassLoaderScopeIdentifier.Id{coreAndPlugins:settings[:]:buildSrc[:]:root-project[:]:project-common:project-development-app:project- demo-tictactoe(export)}) VisitableURLClassLoader(ClassLoaderScopeIdentifier.Id{coreAndPlugins:settings[:]:buildSrc[:]:root-project[:](export)}) VisitableURLClassLoader(ClassLoaderScopeIdentifier.Id{coreAndPlugins:settings[:](export)}) CachingClassLoader(FilteringClassLoader(VisitableURLClassLoader(legacy-mixin-loader))) FilteringClassLoader(VisitableURLClassLoader(legacy-mixin-loader)) VisitableURLClassLoader(legacy-mixin-loader) VisitableURLClassLoader(ant-and-gradle-loader) VisitableURLClassLoader(ant-loader) jdk.internal.loader.ClassLoaders$PlatformClassLoader@1331a37b https://tinyurl.com/mvup8etk // build.gradle class A {} def printClassLoaders(classLoader) { while (classLoader != null) { println(classLoader) classLoader = classLoader.parent } } printClassLoaders(A.classLoader)
106. Dependency horror story: NoSuchMethodError?? com.google.protobuf:protobuf-java com.google.protobuf:protobuf-javalite $ jar tf ~/.gradle/caches/modules-2/files-2.1/ com.google.protobuf/protobuf-javalite/ 3.12.0/8d8ca7983eae28ac654f657f6119e85a0bba9402 /protobuf-javalite-3.12.0.jar $ jar tf ~/.gradle/caches/modules-2/files-2.1/ com.google.protobuf/protobuf-java/ 3.10.0/410b61dd0088aab4caa05739558d43df248958c9 /protobuf-java-3.10.0.jar com/google/protobuf/WireFormat$1.class com/google/protobuf/ WireFormat$FieldType$1.class com/google/protobuf/ WireFormat$FieldType$2.class com/google/protobuf/ WireFormat$FieldType$3.class com/google/protobuf/ WireFormat$FieldType$4.class com/google/protobuf/WireFormat$FieldType.class com/google/protobuf/WireFormat$JavaType.class com/google/protobuf/ WireFormat$Utf8Validation$1.class com/google/protobuf/ WireFormat$Utf8Validation$2.class com/google/protobuf/WireFormat$1.class com/google/protobuf/ WireFormat$FieldType$1.class com/google/protobuf/ WireFormat$FieldType$2.class com/google/protobuf/ WireFormat$FieldType$3.class com/google/protobuf/ WireFormat$FieldType$4.class com/google/protobuf/WireFormat$FieldType.class com/google/protobuf/WireFormat$JavaType.class com/google/protobuf/ WireFormat$Utf8Validation$1.class com/google/protobuf/ WireFormat$Utf8Validation$2.class
107. Shading • Pros and cons • Can bloat plugin size considerably • Shade selectively • Helps avoid diamond dependency problem
108. plugins { ... id("com.github.johnrengelman.shadow") } val relocateShadowJar = tasks.register<ConfigureShadowRelocation>("relocateShadowJar") { notCompatibleWithConfigurationCache("Shadow plugin is incompatible") target = tasks.shadowJar.get() } tasks.shadowJar { dependsOn(relocateShadowJar) archiveClassifier.set("") relocate("org.antlr", "com.autonomousapps.internal.antlr") } val javaComponent = components["java"] as AdhocComponentWithVariants listOf("apiElements", "runtimeElements").forEach { unpublishable -> javaComponent.withVariantsFromConfiguration(configurations[unpublishable]) { skip() } } https://tinyurl.com/2bmt38h9
109. Use compileOnly for optional dependencies Bad dependencies { implementation "com.android.tools.build:gradle:4.2.2" }
110. Use compileOnly for optional dependencies Bad dependencies { implementation "com.android.tools.build:gradle:4.2.2" } Good dependencies { compileOnly "com.android.tools.build:gradle:4.2.2" }
111. Functional testing
112. plugins { id 'java-gradle-plugin' id 'groovy' } testing { suites { functionalTest(JvmTestSuite) { useSpock() dependencies { implementation 'com.google.truth:truth:1.1.3' } } } } https://tinyurl.com/mzpe43p9
113. Functional tests with Gradle TestKit (and Spock) • Reminder that there's a whole JVM ecosystem out there. • Groovy's not so bad once you've drank the kool-aid. • Enforces BDD-style testing, which is very readable. • Very easy parameterization and data-driven testing. https://tinyurl.com/4zhtsfkk
114. class FunctionalSpec extends spock.lang.Specification { @TempDir Path tempDir def "can check best practices with 'checkBestPractices' task"() { given: def project = new SimplePluginProject(tempDir, 'reporting') when: buildAndFail(project.root, 'checkBestPractices') then: project.report.text.trim() == project.expectedReport.trim() } } https://bit.ly/3NbUO9l
115. static BuildResult buildAndFail( Path projectDir, String... args ) { return GradleRunner.create() .withPluginClasspath() .forwardOutput() .withProjectDir(projectDir.toFile()) .withArguments(*args, '-s') // True when `--debug-jvm` is passed to Gradle .withDebug( ManagementFactory.getRuntimeMXBean() .inputArguments.toString().indexOf('-agentlib:jdwp') > 0 ) .buildAndFail() }
116. class DataDrivenSpec extends spock.lang.Specification { def "myTask has expected output for AGP #agp"() { given: 'A test project' def project = MyTestProject.with(agp) when: 'We execute myTask' def result = build(project.projectDir, 'myTask') then: 'The build output contains the expected output' result.output.contains('some expected output') where: 'We test against several versions of AGP' agp << ['7.0', '7.1', '7.2'] } }
117. static BuildResult build( Path projectDir, String... args ) { return GradleRunner.create() .withPluginClasspath() .forwardOutput() .withProjectDir(projectDir.toFile()) .withArguments(*args, '-s') .build() }
118. •Don't inject the plugin classpath except for simple cases. •Instead, publish to local maven repo (but not "maven local"!). •Resolve your plugin from that repo like a normal binary plugin. •This leads to a much more "natural" scenario that is closer to what your users experience.
119. plugins { id 'maven-publish' } publishing { publications { app(MavenPublication) { artifactId = 'sort-gradle-dependencies-app' from components['java'] } } repositories { maven { name = 'tests' url = layout.buildDirectory.dir('for-tests') } } } tasks.named('test') { dependsOn 'publishAppPublicationToTestsRepository' }
120. https://tinyurl.com/534krym9
121. https://tinyurl.com/534krym9
122. https://tinyurl.com/534krym9 fun newAdapter(): AndroidGradlePlugin = when { agpVersion >= AgpVersion.version("7.4") -> { AndroidGradlePlugin7_4(project, versions) } agpVersion >= AgpVersion.version("7.3") -> { AndroidGradlePlugin7_3(project, versions) } agpVersion >= AgpVersion.version("7.2") -> { AndroidGradlePlugin7_2(project, versions) } else -> throw UnknownAgpException("No adapter for AGP $agpVersion") }
123. class ResourceUsages7_2( project: Project, variant: VariantCreationConfig ) : AnalyzeResourceUsageOf<VariantCreationConfig>(project, variant) { private val variantSlug by lazy { variant.name.replaceFirstChar(Char::uppercase) } private val mergeTask = findAndroidTask<MergeResources>(“merge${variantSlug}Resources") private val packageTask = when { variant.variantType.isApk -> mergeTask else -> findAndroidTask("package${variantSlug}Resources") }
124. class ResourceUsages7_2( project: Project, variant: VariantCreationConfig ) : AnalyzeResourceUsageOf<VariantCreationConfig>(project, variant) { private val variantSlug by lazy { variant.name.replaceFirstChar(Char::uppercase) } private val mergeTask = findAndroidTask<MergeResources>(“merge${variantSlug}Resources") private val packageTask = when { variant.variantType.isApk -> mergeTask else -> findAndroidTask("package${variantSlug}Resources") }
125. class ResourceUsages7_3( project: Project, variant: VariantCreationConfig ) : AnalyzeResourceUsageOf<VariantCreationConfig>(project, variant) { private val variantSlug by lazy { variant.name.replaceFirstChar(Char::uppercase) } private val mergeTask = findAndroidTask<MergeResources>(“merge${variantSlug}Resources") private val packageTask = when { variant.componentType.isApk -> mergeTask else -> findAndroidTask("package${variantSlug}Resources") }
126. • "Compute tasks" perform heavy computations and should be cacheable. • "Print tasks" are part of the "UI" of your plugin. They print to console.
127. @CacheableTask abstractaclassaComputeTaska:aDefaultTask() { a@get:PathSensitive(PathSensitivity.RELATIVE)a a@get:InputFilea abstractavalainput:aRegularFileProperty a@get:OutputFilea abstractavalaoutput:aRegularFileProperty a@TaskAction fun action()a{a valaoutput = output.get().asFile output.delete()a valaresult = /* heavy computation */ output.writeText(result.toJson()) a}a }a
128. @CacheableTask abstractaclassaComputeTaska:aDefaultTask() { ... } abstract class PrintTask : DefaultTask() { @get:PathSensitive(PathSensitivity.RELATIVE) @get:InputFile abstractavalainput:aRegularFileProperty @TaskActionafunaaction()a{a valareporta=ainput.get() .asFile .fromJson<MyReport>() logger.quiet(report) a}a }a
129. abstract class PrintTask : DefaultTask() { ... } class MyPlugin : Plugin<Project> { override fun apply(target: Project): Unit = target.run { val computeTask = tasks.register<ComputeTask>("computeTask") { ... } val printTask = tasks.register<PrintTask>("printTask") { input.set(computeTask.flatMap { it.output }) } } } @CacheableTask abstractaclassaComputeTaska:aDefaultTask() { ... }
130. Configuration cache • Make your build compatible and start using it ASAP. • Square estimates we save ~5400 hours annually. • Easily in excess ~$1 million in recovered lost developer productivity. • ...blog post forthcoming! https://tinyurl.com/2p4k3rup • Technically "unsafe" but works very well. • Will be GA by end of this year, before Gradle 8.0. • Necessary pre-step for project isolation.
131. class ConfigurationCacheSpec extends Specification { def "configuration cache works"() { given: def project = new SimplePluginProject() when: 'We build it the first time' def result = build(project, 'myTask', '--configuration-cache') then: 'Configuration cache entry stored' result.output().contains( "0 problems were found storing the configuration cache.") result.output().contains("Configuration cache entry stored.") } }
132. class ConfigurationCacheSpec extends Specification { def "configuration cache works"() { given: def project = new SimplePluginProject() when: 'We build it the first time' def result = build(project, 'myTask', '--configuration-cache') then: 'Configuration cache entry stored' result.output().contains( "0 problems were found storing the configuration cache.") result.output().contains("Configuration cache entry stored.") when: 'We build it again' def result = build(project, 'myTask', '--configuration-cache') then: 'Configuration cache entry reused' result.output().contains("Reusing configuration cache.") } }
133. Project isolation • Will be a major focus of Gradle in 2023. • Enables parallel configuration phase! • Enables incremental configuration! • Enables parallel and incremental IDE sync! • Early experiments at Square showed a 10x improvement in sync performance.
134. incremental_build_abi_change_in_lib { tasks = [":lib:assembleDebug"] apply-abi-change-to = "lib/src/main/java/com/lib/CreateBody.java" apply-abi-change-to = "lib/src/main/java/com/lib/CreateResponse.java" apply-abi-change-to = "lib/src/main/java/com/lib/StandardResponse.kt" show-build-cache-size = true warm-ups = 4 iterations = 7 gradle-args = ["--offline", "--no-build-cache"] } Gradle Profiler https://github.com/gradle/gradle-profiler
135. PSI/Lint • Lint checks are still here and more performant • Can be added to your CI pipeline! • Can use Quick Fixes to -- say -- update from tasks.create to tasks.register!
136. Gradle Best Practices Gradle Plugin https://tinyurl.com/2mjc3r6h • Built for plugin authors. • Protects users' builds from anti-patterns. • Enforces best practices so that you don't have to remember everything yourself. • Bytecode analysis --> works for any JVM language. • Some graph theory, for fun. • Supports a baseline so that you can incrementally fix legacy plugins. • Currently looks for the following issues: • Usage of allprojects or subprojects (always bad) • Usage of Project instances in the context of a @TaskAction. • Can be added to your CI pipeline TODAY!
137. Plugging into the Gradle Matrix @jrodbx @AutonomousApps