4. Os componentes
O capítulo anterior apresentou os componentes do [Material 3] e o estado. Este capítulo mostra como escrever SEUS PRÓPRIOS componentes: seus parâmetros, como eles notificam o componente pai, a composição, seu ciclo de vida, os dados fornecidos a distância e os comportamentos reutilizáveis. Com o [Compose], um componente é uma simples função [@Composable]: o equivalente dos widgets do [Flutter].
4.1. Exemplo 10: componentes e seus parâmetros
Um cartão que exibe um médico, usado várias vezes em uma tela. O tipo de dado, compartilhado pelo pai e pelo filho:
| // o tipo de dado compartilhado pelo pai (DoctorsPage) e pelo filho (DoctorCard)
package fr.stahe.examples.ex10
data class Doctor(
val id: Int,
val title: String,
val firstName: String,
val lastName: String,
val specialty: String,
val available: Boolean,
)
|
O FILHO, o cartão:
| // =========================================================================
// ex10/DoctorCard.kt - um componente FILHO
// -------------------------------------------------------------------------
// Ele recebe seus dados do pai por meio de seus PARÂMETROS. O tipo deles é
// verificado em tempo de compilação: DoctorCard(doctor = 42, ...) seria rejeitado.
// - um parâmetro sem valor padrão: o pai DEVE fornecê-lo;
// - compact: Boolean = false: um parâmetro opcional, com seu valor
// padrão;
// - modifier: Modifier = Modifier: a convenção do Compose, o pai
// pode ajustar o tamanho, as margens... do filho.
//
// Regra de ouro: um componente NUNCA MODIFICA seus parâmetros (eles são
// val). Os dados fluem do pai para o filho; para pedir uma
// alteração, o filho chama uma função que o pai lhe passou
// (cf. exemplo 11). Quando o pai altera seus dados, o Compose REEXECUTA
// o filho com novos parâmetros.
// =========================================================================
package fr.stahe.examples.ex10
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
// o "estilo" do card: constantes PRIVADAS deste arquivo. Nenhum outro
// componente pode vê-las, nem ser incomodado por elas
private val initialsColor = Color(0xFF087EA4)
@Composable
fun DoctorCard(doctor: Doctor, rank: Int, modifier: Modifier = Modifier, compact: Boolean = false) {
// um valor calculado a partir dos parâmetros
val initials = "${doctor.firstName.first()}${doctor.lastName.first()}"
Card(
modifier = modifier.padding(vertical = 4.dp),
shape = RoundedCornerShape(12.dp),
// uma borda verde para um médico disponível (null: sem borda)
border = if (doctor.available) BorderStroke(2.dp, Color(0xFF4CAF50)) else null,
) {
Row(Modifier.padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
// um círculo colorido, com as iniciais no centro
Box(
contentAlignment = Alignment.Center,
modifier = Modifier.size(40.dp).background(initialsColor, CircleShape),
) {
Text(initials, color = Color.White, fontWeight = FontWeight.Bold)
}
Spacer(Modifier.width(12.dp))
// weight(1f): o texto ocupa toda a largura restante
Column(Modifier.weight(1f)) {
Text("$rank. ${doctor.title} ${doctor.firstName} ${doctor.lastName}", style = MaterialTheme.typography.titleMedium)
if (!compact) {
Text(doctor.specialty, color = Color.Gray)
}
}
}
}
}
|
- Linha 43: uma constante [private]: visível apenas neste arquivo;
- linha 46: os parâmetros do cartão. Seu tipo é verificado em tempo de compilação; [doctor] e [rank] são obrigatórios; [compact] é opcional; [modifier: Modifier = Modifier] é a CONVENÇÃO do [Compose]: o pai pode ajustar o tamanho, as margens etc. do filho, que aplica esse [modifier] ao seu componente mais externo;
- Linha 48: um valor calculado a partir dos parâmetros;
- linhas 49–53: [Card], um cartão [Material], com uma borda verde para um médico disponível ([null]: sem borda);
- linhas 57–61: um círculo colorido ([CircleShape]) com as iniciais;
- linhas 67–68: a especialidade só é exibida no modo normal.
A regra de ouro: um componente NUNCA MODIFICA seus parâmetros (eles são [val]; na verdade, o compilador proíbe isso). Os dados fluem do pai para o filho; quando o pai altera seus dados, o [Compose] REEXECUTA o filho com seus novos parâmetros. O PAI:
| // =========================================================================
// ex10/Ex10Activity.kt - o componente PAI
// -------------------------------------------------------------------------
// Ele usa o componente DoctorCard, quantas vezes for preciso, como
// qualquer componente do Compose: uma função @Composable é um
// pedaço de interface REUTILIZÁVEL, com seus próprios parâmetros e seu
// estilo. Escrever os próprios componentes é o coração do trabalho com o
// Compose: uma tela bem escrita é feita de pequenos componentes.
// =========================================================================
package fr.stahe.examples.ex10
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.width
import androidx.compose.material3.ListItem
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
class Ex10Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { DoctorsPage() } }
}
}
@Composable
fun DoctorsPage() {
var doctors by remember {
mutableStateOf(
listOf(
Doctor(1, "Mme", "Marie", "PELISSIER", "general practitioner", true),
Doctor(2, "Mr", "Paul", "TATOU", "pediatrician", false),
Doctor(3, "Melle", "Sophie", "DUPONT", "general practitioner", true),
),
)
}
var compact by remember { mutableStateOf(false) }
ExamplePage("Example 10 - components and their parameters") {
ListItem(
headlineContent = { Text("compact display") },
trailingContent = { Switch(checked = compact, onCheckedChange = { compact = it }) },
)
// o pai altera SEUS dados: o Compose reexecuta esta função, que
// chama os filhos de novo com seus novos parâmetros
OutlinedButton(onClick = { doctors = doctors.map { it.copy(available = !it.available) } }) {
Text("Toggle availabilities")
}
Spacer(Modifier.height(8.dp))
doctors.forEachIndexed { i, d ->
// cada card recebe SEUS parâmetros; key: sua identidade (cf. exemplo 04)
key(d.id) {
DoctorCard(doctor = d, rank = i + 1, compact = compact)
}
}
Spacer(Modifier.height(16.dp))
Text("The same card, in compact version, by setting the parameter:", color = Color.Gray)
// o pai também define a LARGURA do filho, por meio do parâmetro modifier
DoctorCard(doctor = doctors[0], rank = 1, compact = true, modifier = Modifier.width(260.dp))
}
}
|
- linha 63: o pai altera SEUS dados: uma nova lista, em que cada médico é substituído por uma cópia;
- linhas 67–70: um registro por médico, cada um com SEUS parâmetros; [key(d.id)]: a identidade do médico (veja o exemplo 04);
- linha 76: o pai também define a LARGURA do filho por meio do parâmetro [modifier].


