Accélération de la construction du studio Android Gradle

Depuis la dernière mise à jour (Build du 25 juin), tout changement dans le studio Android Gradle est douloureusement lent. Et il semble également effectuer un suivi automatique des modifications lorsque vous modifiez le fichier et recompilez lors de la saisie.

Chaque changement prend plusieurs minutes sur mon i5.

Une idée de la façon dont je peux accélérer mes modifications Gradle?

Les développeurs y travaillent. Comme je l'ai signalé dans cette réponse, la solution la plus rapide pour le moment est d'utiliser gradle à partir de la ligne de commande et vous devriez passer aux bibliothèques binaires pour tous les modules que vous ne développez pas. Sur g +, il y a une discussion avec les développeurs à ce sujet.

Fait vraiment une différence: Comment… accélérer le temps de création de Gradle

Créez simplement un fichier nommé gradle.propertiesdans le répertoire suivant:

/home/<username>/.gradle/ (Linux)
/Users/<username>/.gradle/ (Mac)
C:\Users\<username>\.gradle (Windows)

Ajoutez cette ligne au fichier:

org.gradle.daemon=true

Après avoir modifié ces paramètres, mon temps de compilation de 10 minutes a été réduit à 10 secondes.

Étape 1:

Paramètres (ctrl + Alt + S) ->

Construction, exécution, déploiement ->

Compilateur ->

tapez " --offline" dans la zone Options de la ligne de commande.

Étape 2:

cochez la case «Compiler les modules indépendants en parallèle».

& cliquez sur Appliquer -> OK

Étape 3: Dans votre fichier gradle.properties -> Ajouter les lignes suivantes

org.gradle.jvmargs=-Xmx2048M -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.configureondemand=true
org.gradle.daemon=true

Mettre à jour:

Si vous utilisez Android Studio 2.0 ou supérieur, essayez Instant Run

Paramètres → Construction, exécution, déploiement → Exécution instantanée → Activer l'exécution instantanée.

Plus d'informations sur Instant Run - https://developer.android.com/studio/run/index.html#instant-run

J'ai pu réduire ma compilation gradle de 43 secondes à 25 secondes sur mon ancien ordinateur portable core2duo (exécutant Linux mint) en ajoutant ce qui suit au fichier gradle.properties dans Android Studio

org.gradle.parallel=true
org.gradle.daemon=true

source expliquant pourquoi le paramètre de démon accélère les builds: https://www.timroes.de/2013/09/12/speed-up-gradle/

Suivre les étapes le rendra 10 fois plus rapide et réduira le temps de construction de 90%

Créez d'abord un fichier nommé gradle.properties dans le répertoire suivant:

/home/<username>/.gradle/ (Linux)
/Users/<username>/.gradle/ (Mac)
C:\Users\<username>\.gradle (Windows)

Ajoutez cette ligne au fichier:

org.gradle.daemon=true
org.gradle.parallel=true

Et vérifiez ces options dans Android Studio

Il existe une version plus récente de gradle (ver 2.4).

Vous pouvez définir cela pour votre (vos) projet (s) en ouvrant la boîte de dialogue `` Structure du projet '' dans le menu Fichier,

Project Structure -> Project -> Gradle version

et réglez-le sur «2.4».
Vous pouvez en savoir plus sur l'amélioration des performances sur ce lien .

Avec Android Studio 2.1, vous pouvez activer "Dex In Process" pour des constructions d'applications plus rapides.

Vous pouvez obtenir plus d'informations à ce sujet ici: https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.vijksflyn

C'est ce que j'ai fait et ma vitesse de construction gradle s'est considérablement améliorée! de 1 min à 20 s pour la première construction et les constructions suivantes sont passées de 40 s à 5 s.

Dans le fichier gradle.properties , ajoutez ceci:

org.gradle.jvmargs=-Xmx8192M -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

Dans les arguments de la ligne de commande via Allez dans Fichier> Autres paramètres> Paramètres par défaut> Construire, exécuter, déployer> Complier et ajoutez les arguments suivants aux arguments de ligne de commande

Ajoute ça:

