A criação e execução de aplicativos via Gradle e Android Studio é mais lenta que via Eclipse

461

Eu tenho um multiprojeto (~ 10 módulos) cujo prédio leva cerca de 20 a 30 segundos cada vez. Quando pressiono Executar no Android Studio, tenho que esperar sempre para reconstruir o aplicativo, o que é extremamente lento.

É possível automatizar o processo de construção no Android Studio? Ou você tem algum conselho sobre como tornar esse processo mais rápido?

No Eclipse, graças à criação automática, a execução do mesmo projeto em um emulador leva cerca de 3-5 segundos.

Este é o meu arquivo build.gradle (módulo de aplicativo):

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
    }
}
froger_mcs
fonte
23
Lembre-se de que nem o sistema de criação baseado em Gradle nem o Android Studio são de nível de produção no momento.
CommonsWare
11
O tempo gasto aqui é provavelmente na fase DEX. Infelizmente, o make do estúdio android parece ser limpo todas as vezes, fazendo com que os arquivos anteriormente deletados sejam excluídos. Felizmente, veremos uma correção incremental da compilação em breve.
Richard J. Ross III
3
Enquanto isso, existe alguma maneira simples de dizer como alterar as tarefas padrão do Gradle de forma que elas nem sempre executem uma limpeza?
Sigmabeta 28/10/2013
10
@ CommmonsWare bem, não há desculpa agora que estamos na versão 1.02, mas ainda é um grande problema. Com o Android studio rodando, meu laptop quad core de 4 GB usa cerca de 3,75 GB de RAM, apenas mantendo uma única instância de um projeto Olá Mundo. É também, como resultado, muito lento. Para mim, isso indica uma falha de design séria e contínua. Espero que as coisas sejam resolvidas em breve.
Andrew S
7
@ Andrews Acho uma pena que precisamos mudar nosso sistema operacional apenas para que o gradle funcione a uma velocidade razoável em comparação com as ferramentas anteriores.
Richard Le Mesurier

Respostas:

441

Hardware

Sinto muito, mas atualizar a estação de desenvolvimento para SSD e toneladas de RAM provavelmente tem uma influência maior do que os pontos abaixo combinados.

Versões de ferramentas

Aumentar o desempenho da compilação tem grande prioridade para as equipes de desenvolvimento, portanto, verifique se você está usando os plug-ins Gradle e Android Gradle mais recentes .

Arquivo de configuração

Crie um arquivo nomeado gradle.propertiesem qualquer diretório que se aplique:

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

Acrescentar:

# 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

As propriedades Gradle funcionam localmente se você as colocar projectRoot\gradle.propertiese globalmente se você as colocar em user_home\.gradle\gradle.properties. Propriedades aplicadas se você executar tarefas de classificação no console ou diretamente da ideia:

Configurações IDE

É possível ajustar a integração Gradle-IntelliJ a partir da GUI de configurações do IDE. A ativação do "trabalho offline" (verifique a resposta do yava abaixo) desativará as solicitações reais da rede em todos os "arquivos de sincronização".

Configurações IDE

Multi-dex nativo

Uma das etapas mais lentas da compilação do apk é converter bytecode em java em um único arquivo dex. A ativação do multidex nativo (minSdk 21 apenas para compilações de depuração) ajudará as ferramentas a reduzir uma quantidade de trabalho (verifique a resposta de Aksel Willgert abaixo).

Dependências

Preferir @aardependências sobre subprojetos de bibliotecas.

Pesquise o pacote aar no mavenCentral , jCenter ou use o jitpack.io para criar qualquer biblioteca do github. Se você não estiver editando fontes da biblioteca de dependências, não deve construí-la sempre com as fontes do projeto.

Antivírus

Considere excluir arquivos de projeto e cache da verificação antivírus. Obviamente, isso é uma troca de segurança (não tente fazer isso em casa!). Mas se você alternar bastante entre as ramificações, o antivírus verificará novamente os arquivos antes de permitir que o processo gradle o use, o que diminui o tempo de criação (em particular o projeto de sincronização do AndroidStudio com arquivos gradle e tarefas de indexação). Avalie o tempo de construção e processe a CPU com e sem o antivírus ativado para verificar se está relacionado.

