android-studio - La creazione e l'esecuzione dell'app tramite Gradle e Android Studio è più lenta rispetto a via Eclipse




build.gradle (23)

Potresti rendere il processo più veloce, se usi gradle dalla riga di comando. C'è un sacco di ottimizzazione da fare per gli sviluppatori IDE. Ma è solo una versione anticipata.

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

Ho un multi-progetto (~ 10 moduli) di cui costruzione richiede 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 i processi di costruzione in Android Studio? O hai qualche consiglio su come rendere questo processo più veloce?

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


Risolto il mio con

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

Le build di Gradle sono passate da 8 minuti a 3 secondi.


Potresti provare ad aprire il menu gradle sul lato destro di studio e assemblare solo i moduli che hai modificato, quindi eseguire il comando install. Quando premi premi, assembla tutto indipendentemente da eventuali modifiche che potresti aver apportato al codice che sta assemblando


Hardware

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

Versioni degli strumenti

Aumentare le prestazioni di costruzione è una priorità per i team di sviluppo, quindi assicurati di utilizzare l'ultimo Gradle e il plug-in Gradle Android .

File di configurazione

Creare un file denominato gradle.properties in qualunque directory si applichi:

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

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 in locale se le si posiziona su projectRoot\gradle.properties e globalmente se le si posiziona su 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 dell'IDE. Abilitando il "lavoro offline" (controlla la risposta da yava basso) si disabilitano le richieste di rete reali su ogni "file gradle sync".

Multi-dex nativo

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

dipendenze

Preferisci le dipendenze @aar sui sottoprogetti della libreria.

Cerca il pacchetto di aar su mavenCentral , jCenter o usa jitpack.io per creare qualsiasi libreria da github. Se non stai modificando le fonti della libreria delle dipendenze, non dovresti costruirlo ogni volta con le sorgenti del tuo progetto.

Antivirus

Considera di escludere i file di progetto e di cache dalla scansione antivirus. Questo è ovviamente un compromesso con la sicurezza (non provarlo a casa!). Ma se si passa da una filiale all'altra, l'antivirus esegue nuovamente la scansione dei file prima di consentire l'utilizzo del processo gradle, rallentando i tempi di costruzione (in particolare il progetto di sincronizzazione di AndroidStudio con i file gradle e le attività di indicizzazione). Misura il tempo di costruzione e processa la CPU con e senza antivirus abilitato per vedere se è correlato.

Creazione di profili di una build

Gradle ha il supporto integrato per i progetti di profilazione . Diversi progetti utilizzano una combinazione diversa di plug-in e script personalizzati. Usare --profile ti aiuterà a trovare i colli di bottiglia.


Aggiornamento dopo Android Studio 2.3

Tutte le risposte sono ottime e incoraggio a utilizzare 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 build sperimentale per accelerare le prestazioni di build gradle , ora ufficiale da Android Studio 2.3 Canary. (Nota di rilascio ufficiale)

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

Come usare:

Aggiungi la seguente riga nel tuo file 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.

Pulisci la cache:

  • C'è una nuova attività Gradle chiamata cleanBuildCache per rendere più facile la pulizia della 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 memorizzati nella posizione

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


Prova questo prima. È la mia esperienza personale.

Ho avuto lo stesso problema. Quello che ho fatto è disabilitare in modo permanente l'antivirus (Mine era Avast Security 2015). Subito dopo aver disabilitato l'antivirus, la cosa è andata bene. il gradle è finito con successo. Da ora in pochi secondi il gradino sta finendo (solo prendendo 5-10 secondi).


Sono lontano dall'essere un esperto di Gradle, ma il mio ambiente aveva la seguente riga 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 posso finalmente lavorare senza giurare per lo schema buildind di Android Studio e Gradle.



Solo un altro consiglio di miglioramento delle prestazioni:

Android Studio 3.0 include un nuovo compilatore DEX chiamato D8.