4.2. Exemplo 11: o filho notifica o pai
Os dados são passados para baixo por meio de parâmetros; a informação SOBE por meio de funções que o pai passa ao filho (por convenção, seus nomes começam com [on]). Um primeiro filho, um contador, que tem seu próprio estado e notifica o pai:
| // =========================================================================
// ex11/Counter.kt - um filho que NOTIFICA seu pai
// -------------------------------------------------------------------------
// O pai passa FUNÇÕES a ele como parâmetros (por convenção, seu
// nome começa com "on"), e o filho as chama quando algo
// acontece:
// Counter(label = "Coffees", max = 3, onIncrement = { ... }, onLimit = { ... })
// O tipo de uma função é escrito (parâmetros) -> resultado:
// - (Int) -> Unit : uma função que recebe um Int e não retorna nada;
// - () -> Unit : uma função sem parâmetros, que não retorna nada.
// =========================================================================
package fr.stahe.examples.ex11
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.width
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.SuggestionChip
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.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
@Composable
fun Counter(label: String, max: Int, onIncrement: (Int) -> Unit, onLimit: () -> Unit) {
// o estado ESPECÍFICO deste contador: cada Counter tem o seu
var value by remember { mutableIntStateOf(0) }
fun plus() {
if (value >= max) {
onLimit()
return
}
value++
// NOTIFICAMOS o pai, passando a ele o novo valor
onIncrement(value)
}
Row(verticalAlignment = Alignment.CenterVertically) {
Text(label, Modifier.width(110.dp))
OutlinedButton(onClick = { plus() }) { Text("+1") }
Spacer(Modifier.width(12.dp))
SuggestionChip(onClick = {}, label = { Text("$value / $max") })
}
}
|
- linha 30: o tipo de uma função é escrito como [(parameters) -> result]: [(Int) -> Unit] recebe um [Int] e não retorna nada; [() -> Unit] não tem parâmetros;
- linha 32: o estado PRÓPRIO do contador: cada [Counter] tem o seu;
- linhas 34–41: quando atinge o máximo, o contador notifica o pai ([onLimit()]); caso contrário, incrementa e transmite seu novo valor ([onIncrement(value)]).
Um segundo filho, um componente CONTROLADO, que é usado como os campos do [Compose]: o valor pertence ao pai, que o passa ao filho ([value]) e que é notificado pelo filho a cada tecla digitada ([onChange]). O componente não tem estado:
| // =========================================================================
// ex11/TextField.kt - um componente CONTROLADO
// -------------------------------------------------------------------------
// Um campo de formulário "caseiro" (rótulo + campo + ajuda + contador de
// caracteres) que é usado como os campos do Compose:
// TextField(value = firstName, onChange = { firstName = it }, ...)
// O valor pertence ao PAI, que o passa (value) e que é
// notificado de cada tecla digitada (onChange). É o pai quem decide.
// O componente não tem estado: ele exibe o que lhe é dado. Se o
// próprio pai altera o valor (botão "Clear"), o campo acompanha, sem
// nada mais a escrever.
// =========================================================================
package fr.stahe.examples.ex11
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
@Composable
fun TextField(value: String, onChange: (String) -> Unit, label: String, max: Int, help: String = "") {
val full = value.length == max
OutlinedTextField(
value = value,
// o campo rejeita os caracteres excedentes: a tecla digitada só é repassada
// ao pai se o texto não ultrapassar max caracteres
onValueChange = { text -> if (text.length <= max) onChange(text) },
label = { Text(label) },
singleLine = true,
// a borda fica vermelha quando o campo está cheio
isError = full,
supportingText = { Text(if (full) "Maximum length reached - ${value.length}/$max" else "$help - ${value.length}/$max") },
modifier = Modifier.fillMaxWidth(),
)
}
|
- linha 28: a tecla digitada só é enviada ao pai se o texto não exceder [max] caracteres: o campo “rejeita” os caracteres excedentes;
- linhas 32–33: a borda fica vermelha quando o campo está cheio, e a dica indica isso.
O pai:
| // =========================================================================
// ex11/Ex11Activity.kt - o pai escuta seus filhos
// -------------------------------------------------------------------------
// Os dados descem (parâmetros); a informação sobe por meio de
// funções passadas como parâmetros:
// 1. "eventos" do filho: onIncrement, onLimit;
// 2. um componente controlado: value + onChange, como um TextField.
// O estado continua sendo propriedade do pai, que pode modificá-lo ele mesmo
// (Clear).
// =========================================================================
package fr.stahe.examples.ex11
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
class Ex11Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { ParentPage() } }
}
}
@Composable
fun ParentPage() {
var total by remember { mutableIntStateOf(0) }
var message by remember { mutableStateOf("") }
var firstName by remember { mutableStateOf("Marie") }
var lastName by remember { mutableStateOf("PELISSIER") }
// a função chamada por um contador: ela recebe o valor que o contador repassa
fun onIncrement(label: String, value: Int) {
total++
message = "$label is now $value"
}
val titleStyle = MaterialTheme.typography.titleSmall
ExamplePage("Example 11 - the child notifies its parent") {
Card {
Column(Modifier.padding(12.dp)) {
Text("1. Functions called by the children", style = titleStyle)
Counter(
label = "Coffees",
max = 3,
onIncrement = { v -> onIncrement("Coffees", v) },
onLimit = { message = "No more than 3 coffees!" },
)
Counter(
label = "Glasses of water",
max = 8,
onIncrement = { v -> onIncrement("Glasses of water", v) },
onLimit = { message = "Enough drinking." },
)
Spacer(Modifier.height(8.dp))
Text("Total of clicks: $total - $message", fontStyle = FontStyle.Italic)
}
}
Card {
Column(Modifier.padding(12.dp)) {
Text("2. Controlled components", style = titleStyle)
TextField(value = firstName, onChange = { firstName = it }, label = "First name", max = 20, help = "Required")
TextField(value = lastName, onChange = { lastName = it }, label = "Last name", max = 20, help = "Displayed in upper case")
Spacer(Modifier.height(8.dp))
Text(
buildAnnotatedString {
append("Data of the parent: ")
withStyle(SpanStyle(fontWeight = FontWeight.Bold)) { append("$firstName ${lastName.uppercase()}") }
},
)
Spacer(Modifier.height(8.dp))
OutlinedButton(onClick = {
firstName = ""
lastName = ""
}) { Text("Clear (from the parent)") }
}
}
}
}
|
- linhas 57–59: a função chamada pelos contadores;
- linhas 68–71: cada contador recebe duas expressões lambda; a primeira recebe o valor passado ([v]) e acrescenta a ele o rótulo do contador;
- linhas 86–87: os campos controlados: o valor e o que fazer a cada tecla digitada;
- linhas 97–99: o pai modifica seus próprios dados: os campos o acompanham, sem nada mais a escrever.


