Uma das coisas que mais tenho gostado de estudar atualmente é desenvolvimento nativo para Android com Jetpack Compose. Com alguns projetos em execução e os resultados tem sido incríveis (vou escrever mais sobre isto em breve), mas o processo de aprendizado não tem sido trivial.

O motivo é irônico: apesar de a documentação oficial do Google ter me parecido excelente, não é claro qual caminho você deve seguir ao navegar por ela. É muito extensa e fácil de você se perder. Tanto que terminei com uma página enorme de links no meu Obsidian (app lindo, experimente) que acabei transformando neste post.

Meu objetivo é lhe dar os insumos para que você possa começar a desenvolver suas próprias aplicações nativas no Android sem precisar gastar um centavo sequer com cursos (não que estes sejam ruins (muitos são), mas por que para o caminho que vou expor se tornam desnecessários).

Minha sugestão é que você guarde este post: primeiro o leia do início ao fim e, na sequência, execute os treinamentos que sugiro (todos gratuitos) e guarde os links que cito aqui para que você possa se aprofundar. Muita atenção aos alertas que darei daqui pra frente.

O primeiro passo é ter a última versão do Android Studio em seu computador. Você pode baixá-lo aqui, e ele é a ferramenta que você precisará para fazer tudo.

Este mundo nativo do Android

A primeira coisa é saber aonde você está: neste post falo sobre desenvolvimento de aplicações nativas para Android usando Jetpack, que é a abordagem atual recomendada pelo Google para o desenvolvimento de aplicações nativas hoje.

Isto quer dizer que há dois caminhos a serem seguidos:

• O desenvolvimento antes do Jetpack: baseado em Views (layout baseado em XML) e Java.
• Desenvolvimento baseado em Jetpack – que é o novo modo recomendado pelo Google para começar novos projetos.

Se você navegar pela documentação oficial do Android hoje este direcionamento para o novo modo de desenvolvimento é claro: está mais difícil encontrar o conteúdo sobre views e Java (vai lá: tenta!).

Então precisamos começar entendendo o que o Google está chamando de “novo caminho para o desenvolvimento Android”. A primeira mudança radical diz respeito à linguagem de programação.

Sai Java, entra Kotlin