"Il compilatore dex funziona principalmente sotto lo sviluppo delle app quotidiane, ma influisce direttamente sul tempo di costruzione della tua app, sulla dimensione del file .dex e sulle prestazioni di runtime."

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

D8 è facoltativo: utilizzalo per inserire le proprietà gradle.properties del progetto

android.enableD8=true

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

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


Un cambiamento insignificante (in un xml di resoruce) richiedeva ancora 10 minuti . Come dice @rivare nella sua risposta, una build da riga di comando è mutch più veloce (lo ha ridotto a 15 secondi ).
Ecco alcuni passaggi per rendere almeno una semplice build veloce dalla riga di comando per Windows.

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

    cd c: \ android \ MaskActivity

  2. eseguire la build :

    gradlew assembleDebug

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

  4. Al termine della compilazione, uccidere il processo di Java BIG utilizzando Task Manager di Windows.

O se hai unix strumenti sul tuo computer Windows:

ps

"pid" sono mostrati:

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

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


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

Per prima cosa creare un file denominato gradle.properties nella seguente directory:

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

Aggiungi questa linea al file:

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

E controlla queste opzioni in Android Studio


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

Anche se non risponde direttamente alla tua domanda sul motivo per cui è più lento di eclissi, mostra che il processo è limitato dal disco e un aggiornamento a un SSD potrebbe essere una soluzione (alquanto costosa). Immagino che ci saranno persone che consultano il problema e finiscono qui, che potrebbero apprezzare la mia esperienza.


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

Le build iniziali possono ancora essere brutalmente lente, ma le app in esecuzione di solito sono in genere molto tollerabili. Utilizzo un PC non ottimale: CPU AMD Quad-Core A8-7410, 8 MB di RAM, non SSD HD, Win 10. (E questa è la mia prima pubblicazione su Overflow dello stack ....;)

IN SETTINGS -> GRADLE:

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

IN IMPOSTAZIONI -> COMPILATORE:

sì per "Compilare moduli indipendenti in parallelo" (non è sicuro se questo aiuti di fatto usi le 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 NEGLI SCRIPT DI GRADLE , "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 sta funzionando bene per me; un tablet piccolo che si alza è conveniente.


È possibile ignorare i controlli aggiornamento graduale alla data.

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

giù da ~ 30 + sec a ~ 3 sec


Se utilizzi i servizi di google play, in base alle sole librerie di cui hai bisogno anziché all'intero BLOB puoi rendere le cose più veloci.

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 i metodi 20k (vedi blog) nel classpath, che potrebbe dare una mancia al numero totale di metodi su 64k.

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

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

Se si sviluppa 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
        }
    }
    ...
}

Dopo aver cambiato queste impostazioni, la mia durata di compilazione di 10 minuti è cambiata in ~ 10 secondi.

Passo 1:

Impostazioni (ctrl + Alt + S) ->

Build, Execution, Deployment ->

Compilatore ->

digita " --offline " nella casella delle opzioni della riga di comando.

Passo 2:

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

& fai clic su Applica -> OK

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

Svantaggio:

Non sarai in grado di visualizzare 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 creare con le versioni più recenti delle dipendenze.


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

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

Aggiungi questa linea 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/


Accelerare la build del gradle in Android Studio 3.2.1

Hai mai pensato di aspettare che le build vengano completate in Android Studio per minuti? Anche a me. Ed è piuttosto fastidioso. Fortunatamente, ci sono alcuni modi che puoi usare per migliorare questo. Android utilizza Gradle per la costruzione. L'ultima versione è la 4.6 ha un enorme incremento delle prestazioni rispetto alle versioni precedenti (vedi Note sulla versione per i dettagli).

Passo 1: Aggiornamento della versione di Gradle Un modo più semplice per farlo è quello di andare su: Apri le impostazioni del modulo (il tuo progetto)> Struttura del progetto

AGGIORNARE

Passare alla versione Gradle: 4.6 e passare alla versione plug-in Android: 3.2.1

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