Criação de perfil de uma construção

Gradle tem suporte embutido para projetos de criação de perfil . Projetos diferentes estão usando uma combinação diferente de plug-ins e scripts personalizados. Usar --profileajudará a encontrar gargalos.

Sergii Pechenizkyi
fonte
1
sobre as depedências @aar: usar, por exemplo, dependencies {compile 'com.android.support:support-v4:21.0.+'}é uma solução lenta? não tenho certeza de entender
younes0
1
Imagem, você adicionou uma biblioteca como esta: github.com/novak/numberpicker . Ele tem valor, fornecendo solução de código para um problema, mas o autor não a publicou em lugar algum como o maven ou o jCenter. Agora você deve trazer essa biblioteca como fontes para o seu projeto e construí-la sempre que o projeto principal for compilado ou compilá-lo uma vez e comprometer apenas @aar no repositório do projeto. Portanto, é realmente uma opção de dependência fonte / binária. Se você não estiver editando a fonte, traga sua dependência como binário pré-compilado. Para bibliotecas java simples que é .jar, para as bibliotecas Android que é .aar
Sergii Pechenizkyi
1
É configurações do projeto> gradle. Veja a captura de tela abaixo: i.stack.imgur.com/wrwgo.png
Sergii Pechenizkyi
2
Configurei todas as otimizações conforme descrito, no entanto, no Android Studio, leva de 3 a 4 minutos para iniciar meu aplicativo, enquanto o Eclipse demorou cerca de 30 segundos. Porcaria. Apenas 12 projetos, um único aplicativo para executar! O desenvolvedor do Android se tornou tão complicado agora, e isso aconteceu mais de um ano depois.
3c71
1
Apliquei todas as otimizações e ainda leva cerca de 20 segundos para criar um apk do HelloWorld, comparado a 2-3 segundos no Eclipse.
Pawel
148

Você pode ignorar as verificações atualizadas da gradle.

insira a descrição da imagem aqui

Para Windows executando o Android Studio 1.5: Vá para File -> Settings -> Build, Execution, Deployment -> Build tools -> Gradle -> Check Offline work (as shown in image)

de ~ 30 + seg a ~ 3 seg

yava
fonte
24
Isso é bem legal. Isso é muito mais rápido. Mas o que isso quebra?
John Ballinger
2
Melhor solução. Posso saber os efeitos colaterais desta solução
Kavin Varnan
26
@JohnBallinger Trabalho offline - use esta caixa de seleção para trabalhar com o Gradle no modo offline. Nesse caso, o Gradle usará dependências do cache. Gradle não tentará acessar a rede para executar a resolução de dependência. Se as dependências necessárias não estiverem presentes no cache das dependências, a execução da compilação falhará. (Source: jetbrains.com/idea/help/gradle-2.html )
cprcrack
10
É padrão usar dependências em cache primeiro antes de passar pela rede? Não consigo imaginar que isso verifique se há dependências atualizadas sempre que gradlefor executado. Isso é bizarro.
Ehtesh Choudhury
1
@EhteshChoudhury é MUITO bizarro. Todo o ambiente de desenvolvimento do Gradle / Android Studio é tão slooooooow. A maioria das pessoas pensa que é lento por causa do Java. Eu desenvolvo Java dev no IDEA do lado do servidor e as coisas funcionam muito bem.
stepanian 6/07/16
34

Pesquisou em todos os lugares por isso e finalmente encontrou uma solução que funciona para nós. Habilitar compilações paralelas (no OSX :) preferences -> compiler -> gradle -> "Compile independent modules in parallel"e habilitar 'criar projeto automaticamente' diminuíram de ~ 1 minuto para ~ 20 segundos. Graças a / u / Covalence.

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

odiggity
fonte
56
20 segundos ainda é muito lento.
Johannes Brodwall 7/03
6
Lembre-se de que isso aparentemente só ajuda quando você tem vários módulos / projetos independentes. Eu testei em um aplicativo de módulo único e não fez nenhuma diferença.
26415 Sam
Eu tenho um projeto bem grande e leva de 2 a 3 minutos no MacBook Pro 2012 Core i7, 8 GB de RAM. Tudo bem?
Sermilion
25