À esquerda, o número máximo de cafés foi atingido e o nome tem 20 caracteres; à direita, depois de “Clear (from the parent)”.
4.3. Exemplo 12: composição
Os parâmetros de um componente passam DADOS... mas também CONTEÚDO: um parâmetro pode ser uma função [@Composable], que o componente chama onde quiser. É isso que o [Compose] faz em toda parte ([Card], [Scaffold], o [label] de um campo...). Um primeiro template, um cartão com três slots:
| // =========================================================================
// ex12/Card.kt - um TEMPLATE reutilizável
// -------------------------------------------------------------------------
// Os parâmetros de um componente passam DADOS... mas também
// CONTEÚDO: um parâmetro pode ser uma função @Composable, que o
// componente chama onde quiser. O Compose usa isso em toda parte: o conteúdo
// de um Card, a topBar de um Scaffold, o rótulo de um campo...
// - content: por convenção, o ÚLTIMO parâmetro, o conteúdo "principal".
// Ele é escrito após os parênteses da chamada:
// Card(color = ...) { Text("the content") }
// - header, footer: outros lugares ("slots"), fornecidos pelo
// pai; o header tem um conteúdo padrão, o footer é opcional.
// O card define a moldura (borda, header, footer), o pai fornece o que
// vai dentro.
// =========================================================================
package fr.stahe.examples.ex12
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.ProvideTextStyle
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
@Composable
fun Card(
color: Color? = null, // "?": opcional (null por padrão)
header: @Composable () -> Unit = { Text("Untitled") },
footer: (@Composable () -> Unit)? = null,
content: @Composable () -> Unit,
) {
val fill = color ?: Color(0xFFE0E0E0) // "?:": a cor, ou senão este cinza
Card(
modifier = Modifier.padding(vertical = 4.dp),
shape = RoundedCornerShape(8.dp),
border = BorderStroke(1.dp, fill),
) {
Column {
Box(Modifier.fillMaxWidth().background(fill).padding(10.dp)) {
// ProvideTextStyle: o estilo de TODOS os textos do header,
// qualquer que seja o conteúdo fornecido pelo pai
ProvideTextStyle(TextStyle(color = if (color == null) Color.Black else Color.White, fontWeight = FontWeight.Bold)) {
header()
}
}
Box(Modifier.padding(10.dp)) { content() }
// nenhum footer fornecido: nenhum footer
if (footer != null) {
Box(Modifier.fillMaxWidth().background(Color(0xFFF5F5F5)).padding(8.dp)) {
ProvideTextStyle(TextStyle(color = Color.Gray, fontSize = 12.sp)) { footer() }
}
}
}
}
}
|
- linhas 38–41: três parâmetros de conteúdo: [header], com conteúdo padrão; [footer], OPCIONAL ([(@Composable () -> Unit)?]: uma função ou [null]); [content], o último, que na chamada é escrito após os parênteses;
- linhas 53–54: [ProvideTextStyle] define o estilo de TODOS os textos do cabeçalho, independentemente do conteúdo fornecido pelo pai;
- linhas 59–61: se nenhum rodapé for fornecido, não há rodapé algum.
Um segundo template, uma tabela GENÉRICA: ela sabe percorrer as linhas, mas não sabe exibir UMA célula; o pai lhe diz o que fazer descrevendo as colunas:
| // =========================================================================
// ex12/DataTable.kt - uma tabela GENÉRICA
// -------------------------------------------------------------------------
// DataTable<T> é um componente genérico: ele exibe linhas de
// qualquer tipo T. Ele sabe percorrer as linhas, mas não como
// exibir UMA célula: é o pai quem diz isso a ele, descrevendo suas
// colunas. Cada TableColumn<T> tem um título, uma largura relativa (weight) e
// uma FUNÇÃO @Composable, cell(row, index), que exibe sua célula.
// O conteúdo fornecido pelo pai usa dados que pertencem ao
// filho (a linha, sua posição): é o princípio das listas do Compose
// (LazyColumn e sua função items { ... }).
// =========================================================================
package fr.stahe.examples.ex12
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.ProvideTextStyle
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
// uma coluna de uma tabela de T
class TableColumn<T>(val title: String, val weight: Float = 1f, val cell: @Composable (row: T, index: Int) -> Unit)
@Composable
fun <T> DataTable(
rows: List<T>,
columns: List<TableColumn<T>>,
// exibido quando não há nenhuma linha
empty: @Composable () -> Unit = { Text("No data.") },
) {
Column {
// a linha dos títulos
Row {
for (c in columns) {
Text(c.title, Modifier.weight(c.weight).padding(6.dp), fontWeight = FontWeight.Bold)
}
}
HorizontalDivider()
if (rows.isEmpty()) {
Box(Modifier.padding(6.dp)) { ProvideTextStyle(TextStyle(color = Color.Gray)) { empty() } }
}
rows.forEachIndexed { i, row ->
if (i > 0) HorizontalDivider(color = Color(0xFFE0E0E0))
Row(verticalAlignment = Alignment.CenterVertically) {
// as células DESTA linha, exibidas pelas funções do pai
for (c in columns) {
Box(Modifier.weight(c.weight).padding(6.dp)) { c.cell(row, i) }
}
}
}
}
}
|
- linha 31: uma coluna de uma tabela de [T]: um título, uma largura relativa e uma função [@Composable] que exibe a célula em uma linha;
- Linhas 55–56: as células de cada linha, exibidas pelas funções do pai. O conteúdo fornecido pelo pai usa dados pertencentes ao filho (a linha, seu índice): esse é o princípio por trás das listas do [Compose] ([LazyColumn], veja o estudo de caso).
A tela que usa os dois templates:
| // =========================================================================
// ex12/Ex12Activity.kt - usando os templates Card e DataTable
// =========================================================================
package fr.stahe.examples.ex12
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Icon
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.SuggestionChipDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
// um slot; patient: null se o slot estiver livre
data class Slot(val id: Int, val timeRange: String, val patient: String?)
val slots = listOf(
Slot(1, "8:00 - 8:20", null),
Slot(2, "8:20 - 8:40", "Mme Alice DURAND"),
Slot(3, "8:40 - 9:00", null),
)
data class Person(val id: Int, val name: String)
class Ex12Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { CompositionPage() } }
}
}
@Composable
fun CompositionPage() {
val free = slots.count { it.patient == null }
ExamplePage("Example 12 - composition") {
// header e footer: funções @Composable passadas como parâmetros;
// o conteúdo: a lambda escrita DEPOIS dos parênteses
Card(
color = Color(0xFF3F51B5),
header = {
Row(verticalAlignment = Alignment.CenterVertically) {
Icon(Icons.Default.DateRange, contentDescription = null, tint = Color.White)
Spacer(Modifier.width(8.dp))
Text("Schedule of Mme PELISSIER")
}
},
footer = { Text("$free free slot(s)") },
) {
// DataTable<Slot>: T é deduzido do tipo de rows
DataTable(
rows = slots,
columns = listOf(
// s recebe a linha, i sua posição
TableColumn("#", 0.4f) { _, i -> Text("${i + 1}") },
TableColumn("Slot", 1.2f) { s, _ -> Text(s.timeRange) },
TableColumn("Status", 1.6f) { s, _ ->
if (s.patient != null) {
SuggestionChip(onClick = {}, label = { Text(s.patient) })
} else {
SuggestionChip(
onClick = {},
label = { Text("Free") },
colors = SuggestionChipDefaults.suggestionChipColors(containerColor = Color(0xFFC8E6C9)),
)
}
},
),
)
}
Card(color = Color(0xFF4CAF50), header = { Text("A card without a footer") }) {
Text("The footer is not provided: the card does not display it.")
}
// nenhum header fornecido: o conteúdo padrão, "Untitled"
Card {
DataTable(
rows = emptyList<Person>(),
columns = listOf(TableColumn("Name") { p, _ -> Text(p.name) }),
empty = { Text("Nobody for now.") },
)
}
}
}
|
- linhas 52–61: o cabeçalho e o rodapé, funções lambda passadas pelo nome; o conteúdo, a função lambda escrita APÓS os parênteses;
- linhas 64–70: [DataTable<Slot>]: [T] é DEDUZIDO, o que define o tipo da linha. Cada coluna recebe a linha e seu índice; [_]: um parâmetro não utilizado;
- Linhas 88–92: um cartão sem cabeçalho (o conteúdo padrão, “Untitled”) e uma tabela vazia.

