Skip to content

1. Introdução

O PDF do documento está AQUI.

O código deste documento está AQUI.

Este documento é um produto da IA Claude, da Anthropic. Ele adapta o curso “Introdução passo a passo ao framework mobile Flutter”, incluindo seu roteiro, seus 25 exemplos, seu servidor e seu estudo de caso, e muda a ferramenta utilizada:

  • No curso [Flutter], o aplicativo é escrito em [Dart], usando um framework que desenha cada pixel da tela por conta própria, e o mesmo código produz um aplicativo [Android], [iOS], ou web;
  • Neste curso, o aplicativo é um aplicativo [Android] NATIVO, escrito em [Kotlin] (a linguagem recomendada pelo Google para Android desde 2019), usando o [Jetpack Compose], a biblioteca de interface declarativa do Android.

O servidor, porém, permanece inalterado: é o servidor JSON [RdvMedecins] escrito em [NestJS], já usado pelos clientes React, Vue.js, Angular e Flutter. E as telas são as já familiares aos leitores desses cursos: login com CAPTCHA, a agenda de um médico, uma janela de marcação de consulta, o portal do paciente, gerenciamento de médicos e clientes, criação de conta e suporte aos idiomas francês e inglês.

Os 25 exemplos têm os mesmos números que os do curso [Flutter] (e dos cursos de React, Vue.js e Angular): leitores familiarizados com qualquer um desses frameworks encontrarão cada conceito em seu devido lugar. Quando um conceito do [Flutter] não tem equivalente direto no [Compose], o exemplo demonstra a abordagem usada no [Android] (um formulário escrito com classes comuns, recursos [strings.xml] para os textos, deep links em vez de endereços web...).

Já existe um curso sobre este tema: Um exemplo cliente/servidor - Kotlin Android / NestJS (2026), que apresenta um cliente completo logo de início. Este documento difere em sua abordagem: aprendemos o [Compose] passo a passo, por meio de pequenos exemplos, antes de abordar o cliente completo; e o servidor é tratado como uma caixa-preta, da qual só nos interessam a API e o JSON.

Os fundamentos da linguagem [Kotlin] (classes, data classes, nulabilidade, lambdas, funções de extensão, coleções) são considerados conhecidos: são abordados no curso Kotlin. Os recursos da linguagem particularmente relevantes para o [Compose] (funções como parâmetros, lambdas finais, delegação com [by], interfaces seladas, corrotinas) são revistos ao longo dos exemplos, à medida que são usados.

Claude escreveu todo o código, compilou-o e executou-o em um emulador [Android] no computador do revisor, com a permissão dele; as capturas de tela foram feitas durante essas execuções.

1.1. O papel do Android e do Compose em uma aplicação cliente/servidor

A aplicação tem duas partes, que se comunicam entre si apenas por meio de requisições HTTP:

Image

  • 1: O aplicativo [Android], executado no celular, envia uma requisição HTTP ao servidor, por exemplo, [GET /api/schedule?doctorId=1&day=2026-10-05];
  • 2: O servidor responde com dados JSON: a agenda desse médico para aquele dia. Ele não gera nenhuma página;
  • 3: Com esses dados, o [Compose] atualiza a tela do celular.

Esta é exatamente a arquitetura dos clientes [React], [Vue.js], [Angular] e [Flutter]: a única diferença está no que gera a exibição. [Jetpack Compose] baseia-se nos mesmos conceitos que o [React] e o [Flutter]:

  • a tela é descrita por FUNÇÕES: uma função anotada com [@Composable] descreve uma parte da interface (um texto, um botão, uma coluna, uma tela inteira) chamando outras funções [@Composable]. Elas formam uma árvore;
  • a interface é uma função do estado: quando um dado observado muda (um “estado”, [mutableStateOf]), o [Compose] reexecuta as funções que o leem (é a RECOMPOSIÇÃO) e atualiza a tela. Nunca escrevemos código que modifica a tela: descrevemos a tela como uma função do estado;
  • uma linguagem moderna, [Kotlin], compilada para a máquina virtual do [Android]: suas lambdas, funções de extensão e corrotinas tornam natural esse estilo de escrita.

Diferentemente do [Flutter], o [Compose] é específico do [Android] (existe uma variante, o [Compose Multiplatform], para outras plataformas, mas ela não é abordada aqui). Em compensação, o aplicativo é um aplicativo [Android] “comum”: usa diretamente as bibliotecas do Google ([Jetpack]) e os serviços do sistema (idioma do aplicativo, ciclo de vida da activity, gerenciador de senhas etc.).

Assim como o [Flutter], o [Compose] não é um framework “completo” para comunicação com um servidor: o cliente HTTP, a navegação e o estado compartilhado são fornecidos por bibliotecas. Este curso usa as recomendadas pelo Google ([Jetpack]: Navigation, ViewModel, DataStore, AppCompat) e as bibliotecas mais usadas do ecossistema [Kotlin] ([OkHttp], [kotlinx.serialization]).

1.2. Ferramentas utilizadas

