DEV Community

Rodrigo Sicarelli
Rodrigo Sicarelli

Posted on • Edited on

Android Plataforma - Parte 4: Composite Build

#kotlin #android #gradle

🌱 Branch: 3-4/composite-build

🔗 Repositório: github.com/rsicarelli/kotlin-gradle-android-platform

⬅️ Artigo Anterior: Parte 3: Compartilhando scripts do Gradle

➡️ Próximo Artigo: Parte 5: Simplificando Gradle Init

Nos artigos anteriores, compreendemos a importância da modularidade e como os Composite Builds são a escolha certa para escalar projetos Kotlin.

Incrementaremos o projeto inicial com a criação e inclusão de um composite build.

Primeiro passo é criar uma pasta para declarar os plugins e funcionalidades.

A nomenclatura mais adotada para essa pasta é build-logic, e é comum encontrar vários projetos do Google, Jetbrains e Gradle que seguem essa convenção.

Alguns projetos optam por conventions ou plugins.

Prefiro seguir padrões reconhecidos pela comunidade, então usaremos o nome mais popular: build-logic.

Passo a passo

1 - Crie uma pasta na raiz do projeto:

mkdir build-logic
Enter fullscreen mode Exit fullscreen mode

2 - Entre nesta pasta e execute o comando gradle init. Este script do Gradle inicializa um projeto Gradle na raiz, acompanhado do Gradlew Wrapper (gradlew) e outros arquivos úteis.

Certifique-se de ter o Gradle instalado. Se estiver usando o homebrew:

brew install gradle
Enter fullscreen mode Exit fullscreen mode 
cd build-logic gradle init
Enter fullscreen mode Exit fullscreen mode

3 - Após alguns instantes, a mensagem a seguir surgirá no console:

Digite 4 para escolher o tipo gradle plugin e confirme com enter.

Select type of project to generate: 1: basic 2: application 3: library 4: Gradle plugin Enter selection (default: basic) [1..4] 4
Enter fullscreen mode Exit fullscreen mode

4 - Outra solicitação aparecerá para escolher a linguagem. Digite "3" para Kotlin:

Select implementation language: 1: Groovy 2: Java 3: Kotlin Enter selection (default: Java) [1..3] 3
Enter fullscreen mode Exit fullscreen mode

5 - Em seguida, será pedido para escolher a DSL (domain specific language) dos scripts. Selecione "2" para Kotlin:

Select build script DSL: 1: Groovy 2: Kotlin Enter selection (default: Kotlin) [1..2] 2
Enter fullscreen mode Exit fullscreen mode

6 - Depois, o nome do projeto será solicitado. Como já estamos na pasta build-logic, simplesmente confirme com enter:

Project name (default: build-logic): // Apenas pressione enter
Enter fullscreen mode Exit fullscreen mode

7 - A próxima etapa solicita o source package. Mantenha o padrão:

Source package (default: build.logic): // Apenas pressione enter
Enter fullscreen mode Exit fullscreen mode

8 - Por fim, a opção para gerar utilizando novas API's. Escolha "yes" e confirme:

Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] yes
Enter fullscreen mode Exit fullscreen mode

Arquivos gerados

Concluindo o passo a passo, observe os arquivos gerados:

A .gitattributes A .gitignore A gradle.properties A gradle/wrapper/gradle-wrapper.jar A gradle/wrapper/gradle-wrapper.properties A gradlew A gradlew.bat A plugin/build.gradle.kts A settings.gradle.kts
Enter fullscreen mode Exit fullscreen mode

Vamos nos concentrar nos mais relevantes:

settings.gradle.kts

A presença deste arquivo permite que este módulo seja tratado como um Composite Build.

Note que é um arquivo simples. Por enquanto, não precisamos adicionar nada.

build.gradle.kts

Esse arquivo gerado contém algumas várias configurações, mas vamos focar nas mais importantes:

plugins { `java-gradle-plugin` .. } .. gradlePlugin { // Define the plugin val greeting by plugins.creating { id = "build.logic.greeting" implementationClass = "build.logic.BuildLogicPlugin" } } ..
Enter fullscreen mode Exit fullscreen mode

java-gradle-plugin

Esse plugin traz uma extensão chamada gradlePlugin. É com ela que iremos realizar as declarações dos nossos plugins.

Por debaixo dos panos, esse plugin aplica algumas decorações na hora de compilar o jar desse módulo, além de adicionar metadata do seu artefato, e a criação de um arquivo de propriedade do Gradle que serve como referencia nossa classe de implementação.

Basicamente, estamos registrando um plugin com o id build.logic.greeting no projeto, e, ao aplica-lo, a classe de implementaçào BuildLogicPlugin estará disponível, pré-compilada para uso.

BuildLogicPlugin.kt

Esse arquivo é a declaração do nosso plugin, utilizando a api Plugin<Project>.

Graças ao Kotlin DSL, é bem fácil de entender o que estamos fazendo:

Registrando uma task chamada greetings no projeto que está aplicando esse Plugin

@Supress("unused") // invocado por reflexão class BuildLogicPlugin: Plugin<Project> { override fun apply(project: Project) { // Register a task project.tasks.register("greeting") { task -> task.doLast { println("Hello from plugin 'build.logic.greeting'") } } } }
Enter fullscreen mode Exit fullscreen mode

Incluindo nosso build-logic no projeto raiz

Chegou a hora de conectarmos os dois mundos.

Para incluir composite builds em nosso projeto, precisamos utilizar uma função especial chamada includeBuild(). O único requisito para utilizar essa função, é que o módulo tenha um arquivo settings.gradle.kts em sua raiz.

Como nosso build-logic está pronto pra uso, vamos apenas navegar até o nosso settings.gradle.kts e incluir esse módulo:

// settings.gradle.kts da raiz pluginManagement { includeBuild("build-logic") repositories { google() mavenCentral() gradlePluginPortal() } }
Enter fullscreen mode Exit fullscreen mode

Basicamente, estamos instruindo o Gradle a utilizar nosso build-logic como Composite Build, e incluindo nosso plugin pre-compilado BuildLogicPlugin no classpath do projeto.

Aplicando o plugin no build.gradle.kts

Finalmente, iremos aplicar nosso plugin ao projeto principal.

Tenha certeza de que você sincronizou seus arquivos Gradle ("Reload all gradle projects") e navegue até o arquivo build.gradle.kts da raiz do projeto:

//build.gradle.kts da raiz plugins { // Plugin do android // Plugin do Kotlin id("build.logic.greeting") }
Enter fullscreen mode Exit fullscreen mode

Utilizando nossa task "greeting"

Após sincronizar os arquivos Gradle do projeto, vá até o console e execute o seguinte comando:

Garanta que você esteja na pasta raiz do projeto, e não dentro build-logic:

pwd .../kplatform/build-logic cd .. pwd .../kplatform
Enter fullscreen mode Exit fullscreen mode 
./gradlew greeting > Task :greeting Hello from plugin 'build.logic.greeting' BUILD SUCCESSFUL in 518ms
Enter fullscreen mode Exit fullscreen mode

Sucesso!

Já temos nosso esqueleto para compor nossa plataforma, e incrementar nosso build-logic com outras funcionalidades.

No próximo artigo, vamos dar uma "limpada" nesses arquivos auto gerados pelo gradle init, e dar continuidade aos trabalhos.

Top comments (0)