Android Studio Gradle construir acelerar

Desde a última atualização (compilada a partir de 25 de junho), qualquer alteração no estúdio Android Gradle é dolorosamente lenta. E também parece rastrear automaticamente as alterações quando você edita o arquivo e recompila na inicialização.

Cada alteração leva alguns minutos no meu i5.

Alguma idéia de como posso acelerar minhas alterações no Gradle?

Os desenvolvedores estão trabalhando nisso. Como eu postei nesta resposta, a solução mais rápida agora é usar gradle na linha de comando e você deve mudar para bibliotecas binárias para todos os módulos que não desenvolve. No g +, há uma discussão com os desenvolvedores sobre isso.

Definitivamente faz a diferença: Como ... Acelerar o tempo de construção do Gradle

Basta criar um arquivo nomeado gradle.propertiesno seguinte diretório:

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

Adicione esta linha ao arquivo:

org.gradle.daemon=true

Depois de alterar essas configurações, meu tempo de compilação 10 minutos foi reduzido para 10 segundos.

Passo 1:

Configurações (ctrl + Alt + S) ->

Compilação, Execução, Implantação ->

Compilador ->

tipo "--offline " na caixa Opções da linha de comando.

Passo 2:

marque a caixa de seleção "Compilar módulos independentes em paralelo".

e clique em Aplicar -> OK

Etapa 3: no seu arquivo gradle.properties -> adicione as seguintes linhas

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

Atualizar:

Se você estiver usando o Android studio 2.0 ou superior, tente o Instant Run

Configurações → Compilar, Execução, Implantação → Execução Instantânea → Ativar Execução Instantânea.

Mais informações sobre o Instant Run - https://developer.android.com/studio/run/index.html#instant-run

Consegui reduzir minha compilação gradle de 43 segundos para 25 segundos no meu laptop core2duo antigo (executando o linux mint) adicionando o seguinte ao arquivo gradle.properties no android studio

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

fonte sobre por que a configuração do daemon torna as compilações mais rápidas: https://www.timroes.de/2013/09/12/speed-up-gradle/

Seguir as etapas o tornará 10 vezes mais rápido e reduzirá o tempo de construção em 90%

Primeiro, crie um arquivo chamado gradle.properties no seguinte diretório:

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

Adicione esta linha ao arquivo:

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

E marque estas opções no Android Studio

Existe uma versão mais recente do gradle (versão 2.4).

Você pode definir isso para o (s) seu (s) projeto (s), abrindo a caixa de diálogo 'Estrutura do Projeto' no menu Arquivo,

Project Structure -> Project -> Gradle version

e defina-o como '2.4'.
Você pode ler mais sobre como melhorar o desempenho neste link .

Com o Android Studio 2.1, você pode ativar o "Dex In Process" para criar aplicativos mais rapidamente.

Você pode obter mais informações aqui: https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.vijksflyn

Foi isso que fiz e a velocidade de construção do meu gradle melhorou drasticamente! de 1 min a 20 s para a primeira compilação e as compilações subsequentes passaram de 40 s para 5 s.

No arquivo gradle.properties, adicione isto:

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

Nos argumentos da linha de comando vá para Arquivo> Outras configurações> Configurações padrão> Compilar, Execução, Implantar> Complier e adicione os seguintes argumentos aos Argumentos da linha de comando

Adicione isso:

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

Tente evitar o uso de um Mac / PC com apenas 8 GB de RAM ao desenvolver o Android. Assim que você inicia um emulador (Genymotion ou não), seus tempos de compilação ficam extremamente lentos no Android Studio com compilações gradle. Isso acontece mesmo se você fizer uma alteração simples de uma linha em 1 arquivo de origem.

Fechar o emulador e usar um dispositivo real ajuda muito, mas é claro que isso é muito limitador e menos flexível. Reduzir a configuração de uso de RAM do emulador pode ajudar, mas a melhor maneira é garantir que seu laptop tenha pelo menos 12 a 16 GB de RAM.

Atualização (junho de 2017): agora existem vários artigos bons do medium.com que explicam como acelerar as compilações graduais do Android Studio em detalhes e até funcionam em máquinas de 8 GB:

• Como diminuir o tempo de criação do Gradle em 65% : https://medium.com/@kevalpatel2106/how-to-decrease-your-gradle-build-time-by-65-310b572b0c43
• Faça seu Gradle construir rápido novamente! : https://medium.com/@wasyl/make-your-gradle-builds-fast-again-ea323ce6a435

