Accelerazione della build di Gradle in studio Android

Dall'ultimo aggiornamento (Build dal 25 giugno) qualsiasi modifica in Android Studio Gradle è dolorosamente lenta. E sembra anche tracciare automaticamente le modifiche quando si modifica il file e si ricompila al keyup.

Ogni modifica richiede diversi minuti sul mio i5.

Hai idea di come posso accelerare i miei cambi di grado?

Lo sviluppatore ci sta lavorando. Come ho scritto in questa risposta, la soluzione più veloce in questo momento è usare il gradle dalla riga di comando e dovresti passare alle librerie binarie per tutti i moduli che non sviluppi. Su g + c'è una discussione con gli sviluppatori al riguardo.

Sicuramente fa la differenza: come ... Accelerare i tempi di costruzione dei gradi

Basta creare un file denominato gradle.propertiesnella seguente directory:

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

Aggiungi questa riga al file:

org.gradle.daemon=true

Dopo aver modificato questa impostazione, il mio tempo di compilazione è stato ridotto di 10 minuti a 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

Passaggio 3: nel file gradle.properties -> Aggiungi le seguenti righe

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

Aggiornare:

Se stai utilizzando Android Studio 2.0 o versioni successive, prova Instant Run

Impostazioni → Crea, Esecuzione, Distribuzione → Corsa istantanea → Abilita corsa istantanea.

Maggiori informazioni su Instant Run - https://developer.android.com/studio/run/index.html#instant-run

Sono stato in grado di ridurre la mia build gradle da 43 secondi fino a 25 secondi sul mio vecchio laptop core2duo (con Linux in esecuzione) aggiungendo quanto segue al file gradle.properties in Android Studio

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

fonte sul perché l'impostazione del demone rende le build più veloci: https://www.timroes.de/2013/09/12/speed-up-gradle/

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

Esiste una versione più recente di gradle (versione 2.4).

Puoi impostarlo per i tuoi progetti aprendo la finestra di dialogo "Struttura del progetto" dal menu File,

Project Structure -> Project -> Gradle version

e impostarlo su "2.4".
Puoi leggere ulteriori informazioni sull'aumento delle prestazioni a questo link .

Con Android Studio 2.1 puoi abilitare "Dex In Process" per build di app più veloci.

Puoi ottenere maggiori informazioni qui: https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.vijksflyn

Questo è quello che ho fatto e la mia velocità di costruzione gradle è migliorata notevolmente! da 1 min a 20sec per la prima build e le build successive sono diventate da 40 sec a 5 sec.

Nel file gradle.properties Aggiungi questo:

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

In Argomenti della riga di comando tramite Vai a File> Altre impostazioni> Impostazioni predefinite> Crea, Esegui, Distribuisci> Complier e aggiungi i seguenti argomenti agli Argomenti della riga di comando

Aggiungi questo:

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

Cerca di evitare di utilizzare un Mac / PC che ha solo 8 GB di RAM durante lo sviluppo di Android. Non appena avvii anche solo 1 emulatore (Genymotion o altro), i tuoi tempi di costruzione diventano estremamente lenti in Android Studio con build a gradi. Ciò accade anche se si esegue una semplice modifica di una riga in 1 file di origine.

Chiudere l'emulatore e usare un dispositivo reale aiuta molto, ma ovviamente questo è molto limitante e meno flessibile. Ridurre l'impostazione dell'utilizzo della RAM dell'emulatore può essere d'aiuto, ma il modo migliore è assicurarsi che il laptop disponga di almeno 12-16 GB di RAM.

Aggiornamento (giugno 2017): ora ci sono molti buoni articoli su medium.com che spiegano in dettaglio come velocizzare le build di Android Studio Gradle e funziona anche su macchine da 8 GB:

• Come ridurre i tempi di costruzione del Gradle del 65% : https://medium.com/@kevalpatel2106/how-to-decrease-your-gradle-build-time-by-65-310b572b0c43
• Rendi veloci le tue build Gradle! : https://medium.com/@wasyl/make-your-gradle-builds-fast-again-ea323ce6a435

Il consenso riassunto è:

Creare un file gradle.properties (globale a ~/.gradle/gradle.propertieso locale al progetto) e aggiungere le seguenti righe:

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

1. Abilita lavoro offline

2. Migliora le prestazioni dei gradi aggiungendo il seguente codice in gradle.properties

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

