Réduisez le temps de construction de vos projets Android

Bonjour Nous commençons lundi avec du matériel, dont la traduction a été préparée spécialement pour les étudiants du cours "développeur Android". Cours avancé . "



J'ai récemment migré la base de code Android vers Kure sur AndroidX. Il m'a semblé que c'était une belle opportunité de travailler sur la vitesse du projet. Gradle a toujours eu une mauvaise réputation en raison de la lenteur et de la consommation de ressources, mais j'ai été très surpris que des modifications mineures de la configuration de l'assemblage puissent augmenter sa vitesse de manière si significative.

Regardez les métriques de scan d'assemblage avant / après l'optimisation


avant optimisation


après optimisation ️️

Diminué de 5,5 minutes à 17 secondes ?? Deviens fou!

Il n'est pas si difficile d'en faire trop avec l'optimisation pour réduire davantage le temps d'assemblage. Mais afin de rendre le post compréhensible pour les débutants, je me concentrerai délibérément sur les mesures mineures et indolores que j'ai prises pour me rapprocher de cet indicateur.

Tout d'abord!

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

./gradlew assembleDebug --scan 

Une fois l'assemblage terminé, il vous sera demandé d'accepter les conditions de service pour télécharger les résultats de l'analyse. Entrez oui pour continuer. Une fois la publication terminée, vous recevrez un lien vers le terminal pour vérifier le scan. Ouvrez-le.

Il y a plusieurs options sur le site, mais par souci de concision, nous ne considérerons que ce qui est le plus important.

Résumé affiche des informations récapitulatives sur les tâches terminées et leur durée. Mais ce qui nous intéresse ici, c'est la section Performance . Il fait une ventilation plus détaillée du temps de construction total, comme indiqué ci-dessous.



Dans la section Performances, il y a un onglet Paramètres et suggestions qui fournit des recommandations pour améliorer la vitesse de construction. Regardons-les.



Dans cette section, nous pouvons trouver quelques correctifs simples pour améliorer la vitesse. Continuons donc et appliquons ces corrections dans notre projet.

Étape # 1: Mettre à niveau les outils

L'équipe Android améliore et développe constamment le système de construction. Ainsi, dans la plupart des cas, vous pouvez obtenir une amélioration significative en installant simplement la dernière version de la boîte à outils.

Lors de ce refactoring, notre projet était sur la version 3.2.1 du plugin Gradle pour Android Studio ( plusieurs versions plus anciennes que la dernière version ).

Vous pouvez suivre ce lien pour obtenir la dernière version du plugin Gradle. Au moment d'écrire ces lignes, la dernière version était la version 3.4.0.

Mais il y a un hic ici que nous devons nous rappeler:



( Remarque: lorsque vous utilisez Gradle version 5.0 ou supérieure, la taille par défaut du démon Gradle est réduite de 1 Go à 512 Mo. Cela peut entraîner de mauvaises performances de génération. Pour remplacer ce paramètre par défaut, spécifiez la taille de la mémoire du démon Gradle dans gradle.properties votre projet.)

https://developer.android.com/studio/releases/gradle-plugin

Lors de l'utilisation de Gradle 5.0 et supérieur, nous devrons augmenter explicitement la taille de la mémoire afin que notre vitesse de construction ne se détériore 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 à la section des dépendances :

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

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

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

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

Vous rencontrerez une erreur lors de l'utilisation de Kotlin si la version du plugin Kotlin Gradle est inférieure à 1.3.0. Si c'est le cas, utilisez l'info-bulle IDE pour mettre à jour le plugin Gradle pour Kotlin vers la dernière version (au moment de la rédaction de ce document, il s'agit de la version 1.3.31 ).

Ok, exécutons à nouveau la construction à partir du terminal pour voir si nous avons apporté des améliorations.

Étape # 2: Mettre à jour les configurations

Nous avons donc pu réduire d'environ 2,5 minutes le temps de génération, mais ce n'est toujours pas suffisant. Après avoir étudié les journaux de construction dans le terminal, je suis tombé sur une ligne qui nous intéressera:



