Comment améliorer la vitesse de création de vos projets Android

Récemment, j'ai entrepris la tâche de migrer la base de code Android de Kure vers AndroidX. Cela semblait être l'occasion idéale d'essayer de corriger les vitesses de construction du projet.

Gradle a toujours eu une mauvaise réputation d'être lent et gourmand en ressources, mais j'ai été assez surpris de voir à quel point des modifications mineures de la configuration de construction du projet pouvaient considérablement améliorer les vitesses de construction.

Pour vous donner un aperçu du temps que j'ai pu perdre de nos builds propres, voici une métrique avant et après de l'analyse de build.

Passer de 5,5 minutes à 17 secondes ?? C'est dingue.

Il est facile d'aller trop loin avec les optimisations que vous pouvez effectuer pour réduire encore plus votre temps de construction. Mais je vais me concentrer intentionnellement sur les mesures mineures et indolores que j'ai prises pour me rapprocher de cette métrique dans le but de garder ce poste convivial pour les débutants.

Mais d'abord!

Avant de commencer l'optimisation, il est important de comparer notre projet pour voir combien de temps il faut actuellement pour construire. Gradle dispose d'une option d'analyse pratique que vous pouvez utiliser pour analyser les performances de votre tâche. Lancez le terminal sur Android Studio et exécutez la commande suivante:

./gradlew assembleDebug --scan

Une fois la construction terminée avec succès, il vous demandera d'accepter les conditions de service pour télécharger les résultats de l'analyse de compilation. Tapez oui pour continuer. Une fois la publication terminée, vous obtiendrez un lien sur le terminal pour vérifier votre analyse de construction. Ouvrez le lien.

Il y a pas mal d'options sur le site, mais par souci de concision, nous allons seulement jeter un oeil à ce qui est le plus important.

Le résuméLa vue vous montre un résumé des tâches qui ont été exécutées et la durée de leur exécution. Mais ce qui nous intéresse ici, c'est la section Performance . Il vous donne une ventilation plus détaillée du temps de construction total, comme indiqué ci-dessous.

Sous la section des performances, il y a un onglet Paramètres et suggestions qui vous donne des suggestions sur la façon dont vous pouvez améliorer vos vitesses de construction. Vérifions cela.

Nous pouvons trouver des correctifs simples pour notre vitesse de construction dans cette section. Alors allons-y et appliquons ces suggestions dans notre projet.

Étape n ° 1: Mettez à jour votre outillage

L'équipe Android améliore et fait évoluer constamment le système de construction Android. Ainsi, la plupart du temps, vous pouvez bénéficier d'améliorations significatives simplement en adoptant la dernière version de l'outillage.

Au moment de ce refactor, notre projet était sur la version 3.2.1 du plugin Gradle pour Android Studio (qui est quelques versions plus anciennes que la dernière version).

Vous pouvez visiter ce lien pour obtenir la version de la dernière version du plugin Gradle.

Au moment de la rédaction de cet article, la dernière version est la version 3.4.0.

Mais cela vient avec un piège que nous devons garder à l'esprit pour plus tard:

Lors de l'utilisation de Gradle 5.0 et supérieur, nous devrons augmenter explicitement la taille du tas pour nous assurer que notre vitesse de construction ne s'aggrave pas. Nous y reviendrons dans une minute.

Ouvrez le fichier build.gradle de niveau supérieur que vous trouverez à la racine de votre projet et ajoutez la ligne suivante dans la section dépendances:

classpath 'com.android.tools.build:gradle:3.4.0'

Vous devrez également mettre à jour l' URL de distribution dans le fichier de propriétés du wrapper gradle situé dans gradle / wrapper / gradle-wrapper.properties. Mettez à jour l'URL comme suit.

(Ce lien sera disponible sur la page de sortie du plugin Android Gradle.)

distributionUrl=https\://services.gradle.org/distributions/gradle-5.1.1-all.zip

Si vous utilisez Kotlin dans votre projet, vous rencontrerez une erreur si la version de votre plugin Kotlin Gradle est inférieure à 1.3.0 . Si tel est le cas, utilisez l'invite de l'EDI pour mettre à jour votre plugin Kotlin Gradle vers la dernière version (qui au moment de la rédaction de cet article est la version 1.3.31 ).

Très bien, exécutons à nouveau la compilation à partir du terminal pour voir si nous avons réalisé des améliorations.

Étape # 2: Mettez à jour vos configurations

Nous avons donc pu perdre environ 2,5 minutes du temps de construction, mais ce n'est toujours pas suffisant. En examinant les journaux de construction dans le terminal, je suis tombé sur une ligne qui nous intéresse:

La compilation incrémentielle empêche essentiellement la compilation inutile de l'ensemble des fichiers sources et ne compile à la place que les fichiers qui ont changé. En regardant les journaux, il est clair que nous ne profitons pas de cette fonctionnalité. Cela nous suggère d'utiliser android.enableSeparateAnnotationProcessing = true mais puisque nous utilisons Kotlin dans nos projets, nous ne devrions pas utiliser la configuration 'annotationProcessor' de toute façon.

Heureusement, la version 1.3.30 de Kotlin a ajouté la prise en charge du traitement d'annotation incrémentiel.

Alors allons

  1. Changez la configuration annotationProcessor en kapt
  2. Activer l' indicateur expérimental de traitement d'annotations incrémentielles

Open your module level build.gradle file and add the following line to the top of the file:

apply plugin: 'kotlin-kapt'

Next, change all annotationProcessor configurations in the dependencies section to use kapt. Here’s an example:

//Before annotationProcessor 'com.google.dagger:dagger-compiler:2.9' //After kapt 'com.google.dagger:dagger-compiler:2.9'

Now open up your gradle.properties file located at the root of your project and add the following line:

kapt.incremental.apt=true

Let’s run the build again. ??????

Alright, looks like we’re getting there.

Step #3: Gradle Properties

We’re in the last stage now. Remember the gotcha we came across while updating our Gradle plugin version? Turns out the newer versions of Gradle reduce the heap size to 512 MB. This is to make sure lower end machines don’t choke up. I am on a 16 gig machine so I can afford to give around 2–3gigs to the Gradle daemon, but your mileage may vary.

Open the gradle.properties file located at the root of your project and add the following line. Remember to select the size according to your requirements and machine specification.

org.gradle.jvmargs=-Xmx3072m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

While we’re at it, let’s also enable parallel builds and configure on demand in the properties.

Here’s what my final gradle.properties file looks like:

org.gradle.jvmargs=-Xmx3072m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 org.gradle.parallel=true org.gradle.configureondemand=true kapt.incremental.apt=true
  • org.gradle.parallel - This flag allows Gradle to build modules within a project in parallel instead of sequentially. This is only beneficial in a multi-module project.
  • org.gradle.configureondemand - This flag configures only the modules needed by the project, instead of building all of them.

With these, let’s see where we are on our build speed metric:

And there we go. ???

Closing remarks

This is by no means an extensive coverage of all the ways one can optimize the build speed of their project. There are tons of other things which I did not go over in this post like using minSdk 21 when using MultiDex, pre-dexing your libraries, disabling PNG crunching, and so on — to name a few.

But most of these configurations require a deeper understanding of Android’s build system and experience working on large multi-module projects (which is where the benefits are most apparent). The steps I mentioned above are easy to incorporate in a project even by junior devs and have considerable payoffs. I hope this helps you trim down your build speeds!

Alright until next time, peace! ✌?