J'ai un multi-projet (~ 10 modules) dont la construction prend environ 20-30 secondes à chaque fois. Lorsque j'appuie sur Exécuter dans Android Studio, je dois attendre à chaque fois pour reconstruire l'application, ce qui est extrêmement lent.

Est-il possible d'automatiser le processus de construction dans Android Studio? Ou avez-vous des conseils sur la façon d'accélérer ce processus?

Dans Eclipse, grâce à la construction automatique, l'exécution du même projet sur un émulateur prend environ 3 à 5 secondes.

Voici mon fichier build.gradle (module d'application):

buildscript {
    repositories {
        maven { url 'http://repo1.maven.org/maven2' }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.4'
    }
}
apply plugin: 'android'

dependencies {
    compile fileTree(dir: 'libs', include: '*.jar')
    compile project(':libraries:SharedLibs')
    compile project(':libraries:actionbarsherlock')
    compile project(':libraries:FacebookSDK')
    compile project(':libraries:GooglePlayServices')
    compile project(':libraries:HorizontalGridView')
    compile project(':libraries:ImageViewTouch')
    compile project(':libraries:SlidingMenu')
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 16
    }
}

Matériel

Je suis désolé, mais la mise à niveau de la station de développement vers SSD et des tonnes de RAM a probablement une plus grande influence que les points ci-dessous combinés.

Versions d'outils

L'augmentation des performances de construction est une priorité majeure pour les équipes de développement, alors assurez-vous que vous utilisez le dernier Gradle et Android Gradle Plugin .

Fichier de configuration

Créez un fichier nommé gradle.propertiesdans le répertoire qui s'applique:

• /home/<username>/.gradle/ (Linux)
• /Users/<username>/.gradle/ (Mac)
• C:\Users\<username>\.gradle (Les fenêtres)

Ajouter:

# IDE (e.g. Android Studio) users:
# Settings specified in this file will override any Gradle settings
# configured through the IDE.

# For more details on how to configure your build environment visit
# http://www.gradle.org/docs/current/userguide/build_environment.html

# The Gradle daemon aims to improve the startup and execution time of Gradle.
# When set to true the Gradle daemon is to run the build.
# TODO: disable daemon on CI, since builds should be clean and reliable on servers
org.gradle.daemon=true

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.krd1mm27v
org.gradle.jvmargs=-Xmx5120m -XX:MaxPermSize=512m -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
org.gradle.parallel=true

# Enables new incubating mode that makes Gradle selective when configuring projects. 
# Only relevant projects are configured which results in faster builds for large multi-projects.
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:configuration_on_demand
org.gradle.configureondemand=true

# Set to true or false to enable or disable the build cache. 
# If this parameter is not set, the build cache is disabled by default.
# http://tools.android.com/tech-docs/build-cache
android.enableBuildCache=true

Les propriétés Gradle fonctionnent localement si vous les placez sur projectRoot\gradle.propertieset globalement si vous les placez sur user_home\.gradle\gradle.properties. Propriétés appliquées si vous exécutez des tâches Gradle depuis la console ou directement depuis l'idée:

Paramètres IDE

Il est possible de modifier l'intégration Gradle-IntelliJ à partir de l'interface graphique des paramètres IDE. L'activation du "travail hors ligne" (vérifiez la réponse de yava ci-dessous) désactivera les demandes réelles du réseau sur chaque "fichier de synchronisation de gradle".

Multi-dex natif

L'une des étapes les plus lentes de la construction apk consiste à convertir le bytecode java en un seul fichier dex. L'activation du multidex natif (minSdk 21 pour les versions de débogage uniquement) aidera l'outillage à réduire une quantité de travail (vérifiez la réponse d' Aksel Willgert ci-dessous).

Dépendances

Préférez les @aardépendances aux sous-projets de bibliothèque.

Recherchez un package aar sur mavenCentral , jCenter ou utilisez jitpack.io pour créer n'importe quelle bibliothèque à partir de github. Si vous ne modifiez pas les sources de la bibliothèque de dépendances, vous ne devez pas la créer à chaque fois avec les sources de votre projet.

Antivirus

Envisagez d'exclure les fichiers de projet et de cache de l'analyse antivirus. C'est évidemment un compromis avec la sécurité (n'essayez pas cela à la maison!). Mais si vous basculez souvent entre les branches, l'antivirus réanalysera les fichiers avant d'autoriser le processus Gradle à l'utiliser, ce qui ralentit le temps de construction (en particulier le projet de synchronisation AndroidStudio avec les fichiers Gradle et les tâches d'indexation). Mesurez le temps de génération et traitez le processeur avec et sans antivirus activé pour voir s'il est lié.