Os exemplos foram escritos e testados com as seguintes ferramentas:

  • [Android Studio] (versão Quail 2026.1), o ambiente de desenvolvimento do Google: editor, SDK do [Android], emulador. Ele inclui seu próprio JDK ([JBR] 25), que é usado pelo [Gradle];
  • [Gradle] 9.6 e o plugin [Android] (AGP) 9.4, que compilam o aplicativo. O próprio plugin [Android] 9 inclui suporte ao [Kotlin] 2.2;
  • um emulador [Android] (um Pixel 8, [Android] 17, API 37) ou um celular [Android] real conectado ao computador;
  • o SGBD [MySQL] (ou [MariaDB]), por exemplo, o do [Laragon] no [Windows], e o [Node.js]: eles são necessários para o servidor JSON, a partir do capítulo que o apresenta;
  • a ferramenta de linha de comando [curl], que exibe as respostas HTTP brutas.

As bibliotecas utilizadas são declaradas no arquivo [gradle/libs.versions.toml] de cada projeto: o "BOM" do [Compose] 2026.02 (Material 3), [Navigation Compose] 2.9, [Lifecycle] 2.9 (ViewModel), [DataStore] 1.1, [AppCompat] 1.7, [OkHttp] 4.12, [kotlinx.serialization] 1.9, [AndroidSVG] 1.4.

1.3. Capturas de tela

As capturas de tela deste documento foram geradas automaticamente por meio de testes “instrumentados” (pastas de projeto [app/src/androidTest]): esses testes são executados no emulador, iniciam cada exemplo, interagem com ele como um usuário faria (digitando texto, clicando em botões) e, em seguida, capturam a tela inteira. O relógio da barra de status é congelado em 10:00 (o “modo de demonstração” do [Android]).

1.4. Os exemplos

O código deste documento está organizado em três pastas:

1
2
3
4
kotlin-etape-par-etape-oct-2026/
├── examples_kotlin/          the 25 small examples (a single Android Studio project)
├── rdvmedecins-nestjs-json/  the RdvMedecins JSON server (the "black box")
└── rdvmedecins_kotlin/       the Android client of the case study

Os exemplos formam um único projeto [Android Studio] e um único aplicativo [Android]: cada exemplo é uma ACTIVITY (uma tela), armazenada em seu próprio pacote ([fr.stahe.examples.ex01], [fr.stahe.examples.ex02]...), e um menu, a activity de inicialização, permite iniciar todos eles:

examples_kotlin/
├── app/
│   ├── build.gradle.kts            the configuration of the application
│   └── src/
│       ├── main/
│       │   ├── AndroidManifest.xml the activities of the application
│       │   ├── assets/             files shipped with the application (example 25)
│       │   ├── java/fr/stahe/examples/
│       │   │   ├── MainActivity.kt the menu of the 25 examples
│       │   │   ├── common/         code shared by the examples
│       │   │   ├── ex01/           example 01: Ex01Activity.kt
│       │   │   ├── ...
│       │   │   └── ex25/
│       │   └── res/                the resources: texts, images, icons
│       └── androidTest/            the making of the screenshots
├── gradle/libs.versions.toml       the versions of the libraries
├── build.gradle.kts, settings.gradle.kts
└── gradlew, gradlew.bat            the Gradle launcher

Abra a pasta [examples_kotlin] no [Android Studio] ([File / Open]); o [Gradle] baixará então as bibliotecas. Inicie o aplicativo pelo botão [Run] (o triângulo verde): o menu aparece, e cada linha abre um exemplo. Também é possível iniciar um exemplo diretamente de um console, com a ferramenta [adb] do SDK do [Android]:

adb shell am start -n fr.stahe.examples/.ex05.Ex05Activity

Os exemplos 22 a 25 consultam o servidor JSON [RdvMedecins]: é preciso tê-lo instalado e em execução, conforme explicado no capítulo dedicado a ele.

1.5. Conteúdo do documento

  • Primeiros passos (exemplos 01 a 09): uma activity, as funções [@Composable], o estado ([remember], [mutableStateOf]), eventos, campos de entrada, um reducer, validação, um formulário reutilizável, formatação;
  • Componentes (10 a 16): parâmetros, funções com parâmetros, composição (conteúdo dentro de parâmetros), ciclo de vida e efeitos, [CompositionLocal], comportamentos reutilizáveis (animações, funções [remember...]), janela de confirmação;
  • Navegação (17 e 18): [Navigation Compose], rotas tipadas, parâmetros, deep links, guards;
  • Operações assíncronas e estado compartilhado (19 e 20): corrotinas, [Flow], debounce, respostas expiradas, [ViewModel], [DataStore];
  • Internacionalização (21): recursos [strings.xml], plurais, idioma do aplicativo;
  • O servidor, uma caixa-preta: instalação do servidor JSON, sua API, exemplos de [curl];
  • Comunicação com o servidor (22 a 25): [OkHttp], o endereço do servidor, o cookie de token, uma camada de acesso à API, um view model, erros do servidor;
  • Estudo de caso: o cliente [Android] do aplicativo [RdvMedecins];
  • Implantação: o aplicativo assinado (APK), o servidor de produção.

Cada exemplo é apresentado com seu código completo e comentado e com capturas de tela de sua execução. O próprio código é amplamente comentado: esses comentários fazem parte do curso.