android-studio français - La création et l'exécution de l'application via Gradle et Android Studio est plus lente que via Eclipse




démarrer failed (23)

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

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

de ~ 30 + sec à ~ 3 sec

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 de rendre ce processus plus rapide?

Dans Eclipse, grâce à la construction automatique, exécuter le même projet sur un émulateur prend environ 3-5 secondes.

Ceci est 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
    }
}

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

Bien qu'il ne réponde pas directement à la question de savoir pourquoi il est plus lent que l'éclipse, il montre que le processus est limité par un disque et qu'une mise à niveau vers un SSD peut être une solution (plutôt coûteuse). Je suppose qu'il y aura des gens googler la question et se retrouver ici, qui pourrait apprécier mon expérience.


Si vous utilisez les services google play, en fonction des bibliothèques dont vous avez besoin au lieu de tout le blob, vous pouvez accélérer les choses.

Si votre seul besoin est 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 classpath, ce qui pourrait faire pencher le nombre total de méthodes sur 64k.

Cela forcerait l'utilisation de proguard ou de 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 la bibliothèque de support) ~ 40sec
  • proguard build ~ 20sec
  • construire quand la limite de la 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
        }
    }
    ...
}

Vous pouvez essayer d'ouvrir le menu gradle sur le côté droit du studio, et assembler seulement les modules que vous avez modifiés, puis exécutez la commande d'installation. Lorsque vous appuyez sur Exécuter, tout est assemblé sans tenir compte des modifications que vous avez apportées au code assemblé


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

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

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

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

après tout changer à la dernière version mon problème résolu.


Accélérer Build Gradle dans Android Studio 3.0

Avez-vous déjà l'impression que vous attendez que les builds se terminent dans Android Studio pour quelques minutes? Moi aussi. Et c'est plutôt ennuyant. Heureusement, il existe plusieurs façons d'améliorer cela. Android utilise Gradle pour la construction. La dernière version est 2.14.1 a une énorme amélioration des performances par rapport aux versions précédentes (voir les notes de version pour plus de détails).

Étape 1: Mettre à jour la version de Gradle Un moyen plus facile d'accomplir cela est d'aller à: Ouvrir les paramètres du module (votre projet)> Structure du projet

METTRE À JOUR

Passer à la version Gradle: 4.1 et Passer à la version du plug-in Android: 3.0.0

Téléchargez la distribution Gradle Release sur https://services.gradle.org/distributions/gradle-3.1-all.zip et copiez-la dans le dossier Gradle:

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

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

Étape 2: Activer le mode hors ligne, le démon Gradle et la génération parallèle pour le projet Le mode hors ligne indique à Gradle d'ignorer les vérifications de mise à jour à jour. Gradle demande des dépendances à chaque fois et avoir cette option fait qu'elle utilise simplement ce qui est déjà sur la machine pour les dépendances. Aller à Gradle from android studio Configuration et cliquez dans la zone de travail hors connexion.

  1. Aller au compilateur à partir de android studio Définir et ajouter "- hors ligne" dans la boîte 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 construction parallèle pour votre projet. Les constructions parallèles entraîneront la construction parallèle de vos projets avec plusieurs modules (builds multi-projets dans Gradle), 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 (par exemple, ~ / .gradle / gradle.properties). Certaines de ces options (par exemple Complie modules en parallèle) sont disponibles à partir d'Android Studio et également activées par par défaut, mais les mettre 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 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 builds car il n'aura pas besoin de démarrer l'application Gradle entière à 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). FAQ sur ce mode peut être trouvé ici https://docs.gradle.org/current/userguide/gradle_daemon.html . Le réglage des builds parallèles peut être dangereux pour certains projets. L'exigence 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: Activez les paramètres dexign incrémentiels et tweak memory Vous pouvez accélérer vos builds en activant le dexing 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 du tas pour le processus dex, par exemple:

dexOptions {
    incremental true
    javaMaxHeapSize "12g"
}

Où "12g" est de 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 de Gradle dans le fichier de paramètres, par exemple augmenter la taille maximale du tas au cas où vous auriez 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ésactiver l'antivirus Pensez à exclure les fichiers de projet et de cache de l'analyse antivirus. C'est évidemment un compromis avec la sécurité. Mais si vous changez souvent de branche, l'antivirus va réanalyser les fichiers avant de permettre à Gradle de l'utiliser, ce qui ralentit le temps de construction (en particulier le projet de synchronisation d'Android Studio avec les fichiers Gradle et les tâches d'indexation). Mesurer le temps de construction et traiter le processeur avec et sans antivirus activé pour voir si elle est liée. 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


Mise à jour après Android Studio 2.3

Toutes les réponses sont bonnes, et je vous 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é expérimentale de cache de build pour accélérer les performances de compilation, qui est désormais officielle sur Android Studio 2.3 Canary. (Note de sortie officielle)

Il introduit une nouvelle fonctionnalité de cache de build, activée par défaut, qui permet d'accélérer les temps de compilation (builds complets, builds incrémentaux et exécution instantanée) en stockant et en réutilisant des fichiers / répertoires créés dans des builds précédents du même Android ou différents. projet.

Comment utiliser:

Ajoutez 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.

Nettoyez le cache:

  • Il existe une nouvelle tâche Gradle appelée cleanBuildCache pour vous permettre de nettoyer plus facilement le cache de build. 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


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/


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

Les versions initiales peuvent toujours être très lentes, mais les redémarrages des applications en cours d'exécution sont généralement très tolérables. J'utilise un PC sous-optimal: CPU AMD Quad-Core A8-7410, 8 Mo de RAM, HD non-SSD, Win 10. (Et voici mon premier post de débordement de pile ....;)

DANS LES PARAMÈTRES -> GRADLE:

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

