Reduza o tempo de compilação de seus projetos Android

Bom dia Começamos segunda-feira com material, cuja tradução foi preparada especificamente para os alunos do curso "Android-developer. Curso avançado . ”



Migrei recentemente a base de código do Android para o Kure no AndroidX. Pareceu-me que esta é uma grande oportunidade para trabalhar na velocidade de montagem do projeto. Gradle sempre teve uma má reputação devido à lentidão e ao consumo de recursos, mas fiquei muito surpreso que pequenas alterações na configuração da montagem aumentassem sua velocidade de maneira significativa.

Observe as métricas de varredura de montagem antes / depois da otimização


antes da otimização


depois da otimização ️️

Diminuiu de 5,5 minutos para 17 segundos? Enlouquecer!

Não é tão difícil exagerar na otimização para reduzir ainda mais o tempo de montagem. Mas, a fim de tornar o post compreensível para iniciantes, vou me concentrar deliberadamente nas medidas menores e indolentes que tomei para me aproximar desse indicador.

Primeiro de tudo!

Antes de iniciar a otimização, é importante testar nosso projeto para descobrir quanto tempo leva para construí-lo. Gradle tem uma opção de digitalização conveniente que você pode usar para analisar o desempenho da sua tarefa. Inicie o terminal no Android Studio e execute o seguinte comando:

./gradlew assembleDebug --scan 

Após a conclusão bem-sucedida da montagem, você será solicitado a aceitar os termos de serviço para baixar os resultados da verificação. Digite yes para continuar. Após a publicação, você receberá um link para o terminal para verificar a digitalização. Abra.

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

Resumo exibe informações de resumo sobre tarefas concluídas e seu tempo de conclusão. Mas o que nos interessa aqui é a seção Desempenho . Ele faz uma análise mais detalhada do tempo total de compilação, como mostrado abaixo.



Na seção Desempenho, há uma guia Configurações e sugestões que fornece recomendações para melhorar a velocidade de criação. Vamos olhar para eles.



Nesta seção, podemos encontrar algumas correções simples para melhorar a velocidade. Então, vamos continuar e aplicar essas correções em nosso projeto.

Etapa 1: atualizar ferramentas

A equipe do Android está constantemente aprimorando e desenvolvendo o sistema de compilação. Portanto, na maioria dos casos, você pode obter uma melhoria significativa simplesmente instalando a versão mais recente do kit de ferramentas.

Durante essa refatoração, nosso projeto estava na versão 3.2.1 do plug-in Gradle para Android Studio ( várias versões anteriores à última versão ).

Você pode seguir este link para obter a versão mais recente do Gradle Plugin. No momento da redação deste artigo, a versão mais recente era 3.4.0.

Mas há um problema aqui que devemos lembrar:



( Nota: Ao usar o Gradle versão 5.0 ou superior, o tamanho padrão do daemon Gradle é reduzido de 1 GB para 512 MB. Isso pode levar a um desempenho de construção ruim. Para substituir essa configuração padrão, especifique o tamanho da memória para o daemon Gradle em gradle.properties seu projeto.)

https://developer.android.com/studio/releases/gradle-plugin

Ao usar o Gradle 5.0 e superior, precisaremos aumentar explicitamente o tamanho da memória para que a velocidade de construção não se deteriore. Voltaremos a isso em um minuto.

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

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

Você também precisa atualizar o URL de distribuição no arquivo de propriedades Gradle Wrapper localizado em gradle/wrapper/gradle-wrapper.properties . Atualize o URL para o seguinte.

( Este link estará disponível na página do plug-in Android Gradle . )

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

Você encontrará um erro ao usar o Kotlin se a versão do plug-in do Kotlin Gradle for menor que 1.3.0. Nesse caso, use a dica de ferramenta do IDE para atualizar o plug-in Gradle do Kotlin para a versão mais recente (no momento da redação deste documento, esta é a versão 1.3.31 ).

Ok, vamos executar a compilação novamente no terminal para ver se fizemos alguma melhoria.

Etapa 2: atualizar configurações

