Rock the Gradle, Rule the world

More often than not, an Android project's build.gradle files grow larger and more complex with time. This talk will look at the under-appreciated buildSrc folder, which allows you to create plugins directly from your project, but also can help you make your build.gradle files cleaner and more readable.

Transcript

1. ROCK THE GRADLE RULE THE WORLD Android Makers, 2018 1
2. ABOUT… XAVIER F. GOUCHET LEAD ANDROID ENGINEER AT WORKWELL FLUENT IN ANDROID SINCE CUPCAKE ON ALL SOCIAL NETWORKS @XGOUCHET 2
3. A BRIEF GRADLE INTRODUCTION 3
4. SHOW OF HANDS Configured project in gradle Write a custom task Write a custom plugin Followed Kotlinify your Gradle by Alexander Gherschon 4
5. WHAT IS GRADLE ? General purpose Dependency Management System Build management (dependency based) 5
6. THE GRADLE ALGORITHM Initialization Configuration Execution 6
7. MEET THE buildSrc FOLDER 7
8. ┬ 📂 MyProject ├┬ 📂 app/ │├── 📁 src/ │└── 📄 build.gradle ├┬ 📂 buildSrc/ │├── 📁 src/ │├── 📄 build.gradle ? │└── 📄 settings.gradle ├─ 📄 build.gradle └─ 📄 settings.gradle 8
9. WHAT CAN IT DO FOR ME ? Better dependency management Helper classes / methods Custom tasks in dedicated classes Custom plugin Local a versionned with the project 9
10. HOW DOES IT WORK ? Works like any module in your project Compiled and tested before any gradle task Groovy, Java, Kotlin, … 10
11. DIVING IN THE GOOD STUFF 11
12. STEP 1 : CREATE A buildSrc FOLDER 12
13. STEP 2 : … THAT'S IT DEFAULT build.gradle apply plugin: 'groovy' dependencies { compile gradleApi() compile localGroovy() } 13
14. STEP 2 (BIS) : WITH KOTLIN buildscript { dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.2.30" } repositories { mavenCentral() } } apply plugin: 'kotlin' repositories { mavenCentral() google() } dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.2.30" compile "com.android.tools.build:gradle:3.1.1" } 14
15. DEPENDENCY MANAGEMENT 15
16. BEFORE app/build.gradle dependencies { implementation"org.jetbrains.kotlin:kotlin-stdlib-jre7:1.2.30" implementation "com.android.support:appcompat-v7:27.1.1" implementation "com.android.support:design:27.1.1" implementation "com.android.support:support-annotations:27.1.1" } 16
17. AFTER buildSrc/src/main/kotlin/Dependencies.kt object Dependencies { object Versions { const val Kotlin = "1.2.30" const val AndroidSupportLib = "27.1.1" } object Libraries { const val KotlinJre7 = "org.jetbrains.kotlin:kotlin-stdlib-jre7:${Versions.Kotlin}" @JvmField val SupportLibs = arrayOf("com.android.support:appcompat-v7:${Versions.AndroidSupportLib}", "com.android.support:design:${Versions.AndroidSupportLib}", "com.android.support:support-annotations:${Versions.AndroidSupportLib}") } } 17
18. AFTER app/build.gradle import Dependencies dependencies { implementation Dependencies.Libraries.KotlinJre7 implementation Dependencies.Libraries.SupportLibs } 18
19. HELPER CLASS/METHODS 19
20. buildSrc/src/main/kotlin/Helper.kt object Helper { @JvmStatic @JvmOverloads fun ImThirsty(count: Int = 42) { for (i in count downTo 0) { println("$i bottles of beer on the wall, \n" + "Take one down and pass it around…") } } } 20
21. app/build.gradle import Helper task thirsty { doLast { Helper.ImThirsty() Helper.ImThirsty(3) } } 21
22. CUSTOM TASK A CONCRETE EXAMPLE : Shared translations between , and 22
23. buildSrc/src/main/kotlin/DownloadStrings.kt open class DownloadStrings : DefaultTask() { var languages : Array<String> = arrayOf() var path = "" @TaskAction fun performTask() { for (l in languages) { Fuel.download("http://192.168.1.42/$l/strings.xml") .destination { _, _ -> File("$path/src/main/res/values-$l/strings.xml") } .response { _, res, _ -> println("$l → ${res.statusCode}") } } } } 23
24. app/build.gradle import DownloadStrings task downloadStrings(type: DownloadStrings) { languages = ["en", "fr"] projectBasePath = projectDir } 24
25. GOING FURTHER Add an extension Task dependency 25
26. buildSrc/src/main/kotlin/RemoteExt.kt open class RemoteExt(var languages: Array<String> = arrayOf(), var remoteHost: String = "127.0.0.1") 26
27. buildSrc/src/main/kotlin/RemotePlugin.kt class RemoteL10n : Plugin<Project> { override fun apply(project: Project) { val ext = project.extensions .create("remoteStrings", RemoteExt::class.java) val task = project.tasks .create("downloadStrings", DownloadStrings::class.java) .apply { projectBasePath = project.projectDir.path configuration = ext } } } 27
28. app/build.gradle // […] import RemoteL10n apply plugin: RemoteL10n remoteStrings { languages = ["en", "fr"] remoteHost = "192.168.1.42" } 28
29. SIDENOTE ON TASK MANAGEMENT class RemoteL10n : Plugin<Project> { override fun apply(project: Project) { // … project.afterEvaluate { p -> p.tasks .withType(GenerateResValues::class.java){ it.dependsOn(task) } } } } 29
30. DEPENDENCY dependsOn finalizedBy 30
31. ORDERING mustRunAfter shouldRunAfter 31
32. GOING EVEN FURTHER Create a DSL to configure flavors separately 32
33. buildSrc/src/main/kotlin/RemoteExt.kt open class RemoteExt { var remoteHost: String = "127.0.0.1" var variants: NamedDomainObjectContainer<VariantL10n>? = null fun variants(configureClosure: Closure<VariantL10n>) { variants?.configure(configureClosure) } } open class VariantL10n(val name: String) { var languages: Array<String> = arrayOf() } 33
34. buildSrc/src/main/kotlin/RemotePlugin.kt class RemoteL10n : Plugin<Project> { override fun apply(project: Project) { val ext = project.extensions .create("remoteStrings", RemoteExt::class.java) ext.variants = project.container(VariantL10n::class.java) // … } } 34
35. app/build.gradle remoteL10n { remoteHost = "192.168.1.42" variants { debug { languages = ["en"] } freeRelease { languages = ["fr", "en"] } fullRelease { languages = ["fr", "en", "es", "de"] } } } 35
36. TESTING YOUR CODE #TESTMATTERS 36
37. class RemoteL10nTest { lateinit var fakeProject: Project @Before fun setUp() { fakeProject = ProjectBuilder.builder().build() fakeProject.plugins.apply(AppPlugin::class.java) fakeProject.plugins.apply(RemoteL10n::class.java) fakeProject.evaluate() // using a reflection UglyHack™ } } 37
38. class RemoteL10nTest { // … @Test fun addsExtension() { val extension = fakeProject.extensions .getByName(RemoteL10n.EXTENSION_NAME) assert(extension is RemoteL10nExtension) } @Test fun addsTask() { val task = fakeProject.tasks.getByName(RemoteL10n.TASK_NAME) assert(task is DownloadStrings) } } 38
39. UNIT TESTING THE TASK ITSELF Harder to do directly Delegate all business logic to a dedicated class 39
40. interface Downloader { fun downloadFile(path: String, destination: File, onSuccess: () -> Unit = {}, onError: (Int) -> Unit = {}) } 40
41. interface Fetcher { fun fetchStrings(downloader: Downloader, projectBasePath: String, configuration: RemoteL10nExtension) } 41
42. buildSrc/src/main/kotlin/DownloadStrings.kt open class DownloadStrings : DefaultTask() { var projectBasePath = "." var configuration: RemoteExt = RemoteExt() @TaskAction fun performTask() { val fetcher = RemoteL10nFetcher() fetcher.fetchString( FuelDownloader(), projectBasePath, configuration) } } 42
43. RemoteL10nFetcher can be easily tested Task itself has minmal code and no business logic 43
44. TIPS AND TRICKS 44
45. ALIASING THE PLUGIN buildSrc/build.gradle apply plugin: 'java-gradle-plugin' gradlePlugin { plugins { remoteL10n { id = "remoteL10n" // the important one - implementationClass = "com.packagename.RemoteL10n" } } } 45
46. ALIASING THE PLUGIN app/build.gradle apply plugin: "remoteL10n" 46
47. ADD TASK CATEGORY buildSrc/src/main/kotlin/DownloadStrings.kt open class DownloadStrings : DefaultTask() { init { group = "makers" description = "Downloads strings.xml from a remote server." } // … } 47
48. gradle :tasks Android tasks ------------- androidDependencies - Displays the Android dependencies. signingReport - Displays the signing info for each variant. sourceSets - Prints out all the source sets defined in the project. … Makers tasks ------------ downloadRemoteStrings - Downloads strings.xml from a remote server. … 48
49. DEFINING INPUTS / OUTPUTS @Input / @Output serializable objects @InputFile(s) / @OutputFile(s) @InputDirectory(ies) / @OutputDirectory(ies) @Nested / Console / @Internal / @Destroys / … @SkipWhenEmpty / @Optionnal 49
50. buildSrc/src/main/kotlin/DownloadStrings.kt @Input fun getExtInputs(): List<String> { val inputs = mutableListOf<String>() configuration.variants?.forEach { v -> v.languages.forEach { l -> inputs.add("${v.name}/$l") } } return inputs } 50
51. buildSrc/src/main/kotlin/DownloadStrings.kt @OutputFiles fun getTaskOOutputs(): List<File> { val outputs = mutableListOf<File>() configuration.variants?.forEach { v -> v.languages.forEach { l -> outputs.add( File("$projectBasePath/src/${v.name}/res/values-$l/strings.xml") ) } } return outputs } 51
52. :app:downloadRemoteStrings UP-TO-DATE 52
53. … But then it will never update until we change the config ? 53
54. @Input fun getDateInput() : String { val formatter = DateTimeFormatter.ISO_DATE return LocalDateTime.now().format(formatter) } 54
55. INCREMENTAL TASK @TaskAction fun incrementalAction(inputs: IncrementalTaskInputs) { if (inputs.isIncremental) { inputs.outOfDate { println("Out of date: ${it.file.name}") } inputs.removed { println("Removed: ${it.file.name}") } } else { // … } } 55
56. WHAT ELSE ? Generate source code (JavaPoet / KotlinPoet / … ) Generate resources (drawables, layouts, …) Custom lint / analysis / … 56
57. WHAT NEXT ? Cleanup your Gradle scripts Publish your plugins 57
58. REMINDERS Tasks & Extensions classes must be open DSL can go as deep as you need buildSrc is always built and tested Use apply from: "$project.rootDir/config/findbugs.gradle" Your build code should be as clean as your production code 58
59. THANKS FOR YOUR ATTENTION ANY QUESTION ? Sample app : github.com/xgouchet/RockTheGradle 59