--debug --stacktrace -a, --no-rebuild -q, --quiet --offline

Essayez d'éviter d'utiliser un Mac / PC qui n'a que 8 Go de RAM lors du développement Android. Dès que vous lancez ne serait-ce qu'un émulateur (Genymotion ou autre), vos temps de build deviennent extrêmement lents dans Android Studio avec des builds gradle. Cela se produit même si vous apportez une simple modification d'une ligne à 1 fichier source.

Fermer l'émulateur et utiliser un appareil réel aide beaucoup, mais bien sûr, c'est très limitant et moins flexible. Réduire le paramètre d'utilisation de la RAM de l'émulateur peut aider, mais le meilleur moyen est de s'assurer que votre ordinateur portable dispose d'au moins 12 à 16 Go de RAM.

Mise à jour (juin 2017): Il existe maintenant plusieurs bons articles de medium.com qui expliquent en détail comment accélérer les builds de gradle d'Android Studio, et cela fonctionne même sur des machines de 8 Go:

• Comment réduire votre temps de construction Gradle de 65% : https://medium.com/@kevalpatel2106/how-to-decrease-your-gradle-build-time-by-65-310b572b0c43
• Faites à nouveau votre Gradle construit rapidement! : https://medium.com/@wasyl/make-your-gradle-builds-fast-again-ea323ce6a435

Le consensus résumé est:

Créez un fichier gradle.properties (global à ~/.gradle/gradle.propertiesou local au projet) et ajoutez les lignes suivantes:

org.gradle.daemon=true
org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.configureondemand=true

1. Activer le travail hors ligne

2. Améliorez les performances de Gradle en ajoutant le code suivant dans gradle.properties

org.gradle.daemon = vrai
org.gradle.parallel = vrai

Guide étape par étape: http://www.viralandroid.com/2015/08/how-to-make-android-studio-fast.html

dexOptions {
    incremental true
    javaMaxHeapSize "4g"
}

Selon cette page de l' équipe Android des applications Wikimedia , un bon moyen d'optimiser les versions Gradle est d'ajouter ces lignes à votre ~ / .gradle / gradle.properties

org.gradle.daemon=true                                                          
org.gradle.parallel=true
org.gradle.configureondemand=true
org.gradle.jvmargs=-Xmx2048M

Pour ceux qui n'ont pas le fichier, il y a deux façons de le faire:

1. Ajoutez le fichier localement dans votre projet en créant un fichier appelé gradle.properties à la racine du projet ou,

2. Vous pouvez les définir globalement pour tous vos projets en créant le même fichier dans votre répertoire personnel (% UserProfile% .gradle sous Windows , ~ / .gradle sous Linux et Mac OS X )

   Il est recommandé de définir les propriétés dans votre répertoire personnel, plutôt qu'au niveau du projet.

Vous pouvez également utiliser la ligne de commande pour de meilleures performances.Vous pouvez utiliser la commande ./gradlew <task name>depuis le dossier racine de votre projet depuis Linux ou utiliser le fichier gradlew.bat comme gradlew<task name> vous exécutez pour la première fois l'une des commandes ci-dessus pour un Gradle donné version, il téléchargera la distribution Gradle correspondante et l'utilisera pour exécuter la construction.

Lors de l'importation d'un projet Gradle via son wrapper, votre IDE peut demander à utiliser la distribution Gradle 'all'. Cela convient parfaitement et aide l'EDI à compléter le code pour les fichiers de construction. Non seulement cela signifie que vous n'avez pas à installer manuellement Gradle vous-même, mais vous êtes également sûr d'utiliser la version de Gradle pour laquelle la version est conçue. Cela rend vos constructions historiques plus fiables. pour plus d'informations, reportez-vous à Exécution d'une compilation avec le Wrapper

Pour des versions plus rapides, augmentez la taille maximale du segment de mémoire pour le démon Gradle à plus de 2 048 Mo.

Pour ce faire, définissez
org.gradle.jvmargs=-Xmx2048M
dans le projet gradle.properties .

Ajouter un build.gradlefichier:

android {
...
dexOptions {
        javaMaxHeapSize "4g" //specify the heap size for the dex process
    }
...
}

J'espère que cela aide.

J'utilise un i7 de 5e génération avec Windows 10 et un SSD de 1 To. J'ai compressé le dossier Android Studio Projects et j'ai obtenu une augmentation d'environ 80%. J'espère que cela t'aides.

Je l'ai ensuite combiné avec les solutions ci-dessus, c'est-à-dire (org.gradle.parallel = true, org.gradle.daemon = true). L'amélioration des performances était assez impressionnante.

Aditionellement:

Toutes les réponses ci-dessus sont totalement correctes, mais je dois déclarer en tant que développeur Android d'expérience (de 4 ans et demi) que: Aucun développeur Android / Gradle ne devrait travailler sur une machine avec un lecteur spinner, vous devez débourser pour un État solide. Nous avons tous appuyé sur ce bouton de lecture dans l'IDE des centaines de fois par jour. Quand je suis passé d'un spinner à un SSD (post Gradle), ma vitesse et mon efficacité étaient littéralement 2 à 4 fois plus rapides et je vous promets que je n'exagère PAS ici.

Maintenant, je ne parle pas d'avoir une machine avec un petit SSD et un gros spinner, je parle d'un gros SSD. Si vous avez déjà une machine avec un petit SSD et un gros spinner, vous pouvez mettre à niveau le petit spinner pour dire un SSD de 500 Go et définir le SSD comme lecteur principal du système d'exploitation avec vos outils de développement installés dessus.

Donc, si vous travaillez dans un environnement au rythme rapide, veuillez montrer ce message à votre patron. Un SSD de 1 To décent vous coûtera environ 300 £ (TVA comprise), ou environ 160 £ pour un SSD de 500 Go. Selon que vous êtes un développeur Android junior ou senior, le lecteur se paiera de lui-même (en frais de salaires) en 1 à 2 semaines ouvrables, ou environ 2 jours et demi à 5 jours ouvrables si vous investissez dans un plus petit; disons un SSD de 500 Go.

Beaucoup de développeurs peuvent affirmer que ce n'est pas le cas, mais c'est le cas pour Gradle, car le système Gradle est très dur sur l'accès direct au disque. Si vous travaillez avec .NET / C # / VB Net ou d'autres outils de développement, vous ne remarquerez pas beaucoup de différence, mais la différence dans Gradle est ÉNORME. Si vous agissez sur ce post, je vous le promets, vous ne serez pas déçu. Personnellement, j'utilise un i7 de cinquième génération avec 8 Go de RAM qui était à l'origine livré avec un Spinner de 1 To et je l'ai mis à niveau vers un Samsung SSD 840 EVO 1 To et je n'ai jamais regardé en arrière depuis. J'ai acheté le mien sur: https://www.aria.co.uk .

J'espère que cela t'aides. Je dois également dire que ce n'est PAS un article à motivation commerciale, je recommande simplement Aria car je les ai utilisés plusieurs fois auparavant et ils ont toujours été fiables.

quelques commandes que nous pouvons ajouter au fichier gradle.properties:

org.gradle.configureondemand = true - Cette commande indiquera à gradle de ne construire que les projets dont il a vraiment besoin pour construire. Use Daemon - org.gradle.daemon = true - Daemon maintient l'instance du gradle en marche en arrière-plan même après la fin de la construction. Cela supprimera le temps nécessaire pour initialiser le gradle et réduira considérablement le temps de construction.

org.gradle.parallel = true - Autorise gradle à créer votre projet en parallèle. Si vous avez plusieurs modules dans votre projet, en activant cela, gradle peut exécuter des opérations de construction pour des modules indépendants en parallèle.