4.4. Exemplo 13: o ciclo de vida de um componente
Um componente ENTRA na composição (sua função é executada pela primeira vez), é RECOMPOSTO quantas vezes forem necessárias e depois SAI da composição, definitivamente. O [Compose] oferece “efeitos” a disparar nesses momentos:
- [LaunchedEffect(key) [ ... ]]: inicia uma CORROTINA (código que pode esperar; veja o Exemplo 19) na entrada, reinicia-a se [key] mudar e a CANCELA na saída;
- [DisposableEffect(key) { ... ; onDispose [ ... ] }]: código na entrada e limpeza na saída.
Um relógio que inicia um temporizador... e deve pará-lo quando desaparece:
| // =========================================================================
// ex13/Clock.kt - um componente que inicia e para
// -------------------------------------------------------------------------
// A vida de um componente na tela ("a composição"):
// 1. ele ENTRA na composição: sua função é executada pela
// primeira vez. O que deve ser iniciado é iniciado aqui;
// 2. ele é RECOMPOSTO quantas vezes for preciso (seu estado ou seus
// parâmetros mudaram);
// 3. ele SAI da composição: desaparece da tela, para sempre.
// O que foi iniciado é PARADO aqui.
// O Compose fornece "efeitos" para agir nesses momentos, fora da
// própria exibição:
// - LaunchedEffect(key) { ... }: lança uma COROTINA (código que pode
// esperar, cf. exemplo 19) ao entrar na composição, relança-a
// se key mudar, CANCELA-a ao sair;
// - DisposableEffect(key) { ...; onDispose { ... } }: código ao
// entrar, e sua limpeza (onDispose) ao sair.
// Um relógio inicia um timer quando aparece... e deve
// obrigatoriamente pará-lo quando desaparece: com LaunchedEffect,
// isso é automático.
// =========================================================================
package fr.stahe.examples.ex13
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.runtime.setValue
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.delay
import java.time.LocalTime
import java.time.format.DateTimeFormatter
fun currentTime(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))
@Composable
fun Clock(onLog: (String) -> Unit, color: Color = Color(0xFF3F51B5)) {
var time by remember { mutableStateOf(currentTime()) }
// a ÚLTIMA função onLog recebida (os efeitos abaixo duram
// mais que uma execução da função)
val log by rememberUpdatedState(onLog)
// entrando na composição e saindo dela
DisposableEffect(Unit) {
log("Clock: entering the composition - timer started")
onDispose { log("Clock: leaving the composition - timer stopped") }
}
// o timer: uma corotina, CANCELADA automaticamente ao sair
LaunchedEffect(Unit) {
while (true) {
delay(1000) // espera um segundo, sem bloquear o celular
time = currentTime()
}
}
// um parâmetro que muda: o efeito é relançado (exceto na primeira vez)
var firstColor by remember { mutableStateOf(true) }
LaunchedEffect(color) {
if (firstColor) firstColor = false else log("Clock: recomposed with a new color")
}
Text(time, fontSize = 40.sp, fontFamily = FontFamily.Monospace, color = color)
}
|
- linha 47: [rememberUpdatedState]: os efeitos duram mais que uma única chamada de função; eles devem chamar a ÚLTIMA função recebida ([onLog]), e não a primeira;
- linhas 50–52: entrada na composição e saída ([onDispose]);
- linhas 57–59: o temporizador, um laço infinito... em uma corrotina: [delay(1000)] espera um segundo SEM bloquear o celular; a corrotina é cancelada ao sair da composição, e o laço com ela;
- linha 65: um efeito cuja chave é um parâmetro: ele é disparado novamente quando a cor muda.
A tela:
| // =========================================================================
// ex13/Ex13Activity.kt - o ciclo de vida
// -------------------------------------------------------------------------
// - if (withClock) Clock(...): marcar / desmarcar a caixa faz
// o relógio entrar / sair da composição (cf. Clock.kt);
// mudar sua cor o recompõe;
// - um campo que recebe o foco assim que aparece (o teclado do
// celular abre);
// - o título do aplicativo acompanha a entrada (TaskTitle);
// - a vida da própria ACTIVITY (seu "Lifecycle"): em um celular,
// ela vai para segundo plano (outro aplicativo é aberto, a tela
// apaga), depois volta: podemos reagir a isso (salvar, parar
// um timer...).
// =========================================================================
package fr.stahe.examples.ex13
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.selection.toggleable
import androidx.compose.material3.Card
import androidx.compose.material3.Checkbox
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.compose.LocalLifecycleOwner
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.common.TaskTitle
class Ex13Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { LifecyclePage() } }
}
}
@Composable
fun LifecyclePage() {
var withClock by remember { mutableStateOf(true) }
var red by remember { mutableStateOf(false) }
val log = remember { mutableStateListOf<String>() }
var search by remember { mutableStateOf("") }
var showSearch by remember { mutableStateOf(false) }
fun trace(message: String) {
log.add("${currentTime()} $message")
}
// a vida da activity: nos INSCREVEMOS em suas mudanças de estado ao entrar
// na composição, CANCELAMOS a inscrição ao sair (onDispose)
val lifecycle = LocalLifecycleOwner.current.lifecycle
DisposableEffect(lifecycle) {
val observer = LifecycleEventObserver { _, event -> trace("Activity: ${event.name}") }
lifecycle.addObserver(observer)
onDispose { lifecycle.removeObserver(observer) }
}
TaskTitle(if (search.isEmpty()) "Example 13" else "Search: $search")
ExamplePage("Example 13 - the lifecycle") {
Card {
Column(Modifier.padding(12.dp)) {
CheckboxRow("show the clock", withClock) { withClock = it }
CheckboxRow("in red", red) { red = it }
if (withClock) {
Clock(onLog = { trace(it) }, color = if (red) Color.Red else Color(0xFF3F51B5))
}
}
}
Card {
Column(Modifier.padding(12.dp)) {
if (!showSearch) {
OutlinedButton(onClick = { showSearch = true }) { Text("Search...") }
} else {
// um campo que recebe o foco assim que aparece
val focus = remember { FocusRequester() }
OutlinedTextField(
value = search,
onValueChange = { search = it },
placeholder = { Text("the title follows the input") },
modifier = Modifier.fillMaxWidth().focusRequester(focus),
)
LaunchedEffect(Unit) { focus.requestFocus() }
}
}
}
Text("Log", style = MaterialTheme.typography.titleSmall)
log.forEachIndexed { i, line -> Text("${i + 1}. $line", fontSize = 12.sp) }
}
}
// uma caixa de seleção e seu rótulo; a linha inteira reage ao toque.
// onChange é o ÚLTIMO parâmetro: pode ser escrito após os parênteses
@Composable
fun CheckboxRow(label: String, checked: Boolean, onChange: (Boolean) -> Unit) {
ListItem(
modifier = Modifier.toggleable(value = checked, onValueChange = onChange),
leadingContent = { Checkbox(checked = checked, onCheckedChange = null) },
headlineContent = { Text(label) },
)
}
|
- linhas 74–78: o ciclo de vida da própria ACTIVITY: em um celular, ela vai para segundo plano (outro aplicativo, a tela se apaga) e depois volta. Assinamos suas mudanças ([addObserver]) ao entrar na composição e cancelamos a assinatura ao sair;
- linhas 4–89: [if (withClock) Clock(...)]: desmarcar a caixa faz o relógio SAIR da composição; marcá-la novamente cria um NOVO;
- linhas 99–106: um campo que ganha o foco assim que aparece: [LaunchedEffect] é executado APÓS a exibição, quando o campo já existe.

