4. Capítulo 3 - Introdução ao Android e ao Jetpack Compose
4.1. Fontes
Documentação oficial: https://developer.android.com, em particular as páginas “Jetpack Compose” (https://developer.android.com/compose), “Thinking in Compose”, “State and Jetpack Compose”, “Introduction to Activities” e “ViewModel Overview”. Corrotinas do Kotlin: https://kotlinlang.org/docs/coroutines-overview.html
4.2. O que é um aplicativo Android?
Um aplicativo Android é um arquivo .apk (ou .aab para a Play Store) que contém o código compilado, os recursos (ícones, textos, imagens) e um manifesto ([AndroidManifest.xml]), sua “carteira de identidade” para o sistema: seu identificador, as permissões que ele solicita (acesso à rede etc.) e a lista de suas telas.
Essas telas são chamadas de “activities” ([Activity]). Uma activity não é criada pelo próprio programa: é o SISTEMA que a cria quando o usuário toca no ícone do aplicativo e, em seguida, chama seus métodos ao longo do seu ciclo de vida: [onCreate(...)] na criação, [onPause()] quando ela vai para segundo plano, [onDestroy()] na destruição... Portanto, não existe uma função [main()] em um aplicativo Android; essa é a primeira diferença em relação ao [void main()] do cliente Flutter. Esse ciclo de vida tem uma consequência importante, detalhada adiante: uma rotação de tela DESTRÓI e depois RECRIA a activity.
O código Kotlin é compilado em bytecode Java, depois convertido para o formato DEX e executado pela máquina virtual Android, [ART] (Android Runtime), que por sua vez o compila em código de máquina na instalação e durante a execução. Não há JavaScript nem engine de [WebView]: é um aplicativo NATIVO, como os que já vêm instalados no celular. Assim como o Flutter, o Jetpack Compose desenha seus próprios componentes (botões, campos de entrada etc.) em vez de usar os componentes de interface Android legados (a [View]), mas faz isso usando as próprias bibliotecas de interface do Android, e não um mecanismo de renderização embutido no aplicativo, como o Flutter.
Diferentemente do Flutter, este cliente tem como alvo SOMENTE o Android: o mesmo código não produz um aplicativo para iOS, desktop ou web. O Capítulo 5 explica o que seria necessário para isso (Kotlin Multiplatform e Compose Multiplatform).
4.3. O modelo de desenvolvimento do Compose: tudo é uma função
Com o Jetpack Compose, uma interface é descrita por funções Kotlin anotadas com @Composable. Uma função @Composable não retorna nada: ela EMITE a interface chamando outras funções @Composable, como [Text(...)], [Button(...)], [Column(...)]... A interface completa é a árvore dessas chamadas aninhadas.
Este é o mesmo modelo declarativo do Flutter (“a interface é uma função do estado”), com uma diferença formal: enquanto o Flutter descreve cada elemento por meio de uma CLASSE (um [Widget]) cujo método [build(...)] retorna uma árvore de objetos, o Compose usa apenas funções. O plugin de compilação do Compose transforma essas funções para que possam ser reexecutadas seletivamente quando o estado que elas leem muda: isso se chama “recomposição”.
As configurações de aparência e de layout (margens, tamanho, alinhamento, cor de fundo, cliques etc.) não são elementos da árvore, como os widgets [Padding] ou [Center] do Flutter, mas “modificadores”, encadeados e passados como parâmetros: [Modifier.padding(16.dp).fillMaxWidth()]. A unidade [dp] (pixel independente de densidade) equivale aos pixels lógicos do Flutter: 1 dp corresponde a um pixel em uma tela com resolução de 160 pontos por polegada, independentemente da densidade real da tela.
4.4. Estado e recomposição: nem StatefulWidget nem setState
O Flutter distingue, desde a declaração da classe, um [StatelessWidget] de um [StatefulWidget] associado à sua classe [State], e exige a chamada de [setState(() { ... })] para que uma mudança de estado seja exibida. O Compose não faz nada disso:
- uma variável local é declarada na própria função: [var clicks by remember { mutableStateOf(0) }];
- [mutableStateOf(...)] cria um ESTADO OBSERVÁVEL: o Compose registra automaticamente toda função @Composable que o LÊ e reexecuta (“recompõe”) essas funções, e somente elas, quando o valor muda. Não há nada a chamar após uma mudança: [clicks++] é tudo o que se precisa. É assim que [ref(...)]/[reactive(...)] funcionam no Vue.js, e não como [setState(...)] funciona;
- [remember { ... }] armazena um valor de uma execução da função para a seguinte. Sem ele, o estado seria recriado, e zerado, a cada chamada;
- [rememberSaveable { ... }] faz a mesma coisa e, ALÉM DISSO, preserva o valor quando a activity é destruída e depois recriada (rotação de tela; veja abaixo);
- A palavra-chave [by] (delegação de propriedade; veja o curso de Kotlin) permite escrever [clicks] em vez de [clicks.value].
O mesmo mecanismo se aplica a um estado compartilhado: uma classe comum cujas propriedades são declaradas como [by mutableStateOf(...)] é observada automaticamente por todas as funções que leem essas propriedades. É assim que os serviços do cliente são escritos ([SettingsService], [AuthService], [TranslationsService]; veja o Capítulo 4): enquanto a versão Flutter estendia [ChangeNotifier] e chamava manualmente [notifyListeners()] após cada modificação, aqui não há nada a notificar.
4.5. Compartilhamento de estado: CompositionLocal, o equivalente de provider
Para disponibilizar um serviço a toda uma árvore de funções @Composable sem passá-lo como parâmetro de chamada em chamada, o Compose oferece o [CompositionLocal]: você declara uma “chave” ([val LocalAuth = staticCompositionLocalOf<AuthService> { ... }]), atribui um valor ao topo da árvore ([CompositionLocalProvider(LocalAuth provides auth) { ... }]) e qualquer função descendente pode LÊ-LO com [LocalAuth.current]. Esse é exatamente o papel do pacote [provider] na versão Flutter ([MultiProvider] / [context.read<...>()]), de [provide]/[inject] no Vue.js ou de um [Context] do React. O Compose não precisa do equivalente de [context.watch<...>()]: a assinatura de mudanças é tratada pelos próprios estados observáveis.
4.6. Sem linguagem de template: condições e listas
Como no Flutter, a renderização condicional e as listas são escritas com construções comuns da linguagem: uma expressão [if] do Kotlin para uma condição, um laço [forEach] para uma lista. Como uma função @Composable é como qualquer outra função, [if (auth.isLoggedIn) { ... }] EMITE seu conteúdo ou não; não há equivalente à construção de listas de widgets ([children: [...]]) nem à sintaxe “collection if” do Dart.
4.7. Corrotinas: async/await no estilo do Kotlin
Um aplicativo Android tem apenas uma thread responsável por desenhar a interface e responder ao usuário: a thread principal. Ela NUNCA deve esperar; na verdade, o Android proíbe qualquer acesso à rede a partir dessa thread (exceção [NetworkOnMainThreadException]). As chamadas ao servidor devem, portanto, ser feitas “em segundo plano”. O Kotlin oferece as corrotinas para isso:
- uma função [suspend] pode ser pausada sem bloquear a thread que a executa, o equivalente de uma função [async] do Dart ou do TypeScript. Chamar uma função [suspend] equivale a esperar por ela: não existe a palavra-chave [await]; a espera é implícita;
- [withContext(Dispatchers.IO) { ... }] executa um bloco em uma thread reservada para E/S e depois volta à thread original com o resultado. É isso que permite usar uma biblioteca de rede “bloqueante” ([OkHttp]) sem nunca bloquear a interface;
- Uma corrotina é iniciada com [launch { ... }] DENTRO de um escopo ([CoroutineScope]) vinculado a um ciclo de vida: [viewModelScope] (as corrotinas de um ViewModel, canceladas quando ele é destruído) ou [rememberCoroutineScope()] (as de uma função @Composable, canceladas quando ela desaparece da tela). Não há mais o risco, como no Flutter, de modificar o estado de uma tela que já foi destruída (o teste [if (mounted)]): a corrotina é cancelada junto com ela.
4.8. O ciclo de vida: rotação de tela e ViewModel
Por padrão, quando o usuário gira o celular (ou muda o idioma do sistema ou passa para o modo escuro), o Android DESTRÓI a activity e cria uma nova, adaptada à nova configuração. Tudo o que estava armazenado na activity antiga, e nos estados de suas funções @Composable, é perdido. O Flutter não tem esse problema: girar a tela apenas altera o tamanho da tela.
O Android oferece duas soluções, e o cliente usa as duas:
- [rememberSaveable { ... }] para pequenos estados da interface (texto em digitação, médico selecionado etc.): o Android os salva antes da destruição e os restaura na nova activity;
- um [ViewModel] para o estado e a lógica de uma tela (listas carregadas do servidor, calendário exibido etc.): é um objeto que o Android MANTÉM entre as recriações da activity e repassa à nova. Ele só é destruído quando a tela é abandonada em definitivo. O cliente deste documento coloca em um ViewModel ([AppViewModel]) todo o estado que a versão Flutter mantinha na classe [_AppRootState].
Os objetos que devem viver tanto quanto a aplicação (serviços) não são criados na activity nem em um ViewModel, mas na classe [Application] da aplicação, que é criada uma única vez quando o processo é iniciado.
4.9. Um primeiro exemplo simples
Eis um pequeno aplicativo Compose: um texto, um botão que conta os cliques e uma mensagem que aparece somente após o terceiro clique. Para experimentá-lo, basta substituir o conteúdo do arquivo [MainActivity.kt] de um projeto criado com o template [Empty Activity] (veja o Capítulo 1), ajustando a linha [package].
Vamos analisar este código:
- linha 19: [class MainActivity : ComponentActivity()]: a activity, a tela iniciada pelo sistema. [ComponentActivity] é a classe base destinada ao Compose;
- linha 20: [onCreate(...)]: chamado pelo Android quando a activity é criada. É o ponto de partida do código do aplicativo, no lugar do [main()] do Flutter;
- linha 22: [setContent { ... }]: substitui o conteúdo da tela pela interface descrita no bloco; é o equivalente de [runApp(...)] no Flutter;
- linha 23: [MaterialTheme { ... }]: fornece o tema Material 3 (cores, tipografia, formas) a tudo o que é chamado dentro do bloco; o papel do [MaterialApp] do Flutter, sem a navegação;
- linhas 30–31: [@Composable fun Counter(name: String)]: uma função `@Composable` com um parâmetro. Por convenção, seu nome começa com letra maiúscula, como o nome de uma classe: ela representa um elemento da interface;
- linha 32: [var clicks by remember { mutableIntStateOf(0) }]: um estado local; [mutableIntStateOf] é a variante de [mutableStateOf] otimizada para um inteiro;
- linha 33: [Column(modifier = Modifier.padding(32.dp)) { ... }]: organiza seus filhos um abaixo do outro, com uma margem de 32 dp. [Row] os organizaria lado a lado;
- linha 35: [Button(onClick = { clicks++ })]: o tratador de clique é uma simples lambda. [clicks++] altera o estado: o Compose recompõe imediatamente [Counter], que LÊ esse estado, e o texto do botão é atualizado;
- Linhas 38–40: um [if] comum do Kotlin: o texto “Well done!” só é emitido, e portanto exibido, a partir do terceiro clique.
4.10. Resumo: correspondências entre Flutter e Jetpack Compose
- [void main()] + [runApp(...)] → activity ([ComponentActivity]) + [setContent { ... }]
- [StatelessWidget]/[StatefulWidget] (classes) → funções [@Composable]
- campos de [State<T>] + [setState(...)] → [remember { mutableStateOf(...) }] (recomposição automática)
- [ChangeNotifier] + [notifyListeners()] → classe com propriedades [by mutableStateOf(...)] (nada a notificar)
- pacote [provider] ([MultiProvider], [context.read]/[watch]) → [CompositionLocal] ([CompositionLocalProvider], [LocalXxx.current])
- parâmetros do construtor de widgets (entradas), funções passadas como parâmetros (saídas) → parâmetros de funções @Composable, lambdas
- [build(BuildContext)] → o corpo da função @Composable
- widgets [Padding], [Center], [SizedBox]... → modificadores ([Modifier.padding(...)]...)
- [Future<T>] + [async]/[await] → funções [suspend] + corrotinas
- pacote [http] → biblioteca [OkHttp]
- construtores [fromJson(...)] escritos à mão → classes [@Serializable] ([kotlinx.serialization])
- pacote [shared_preferences] → [SharedPreferences] do Android (a API da qual o pacote Flutter tirou seu nome)
- [showDialog(...)] → uma função [AlertDialog(...)] exibida enquanto um estado a exigir
- [LayoutBuilder] / [MediaQuery] → [BoxWithConstraints] / [LocalConfiguration]
- [pubspec.yaml] + [flutter pub get] → [build.gradle.kts] + [libs.versions.toml] + Gradle
- Sem equivalente no Flutter: [ViewModel] e [rememberSaveable], causados pela recriação da activity quando a tela gira