Recentemente, comprei um novo SSD e fui do Windows para o Linux. Meus tempos de compilação agora são uma ordem de magnitude mais rápida e não são mais irritantes.

Embora não responda diretamente à sua pergunta sobre por que é mais lento que o eclipse, mostra que o processo é delimitado por disco e que a atualização para um SSD pode ser uma solução (um tanto cara). Suponho que haverá pessoas pesquisando a questão e terminando aqui, que poderão apreciar minha experiência.

Andreas Løve Selvik
fonte
11
Os desenvolvedores da minha equipe têm SSDs rápidos em máquinas rápidas com muita memória. Para um aplicativo não trivial, a reimplantação após uma pequena alteração no código ainda leva cerca de 45 segundos, em comparação com a reimplantação quase instantaneamente no Eclipse. Mesmo a execução de uma JUnit simples, sem Android, é proibitivamente lenta. "Atualizar" para o Android Studio e Gradle tem sido um grande downgrade até agora. : - /
spaaarky21
@Lionleaf quanto mais rápido mudar do Windows para o Linux?
precisa saber é o seguinte
@ younes0 eu não sei. Mudei para o Linux ao mesmo tempo em que mudei para um SSD. Não estou dizendo que tenha algum efeito positivo, foram apenas essas duas variáveis ​​que mudei para a aceleração.
Andreas Løve Selvik
4
No meu caso de comutação do Windows para o Linux resultaram em 40% mais rápido do Android constrói ... por isso é definitivamente vale a pena
kosiara - Bartosz Kosarzycki
Segundo, o que @Bartosz Kosarzycki disse. Acabei rodando um Ubuntu vm com virtualbox na minha máquina de desenvolvimento. ~ 54 segundos de compilação no Windows, ~ 7seg para a mesma compilação dentro da máquina virtual no mesmo hardware. Aceleração insana mudando para o Linux.
Eric Cornelson
20

Acelere a construção do Gradle no Android Studio 3.2.1

Você já sentiu a espera de concluir as compilações no Android Studio por alguns minutos? Eu também. E é muito chato. Felizmente, existem algumas maneiras que você pode usar para melhorar isso. Android usa Gradle para a construção. A versão mais recente é 4.6, com um enorme aumento de desempenho em relação às versões anteriores (consulte as Notas da versão para obter detalhes).

Etapa 1: Atualizar a versão Gradle Uma maneira mais fácil de fazer isso é acessar: Configurações do módulo aberto (seu projeto)> Estrutura do projeto

insira a descrição da imagem aqui

ATUALIZAR

Altere para a versão Gradle: 4.6 e Altere para a versão do plug-in Android: 3.2.1

insira a descrição da imagem aqui

Faça o download do Gradle Release distributivo em https://services.gradle.org/distributions/gradle-4.6-all.zip E copie-o para a pasta Gradle:

insira a descrição da imagem aqui

O último passo é adicionar sua discrição em Configurações> Gradle

insira a descrição da imagem aqui

Não se esqueça de clicar em Aplicar para salvar as alterações.

Etapa 2: ativar o modo offline, o daemon Gradle e a compilação paralela para o projeto O modo offline instrui o Gradle a ignorar as verificações atualizadas. Gradle solicita dependências sempre e, com essa opção, ela usa apenas o que já está na máquina para dependências. Vá para Gradle no Android studio Setting e clique na caixa de trabalho Off-line.

insira a descrição da imagem aqui

  1. Vá para o Compiler no Android studio Setting e adicione "- offline" na caixa de linha de comando e clique em Compilar módulos independentes em paralelo.

insira a descrição da imagem aqui

A próxima etapa é ativar o daemon Gradle e a compilação paralela para o seu projeto. Construções paralelas farão com que seus projetos com vários módulos (construções com vários projetos no Gradle) sejam paralelos, o que deve fazer projetos grandes ou modulares serem construídos mais rapidamente.

insira a descrição da imagem aqui

