Android Studio Poet

Improve your Android build with Android Studio Poet https://github.com/android/android-studio-poet

Transcript

1. AS Poet Optimise your Android Studio builds Boris Farber Google @borisfarber
2. About me • Android/Java/Kotlin • Partner Engineer at Google • Focusing on Android app optimizations (ClassyShark, AS Poet)
3. Disclaimer If you have a Android small app, forget these slides
4. Optimize your Android build
5. Some metrics we have seen • From 5% to 50% build improvement time • Disclaimer ⇒ Heavily depends on ◦ Project ◦ Team skills ◦ Etc… • Take these number with a huge grain of salt
6. Why • You work relentlessly on your awesome Android app. You add new features, libraries and frameworks. • Some more code here, some more resources there, it all ends up impacting the build time.
7. Why • But it doesn’t have to be that way! • As you refactor your classes and methods, why not to treat your Android project as a refactor-able unit
8. Many variables that affect our build speed • Annotations • Resources • Java Modules • Android modules • Number of classes • Number of methods • Dependencies • Topology • …
9. What • It requires a lot of testing, experiments, manual work, and patience.
10. AS Poet • What if we will generate many synthesized Android projects with a configurable number of metrics that mimics your project • Then we analyze the build times and understand where are the places to refactor
11. AS Poet • A desktop based utility for Android developers • Generates synthesized Android projects with a configurable number of metrics
12. How • Let's take a simple JSON file (less than 20 lines), that mimics the Android projects with gradle plugin syntax • Has number of other parameters such as class/method count ... • AS Poet will read the script and generate a buildable Android Studio project
17. Dependencies.dot digraph GeneratedASProject { androidAppModule0 -> androidAppModule1, module0, module1; androidAppModule1; module0; module1 -> module0; }
18. Sample Script - definitions { "projectName": "genny", "root": "./modules/", "gradleVersion": "4.3.1", "androidGradlePluginVersion": "3.0.1", "kotlinVersion": "1.1.60", "numModules": "5",
19. Sample Script - source data "allMethods": "4000", "javaPackageCount": "20", "javaClassCount": "8", "javaMethodCount": "2000", "kotlinPackageCount": "20", "kotlinClassCount": "8", "androidModules": "2",
20. Sample Script - dependencies & build types "numActivitiesPerAndroidModule": "8", "dependencies": [ {"from": 3, "to": 2}, {"from": 4, "to": 2}, {"from": 4, "to": 3} ], }
21. Github https://github.com/android/android-studio-poet
22. Features • GUI and CLI • Share resources between Android modules (layouts ...) • Call Java/Koltin code between different modules • Build flavours • Topologies • Full format for fain gained control over modules • ...
23. Optimize Kotlin on desktop
24. Swing • Zero Kotlin documentation • All documentation (really good) is 20 years old • Ended up doing skeleton development in Java and convert to Kotlin
25. AS Poet • A desktop based utility for Android developers • IO bound app (generates folders with 100K with interconnected dependencies)
26. Optimizations • Measure, measure and measure • It is better to solve the right problem the wrong way than the wrong problem the right way • Our architecture - coroutunes for module creation with fork/join for individual classes write
27. Coroutines • Used at module & project generation generation • 5x overall improvement
28. Projects val timeModels = measureTimeMillis { ModuleBlueprintFactory.initCache() runBlocking { val deferredModules = projectConfig.pureModuleConfigs.map { async { ModuleBlueprintFactory.create(it, projectRoot) } } val deferredAndroid = projectConfig.androidModuleConfigs.map { async { ModuleBlueprintFactory.createAndroidModule(projectRoot, it, projectConfig.moduleConfigs) } } temporaryModuleBlueprints = deferredModules.map { it.await() } temporaryAndroidBlueprints = deferredAndroid.map { it.await() } } }
29. Source modules fun generate(projectBlueprint: ProjectBlueprint) = runBlocking { fileWriter.delete(projectBlueprint.projectRoot) fileWriter.mkdir(projectBlueprint.projectRoot) ...
30. Parallelisation • Creating modules in parallel • Using fork/join
31. Fork/Join var randomCount: Long = 0 projectBlueprint.androidModuleBlueprints.forEach{ blueprint -> val random = Random(randomCount++) val job = launch { androidModuleGenerator.generate(blueprint, random) println("Done writing Android module " + blueprint.name) } allJobs.add(job) } for (job in allJobs) { job.join() }
32. Cache immutable • Blueprints for methods are immutable • A lot of small objects • Caching into deferred maps (inside coroutine)
33. IO Optimizations 101 • Download only necessary data (gradle full versus gradle bin) • Close to 33 MBs saved
34. Dependency Injection • Injector class • All the objects created there • Dependencies are passed as parameters • Maintenance • Testability
35. ImageIO • Great & simple API • Treat your users :)
36. Pretty easy to generate
37. Build - FatJar/Gradle • FatJar is a gradle task that creates a self contained Jar file with all dependencies
38. Tests • Should have more • Selecting the right mocking framework
39. Documentation • Make it easy to extend (architecture) • Provide bullet point steps
40. Thank you ! @borisfarber