Ainda é possível usar Java para o desenvolvimento de novas aplicações Android, mas você não conseguirá (ou pelo menos terá muita dificuldade) em usar o Jetpack Compose (que é o novo toolkit gráfico para construção de interfaces gráficas) em seus projetos. Então o primeiro passo aqui é ignorar o Java ( :( ) e partir pro Kotlin.

Na minha experiência como “javeiro” (desde 1996), as maiores dificuldades podem ser:

• O modo como Kotlin lida com nulidade pra evitar os famigerados NullpointerExceptions da vida. Leva tempo até pegar o jeito da coisa (ao menos pra mim levou (a linguagem deixa bem claro o trauma com estes problemas e realmente é uma solução interessante para a questão gerando código que pode ser bem mais seguro)).
• O uso que a linguagem faz de funções: você não precisa ter classes em um arquivo Kotlin, pode ter só funções. Isto me gerou muito estranhamento. Se você tem uma boa experiência com o conceito de lambdas no Java (a partir do 8) então a coisa vai ser bem mais tranquila.
• A sintaxe: não se iluda achando que “é muito parecida com Java”. É ilusão.

Minha dificuldade só não foi maior devido à minha longa experiência com Groovy. Então aqui seguem os primeiros materiais que sugiro para vocês.

Alguns alertas

Na minha experiência há duas formas de se aprender uma nova linguagem de programação: apanhando e pondo seus clientes em risco ou maximizando seu tempo e minimizando o risco para seus clientes. Opto por falar sobre a segunda alternativa aqui.

• Nos cursos que cito abaixo, execute-os do início ao fim, sem pular. As aulas muitas vezes são encadeadas: se você ignorar uma delas terá dificuldades em entender o conteúdo posterior.
• No caso dos cursos há exercícios: faça-os. Se não houver, tente reproduzir o código dos instrutores no seu ambiente de desenvolvimento local. Aprendi horrores assim.
• Se você vêm do Java, não caia na ilusão de que já sabe como os elementos básicos do Kotlin irão funcionar. Há diferenças e elas podem te tomar boa parte do seu tempo.
• Cuidado com as traduções do Google: vou incluir vários links que direcionam para a documentação oficial do Android e esta normalmente é traduzida, mas em alguns pontos encontrei erros.
• Você não conseguirá fazer muita coisa (se é que conseguirá fazer algo) sem ter noções mínimas de Kotlin.

Voltando ao conteúdo sobre Kotlin

Bootcamp Kotlin para Programadores na Udacity (grautito) – https://www.udacity.com/course/kotlin-bootcamp-for-programmers–ud9011

É um treinamento bem interessante: totalmente em inglês. Confesso que minha maior dificuldade foram os instrutores que, apesar de bons, são “divertidos demais” pro meu gosto. Mesmo com este “problema”, foi meu primeiro contato com Kotlin e ajudou muito.

Se o inglês for um problema, não desanime, há um outro treinamento muito legal também que encontra-se no site do Google e que possui tradução para o português:

Treinamento Kotlin para programadores – https://developer.android.com/courses/kotlin-bootcamp/overview

É essencialmente o primeiro treinamento, mas com uma vantagem (pra mim): sem os vídeos dos instrutores que mencionei acima.

Finalmente, há a documentação oficial da linguagem, que também é bem legal como fonte de referência (não é um curso) e pode ser acessada neste link: https://kotlinlang.org/docs/home.html

Assuntos que você deve prestar muita atenção:

• Coroutines – é a solução para programação assíncrona não bloqueante no Kotlin que será vital no desenvolvimento de aplicações Android. Link na documentação oficial: https://kotlinlang.org/docs/coroutines-overview.html
• Null safety – especialmente você javeiro! Como Kotlin lida com nulidades de forma segura. Link para a documentação oficial: https://kotlinlang.org/docs/null-safety.html
• Lambdas – https://kotlinlang.org/docs/lambdas.html
• Data classes – a solução para “DTOs” em Kotlin – vai ser muito útil na criação de DTOs, especialmente quando precisar escrever clientes REST. Link para a documentalção oficial: https://kotlinlang.org/docs/data-classes.html
• Sealed classes – especialmente para você javeiro! Em Kotlin é possível escrever classes que impossibilitem a criação de subclasses. Muito útil. – https://kotlinlang.org/docs/sealed-classes.html
• Generics em Kotlin – https://kotlinlang.org/docs/generics.html

Muito além do Android

Houve um momento que me empolguei com Kotlin: foi quando descobri que existe uma versão nativa da linguagem que permite gerar executáveis que não dependem de uma máquina virtual. Trata-se do projeto “Kotlin Multiplatform” que permite escrever aplicações para Android (claro), iOS, Windows, Linux, macOS e web. Mais detalhes neste link: https://kotlinlang.org/lp/multiplatform/

Pode inclusive ser uma alternativa bem interessante ao Rust em alguns cenários (vou escrever sobre isto no futuro, pode aguardar). Bora voltar pro Android?

MAD – Modern Android Development

Você encontrará este termo MAD (“MAD Skills” – link oficial) em diversos materiais no site oficial do Android: é este o tal “novo modo” de se desenvolver aplicações. É composto por essencialmente três componentes:

• Kotlin ao invés de Java (já falei a respeito).
• O conjunto de bibliotecas Jetpack.
• Compose para interfaces.

Arquitetura

Antes de pular para o Jetpack e o Compose (que tá dentro do Jetpack :) ) é muito importante que você entenda os conceitos essenciais por trás da arquitetura de uma aplicação Android e, talvez mais importante, conhecer as recomendações dadas pelo Google a respeito.

Eu sei: há aquela ansiedade em pular no código e escrever as aplicações o mais rápido possível, mas recomendo que você dê uma lida neste material aqui antes. Não precisa se aprofundar: uma leitura rápida inicial já vai servir para que ao menos você entenda os conceitos principais.

Aviso: vale muito à pena investir algum tempo neste ponto. A maior parte das coisas que mencionarei adiante ficarão muito mais claras passando pelo treinamento que menciono a seguir. (nem que seja uma passada rápida pelos textos)

Curso Modern Android App Architecture – https://developer.android.com/courses/pathways/android-architecture

Acho muito interessante que você passe por este curso. Nele você vai entender quais as recomendações do Google para que organizemos nosso código de tal forma que obtenhamos projetos que sejam fáceis de serem mantidos no longo prazo (e no curto e médio também) e, talvez mais importante: adquirir vocabulário.

