La creazione e l'esecuzione di app tramite Gradle e Android Studio è più lenta rispetto a Eclipse


461

Ho un multi-progetto (~ 10 moduli) il cui edificio impiega circa 20-30 secondi ogni volta. Quando premo Esegui in Android Studio, devo aspettare ogni volta per ricostruire l'app, che è estremamente lenta.

È possibile automatizzare il processo di costruzione in Android Studio? O hai qualche consiglio su come velocizzare questo processo?

In Eclipse, grazie alla costruzione automatica, l'esecuzione dello stesso progetto su un emulatore richiede circa 3-5 secondi.

Questo è il mio file build.gradle (modulo app):

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

23
Tieni presente che al momento né il sistema di build basato su Gradle né Android Studio sono di livello produttivo.
CommonsWare,

11
Il tempo trascorso qui è molto probabilmente nella fase DEXing. Sfortunatamente, la marca di Android Studio sembra eseguire un clean ogni volta, causando l'eliminazione dei file precedentemente dex. Speriamo di vedere presto una correzione incrementale della build.
Richard J. Ross III,

3
Nel frattempo, c'è un modo semplice per dire cambiando le attività Gradle predefinite in modo che non eseguano sempre una pulizia?
sigmabeta,

10
@CommonsWare bene, non ci sono scuse ora siamo sulla versione 1.02, ma è ancora un grosso problema. Con Android Studio in esecuzione, il mio laptop quad core da 4 GB utilizza circa 3,75 GB di RAM solo in possesso di una singola istanza di un progetto Hello World. È anche molto lento. Per me questo indica un difetto di progettazione serio e continuo. Spero che le cose si risolvano presto.
Andrew S,

7
@AndrewS Trovo che sia un peccato che dobbiamo cambiare il nostro sistema operativo solo per far funzionare Gradle a una velocità ragionevole rispetto agli strumenti precedenti.
Richard Le Mesurier,

Risposte:


441

Hardware

Mi dispiace, ma l'aggiornamento della stazione di sviluppo a SSD e tonnellate di ram ha probabilmente un'influenza maggiore rispetto ai punti sotto combinati.

Versioni degli strumenti

L'aumento delle prestazioni della build ha la massima priorità per i team di sviluppo, quindi assicurati di utilizzare il plug-in Gradle e Android Gradle più recente .

File di configurazione

Crea un file denominato gradle.propertiesin qualunque directory si applichi:

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

Aggiungere:

# 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

Le proprietà Gradle funzionano localmente se le posizionate in projectRoot\gradle.propertiese globalmente se le posizionate in user_home\.gradle\gradle.properties. Proprietà applicate se si eseguono attività gradle dalla console o direttamente dall'idea:

Impostazioni IDE

È possibile modificare l'integrazione Gradle-IntelliJ dalla GUI delle impostazioni IDE. L'attivazione di "lavoro offline" (controlla la risposta da yava di seguito) disattiverà le richieste di rete reali su ogni "file di sincronizzazione graduale".

Impostazioni IDE

Multi-dex nativo

Uno dei passaggi più lenti della build di apk è la conversione del bytecode java in un singolo file dex. Abilitare il multidex nativo (minSdk 21 solo per build di debug) aiuterà gli strumenti a ridurre una quantità di lavoro (controlla la risposta da Aksel Willgert di seguito).

dipendenze

Preferire le @aardipendenze rispetto ai sottoprogetti della biblioteca.

Cerca un pacchetto su mavenCentral , jCenter o usa jitpack.io per compilare qualsiasi libreria da github. Se non si stanno modificando le origini della libreria delle dipendenze non è necessario crearla ogni volta con le origini del progetto.

Antivirus

Considerare di escludere i file di progetto e cache dalla scansione antivirus. Questo è ovviamente un compromesso con la sicurezza (non provarlo a casa!). Ma se si passa molto da un ramo all'altro, l'antivirus eseguirà nuovamente la scansione dei file prima di consentire l'utilizzo del processo Gradle, il che rallenta i tempi di costruzione (in particolare il progetto di sincronizzazione di AndroidStudio con file Gradle e attività di indicizzazione). Misura i tempi di compilazione ed elabora la CPU con e senza antivirus abilitato per vedere se è correlata.

Profilare una build

