Usando arquivos Kotlin para gerenciar suas dependência

O bom de desenvolver com o Kotlin é que sempre me encontro uma nova forma de melhorar o desenvolvimento para Android.

Não dá para esquecer a primeira Coroutine ou a injeção de dependência com o Koin. Esses são pequenos exemplos de como o Kotlin é produtivo e simples de se utilizar. E depois de muito estudar eu vejo que estou apenas riscando a superfície de tudo que pode ser feito. Minha ultima “descoberta” foi uma forma de gerenciar as dependências da aplicação por meio de um arquivo Kotlin a fim de gerenciar todas em um único lugar, principalmente para projetos multi módulos.

Uau! Mas como fazemos isso?

É bem simples, basta usarmos o poder do Gradle somado a simplicidade do Kotlin, muito poético?

Sim, bastante :/

Então vamos tentar ir por partes. Primeiro vamos explicar como o Gradle entra nisso tudo.

No Gradle

Para o desenvolvimento Android, o Gradle, entre outras coisas, serve para gerenciarmos as dependências e principais informações de nossa aplicação, e em caso de projetos com mais de um módulo (clean architeture) e ele fica representado nos arquivos build.gradle, sendo um no nível da app e outro no nível do projeto. Não vamos entrar em muitos detalhes como o Gradle funciona, deixaremos isso para depois.

Quando executamos o Gradle ele busca uma pasta chamada buildSrc, caso ela exista o Gradle compile os componentes dessa classe e inseri no classpath principal do seu projeto, como se a buildSrc fosse um outro módulo da sua aplicação.

Muito interressante, mas onde fica essa pasta em meu projeto?

Isso é uma boa pergunta. Essa pasta não existe no seu projeto e ela deve ser criada pelo desenvolvedor, lembrado que o Gradle busca uma pasta com o nome exato de buildSrc, com case sensitive, então atenção na hora de criar.

Atenção: Antes criar essa pasta no projeto, crie um novo ramo e execute a build do seu projeto, pois isso pode causar alguns problemas de reconhecimento de pasta no Android Studio, isso não ocorre em todos os casos. Em meus testes, em alguns momentos precisei executar uma build antes.

Para criar essa pasta precisamos mudar o modo de visualização do nosso projeto para Project, que vai exibir todos os arquivos e pastas da nossa aplicação. E dentro da pasta principal do projeto vai ser criado a pasta buildSrc.

Selecionando a visualização de projeto no Android Studio.

Tudo bem até aqui, mas não basta criar somente essa pasta, dentro dessa pasta precisaremos criar um scritpt do Kotlin, para que ele carregue o plugin de dsl do Gradle. Esse arquivo será chamado de build.gradle.kts e terá o seguinte conteúdo.

Ao criar esse arquivo será necessário que você sincronize o seu Gradle, utilize o botão “Sync project with Gradle file” do Android Studio.

Botão Sync project with Gradle file, o ícone pode mudar de acordo com a versão do Android Studio.
Nossa, mas ocorreram vários erros aqui!
Caso ocorra algum erro, tente atualizar a sua versão do Gradle e verifique se a versão do Kotlin corresponde a versão do Gradlre.

Após finalizar a sincronização, você vai precisar criar uma serie de pastas dentro de buildSrc, a mesma sequencia de pastas que existe na pasta app, que são: src > main > java.

Pastas dentro de buildSrc.

Pronto, já estamos quase lá, da parte do Gradle já finalizamos tudo, agora resta apenas configurar as suas dependências com o Kotlin.

Com o Kotlin nosso de cada dia

Dentro da pasta java que criamos, vamos inserir um arquivo Kotlin que vai armazenar todas as nossas dependências. Ele será composto por alguns objects do Kotlin, para que possamos acessa-los estaticamente. No exemplo foi criado um object para armazenar o número das versões, um para as dependências padrões e outra para os testes, mas você pode criar quantas quiser.

Tudo certo, finalizamos com o Kotlin. Simples, não?

Sério? Só isso? Puts !!!

Finalizando

Pronto, com tudo feito, basta vocês ir nos seus builds.gradle e substituir das versões por essas chaves. Mas essa não é a melhor noticias. Fazendo dessa forma você ganha a possibilidade de auto completar.

Dimitri, temos auto completar no build.gradle!!

Ao final os arquivos irão ficar assim:

Esse é o build.gradle no nível de projeto.
Esse é o build.gradle no nível de aplicação.

Pronto, agora todas as suas dependências, de todos os seus módulos, estão armazenadas em um único lugar, onde você pode inclusive criar algoritmos para gerar o nome e o número das versões da sua aplicação.

Foi show?
Foi show demais!

Fontes