Portanto, conseguimos reduzir cerca de 2,5 minutos do tempo de compilação, mas isso ainda não é bom o suficiente. Tendo estudado os logs de construção no terminal, deparei-me com uma linha que nos interessará:



(> Tarefa: app: compileDevelopDebugJavawithJavac

Gradle pode desativar a compilação incremental porque os seguintes processadores de anotação não são incrementais: butterknife-compiler-10.1.0.jar (com.jakewharton: butterknife-compiler: 10.1.0), dagger-compiler-2.9.jar (com.google. punhal: punhal-compilador: 2.9).

Considere definir o sinalizador experimental android.enableSeparateAnnotationProcessing-true no arquivo gradle.properties para iniciar o processamento da anotação em uma tarefa separada e executar a compilação incremental.)

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 modificados. A partir dos logs, fica claro que não usamos essa função. Ele sugere que usemos android.enableSeparateAnnotationProcessing=true , mas, em qualquer caso, não devemos usar a configuração "annotationProcessor", pois o Kotlin é usado em nosso projeto.

Felizmente, a versão 1.3.30 do Kotlin adiciona suporte ao processamento passo a passo de anotações.



https://kotlinlang.org/docs/reference/kapt.html

(Processamento incremental de anotações (de 1.3.30)

A partir da versão 1.3.30, o kapt suporta o processamento de anotação incremental como uma função experimental. Atualmente, o processamento de anotação pode ser executado de forma incremental apenas se todos os processadores de anotação usados ​​forem incrementais.
Para ativar o processamento de anotação incremental, inclua esta linha no arquivo gradle.properties :

kapt.incremental.apt=true

Observe que o processamento de anotação incremental requer que a compilação incremental também seja ativada.)

Então, vamos começar:

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

Abra o arquivo build.gradle do seu módulo e inclua a seguinte linha na parte superior do arquivo:

apply plugin: 'kotlin-kapt'

Em seguida, altere todas as configurações do annotationProcessor na seção dependências para usar o kapt. Por exemplo:

//
annotationProcessor 'com.google.dagger:dagger-compiler:2.9'
//
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 a compilação novamente.



Bem, parece que fizemos alguns progressos.

Etapa 3: Propriedades da gradação

Estamos na última etapa. Lembra do truque que encontramos ao atualizar a versão do plugin Gradle? Acontece que as versões mais recentes do Gradle reduzem o tamanho da memória usada para 512 MB. Isso é para garantir que máquinas fracas não consumam muita memória. Eu tenho um computador com 16 gigabytes de RAM, para poder alimentar de 2 a 3 GB ao daemon Gradle, mas seus números podem variar.

Abra o arquivo gradle.properties localizado na raiz do seu projeto e adicione a seguinte linha. Certifique-se de escolher o tamanho adequado às suas necessidades e especificações do computador.

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

Enquanto fazemos isso, vamos também ativar montagens paralelas e ajuste sob demanda nas propriedades.

É assim que minha versão final do arquivo gradle.properties :

 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 - esse sinalizador permite que o Gradle monte módulos dentro de um projeto em paralelo, em vez de sequencialmente. Isso é útil apenas para projetos com vários módulos.
• org.gradle.configureondemand - esse sinalizador configura apenas os módulos necessários para o projeto e não coleta todos eles.

Feito isso, vamos ver o que temos agora os indicadores de velocidade de montagem:




Lá vai você!

Observações finais

Isso não é de forma alguma uma cobertura abrangente de todas as formas de otimizar a velocidade de montagem. Há muitas outras coisas que não abordamos neste post, como usar o minSdk 21 ao usar o MultiDex, pré-indexar bibliotecas, desativar a compactação PNG, etc., são apenas algumas delas.

Mas a maioria dessas configurações requer um entendimento mais profundo do sistema de compilação Android e experiência no trabalho com grandes projetos de múltiplos módulos (onde os benefícios são mais óbvios). As etapas que eu mencionei acima são facilmente implementadas até pelos desenvolvedores juniores e têm benefícios significativos. Espero que isso ajude você a aumentar a velocidade de construção!

Até a próxima, a paz esteja com você!