Gradle ha il supporto integrato per i progetti di profilazione . Diversi progetti utilizzano una diversa combinazione di plug-in e script personalizzati. L'utilizzo --profileaiuterà a trovare i colli di bottiglia.


1
sulle dipendenze di @aar: usare eg dependencies {compile 'com.android.support:support-v4:21.0.+'}è una soluzione lenta? non sono sicuro di capire
younes0

1
Imaging, hai aggiunto una libreria come questa: github.com/novak/numberpicker . Ha valore, fornendo una soluzione di codice per un problema, ma l'autore non lo ha pubblicato da nessuna parte come Maven o JCenter. Ora stai portando quella libreria come fonti nel tuo progetto e la costruisci ogni volta che il progetto principale lo compila o la compili una volta e impegna solo @aar nel tuo repository del progetto. Quindi è davvero una scelta di dipendenza sorgente / binaria. Se non stai modificando l'origine, dovresti portare la tua dipendenza come binario precompilato. Per le semplici librerie Java che sono .jar, per le librerie Android che sono .aar
Sergii Pechenizkyi,

1
Sono le impostazioni del progetto> gradle. Vedi screenshot qui sotto: i.stack.imgur.com/wrwgo.png
Sergii Pechenizkyi,

2
Ho impostato tutte le ottimizzazioni come descritto, tuttavia in Android Studio sono necessari da 3 a 4 minuti per avviare la mia app, mentre in Eclipse sono trascorsi circa 30 secondi. Una schifezza. Solo 12 progetti, un'unica app da eseguire! Lo sviluppatore Android è diventato così ingombrante ora, e questo è più di un anno dopo.
3c71,

1
Ho applicato tutte le ottimizzazioni e ci vogliono ancora circa 20 secondi per creare un apk HelloWorld, rispetto ai 2-3 secondi in Eclipse.
Pawel,

148

È possibile ignorare i controlli di aggiornamento aggiornato graduale.

inserisci qui la descrizione dell'immagine

Per Windows con Android Studio 1.5: vai a File -> Settings -> Build, Execution, Deployment -> Build tools -> Gradle -> Check Offline work (as shown in image)

da ~ 30 + sec a ~ 3 sec


24
È piuttosto bello. Questo è MOLTO più veloce. Ma cosa rompe questo?
John Ballinger,

2
Soluzione migliore. Posso conoscere gli effetti collaterali di questa soluzione
Kavin Varnan,

26
@JohnBallinger Lavoro offline: utilizzare questa casella di controllo per lavorare con Gradle in modalità offline. In questo caso Gradle utilizzerà le dipendenze dalla cache. Gradle non tenterà di accedere alla rete per eseguire la risoluzione delle dipendenze. Se le dipendenze richieste non sono presenti nella cache delle dipendenze, l'esecuzione di una build fallirà. (Fonte: jetbrains.com/idea/help/gradle-2.html )
cprcrack,

10
L'impostazione predefinita utilizza le dipendenze memorizzate nella cache prima di accedere alla rete? Non riesco a immaginare questo controllo per le dipendenze aggiornate ogni volta che gradleviene eseguito. È bizzarro.
Ehtesh Choudhury,

1
@EhteshChoudhury è MOLTO bizzarro. L'intero ambiente di sviluppo di Gradle / Android Studio è così slooooooow. Molte persone pensano che sia lento a causa di Java. Faccio lo sviluppo Java lato server su IDEA e le cose funzionano molto bene.
stepanian

34

Cercato ovunque per questo e finalmente trovato una soluzione che funziona per noi. Abilitare build parallele (su OSX:) preferences -> compiler -> gradle -> "Compile independent modules in parallel"e abilitare 'make project automaticamente' lo ha portato da ~ 1 minuto a ~ 20 sec. Grazie a / u / Covalence.

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


56
20 secondi è ancora terribilmente lento.
Johannes Brodwall,

6
Tieni presente che questo sembra essere utile solo quando hai più moduli / progetti indipendenti. L'ho provato su un'app a modulo singolo e non ha fatto alcuna differenza.
Sam,

Ho un progetto piuttosto grande e ci vogliono 2-3 minuti su MacBook Pro 2012 Core i7, 8 GB di RAM. Va bene?
Sermilion,

25