Augmenter la taille du tas - org.gradle.jvmargs = -Xmx3072m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8 - Depuis android studio 2.0, gradle utilise dex dans le processus pour réduire les délais de construction pour le projet. En général, lors de la création des applications, plusieurs processus dx s'exécutent sur différentes instances de VM. Mais à partir d'Android Studio 2.0, tous ces processus dx s'exécutent dans la seule VM et cette VM est également partagée avec le gradle. Cela réduit considérablement le temps de génération car tout le processus dex s'exécute sur les mêmes instances de VM. Mais cela nécessite une plus grande mémoire pour accueillir tous les processus dex et gradle. Cela signifie que vous devez augmenter la taille du tas requise par le démon gradle. Par défaut, la taille du tas du démon est d'environ 1 Go.

Assurez-vous que la dépendance dynamique n'est pas utilisée. c'est-à-dire ne pas utiliser l'implémentation «com.android.support:appcompat-v7:27.0.+». Cette commande signifie que gradle sera mis en ligne et vérifiera la dernière version à chaque fois qu'il crée l'application. Utilisez plutôt des versions fixes, c'est-à-dire «com.android.support:appcompat-v7:27.0.2»

Ajoutez ceci à votre gradle.propertiesfichier

org.gradle.daemon=true                                                          
org.gradle.parallel=true
org.gradle.configureondemand=true
org.gradle.jvmargs=-Xmx2048M

Ouvrez gradle.properties à partir du dossier Android et décommentez les lignes en surbrillance et fournissez les valeurs de mémoire selon la configuration de votre machine. J'ai 8 Go de RAM sur ma machine, donc j'ai donné un maximum de 4096 Mo et 1024 Mo respectivement.

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
//Uncomment below line for providing your system specific configuration
#org.gradle.jvmargs=-Xmx4096m -XX:MaxPermSize=1024m -XX:+HeapDumpOnOutOfMemoryError - Dfile.encoding=UTF-8

# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
#http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 //Uncomment below line to allow parallel process execution.
 #org.gradle.parallel=true

Mon temps de construction a été réduit de moitié après cela. Bonne construction !!

Cela se produit souvent lorsque vous avez activé le multidex dans votre projet. Cela peut potentiellement ralentir votre processus de développement !! Selon doc :

La configuration multidex nécessite un temps de traitement de construction considérablement accru car le système de construction doit prendre des décisions complexes sur les classes à inclure dans le fichier DEX principal et les classes qui peuvent être incluses dans les fichiers DEX secondaires. Cela signifie que les générations incrémentielles utilisant le multidex prennent généralement plus de temps et peuvent potentiellement ralentir votre processus de développement.

mais vous pouvez optimiser ceci:

Pour réduire les temps de génération incrémentiels plus longs, vous devez utiliser le pré-dexing pour réutiliser la sortie multidex entre les générations.

Si vous utilisez Android Studio 2.3 et supérieur, l'EDI utilise automatiquement cette fonctionnalité lors du déploiement de votre application sur un appareil exécutant Android 5.0 (niveau d'API 21) ou supérieur.

Vous devez donc définir minSdkVersion sur 21 ou plus !

Mais si votre version de production doit prendre en charge minSdkVersion inférieure à 21, par exemple 19

vous pouvez utiliser productFlavors pour définir minSdkVersion 21 pour votre version de développement:

    android {
    defaultConfig {
        ...
        multiDexEnabled true
        // The default minimum API level you want to support.
        minSdkVersion 15
    }
    productFlavors {
        // Includes settings you want to keep only while developing your app.
        dev{
            //the IDE automatically uses  pre-dexing feature to mitigate longer incremental when deploying your app to a device running Android 5.0 !
            minSdkVersion 21
        }
        prod {

        }
    }
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'),
                                                 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile 'com.android.support:multidex:1.0.3'
}

Je préfère construire à partir de la ligne de commande pour de meilleurs temps de construction. Si la base de code de votre application est volumineuse et que vous avez plusieurs modules, vous pouvez essayer l'approche AAR locale comme décrit ici, cela vous donnera un gros coup de pouce dans les performances d'Android Studio et les temps de construction des gradins. Il est également compatible avec les versions de ligne de commande

https://blog.gojekengineering.com/how-we-improved-performance-and-build-times-in-android-studio-306028166b79

Le projet de démonstration avec les instructions d'intégration peut être trouvé ici: https://github.com/akhgupta/AndroidLocalMavenRepoAARDemo