Como melhorar a velocidade de compilação de seus projetos Android

Recentemente, assumi a tarefa de migrar a base de código do Android em Kure para o AndroidX. Parecia a oportunidade perfeita para tentar corrigir as velocidades de construção do projeto.

O Gradle sempre teve uma má reputação por ser lento e usar muitos recursos, mas fiquei bastante surpreso ao ver como pequenas alterações na configuração de compilação do projeto poderiam melhorar muito as velocidades de compilação.

Para dar a você uma prévia do tempo que consegui eliminar de nossas compilações limpas, aqui está uma métrica antes e depois da varredura de compilação.

Descendo de 5,5 minutos para 17 segundos ?? Isso é maluco.

É fácil exagerar com otimizações que você pode executar para reduzir ainda mais o tempo de construção. Mas vou me concentrar intencionalmente nas medidas menores e indolores que tomei para chegar perto dessa métrica com o objetivo de manter este post amigável para iniciantes.

Mas primeiro!

Antes de começar com a otimização, é importante comparar nosso projeto para ver quanto tempo leva para construir. O Gradle tem uma opção de digitalização útil que você pode usar para analisar o desempenho de sua tarefa. Abra o terminal no Android Studio e execute o seguinte comando:

./gradlew assembleDebug --scan

Assim que a construção for concluída com êxito, ele solicitará que você aceite os termos de serviço para fazer upload dos resultados da varredura de construção. Digite sim para continuar. Assim que terminar a publicação, você receberá um link no terminal para verificar sua varredura de construção. Abra o link.

Existem algumas opções no site, mas por uma questão de brevidade, vamos apenas dar uma olhada no que é mais importante.

O sumárioA visualização mostra um resumo das tarefas que foram executadas e quanto tempo levou para serem concluídas. Mas o que nos interessa aqui é a seção Desempenho . Fornece uma análise mais detalhada do tempo total de construção, conforme mostrado abaixo.

Na seção de desempenho, há uma guia Configurações e sugestões que fornece sugestões sobre como você pode melhorar suas velocidades de construção. Vamos verificar isso.

Podemos encontrar algumas correções fáceis para nossa velocidade de construção nesta seção. Então, vamos aplicar essas sugestões em nosso projeto.

Etapa nº 1: atualize suas ferramentas

A equipe do Android está constantemente melhorando e evoluindo o sistema de compilação do Android. Portanto, na maioria das vezes, você pode receber melhorias significativas apenas com a adoção da versão mais recente das ferramentas.

No momento desta refatoração, nosso projeto estava na versão 3.2.1 do plug-in Gradle para Android Studio (que é algumas versões mais antigas do que a versão mais recente).

Você pode visitar este link para obter a versão mais recente do plug-in do Gradle.

No momento em que escrevo esta postagem, a versão mais recente é 3.4.0.

Mas vem com um problema que precisamos manter em mente para mais tarde:

Ao usar o Gradle 5.0 e superior , precisaremos aumentar explicitamente o tamanho do heap para garantir que nossa velocidade de construção não piore. Voltaremos a isso em apenas um minuto.

Abra o arquivo build.gradle de nível superior que você encontrará na raiz do seu projeto e adicione a seguinte linha na seção de dependências:

classpath 'com.android.tools.build:gradle:3.4.0'

Você também precisará atualizar a URL de distribuição no arquivo de propriedades do gradle wrapper localizado em gradle / wrapper / gradle-wrapper.properties. Atualize o URL para o seguinte.

(Este link estará disponível na página de lançamento do plugin Android Gradle.)

distributionUrl=https\://services.gradle.org/distributions/gradle-5.1.1-all.zip

Se você estiver usando Kotlin em seu projeto, ocorrerá um erro se a versão do seu plugin Kotlin Gradle for inferior a 1.3.0 . Se for esse o caso, use o prompt do IDE para atualizar seu plug-in Kotlin Gradle para a versão mais recente (que no momento em que este post foi escrito é a versão 1.3.31 ).

Tudo bem, vamos executar a compilação novamente do terminal para ver se conseguimos alguma melhoria.

Etapa 2: atualize suas configurações

Portanto, conseguimos reduzir cerca de 2,5 minutos do tempo de construção, mas ainda não é bom o suficiente. Ao investigar os logs de construção no terminal, encontrei uma linha que é do nosso interesse:

A compilação incremental basicamente evita a compilação desnecessária de todo o conjunto de arquivos de origem e, em vez disso, compila apenas os arquivos que foram alterados. Olhando os registros, fica claro que não estamos aproveitando esse recurso. Ele sugere que usemos android.enableSeparateAnnotationProcessing = true, mas como estamos usando Kotlin em nossos projetos, não devemos usar a configuração 'annotationProcessor' de qualquer maneira.

Felizmente, Kotlin versão 1.3.30 adicionou o suporte para processamento de anotação incremental.

Então vamos

  1. Mude a configuração do annotationProcessor para kapt
  2. Ativar o sinalizador experimental de processamento de anotação incremental

Abra o arquivo build.gradle de nível de módulo e adicione a seguinte linha ao início do arquivo:

apply plugin: 'kotlin-kapt'

Em seguida, altere todas as configurações de annotationProcessor na seção de dependências para usar kapt. Aqui está um exemplo:

//Before annotationProcessor 'com.google.dagger:dagger-compiler:2.9' //After kapt 'com.google.dagger:dagger-compiler:2.9'

Agora abra o arquivo gradle.properties localizado na raiz do seu projeto e adicione a seguinte linha:

kapt.incremental.apt=true

Vamos executar o build novamente. ??????

Tudo bem, parece que estamos chegando lá.

Etapa 3: Propriedades do Gradle

Estamos no último estágio agora. Lembra da pegada que encontramos ao atualizar nossa versão do plugin do Gradle? Acontece que as versões mais recentes do Gradle reduzem o tamanho do heap para 512 MB. Isso é para garantir que as máquinas de extremidade inferior não engasguem. Estou em uma máquina de 16 GB, então posso dar de 2 a 3 gigs para o daemon do Gradle, mas sua milhagem pode variar.

Open the gradle.properties file located at the root of your project and add the following line. Remember to select the size according to your requirements and machine specification.

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

While we’re at it, let’s also enable parallel builds and configure on demand in the properties.

Here’s what my final gradle.properties file looks like:

org.gradle.jvmargs=-Xmx3072m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 org.gradle.parallel=true org.gradle.configureondemand=true kapt.incremental.apt=true
  • org.gradle.parallel - This flag allows Gradle to build modules within a project in parallel instead of sequentially. This is only beneficial in a multi-module project.
  • org.gradle.configureondemand - This flag configures only the modules needed by the project, instead of building all of them.

With these, let’s see where we are on our build speed metric:

And there we go. ???

Closing remarks

Isso não é, de forma alguma, uma cobertura extensiva de todas as maneiras de otimizar a velocidade de construção de seu projeto. Há muitas outras coisas que não falei neste post, como usar minSdk 21 ao usar MultiDex, pré-dexar suas bibliotecas, desativar PNG crunching, e assim por diante - para citar alguns.

Mas a maioria dessas configurações requer uma compreensão mais profunda do sistema de compilação do Android e experiência de trabalho em grandes projetos de vários módulos (que é onde os benefícios são mais aparentes) . As etapas que mencionei acima são fáceis de incorporar em um projeto, mesmo por desenvolvedores juniores e têm recompensas consideráveis. Espero que isso ajude você a reduzir suas velocidades de construção!

Tudo bem até a próxima, paz! ✌?