Profilage d'une génération

Gradle a un support intégré pour les projets de profilage . Différents projets utilisent une combinaison différente de plugins et de scripts personnalisés. L'utilisation --profileaidera à trouver les goulots d'étranglement.

Vous pouvez ignorer les vérifications à jour de Gradle.

Pour Windows exécutant Android Studio 1.5: accédez à File -> Settings -> Build, Execution, Deployment -> Build tools -> Gradle -> Check Offline work (as shown in image)

de ~ 30 + sec à ~ 3 sec

J'ai cherché partout cela et j'ai finalement trouvé une solution qui fonctionne pour nous. L'activation de builds parallèles (sous OSX:) preferences -> compiler -> gradle -> "Compile independent modules in parallel"et l'activation de «créer un projet automatiquement» l'ont réduit de ~ 1 min à ~ 20 sec. Merci à / u / Covalence.

http://www.reddit.com/r/androiddev/comments/1k3nb3/gradle_and_android_studio_way_slower_to_build/

J'ai récemment acheté un nouveau SSD et je suis passé de Windows à Linux.Mes temps de construction sont désormais un ordre de grandeur plus rapides et plus ennuyeux.

Bien qu'il ne réponde pas directement à votre question de savoir pourquoi il est plus lent que l'éclipse, il montre que le processus est limité au disque et qu'une mise à niveau vers un SSD pourrait être une solution (quelque peu coûteuse). J'imagine qu'il y aura des gens qui googleront le problème et finiront ici, qui pourraient apprécier mon expérience.

Accélérez la construction de Gradle dans Android Studio 3.2.1

Avez-vous déjà eu l'impression d'attendre que les versions soient terminées dans Android Studio pendant quelques minutes? Moi aussi. Et c'est assez ennuyeux. Heureusement, il existe plusieurs façons d'améliorer cela. Android utilise Gradle pour la construction. La dernière version est 4.6 a une énorme amélioration des performances par rapport aux versions précédentes (voir les notes de publication pour plus de détails).

Étape 1: mise à jour de la version Gradle Un moyen plus simple d'y parvenir consiste à accéder à: Ouvrir les paramètres du module (votre projet)> Structure du projet

MISE À JOUR

Passez à la version Gradle: 4.6 et passez à la version du plug-in Android: 3.2.1

Téléchargez la distribution Gradle Release depuis https://services.gradle.org/distributions/gradle-4.6-all.zip Et copiez-la dans le dossier Gradle:

La dernière étape consiste à ajouter votre distribution dans Paramètres> Gradle

N'oubliez pas de cliquer sur Appliquer pour enregistrer les modifications.

Étape 2: Activez le mode hors ligne, le démon Gradle et la construction parallèle pour le projet Le mode hors ligne indique à Gradle d'ignorer les vérifications de mise à jour. Gradle demande des dépendances à chaque fois et ayant cette option, il utilise simplement ce qui est déjà sur la machine pour les dépendances. Accédez à Gradle depuis Android Studio Setting et cliquez dans la zone de travail hors ligne.

2. Accédez au compilateur depuis Android Studio Setting et ajoutez «- offline» dans la zone de ligne de commande et cliquez sur Compiler des modules indépendants en parallèle.

L'étape suivante consiste à activer le démon Gradle et la génération parallèle pour votre projet. Les builds parallèles feront que vos projets avec plusieurs modules (builds multi-projets dans Gradle) seront construits en parallèle, ce qui devrait accélérer la construction de projets volumineux ou modulaires.

