Przyspieszenie tworzenia aplikacji Android Studio Gradle

Od ostatniej aktualizacji (Build from 25 czerwca) wszelkie zmiany w Android Studio Gradle są boleśnie powolne. Wydaje się również, że automatycznie śledzi zmiany podczas edycji pliku i ponownej kompilacji przy keyup.

Każda zmiana na moim i5 zajmuje kilka minut.

Masz jakiś pomysł, jak mogę przyspieszyć zmiany w Gradle?

Deweloper nad tym pracuje. Jak napisałem w tej odpowiedzi, najszybszym obecnie rozwiązaniem jest użycie gradle z wiersza poleceń i powinieneś przełączyć się na biblioteki binarne dla wszystkich modułów, których nie tworzysz. Na g + toczy się dyskusja z programistami na ten temat.

Zdecydowanie robi różnicę: jak… przyspieszyć czas kompilacji Gradle

Po prostu utwórz plik o nazwie gradle.propertiesw następującym katalogu:

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

Dodaj tę linię do pliku:

org.gradle.daemon=true

Po zmianie tych ustawień mój czas kompilacji z 10 minut został skrócony do 10 sekund.

Krok 1:

Ustawienia (ctrl + Alt + S) ->

Kompilacja, wykonanie, wdrożenie ->

Kompilator ->

wpisz „ --offline” w polu Opcje wiersza polecenia.

Krok 2:

zaznacz pole wyboru „Kompiluj niezależne moduły równolegle”.

i kliknij Zastosuj -> OK

Krok 3: W pliku gradle.properties -> Dodaj następujące wiersze

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

Aktualizacja:

Jeśli używasz Android Studio 2.0 lub nowszego, wypróbuj Instant Run

Ustawienia → Kompilacja, wykonanie, wdrożenie → Natychmiastowe uruchamianie → Włącz natychmiastowe uruchamianie.

Więcej informacji o Instant Run - https://developer.android.com/studio/run/index.html#instant-run

Udało mi się skrócić moją kompilację Gradle z 43 do 25 sekund na moim starym laptopie core2duo (z systemem Linux Mint), dodając następujące polecenie do pliku gradle.properties w Android Studio

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

źródło wyjaśniające, dlaczego ustawienie demona przyspiesza kompilacje: https://www.timroes.de/2013/09/12/speed-up-gradle/

Wykonanie tych czynności przyspieszy to 10 razy i skróci czas budowy o 90%

Najpierw utwórz plik o nazwie gradle.properties w następującym katalogu:

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

Dodaj tę linię do pliku:

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

I sprawdź te opcje w Android Studio

Dostępna jest nowsza wersja gradle (wersja 2.4).

Możesz to ustawić dla swojego projektu (projektów), otwierając okno dialogowe „Struktura projektu” z menu Plik,

Project Structure -> Project -> Gradle version

i ustaw go na „2.4”.
Możesz przeczytać więcej o zwiększaniu wydajności pod tym linkiem .

Dzięki Android Studio 2.1 możesz włączyć „Dex In Process”, aby przyspieszyć tworzenie aplikacji.

Możesz uzyskać więcej informacji na ten temat tutaj: https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.vijksflyn

To właśnie zrobiłem, a moja szybkość budowania gradle znacznie się poprawiła! od 1 minuty do 20 sekund dla pierwszej kompilacji, a kolejne kompilacje od 40 do 5 sekund.

W pliku gradle.properties Dodaj to:

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

W Argumentach wiersza polecenia za pośrednictwem Idź do Plik> Inne ustawienia> Ustawienia domyślne> Kompiluj, Wykonaj, Wdrażaj> Zgodne i dodaj następujące argumenty do Argumentów wiersza polecenia

Dodaj:

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

Podczas tworzenia aplikacji na Androida staraj się unikać komputera Mac / PC, który ma tylko 8 GB pamięci RAM. Gdy tylko uruchomisz nawet 1 emulator (Genymotion lub inny), czas kompilacji w Android Studio z kompilacjami Gradle stanie się bardzo wolny. Dzieje się tak nawet wtedy, gdy dokonasz prostej zmiany w jednym wierszu na 1 plik źródłowy.

Zamknięcie emulatora i użycie prawdziwego urządzenia bardzo pomaga, ale oczywiście jest to bardzo ograniczone i mniej elastyczne. Zmniejszenie ustawienia emulatora użycia pamięci RAM może pomóc, ale najlepszym sposobem jest upewnienie się, że Twój laptop ma co najmniej 12-16 GB pamięci RAM.

Aktualizacja (czerwiec 2017 r.): Istnieje teraz kilka dobrych artykułów z medium.com, które szczegółowo wyjaśniają, jak przyspieszyć kompilacje gradle Android Studio, a działa nawet na maszynach 8 GB:

• Jak skrócić czas kompilacji Gradle o 65% : https://medium.com/@kevalpatel2106/how-to-decrease-your-gradle-build-time-by-65-310b572b0c43
• Spraw, aby Twoje Gradle budowały ponownie szybko! : https://medium.com/@wasyl/make-your-gradle-builds-fast-again-ea323ce6a435

