Android Plataforma - Parte 0: Introdução à Série

No mundo do desenvolvimento Android, enfrentamos um fluxo contínuo de novidades: novos dispositivos, atualizações do SDK e uma variedade de bibliotecas e ferramentas que são lançadas todos os dias.

Junte a isso as constantes alterações, depreciações e a pressão do negócio para entregar funcionalidades que atendam às necessidades dos clientes. Este cenário volátil torna-se um desafio para manter nosso código organizado, eficiente e escalável.

Nesta série de artigos, guiarei vocês através do processo de criação de uma Plataforma Android.

O que é uma plataforma?

Ao escalar um projeto Android, encontramos desafios como modularização e gestão de dependências. A necessidade de performance, otimização, consistência UI/UX e garantir a retrocompatibilidade também se tornam cada vez mais urgentes.

Uma "plataforma" é um conjunto coeso e bem definido de práticas, ferramentas e bibliotecas que agilizam o desenvolvimento.

Ela se destaca como uma solução robusta e escalável para enfrentar os desafios inerentes ao desenvolvimento Android, auxiliando em aspectos como modularização, otimização, integração contínua, testes e segurança.

Construindo uma Plataforma no Android

No decorrer desses artigos, iremos construir uma plataforma desde o início, acoplando-a a um projeto já existente.

🔗 github.com/rsicarelli/kotlin-gradle-android-platform

1. Modularização
   • Exploraremos as razões e ideias por trás da modularização no Android.
2. Início do Projeto
   • Apresentaremos o projeto base que será evoluído e integrado com nossa plataforma.
3. Compartilhando scripts do Gradle
   • Abordaremos o buildSrc e discutiremos como compartilhar scripts em projetos Gradle.
4. Composite Build
   • Introduziremos essa valiosa feature do Gradle e criaremos um composite build para representar nossa plataforma.
5. Simplificando Gradle Init
   • Abordaremos, com mais contexto, as funcionalidades realmente necessárias para nossa plataforma.
6. Version Catalog
   • Introduziremos e implementaremos o catálogo de versões do Gradle.
7. Decorando o módulo 'app'
   • Introduziremos o conceito de "decorações" e delegaremos os scripts Gradle do app para nossa plataforma.
8. Decorando os módulos 'library'
   • Prosseguiremos para nossas libraries e também delegaremos a lógica para nossa plataforma.
9. Unificando a Application e Library extensions com a Common Extension
   • Discutiremos sobre ApplicationExtension, LibraryExtension e CommonsExtension do Android Gradle Plugin (AGP).
10. Customização dos módulos
    • Parametrizaremos nossa plataforma, possibilitando customizações nos módulos que a utilizam.
11. Criando uma DSL para customizar as novas opções
    • Implementaremos uma forma idiomática em Kotlin para realizar nossas customizações com a plataforma.
12. Otimizando tempo de compilação para bibliotecas Android
    • Discutiremos sobre as BuildFeatures do Android Gradle Plugin e otimizaremos a compilação de bibliotecas Android.
13. Incluindo módulos "puro JVM"
    • Exploraremos os motivos para ter módulos mais "enxutos" e evitar etapas extras do Android Gradle Plugin.
14. Aderindo a funcionalidades experimentais do compilador do Kotlin
    • Discutiremos sobre a anotação @RequiresOptIn e como adaptar nossa plataforma para aderir a funcionalidades experimentais.
15. Cuidando do código com Detekt, Klint e Spotless
    • Focaremos na qualidade de código, utilizando nossa plataforma para adaptar nosso projeto com ferramentas de análise e formatação de código.
16. Considerações finais
    • Refletiremos sobre a real necessidade de uma plataforma, boas práticas e os próximos passos para futuras séries!

Spoiler do que iremos aprender

Iremos constrúir algumas decorações para serem aplicadas em nossos build.gradle.kts:

• Declarando um módulo app através da função androidApp()
• Declarando módulos library através da função androidLibrary()
• Declarando módulos puramente JVM através da função jvmLibrary()
• Integração com detekt e spotless como ferramentas de qulidade de código.

import com.rsicarelli.kplatform.detekt
import com.rsicarelli.kplatform.spotless

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.arturbosch.detekt) apply false
    alias(libs.plugins.diffplug.spotless) apply false
    id(libs.plugins.rsicarelli.kplatform.get().pluginId)
}

detekt()
spotless()

import com.rsicarelli.kplatform.androidApp

plugins {
    id(libs.plugins.android.application.get().pluginId)
    kotlin("android")
}

androidApp {
    versionCode = 1
    versionName = "1.0.0"
}

dependencies {
    implementation(libs.androidx.activity.compose)
    implementation(projects.core.designsystem)
    implementation(projects.features.home)
}

import com.rsicarelli.kplatform.androidLibrary

plugins {
    id(libs.plugins.android.library.get().pluginId)
    kotlin("android")
}

androidLibrary()

dependencies {
    implementation(platform(libs.androidx.compose.bom))
    implementation(libs.androidx.compose.ui)
}

import com.rsicarelli.kplatform.jvmLibrary

plugins {
    kotlin("jvm")
}

jvmLibrary()

dependencies {
    implementation(libs.kotlinx.coroutines.core)
}

Bons estudos!

Espero que desfrute desse conteúdo e possa aprender bastante!

Se tiver qualquer dúvida ou problema, não hesite em me contatar, ou deixar um comentário.

Comece por aqui: Parte 1: Modularização