O log mostra a sequência: a activity é criada, iniciada e retomada ([ON_CREATE], [ON_START], [ON_RESUME]); o relógio é adicionado ao layout; sua cor muda; depois a caixa é desmarcada e marcada novamente.
4.5. Exemplo 14: os dados fornecidos
Como compartilhar dados entre componentes distantes sem passá-los de parâmetro em parâmetro por todos os intermediários? Com um [CompositionLocal], um dado que é “local à composição”: ele é DECLARADO uma vez; um componente o repassa a todos os seus descendentes ([CompositionLocalProvider]); qualquer descendente o LÊ. O [Compose] o usa ele mesmo: [MaterialTheme.colorScheme], [LocalContext.current], [LocalDensity.current]... É o equivalente de [InheritedWidget] e do pacote [provider] do [Flutter].
Um log, exibido em tela cheia:
| // =========================================================================
// ex14/providers/Log.kt - um dado para a aplicação INTEIRA
// -------------------------------------------------------------------------
// Como compartilhar dados e funções entre componentes distantes,
// sem passá-los de parâmetro em parâmetro por todos os
// intermediários? Com um CompositionLocal, um dado "local à
// composição":
// 1. ele é DECLARADO uma só vez: val LocalLog = staticCompositionLocalOf<Log> { ... };
// 2. um componente situado no alto da árvore o FORNECE a todos os seus
// descendentes: CompositionLocalProvider(LocalLog provides log) { ... };
// 3. qualquer descendente, em qualquer profundidade, o LÊ:
// LocalLog.current.
// É o mecanismo que o próprio Compose usa: MaterialTheme.colorScheme,
// LocalContext.current, LocalDensity.current... são leituras de
// CompositionLocal.
//
// O log em si é um objeto comum, cujo estado (suas linhas) é
// OBSERVADO pelo Compose (mutableStateListOf): um componente que lê suas
// linhas é recomposto quando elas mudam.
// =========================================================================
package fr.stahe.examples.ex14.providers
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.staticCompositionLocalOf
import java.time.LocalTime
import java.time.format.DateTimeFormatter
class Log {
// a lista observada; fora, ela é vista apenas como uma List NÃO MODIFICÁVEL
private val _lines = mutableStateListOf<String>()
val lines: List<String> get() = _lines
fun trace(message: String) {
_lines.add(0, "${LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))} $message")
if (_lines.size > 6) _lines.removeAt(_lines.lastIndex)
}
}
// a declaração: o tipo do dado e o que acontece se ninguém o
// fornecer (aqui, um erro explícito).
// static: o log fornecido nunca muda (é seu CONTEÚDO que muda)
val LocalLog = staticCompositionLocalOf<Log> { error("LocalLog: no log provided above this component") }
|
- linhas 30–31: o estado do log, uma lista observada, que é exposta externamente apenas como uma [List] NÃO modificável;
- linha 8: a declaração: o tipo do dado e o que acontece se ninguém o fornecer (um erro explícito). [static]: o dado fornecido nunca muda (o que muda é o seu CONTEÚDO).
Um carrinho de compras, fornecido a uma parte da tela por um componente provedor, que o cria:
| // =========================================================================
// ex14/providers/Cart.kt - um dado fornecido por UM componente
// -------------------------------------------------------------------------
// O carrinho só é fornecido a uma parte da árvore: os componentes
// que CartProvider envolve (cf. Ex14Activity.kt). Dois providers
// colocados em dois lugares da tela dariam dois carrinhos independentes.
// É o provider que CRIA o carrinho (remember); ele
// mesmo usa o log.
// =========================================================================
package fr.stahe.examples.ex14.providers
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.staticCompositionLocalOf
data class Item(val label: String, val price: Double)
class Cart(private val log: Log) {
private val _items = mutableStateListOf<Item>()
val items: List<Item> get() = _items
// um valor calculado: sumOf soma um valor de cada item
val total: Double get() = _items.sumOf { it.price }
fun add(item: Item) {
_items.add(item)
log.trace("cart: + ${item.label}")
}
fun remove(index: Int) {
log.trace("cart: - ${_items[index].label}")
_items.removeAt(index)
}
}
val LocalCart = staticCompositionLocalOf<Cart> { error("LocalCart: no cart provided above this component") }
// o provider: ele cria o carrinho UMA VEZ e o fornece ao seu conteúdo
@Composable
fun CartProvider(content: @Composable () -> Unit) {
val log = LocalLog.current
val cart = remember { Cart(log) }
CompositionLocalProvider(LocalCart provides cart, content = content)
}
|
- linha 25: [total], uma propriedade calculada; [sumOf] soma o valor de cada item;
- linhas 42–45: o provedor cria o carrinho UMA ÚNICA VEZ ([remember]) e o preenche com seu conteúdo; ele próprio lê o log, fornecido acima.
Um relógio, fornecido com um período configurável:
| // =========================================================================
// ex14/providers/Clock.kt - um provider PARAMETRIZADO
// -------------------------------------------------------------------------
// Um relógio, cujo período de atualização é um parâmetro do
// provider: ClockProvider(periodMs = 5000) { ... }.
// Dois providers aninhados: um componente lê aquele que estiver MAIS
// PRÓXIMO acima dele.
// Desta vez, o dado fornecido MUDA (a hora, a cada tique):
// compositionLocalOf (e não staticCompositionLocalOf). O Compose então só
// recompõe os componentes que LEEM a hora.
// O relógio para quando seu provider desaparece (LaunchedEffect).
// =========================================================================
package fr.stahe.examples.ex14.providers
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import kotlinx.coroutines.delay
import java.time.LocalDateTime
// o valor padrão: uma data congelada, lida por um componente sem provider
val LocalClock = compositionLocalOf { LocalDateTime.of(2026, 1, 1, 0, 0) }
@Composable
fun ClockProvider(periodMs: Long = 1000, content: @Composable () -> Unit) {
var now by remember { mutableStateOf(LocalDateTime.now()) }
// se o período mudar, a corotina é cancelada e relançada
LaunchedEffect(periodMs) {
while (true) {
delay(periodMs)
now = LocalDateTime.now()
}
}
CompositionLocalProvider(LocalClock provides now, content = content)
}
|
- linha 27: desta vez, o dado fornecido MUDA (a hora, a cada tique): [compositionLocalOf], e não [staticCompositionLocalOf]. O [Compose] então reconstrói apenas os componentes que LEEM a hora;
- linhas 33–36: se o período mudar, a corrotina é cancelada e reiniciada.
Dois descendentes que usam o carrinho:
| // ex14/Catalog.kt - um descendente que ADICIONA ao carrinho
package fr.stahe.examples.ex14
import androidx.compose.foundation.layout.Column
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ShoppingCart
import androidx.compose.material3.Card
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import fr.stahe.examples.ex14.providers.Item
import fr.stahe.examples.ex14.providers.LocalCart
val catalog = listOf(Item("Consultation", 30.0), Item("Vaccine", 12.5), Item("Certificate", 5.0))
@Composable
fun Catalog() {
// o carrinho fornecido por ShopPage (um erro se ninguém o fornecer)
val cart = LocalCart.current
Card {
Column {
for (item in catalog) {
ListItem(
headlineContent = { Text("${item.label} (€${item.price})") },
trailingContent = {
IconButton(onClick = { cart.add(item) }) {
Icon(Icons.Default.ShoppingCart, contentDescription = "add ${item.label}")
}
},
)
}
}
}
}
// =========================================================================
// ex14/CartSummary.kt
// -------------------------------------------------------------------------
// Outro descendente: o MESMO carrinho de Catalog, mas SEU PRÓPRIO
// relógio, atualizado a cada 5 segundos. Um componente só lê os
// providers colocados ACIMA dele: CartSummary, portanto, coloca um segundo
// ClockProvider em torno de seu conteúdo, que ele entrega a um pequeno
// componente, Content, que lê o relógio MAIS PRÓXIMO: o de 5 s.
// =========================================================================
package fr.stahe.examples.ex14
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.stahe.examples.ex14.providers.ClockProvider
import fr.stahe.examples.ex14.providers.LocalClock
import fr.stahe.examples.ex14.providers.LocalCart
@Composable
fun CartSummary() {
ClockProvider(periodMs = 5000) { Content() }
}
@Composable
private fun Content() {
val cart = LocalCart.current
val now = LocalClock.current // o mais próximo: o de 5 s
Card {
Column(Modifier.padding(12.dp)) {
Text(
"Cart (${cart.items.size} item(s)) - ${now.toLocalTime().withNano(0)}",
style = MaterialTheme.typography.titleSmall,
)
cart.items.forEachIndexed { i, item ->
Row(verticalAlignment = Alignment.CenterVertically) {
Text(item.label)
TextButton(onClick = { cart.remove(i) }) { Text("remove") }
}
}
Text("Total: €${cart.total}", fontWeight = FontWeight.Bold)
}
}
}
|
- linhas 29–30: [CartSummary] coloca um SEGUNDO provedor de relógio (5 segundos) em torno de seu conteúdo: um componente lê o provedor de relógio MAIS PRÓXIMO acima dele.
A tela:
| // =========================================================================
// ex14/Ex14Activity.kt - três níveis de dados fornecidos
// -------------------------------------------------------------------------
// - o log: fornecido no topo, pela activity, a toda a tela;
// - o carrinho, fornecido por ShopPage: compartilhado por Catalog e
// CartSummary, que veem o MESMO carrinho;
// - o relógio, fornecido por ShopPage (período padrão, 1 s) E por
// CartSummary (5 s): cada um com o seu.
// =========================================================================
package fr.stahe.examples.ex14
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.ex14.providers.ClockProvider
import fr.stahe.examples.ex14.providers.CartProvider
import fr.stahe.examples.ex14.providers.Log
import fr.stahe.examples.ex14.providers.LocalClock
import fr.stahe.examples.ex14.providers.LocalLog
class Ex14Activity : ComponentActivity() {
// o log: um objeto criado com a activity
private val log = Log()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent {
// o log, fornecido a TODA a tela
CompositionLocalProvider(LocalLog provides log) {
ExamplesTheme { ShopPage() }
}
}
}
}
// a hora do relógio da página: um pequeno componente, colocado ABAIXO do provider
@Composable
private fun PageTime() {
Text("Clock of the page: ${LocalClock.current.toLocalTime().withNano(0)}", color = Color.Gray)
}
@Composable
fun ShopPage() {
// a página lê o log: ela será recomposta a cada nova linha
val log = LocalLog.current
ClockProvider {
CartProvider {
ExamplePage("Example 14 - provided data") {
PageTime()
Catalog()
CartSummary()
Spacer(Modifier.height(12.dp))
Text("Log (provided to the whole screen)", style = MaterialTheme.typography.titleSmall)
for (line in log.lines) {
Text(line, fontSize = 12.sp)
}
}
}
}
}
|
- linhas 43–44: o log, um objeto de atividade, renderizado na tela;
- linhas 60–65: o relógio (1 s) e o carrinho de compras, fornecidos à página; [Catalog] e [CartSummary] veem o MESMO carrinho de compras.