DANS LES RÉGLAGES -> COMPILER:

oui pour "Compiler des modules indépendants en parallèle" (pas sûr 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

AUSSI DANS GRADLE SCRIPTS , "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

De plus , tester sur un périphérique physique au lieu de l'émulateur fonctionne bien pour moi; une petite tablette qui se lève est pratique.


Je suis loin d'être un expert sur 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 je tente de changer pour

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

et maintenant je peux enfin travailler sans jurer sur le système de construction Android Studio & Gradle.


Résolu mine avec

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

Les constructions de gravure sont passées de 8 minutes à 3 secondes.


Dans notre cas, le problème était dû au plugin retrolambda , 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.

Enlever retrolamba l'a fixé pour nous. J'espère que ça aide quelqu'un.


La réponse acceptée est pour les anciennes versions de studio Android et la plupart d'entre eux fonctionne encore maintenant. La mise à jour du studio Android a rendu le tout un peu plus rapide. 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

  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émarrer le studio android. Allez dans Fichier-> Paramètres-> Générer, Exécution, Déploiement-> Compilateur

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

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

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

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

Si quelqu'un travaille sur un projet qui est synchronisé via Subversion et que cela se produit encore, je pense que cela peut ralentir le processus de workflow dans Android Studio. Par exemple, si cela fonctionne très lentement tout en: défilant dans une classe, xml etc, pendant 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.

Pour exécuter Android envirorment sur une machine à configuration basse.

  1. Fermez les onglets Web incohérents dans le navigateur
  2. Pour les utilisateurs d'antivirus, excluez le dossier de génération généré automatiquement
  3. Le studio Android a 1,2 Go par défaut Le tas peut diminuer jusqu'à 512 Mo Aide> Modifier les options personnalisées de la machine virtuelle studio.vmoptions -Xmx512m La performance des mises en page sera accélérée

  4. Pour Gradle l'un des composants de base dans Android studio Mkae sûr comme en ce moment 3.0beta est le dernier

Les conseils ci-dessous peuvent affecter la qualité du code, donc s'il vous plaît utiliser avec des précautions:

  1. Studio contient Power Safe Mode lorsqu'il est allumé, il ferme les opérations en arrière-plan que la charpie, les compléments de code et ainsi de suite.

  2. Vous pouvez exécuter manuellement le contrôle de linteau si nécessaire.

  3. La plupart utilisent des émulateurs Android en moyenne, il consomme 2 Go de RAM, donc si possible utiliser 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 dans les paramètres avancés.

  4. Gradle mode hors connexion est une fonctionnalité pour les utilisateurs de bande passante limitée pour désactiver le téléchargement des dépendances de construction. Cela réduira l'opération d'arrière-plan qui aidera à augmenter les performances du studio Android.

  5. Android studio offre 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.


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

Étape 1:

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

Construire, Exécuter, Déployer ->

Compilateur ->

tapez " --offline " dans la boîte Options de la ligne de commande.

Étape 2:

cochez la case "Compiler les 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.


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

  1. Allez à la racine de votre projet (où se trouve le gradlew.bat):

    cd c: \ android \ MaskActivity

  2. exécuter la construction :

    gradlew assemblerDebug

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

  4. Lorsque la construction est terminée, supprimez le processus BIG 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>
  1. Maintenant, installez votre apk:

    adb -d installer C: \ Android \ MaskActivity \ app \ build \ sorties \ apk \ app-debug.apk


Matériel

Je suis désolé, mais la mise à niveau de la station de développement à 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 d'utiliser le dernier Gradle et Android Gradle Plugin .

Fichier de configuration

Créez un fichier nommé gradle.properties dans n'importe quel répertoire:

  • /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 Gradle fonctionnent localement si vous les placez sur projectRoot\gradle.properties et globalement si vous les placez sur user_home\.gradle\gradle.properties . Propriétés appliquées si vous exécutez des tâches Gradle à partir de la console ou directement à partir de l'idée:

Paramètres IDE

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

Multi-dex natif

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

Dépendances

Préférer les dépendances @aar aux sous-projets de bibliothèque.

Recherchez un paquet aar sur mavenCentral , jCenter ou utilisez jitpack.io pour construire une bibliothèque depuis github. Si vous ne modifiez pas les sources de la bibliothèque de dépendances, vous ne devez pas la générer à 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é (ne l'essayez pas à la maison!). Mais si vous changez souvent de branche, l'antivirus va réanalyser les fichiers avant de permettre à Gradle de l'utiliser, ce qui ralentit le temps de construction (en particulier le projet de synchronisation AndroidStudio avec des fichiers gradués et des tâches d'indexation). Mesurer le temps de construction et traiter le processeur avec et sans antivirus activé pour voir si elle est liée.

Profilage d'une construction

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 de --profile aidera à trouver les goulots d'étranglement.


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

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

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 ordinateur:

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

fichiers de projet
- Tous situés en HD locale


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 voulez en savoir plus sur la course instantanée s'il vous plaît visitez le site développeur android.


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

J'ai eu le même problème. Ce que j'avais fait est juste désactiver de manière permanente l'antivirus (Mine était Avast Security 2015). Juste après la désactivation de l'antivirus, tout s'est bien passé. le gradle s'est terminé avec succès. A partir de maintenant en quelques secondes le gradle est en train de finir (ne prenant que 5-10 secondes).


The Android build system compiles app resources and source code, and packages them into APKs that you can test, deploy, sign, and distribute. Android Studio uses Gradle , an advanced build toolkit, to automate and manage the build process, while allowing you to define flexible custom build configurations. Each build configuration can define its own set of code and resources, while reusing the parts common to all versions of your app. The Android plugin for Gradle works with the build toolkit to provide processes and configurable settings that are specific to building and testing Android applications.







android gradle android-studio build.gradle