O consenso resumido é:

Crie um arquivo gradle.properties (global em ~/.gradle/gradle.propertiesou local para projetar) e adicione as seguintes linhas:

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. Ativar trabalho offline

2. Melhore o desempenho do Gradle adicionando o seguinte código em gradle.properties

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

Guia passo a passo: http://www.viralandroid.com/2015/08/how-to-make-android-studio-fast.html

dexOptions {
    incremental true
    javaMaxHeapSize "4g"
}

De acordo com esta página da Equipe Android de Wikimedia Apps , uma boa maneira de otimizar as compilações do Gradle é adicionar essas linhas ao seu ~ / .gradle / gradle.properties

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

Para quem não possui o arquivo, existem duas maneiras de fazê-lo:

1. Adicione o arquivo localmente no seu projeto, criando um arquivo chamado gradle.properties na raiz do projeto ou,

2. Você pode configurá-los globalmente para todos os seus projetos, criando o mesmo arquivo no diretório inicial (% UserProfile% .gradle no Windows , ~ / .gradle no Linux e Mac OS X )

   É uma boa prática definir as propriedades no diretório inicial, e não no nível do projeto.

Você também pode usar a linha de comando para obter melhor desempenho. Você pode usar o comando ./gradlew <task name>de dentro da pasta raiz do seu projeto no linux ou usar o arquivo gradlew.bat como gradlew<task name> você executa pela primeira vez um dos comandos acima para um determinado Gradle versão, ele fará o download da distribuição Gradle correspondente e a utilizará para executar a compilação.

Ao importar um projeto Gradle por meio de seu invólucro, seu IDE pode solicitar o uso da distribuição 'all' da Gradle. Isso está perfeitamente correto e ajuda o IDE a fornecer o preenchimento de código para os arquivos de compilação. Isso não significa apenas que você não precisa instalar manualmente o Gradle, mas também usará a versão do Gradle para a qual a construção foi projetada. Isso torna suas construções históricas mais confiáveis. para obter mais informações, consulte Executando uma Construção com o Wrapper

Para compilações mais rápidas, aumente o tamanho máximo do heap para o daemon Gradle para mais de 2048 MB.

Para fazer isso, defina
org.gradle.jvmargs=-Xmx2048M
o projeto gradle.properties .

Adicione um build.gradlearquivo:

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

Espero que ajude.

Estou executando um i7 de quinta geração com Windows 10 e um estado sólido de 1 TB. Compactei a pasta Projetos do Android Studio e recebi um aumento de 80%. Espero que isto ajude.

Em seguida, combinei-o com as soluções acima, por exemplo (org.gradle.parallel = true, org.gradle.daemon = true). O aumento de desempenho foi bastante impressionante.

Além disso:

Todas as respostas acima estão totalmente corretas, mas devo declarar como uma experiência desenvolvedor Android (de 4 anos e meio) que: Nenhum desenvolvedor Android / Gradle deve estar trabalhando em uma máquina com um acionador giratório, é necessário fazer uma Estado sólido. Todos nós pressionamos o botão play no IDE centenas de vezes por dia. Quando passei de um spinner para SSD (pós Gradle), minha velocidade e eficiência foram literalmente 2-4 vezes mais rápidas e prometo que não estou exagerando aqui.

Agora não estou falando de ter uma máquina com um pequeno SSD e um grande girador, estou falando de um grande SSD. Se você já possui uma máquina com um SSD pequeno e um grande girador, pode atualizá-lo para um SSD de 500 GB e configurá-lo como sua unidade principal do sistema operacional com as ferramentas de desenvolvedor instaladas.

Portanto, se você estiver trabalhando em um ambiente de ritmo acelerado, mostre esta postagem ao seu chefe. Um SSD decente de 1 TB custará cerca de £ 300 (incluindo IVA) ou cerca de £ 160 para um SSD de 500 GB. Dependendo de você ser um desenvolvedor Android júnior ou sênior, a unidade pagará por si mesma (em despesas salariais) em 1 a 2 semanas úteis, ou cerca de 2 e meia a 5 dias úteis se você investir em uma empresa menor; digamos 500GB SSD.