Di recente ho acquistato un nuovo SSD e sono passato da Windows a Linux. I miei tempi di costruzione sono ora un ordine di grandezza più veloce e non più fastidioso.

Sebbene non risponda direttamente alla tua domanda sul perché sia ​​più lento dell'eclissi, mostra che il processo è limitato al disco e che l'aggiornamento a un SSD potrebbe essere una soluzione (piuttosto costosa). Immagino che ci saranno persone che cercano su Google il problema e finiscono qui, che potrebbero apprezzare la mia esperienza.


11
Gli sviluppatori del mio team hanno SSD veloci in macchine veloci con molta memoria. Per un'app non banale, la ridistribuzione dopo una piccola modifica del codice richiede ancora circa ~ 45 secondi, rispetto alla ridistribuzione quasi istantanea in Eclipse. Anche l'esecuzione di una JUnit semplice e non Android è proibitivamente lenta. "L'aggiornamento" ad Android Studio e Gradle è stato finora un grande downgrade. : - /
spaaarky21

@Lionleaf quanto passa più velocemente da Windows a Linux?
yo00

@ younes0 Non lo so. Sono passato a Linux contemporaneamente a un SSD. Non sto dicendo che abbia alcun effetto positivo, erano solo quelle due variabili che ho cambiato per lo speedup.
Andreas Løve Selvik,

4
Nel mio caso il passaggio da Windows a Linux ha comportato build Android più veloci del 40% ... quindi ne vale sicuramente la pena
kosiara - Bartosz Kosarzycki,

Dico ciò che ha detto @Bartosz Kosarzycki. Ho finito per eseguire un Ubuntu VM con Virtualbox sul mio computer di sviluppo. ~ 54 secondi di build su Windows, ~ 7sec per la stessa build all'interno della macchina virtuale sullo stesso hardware. Accelerazione folle passando a Linux.
Eric Cornelson,

20

Accelerare la compilazione di gradi in Android Studio 3.2.1

Hai mai pensato di aspettare il completamento delle build in Android Studio per pochi minuti? Anch'io. Ed è piuttosto fastidioso. Fortunatamente, ci sono alcuni modi che è possibile utilizzare per migliorare questo. Android utilizza Gradle per la costruzione. L'ultima versione è 4.6 ha un enorme aumento delle prestazioni rispetto alle versioni precedenti (vedere le note di rilascio per i dettagli).

Passaggio 1: Aggiorna la versione di Gradle Un modo più semplice per raggiungere questo obiettivo è andare a: Apri le impostazioni del modulo (il tuo progetto)> Struttura del progetto

inserisci qui la descrizione dell'immagine

AGGIORNARE

Passa alla versione Gradle: 4.6 e passa alla versione del plug-in Android: 3.2.1

inserisci qui la descrizione dell'immagine

Scarica il distributore Gradle Release da https://services.gradle.org/distributions/gradle-4.6-all.zip e copialo nella cartella Gradle:

inserisci qui la descrizione dell'immagine

L'ultimo passo è aggiungere la tua discrezione in Impostazioni> Grado

inserisci qui la descrizione dell'immagine

Non dimenticare di fare clic su Applica per salvare le modifiche.

Passaggio 2: abilitare la modalità offline, il demone Gradle e la build parallela per il progetto La modalità offline dice a Gradle di ignorare i controlli aggiornati. Gradle chiede dipendenze ogni volta e questa opzione consente di utilizzare solo le dipendenze già presenti sulla macchina. Vai a Gradle da Android Studio Setting e fai clic nella casella di lavoro Offline.

inserisci qui la descrizione dell'immagine

  1. Vai a Compilatore da Android Studio Impostazione e aggiungi "- offline" nella casella della riga di comando e fai clic su Compila moduli indipendenti in parallelo.

inserisci qui la descrizione dell'immagine

Il prossimo passo è abilitare il demone Gradle e la build parallela per il tuo progetto. Le build parallele faranno sì che i tuoi progetti con più moduli (build multiprogetto in Gradle) vengano costruiti in parallelo, il che dovrebbe rendere i progetti di grandi dimensioni o modulari più veloci.

inserisci qui la descrizione dell'immagine