(> Tâche: app: compileDevelopDebugJavawithJavac

Gradle peut désactiver la compilation incrémentielle car les processeurs d'annotation suivants ne sont pas incrémentiels: butterknife-compiler-10.1.0.jar (com.jakewharton: butterknife-compiler: 10.1.0), dagger-compiler-2.9.jar (com.google. dague: dague-compilateur: 2.9).

Envisagez de définir l'indicateur expérimental android.enableSeparateAnnotationProcessing-true dans le fichier gradle.properties pour démarrer le traitement des annotations dans une tâche distincte et effectuer une compilation incrémentielle.)

La compilation incrémentielle empêche essentiellement la compilation inutile de l'ensemble des fichiers source et ne compile à la place que les fichiers qui ont été modifiés. D'après les journaux, il est clair que nous n'utilisons pas cette fonction. Il suggère que nous utilisons android.enableSeparateAnnotationProcessing=true , mais, dans tous les cas, nous ne devons pas utiliser la configuration «annotationProcessor» puisque Kotlin est utilisé dans notre projet.

Heureusement, la version 1.3.30 de Kotlin ajoute la prise en charge du traitement étape par étape des annotations.



https://kotlinlang.org/docs/reference/kapt.html

(Traitement incrémentiel des annotations (à partir du 1.3.30)

Depuis la version 1.3.30, kapt prend en charge le traitement d'annotations incrémentielles comme fonction expérimentale. Actuellement, le traitement d'annotation ne peut être effectué de manière incrémentielle que si tous les processeurs d'annotation utilisés sont incrémentiels.
Pour activer le traitement d'annotations incrémentielles, ajoutez cette ligne au fichier gradle.properties :

kapt.incremental.apt=true

Notez que le traitement d'annotations incrémentielles nécessite que la compilation incrémentielle soit également activée.)

Commençons donc:

1. 1. Changez la configuration de l' annotationProcessor en kapt
2. 2. Activez l'indicateur de traitement d'annotation incrémentiel expérimental

Ouvrez le fichier build.gradle votre module et ajoutez la ligne suivante en haut du fichier:

apply plugin: 'kotlin-kapt'

Modifiez ensuite toutes les configurations d'annotationProcessor dans la section des dépendances pour utiliser kapt. Par exemple:

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

Ouvrez maintenant le fichier gradle.properties situé à la racine de votre projet et ajoutez la ligne suivante:

kapt.incremental.apt=true

Lançons à nouveau la construction.



Eh bien, il semble que nous ayons fait des progrès.

Étape # 3: Propriétés Gradle

Nous sommes à la dernière étape. Vous vous souvenez de l'astuce que nous avons rencontrée lors de la mise à jour de la version du plugin Gradle? Il s'avère que les nouvelles versions de Gradle réduisent la taille de la mémoire utilisée à 512 Mo. C'est pour s'assurer que les machines faibles ne consomment pas trop de mémoire. J'ai un ordinateur avec 16 gigaoctets de RAM, donc je peux me permettre d'alimenter environ 2-3 Go au démon Gradle, mais vos chiffres peuvent varier.

Ouvrez le fichier gradle.properties situé à la racine de votre projet et ajoutez la ligne suivante. Assurez-vous de choisir la taille qui correspond à vos besoins et aux spécifications de l'ordinateur.

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

Pendant ce temps, activons également les assemblys parallèles et le réglage à la demande dans les propriétés.

Voici à quoi ressemble ma version finale du fichier gradle.properties :

 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 - cet indicateur permet à Gradle d'assembler des modules dans un projet en parallèle, plutôt que séquentiellement. Ceci n'est utile que pour les projets multi-modules.
• org.gradle.configureondemand - cet indicateur configure uniquement les modules nécessaires au projet et ne les collecte pas tous.

Cela fait, voyons ce que nous avons maintenant les indicateurs de vitesse d'assemblage:




Et voilà!

Observations finales

Il ne s'agit en aucun cas d'une couverture étendue de toutes les façons d'optimiser la vitesse d'assemblage. Il y a beaucoup d'autres choses que je n'ai pas couvert dans cet article, comme l'utilisation de minSdk 21 lors de l'utilisation de MultiDex, la pré-indexation des bibliothèques, la désactivation de la compression PNG, etc., ne sont que quelques-unes d'entre elles.

Mais la plupart de ces configurations nécessitent une compréhension plus approfondie du système de construction Android et une expérience de travail avec de grands projets multi-modules (où les avantages sont les plus évidents). Les étapes que j'ai mentionnées ci-dessus sont facilement mises en œuvre par même les développeurs juniors et présentent des avantages significatifs. J'espère que cela vous aide à augmenter la vitesse de construction!

A la prochaine fois, la paix soit sur vous!