Muitos desenvolvedores podem argumentar que esse não é o caso, mas é o caso da Gradle, pois o sistema Gradle é muito rígido no acesso direto ao disco. Se você trabalha com .NET / C # / VB Net ou outras ferramentas de desenvolvimento, não notará muita diferença, mas a diferença em Gradle é ENORME. Se você agir neste post, prometo, não ficará desapontado. Pessoalmente, estou usando o i7 de quinta geração com 8 GB de RAM, que originalmente vinha com um Spinner de 1 TB e eu o atualizei para um Samsung SSD 840 EVO 1 TB e nunca mais olhei para trás desde então. Comprei o meu em: https://www.aria.co.uk .

Espero que isto ajude. Também devo declarar que este NÃO é um post motivado comercialmente, só estou recomendando o Aria, pois já os usei muitas vezes antes e eles sempre foram confiáveis.

alguns comandos que podemos adicionar ao arquivo gradle.properties:

org.gradle.configureondemand = true - Este comando instruirá o gradle a criar apenas os projetos que ele realmente precisa. Use Daemon - org.gradle.daemon = true - O Daemon mantém a instância do nivelamento em execução em segundo plano, mesmo após a conclusão da sua compilação. Isso removerá o tempo necessário para inicializar a gradle e diminuirá significativamente o tempo de compilação.

org.gradle.parallel = true - permita que o gradle construa seu projeto em paralelo. Se você possui vários módulos no seu projeto, habilitando isso, o gradle pode executar operações de construção para módulos independentes paralelamente.

Aumentar tamanho do heap - org.gradle.jvmargs = -Xmx3072m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8 - Desde o android studio 2.0, o gradle usa dex no processo para diminuir o tempo de compilação do projeto. Geralmente, ao criar os aplicativos, vários processos dx são executados em diferentes instâncias da VM. Mas a partir do Android Studio 2.0, todos esses processos dx são executados na única VM e essa VM também é compartilhada com o gradle. Isso diminui significativamente o tempo de construção, pois todo o processo dex é executado nas mesmas instâncias da VM. Mas isso requer uma memória maior para acomodar todos os processos de dex e gradação. Isso significa que você precisa aumentar o tamanho do heap exigido pelo daemon gradle. Por padrão, o tamanho da pilha do daemon é de cerca de 1 GB.

Certifique-se de que a dependência dinâmica não seja usada. ou seja, não use a implementação 'com.android.support:appcompat-v7:27.0.+'. Este comando significa que o gradle ficará online e procurará a versão mais recente sempre que criar o aplicativo. Em vez disso, use versões fixas, ou seja, 'com.android.support:appcompat-v7:27.0.2'

Adicione isso ao seu gradle.propertiesarquivo

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

Abra gradle.properties da pasta android e descomente as linhas destacadas e forneça valores de memória conforme a configuração da sua máquina. Eu tenho 8GB de RAM na minha máquina, então eu dei no máximo 4096mb e 1024mb, respectivamente.

# 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

Meu tempo de construção foi reduzido para metade depois disso. Edifício feliz !!

Isso geralmente acontece quando você habilita o multidex no seu projeto. Isso pode potencialmente retardar seu processo de desenvolvimento! De acordo com o documento :

a configuração multidex requer um tempo de processamento de construção significativamente aumentado, porque o sistema de construção deve tomar decisões complexas sobre quais classes devem ser incluídas no arquivo DEX principal e quais classes podem ser incluídas nos arquivos DEX secundários. Isso significa que construções incrementais usando multidex normalmente levam mais tempo e podem potencialmente retardar seu processo de desenvolvimento.

mas você pode otimizar isso:

Para mitigar tempos de construção incrementais mais longos, você deve usar a pré-destinação para reutilizar a saída multidex entre construções.

Se você estiver usando o Android Studio 2.3 e superior, o IDE usará automaticamente esse recurso ao implantar o aplicativo em um dispositivo executando o Android 5.0 (nível de API 21) ou superior.

Então, você precisa definir o minSdkVersion para 21 ou superior !

Mas se a sua versão de produção precisar suportar minSdkVersion menor que 21, por exemplo 19

você pode usar productFlavors para definir o minSdkVersion 21 para sua versão do desenvolvedor:

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

Eu prefiro construir a partir da linha de comando para obter melhores tempos de construção. Se a sua base de códigos do aplicativo for grande e você tiver vários módulos, poderá tentar a abordagem do AAR local conforme descrito aqui, isso lhe dará um grande impulso no desempenho do Android Studio e nos tempos de compilação. Também é compatível com a linha de comando

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

O projeto de demonstração com instruções de integração pode ser encontrado aqui: https://github.com/akhgupta/AndroidLocalMavenRepoAARDemo