Queste impostazioni potrebbero essere abilitate modificando un file chiamato gradle.properties nella directory degli script Gradle (ad es. ~ / .Gradle / gradle.properties). Alcune di queste opzioni (ad es. Moduli Complie in parallelo) sono disponibili da Android Studio e abilitate lì da impostazione predefinita, ma inserendoli nel file gradle.properties li abiliteranno durante la compilazione dal terminale e assicurandoti anche che i tuoi colleghi utilizzino le stesse impostazioni. Ma se stai lavorando in una squadra, a volte non puoi commettere queste cose.

# 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'uso del demone renderà più veloce l'avvio delle build in quanto non sarà necessario avviare ogni volta l'intera applicazione Gradle. Gradle Daemon non è abilitato per impostazione predefinita, ma è consigliabile abilitarlo sempre per le macchine degli sviluppatori (ma lasciandolo disabilitato per i server di integrazione continua). Le domande frequenti su questa modalità sono disponibili qui https://docs.gradle.org/current/userguide/gradle_daemon.html . L'impostazione di build parallele potrebbe non essere sicura per alcuni progetti. Il requisito è che tutti i tuoi moduli debbano essere disaccoppiati o la tua build potrebbe fallire (vedi http://gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects per i dettagli).

Passaggio 3: abilitare la dexign incrementale e modificare le impostazioni della memoria È possibile velocizzare le build attivando la dexing incrementale. Nel file di build del tuo modulo:

inserisci qui la descrizione dell'immagine

Aggiungi questa opzione al tuo blocco Android:

dexOptions {
    incremental true
}

In quel blocco dexOptions puoi anche specificare la dimensione dell'heap per il processo dex, ad esempio:

dexOptions {
    incremental true
    javaMaxHeapSize "12g"
}

Dove "12g" è 12 GB di memoria. Ulteriori informazioni al riguardo sono disponibili qui google.github.io/android-gradle-dsl/current/ È inoltre possibile configurare i parametri Gradle nel file delle impostazioni, ad esempio aumentare la dimensione massima dell'heap nel caso si abbia un progetto di grandi dimensioni:

# 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

Vedi tutto l'elenco dei parametri qui: https://docs.gradle.org/current/userguide/userguide_single.html#sec:gradle_configuration_properties per i dettagli.

Passaggio 4: disabilitare l'antivirus Considerare di escludere i file di progetto e cache dalla scansione antivirus. Questo è ovviamente un compromesso con la sicurezza. Ma se passi molto da un ramo all'altro, l'antivirus eseguirà nuovamente la scansione dei file prima di consentire l'utilizzo del processo gradle, il che rallenta i tempi di costruzione (in particolare il progetto di sincronizzazione di Android Studio con file gradle e attività di indicizzazione). Misura i tempi di compilazione ed elabora la CPU con e senza antivirus abilitato per vedere se è correlata. Spero che questo possa essere d'aiuto. Lascia un commento in caso di domande o altri suggerimenti per migliorare le prestazioni della build.

link utile


19

Se si utilizzano i servizi di Google Play, a seconda delle sole librerie necessarie anziché dell'intero BLOB è possibile velocizzare le cose.

Se hai solo bisogno di mappe, usa:

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

invece di:

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

Quest'ultimo porta 20k metodi (vedi blog) nel percorso di classe, il che potrebbe portare il conteggio totale dei metodi su 64k.

Ciò costringerebbe l'uso di proguard o multidex anche per build di debug. Per uno dei miei progetti ho avuto i seguenti tempi di costruzione

  • build multidex (con supportlibrary) ~ 40sec
  • proguard build ~ 20sec
  • compilare quando il limite del metodo <64k ~ 5sec

Se si sviluppasse su sdk 21+, sarebbe possibile ottimizzare le build multidex come indicato nella documentazione di 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
        }
    }
    ...
}

2
Invece di compilare tutta la play-servicelibreria, ho compilato solo mapsed locations e disattivato il multidex. Sento la grande differenza. Grazie +1
Sami Eltamawy,

16

