Como otimizar o tempo de compilação do seu app Android

Se você sempre se perguntou se “meu projeto vai compilar mais rápido com 8 GB de RAM em vez de 4”, este artigo é para você. Vamos explorar como o Gradle profiler Android pode ajudar a otimizar o tempo de compilação dos seus projetos.

Hoje, vamos falar sobre a ferramenta autônoma gradle-profiler. Existe uma pequena introdução sobre como usá-la aqui, mas muito do que está lá ainda passou pela minha cabeça. Sou apenas um desenvolvedor Android medíocre, que ainda sente que preciso de um PhD para entender o Gradle.

Tenho dois cenários típicos que quero testar e que encontro todos os dias:

1. Compilações após uma limpeza (clean builds)
2. Compilações incrementais

Compilações após uma limpeza parecem levar cerca de 3 minutos no meu projeto, em média. Isso não é medido precisamente, mas é o que vejo no canto inferior direito do Android Studio: “Sua compilação terminou em 3 minutos e 02 segundos”. Fazer uma limpeza é bem comum para mim porque, às vezes, as coisas simplesmente não funcionam no IDE (acho que muito disso é/pode ser devido ao kapt), mas, independentemente disso, tenho que limpar/invalidar caches/reiniciar/esperar que minha compilação seja corrigida e, em seguida, executar novamente. Este é o cenário que quero testar primeiro.

Instalação do Gradle profiler Android

Para começar a usar o gradle-profiler, siga estes passos simples no seu terminal:

git clone https://github.com/gradle/gradle-profiler
    && cd gradle-profiler
    && ./gradlew installDist

Esses comandos clonam o repositório do gradle-profiler do GitHub, entram no diretório e instalam a distribuição.

Depois de instalar, entre no diretório do gradle-profiler com o seguinte comando:

cd build/install/gradle-profiler/bin

Criando um arquivo scenarios.txt

O arquivo scenarios.txt lista todos os cenários que o gradle-profiler irá executar. Descobri que o que está na documentação do Android Studio não foi muito útil para testar meu primeiro cenário. Recebi muita ajuda de Paul Merlin, que trabalha na equipe do Gradle.

Este é o meu arquivo scenarios.txt:

clean_build_1gb {
    tasks = [":app:assembleFreeDebug", "--rerun-tasks"]
    jvm-args = ["-Xmx1024m", "-Dkotlin.daemon.jvm.options=-Xmx1024m"]
}

clean_build_2gb {
    tasks = [":app:assembleFreeDebug", "--rerun-tasks"]
    jvm-args = ["-Xmx2048m", "-Dkotlin.daemon.jvm.options=-Xmx2048m"]
}

clean_build_4gb {
    tasks = [":app:assembleFreeDebug", "--rerun-tasks"]
    jvm-args = ["-Xmx4096m", "-Dkotlin.daemon.jvm.options=-Xmx4096m"]
}

clean_build_8gb {
    tasks = [":app:assembleFreeDebug", "--rerun-tasks"]
    jvm-args = ["-Xmx8192m", "-Dkotlin.daemon.jvm.options=-Xmx8192m"]
}

clean_build_16gb {
    tasks = [":app:assembleFreeDebug", "--rerun-tasks"]
    jvm-args = ["-Xmx16384m", "-Dkotlin.daemon.jvm.options=-Xmx16384m"]
}

clean_build_32gb {
    tasks = [":app:assembleFreeDebug", "--rerun-tasks"]
    jvm-args = ["-Xmx32768m", "-Dkotlin.daemon.jvm.options=-Xmx32768m"]
}

Como você pode ver, eu testo de 1 a 32 GB (minha máquina tem muita RAM) e defino os argumentos JVM e kotlin jvm para a mesma quantidade. Suponho que seria bom se eu pudesse ajustar ambos para variáveis e apenas executar isso durante a noite e, de alguma forma, fazer com que ele fosse executado em várias combinações para ver o que funciona melhor, mas ainda não descobri como fazer isso.

Note que também adicionei o argumento “–rerun-tasks” porque, de acordo com Paul Merlin, isso significa “Se você quiser comparar um cenário de ‘reconstruir tudo’, você pode usar –rerun-tasks.”

Executando o Profiler

Para executar o profiler, use o seguinte comando:

./gradle-profiler --benchmark --project-dir ~/dev/rollertoaster --scenario-file ~/dev/rollertoaster/scenarios.txt

Este comando executa o profiler, apontando para o arquivo do seu projeto e para o arquivo de cenários no seu projeto. Salvo os cenários lá para que outras pessoas na minha equipe possam facilmente comparar e atualizar seu arquivo gradle.properties local. O que realmente me fez tentar o profiler foi o fato de que meu CI tem RAM muito diferente do meu desktop, do meu laptop, e todos nós aderirmos a um único gradle.properties parecia estúpido.

Análise dos Resultados do Gradle profiler Android

Executar o profiler pode levar algum tempo, pois ele executa algumas iterações, mas, eventualmente, fornecerá um diretório para abrir. Neste diretório, você terá um documento HTML e poderá praticamente olhar para a coluna “Média” e escolher a mais rápida para você. Aqui, estou mostrando a saída .CSV e você pode ver que minhas compilações de 1GB e 2GB falharam completamente, mas, para minha surpresa, não houve muita diferença em adicionar RAM após 4GB. Se você está buscando otimizar o desempenho de outros aplicativos, pode ser interessante aprender como usar o App Freeze no Android 15 para liberar espaço.

Próximo passo: Mudanças incrementais!

EM PROGRESSO

Obrigado ao artigo de Adam Bennet que me apresentou o gradle-profiler e como foi simples começar. Para complementar, você pode conferir outras novidades do Android, como o novo Easter Egg do Android 16 que destaca o recurso de Atualizações ao Vivo.

Este conteúdo foi auxiliado por Inteligência Artificial, mas escrito e revisado por um humano.

Via dev.to