Guida dettagliata: http://www.viralandroid.com/2015/08/how-to-make-android-studio-fast.html

dexOptions {
    incremental true
    javaMaxHeapSize "4g"
}

Secondo questa pagina del Team Android di Wikimedia Apps , un buon modo per ottimizzare le build Gradle è l'aggiunta di queste righe al tuo ~ / .gradle / gradle.properties

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

Per coloro che non hanno il file ci sono due modi per farlo:

1. Aggiungi il file localmente nel tuo progetto creando un file chiamato gradle.properties nella radice del progetto o,

2. Puoi impostarli a livello globale per tutti i tuoi progetti creando lo stesso file nella tua home directory (% UserProfile% .gradle su Windows , ~ / .gradle su Linux e Mac OS X )

   È buona norma impostare le proprietà nella directory home anziché a livello di progetto.

Puoi anche usare la riga di comando per prestazioni migliori. Puoi usare il comando ./gradlew <task name>dall'interno della cartella principale del tuo progetto da Linux o usare il file gradlew.bat come gradlew <task name>.quando esegui per la prima volta uno dei comandi sopra per un dato Gradle versione, scaricherà la distribuzione Gradle corrispondente e la utilizzerà per eseguire la build.

Quando si importa un progetto Gradle tramite il suo wrapper, l'IDE potrebbe chiedere di utilizzare la distribuzione "all" di Gradle. Questo va perfettamente bene e aiuta l'IDE a fornire il completamento del codice per i file di build. Questo non significa solo che non è necessario installare manualmente Gradle, ma è anche sicuro di utilizzare la versione di Gradle per cui è stata progettata la build. Questo rende le tue build storiche più affidabili. per ulteriori informazioni consultare Esecuzione di una build con il wrapper

Per build più veloci, aumenta la dimensione massima dell'heap per il demone Gradle a oltre 2048 MB.

Per fare questo impostare
org.gradle.jvmargs=-Xmx2048M
nel progetto gradle.properties .

Aggiungi un build.gradlefile:

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

Spero possa essere d'aiuto.

Sto eseguendo un i7 di quinta generazione con Windows 10 e uno stato solido da 1 TB. Ho compresso la cartella Progetti di Android Studio e ho ottenuto un aumento dell'80% circa. Spero che questo ti aiuti.

L'ho quindi combinato con le soluzioni sopra es. (Org.gradle.parallel = true, org.gradle.daemon = true). L'aumento delle prestazioni è stato piuttosto impressionante.

Inoltre:

Tutte le risposte di cui sopra sono totalmente corrette ma devo affermare come esperienza uno sviluppatore Android (di 4 anni e mezzo) che: nessuno sviluppatore Android / Gradle dovrebbe lavorare su una macchina con un spinner drive, è necessario sborsare per un Stato solido. Premiamo tutti quel pulsante di riproduzione nell'IDE 100 volte al giorno. Quando sono passato da un filatore a SSD (post Gradle), la mia velocità ed efficienza sono state letteralmente 2 - 4 volte più veloci e ti prometto che NON sto esagerando qui.

Ora non sto parlando di avere una macchina con un piccolo SSD e un grande spinner, sto parlando di 1 grande SSD. Se hai già una macchina con un piccolo SSD e un grande spinner puoi aggiornare il piccolo spinner per dire un SSD da 500 GB e impostare l'SSD come unità del sistema operativo principale con gli strumenti di sviluppo installati su di esso.

Quindi, se lavori in un ambiente frenetico, ti preghiamo di mostrare questo post al tuo capo. Un discreto SSD da 1 TB ti riporterà a circa £ 300 (IVA inclusa), o circa £ 160 per un SSD da 500 GB. A seconda che tu sia uno sviluppatore Android junior o senior, l'unità pagherà per sé (in spese salariali) in 1 - 2 settimane lavorative, o circa 2 e mezzo a 5 giorni lavorativi se investi in un importo inferiore; dì SSD da 500 GB.

Molti sviluppatori potrebbero sostenere che questo non è il caso, ma è il caso di Gradle, poiché il sistema Gradle è molto difficile sull'accesso diretto al disco. Se lavori con .NET / C # / VB Net o altri strumenti di sviluppo non noterai molte differenze, ma la differenza in Gradle è ENORME. Se agisci in questo post, te lo prometto, non rimarrai deluso. Personalmente sto usando la quinta generazione i7 con 8 GB di RAM originariamente fornita con uno spinner da 1 TB e l'ho aggiornata a un SSD Samsung 840 EVO da 1 TB e da allora non ho mai guardato indietro. Ho comprato il mio da: https://www.aria.co.uk .