Podsumowany konsensus jest następujący:

Utwórz plik gradle.properties (globalny ~/.gradle/gradle.propertieslub lokalny w projekcie) i dodaj następujące wiersze:

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. Włącz pracę w trybie offline

2. Popraw wydajność Gradle, dodając następujący kod w gradle.properties

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

Przewodnik krok po kroku: http://www.viralandroid.com/2015/08/how-to-make-android-studio-fast.html

dexOptions {
    incremental true
    javaMaxHeapSize "4g"
}

Acording do tej strony z Androidem Zespołu Wikimedia Apps , dobry sposób Optimize Gradle opiera się dodanie tej linii do ~ / .gradle / gradle.properties

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

Dla tych, którzy nie mają tego pliku, możesz to zrobić na dwa sposoby:

1. Dodaj plik lokalnie do swojego projektu, tworząc plik o nazwie gradle.properties w katalogu głównym projektu lub

2. Możesz ustawić je globalnie dla wszystkich swoich projektów, tworząc ten sam plik w swoim katalogu domowym (% UserProfile% .gradle w systemie Windows , ~ / .gradle w systemie Linux i Mac OS X )

   Jest to dobra praktyka , aby ustawić właściwości w katalogu domowym, a nie na poziomie projektu.

Możesz także użyć wiersza poleceń, aby uzyskać lepszą wydajność.Możesz użyć polecenia ./gradlew <task name>z katalogu głównego swojego projektu z linuxa lub użyć pliku gradlew.bat, takiego jak gradlew <task name>. Po pierwszym uruchomieniu jednego z powyższych poleceń dla danego Gradle wersja, pobierze odpowiednią dystrybucję Gradle i użyje jej do wykonania kompilacji.

Podczas importowania projektu Gradle przez jego opakowanie, twoje IDE może poprosić o użycie dystrybucji Gradle „all”. Jest to całkowicie w porządku i pomaga IDE zapewnić uzupełnianie kodu dla plików kompilacji. Nie tylko oznacza to, że nie musisz samodzielnie instalować Gradle ręcznie, ale na pewno używasz wersji Gradle, dla której jest przeznaczona kompilacja. Dzięki temu Twoje historyczne kompilacje są bardziej niezawodne. Aby uzyskać więcej informacji, zobacz Wykonywanie kompilacji za pomocą Wrappera

Aby uzyskać szybsze kompilacje, zwiększ maksymalny rozmiar sterty dla demona Gradle do ponad 2048 MB.

Aby to zrobić, ustaw
org.gradle.jvmargs=-Xmx2048M
w projekcie gradle.properties .

Dodaj build.gradleplik:

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

Mam nadzieję, że to pomoże.

Używam i7 piątej generacji z systemem Windows 10 i dyskiem SSD o pojemności 1 TB. Skompresowałem folder Android Studio Projects i uzyskałem około 80% przyspieszenia. Mam nadzieję że to pomoże.

Następnie połączyłem to z powyższymi rozwiązaniami, tj. (Org.gradle.parallel = true, org.gradle.daemon = true). Wzrost wydajności był imponujący.

Do tego:

Wszystkie powyższe odpowiedzi są całkowicie poprawne, ale jako doświadczony programista Android (od 4 i pół roku) muszę stwierdzić, że: Żaden programista Android / Gradle nie powinien pracować na maszynie z napędem obrotowym, musisz rozwidlić Stan stały. Wszyscy naciskamy ten przycisk odtwarzania w IDE 100 razy dziennie. Kiedy przeszedłem ze spinner na SSD (po Gradle), moja prędkość i wydajność były dosłownie 2 - 4 razy szybsze i obiecuję Wam, że NIE przesadzam.

Teraz nie mówię o posiadaniu maszyny z małym dyskiem SSD i dużym spinnerem, mówię o 1 dużym dysku SSD. Jeśli masz już maszynę z małym dyskiem SSD i dużym spinnerem, możesz zaktualizować mały spinner, aby powiedzieć dysk SSD 500 GB i ustawić dysk SSD jako główny dysk systemu operacyjnego z zainstalowanymi na nim narzędziami programistycznymi.

Jeśli więc pracujesz w dynamicznym środowisku, pokaż ten post swojemu szefowi. Przyzwoity dysk SSD 1 TB kosztuje około 300 GBP (z VAT) lub około 160 GBP za dysk SSD 500 GB. W zależności od tego, czy jesteś młodszym, czy starszym programistą Androida, dysk zwróci się (w wydatkach na wynagrodzenia) w ciągu 1-2 tygodni roboczych lub około 2 i pół do 5 dni roboczych, jeśli zainwestujesz w mniejszy; powiedzmy 500 GB SSD.