4.6. Exemplo 15: reutilizando comportamentos
Reutilizar uma EXIBIÇÃO consiste em escrever um componente. Para reutilizar um COMPORTAMENTO (e seu estado), o [Compose] oferece duas ferramentas: um componente “wrapper” ou uma função [remember...]. Um wrapper que destaca seu conteúdo quando é tocado:
| // =========================================================================
// ex15/Highlighter.kt - um comportamento em um componente "wrapper"
// -------------------------------------------------------------------------
// A primeira forma de reutilizar um COMPORTAMENTO (com seu estado): um
// componente que envolve qualquer conteúdo e adiciona a ele este
// comportamento:
// Highlighter(color = ...) { ListItem(...) }
// Este destaca seu conteúdo enquanto ele é TOCADO (o dedo na
// tela) e, com um mouse (tablet, ChromeOS), enquanto o ponteiro está
// SOBRE ele. Cada Highlighter tem seu próprio estado: duas linhas não interferem.
// =========================================================================
package fr.stahe.examples.ex15
import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.awaitEachGesture
import androidx.compose.foundation.gestures.awaitFirstDown
import androidx.compose.foundation.gestures.waitForUpOrCancellation
import androidx.compose.foundation.hoverable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.interaction.collectIsHoveredAsState
import androidx.compose.foundation.layout.Box
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.pointer.pointerInput
@Composable
fun Highlighter(color: Color = Color(0xFFFFF3CD), content: @Composable () -> Unit) {
var touched by remember { mutableStateOf(false) }
// passagem do mouse: uma "interaction source", cujo estado
// "hovered" é observado
val interactions = remember { MutableInteractionSource() }
val hovered by interactions.collectIsHoveredAsState()
// uma mudança de cor ANIMADA (200 ms)
val fill by animateColorAsState(if (touched || hovered) color else Color.Transparent, tween(200), label = "fill")
Box(
Modifier
.background(fill)
.hoverable(interactions)
// os contatos do dedo, no nível mais baixo: o dedo toca a tela,
// depois se levanta (ou o gesto é cancelado). requireUnconsumed = false:
// mesmo que o conteúdo (um botão) já tenha tratado o toque
.pointerInput(Unit) {
awaitEachGesture {
awaitFirstDown(requireUnconsumed = false)
touched = true
waitForUpOrCancellation()
touched = false
}
},
) {
content()
}
}
|
- linhas 38–39: passar o mouse por cima (tablet, [ChromeOS]): uma “fonte de interação”, cujo estado “hovered” é observado;
- linha 41: [animateColorAsState]: uma mudança de cor ANIMADA;
- linhas 49–54: toques do dedo no nível mais baixo: para cada gesto ([awaitEachGesture]), esperamos o dedo tocar a tela e depois levantar. [requireUnconsumed = false]: mesmo que o conteúdo (um botão) já tenha processado o toque.
Um componente com animação: um botão que deve ser mantido pressionado por um segundo enquanto um anel se preenche:
| // =========================================================================
// ex15/LongPressButton.kt - um botão de toque longo
// -------------------------------------------------------------------------
// LongPressButton(durationMs = 1000, onAction = { remove() }) { Text(...) }
// A ação só é executada se o botão for mantido pressionado durante
// toda a duração: uma proteção contra toques acidentais. Um anel
// se preenche durante o toque.
// O preenchimento é uma ANIMAÇÃO: um Animatable é um valor (de 0 a 1)
// que uma corotina faz variar, quadro a quadro (animateTo). Cancelar a
// corotina (o dedo se levanta cedo demais) interrompe a animação.
// =========================================================================
package fr.stahe.examples.ex15
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.LinearEasing
import androidx.compose.animation.core.tween
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.launch
@Composable
fun LongPressButton(durationMs: Int = 1000, onAction: () -> Unit, content: @Composable () -> Unit) {
val progress = remember { Animatable(0f) }
// o escopo das corotinas do componente: elas são canceladas se ele desaparecer
val scope = rememberCoroutineScope()
val action by rememberUpdatedState(onAction)
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.pointerInput(Unit) {
detectTapGestures(
// onPress: o dedo toca a tela; tryAwaitRelease ESPERA que ele se levante
onPress = {
val filling = scope.launch {
progress.animateTo(1f, tween(durationMs, easing = LinearEasing))
// a animação foi até o fim: o toque durou o suficiente
progress.snapTo(0f)
action()
}
tryAwaitRelease()
// o dedo se levanta cedo demais: o preenchimento é interrompido, o anel se esvazia
if (filling.isActive) {
filling.cancel()
scope.launch { progress.animateTo(0f, tween(200)) }
}
},
)
},
) {
CircularProgressIndicator(
progress = { progress.value },
modifier = Modifier.size(22.dp),
color = Color.Red,
strokeWidth = 3.dp,
trackColor = Color(0xFFFFEBEE),
)
Spacer(Modifier.width(8.dp))
content()
}
}
|
- linhas 37–39: um [Animatable], um valor (de 0 a 1) que uma corrotina incrementa quadro a quadro; [rememberCoroutineScope]: um escopo para iniciar corrotinas a partir de um evento;
- linhas 47–58: o dedo é colocado: o preenchimento é iniciado ([animateTo(1f)], em [durationMs]); se chegar ao fim, a ação é executada. [tryAwaitRelease()] ESPERA o dedo ser levantado: se o preenchimento ainda estiver em andamento, ele é cancelado e o anel é esvaziado.
Uma função [remember...], que RETORNA um objeto depois de configurar seu estado e seus efeitos (essa é a convenção do [Compose]: [rememberScrollState()], [rememberCoroutineScope()]...), é a seguinte:
| // =========================================================================
// ex15/FocusOnStart.kt - um comportamento em uma função "remember..."
// -------------------------------------------------------------------------
// A segunda forma de reutilizar um comportamento: uma
// função @Composable que RETORNA um objeto, depois de ter configurado seu estado e
// seus efeitos. É a convenção do Compose (rememberScrollState(),
// rememberCoroutineScope()...): seu nome começa com "remember".
// val focus = rememberFocusOnStart()
// OutlinedTextField(..., modifier = Modifier.focusRequester(focus))
// O campo que usa este FocusRequester recebe o foco assim que a tela
// é exibida.
// =========================================================================
package fr.stahe.examples.ex15
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.remember
import androidx.compose.ui.focus.FocusRequester
@Composable
fun rememberFocusOnStart(): FocusRequester {
val focus = remember { FocusRequester() }
// após a primeira exibição: o campo existe, e o foco lhe é dado
LaunchedEffect(Unit) { focus.requestFocus() }
return focus
}
|
A tela:
| // =========================================================================
// ex15/Ex15Activity.kt - reutilizando comportamentos
// -------------------------------------------------------------------------
// Três ferramentas do Compose para reutilizar um COMPORTAMENTO (e seu estado),
// e não uma simples exibição:
// - um componente "wrapper" (Highlighter);
// - um componente que carrega uma animação (LongPressButton);
// - uma função "remember..." (rememberFocusOnStart).
// =========================================================================
package fr.stahe.examples.ex15
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.material3.ListItem
import androidx.compose.material3.ListItemDefaults
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
class Ex15Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { BehavioursPage() } }
}
}
@Composable
fun BehavioursPage() {
val doctors = remember { mutableStateListOf("Mme Marie PELISSIER", "Mr Paul TATOU", "Melle Sophie DUPONT") }
var message by remember { mutableStateOf("") }
// o FocusRequester preparado por rememberFocusOnStart
val focus = rememberFocusOnStart()
var input by remember { mutableStateOf("") }
ExamplePage("Example 15 - reusing behaviours") {
OutlinedTextField(
value = input,
onValueChange = { input = it },
placeholder = { Text("this field received the focus on its own") },
modifier = Modifier.fillMaxWidth().focusRequester(focus),
)
Spacer(Modifier.height(12.dp))
Text("Touch the lines; hold a button down for one second to delete.", color = Color.Gray)
doctors.forEachIndexed { i, d ->
key(d) {
// uma linha em duas: a cor padrão; as outras, verdes
Highlighter(color = if (i % 2 == 0) Color(0xFFFFF3CD) else Color(0xFFD1E7DD)) {
ListItem(
// um fundo transparente: o do Highlighter aparece por baixo
colors = ListItemDefaults.colors(containerColor = Color.Transparent),
headlineContent = { Text(d) },
trailingContent = {
LongPressButton(onAction = {
doctors.remove(d)
message = "$d has been deleted."
}) {
Text("Delete", color = Color.Red)
}
},
)
}
}
}
Spacer(Modifier.height(12.dp))
if (message.isNotEmpty()) {
Text(message, color = Color(0xFF3F51B5))
}
}
}
|