Spero che questo ti aiuti. Devo anche affermare che questo NON è un post commercialmente motivato, sto solo raccomandando Aria come li ho usati molte volte prima e sono sempre stati affidabili.

alcuni comandi che possiamo aggiungere al file gradle.properties:

org.gradle.configureondemand = true - Questo comando dirà a Gradle di costruire solo i progetti che deve davvero costruire. Usa Daemon - org.gradle.daemon = true - Daemon mantiene attiva e funzionante l'istanza del gradle in background anche al termine della compilazione. Ciò rimuoverà il tempo necessario per inizializzare la pendenza e ridurre significativamente i tempi di costruzione.

org.gradle.parallel = true - Consenti a Gradle di costruire il tuo progetto in parallelo. Se hai più moduli nel tuo progetto, abilitando ciò, Gradle può eseguire in parallelo operazioni di compilazione per moduli indipendenti.

Aumenta dimensione heap - org.gradle.jvmargs = -Xmx3072m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8 - Da android studio 2.0, gradle utilizza dex nel processo per ridurre i tempi di compilazione del progetto. Generalmente, durante la creazione delle applicazioni, più processi dx vengono eseguiti su diverse istanze di macchine virtuali. Ma a partire da Android Studio 2.0, tutti questi processi dx vengono eseguiti nella singola VM e tale VM è condivisa anche con il gradle. Ciò riduce significativamente il tempo di compilazione poiché tutto il processo di dex viene eseguito sulle stesse istanze di VM. Ma questo richiede una memoria più grande per adattarsi a tutti i processi e gradi graduali. Ciò significa che è necessario aumentare le dimensioni dell'heap richieste dal demone Gradle. Per impostazione predefinita, la dimensione dell'heap per il demone è di circa 1 GB.

Assicurarsi che non venga utilizzata la dipendenza dinamica. cioè non usare l'implementazione 'com.android.support:appcompat-v7:27.0.+'. Questo comando indica che Gradle andrà online e controllerà l'ultima versione ogni volta che crea l'app. Utilizza invece versioni fisse, ad esempio "com.android.support:appcompat-v7:27.0.2"

Aggiungi questo al tuo gradle.propertiesfile

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

Apri gradle.properties dalla cartella Android e rimuovi le righe evidenziate e fornisci i valori di memoria secondo la configurazione della tua macchina. Ho un ram da 8 GB sulla mia macchina, quindi ho dato rispettivamente un massimo di 4096mb e 1024mb.

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

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

Il mio tempo di costruzione è stato ridotto alla metà dopo questo. Buon edificio !!

Succede spesso quando hai abilitato multidex nel tuo progetto. Questo può potenzialmente rallentare il tuo processo di sviluppo !! Secondo doc :

La configurazione multidex richiede un tempo di elaborazione della build significativamente maggiore poiché il sistema di build deve prendere decisioni complesse su quali classi devono essere incluse nel file DEX primario e quali classi possono essere incluse nei file DEX secondari. Ciò significa che le build incrementali che utilizzano multidex in genere richiedono più tempo e possono potenzialmente rallentare il processo di sviluppo.

ma puoi ottimizzarlo:

Per ridurre i tempi di build incrementali più lunghi, è necessario utilizzare la pre-dex per riutilizzare l'output multidex tra build.

Se utilizzi Android Studio 2.3 e versioni successive, l'IDE utilizza automaticamente questa funzione durante la distribuzione dell'app su un dispositivo con Android 5.0 (livello API 21) o versione successiva.

Quindi è necessario impostare minSdkVersion su 21 o superiore !

Ma se la tua versione di produzione deve supportare minSdkVersion inferiore a 21, ad esempio 19

puoi usare productFlavors per impostare minSdkVersion 21 per la tua versione di sviluppo:

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

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

Preferisco costruire dalla riga di comando per tempi di costruzione migliori. Se la base di codice dell'app è grande e hai più moduli, puoi provare l' approccio AAR locale come descritto qui, ti darà un grande impulso nelle prestazioni di Android Studio e nei tempi di costruzione graduale. È compatibile anche con build da riga di comando

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

Il progetto demo con le istruzioni di integrazione è disponibile qui: https://github.com/akhgupta/AndroidLocalMavenRepoAARDemo