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)

Read next

ajmal_hasan profile image

SSL Pinning in React Native for iOS and Android

Ajmal Hasan -

hamada147 profile image

Kotlin Smart Casts vs. Java Casts: A Type-Safe Tale (with Fewer Runtime Surprises!)

Ahmed Moussa -

devslm profile image

Create a native Kotlin or JAVA application with Spring Boot Native, Gradle, and GraalVM without Docker for MacOS and Windows

Sergey Mareychev -

kiolk profile image

Day 22. Lottie animation

Kiolk -