À esquerda, o dedo está apoiado na primeira linha: ela fica destacada; à direita, o botão “Delete” foi mantido pressionado por um segundo.
4.7. Exemplo 16: uma janela de confirmação reutilizável
Com o [Compose], uma janela ([AlertDialog]) é um componente como qualquer outro: ela é exibida enquanto um estado a solicitar. Para fazer uma pergunta e fornecer a resposta, escrevemos uma pequena classe cuja função [confirm] é uma função SUSPEND (veja o Exemplo 19):
| // =========================================================================
// ex16/Confirmation.kt - "Are you sure?"
// -------------------------------------------------------------------------
// No Compose, um diálogo (AlertDialog) é um componente como outro qualquer:
// ele é exibido enquanto um estado o pedir. Para fazer uma pergunta
// e ESPERAR a resposta, escrevemos uma pequena classe, Confirmation, cuja
// função confirm é uma função SUSPEND (suspend, cf. exemplo
// 19): ela abre o diálogo e depois espera, sem bloquear o celular, que
// o usuário responda. O código chamador fica então muito simples,
// em uma corotina:
//
// if (confirmation.confirm("Delete this doctor?")) { ... }
//
// Fechar o diálogo SEM responder (toque fora, botão Voltar do celular)
// é tratado como um "não".
// O próprio diálogo é exibido por ConfirmDialog(confirmation),
// colocado uma única vez na tela.
// =========================================================================
package fr.stahe.examples.ex16
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.graphics.Color
import kotlinx.coroutines.CompletableDeferred
class Confirmation {
// a pergunta feita (null: nenhum diálogo)
var question by mutableStateOf<String?>(null)
private set
// a resposta esperada: um valor que chegará MAIS TARDE
private var answer: CompletableDeferred<Boolean>? = null
suspend fun confirm(message: String): Boolean {
val waiting = CompletableDeferred<Boolean>()
answer = waiting
question = message // o diálogo é exibido
try {
return waiting.await() // a corotina fica suspensa até a resposta
} finally {
question = null // o diálogo desaparece
}
}
fun respond(yes: Boolean) {
answer?.complete(yes)
}
}
// remember: a Confirmation sobrevive às recomposições da tela
@Composable
fun rememberConfirmation(): Confirmation = remember { Confirmation() }
@Composable
fun ConfirmDialog(confirmation: Confirmation) {
// ?: return: nenhuma pergunta, nada a exibir
val question = confirmation.question ?: return
// AlertDialog: um diálogo Material, com título, conteúdo e botões
AlertDialog(
onDismissRequest = { confirmation.respond(false) }, // fechado sem resposta: "não"
title = { Text("Confirmation") },
text = { Text(question) },
dismissButton = { TextButton(onClick = { confirmation.respond(false) }) { Text("No, go back") } },
confirmButton = {
Button(
onClick = { confirmation.respond(true) },
colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFD32F2F)),
) { Text("Yes, confirm") }
},
)
}
|
- linhas 36–37: a pergunta feita ([null]: nenhuma janela), um estado observado;
- linhas 42–49: [CompletableDeferred]: um valor que chegará MAIS TARDE. [confirm] exibe a janela e depois ESPERA a resposta ([await()]), sem congelar o celular; [finally]: em qualquer caso, a janela desaparece;
- linhas 53–54: um botão da janela FORNECE a resposta: a corrotina em espera é retomada;
- linhas 63–68: a janela: nada se não houver pergunta ([?: return]); fechá-la sem responder (tocando fora da janela ou pressionando o botão Voltar do celular) é tratado como “não”.
A tela: uma lista de contatos e, após cada exclusão, uma mensagem pop-up ([Snackbar]) com um botão “Desfazer”, outro método, muito comum em dispositivos móveis, para proteger o usuário de um engano:
| // =========================================================================
// ex16/Ex16Activity.kt - usando o diálogo de confirmação
// -------------------------------------------------------------------------
// Uma exclusão, depois uma mensagem temporária na parte de baixo da tela (Snackbar),
// com um botão "Undo": a outra forma, muito comum no mobile, de
// proteger o usuário de um engano.
// As duas esperas (a resposta à pergunta, o botão "Undo" da
// mensagem) são feitas em uma COROTINA, lançada por rememberCoroutineScope.
// =========================================================================
package fr.stahe.examples.ex16
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Person
import androidx.compose.material.icons.outlined.Delete
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.SnackbarDuration
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.SnackbarResult
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.coroutines.launch
data class Contact(val id: Int, val name: String)
class Ex16Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { ContactsPage() } }
}
}
@Composable
fun ContactsPage() {
val contacts = remember { mutableStateListOf(Contact(1, "Jean MARTIN"), Contact(2, "Alice DURAND"), Contact(3, "Luc GERMAN")) }
var message by remember { mutableStateOf("") }
val confirmation = rememberConfirmation()
// a área das mensagens temporárias e um escopo para lançar corotinas
val messages = remember { SnackbarHostState() }
val scope = rememberCoroutineScope()
// uma função suspend: ela "espera" a resposta do usuário
suspend fun remove(c: Contact) {
if (!confirmation.confirm("Delete the contact ${c.name}?")) {
message = "Deletion abandoned."
return
}
val position = contacts.indexOf(c)
contacts.remove(c)
message = "${c.name} has been deleted."
// uma mensagem temporária na parte de baixo da tela; showSnackbar espera
// seu desaparecimento e informa se seu botão foi tocado
val result = messages.showSnackbar("${c.name} deleted", actionLabel = "Undo", duration = SnackbarDuration.Short)
if (result == SnackbarResult.ActionPerformed) {
contacts.add(position, c)
message = "${c.name} is back."
}
}
suspend fun removeAll() {
if (confirmation.confirm("Delete the ${contacts.size} contacts?")) {
contacts.clear()
message = "All the contacts have been deleted."
}
}
ExamplePage("Example 16 - a confirmation dialog", messages = messages) {
for (c in contacts) {
ListItem(
leadingContent = { Icon(Icons.Default.Person, contentDescription = null) },
headlineContent = { Text(c.name) },
trailingContent = {
// launch: uma corotina, para poder chamar a função suspend
IconButton(onClick = { scope.launch { remove(c) } }) {
Icon(Icons.Outlined.Delete, contentDescription = "delete ${c.name}", tint = Color.Red)
}
},
)
}
if (contacts.isEmpty()) {
ListItem(headlineContent = { Text("No contact.", color = Color.Gray) })
}
Spacer(Modifier.height(12.dp))
Button(
onClick = { scope.launch { removeAll() } },
// o botão fica desabilitado quando a lista está vazia
enabled = contacts.isNotEmpty(),
colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFD32F2F)),
) { Text("Delete all") }
Spacer(Modifier.height(12.dp))
if (message.isNotEmpty()) {
Text(message, color = Color(0xFF3F51B5))
}
}
// o diálogo, quando uma pergunta é feita
ConfirmDialog(confirmation)
}
|
- linhas 60–61: a área para mensagens pop-up, passada a [ExamplePage] (que a passa ao [Scaffold]), e um escopo de corrotinas;
- linhas 64–77: uma função suspensa que se lê como código comum: fazer uma pergunta, esperar a resposta; excluir; exibir a mensagem, ESPERAR seu desaparecimento ([showSnackbar] indica se o seu botão foi tocado) e cancelar, se necessário;
- linha 95: [scope.launch [ ... ]]: uma corrotina, para poder chamar uma função suspensa a partir de um evento;
- linha 117: a janela, colocada na tela uma única vez.