Pontos que você deve prestar muita atenção:

• Entenda as camadas: UI (interface gráfica), Data (dados), Domínio.
• Eventos: vai te poupar muito tempo em seus primeiros protótipos (quando você topar com situações do tipo “por que meus dados só aparecem quando rotaciono o device?” lembre disto)
• Estado: como a interface mantém o estado (esta é uma das coisas mais difíceis na minha opinião)

O treinamento acima é demais pra você? Tem um caminho um pouco mais curto mas que pode te ajudar também. É este link da documentação: Guide to app architecture – https://developer.android.com/topic/architecture

Jetpack

É o conjunto de bibliotecas desenvolvidas pelo Google com o objetivo de facilitar a vida do desenvolvedor provendo diversas funcionalidades que podem ser aplicadas tanto em novos projetos quanto pré existentes do Android. Cito os que, para o meu caso, tem sido mais importantes:

• Room – ORM para persistência de dados no SQLite.
• Camera – para lidar com a câmera do celular.
• Navigation – biblioteca usada para que você possa implementar a navegação de uma forma muito fácil entre as telas da sua aplicação.
• Hilt – uma implementação do padrão de injeção de dependências pra Android (pense no Spring pessoal do Java, mas simplificado)

O perigo aqui é que são diversas bibliotecas, e você não terá tempo hábil para ver todas elas. Então o que recomendo é que você comece pelos links abaixo:

Getting started with Android Jetpack – https://developer.android.com/jetpack/getting-started – vai te mostrar como incluir as bibliotecas no seu projeto e também dá uma visão geral sobre o Jetpack. Aproveite e navegue pelos links expostos na barra lateral. Não precisa se aprofundar, apenas leia o que está aqui (é um conteúdo bem pequeno).

Navegue pelas bibliotecas – https://developer.android.com/jetpack/androidx/explorer?case=data – Para não ficar preso apenas às bibliotecas que mencionei aqui, é legal ver a variedade incrível de bibliotecas liberadas pelo Google. Tem biblioteca pra quase tudo aqui.

Dica sobre a documentação das bibliotecas: atenção aos links “User Guide” e “Codelab” que aparecem no título de cada biblioteca, tal como no print a seguir:

Clique nestes links! São cursos muito bons, práticos e que mostram como aplicar a biblioteca de uma forma bem fácil de entender.

Sobre Java: até onde vi a maior parte das bibliotecas vai funcionar no Java (até por que o Kotlin é compatível), mas nem sempre. O Compose por exemplo não é tão simples assim de ser adotado nesta linguagem. De novo: aprenda Kotlin pra prosseguir, é importante.

Links para aprofundamento

Use estes links para se aprofundar em algumas bibliotecas muito importantes do Jetpack.

Codelab do Room – https://developer.android.com/codelabs/basic-android-kotlin-compose-persisting-data-room – para você aprender como este ORM opera.

Using Hilt in your Android app – https://developer.android.com/codelabs/android-hilt – conforme sua aplicação cresce você uma hora ou outra precisará lidar com a complexidade. E o Hilt como container de injeção de dependências pode ajudar HORRORES.

Working with Preferences DataStore – https://developer.android.com/codelabs/android-preferences-datastore#0 – para diversas aplicações o SQLite é mais complexo que o necessário. Se você precisa armazenar apenas informações simples e não tão bem estruturadas, pense no DataStore.

Testando – https://developer.android.com/training/testing/fundamentals – é vital que você aprenda a testar seus projetos. Dica: use os testes para aprender as bibliotecas do Jetpack! Vai te poupar muito tempo e é uma ferramenta pedagógica bem interessante.

Jetpack Compose

Deixei meu favorito para o final: a primeira vez que comecei a brincar com o Jetpack Compose foi meu momento “eureka” pro desenvolvimento nativo com Android. Muda bastante o modo como é feita a construção das nossas interfaces gráficas.

Ah: o Jetpack Compose é o toolkit gráfico usado para criar interfaces para Android nativo.

Até então nós tínhamos o desenvolvimento do frontend baseado nas Views do Android, que sempre me lembraram muito o XAML da Microsoft, o JSF do Java ou mesmo o HTML. Você essencialmente cria suas páginas usando XML ou um editor visual e faz todo o desenvolvimento baseando-se no modelo baseado em eventos (“ao clicar”, “ao pressionar”, etc).

