La création et l'exécution de l'application via Gradle et Android Studio est plus lente que via Eclipse.
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 manière d'accélérer ce processus?
Dans Eclipse, grâce à la création 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 sur SSD et sur des tonnes de bélier a probablement une plus grande influence que les points combinés.
Versions d'outils
L'augmentation des performances de construction étant une priorité majeure pour les équipes de développement, assurez-vous d'utiliser les versions les plus récentes Gradle et Android Gradle Plugin .
Fichier de configuration
Créez un fichier nommé gradle.properties dans le répertoire qui convient:
/home/<username>/.gradle/(Linux)/Users/<username>/.gradle/(Mac)C:\Users\<username>\.gradle(Windows)
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 de Gradle fonctionnent localement si vous les placez à projectRoot\gradle.properties et globalement si vous les placez à user_home\.gradle\gradle.properties. Propriétés appliquées si vous exécutez des tâches de dégradé à partir de la console ou directement à partir d'une idée:
Paramètres IDE
Il est possible de modifier l’intégration Gradle-IntelliJ à partir de l’interface graphique IDE. L'activation du "travail hors connexion" (cochez la réponse de yava ci-dessous) désactivera les requêtes réseau réelles sur chaque "fichier de dégradé de synchronisation".
Multi-dex natif
L'une des étapes les plus lentes de la construction de l'apk est la conversion du bytecode Java en un fichier dex unique. L'activation de multidex natif (minSdk 21 pour les versions de débogage uniquement) aidera l'outil à réduire la quantité de travail (vérifiez la réponse dans Aksel Willgert ci-dessous).
Les dépendances
Préférez les dépendances @aar par rapport aux sous-projets de la bibliothèque.
Recherchez un package aar sur mavenCentral , jCenter ou utilisez jitpack.io pour construire une bibliothèque à partir de github. Si vous ne modifiez pas les sources de la bibliothèque de dépendances, vous ne devez pas la construire à chaque fois avec vos sources de projet.
Antivirus
Pensez à exclure les fichiers de projet et les fichiers en cache de l'analyse antivirus. C'est évidemment un compromis avec la sécurité (n'essayez pas cela à la maison!). Mais si vous changez beaucoup de branches, l’antivirus réanalysera les fichiers avant de permettre son utilisation par le processus de gradation, ce qui ralentira le temps de construction (notamment le projet de synchronisation AndroidStudio avec des fichiers de gradation et des tâches d’indexation). Mesurez le temps de construction et traitez la CPU avec et sans antivirus activé pour voir s'il est lié.
Profiler une construction
Gradle a un support intégré pour projets de profilage . Différents projets utilisent une combinaison différente de plugins et de scripts personnalisés. Utiliser --profile aidera à trouver les goulots d'étranglement.
Vous pouvez ignorer les vérifications Gradle Update-to-Date.
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)
bas de ~ 30 + sec à ~ 3 sec
Recherché partout pour cela et finalement trouvé une solution qui fonctionne pour nous. L'activation de constructions parallèles (sous OSX: preferences -> compiler -> gradle -> "Compile independent modules in parallel") et l'activation de la fonction "Créer automatiquement le projet" l'ont ramené de ~ 1 min à ~ 20 s. 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 disque SSD et je suis passé de Windows à Linux. Mes temps de construction sont maintenant beaucoup plus rapides et ne sont plus gênants.
Bien que cela ne réponde pas directement à votre question quant à la raison pour laquelle c'est plus lent qu'Eclipse, cela montre que le processus est lié au disque et qu'une mise à niveau vers un SSD pourrait être une solution (un peu coûteuse). Je suppose qu'il y aura des gens qui googleront la question et finiront ici, qui apprécieront peut-être mon expérience.
Si vous utilisez les services de Google Play, le simple fait de ne disposer que de la totalité des objets blob dépend des bibliothèques dont vous avez besoin pour accélérer le processus.
Si votre seul besoin est des 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 classpath, 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
- construction multidex (avec supportlibrary) ~ 40sec
- proguard construire ~ 20sec
- construire quand la limite de la méthode est <64k ~ 5sec
Si vous développez sur sdk 21+, il serait possible d'optimiser les versions 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
}
}
...
}
Accélérez la construction de Gradle dans Android Studio 3.2.1
Avez-vous déjà eu l'impression que vous attendiez la fin des versions dans Android Studio pendant quelques minutes? Moi aussi. Et c’est assez ennuyant. Heureusement, il existe plusieurs moyens d’améliorer cette situation. Android utilise Gradle pour la construction. La dernière version, la 4.6, améliore considérablement les performances par rapport aux versions précédentes (voir Notes de version pour plus de détails).
Étape 1: Mettre à jour la version de Gradle Une méthode plus simple consiste à accéder à: Paramètres du module ouvert (votre projet)> Structure du projet
UPDATE
Changer pour Gradle version: 4.6 et changer pour Version du plug-in Android: 3.2.1
Téléchargez la version distribuée de Gradle à partir de https://services.gradle.org/distributions/gradle-4.6-all.Zip et copiez-le dans le dossier Gradle:
La dernière étape consiste à ajouter votre distribution dans Paramètres> Graduer
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 du projet. Le mode hors ligne indique à Gradle d'ignorer les contrôles de mise à jour. Gradle demande à chaque fois des dépendances et cette option lui permet d'utiliser simplement ce qui est déjà sur la machine pour les dépendances. Allez dans Gradle depuis Android Studio Setting et cliquez sur dans la zone de travail Hors connexion.
- Accédez au compilateur à partir de Android studio Configuration et ajoutez "- hors connexion" dans la zone de ligne de commande, puis cliquez sur Compiler les modules indépendants en parallèle.
L'étape suivante consiste à activer le démon Gradle et la construction parallèle pour votre projet. Les constructions parallèles entraîneront la construction parallèle de vos projets comportant plusieurs modules (constructions multi-projets dans Gradle), ce qui devrait permettre d'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 (~/.gradle/gradle.properties). Certaines de ces options (par exemple, Complie des modules en parallèle) sont disponibles à partir de Android. Studio et également activé par défaut, mais les placer dans le fichier gradle.properties les activera lors de la création à partir du terminal et garantira également que vos collègues utiliseront les mêmes paramètres. Mais si vous travaillez en équipe, vous ne pouvez parfois pas commettre 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 versions, car il ne sera pas nécessaire de lancer l’application Gradle au complet à chaque fois. Le démon Gradle n’est pas activé par défaut, mais il est recommandé de toujours l’activer pour les ordinateurs des développeurs (en le laissant désactivé pour les serveurs à intégration continue). FAQ à propos de ce mode peut être trouvé ici https://docs.gradle.org/current/userguide/gradle_daemon.html . Le paramètre de construction parallèle peut être dangereux pour certains projets. La condition est que tous vos modules doivent être découplés ou votre construction pourrait échouer (voir http://gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects pour plus de détails).
Étape 3: Activez les paramètres de mémoire incrémentielle dexign et Tweak Vous pouvez accélérer vos constructions en activant la fonction dexage incrémental. 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. Vous trouverez des informations supplémentaires à ce sujet ici google.github.io/Android-gradle-dsl/current/ Vous pouvez également configurer les paramètres Gradle dans le fichier de paramètres, par exemple. augmentez la taille maximale du tas si vous avez un gros 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ésactivez l'antivirus Pensez à exclure les fichiers de projet et les fichiers en cache de l'analyse antivirus. C'est évidemment un compromis avec la sécurité. Mais si vous changez beaucoup de branches, l’antivirus réanalysera les fichiers avant de permettre son utilisation par le processus de gradation, ce qui ralentira le temps de construction (en particulier Android Projet de synchronisation Studio avec des fichiers de gradation et des tâches d’indexation). Mesurez le temps de construction et traitez la CPU 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 des astuces pour améliorer les performances de construction.
La réponse acceptée concerne les anciennes versions de Android studio et la plupart d'entre elles fonctionnent encore maintenant. La mise à jour de Android studio accélère un peu le processus. Ne prenez pas la peine de spécifier la taille du tas, car elle augmentera automatiquement avec l'augmentation de Xms et Xmx. Voici quelques modifications avec les VMoptions
Dans le dossier bin, un fichier studio.vmoptions permet de définir la configuration de l'environnement. Dans mon cas, il s'agit de 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`Démarrer le studio Android. Allez dans Fichier-> Paramètres-> Générer, Exécuter, Déployer-> Compilateur
- Vérifier la compilation de modules indépendants en parallèle
- Dans les options de ligne de commande, écrivez: --offline
- Vérifier le projet automatiquement
- Vérifier la configuration à la demande
En cas d'utilisation de mac, au début, je ne pouvais pas trouver les vmoptions. Quoi qu'il en soit, voici un article intéressant 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.
Vous pouvez accélérer le processus si vous utilisez gradle à partir de 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 flux de travail dans Android Studio. Par exemple, si cela fonctionne très lentement lors du défilement dans une classe, xml, etc., alors que mon application est toujours en cours d'exécution sur mon appareil.
- Accédez à Contrôle de version dans Préférences et définissez Subversion sur Aucun .
![enter image description here]()
Mise à jour après Android Studio 2.3
Toutes les réponses sont bonnes et j'encourage à utiliser ces méthodes avec celle-ci pour améliorer la vitesse de construction.
Après la sortie de Android 2.2 en septembre 2016, Android a publié la fonctionnalité de cache de construction expérimentale afin d'accélérer les performances de construction de gradle. qui est maintenant officiel de Android Studio 2.3 Canary. (Note de sortie officielle)
Il introduit une nouvelle fonctionnalité de cache de construction, activée par défaut, peut accélérer les temps de construction (y compris les versions complètes, incrémentielles et instantanées) en stockant et en réutilisant les fichiers/répertoires créés dans les versions précédentes de la même ou de différentes Android projet.
Comment utiliser:
Ajouter la ligne suivante dans votre fichier gradle.properties
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.
Nettoyer le cache:
Une nouvelle tâche Gradle appelée
cleanBuildCachevous permet de nettoyer plus facilement le cache de génération. Vous pouvez l'utiliser en tapant ce qui suit dans votre terminal:./gradlew cleanBuildCacheOU 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 a été changée en ~ 10 secondes.
Étape 1:
Paramètres (Ctrl + Alt + S) ->
Construction, exécution, déploiement ->
Compilateur ->
tapez "
--offline" dans la boîte de dialogue Options de la ligne de commande.
Étape 2:
cochez la case "Compiler les modules indépendants en parallèle".
& cliquez sur Apply -> OK
Référence - https://www.sundoginteractive.com/blog/speed-up-gradle-in-Android-studio
Inconvénient:
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é en cache de ces bibliothèques importées.
Remarque importante : lorsque vous déployez l'application, supprimez ces paramètres et créez-la avec les dernières versions de dépendances.
Le mien résolu avec
File -> Settings -> Build, Execution, Deployment -> Build Tools ->Gradle -> Offline work
Les constructions de Gradle sont passées de 8 minutes à 3 secondes.
Juste un autre conseil d’amélioration des performances:
Android Studio 3.0 inclut un nouveau compilateur DEX appelé D8.
"Le compilateur dex fonctionne principalement sous le capot du développement quotidien de votre application, mais il a un impact direct sur le temps de création de votre application, la taille de son fichier .dex et ses 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 obtenant des performances d'exécution égales ou meilleures."
D8 est optionnel - utilisez-le, vous devez le mettre dans le fichier 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 d'environ 30% mon temps de construction.
Voici ce qui a aidé ce débutant Android programmeur (ancien programmeur professionnel, il y a des années) à accélérer Android Studio 2.2. Je sais que c'est un rehash, mais, juste résumant en un seul endroit.
Les versions initiales peuvent toujours être brutalement lentes, mais les redémarrages d'applications en cours d'exécution sont désormais généralement très tolérables. J'utilise un PC sous-optimal: processeur AMD Quad-Core A8-7410, 8 Mo de RAM, disque non SSD HD, Win 10. (Et, c'est mon premier postage de débordement de pile ...;)
IN SETTINGS -> GRADLE:
oui pour "Travail hors ligne" (c'est peut-être le paramètre le plus important).
IN SETTINGS -> COMPILER:
yes pour "Compiler des modules indépendants en parallèle" (ne sait pas si cela aide en fait à utiliser des CPU multicœurs).
DANS LES SCRIPTS DE GRADLE , "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
AUSSI DANS LES SCRIPTS DE GRADLE , "gradle.properties (Propriétés du projet)":
org.gradle.jvmargs = -Xmx3048m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8
org.gradle.parallel = true org.gradle.daemon = true
En outre , les tests sur un périphérique physique au lieu de l'émulateur fonctionnent bien pour moi. une petite tablette qui se lève est pratique.
Cette configuration va très vite pour moi (environ 2 secondes la 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 PC:
- CPU Intel (R) Pentium (R) CPU G2030 @ 3.00GHz, 3000 Mhz, 2 processeurs principaux, 2 processeurs de batterie
- x64
- Microsoft Windows 7 Professionnel
- (RAM) 16,0 Go
fichiers de projet
- Tous situés en HD local
Veuillez suivre les étapes suivantes.
Activer le mode hors ligne: Veuillez vérifier ci-dessous l’écran d’impression.
Activer Instant Run: 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 pour développeurs Android.
Vous pouvez essayer d'ouvrir le menu de niveaux sur le côté droit de studio et d'assembler uniquement les modules que vous avez modifiés, puis exécutez la commande install. Lorsque vous appuyez sur Exécuter, tout est assemblé, quelles que soient les modifications apportées au code qu’il assemble.
Dans notre cas spécifique, le problème était dû au plugin retrolambda, qui obligeait tous les projets et sous-projets à recompiler à chaque fois que nous essayions de lancer notre application, même si aucun code n'avait été modifié dans nos modules centraux.
Supprimer retrolamba l'a corrigé pour nous. J'espère que ça aide quelqu'un.
Selon le documentation Android , ajoutez ceci dans le fichier de classement du module d'application.
Android {
...
dexOptions {
preDexLibraries true
maxProcessCount 8
}
}
Essayez ceci d'abord. C'est mon expérience personnelle.
J'ai eu le même problème. Ce que j’avais fait est de désactiver l’antivirus de manière permanente (le mien était Avast Security 2015). Juste après la désactivation de l'antivirus, tout s'est bien passé. le grade terminé avec succès. A partir de maintenant, le classement est terminé en quelques secondes (5-10 secondes seulement).
Je suis loin d'être un expert de Gradle, mais mon environnement comportait la ligne suivante: .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 Android Studio & Gradle.
Pour exécuter Android environ sur une machine à configuration réduite.
- Fermez les onglets Web non moins importants dans le navigateur.
- Pour les utilisateurs d’Antivirus, excluez le dossier de construction généré automatiquement.
Le studio Android dispose de 1,2 Go de mémoire par défaut pouvant atteindre 512 Mo Aide> Modifier les options personnalisées VM options studio.vmoptions -Xmx512m Les performances des présentations sont accélérées
Pour Gradle, l’un des composants essentiels de Android studio Mkae est certain que sa version actuelle est la dernière version bêta.
Les astuces ci-dessous peuvent affecter la qualité du code, merci donc de les utiliser avec précaution:
Studio contient le mode d'alimentation sécurisée lorsqu'il est activé, il fermera les opérations en arrière-plan qui se ramollissent, complètent le code, etc.
Vous pouvez exécuter manuellement la vérification du peluche si nécessaire ./gradlew lint
La plupart utilisent des émulateurs Android en moyenne. Ils consomment en moyenne 2 Go RAM. Par conséquent, si possible, utilisez le périphérique Android actuel, ce qui réduira la charge de ressources de votre ordinateur. Vous pouvez également réduire la RAM de l'émulateur, ce qui réduira automatiquement la consommation de mémoire virtuelle sur votre ordinateur. vous pouvez le trouver dans la configuration de périphérique virtuel et les paramètres avancés.
Le mode hors connexion Gradle est une fonctionnalité permettant aux utilisateurs limités en bande passante de désactiver le téléchargement des dépendances de construction. Cela réduira le fonctionnement en arrière-plan, ce qui contribuera à améliorer les performances de Android studio.
Android studio offre une optimisation pour compiler plusieurs modules en parallèle. Sur les machines RAM faibles, 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.
Salut je sais que c'est très très tard répondre mais peut-être aider quelqu'un
Dans mon cas, j'utilisais
compile 'com.Android.support:support-v4:23.1.1'
dans ma dépendance à l'application
mais dans une de mes bibliothèques c'était
compile 'com.Android.support:support-v4:23.0.1'
après le changement tout à la dernière version mon problème résolu.
Suivre les étapes le rendra 10 fois plus rapide et réduira le temps de construction de 90%
Commencez par créer 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
Un changement trivial (en un fichier xml de résorption) prenait toujours 10 minutes. Comme @ rivare dit dans sa réponse, une construction en ligne de commande est beaucoup plus rapide (cela passe à 15secondes).
Voici quelques étapes pour au moins créer rapidement une construction triviale à partir de la ligne de commande de Windows.
Allez à la racine de vos projets (où se trouve le gradlew.bat):
cd c:\Android\MaskActivity
exécuter le build:
gradlew assembleDebug
désinstaller l'apk directement du téléphone (faites-le glisser pour désinstaller).
Lorsque la construction est terminée, kill le processus BIG Java à l'aide du gestionnaire de tâches Windows.
OU si vous avez des outils Unix sur votre machine Windows:
ps
Les "pid" sont affichés:
kill -9 <pid>
Maintenant installez votre apk:
adb -d install C:\Android\MasqueActivité\app\build\sorties\apk\app-debug.apk
UTILISEZ cette mise à jour Sudo dpkg --add-architecture i386 Sudo apt-get Sudo apt-get install libncurses5: i386 libstdc ++ 6: i386 zlib1g: i386