Essas configurações podem ser ativadas modificando um arquivo chamado gradle.properties no diretório de scripts Gradle (por exemplo, ~ / .gradle / gradle.properties). Algumas dessas opções (por exemplo, módulos Complie em paralelo) estão disponíveis no Android Studio e também são ativadas por o padrão, mas colocá-los no arquivo gradle.properties os habilitará ao criar a partir do terminal e também garantir que seus colegas usem as mesmas configurações. Mas se você estiver trabalhando em equipe, às vezes não poderá cometer essas coisas.

# 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

O uso do daemon tornará a inicialização de suas compilações mais rápida, pois não será necessário iniciar o aplicativo Gradle inteiro todas as vezes. O Gradle Daemon não está ativado por padrão, mas é recomendável sempre habilitá-lo para as máquinas dos desenvolvedores (mas deixando-o desativado para servidores de integração contínua). As perguntas frequentes sobre este modo podem ser encontradas aqui https://docs.gradle.org/current/userguide/gradle_daemon.html . A configuração de compilações paralelas pode não ser segura para alguns projetos. O requisito é que todos os seus módulos sejam dissociados ou sua compilação possa falhar (consulte http://gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects para obter detalhes).

Etapa 3: ativar as configurações incrementais de dexign e ajustar a memória Você pode acelerar suas construções ativando a dexing incremental. No arquivo de construção do seu módulo:

insira a descrição da imagem aqui

Adicione esta opção ao seu bloco Android:

dexOptions {
    incremental true
}

Nesse bloco dexOptions, você também pode especificar o tamanho do heap para o processo dex, por exemplo:

dexOptions {
    incremental true
    javaMaxHeapSize "12g"
}

Onde "12g" representa 12 GB de memória. Informações adicionais sobre isso podem ser encontradas aqui google.github.io/android-gradle-dsl/current/ Você também pode configurar os parâmetros Gradle no arquivo de configurações, por exemplo, aumentar o tamanho máximo do heap caso tenha um projeto grande:

# 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

Veja toda a lista de parâmetros aqui: https://docs.gradle.org/current/userguide/userguide_single.html#sec:gradle_configuration_properties para obter detalhes.

Passo 4: Desativar antivírus Considere excluir arquivos de projeto e cache da verificação antivírus. Obviamente, isso é uma troca com segurança. Mas se você alternar bastante entre as ramificações, o antivírus verificará novamente os arquivos antes de permitir que o processo gradle o use, o que diminui o tempo de compilação (em particular, o projeto de sincronização do Android Studio com arquivos gradle e tarefas de indexação). Avalie o tempo de construção e processe a CPU com e sem o antivírus ativado para verificar se está relacionado. Eu espero que isso ajude. Deixe um comentário se tiver alguma dúvida ou alguma outra dica para melhorar o desempenho da compilação.

link útil

Ahmad Aghazadeh
fonte
19

Se você estiver usando os serviços do Google Play, dependendo apenas das bibliotecas necessárias em vez de todo o blob, as coisas podem ser mais rápidas.

Se sua única necessidade é de mapas, use:

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

ao invés de:

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

O último traz métodos de 20k (consulte o blog) no caminho de classe, o que pode reduzir a contagem total de métodos acima de 64k.

Isso forçaria o uso de proguard ou multidex, mesmo para compilações de depuração. Para um dos meus projetos, tive os seguintes tempos de compilação

  • compilação multidex (com supportlibrary) ~ 40seg
  • construção do programa ~ 20seg
  • construir quando o limite do método <64k ~ 5seg

Se estiver desenvolvendo no sdk 21+, seria possível otimizar as compilações multidex, conforme indicado na documentação do 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
        }
    }
    ...
}
Aksel Willgert
fonte
2
Em vez de compilar toda a play-servicebiblioteca, eu compilado única mapse locations e desativado o multidex. Eu sinto a grande diferença. Obrigado +1
Sami Eltamawy
16

