Skip to content

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].

package fr.rdvmedecins.example

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Counter(name = "RdvMedecins")
            }
        }
    }
}

@Composable
fun Counter(name: String) {
    var clicks by remember { mutableIntStateOf(0) }
    Column(modifier = Modifier.padding(32.dp)) {
        Text("Hello, $name!")
        Button(onClick = { clicks++ }) {
            Text("Clicked $clicks times")
        }
        if (clicks >= 3) {
            Text("Well done!")
        }
    }
}

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