La risposta accettata è per le versioni precedenti di Android Studio e la maggior parte di esse funziona ancora adesso. L'aggiornamento di Android Studio lo ha reso un po 'più veloce. Non preoccuparti di specificare la dimensione dell'heap poiché aumenterà automaticamente con l'aumento di Xms e Xmx. Ecco alcune modifiche con VMoptions

  1. Nella cartella bin c'è un file studio.vmoptions per impostare la configurazione dell'ambiente. Nel mio caso questo è studio64.vmoptions Aggiungi le seguenti righe se non sono già state aggiunte e salva il file. Nel mio caso ho 8 GB di RAM.

    -Xms4096m
    -Xmx4096m
    -XX:MaxPermSize=2048m
    -XX:+CMSClassUnloadingEnabled
    -XX:+CMSPermGenSweepingEnabled 
    -XX:+HeapDumpOnOutOfMemoryError
    -Dfile.encoding=utf-8`
  2. Avvia Android Studio. Vai su File-> Impostazioni-> Build, Execution, Deployment-> Compiler

    • Controllare compilare moduli indipendenti in parallelo
    • Nella riga di comando Opzioni scrivi: --offline
    • Seleziona Crea progetto automaticamente
    • Controlla configura su richiesta

In caso di utilizzo di Mac, all'inizio non sono riuscito a trovare le vmoptions. Comunque, ecco un bell'articolo su come possiamo cambiare le vmoptions in MAC OSX . Citando da questo articolo qui.

Apri il tuo terminale e inserisci questo comando per aprire le vmoptions in MAC OSX:

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

1
a partire da AS 2.3.2 è possibile modificare le opzioni vim tramite aiuto-> Modifica opzioni Vm personalizzate
Sam

15

Basta creare un file chiamato gradle.properties nella seguente directory:

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

Aggiungi questa riga al file:

org.gradle.daemon=true

Per me la velocità è ora uguale a Eclipse.

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


Non riesco a vedere la cartella .gradle in mac. Come aprirlo?
Dharmik,

@Dharmik: forse hai installato Android Studio con un nome utente diverso. Altrimenti, suppongo che non sia installato correttamente.
Yster,

1
No, era un altro problema. La cartella di sistema ".gradle" era nascosta .. Quindi vado a Vai => Vai alla cartella e poi ho trovato la cartella .gradle .. Grazie per la rapida risposta ..
Dharmik,

14

È possibile velocizzare il processo se si utilizza la pendenza dalla riga di comando. C'è molta ottimizzazione da fare per gli sviluppatori IDE. Ma è solo una versione iniziale.

Per maggiori informazioni leggi questa discussione su g + con alcuni sviluppatori.


3
Questo sembra essere vero anche ora nel 2016
Leo supporta Monica Cellio il

11

Se qualcuno sta lavorando a un progetto sincronizzato tramite Subversion e questo sta ancora accadendo, penso che questo possa rallentare il processo di flusso di lavoro in Android Studio. Ad esempio se funziona molto lentamente durante: scorrimento in una classe, xml ecc., Mentre la mia app è ancora in esecuzione sul mio dispositivo.

  • Vai a Controllo versione in Preferenze e imposta da Subversion a Nessuno.inserisci qui la descrizione dell'immagine

1
Mi risparmi la giornata: 2/4 min -> 15sec (ho disabilitato Tortoise HG per il progetto).
Kaftanati,

3
Se qualcuno sta ancora usando Subversion, dovrebbe passare a Git o Mercurial
Leo supporta Monica Cellio il

8

Aggiornamento dopo Android Studio 2.3

Tutte le risposte sono fantastiche e incoraggio a usare questi metodi con questo per migliorare la velocità di costruzione.

Dopo il rilascio di Android 2.2 a settembre 2016, Android ha rilasciato la funzionalità di cache di build sperimentale per accelerare le gradleprestazioni di build, che è ora ufficiale da Android Studio 2.3 Canary. (Nota ufficiale di rilascio)

Introduce una nuova funzionalità di cache di build, che è abilitata per impostazione predefinita, in grado di accelerare i tempi di build (inclusi build complete, build incrementali e esecuzione istantanea) archiviando e riutilizzando file / directory creati in build precedenti dello stesso o diverso Android progetto.

Come usare:

Aggiungi la seguente riga nel tuo gradle.propertiesfile

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.

Pulisci la cache:

  • È stata richiesta una nuova attività Gradle cleanBuildCacheper pulire più facilmente la cache di build. Puoi usarlo digitando quanto segue nel tuo terminale:

    ./gradlew cleanBuildCache

  • OPPURE È possibile pulire la cache per Android Studio 2.2 eliminando tutti i file archiviati nella posizione

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


7

Dopo aver modificato questa impostazione, la durata della compilazione di 10 minuti è cambiata in ~ 10 secondi.

Passo 1:

Impostazioni (ctrl + Alt + S) ->

Build, Execution, Deployment ->

Compilatore ->

digitare " --offline" nella casella Opzioni della riga di comando.

Passo 2:

selezionare la casella di controllo "Compila moduli indipendenti in parallelo".

e fai clic su Applica -> OK

inserisci qui la descrizione dell'immagine

Riferimento - https://www.sundoginteractive.com/blog/speed-up-gradle-in-android-studio

Svantaggio:

Non sarai in grado di estrarre le ultime versioni delle dipendenze identificate nel tuo file build.gradle. Funziona più velocemente perché utilizza un'istantanea memorizzata nella cache di quelle librerie importate.

Nota importante : quando si distribuisce l'applicazione, rimuovere queste impostazioni e compilare con le ultime versioni delle dipendenze.


6

Risolto il mio con

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

Le build dei gradi sono passate da 8 minuti a 3 secondi.


4

Ecco cosa ha aiutato questo programmatore Android (ex programmatore professionista, anni fa) ad accelerare Android Studio 2.2. So che è una rehash, ma, riassumendo in un unico posto.

Le build iniziali possono comunque essere brutalmente lente, ma i riavvii delle app in esecuzione ora sono generalmente molto tollerabili. Sto usando un PC non ottimale: CPU AMD Quad-Core A8-7410, 8 MB di RAM, HD non SSD, Win 10. (E, questo è il mio primo post Stack Overflow ....;)

IN IMPOSTAZIONI -> GRADLE:

sì per "Lavoro offline" (questa è forse l'impostazione più importata).

IN IMPOSTAZIONI -> COMPILATORE:

sì per "Compilare moduli indipendenti in parallelo" (non sono sicuro se questo effettivamente aiuta a utilizzare CPU multicore).

IN GRADLE SCRIPTS , "build.gradle (Modulo: 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

ANCHE IN GRADLE SCRIPTS , "gradle.properties (Proprietà del progetto)":

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

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

Inoltre , il test su un dispositivo fisico anziché sull'emulatore funziona bene per me; un piccolo tablet che si alza è conveniente.


4

Solo un altro suggerimento per migliorare le prestazioni:

Android Studio 3.0 include un nuovo compilatore DEX chiamato D8.

"Il compilatore dex lavora principalmente sotto il cofano nello sviluppo quotidiano delle tue app, ma influisce direttamente sul tempo di costruzione della tua app, sulle dimensioni del file .dex e sulle prestazioni di runtime."

"E confrontando il nuovo compilatore D8 con l'attuale compilatore DX, D8 si compila più velocemente e genera file .dex più piccoli, pur avendo le stesse o migliori prestazioni di runtime delle app."

D8 è facoltativo - utilizzalo dobbiamo mettere a gradle.properties del progetto

android.enableD8=true

Ulteriori informazioni: https://android-developers.googleblog.com/2017/08/next-generation-dex-compiler-now-in.html

PS. Impedisce il mio tempo di costruzione di circa il 30%.


1

Questa configurazione è molto veloce per me (circa 2 secondi la build)

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

il mio PC:

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

file di progetto
- Tutti situati in HD locale



1

Potresti provare ad aprire il menu Gradle sul lato destro di Studio e assemblare solo i moduli che hai modificato, quindi eseguire il comando di installazione. Quando si preme run, assembla tutto indipendentemente dalle eventuali modifiche apportate al codice che sta assemblando


0

Sono lungi dall'essere un esperto di Gradle ma il mio ambiente aveva la seguente linea in .gradle / init.gradle

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

Eppure non ho idea del perché quella linea fosse lì, ma provo a cambiare

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

e ora finalmente posso lavorare senza imprecare sullo schema di buildind di Android Studio e Gradle.


artificialmente nel tuo caso è stato probabilmente usato come cache di libreria. Si contatta il server artificiale che verifica se dispone della libreria. Se sì, te lo restituisce, altrimenti va a prenderlo dal centro e poi torna da te.
Fabio Marcolini,

0

Nel nostro caso specifico, il problema era dovuto alla presenza del plug-in retrolambda , che costringeva tutti i progetti e sottoprogetti a ricompilarsi ogni volta che provavamo a lanciare la nostra applicazione, anche se non era stato modificato alcun codice nei nostri moduli core.

La rimozione di retrolamba l'ha risolto per noi. Spero che aiuti qualcuno.


0

Prova prima questo. È la mia esperienza personale.

Ho avuto lo stesso problema. Quello che avevo fatto è stato disabilitare permanentemente l'antivirus (il mio era Avast Security 2015). Subito dopo aver disabilitato l'antivirus, la cosa è andata bene. il grado è terminato con successo. Da adesso in pochi secondi la pendenza sta finendo (impiegando solo 5-10 secondi).


0

Ciao, so che questa è una risposta molto tardi, ma forse
posso aiutare qualcuno nel mio caso che stavo usando

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

nella mia app Gradle dependency
ma in una delle mie librerie lo era

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

dopo aver cambiato tutto all'ultima versione il mio problema è stato risolto.


0

Seguire i passaggi lo renderà 10 volte più veloce e ridurrà il tempo di costruzione del 90%

Innanzitutto crea un file chiamato gradle.properties nella seguente directory:

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

Aggiungi questa riga al file:

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

E controlla queste opzioni in Android Studio

inserisci qui la descrizione dell'immagine



0

Una banale modifica (a un nuovo file XML) ha richiesto ancora 10 minuti . Come dice @rivare nella sua risposta, un build della riga di comando è più veloce (portato a 15 secondi ).
Ecco alcuni passaggi per rendere almeno una banale build veloce dalla riga di comando per Windows.

  1. Vai alla radice dei tuoi progetti (dove si trova gradlew.bat):

    cd c: \ android \ MaskActivity

  2. eseguire la build :

    gradlew assembleDebug

  3. disinstallare direttamente l'apk dal telefono (trascinarlo per disinstallarlo).

  4. Al termine della compilazione, interrompere il processo Java GRANDE utilizzando Task Manager di Windows.

O se hai strumenti unix sul tuo computer Windows:

ps

Vengono visualizzati i "pid":

kill -9 <pid>
  1. Ora installa il tuo apk:

    adb -d installa C: \ Android \ MaskActivity \ app \ build \ output \ apk \ app-debug.apk


0

Secondo la documentazione Android , aggiungila nel file gradle del modulo dell'app.

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

0

Per eseguire l'ambiente Android su macchine con configurazione bassa.

  1. Chiudere le schede Web non soggette a browser nel browser
  2. Per gli utenti antivirus, escludere la cartella di generazione generata automaticamente
  3. Android studio ha un heap predefinito di 1,2 Gb che può scendere a 512 MB Guida> Modifica opzioni VM personalizzate studio.vmoptions -Xmx512m Le prestazioni dei layout saranno accelerate

  4. Per Gradle uno dei componenti principali dello studio Android Mkae sicuramente come al momento 3.0beta è l'ultimo

I suggerimenti di seguito possono influire sulla qualità del codice, quindi utilizzare con cautela:

  1. Studio contiene la modalità Risparmio energetico quando viene attivata per chiudere le operazioni in background che sfilacciano, compilano il codice e così via.

  2. È possibile eseguire il controllo manuale di lintch quando necessario ./gradlew lint

  3. La maggior parte utilizza emulatori Android in media consuma 2 GB di RAM, quindi, se possibile, utilizza un dispositivo Android reale che ridurrà il carico di risorse sul tuo computer. In alternativa puoi ridurre la RAM dell'emulatore e questo ridurrà automaticamente il consumo di memoria virtuale sul tuo computer. puoi trovarlo nella configurazione del dispositivo virtuale e nelle impostazioni avanzate.

  4. La modalità offline Gradle è una funzione per gli utenti con limitazioni di larghezza di banda per disabilitare il download delle dipendenze di build. Ridurrà le operazioni in background che aiuteranno ad aumentare le prestazioni di Android Studio.

  5. Android Studio offre un'ottimizzazione per compilare più moduli in parallelo. Su macchine con poca RAM questa funzione avrà probabilmente un impatto negativo sulle prestazioni. Puoi disabilitarlo nella finestra di dialogo delle impostazioni del compilatore.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.