Wielu programistów może argumentować, że tak nie jest, ale tak jest w przypadku Gradle, ponieważ system Gradle jest bardzo trudny w bezpośrednim dostępie do dysku. Jeśli pracujesz z .NET / C # / VB Net lub innymi narzędziami programistycznymi, nie zauważysz dużej różnicy, ale różnica w Gradle jest OGROMNA. Obiecuję, że jeśli postąpisz zgodnie z tym postem, nie będziesz rozczarowany. Osobiście używam i7 piątej generacji z 8 GB pamięci RAM, który pierwotnie był dostarczany z 1 TB Spinner i zaktualizowałem go do Samsung SSD 840 EVO 1 TB i nigdy nie patrzyłem wstecz. Kupiłem na: https://www.aria.co.uk .

Mam nadzieję że to pomoże. Muszę również stwierdzić, że NIE jest to post motywowany komercyjnie, po prostu polecam Arię, ponieważ korzystałem z nich wiele razy wcześniej i zawsze były niezawodne.

kilka poleceń, które możemy dodać do pliku gradle.properties:

org.gradle.configureondemand = true - To polecenie mówi gradle, aby budował tylko te projekty, które naprawdę musi zbudować. Użyj programu Daemon - org.gradle.daemon = true - Daemon utrzymuje instancję gradle w tle, nawet po zakończeniu kompilacji. Spowoduje to skrócenie czasu potrzebnego do zainicjowania gradle i znaczne skrócenie czasu kompilacji.

org.gradle.parallel = true - Zezwól gradle na równoległe budowanie projektu. Jeśli masz wiele modułów w swoim projekcie, to włączając tę ​​opcję, gradle może równolegle uruchamiać operacje budowania dla niezależnych modułów.

Zwiększ rozmiar sterty - org.gradle.jvmargs = -Xmx3072m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8 - Od czasu Android Studio 2.0, gradle używa dex w procesie do zmniejszenia czasu kompilacji projekt. Generalnie podczas tworzenia aplikacji wiele procesów dx działa na różnych maszynach wirtualnych. Ale począwszy od Android Studio 2.0, wszystkie te procesy dx działają na pojedynczej maszynie wirtualnej i ta maszyna wirtualna jest również współdzielona z gradle. To znacznie skraca czas kompilacji, ponieważ cały proces dex działa na tych samych instancjach maszyn wirtualnych. Ale to wymaga większej pamięci, aby pomieścić wszystkie procesy dex i gradle. Oznacza to, że musisz zwiększyć rozmiar sterty wymagany przez demona gradle. Domyślnie rozmiar sterty dla demona wynosi około 1 GB.

Upewnij się, że zależność dynamiczna nie jest używana. tj. nie używaj implementacji „com.android.support:appcompat-v7:27.0.+”. To polecenie oznacza, że ​​gradle przejdzie do trybu online i będzie sprawdzać dostępność najnowszej wersji za każdym razem, gdy tworzy aplikację. Zamiast tego użyj stałych wersji, np. „Com.android.support:appcompat-v7:27.0.2”

Dodaj to do swojego gradle.propertiespliku

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

Otwórz gradle.properties z folderu systemu Android i odznacz podświetlone wiersze i podaj wartości pamięci zgodnie z konfiguracją komputera. Mam 8 GB pamięci RAM na moim komputerze, więc dałem odpowiednio maksymalnie 4096 MB i 1024 MB.

# 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

Po tym czasie mój czas budowy został skrócony o połowę. Szczęśliwy budynek !!

Dzieje się tak często, gdy włączysz multidex w swoim projekcie. Może to potencjalnie spowolnić proces tworzenia oprogramowania !! Według doc :

Konfiguracja multidex wymaga znacznie wydłużonego czasu przetwarzania kompilacji, ponieważ system kompilacji musi podejmować złożone decyzje dotyczące tego, które klasy muszą być zawarte w podstawowym pliku DEX, a które z dodatkowych plików DEX. Oznacza to, że kompilacje przyrostowe przy użyciu multidex zwykle trwają dłużej i mogą potencjalnie spowolnić proces programowania.

ale możesz to zoptymalizować:

Aby złagodzić dłuższe przyrostowe czasy kompilacji, należy użyć funkcji pre-dexing, aby ponownie wykorzystać dane wyjściowe multidex między kompilacjami.

Jeśli korzystasz z Android Studio 2.3 lub nowszego, IDE automatycznie korzysta z tej funkcji podczas wdrażania aplikacji na urządzeniu z systemem Android 5.0 (poziom API 21) lub nowszym.

Musisz więc ustawić minSdkVersion na 21 lub wyższą !

Ale jeśli twoja wersja produkcyjna musi obsługiwać minSdkVersion niższą niż 21, na przykład 19

możesz użyć productFlavors do ustawienia minSdkVersion 21 dla swojej wersji deweloperskiej :

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

Wolę budować z wiersza poleceń, aby uzyskać lepsze czasy kompilacji. Jeśli baza kodu aplikacji jest duża i masz wiele modułów, możesz wypróbować podejście lokalne AAR, jak opisano tutaj, zapewni to duży wzrost wydajności Android Studio i czasu kompilacji. Jest również kompatybilny z wersjami poleceń

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

Projekt demonstracyjny z instrukcją integracji można znaleźć tutaj: https://github.com/akhgupta/AndroidLocalMavenRepoAARDemo