Ces paramètres pourraient être activés en modifiant un fichier nommé gradle.properties dans le répertoire des scripts Gradle (c'est-à-dire ~ / .gradle / gradle.properties). Certaines de ces options (par exemple, les modules Complie en parallèle) sont disponibles à partir d'Android Studio et également activées par par défaut, mais les placer dans le fichier gradle.properties les activera lors de la construction à partir du terminal et s'assurera également que vos collègues utiliseront les mêmes paramètres. Mais si vous travaillez en équipe, vous ne pouvez parfois pas engager ce genre de choses.

# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit org.gradle.parallel=true
# When set to true the Gradle daemon is used to run the build. For local developer builds this is our favorite property.
# The developer environment is optimized for speed and feedback so we nearly always run Gradle jobs with the daemon.
 org.gradle.daemon=true

L'utilisation du démon accélérera le démarrage de vos builds car il n'aura pas à démarrer l'intégralité de l'application Gradle à chaque fois. Le démon Gradle n'est pas activé par défaut, mais il est recommandé de toujours l'activer pour les machines des développeurs (mais en le laissant désactivé pour les serveurs d'intégration continue). La FAQ sur ce mode peut être trouvée ici https://docs.gradle.org/current/userguide/gradle_daemon.html . Le paramètre de génération parallèle peut être dangereux pour certains projets. La condition est que tous vos modules doivent être découplés ou votre build pourrait échouer (voir http://gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects pour plus de détails).

Étape 3: Activer la décomposition incrémentielle et modifier les paramètres de mémoire Vous pouvez accélérer vos builds en activant la décomposition incrémentielle. Dans le fichier de construction de votre module:

Ajoutez cette option à votre bloc Android:

dexOptions {
    incremental true
}

Dans ce bloc dexOptions, vous pouvez également spécifier la taille de segment de mémoire pour le processus dex, par exemple:

dexOptions {
    incremental true
    javaMaxHeapSize "12g"
}

Où «12g» correspond à 12 Go de mémoire. Des informations supplémentaires à ce sujet peuvent être trouvées ici google.github.io/android-gradle-dsl/current/ Vous pouvez également configurer les paramètres Gradle dans le fichier de paramètres, par exemple augmenter la taille maximale du tas dans le cas où vous avez un grand projet:

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

Voir toute la liste des paramètres ici: https://docs.gradle.org/current/userguide/userguide_single.html#sec:gradle_configuration_properties pour plus de détails.

Étape 4: désactivation de l'antivirus Envisagez d'exclure les fichiers de projet et de cache de l'analyse antivirus. C'est évidemment un compromis avec la sécurité. Mais si vous basculez souvent entre les branches, l'antivirus réanalysera les fichiers avant d'autoriser le processus Gradle à l'utiliser, ce qui ralentit le temps de construction (en particulier le projet de synchronisation Android Studio avec les fichiers Gradle et les tâches d'indexation). Mesurez le temps de génération et traitez le processeur avec et sans antivirus activé pour voir s'il est lié. J'espère que ça aide. Laissez un commentaire si vous avez des questions ou d'autres conseils pour améliorer les performances de construction.

lien utile

Si vous utilisez les services google play, dépendre uniquement des bibliothèques dont vous avez besoin au lieu de l'ensemble du blob peut accélérer les choses.

Si vous n'avez besoin que de cartes, utilisez:

compile 'com.google.android.gms:play-services-maps:6.5.+'

au lieu de:

compile 'com.google.android.gms:play-services:6.5.+'

Ce dernier apporte 20k méthodes (voir blog) dans le chemin de classe, ce qui pourrait faire basculer le nombre total de méthodes sur 64k.

Cela forcerait l'utilisation de proguard ou multidex même pour les versions de débogage. Pour l'un de mes projets, j'ai eu les temps de construction suivants

• build multidex (avec supportlibrary) ~ 40sec
• proguard build ~ 20sec
• construire quand la limite de méthode <64k ~ 5sec

Si vous développez sur sdk 21+, il serait possible d'optimiser les builds multidex comme indiqué dans la documentation Android

android {
    productFlavors {
        // Define separate dev and prod product flavors.
        dev {
            // dev utilizes minSDKVersion = 21 to allow the Android gradle plugin
            // to pre-dex each module and produce an APK that can be tested on
            // Android Lollipop without time consuming dex merging processes.
            minSdkVersion 21
        }
        prod {
            // The actual minSdkVersion for the application.
            minSdkVersion 14
        }
    }
    ...
}

La réponse acceptée concerne les anciennes versions d'Android Studio et la plupart d'entre elles fonctionnent encore maintenant. La mise à jour d'Android Studio l'a rendu un peu plus rapide. Ne vous embêtez pas à spécifier la taille du tas car elle augmentera automatiquement avec l'augmentation de Xms et Xmx. Voici quelques modifications avec les VMoptions

1. Dans le dossier bin, il y a un fichier studio.vmoptions pour définir la configuration de l'environnement. Dans mon cas, c'est studio64.vmoptions Ajoutez les lignes suivantes si elles ne sont pas déjà ajoutées et enregistrez le fichier. Dans mon cas, j'ai 8 Go de RAM.

   -Xms4096m
   -Xmx4096m
   -XX:MaxPermSize=2048m
   -XX:+CMSClassUnloadingEnabled
   -XX:+CMSPermGenSweepingEnabled 
   -XX:+HeapDumpOnOutOfMemoryError
   -Dfile.encoding=utf-8`

2. Démarrez Android Studio. Allez dans File-> Settings-> Build, Execution, Deployment-> Compiler

   • Vérifier la compilation de modules indépendants en parallèle
   • Dans les options de ligne de commande, écrivez: --offline
   • Cochez Créer un projet automatiquement
   • Vérifier configurer à la demande

En cas d'utilisation de mac, au début, je n'ai pas pu trouver les vmoptions. Quoi qu'il en soit, voici un bel article sur la façon dont nous pouvons changer les vmoptions dans MAC OSX . Citant cet article ici.

Ouvrez votre terminal et mettez cette commande pour ouvrir les vmoptions dans MAC OSX:

open -e /Applications/Android\ Studio.app/Contents/bin/studio.vmoptions

Créez simplement 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

Pour moi, la vitesse est maintenant égale à Eclipse.

Source: https://www.timroes.de/2013/09/12/speed-up-gradle/

Vous pouvez accélérer le processus si vous utilisez gradle depuis la ligne de commande. Il y a beaucoup d'optimisation à faire pour les développeurs IDE. Mais ce n'est qu'une première version.

Pour plus d'informations, lisez cette discussion sur g + avec certains des développeurs.

Si quelqu'un travaille sur un projet synchronisé via Subversion et que cela se produit toujours, je pense que cela peut ralentir le processus de workflow dans Android Studio. Par exemple, si cela fonctionne très lentement: défilement dans une classe, xml, etc., alors que mon application est toujours en cours d'exécution sur mon appareil.

• Accédez au contrôle de version dans les préférences et définissez Subversion sur Aucun.

Mettre à jour après Android Studio 2.3

Toutes les réponses sont excellentes et j'encourage à utiliser ces méthodes avec celle-ci pour améliorer la vitesse de construction.

Après la sortie d'Android 2.2 en septembre 2016, Android a publié une fonctionnalité de cache de construction expérimentale pour accélérer les gradleperformances de construction, qui est maintenant officielle à partir d'Android Studio 2.3 Canary. (Note de version officielle)

Il introduit une nouvelle fonctionnalité de cache de génération, qui est activée par défaut, peut accélérer les temps de génération (y compris les versions complètes, les versions incrémentielles et l'exécution instantanée) en stockant et en réutilisant les fichiers / répertoires qui ont été créés dans les versions précédentes du même Android ou de différents Android projet.

Comment utiliser:

Ajoutez la ligne suivante dans votre gradle.propertiesfichier

android.enableBuildCache = true
# Set to true or false to enable or disable the build cache. If this parameter is not set, the build cache is enable by default.

Nettoyez le cache:

• Une nouvelle tâche Gradle cleanBuildCachevous est demandée pour nettoyer plus facilement le cache de génération. Vous pouvez l'utiliser en tapant ce qui suit dans votre terminal:

  ./gradlew cleanBuildCache

• OU Vous pouvez nettoyer le cache pour Android studio 2.2 en supprimant tous les fichiers stockés à l'emplacement

  C:\Users\<username>\.android\build-cache

Après avoir modifié ces paramètres, ma durée de compilation de 10 minutes est passée à ~ 10 secondes.

Étape 1:

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

Construction, exécution, déploiement ->

Compilateur ->

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

Étape 2:

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

& cliquez sur Appliquer -> OK

Référence - https://www.sundoginteractive.com/blog/speed-up-gradle-in-android-studio

Désavantage:

Vous ne pourrez pas extraire les dernières versions des dépendances identifiées dans votre fichier build.gradle. Il s'exécute plus rapidement car il utilise un instantané mis en cache de ces bibliothèques importées.

Remarque importante : lorsque vous déployez l'application, supprimez ces paramètres et créez avec les dernières versions des dépendances.

Résolu le mien avec

File -> Settings -> Build, Execution, Deployment -> Build Tools -> Gradle -> Offline work

Les versions de Gradle sont passées de 8 minutes à 3 secondes.

Voici ce qui a aidé ce débutant programmeur Android (ancien programmeur professionnel, il y a des années) à accélérer Android Studio 2.2. Je sais que c'est un remaniement, mais, juste résumer en un seul endroit.

Les versions initiales peuvent encore être brutalement lentes, mais les redémarrages des applications en cours d'exécution sont désormais généralement très tolérables. J'utilise un PC sous-optimal: AMD Quad-Core A8-7410 CPU, 8 Mo de RAM, non-SSD HD, Win 10. (Et, c'est ma première publication Stack Overflow ....;)

DANS LES PARAMÈTRES -> GRADLE:

oui pour "Travail hors ligne" (c'est peut-être le paramètre le plus important).

DANS LES PARAMÈTRES -> COMPILATEUR:

oui pour "Compiler des modules indépendants en parallèle" (je ne sais pas si cela aide en fait à utiliser des processeurs multicœurs).

DANS GRADLE SCRIPTS , "build.gradle (Module: app)":

defaultConfig {
    ...
   // keep min high so that restarted apps can be hotswapped...obviously, this is hugely faster.
   minSdkVersion 14
   ...
    // enabling multidex support...does make big difference for me.
    multiDexEnabled true

ÉGALEMENT DANS GRADLE SCRIPTS , "gradle.properties (Project Properties)":

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

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

De plus , les tests sur un périphérique physique au lieu de l'émulateur fonctionnent bien pour moi; une petite tablette qui tient debout est pratique.

Juste un autre conseil sur l'amélioration des performances:

Android Studio 3.0 inclut un nouveau compilateur DEX appelé D8.

"Le compilateur dex fonctionne principalement sous le capot dans le développement quotidien de votre application, mais il a un impact direct sur le temps de génération de votre application, la taille du fichier .dex et les performances d'exécution."

"Et lorsque l'on compare le nouveau compilateur D8 avec le compilateur DX actuel, D8 compile plus rapidement et génère des fichiers .dex plus petits, tout en ayant des performances d'exécution de l'application identiques ou supérieures."

D8 est facultatif - utilisez-le, nous devons le mettre à gradle.properties du projet

android.enableD8=true

Plus d'informations: https://android-developers.googleblog.com/2017/08/next-generation-dex-compiler-now-in.html

PS. Cela augmente mon temps de construction d'environ 30%.

Cette configuration va très vite pour moi (environ 2 secondes de construction)

build.gradle

android {

    dexOptions {
        incremental true
        preDexLibraries = false
        jumboMode = false
        maxProcessCount 4
        javaMaxHeapSize "6g"
    }
}

gradle.properties

org.gradle.daemon=true
org.gradle.parallel=true
org.gradle.jvmargs=-Xmx8192M

mon ordinateur:

• CPU Intel (R) Pentium (R) CPU G2030 @ 3.00GHz, 3000 Mhz, 2 procesadores principales, 2 procesadores lógicos
• x64
• Microsoft Windows 7 Professionnel
• (RAM) 16,0 Go

fichiers de projet
- Tous situés en HD local

Veuillez suivre les étapes suivantes.

1. Activer le mode hors ligne: veuillez vérifier ci-dessous l'écran d'impression.

   https://i.stack.imgur.com/RF9uG.png

2. Activer l'exécution instantanée: veuillez vérifier ci-dessous l'écran d'impression.

   https://i.stack.imgur.com/mvHKJ.png

   Si vous souhaitez en savoir plus sur l'exécution instantanée, veuillez visiter le site des développeurs Android.

Vous pouvez essayer d'ouvrir le menu Gradle sur le côté droit du studio, assembler uniquement les modules que vous avez modifiés, puis exécuter la commande d'installation. Lorsque vous appuyez sur Exécuter, il assemble tout, indépendamment des modifications que vous avez apportées au code qu'il assemble.

Je suis loin d'être un expert de Gradle mais mon environnement avait la ligne suivante dans .gradle / init.gradle

gradle.projectsLoaded {
    rootProject.allprojects {
        repositories {
            mavenRepo name: 'libs-repo', url: 'http://guest-vm/artifactory/repo'
        }
    }
}

Pourtant, je ne sais pas pourquoi cette ligne était là, mais j'essaie de changer pour

gradle.projectsLoaded {
    rootProject.allprojects {
        repositories {
            mavenCentral()
        }
    }
} 

et maintenant je peux enfin travailler sans jurer sur le schéma de buildind Android Studio & Gradle.

Dans notre cas spécifique, le problème était dû à la retrolambda plugin , qui obligeait tous les projets et sous-projets à se recompiler chaque fois que nous essayions de lancer notre application, même si aucun code n'avait été modifié dans nos modules de base.

La suppression de retrolamba l'a corrigé pour nous. J'espère que cela aide quelqu'un.

Essayez d'abord cela. C'est mon expérience personnelle.

J'ai eu le même problème. Ce que j'avais fait était simplement de désactiver définitivement l'antivirus (le mien était Avast Security 2015). Juste après avoir désactivé l'antivirus, tout s'est bien passé. le gradle s'est terminé avec succès. À partir de maintenant, en quelques secondes, le gradle se termine (ne prend que 5 à 10 secondes).

Salut, je sais que c'est une réponse très très tardive, mais peut-être aider quelqu'un
dans mon cas que j'utilisais

compile 'com.android.support:support-v4:23.1.1'

dans mon application Gradle dépendance
mais dans l'une de mes bibliothèques, il était

 compile 'com.android.support:support-v4:23.0.1'

après avoir tout changé pour la dernière version, mon problème a été résolu.

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

UTILISER ce sudo dpkg --add-architecture i386 sudo apt-get update sudo apt-get install libncurses5: i386 libstdc ++ 6: i386 zlib1g: i386

Android Studio ne parvient pas à créer un nouveau projet, a expiré lors de l'attente du processus d'aapt esclave

Un changement trivial (à un xml resoruce) a encore pris 10 minutes . Comme @rivare le dit dans sa réponse, une construction en ligne de commande est plus rapide (cela a pris 15 secondes ).
Voici quelques étapes pour accélérer au moins une construction triviale à partir de la ligne de commande pour Windows.

1. Accédez à la racine de vos projets (où se trouve gradlew.bat):

   cd c: \ android \ MaskActivity

2. exécutez la construction :

   gradlew assembleDebug

3. désinstallez l'apk du téléphone directement (faites-le glisser pour désinstaller).

4. Une fois la génération terminée, supprimez le GRAND processus java à l'aide du Gestionnaire des tâches de Windows.

OU si vous avez des outils Unix sur votre machine Windows:

ps

les "pid" sont affichés:

kill -9 <pid>

5. Maintenant installez votre apk:

   adb -d installe C: \ Android \ MaskActivity \ app \ build \ outputs \ apk \ app-debug.apk

Selon la documentation Android , ajoutez ceci dans le fichier gradle du module d'application.

android {
    ...
    dexOptions {
    preDexLibraries true
    maxProcessCount 8
    }
}

Pour exécuter l'environnement Android sur une machine à faible configuration.

1. Fermez les onglets Web non censurés dans le navigateur
2. Pour les utilisateurs d'Antivirus, excluez le dossier de génération qui est généré automatiquement

3. Le studio Android dispose d'un segment de mémoire par défaut de 1,2 Go pouvant diminuer à 512 Mo Aide> Modifier les options de machine virtuelle personnalisées studio.vmoptions -Xmx512m Les performances des mises en page seront accélérées

4. Pour Gradle, l'un des composants de base du studio Android Mkae, comme en ce moment, 3.0beta est le dernier

Les conseils ci-dessous peuvent affecter la qualité du code, veuillez donc les utiliser avec prudence:

1. Studio contient le mode Power Safe lorsqu'il est activé, il fermera les opérations en arrière-plan qui peluchent, les compléments de code, etc.

2. Vous pouvez exécuter manuellement lintcheck si nécessaire ./gradlew lint

3. La plupart utilisent des émulateurs Android en moyenne, ils consomment 2 Go de RAM, donc si possible, utilisez un appareil Android réel, cela réduira votre charge de ressources sur votre ordinateur. Alternativement, vous pouvez réduire la RAM de l'émulateur et cela réduira automatiquement la consommation de mémoire virtuelle sur votre ordinateur. vous pouvez le trouver dans la configuration de l'appareil virtuel et les paramètres avancés.

4. Le mode hors ligne Gradle est une fonctionnalité permettant aux utilisateurs à bande passante limitée de désactiver le téléchargement des dépendances de génération. Cela réduira le fonctionnement en arrière-plan qui contribuera à augmenter les performances d'Android studio.

5. Le studio Android propose une optimisation pour compiler plusieurs modules en parallèle. Sur les machines à faible RAM, cette fonctionnalité aura probablement un impact négatif sur les performances. Vous pouvez le désactiver dans la boîte de dialogue des paramètres du compilateur.