É um modelo bacana pra se trabalhar: e o fato de existir um editor visual ajuda bastante. Tenho uma notícia ruim aqui: não temos este editor visual com o Compose, mas sim um outro modelo de desenvolvimento, declarativo, baseado em estado “imutável” e muito, muito parecido com o que temos no desenvolvimento com React (especialmente o Native), Flutter ou Swift UI.

Se você já tem experiência em qualquer uma destas ferramentas acima o Compose vai te parecer bastante familiar. Aliás, recomendo que você leia este texto (Thinking in React) pois as ideias ali descritas são muito parecidas com as que serão expostas no Jetpack Compose. Não é por acaso que a própria equipe do Google lançou sua “versão” deste texto: Thinking in Compose (https://developer.android.com/jetpack/compose/mental-model). Leia antes de começar.

Um bom caminho pra começar são os cursos abaixo.

Jetpack Compose for Android Developers – https://developer.android.com/courses/jetpack-compose/course

Este treinamento é composto por trilhas. Faça ao menos a primeira: Compose Essentials. Você irá adquirir o “feeling” sobre como trabalhar com o Compose para coisas bem simples. Repito: coisas bem simples.

Na sequência siga para as outras trilhas:

Layouts, Theming and Animation – aqui você vai aprender como deixar sua aplicação bonita.

Architecture and State – de longe na minha opinião a parte mais difícil do aprendizado. E aqui você vai me agradecer por ter lhe pedido para que antes de chegar aqui lesse um pouco sobre arquitetura. Você irá aprender como as aplicações gerenciam seu estado (isto é, as “variáveis” por trás de cada view). Faça e refaça quantas vezes for necessário esta trilha até que tudo fique claro.

Cuidado: este curso é de 2022 e há alguns pontos desatualizados nele. Especialmente no que diz respeito ao uso do Android Studio.

É ali que você aprenderá o que são os view models, que são um componente essencial da arquitetura. Se você já conhece o padrão de projeto MVC, pense nos view models como o “Controlador” da história.

Lembra lá no início quando falei pra você começar pelo Kotlin? Aquele esforço se pagará muito aqui.

O “outro” treinamento (o “grandão”)

Há um outro treinamento online que você também pode tirar proveito: “Android Basics with Compose” – https://developer.android.com/courses/android-basics-compose/course

Este é o treinamento completo: vai desde o básico do Kotlin, passa pelo Compose, lida com as camadas de dados, ensina a fazer requisições à Internet (REST), como lidar com execução em segundo plano e até mesmo como integrar projetos que usam Views (legado) com Compose.

Se você tiver muita paciência e seguir apenas este treinamento já te dá um belo passo a frente. Por que não falei dele antes? Por que quis te dar alternativas. Pense neste como o “resumão da obra”.

Conteúdo adicional sobre o Compose

Se você realizou o treinamento acima vai ser importante você se aprofundar em alguns temas. Seguem aqui mais alguns links para que você possa se aprofundar.

Codelab do Navigation – https://developer.android.com/codelabs/android-navigation – para que você possa se focar neste ponto que é muito importante.

Material Components and Layouts – https://developer.android.com/jetpack/compose/layouts/material – Material é a linguagem de design do Google, e neste link você irá aprender a como começar a tirar proveito dele. Muita atenção ao uso do “scaffolding”, que pode poupar MUITO tempo no desenvolvimento.

ViewModel Overview – https://developer.android.com/topic/libraries/architecture/viewmodel – digo e repito: minha maior dificuldade foi entender o conceito de estado em aplicações Android. Quanto mais você ler sobre o ViewModel, melhor. E este texto pode te ajudar a entender os conceitos por trás deste elemento.

E isto é só o começo

Espero que este guia lhe seja útil tal como tem sido para mim e nossa equipe. De tempos em tempos voltarei a este post para atualizar os links caso mudem ou para adicionar mais conteúdos.

E meus próximos posts aqui serão sobre como tem sido nossa experiência no desenvolvimento deste tipo de aplicação e por que tem nos parecido tão interessante. Até lá!

PS: “one more thing”

Lembra quando mencionei o “Kotlin Multiplatform”? Então: existe também o Compose Multiplatform, que permite usar a mesma base de código para Android, iOS, desktop e web. Ainda em desenvolvimento, mas bastante promissor. https://www.jetbrains.com/lp/compose-multiplatform/