L'ultimo passo è aggiungere la tua discribuzione in Impostazioni> Gradle

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

Passo 2: Abilita la modalità Offline, il demone Gradle e la build parallela per il progetto. La modalità Offline dice a Gradle di ignorare i controlli aggiornati alla data. Gradle chiede sempre le dipendenze e, avendo questa opzione, usa solo ciò che è già presente sulla macchina per le dipendenze. Vai a Gradle da Android Studio Setting e fai clic su nella casella di lavoro Offline.

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

Il prossimo passo è abilitare il demone Gradle e la build parallela per il tuo progetto. Le build parallele faranno in modo che i progetti con più moduli (build multi-progetto in Gradle) siano costruiti in parallelo, il che dovrebbe rendere più veloce la costruzione di progetti grandi o modulari.

Queste impostazioni possono essere abilitate modificando un file denominato gradle.properties nella directory degli script Gradle (ad es. ~ / .Gradle / gradle.properties). Alcune di queste opzioni (ad esempio i moduli Complie in parallelo) sono disponibili da Android Studio e abilitate anche da predefinito, ma inserirli nel file gradle.properties li abiliterà quando costruiranno dal terminale e anche facendo in modo che i colleghi utilizzino le stesse impostazioni. Ma se lavori in una squadra, a volte non puoi commettere questa roba.

# 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'utilizzo del demone renderà l'avvio delle build più veloce in quanto non dovrà avviare l'intera applicazione Gradle ogni volta. Il demone Gradle non è abilitato per impostazione predefinita, ma è consigliabile abilitarlo sempre per i computer degli sviluppatori (ma disabilitarlo per i server di integrazione continui). Le domande frequenti su questa modalità possono essere trovate 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 che la tua build possa fallire (vedi http://gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects per i dettagli).

Passaggio 3: abilitare le impostazioni di memoria incrementale dexign e tweak È possibile accelerare le build attivando il dexing incrementale. Nel file di build del tuo modulo:

Aggiungi questa opzione al tuo blocco Android:

dexOptions {
    incremental true
}

Nel blocco dexOptions è anche possibile specificare la dimensione heap per il processo dex, ad esempio:

dexOptions {
    incremental true
    javaMaxHeapSize "12g"
}

Dove "12g" è 12 GB di memoria. Ulteriori informazioni a riguardo possono essere trovate qui google.github.io/android-gradle-dsl/current/ Puoi anche configurare i parametri di Gradle nel file delle impostazioni, ad esempio aumentare la dimensione massima dell'heap nel caso in cui tu 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 tutti i parametri qui: https://docs.gradle.org/current/userguide/userguide_single.html#sec:gradle_configuration_properties per i dettagli.

Passaggio 4: Disattiva antivirus Considerare di escludere i file di progetto e di cache dalla scansione antivirus. Questo è ovviamente un compromesso con la sicurezza. Ma se si passa da un ramo all'altro, l'antivirus esegue nuovamente la scansione dei file prima di consentire l'utilizzo del processo gradle, rallentando i tempi di costruzione (in particolare il progetto di sincronizzazione di Android Studio con i file gradle e le attività di indicizzazione). Misura il tempo di costruzione e processa la CPU con e senza antivirus abilitato per vedere se è correlato. Spero che questo possa essere d'aiuto. Lascia un commento se hai qualche domanda o qualche altro consiglio per migliorare le prestazioni di costruzione.

link utile


Questa configurazione è molto veloce per me (circa 2 secondi per 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,00 GHz, 3000 Mhz, 2 processori principali, 2 processori logici
  • x64
  • Microsoft Windows 7 Professional
  • (RAM) 16,0 GB

file di progetto
- Tutti situati in HD locale


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

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


Secondo la documentazione di Android , aggiungi questo nel file gradle del modulo app.

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

Gradle è uno strumento di creazione personalizzato e utilizzato per creare APK o conosciuto come pacchetto di pacchetti di applicazioni.





android gradle android-studio build.gradle