A resposta aceita é para versões mais antigas do android studio e a maioria delas ainda funciona agora. A atualização do android studio tornou um pouco mais rápido. Não se preocupe em especificar o tamanho da pilha, pois ela aumentará automaticamente com o aumento de Xms e Xmx. Aqui estão algumas modificações com as VMoptions

  1. Na pasta bin, há um arquivo studio.vmoptions para definir a configuração do ambiente. No meu caso, é studio64.vmoptions Adicione as seguintes linhas, se ainda não tiverem sido adicionadas, e salve o arquivo. No meu caso, tenho 8 GB de RAM.

    -Xms4096m
    -Xmx4096m
    -XX:MaxPermSize=2048m
    -XX:+CMSClassUnloadingEnabled
    -XX:+CMSPermGenSweepingEnabled 
    -XX:+HeapDumpOnOutOfMemoryError
    -Dfile.encoding=utf-8`
  2. Inicie o android studio. Vá para Arquivo-> Configurações-> Compilar, Execução, Implantação-> Compilador

    • Verifique compilar módulos independentes em paralelo
    • Nas opções da linha de comando, escreva: --offline
    • Marque Criar projeto automaticamente
    • Verifique a configuração sob demanda

No caso de usar mac, no começo não consegui encontrar as vmoptions. Enfim, aqui está um bom artigo sobre como podemos alterar as vmoptions no MAC OSX . Citando este artigo aqui.

Abra seu terminal e coloque este comando para abrir as vmoptions no MAC OSX:

open -e /Applications/Android\ Studio.app/Contents/bin/studio.vmoptions
Reaz Murshed
fonte
1
a partir do AS 2.3.2, você pode alterar as opções do vim por help-> Edit Custom Vm Options
Sam
15

Basta criar 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

Para mim, a velocidade agora é igual ao Eclipse.

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

Yster
fonte
Não consigo ver a pasta .gradle no mac. Como abrir?
Dharmik 4/11/14
@ Darmik: Talvez você tenha instalado o Android Studio com um nome de usuário diferente. Caso contrário, não está instalado corretamente, eu acho.
Yster
1
Não, havia outro problema. A pasta do sistema ".gradle" estava oculta. Então, vou para Go => Go To Folder e encontrei a pasta .gradle .. Obrigado pela resposta rápida ..
Dharmik
14

Você pode tornar o processo mais rápido se usar gradle na linha de comando. Há muita otimização para os desenvolvedores de IDE. Mas é apenas uma versão inicial.

Para mais informações, leia esta discussão no g + com alguns dos desenvolvedores.

rivare
fonte
3
Isso parece ser verdade agora mesmo em 2016
Leo apoia Monica Cellio 04/06
11

Se alguém estiver trabalhando em um projeto sincronizado via Subversion e isso ainda estiver acontecendo, acho que isso pode atrasar o processo de fluxo de trabalho no Android Studio. Por exemplo, se funcionar muito lentamente enquanto: rolagem em uma classe, xml etc., enquanto meu aplicativo ainda está sendo executado no meu dispositivo.

  • Vá para Controle de versão em Preferências e defina do Subversion para Nenhum.insira a descrição da imagem aqui
Gent Berani
fonte
1
Você salva meu dia: 2/4 min -> 15seg (desativei o Tortoise HG para o projeto).
kaftanati
3
Se alguém ainda está usando Subversion, eles devem mudar para o Git ou Mercurial
Leo suporta Monica Cellio
8

Atualizar após o Android Studio 2.3

Todas as respostas são ótimas, e eu incentivo a usar esses métodos com este para melhorar a velocidade de construção.

Após o lançamento do Android 2.2 em setembro de 2016, o Android lançou o recurso experimental de cache de compilação para acelerar o gradledesempenho da compilação, que agora é oficial do Android Studio 2.3 Canary. (Nota oficial de lançamento)

Ele introduz um novo recurso de cache de compilação, que é ativado por padrão, pode acelerar os tempos de compilação (incluindo compilações completas, compilações incrementais e execução instantânea) armazenando e reutilizando arquivos / diretórios criados em compilações anteriores do mesmo ou de outro Android projeto.

Como usar:

Adicione a seguinte linha no seu gradle.propertiesarquivo

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.

Limpe o cache:

  • Há uma nova tarefa Gradle solicitada cleanBuildCachepara que você limpe mais facilmente o cache de compilação. Você pode usá-lo digitando o seguinte em seu terminal:

    ./gradlew cleanBuildCache

  • OU Você pode limpar o cache do Android studio 2.2 excluindo todos os arquivos armazenados no local

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

Shaishav Jogani
fonte
7

Depois de alterar essas configurações, minha duração de compilação 10 minutos mudou para ~ 10 segundos.

Passo 1:

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

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

Compilador ->

digite " --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

insira a descrição da imagem aqui

Referência - https://www.sundoginteractive.com/blog/speed-up-gradle-in-android-studio

Desvantagem:

Você não poderá baixar as versões mais recentes das dependências identificadas no seu arquivo build.gradle. Ele roda mais rápido porque usa um instantâneo em cache dessas bibliotecas importadas.

Nota importante : Ao implantar o aplicativo, remova essas configurações e construa com as versões mais recentes das dependências.

Ranjith Kumar
fonte
6

Mina resolvida com

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

As versões do Gradle passaram de 8 minutos para 3 segundos.

mn_test347
fonte
4

Aqui está o que ajudou esse programador iniciante do Android (ex-programador profissional, anos atrás) a acelerar o Android Studio 2.2. Eu sei que isso é uma reformulação, mas, apenas resumindo em um só lugar.

As versões iniciais ainda podem ser brutalmente lentas, mas as reinicializações de aplicativos em execução agora são geralmente muito toleráveis. Estou usando um PC subótimo: CPU AMD Quad-Core A8-7410, 8 MB de RAM, HD sem SSD, Win 10. (E, esta é minha primeira postagem no Stack Overflow ....;)

EM CONFIGURAÇÕES -> GRADLE:

sim para "Trabalho off-line" (talvez essa seja a configuração mais importante).

EM CONFIGURAÇÕES -> COMPILADOR:

yes para "Compile módulos independentes em paralelo" (não tenho certeza se isso de fato ajuda a utilizar CPUs multicore).

EM GRADLE SCRIPTS , "build.gradle (Módulo: 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

TAMBÉM EM SCRIPTS GRADLE , "gradle.properties (Propriedades do Projeto)":

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

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

Além disso , o teste em um dispositivo físico em vez do emulador está funcionando bem para mim; um pequeno tablet que se levanta é conveniente.

Greg
fonte
4

Apenas mais uma dica de melhoria de desempenho:

O Android Studio 3.0 inclui o novo compilador DEX chamado D8.

"O compilador dex funciona principalmente sob o capô no desenvolvimento diário do seu aplicativo, mas afeta diretamente o tempo de criação do aplicativo, o tamanho do arquivo .dex e o desempenho do tempo de execução."

"E ao comparar o novo compilador D8 com o atual compilador DX, o D8 compila mais rapidamente e gera arquivos .dex menores, mantendo o mesmo ou melhor desempenho em tempo de execução do aplicativo".

D8 é opcional - use-o para colocar no gradle.properties do projeto

android.enableD8=true

Mais informações: https://android-developers.googleblog.com/2017/08/next-generation-dex-compiler-now-in.html

PS. Impulsionou meu tempo de construção em cerca de 30%.

Leśniakiewicz
fonte
1

Essa configuração é muito rápida para mim (cerca de 2 segundos após a compilação)

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

meu PC:

  • CPU Processador Intel® Pentium® G2030 @ 3.00GHz, 3000 Mhz, 2 processadores principais, 2 processos lógicos
  • x64
  • Microsoft Windows 7 Professional
  • (RAM) 16,0 GB

arquivos de projeto
- todos localizados em HD local

MoaLaiSkirulais
fonte
1

Você pode tentar abrir o menu gradle no lado direito do estúdio, montar apenas os módulos alterados e executar o comando install. Quando você pressiona executar, ele monta tudo, independentemente de quaisquer alterações que você possa ter feito no código que está montando

SBC
fonte
0

Estou longe de ser um especialista em Gradle, mas meu ambiente tinha a seguinte linha em .gradle / init.gradle

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

No entanto, não tenho idéia do porquê dessa linha, mas tento mudar para

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

e agora finalmente posso trabalhar sem jurar pelo esquema de construção do Android Studio e Gradle.

cifuentes
fonte
provavelmente o artifactory no seu caso foi usado como um cache de biblioteca. Você entra em contato com o servidor artefato que verifica se ele possui a biblioteca. Se sim, devolva-o para você, caso contrário, ele o buscará no mavencentral e depois retornará para você.
Fabio Marcolini
0

No nosso caso específico, o problema ocorreu devido à retrolambda in , que forçou todos os projetos e subprojetos a se recompilarem sempre que tentamos iniciar nosso aplicativo, mesmo que nenhum código tenha sido alterado em nossos módulos principais.

A remoção do retrolamba o corrigiu para nós. Espero que ajude alguém.

Henrique de Sousa
fonte
0

Apenas tente isso primeiro. É a minha experiência pessoal.

Eu tive o mesmo problema. O que eu fiz foi desativar permanentemente o antivírus (o Mine era o Avast Security 2015). Logo após desativar o antivírus, tudo correu bem. o gradle terminou com sucesso. A partir de segundos, o gradle está terminando (levando apenas 5 a 10 segundos).

NIKHIL CM
fonte
0

Oi, eu sei que esta é uma resposta muito, muito tarde, mas talvez ajude alguém
no meu caso, eu estava usando

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

no meu aplicativo dependência Gradle,
mas em uma das minhas bibliotecas era

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

depois de mudar tudo para a versão mais recente, meu problema foi resolvido.

max
fonte
0

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

insira a descrição da imagem aqui

Biswajit Karmakar
fonte
0

Uma alteração trivial (para um xml de reabsorção) ainda levou 10 minutos . Como o @rivare diz em sua resposta, a criação de uma linha de comando é mais rápida (levou isso para 15 segundos ).
Aqui estão algumas etapas para, pelo menos, tornar uma construção trivial rápida a partir da linha de comando do Windows.

  1. para a raiz do seu projeto (onde está o gradlew.bat):

    cd c: \ android \ MaskActivity

  2. execute a compilação :

    gradlew assembleDebug

  3. desinstale o apk diretamente do telefone (arraste-o para desinstalar).

  4. Quando a compilação estiver concluída, mate o processo java BIG usando o Gerenciador de Tarefas do Windows.

OU se você possui ferramentas unix em sua máquina Windows:

ps

Os "pid" são mostrados:

kill -9 <pid>
  1. Agora instale seu apk:

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

Jon Goodwin
fonte
0

De acordo com a documentação do Android , adicione isso no arquivo gradle do módulo de aplicativo.

android {
    ...
    dexOptions {
    preDexLibraries true
    maxProcessCount 8
    }
}
Allan
fonte
0

Para executar o ambiente Android na máquina de baixa configuração.

  1. Feche as guias da web desnecessárias no navegador
  2. Para usuários de antivírus, exclua a pasta de compilação gerada automaticamente
  3. O estúdio Android tem um heap padrão de 1,2 Gb que pode diminuir para 512 MB Ajuda> Editar opções personalizadas da VM studio.vmoptions -Xmx512m O desempenho dos layouts será acelerado

  4. Para Gradle, um dos componentes principais do estúdio Android Mkae, com certeza, como agora, 3.0beta é o mais recente

As dicas abaixo podem afetar a qualidade do código; portanto, use com cuidado:

  1. O Studio contém o Modo de economia de energia, quando ativado, fecha as operações em segundo plano que fiam, complementam o código e assim por diante.

  2. Você pode executar a verificação manual do lint quando necessário ./gradlew lint

  3. A maioria deles usa emuladores Android, em média, consome 2 GB de RAM; portanto, se possível, use o dispositivo Android real, pois isso reduzirá a carga de recursos no seu computador. Como alternativa, você pode reduzir a RAM do emulador e isso reduzirá automaticamente o consumo de memória virtual no seu computador. você pode encontrar isso na configuração do dispositivo virtual e na configuração avançada.

  4. O modo offline Gradle é um recurso para usuários com largura de banda limitada para desativar o download de dependências de compilação. Reduzirá a operação em segundo plano que ajudará a aumentar o desempenho do Android studio.

  5. O Android studio oferece uma otimização para compilar vários módulos em paralelo. Em máquinas com pouca RAM, esse recurso provavelmente terá um impacto negativo no desempenho. Você pode desativá-lo na caixa de diálogo de configurações do compilador.

Smit Patel
fonte