Skip to content

9. Comunicação com o servidor

O servidor RdvMedecins está em execução (veja o capítulo anterior, com [CAPTCHA_TEST=test] em seu arquivo [.env] para os testes). Os exemplos 22 a 25 o consultam a partir do celular.

9.0.1. Onde está o servidor?

Uma aplicação web servida pelo próprio servidor não precisa fazer essa pergunta: suas requisições vão para a mesma origem da página. Um aplicativo MOBILE precisa: é necessário informar a ele o endereço completo do servidor. Acontece que o celular não é o computador que executa o servidor:

// =========================================================================
// common/Config.kt - ONDE está o servidor JSON? (exemplos 22 a 25)
// -------------------------------------------------------------------------
// Uma aplicação web servida pelo próprio servidor não precisa fazer
// esta pergunta: suas requisições vão para a MESMA origem da
// página. Um aplicativo MOBILE precisa: é preciso informar a ele o endereço
// completo do servidor. Mas o celular não é o computador que executa o
// servidor:
//   - "localhost", para o celular (ou o emulador), é ELE MESMO. O
//     comando  adb reverse tcp:8080 tcp:8080  resolve isso: ele liga a
//     porta 8080 do celular à porta 8080 do computador, pelo cabo USB
//     (ou, no caso do emulador, diretamente). É a solução escolhida por
//     padrão: http://localhost:8080;
//   - o emulador Android também enxerga o computador pelo endereço especial
//     10.0.2.2;
//   - um celular real, conectado à mesma rede Wi-Fi do computador, pode
//     usar o endereço do computador nessa rede (192.168.1.20...).
// O endereço é fixado em tempo de COMPILAÇÃO (BuildConfig, cf. app/build.gradle.kts):
//     gradlew installDebug -Pserver=http://10.0.2.2:8080
// =========================================================================
package fr.stahe.examples.common

import fr.stahe.examples.BuildConfig

object Config {
    val serverUrl: String = BuildConfig.SERVER_URL
}
  • “localhost”, para o celular (ou emulador), é ELE MESMO. O comando [adb reverse tcp:8080 tcp:8080] conecta a porta 8080 do celular à porta 8080 do computador pelo cabo USB (ou diretamente, no caso do emulador). Esta é a solução padrão: [http://localhost:8080]. O comando deve ser executado novamente a cada vez que o emulador for iniciado;
  • o emulador também enxerga o computador no endereço especial [10.0.2.2];
  • um celular real conectado à mesma rede Wi-Fi do computador pode usar o endereço do computador nessa rede ([192.168.1.20]...), desde que o firewall do computador permita o tráfego pela porta 8080.

O endereço é um campo da classe [BuildConfig], gerada em tempo de compilação (veja [app/build.gradle.kts], Exemplo 01); ele pode ser alterado sem modificar o código:

gradlew installDebug -Pserver=http://10.0.2.2:8080

Por fim, o manifesto solicita a permissão [INTERNET] e permite o tráfego HTTP “não criptografado” ([usesCleartextTraffic]): a partir do [Android] 9, apenas HTTPS é permitido por padrão.

9.1. Exemplo 22: Uma primeira requisição HTTP

Um CAPTCHA é solicitado ao servidor: [GET /api/captcha] retorna [{ "id": "...", "svg": "<svg ...>" }]. O cliente HTTP é o [OkHttp], o mais utilizado no [Android] (o equivalente ao pacote [http] do [Flutter]).

// =========================================================================
// ex22/Ex22Activity.kt - uma primeira requisição HTTP ao servidor
// -------------------------------------------------------------------------
// O servidor JSON do RdvMedecins deve estar em execução (porta 8080). Pedimos a ele
// um captcha: GET /api/captcha -> { "id": "...", "svg": "<svg ...>" }.
//
//   - OkHttp, o cliente HTTP mais usado no Android: descrevemos a
//     requisição (Request), o cliente a executa (newCall(...).execute()) e
//     devolve a resposta: seu código de status (code), seus cabeçalhos
//     (headers), seu corpo (body);
//   - execute() BLOQUEIA até a resposta: o Android proíbe chamá-lo
//     na thread da tela. withContext(Dispatchers.IO)
//     o executa em outra thread, e a corrotina ESPERA o resultado;
//   - Json.parseToJsonElement(text): o corpo JSON -> objetos Kotlin;
//   - o endereço do servidor depende de onde a aplicação executa
//     (emulador, celular...): cf. common/Config.kt;
//   - três estados a exibir: carregando, sucesso, erro;
//   - a imagem do captcha é SVG: cf. common/SvgImage.kt.
// =========================================================================
package fr.stahe.examples.ex22

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
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.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.Config
import fr.stahe.examples.common.SvgImage
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import okhttp3.OkHttpClient
import okhttp3.Request

// o que GET /api/captcha devolve
data class Captcha(val id: String, val svg: String)

// um cliente HTTP: um objeto caro de criar, que é criado UMA ÚNICA vez
val client = OkHttpClient()

// a requisição: uma função SUSPEND, que devolve o captcha ou lança uma exceção
suspend fun readCaptcha(): Captcha = withContext(Dispatchers.IO) {
    val request = Request.Builder().url("${Config.serverUrl}/api/captcha").build()
    client.newCall(request).execute().use { response ->
        // OkHttp NÃO lança exceção para uma resposta de erro (4xx,
        // 5xx): o código de status é testado
        if (!response.isSuccessful) {
            throw Exception("the server responded ${response.code} ${response.message}")
        }
        val json = Json.parseToJsonElement(response.body!!.string()).jsonObject
        Captcha(json["id"]!!.jsonPrimitive.content, json["svg"]!!.jsonPrimitive.content)
    }
}

class Ex22Activity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent { ExamplesTheme { CaptchaPage() } }
    }
}

@Composable
fun CaptchaPage() {
    var captcha by remember { mutableStateOf<Captcha?>(null) }
    var loading by remember { mutableStateOf(true) }
    var error by remember { mutableStateOf<String?>(null) }
    var requestCount by remember { mutableIntStateOf(0) }
    // o número do PEDIDO: alterá-lo relança o efeito abaixo
    var demand by remember { mutableIntStateOf(0) }

    // a requisição, assim que a tela aparece (pedido = 0), depois a cada
    // novo pedido. Se um pedido chega antes da resposta ao
    // anterior, a corrotina anterior é CANCELADA: sua resposta
    // obsoleta nunca será exibida
    LaunchedEffect(demand) {
        loading = true
        error = null
        try {
            captcha = readCaptcha()
            requestCount++
        } catch (e: CancellationException) {
            throw e // a corrotina foi cancelada (novo pedido): nada a exibir
        } catch (e: Exception) {
            // nenhuma resposta (servidor parado, endereço errado...), ou erro
            error = e.message ?: e.toString()
            captcha = null
        }
        loading = false
    }

    ExamplePage("Example 22 - a first HTTP request") {
        Text("Server: ${Config.serverUrl}", color = Color.Gray)
        Spacer(Modifier.height(12.dp))
        if (loading) LinearProgressIndicator(Modifier.fillMaxWidth())
        error?.let {
            Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFFFEBEE))) {
                Text("Unable to get a captcha: $it.\nIs the RdvMedecins JSON server running (port 8080)?", Modifier.padding(12.dp))
            }
        }
        val c = captcha
        if (c != null && !loading) {
            SvgImage(
                c.svg,
                height = 60.dp,
                modifier = Modifier.border(1.dp, Color(0xFFE0E0E0), RoundedCornerShape(6.dp)).padding(4.dp),
            )
            Spacer(Modifier.height(8.dp))
            Text("id: ${c.id}", fontFamily = FontFamily.Monospace, fontSize = 11.sp)
        }
        Spacer(Modifier.height(12.dp))
        Button(onClick = { demand++ }, enabled = !loading) { Text("Another image") }
        Spacer(Modifier.height(8.dp))
        Text("$requestCount successful request(s)", color = Color.Gray)
    }
}
  • Linha 66: um cliente HTTP, objeto caro de criar, que é criado UMA ÚNICA VEZ;
  • Linhas 69–71: a requisição, uma função SUSPEND. A requisição ([Request]) é descrita; o cliente a executa ([newCall(...).execute()]) e retorna a resposta: seu código de status, cabeçalhos e corpo. [execute()] BLOQUEIA até a resposta: o [Android] proíbe chamá-lo na thread de execução da tela ([NetworkOnMainThreadException]). [withContext(Dispatchers.IO)] o executa em uma thread reservada para E/S, e a corrotina ESPERA pelo resultado;
  • Linhas 74–75: o [OkHttp] não lança uma exceção para uma resposta de erro (4xx, 5xx); em vez disso, é preciso verificar o código de status. No entanto, ele lança uma [IOException] se não houver nenhuma resposta (servidor fora do ar, endereço incorreto);
  • linhas 77–78: o corpo JSON, lido “manualmente”: [jsonObject], [jsonPrimitive.content];
  • linhas 103–116: a requisição é disparada por um [LaunchedEffect] cuja chave é um número de REQUISIÇÃO: o botão “Outra imagem” o incrementa, o que reinicia o efeito. Se uma requisição chegar antes de a anterior ter respondido, a corrotina anterior é CANCELADA: sua resposta, agora obsoleta, nunca será exibida;
  • linhas 122–136: três estados a exibir: em andamento (uma barra de progresso), erro e sucesso.

A imagem do CAPTCHA está no formato SVG, que o [Android] não consegue exibir por si só: a biblioteca [AndroidSVG] a renderiza em uma imagem ([Bitmap]):

// =========================================================================
// common/SvgImage.kt - desenhar uma imagem SVG fornecida como texto
// -------------------------------------------------------------------------
// A imagem do captcha é feita pelo servidor, em formato SVG (um texto
// que descreve um desenho). O Android não consegue exibi-la sozinho: a
// biblioteca AndroidSVG a desenha em uma imagem (um Bitmap), que
// o Compose exibe com o componente Image.
// =========================================================================
package fr.stahe.examples.common

import android.graphics.Bitmap
import android.graphics.Canvas
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.height
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import com.caverock.androidsvg.SVG

@Composable
fun SvgImage(svg: String, modifier: Modifier = Modifier, height: Dp = 50.dp, description: String? = null) {
    // o desenho só é refeito se o texto SVG mudar (remember(svg))
    val image = remember(svg) {
        val document = SVG.getFromString(svg)
        // desenhado 3 vezes maior que seu tamanho "natural": uma imagem nítida
        val scale = 3f
        val width = (document.documentWidth.takeIf { it > 0 } ?: 150f)
        val tall = (document.documentHeight.takeIf { it > 0 } ?: 50f)
        val bitmap = Bitmap.createBitmap((width * scale).toInt(), (tall * scale).toInt(), Bitmap.Config.ARGB_8888)
        val canvas = Canvas(bitmap)
        canvas.scale(scale, scale)
        document.renderToCanvas(canvas)
        bitmap.asImageBitmap()
    }
    Image(image, contentDescription = description, contentScale = ContentScale.Fit, modifier = modifier.height(height))
}

Image

Image

Pare o servidor e clique em “Outra imagem”: o erro é exibido.

O servidor coloca o token JWT em um COOKIE. Em um navegador, cabe a ele armazenar os cookies e reenviá-los; o código da aplicação não precisa fazer nada. Em um celular, não há navegador: cabe ao aplicativo cuidar disso. O [OkHttp] faz isso, se receber um “cookie jar” ([CookieJar]):

// =========================================================================
// common/HttpClient.kt - um cliente HTTP que gerencia COOKIES
// -------------------------------------------------------------------------
// O servidor RdvMedecins coloca o token JWT em um COOKIE (httpOnly).
// Em um navegador, é o navegador que armazena os cookies e os devolve
// a cada requisição: o código da aplicação não tem nada a fazer.
// Em um celular, NÃO há navegador: cabe à aplicação
// fazer o papel dele, ou seja:
//   1. ler o cabeçalho "Set-Cookie" de cada resposta e armazenar os cookies;
//   2. devolvê-los no cabeçalho "Cookie" de cada requisição.
// A biblioteca OkHttp faz isso por nós, se lhe dermos um CookieJar
// (um "pote de cookies"): uma classe com duas funções, saveFromResponse
// (armazenar) e loadForRequest (retirar). Esta também armazena os cookies
// no dispositivo (SharedPreferences): continuamos logados quando paramos
// e reiniciamos a aplicação.
// =========================================================================
package fr.stahe.examples.common

import android.content.Context
import android.content.SharedPreferences
import androidx.core.content.edit
import okhttp3.Cookie
import okhttp3.CookieJar
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import java.util.concurrent.TimeUnit

class DeviceCookieJar(private val storage: SharedPreferences) : CookieJar {
    // nome do cookie -> o cookie (seu valor, seu domínio, sua expiração...)
    private val cookies = mutableMapOf<String, Cookie>()

    init {
        // os cookies armazenados durante um uso anterior: cada um
        // é armazenado na forma de seu cabeçalho Set-Cookie
        val base = Config.serverUrl.toHttpUrl()
        for (text in storage.getStringSet(KEY, emptySet()).orEmpty()) {
            Cookie.parse(base, text)?.let { cookies[it.name] = it }
        }
    }

    // a resposta traz cookies: nós os armazenamos. Um cookie já expirado
    // (logout: o servidor o apaga dessa forma) é removido
    @Synchronized
    override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
        for (c in cookies) {
            if (c.expiresAt < System.currentTimeMillis() || c.value.isEmpty()) {
                this.cookies.remove(c.name)
            } else {
                this.cookies[c.name] = c
            }
        }
        storage.edit { putStringSet(KEY, this@DeviceCookieJar.cookies.values.map { it.toString() }.toSet()) }
    }

    // uma requisição sai: os cookies que a ela dizem respeito (endereço, caminho), não expirados
    @Synchronized
    override fun loadForRequest(url: HttpUrl): List<Cookie> =
        cookies.values.filter { it.expiresAt >= System.currentTimeMillis() && it.matches(url) }

    companion object {
        private const val KEY = "rdvmedecins.cookies"
    }
}

// o cliente HTTP dos exemplos: um único para toda a aplicação
fun createHttpClient(context: Context): OkHttpClient = OkHttpClient.Builder()
    .cookieJar(DeviceCookieJar(context.getSharedPreferences("examples", Context.MODE_PRIVATE)))
    // nenhuma resposta após 10 segundos: a requisição falha
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(10, TimeUnit.SECONDS)
    .build()
  • linha 29: um [CookieJar] tem duas funções: [saveFromResponse] (armazenar os cookies de uma resposta) e [loadForRequest] (recuperar os de uma requisição);
  • linhas 33–38: na inicialização, os cookies armazenados durante uma sessão anterior — salvos no dispositivo ([SharedPreferences], um pequeno arquivo de chave-valor; veja o Exemplo 20) — são recuperados na forma de seu cabeçalho [Set-Cookie];
  • linhas 44–53: um cookie que já expirou ou está vazio é removido; é assim que o servidor exclui o cookie no logout; [@Synchronized]: o [OkHttp] pode chamar essas funções a partir de várias threads ao mesmo tempo;
  • linhas 67–72: o cliente HTTP dos exemplos, com seu jar e seus timeouts.

O cliente é criado uma única vez para toda a aplicação, dentro do objeto [Application] (declarado no manifesto), que o [Android] cria na inicialização, antes de qualquer activity começar:

// =========================================================================
// ExamplesApplication.kt - o objeto "application"
// -------------------------------------------------------------------------
// O Android cria UM objeto Application quando a aplicação inicia, antes de
// qualquer activity, e o mantém até ela parar (ele é declarado em
// AndroidManifest.xml, android:name=".ExamplesApplication"). É
// o lugar do que deve ser compartilhado por TODAS as activities:
// aqui, o cliente HTTP e seu cookie jar (exemplos 23 a 25). Uma
// activity o obtém com (application as ExamplesApplication).api.
// =========================================================================
package fr.stahe.examples

import android.app.Application
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.createHttpClient
import okhttp3.OkHttpClient

class ExamplesApplication : Application() {
    // by lazy: criado no primeiro acesso
    val httpClient: OkHttpClient by lazy { createHttpClient(this) }
    val api: Api by lazy { Api(httpClient) }
}

Uma ação assíncrona (fazer login, salvar etc.) tem um status que a tela deve exibir: está em andamento? Terminou com erro? Uma pequena classe cuida disso:

// =========================================================================
// ex23/Command.kt - uma AÇÃO, seu estado, seu resultado
// -------------------------------------------------------------------------
// Uma ação assíncrona (fazer login, salvar...) tem um estado que
// a tela deve mostrar: está EM ANDAMENTO (botão desabilitado)? terminou
// com um ERRO (mensagem)? É o padrão "Command", reduzido
// ao essencial:
//
//     val loginCommand = remember { Command() }
//     scope.launch { loginCommand.execute { logIn() } }    // lança a ação
//     loginCommand.inProgress, loginCommand.error          // seu estado
//
// Suas duas propriedades são estados observados pelo Compose: a tela é
// redesenhada quando a ação começa e quando termina.
// =========================================================================
package fr.stahe.examples.ex23

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import kotlinx.coroutines.CancellationException

class Command {
    var inProgress by mutableStateOf(false)
        private set
    var error by mutableStateOf<String?>(null)
        private set

    // executa a ação, se outra não estiver já em andamento
    suspend fun execute(action: suspend () -> Unit) {
        if (inProgress) return // sem envio duplo (pressionar o botão duas vezes)
        inProgress = true
        error = null
        try {
            action()
        } catch (e: CancellationException) {
            throw e // uma corotina cancelada deve permanecer cancelada
        } catch (e: Exception) {
            error = e.message ?: e.toString() // o erro é MANTIDO, para ser exibido
        } finally {
            // finally: executado em TODOS os casos, sucesso ou erro
            inProgress = false
        }
    }

    fun clearError() {
        error = null
    }
}
  • linha 31: impede o envio duplo (toque duplo no botão);
  • linhas 40–42: [finally]: executado em TODOS os casos, sucesso e erro.

A tela de login:

// =========================================================================
// ex23/Ex23Activity.kt - login no servidor RdvMedecins
// -------------------------------------------------------------------------
//   1. na inicialização: GET /api/auth/me - já estamos logados?
//      (a aplicação pode ter sido parada; o servidor, por sua vez, lê o cookie
//      que lhe é apresentado);
//   2. login: POST /api/auth/login, corpo JSON { login, password,
//      captchaId, captcha }. Em caso de sucesso, o servidor envia o cookie
//      do token JWT (cabeçalho Set-Cookie);
//   3. requisição protegida: GET /api/doctors. O cookie a acompanha;
//   4. logout: POST /api/auth/logout - o servidor apaga o cookie.
// É o cliente HTTP da aplicação (common/HttpClient.kt), com seu
// cookie jar, que armazena o cookie e o devolve.
// =========================================================================
package fr.stahe.examples.ex23

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.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.ExamplesApplication
import fr.stahe.examples.common.Config
import fr.stahe.examples.common.SvgImage
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.jsonArray
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import kotlinx.serialization.json.put
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody

// as poucas mensagens de que este exemplo precisa (o exemplo 25 usará dicionários)
val messages = mapOf(
    "LOGIN.ERROR" to "Incorrect login or password.",
    "ERRORS.WRONG_CAPTCHA" to "The characters do not match the image.",
    "ERRORS.TOO_MANY_ATTEMPTS" to "Too many failed attempts. Try again later.",
)

// uma resposta que não seja 2xx vira uma exceção, que mantém seu código e seu corpo
class ErrorResponse(val code: Int, val body: String) : Exception("the server responded $code")

// uma resposta HTTP reduzida ao que nos interessa
data class Response(val code: Int, val body: String)

class Ex23Activity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        // o cliente HTTP da aplicação, com seu cookie jar
        val client = (application as ExamplesApplication).httpClient
        setContent { ExamplesTheme { LoginPage(client) } }
    }
}

// executando uma requisição, na thread de entrada e saída
suspend fun send(client: OkHttpClient, request: Request): Response = withContext(Dispatchers.IO) {
    client.newCall(request).execute().use { Response(it.code, it.body?.string().orEmpty()) }
}

@Composable
fun LoginPage(client: OkHttpClient) {
    var user by remember { mutableStateOf<JsonObject?>(null) } // null: ninguém está logado
    var doctors by remember { mutableStateOf<JsonArray?>(null) }
    var captcha by remember { mutableStateOf<JsonObject?>(null) }
    var ready by remember { mutableStateOf(false) } // a verificação inicial terminou?
    var serverError by remember { mutableStateOf<String?>(null) }
    val loginCommand = remember { Command() }
    var login by remember { mutableStateOf("admin") }
    var password by remember { mutableStateOf("") }
    var captchaAnswer by remember { mutableStateOf("") }
    val scope = rememberCoroutineScope()

    fun url(path: String) = "${Config.serverUrl}/api$path"

    // uma requisição GET cujo corpo JSON queremos; uma exceção se não for 2xx
    suspend fun read(path: String): JsonElement {
        val r = send(client, Request.Builder().url(url(path)).build())
        if (r.code >= 300) throw ErrorResponse(r.code, r.body)
        return Json.parseToJsonElement(r.body)
    }

    // um POST com corpo JSON
    suspend fun post(path: String, body: JsonObject): Response =
        send(client, Request.Builder().url(url(path)).post(body.toString().toRequestBody("application/json".toMediaType())).build())

    suspend fun loadCaptcha() {
        captcha = read("/captcha").jsonObject
        captchaAnswer = ""
    }

    suspend fun loadDoctors() {
        doctors = read("/doctors").jsonArray
    }

    // 1. quem está logado? 200 -> o usuário; 401 -> ninguém
    LaunchedEffect(Unit) {
        try {
            user = read("/auth/me").jsonObject
            loadDoctors()
        } catch (e: ErrorResponse) {
            // "catch (e: Type)": captura SOMENTE este tipo de exceção
            if (e.code == 401) loadCaptcha() else serverError = "The server responded ${e.code}."
        } catch (e: java.io.IOException) {
            serverError = "Is the RdvMedecins JSON server running (${Config.serverUrl})?"
        }
        ready = true
    }

    // 2. o login: uma ação executada pelo Command, que memoriza seu erro
    suspend fun logIn() {
        val r = post(
            "/auth/login",
            buildJsonObject {
                put("login", login.trim())
                put("password", password)
                put("captchaId", captcha?.get("id")?.jsonPrimitive?.content)
                put("captcha", captchaAnswer)
            },
        )
        if (r.code != 200) {
            // o corpo JSON da resposta de erro: { statusCode, key, ... }
            val key = Json.parseToJsonElement(r.body).jsonObject["key"]!!.jsonPrimitive.content
            loadCaptcha() // cada imagem só é usada uma vez
            throw Exception("${r.code} - ${messages[key] ?: key}")
        }
        password = ""
        user = Json.parseToJsonElement(r.body).jsonObject
        loadDoctors()
    }

    // 4. o logout
    suspend fun logOut() {
        post("/auth/logout", JsonObject(emptyMap()))
        user = null
        doctors = null
        loadCaptcha()
    }

    // um texto JSON -> seu valor, sem as aspas
    fun JsonObject.text(key: String) = this[key]?.jsonPrimitive?.content.orEmpty()

    ExamplePage("Example 23 - logging in to the server") {
        val u = user
        when {
            !ready -> Text("Checking the session...", color = Color.Gray)
            // logado
            u != null -> Card(Modifier.fillMaxWidth()) {
                Column(Modifier.padding(12.dp)) {
                    Text(
                        buildAnnotatedString {
                            append("Logged in: ")
                            withStyle(SpanStyle(fontWeight = FontWeight.Bold)) { append(u.text("name")) }
                            append(" (${u.text("login")}), role ${u.text("role")}")
                        },
                    )
                    Spacer(Modifier.height(8.dp))
                    Text("GET /api/doctors", style = MaterialTheme.typography.titleSmall)
                    for (d in doctors.orEmpty()) {
                        val o = d.jsonObject
                        Text("• ${o.text("title")} ${o.text("firstName")} ${o.text("lastName")}")
                    }
                    Spacer(Modifier.height(8.dp))
                    Text("Stop then restart the application: you stay logged in.", color = Color.Gray)
                    Spacer(Modifier.height(8.dp))
                    OutlinedButton(onClick = { scope.launch { logOut() } }) { Text("Log out") }
                }
            }
            // não logado: o formulário
            serverError == null -> Card(Modifier.fillMaxWidth()) {
                Column(Modifier.padding(12.dp)) {
                    OutlinedTextField(login, { login = it }, label = { Text("Login") }, singleLine = true, modifier = Modifier.fillMaxWidth())
                    OutlinedTextField(
                        password,
                        { password = it },
                        label = { Text("Password") },
                        singleLine = true,
                        visualTransformation = PasswordVisualTransformation(),
                        modifier = Modifier.fillMaxWidth(),
                    )
                    Spacer(Modifier.height(12.dp))
                    Row(verticalAlignment = Alignment.CenterVertically) {
                        captcha?.let { SvgImage(it.text("svg"), height = 50.dp) }
                        TextButton(onClick = { scope.launch { runCatching { loadCaptcha() } } }) { Text("Another image") }
                    }
                    OutlinedTextField(
                        captchaAnswer,
                        { captchaAnswer = it },
                        label = { Text("Copy the characters of the image") },
                        singleLine = true,
                        modifier = Modifier.fillMaxWidth(),
                    )
                    Spacer(Modifier.height(16.dp))
                    // este trecho acompanha o estado do command
                    Button(onClick = { scope.launch { loginCommand.execute { logIn() } } }, enabled = !loginCommand.inProgress) {
                        Text(if (loginCommand.inProgress) "Logging in..." else "Log in")
                    }
                    loginCommand.error?.let { Text(it, color = Color.Red, modifier = Modifier.padding(top = 12.dp)) }
                    Spacer(Modifier.height(8.dp))
                    Text("Accounts: admin, pelissier, martin... (password = login).", color = Color.Gray, fontSize = 12.sp)
                }
            }
        }
        serverError?.let {
            Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFFFEBEE))) { Text(it, Modifier.padding(12.dp)) }
        }
    }
}
  • Linha 92: o cliente HTTP da aplicação ([application as ExamplesApplication]: uma conversão de tipo);
  • Linhas 138–148: na inicialização, [GET /api/auth/me]: já estamos logados? O aplicativo pode ter sido encerrado; no entanto, o cookie foi mantido no dispositivo. [catch (e: ErrorResponse)] captura APENAS esse tipo de exceção; um 401 significa “não autorizado”;
  • linhas 152–170: [POST /api/auth/login], corpo JSON gerado por [buildJsonObject]. Se a tentativa falhar, o corpo da resposta fornece o código do erro; um novo CAPTCHA é solicitado (cada imagem é usada apenas uma vez);
  • linhas 174–178: logout, [POST /api/auth/logout]: o servidor exclui o cookie;
  • linha 182: uma função de extensão LOCAL, para ler texto de um objeto JSON;
  • linhas 236–239: o botão acompanha o estado do comando.

Image

Image

Image

Pare o aplicativo (removendo-o da lista de aplicativos recentes) e reinicie o exemplo: você continua logado.

9.3. Exemplo 24: Uma camada de acesso à API

O Exemplo 23 repete as mesmas etapas para cada requisição: endereço do servidor, prefixo [/api], corpo JSON, verificação do código de status e leitura do corpo do erro. Elas são reunidas em três camadas. A primeira camada executa uma requisição e converte QUALQUER erro em uma única classe de exceção:

// =========================================================================
// common/ApiError.kt - UMA classe para todos os erros da API
// -------------------------------------------------------------------------
// Todas as respostas de erro do servidor RdvMedecins têm a mesma forma:
//   { "statusCode": 409, "key": "ERRORS.LOGIN_TAKEN", "params": {...}, "fields": {...} }
// Mas uma requisição também pode falhar DE OUTRO MODO: nenhuma resposta
// (rede fora do ar, servidor parado, endereço errado), ou uma resposta que não
// vem do nosso servidor (uma página de erro de um proxy). Convertemos
// tudo isso em UMA classe de exceção, ApiError, que carrega a chave de tradução
// enviada pelo servidor (e, se houver, seus parâmetros e
// o erro de cada campo).
// =========================================================================
package fr.stahe.examples.common

import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonObject

class ApiError(
    val statusCode: Int, // 0: o servidor não respondeu
    val key: String, // ex.: "ERRORS.LOGIN_TAKEN"
    val params: Map<String, String> = emptyMap(),
    val fields: Map<String, String> = emptyMap(),
) : Exception("$statusCode $key") {

    override fun toString() = "$statusCode $key"

    // companion object: o que pertence à CLASSE (o "static" do Java)
    companion object {
        // uma resposta de erro (4xx, 5xx) -> um ApiError
        fun fromResponse(statusCode: Int, body: String): ApiError {
            // runCatching: o resultado, ou null se o corpo não for JSON
            // (então não foi o nosso servidor que respondeu)
            val json = runCatching { Json.parseToJsonElement(body).jsonObject }.getOrNull()
            val key = (json?.get("key") as? JsonPrimitive)?.content
            if (json == null || key == null) {
                return ApiError(statusCode, if (statusCode >= 500) "ERRORS.SERVER_UNREACHABLE" else "ERRORS.SERVER_ERROR")
            }
            return ApiError(statusCode, key, strings(json["params"]), strings(json["fields"]))
        }

        // um objeto JSON { "name": "ERRORS..." } -> Map<String, String> (vazio caso contrário)
        private fun strings(json: Any?): Map<String, String> =
            (json as? JsonObject)?.mapValues { (_, v) -> (v as? JsonPrimitive)?.content ?: v.toString() } ?: emptyMap()
    }
}
// =========================================================================
// common/Api.kt - requisições à API, em uma linha
// -------------------------------------------------------------------------
// No exemplo 23, cada requisição repete as mesmas etapas: endereço do
// servidor, prefixo /api, corpo JSON, teste do código de status, leitura do
// corpo de erro... Elas são agrupadas aqui:
//
//   val json = api.get("/doctors")
//   api.post("/appointments", buildJsonObject { put("day", day); put("slotId", 3) })
//
//   - em caso de sucesso, a função devolve o corpo JSON (um JsonElement:
//     um objeto, um array...), ou null para um corpo vazio;
//   - em caso de falha, ela lança um ApiError.
// São funções SUSPEND: esperam a resposta do servidor sem
// bloquear o celular. A requisição em si é executada em uma thread
// reservada para entrada e saída (Dispatchers.IO): o Android
// proíbe acesso à rede na thread da tela.
// Todas as requisições passam pela função request: é o lugar onde
// um problema COMUM a todas elas seria tratado (cf. o estudo de caso e a
// resposta 401). Usado pelos exemplos 24 e 25.
// =========================================================================
package fr.stahe.examples.common

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException

class Api(private val client: OkHttpClient) {

    suspend fun request(method: String, url: String, body: JsonElement? = null): JsonElement? =
        withContext(Dispatchers.IO) {
            // um corpo JSON (o servidor rejeita um POST que não tenha um)
            val httpBody = body?.toString()?.toRequestBody("application/json".toMediaType())
            val request = Request.Builder().url("${Config.serverUrl}/api$url").method(method, httpBody).build()
            try {
                // use: a resposta é fechada (liberada) ao final do bloco
                client.newCall(request).execute().use { response ->
                    val text = response.body?.string().orEmpty()
                    if (!response.isSuccessful) throw ApiError.fromResponse(response.code, text)
                    if (text.isEmpty()) null else Json.parseToJsonElement(text)
                }
            } catch (e: IOException) {
                // NENHUMA resposta (rede, servidor parado, endereço errado)
                throw ApiError(0, "ERRORS.SERVER_UNREACHABLE")
            }
        }

    suspend fun get(url: String) = request("GET", url)

    // um POST sempre tem corpo JSON: {} por padrão
    suspend fun post(url: String, body: JsonElement = JsonObject(emptyMap())) = request("POST", url, body)

    suspend fun put(url: String, body: JsonElement) = request("PUT", url, body)

    suspend fun delete(url: String, body: JsonElement? = null) = request("DELETE", url, body)
}
  • linhas 37–47: em caso de sucesso, a função retorna o corpo JSON ([JsonElement]), ou [null] para um corpo vazio; em caso de falha, um [ApiError];
  • linhas 55–62: atalhos por método HTTP.

Os objetos JSON trocados tornam-se classes [Kotlin] e [@Serializable]:

// =========================================================================
// common/Types.kt - os objetos JSON trocados com a API RdvMedecins
// (cf. o capítulo sobre a caixa-preta, que descreve cada rota)
// -------------------------------------------------------------------------
// Cada classe é @Serializable: o plugin kotlinx.serialization escreve
// para ela o código que a constrói a partir do JSON. A leitura VERIFICA a
// forma do JSON recebido: um campo ausente ou de tipo errado lança uma
// exceção no recebimento, e não depois, no meio da exibição.
//     val u = json.decodeFromJsonElement<User>(response)
// Um campo OPCIONAL tem um valor padrão (login: String? = null).
// =========================================================================
package fr.stahe.examples.common

import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.serializer

enum class Role { ADMIN, DOCTOR, USER }

// POST /api/auth/login, GET /api/auth/me
@Serializable
data class User(val login: String, val name: String, val role: Role)

// GET /api/captcha
@Serializable
data class Captcha(val id: String, val svg: String)

// um médico ou um cliente (GET /api/doctors, GET /api/clients...)
@Serializable
data class Person(
    val id: Int,
    val version: Int,
    val title: String,
    val firstName: String,
    val lastName: String,
    val login: String? = null, // somente para o ADMIN
) {
    val fullName get() = "$title $firstName $lastName"
}

// o nome de uma pessoa, nada mais
@Serializable
data class Identity(val title: String, val firstName: String, val lastName: String) {
    override fun toString() = "$title $firstName $lastName"
}

// uma linha de GET /api/schedule
@Serializable
data class ScheduleSlot(
    val id: Int,
    val startHour: Int,
    val startMinute: Int,
    val endHour: Int,
    val endMinute: Int,
    val free: Boolean,
    val patient: Identity?,
    val mine: Boolean,
    val bookable: Boolean,
    val appointmentId: Int?,
) {
    // "8:00 - 8:20"
    val timeRange: String
        get() {
            fun hm(h: Int, m: Int) = "$h:${m.toString().padStart(2, '0')}"
            return "${hm(startHour, startMinute)} - ${hm(endHour, endMinute)}"
        }
}

// GET /api/schedule?doctorId=...&day=...
@Serializable
data class Schedule(val doctor: Person, val day: String, val slots: List<ScheduleSlot>, val info: String?)

// o leitor JSON: ignoreUnknownKeys, os campos que o cliente não usa
// são ignorados (o servidor pode adicionar alguns sem quebrar o cliente)
val apiJson = Json { ignoreUnknownKeys = true }

// JsonElement -> objeto Kotlin: uma função genérica "reified" (o tipo T
// é conhecido em tempo de execução); serializer<T>(): o código escrito pelo plugin
inline fun <reified T> JsonElement?.read(): T =
    apiJson.decodeFromJsonElement(serializer<T>(), this ?: throw IllegalStateException("empty response"))
  • linha 37: um campo opcional tem um valor padrão; [Identity?]: um objeto ou [null];
  • linha 76: [ignoreUnknownKeys]: os campos que o cliente não usa são ignorados (o servidor pode adicioná-los sem quebrar o cliente);
  • linhas 80–81: uma função de extensão GENÉRICA é “reificada” ([reified]: o tipo [T] é conhecido em tempo de execução, o que é permitido por [inline]). [serializer<T>()]: o código escrito pelo plugin para [T]. A leitura VERIFICA o formato do JSON: um campo ausente ou de tipo errado lança uma exceção no momento do recebimento, e não depois, no meio da exibição.

A segunda camada: uma função com tipagem segura para cada rota da API. As telas não conhecem mais a URL, o [OkHttp] nem o JSON. É o equivalente, no lado do cliente, da camada DAO do lado do servidor; no guia de arquitetura do [Android], um “repositório”:

// =========================================================================
// ex24/RdvMedecins.kt - a camada de acesso à API
// -------------------------------------------------------------------------
// Uma função tipada por rota da API. As telas não conhecem nem as
// URLs, nem o OkHttp, nem o formato JSON: elas chamam funções que
// devolvem objetos Kotlin (Person, Schedule...).
// É o equivalente, no lado cliente, da camada DAO do servidor: se a API
// mudar (uma URL, um nome de campo), só este arquivo é modificado. No
// guia de arquitetura do Android, é um "repository".
// =========================================================================
package fr.stahe.examples.ex24

import android.net.Uri
import fr.stahe.examples.common.Schedule
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.Person
import fr.stahe.examples.common.read
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put

class RdvMedecins(private val api: Api) {
    suspend fun getDoctors(): List<Person> = api.get("/doctors").read()

    suspend fun getClients(): List<Person> = api.get("/clients").read()

    // Uri.Builder constrói "doctorId=1&day=2030-01-15", codificando o que for necessário
    suspend fun getSchedule(doctorId: Int, day: String): Schedule {
        val params = Uri.Builder()
            .appendQueryParameter("doctorId", "$doctorId")
            .appendQueryParameter("day", day)
            .build().encodedQuery
        return api.get("/schedule?$params").read()
    }

    // clientId: opcional; a chave só é colocada no JSON se não for null
    suspend fun book(day: String, slotId: Int, clientId: Int? = null) {
        api.post(
            "/appointments",
            buildJsonObject {
                put("day", day)
                put("slotId", slotId)
                if (clientId != null) put("clientId", clientId)
            },
        )
    }

    suspend fun cancelAppointment(appointmentId: Int) {
        api.delete("/appointments/$appointmentId")
    }
}
  • linha 22: [api.get("/doctors").read()]: o tipo esperado, [List<Person>], é inferido a partir do tipo de retorno da função;
  • linhas 28–31: [Uri.Builder] constrói a string de parâmetros, codificando as informações necessárias.

A terceira camada: o estado e as ações da tela, em um [ViewModel] (veja o Exemplo 20). Desta vez, o estado consiste em propriedades do [Compose] ([mutableStateOf]), mais fáceis de ler do que um [StateFlow] quando apenas a tela as observa:

// =========================================================================
// ex24/ScheduleModel.kt - o "view model" da tela
// -------------------------------------------------------------------------
// O guia de arquitetura do Android recomenda separar:
//   - a VIEW: as funções @Composable, que exibem e repassam as ações
//     do usuário;
//   - o VIEW MODEL (ViewModel): o estado da tela (o médico escolhido,
//     o dia, a agenda recebida...), as ações (escolher, marcar, cancelar),
//     e as chamadas à camada de acesso à API.
// A view deixa de ter lógica: é fácil de ler; o view model
// não tem componentes: é fácil de testar. E ele sobrevive à
// recriação da activity (rotação da tela).
// As ações lançam suas corrotinas em viewModelScope: elas são
// canceladas se o ViewModel for destruído (activity fechada de vez).
//
// Ele também faz o que não queremos reescrever para cada tela:
//   - um CACHE: a agenda de cada (médico, dia) já lida é mantida; voltar
//     a ela a exibe imediatamente, enquanto é lida de novo em segundo plano;
//   - as respostas OBSOLETAS são ignoradas: uma nova leitura CANCELA a
//     anterior (cf. exemplo 19).
// =========================================================================
package fr.stahe.examples.ex24

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import fr.stahe.examples.common.Schedule
import fr.stahe.examples.common.ScheduleSlot
import fr.stahe.examples.common.ApiError
import fr.stahe.examples.common.Person
import fr.stahe.examples.common.Role
import fr.stahe.examples.common.User
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch
import java.time.LocalDate

// uma mensagem exibida ao usuário
data class Message(val success: Boolean, val text: String)

class ScheduleModel(private val rdvmedecins: RdvMedecins) : ViewModel() {
    // ---- o estado: states do Compose, modificáveis somente aqui ----
    var user by mutableStateOf<User?>(null)
        private set
    var doctors by mutableStateOf(listOf<Person>())
        private set
    var clients by mutableStateOf(listOf<Person>())
        private set
    var doctorId by mutableStateOf<Int?>(null)
        private set
    var day by mutableStateOf(LocalDate.now().plusDays(1).toString()) // amanhã, "2026-10-06"
        private set
    var clientId by mutableStateOf<Int?>(null)
        private set
    var schedule by mutableStateOf<Schedule?>(null)
        private set
    var loading by mutableStateOf(false)
        private set
    var message by mutableStateOf<Message?>(null)
        private set
    private val cache = mutableMapOf<String, Schedule>()
    private var reading: Job? = null

    // ---- valores calculados ----
    val loggedIn get() = user != null
    val isManager get() = user.let { it != null && it.role != Role.USER }

    // ---- as ações ----
    fun changeUser(u: User?) {
        user = u
        doctors = emptyList()
        clients = emptyList()
        schedule = null
        doctorId = null
        cache.clear() // os direitos mudaram: tudo é esquecido
        if (u == null) return
        viewModelScope.launch {
            try {
                doctors = rdvmedecins.getDoctors()
                if (isManager) clients = rdvmedecins.getClients() // um USER receberia 403
            } catch (e: ApiError) {
                message = Message(false, e.toString())
            }
        }
    }

    fun chooseDoctor(id: Int?) {
        doctorId = id
        message = null
        readSchedule()
    }

    fun chooseDay(d: LocalDate) {
        day = d.toString()
        message = null
        readSchedule()
    }

    fun chooseClient(id: Int?) {
        clientId = id
    }

    fun book(s: ScheduleSlot) = act("Slot ${s.timeRange} booked.") {
        rdvmedecins.book(day, s.id, if (isManager) clientId else null)
    }

    fun cancel(s: ScheduleSlot) = act("Appointment at ${s.timeRange} cancelled.") { rdvmedecins.cancelAppointment(s.appointmentId!!) }

    // uma ação, e SEMPRE uma nova leitura da agenda: o SERVIDOR é a referência
    private fun act(success: String, action: suspend () -> Unit) {
        viewModelScope.launch {
            message = try {
                action()
                Message(true, success)
            } catch (e: ApiError) {
                Message(false, e.toString())
            }
            readSchedule()
        }
    }

    private fun readSchedule() {
        val id = doctorId ?: return
        val key = "$id/$day"
        // uma leitura mais antiga ainda está em andamento: ela é cancelada
        reading?.cancel()
        // primeiro o cache (ou nada), depois a leitura
        schedule = cache[key]
        loading = true
        reading = viewModelScope.launch {
            try {
                val read = rdvmedecins.getSchedule(id, day)
                cache[key] = read
                schedule = read
            } catch (e: ApiError) {
                schedule = null
                message = Message(false, e.toString())
            }
            loading = false
        }
    }
}
  • linhas 44–62: o estado, que só pode ser modificado aqui;
  • linhas 70–83: uma troca de usuário — tudo é limpo (as permissões mudaram) e depois recarregado. [viewModelScope.launch]: uma corrotina que vive tanto quanto o [ViewModel];
  • linhas 111–119: cada ação termina SEMPRE relendo a agenda: o SERVIDOR é a versão de referência;
  • linhas 123–140: leitura da agenda: qualquer leitura anterior ainda em andamento é cancelada; o cache fornece uma resposta imediata, que é depois substituída pela resposta do servidor.

A view, que simplesmente exibe o modelo. A conexão é tratada por um componente reutilizável, a barra [common/LoginBar.kt] (o formulário do Exemplo 23, reescrito com [Api]):

// =========================================================================
// common/LoginBar.kt - login / logout, em uma barra
// -------------------------------------------------------------------------
// O formulário do exemplo 23, reduzido a uma barra e reescrito com Api.kt.
// O componente chama onUserChange com o usuário logado (ou
// null) a cada mudança - inclusive na inicialização, após
// consultar GET /api/auth/me. Usado pelos exemplos 24 e 25.
// =========================================================================
package fr.stahe.examples.common

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.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ExitToApp
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Person
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.launch
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put

@Composable
fun LoginBar(api: Api, onUserChange: (User?) -> Unit) {
    var user by remember { mutableStateOf<User?>(null) }
    var captcha by remember { mutableStateOf<Captcha?>(null) }
    var login by rememberSaveable { mutableStateOf("admin") }
    var password by rememberSaveable { mutableStateOf("") }
    var captchaAnswer by rememberSaveable { mutableStateOf("") }
    var error by remember { mutableStateOf<String?>(null) }
    val scope = rememberCoroutineScope()

    fun changeUser(u: User?) {
        user = u
        onUserChange(u)
    }

    suspend fun newCaptcha() {
        captcha = api.get("/captcha").read<Captcha>()
        captchaAnswer = ""
    }

    // na inicialização: já estamos logados?
    LaunchedEffect(Unit) {
        try {
            changeUser(api.get("/auth/me").read<User>())
        } catch (e: ApiError) {
            changeUser(null) // 401: ninguém está logado
            try {
                newCaptcha()
            } catch (e: ApiError) {
                error = "Is the JSON server running (${Config.serverUrl})?"
            }
        }
    }

    suspend fun logIn() {
        error = null
        try {
            val body = buildJsonObject {
                put("login", login.trim())
                put("password", password)
                put("captchaId", captcha?.id)
                put("captcha", captchaAnswer)
            }
            val u = api.post("/auth/login", body).read<User>()
            password = ""
            changeUser(u)
        } catch (e: ApiError) {
            error = e.toString() // "401 LOGIN.ERROR"
            runCatching { newCaptcha() }
        }
    }

    suspend fun logOut() {
        runCatching { api.post("/auth/logout") }
        changeUser(null)
        runCatching { newCaptcha() }
    }

    Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFECEFF1))) {
        val u = user
        if (u != null) {
            Row(Modifier.padding(8.dp), verticalAlignment = Alignment.CenterVertically) {
                Icon(Icons.Default.Person, contentDescription = null)
                Spacer(Modifier.width(8.dp))
                Text("${u.name} (${u.role})", Modifier.weight(1f))
                TextButton(onClick = { scope.launch { logOut() } }) {
                    Icon(Icons.AutoMirrored.Filled.ExitToApp, contentDescription = null)
                    Text("Log out")
                }
            }
        } else {
            Column(Modifier.padding(8.dp)) {
                Row {
                    OutlinedTextField(login, { login = it }, label = { Text("login") }, singleLine = true, modifier = Modifier.weight(1f))
                    Spacer(Modifier.width(8.dp))
                    OutlinedTextField(
                        password,
                        { password = it },
                        label = { Text("password") },
                        singleLine = true,
                        visualTransformation = PasswordVisualTransformation(),
                        modifier = Modifier.weight(1f),
                    )
                }
                Row(verticalAlignment = Alignment.CenterVertically) {
                    // a imagem SVG do captcha, feita pelo NOSSO servidor (cf. exemplo 22)
                    captcha?.let { SvgImage(it.svg, height = 40.dp) }
                    Spacer(Modifier.width(8.dp))
                    OutlinedTextField(captchaAnswer, { captchaAnswer = it }, label = { Text("captcha") }, singleLine = true, modifier = Modifier.weight(1f))
                    IconButton(onClick = { scope.launch { logIn() } }) {
                        Icon(Icons.Default.Check, contentDescription = "Log in")
                    }
                }
                error?.let { Text(it, color = Color.Red) }
            }
        }
    }
}
// =========================================================================
// ex24/Ex24Activity.kt - uma agenda, com a camada de acesso à API
// -------------------------------------------------------------------------
// Faça login (barra superior), escolha um médico e um dia:
// a agenda é exibida. ADMIN e DOCTOR podem marcar consulta para um paciente e
// cancelar; um paciente (martin...) marca para si mesmo. Cada ação
// termina com uma nova leitura da agenda.
// Três camadas, de baixo para cima:
//   Api (common/Api.kt)               as requisições HTTP, os erros;
//   RdvMedecins (RdvMedecins.kt)      uma função tipada por rota da API;
//   ScheduleModel (ScheduleModel.kt)  o estado e as ações da tela;
// e a view, abaixo, que apenas exibe o modelo.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)

package fr.stahe.examples.ex24

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.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AddCircle
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.DatePicker
import androidx.compose.material3.DatePickerDialog
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.SuggestionChipDefaults
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberDatePickerState
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.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import fr.stahe.examples.ExamplesApplication
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.LoginBar
import fr.stahe.examples.common.ScheduleSlot
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset

class Ex24Activity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        val api = (application as ExamplesApplication).api
        setContent { ExamplesTheme { SchedulePage(api) } }
    }
}

@Composable
fun SchedulePage(api: Api) {
    // viewModel { ... }: o modelo da activity, criado por este bloco no
    // primeiro acesso (ele precisa de um parâmetro: a camada de acesso à API)
    val model = viewModel { ScheduleModel(RdvMedecins(api)) }
    var calendarOpen by remember { mutableStateOf(false) }

    ExamplePage("Example 24 - an API access layer") {
        LoginBar(api, onUserChange = { model.changeUser(it) })
        if (model.loggedIn) {
            DropdownList(
                label = "Doctor",
                value = model.doctorId,
                choices = listOf<Int?>(null) + model.doctors.map { it.id },
                text = { id -> model.doctors.find { it.id == id }?.fullName ?: "-- choose a doctor --" },
                onChange = { model.chooseDoctor(it) },
                modifier = Modifier.fillMaxWidth(),
            )
            Row(verticalAlignment = Alignment.CenterVertically) {
                Text("Day: ${model.day}")
                IconButton(onClick = { calendarOpen = true }) { Icon(Icons.Default.DateRange, contentDescription = "choose the day") }
            }
            if (model.isManager) {
                DropdownList(
                    label = "Patient",
                    value = model.clientId,
                    choices = listOf<Int?>(null) + model.clients.map { it.id },
                    text = { id -> model.clients.find { it.id == id }?.fullName ?: "-- patient to book for --" },
                    onChange = { model.chooseClient(it) },
                    modifier = Modifier.fillMaxWidth(),
                )
            }
            model.message?.let { m ->
                Card(colors = CardDefaults.cardColors(containerColor = if (m.success) Color(0xFFE8F5E9) else Color(0xFFFFEBEE))) {
                    Text(m.text, Modifier.padding(10.dp))
                }
            }
            if (model.loading) LinearProgressIndicator(Modifier.fillMaxWidth())
            model.schedule?.let { schedule ->
                // info: a chave enviada pelo servidor quando um paciente já tem uma consulta futura
                schedule.info?.let { Text(it, color = Color(0xFF1976D2)) }
                Text(
                    "Schedule of ${schedule.day} - ${schedule.doctor.fullName}",
                    style = MaterialTheme.typography.titleSmall,
                    modifier = Modifier.padding(vertical = 8.dp),
                )
                for (s in schedule.slots) {
                    SlotRow(s, onBook = { model.book(s) }, onCancel = { model.cancel(s) })
                }
            }
        }
    }

    if (calendarOpen) {
        val state = rememberDatePickerState(
            initialSelectedDateMillis = LocalDate.parse(model.day).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(),
        )
        DatePickerDialog(
            onDismissRequest = { calendarOpen = false },
            confirmButton = {
                TextButton(onClick = {
                    state.selectedDateMillis?.let { model.chooseDay(Instant.ofEpochMilli(it).atZone(ZoneOffset.UTC).toLocalDate()) }
                    calendarOpen = false
                }) { Text("OK") }
            },
        ) { DatePicker(state = state) }
    }
}

// uma linha da agenda: o intervalo de horário, o ocupante, os botões permitidos
@Composable
fun SlotRow(s: ScheduleSlot, onBook: () -> Unit, onCancel: () -> Unit) {
    ListItem(
        leadingContent = { Text(s.timeRange, Modifier.width(96.dp)) },
        headlineContent = {
            if (s.free) {
                SuggestionChip(
                    onClick = {},
                    label = { Text("Free") },
                    colors = SuggestionChipDefaults.suggestionChipColors(containerColor = Color(0xFFC8E6C9)),
                )
            } else {
                SuggestionChip(
                    onClick = {},
                    label = { Text(s.patient?.toString() ?: "Booked") },
                    colors = SuggestionChipDefaults.suggestionChipColors(
                        containerColor = if (s.mine) Color(0xFFC5CAE9) else Color(0xFFE0E0E0),
                    ),
                )
            }
        },
        // os botões seguem os direitos calculados pelo servidor
        trailingContent = {
            when {
                s.bookable -> IconButton(onClick = onBook) {
                    Icon(Icons.Default.AddCircle, contentDescription = "Book", tint = Color(0xFF2E7D32))
                }
                s.appointmentId != null -> IconButton(onClick = onCancel) {
                    Icon(Icons.Default.Close, contentDescription = "Cancel", tint = Color.Red)
                }
            }
        },
    )
}
  • linha 79: [viewModel [ ... ]]: o modelo, criado por este bloco na primeira solicitação (ele exige um parâmetro);
  • linhas 86–90: a lista de médicos: suas opções são [Int?] e [null] para “-- escolha um médico --”;
  • linhas 169–172: os botões de cada linha correspondem às permissões CALCULADAS PELO SERVIDOR ([bookable], [appointmentId]).

Image

Image

Image

À esquerda e no meio, o ADMIN reserva o primeiro horário para Jean MARTIN; à direita, logado como [martin]: o servidor definiu [bookable] como [false] para todos os horários, porque esse paciente já tem uma consulta futura, como indica a chave [SCHEDULE.ALREADY_BOOKED_INFO]. Essa chave bruta não é muito significativa: o Exemplo 25 traduz as chaves do servidor.

9.4. Exemplo 25: Erros retornados pelo servidor

O servidor valida TUDO o que recebe (veja o Exemplo 07) e responde, em caso de rejeição, com um JSON de erro, que fornece a chave da mensagem geral e a chave de erro de CADA campo:

1
2
3
400 { key: 'ERRORS.INVALID_FORM', fields: { lastName: 'ERRORS.LASTNAME_REQUIRED' } }
409 { key: 'ERRORS.PATIENT_ALREADY_EXISTS', fields: { firstName: ..., lastName: ... } }
409 { key: 'ERRORS.CONCURRENT_UPDATE' }

Existem muitas dessas chaves. Os clientes do servidor — [Vue.js], [Angular], [React], e [Flutter] — as traduzem usando dicionários JSON, um por idioma. Em vez de copiar essas centenas de textos para arquivos [strings.xml] (e escrever a tabela chave → recurso do Exemplo 21), reutilizamos esses dicionários como estão, armazenados na pasta [assets/] do aplicativo: arquivos incluídos no aplicativo, lidos por seu caminho ([assets/i18n/ex25_fr.json], [ex25_en.json]):

// =========================================================================
// ex25/Dictionary.kt - os dicionários compartilhados com os outros clientes
// -------------------------------------------------------------------------
// O servidor RdvMedecins só devolve CHAVES ("ERRORS.LOGIN_TAKEN"),
// em grande quantidade: as mensagens de erro de cada campo, de cada
// rota... Os clientes web (Vue.js, Angular, React) e Flutter deste
// servidor as traduzem com DICIONÁRIOS JSON, um por idioma, onde
// cada texto tem sua chave:
//     { "ERRORS": { "LOGIN_TAKEN": "Este login já está em uso..." } }
// Em vez de copiar esses centenas de textos para arquivos strings.xml (e
// escrever a tabela chave -> recurso do exemplo 21), reutilizamos esses
// dicionários como estão. Eles ficam na pasta assets/ da
// aplicação: arquivos distribuídos com ela, lidos pelo seu caminho.
//   - t("FORM.ADDED", mapOf("name" to "Marie DUPONT")): o texto do
//     idioma atual, cujos parâmetros {{name}} são substituídos;
//   - uma chave desconhecida é exibida como está: vemos o que falta.
// O idioma continua sendo o da APLICAÇÃO (exemplo 21): o dicionário
// é escolhido de acordo com ele.
// =========================================================================
package fr.stahe.examples.ex25

import android.content.Context
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.platform.LocalContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive

class Dictionary(context: Context, file: String) {
    // o conteúdo do arquivo JSON, lido uma vez por todas
    private val root: JsonObject = context.assets.open(file).bufferedReader().use { reader ->
        Json.parseToJsonElement(reader.readText()) as JsonObject
    }

    // "FORM.ADDED" -> root["FORM"]["ADDED"]; null se ausente
    private fun find(key: String): String? {
        var node: JsonElement? = root
        for (part in key.split('.')) {
            node = (node as? JsonObject)?.get(part)
        }
        return (node as? JsonPrimitive)?.takeIf { it.isString }?.content
    }

    fun t(key: String, params: Map<String, String> = emptyMap()): String {
        val text = find(key) ?: return key
        // {{name}} -> o valor do parâmetro name (ou {{name}} se não for fornecido)
        return Regex("\\{\\{(\\w+)\\}\\}").replace(text) { m -> params[m.groupValues[1]] ?: m.value }
    }
}

// o dicionário do idioma atual: assets/i18n/<prefix>_<language>.json
@Composable
fun rememberDictionary(prefix: String): Dictionary {
    val context = LocalContext.current
    val language = LocalConfiguration.current.locales[0].language.let { if (it == "fr") "fr" else "en" }
    // lido de novo somente se o idioma mudar
    return remember(language) { Dictionary(context, "i18n/${prefix}_$language.json") }
}
  • linhas 34–35: o arquivo JSON, lido uma vez por todas ([context.assets.open]);
  • linhas 39–48: ["FORM.ADDED"] → [root["FORM"]["ADDED"]]; uma chave desconhecida é exibida como está: assim vemos o que está faltando;
  • linha 50: os parâmetros [{{name}}] são substituídos por uma expressão regular;
  • linhas 56–60: o dicionário do idioma do APLICATIVO (exemplo 21), relido somente se ele mudar.

O modelo da tela: este formulário não faz nenhuma validação no celular; tudo é enviado ao servidor.

// =========================================================================
// ex25/ClientsModel.kt - o estado da tela de clientes
// -------------------------------------------------------------------------
// Este formulário DELIBERADAMENTE não faz nenhuma validação no celular:
// tudo é enviado ao servidor, que responde, em caso de recusa, com um erro
// JSON (convertido em ApiError por common/Api.kt):
//
//   400 { key: 'ERRORS.INVALID_FORM', fields: { lastName: 'ERRORS.LASTNAME_REQUIRED' } }
//   409 { key: 'ERRORS.PATIENT_ALREADY_EXISTS', fields: { firstName: ..., lastName: ... } }
//   409 { key: 'ERRORS.CONCURRENT_UPDATE' }         (bloqueio otimista)
//
// O erro de CADA campo (ApiError.fields) é armazenado no estado e
// exibido sob o campo; sua mensagem é a CHAVE enviada pelo servidor,
// que a tela traduz. Modificar um campo apaga seu erro.
// O estado fica em um ViewModel: trocar o idioma RECRIA a activity
// (cf. exemplo 21), e o que está sendo digitado não deve ser perdido.
// =========================================================================
package fr.stahe.examples.ex25

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.ApiError
import fr.stahe.examples.common.Person
import fr.stahe.examples.common.Role
import fr.stahe.examples.common.User
import fr.stahe.examples.common.read
import fr.stahe.examples.ex23.Command
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put

// uma mensagem a traduzir: uma chave e seus parâmetros
data class KeyMessage(val key: String, val params: Map<String, String> = emptyMap())

class ClientsModel(private val api: Api) : ViewModel() {
    var user by mutableStateOf<User?>(null)
        private set
    var clients by mutableStateOf(listOf<Person>())
        private set

    // o formulário: editedId == null -> criação, caso contrário atualização
    var editedId by mutableStateOf<Int?>(null)
        private set
    private var version = 0

    // os valores digitados, por nome de campo (os nomes esperados pelo servidor)
    var input by mutableStateOf(empty)
        private set

    // o erro de cada campo (uma CHAVE de tradução), devolvido pelo servidor
    var errors by mutableStateOf(mapOf<String, String>())
        private set

    // a mensagem geral do último erro, e a de um sucesso
    var pageError by mutableStateOf<ApiError?>(null)
        private set
    var success by mutableStateOf<KeyMessage?>(null)
        private set

    // envio ao servidor: um Command (exemplo 23), que diz se está em andamento
    val sending = Command()

    val isAdmin get() = user?.role == Role.ADMIN

    suspend fun onUserChange(u: User?) {
        user = u
        clients = emptyList()
        if (u?.role == Role.ADMIN) reload()
    }

    private suspend fun reload() {
        clients = try {
            api.get("/clients").read()
        } catch (e: ApiError) {
            emptyList()
        }
    }

    private fun clearMessages() {
        errors = emptyMap()
        pageError = null
        success = null
    }

    // um campo modificado: seu valor muda, seu erro desaparece
    fun change(field: String, value: String) {
        input = input + (field to value)
        errors = errors - field
    }

    fun newForm() {
        editedId = null
        version = 0
        input = empty
        clearMessages()
    }

    fun edit(c: Person) {
        editedId = c.id
        // a VERSÃO lida com o registro volta com a atualização: se
        // alguém modificou o registro nesse meio tempo, o servidor responderá 409
        // CONCURRENT_UPDATE
        version = c.version
        input = mapOf("title" to c.title, "firstName" to c.firstName, "lastName" to c.lastName, "login" to (c.login ?: ""), "password" to "")
        clearMessages()
    }

    suspend fun save() {
        clearMessages()
        val body = buildJsonObject {
            for ((field, value) in input) put(field, value)
            put("version", version)
        }
        try {
            val id = editedId
            val client: Person = (if (id == null) api.post("/clients", body) else api.put("/clients/$id", body)).read()
            val key = if (id == null) "FORM.ADDED" else "FORM.UPDATED"
            newForm() // formulário esvaziado, mensagens apagadas...
            // ... exceto esta
            success = KeyMessage(key, mapOf("name" to "${client.firstName} ${client.lastName}", "login" to (client.login ?: "")))
            reload()
        } catch (e: ApiError) {
            pageError = e // a mensagem geral
            errors = e.fields // o erro de cada campo
        }
    }

    suspend fun remove(c: Person) {
        clearMessages()
        try {
            api.delete("/clients/${c.id}")
            success = KeyMessage("FORM.DELETED", mapOf("name" to "${c.firstName} ${c.lastName}"))
        } catch (e: ApiError) {
            pageError = e
        }
        reload()
    }

    companion object {
        val empty = mapOf("title" to "Mr", "firstName" to "", "lastName" to "", "login" to "", "password" to "")
    }
}
  • linhas 49–53: a entrada, por nome de campo (os nomes esperados pelo servidor), e o erro de cada campo (uma tradução);
  • linhas 88–90: modificar um campo limpa o seu erro;
  • linha 105: a VERSÃO lida do registro é reenviada com a modificação; se alguém modificou o registro nesse meio-tempo, o servidor responde com um 409 [CONCURRENT_UPDATE] (bloqueio otimista);
  • linhas 110–126: salvamento: em caso de erro, a mensagem geral e o erro de cada campo ([e.fields]) são armazenados no estado.

A tela:

// =========================================================================
// ex25/Ex25Activity.kt - exibindo os erros do SERVIDOR
// -------------------------------------------------------------------------
// O gerenciamento dos clientes (conta admin), cf. ClientsModel.kt. A tela
// exibe, sob cada campo, o erro que o servidor associou a ele,
// traduzido pelos dicionários (Dictionary.kt), e a mensagem geral
// no final do formulário.
// Experimente: um nome vazio, um título "Dr", um homônimo (Alice DURAND), um
// login já usado (martin), o mesmo registro modificado em dois dispositivos...
// =========================================================================
package fr.stahe.examples.ex25

import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.app.AppCompatDelegate
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.outlined.Delete
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
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.getValue
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.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.os.LocaleListCompat
import androidx.lifecycle.viewmodel.compose.viewModel
import fr.stahe.examples.ExamplesApplication
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.LoginBar
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.ex16.ConfirmDialog
import fr.stahe.examples.ex16.rememberConfirmation
import kotlinx.coroutines.launch

class Ex25Activity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        val api = (application as ExamplesApplication).api
        setContent { ExamplesTheme { ClientsPage(api) } }
    }
}

@Composable
fun ClientsPage(api: Api) {
    val model = viewModel { ClientsModel(api) }
    val dict = rememberDictionary("ex25")
    // um atalho: t("KEY") chama dict.t("KEY")
    fun t(key: String, params: Map<String, String> = emptyMap()) = dict.t(key, params)
    val confirmation = rememberConfirmation()
    val scope = rememberCoroutineScope()
    var languageMenu by remember { mutableStateOf(false) }

    // um campo de entrada, com seu erro (uma chave do servidor) traduzido
    @Composable
    fun Field(field: String, secret: Boolean = false) {
        val error = model.errors[field]
        OutlinedTextField(
            value = model.input[field].orEmpty(),
            onValueChange = { model.change(field, it) },
            label = { Text(t("FORM.${field.uppercase()}")) },
            singleLine = true,
            isError = error != null,
            supportingText = error?.let { e -> { Text(t(e)) } },
            visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None,
            modifier = Modifier.fillMaxWidth(),
        )
    }

    ExamplePage(
        title = t("FORM.PAGE_TITLE"),
        // o idioma: um menu
        actions = {
            IconButton(onClick = { languageMenu = true }) { Icon(Icons.Default.MoreVert, contentDescription = "language") }
            DropdownMenu(expanded = languageMenu, onDismissRequest = { languageMenu = false }) {
                for (l in listOf("fr", "en")) {
                    DropdownMenuItem(text = { Text(l.uppercase()) }, onClick = {
                        languageMenu = false
                        AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags(l))
                    })
                }
            }
        },
    ) {
        LoginBar(api, onUserChange = { u -> scope.launch { model.onUserChange(u) } })
        if (model.user != null && !model.isAdmin) {
            Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFFFF8E1))) {
                Text(t("FORM.ADMIN_ONLY"), Modifier.padding(12.dp))
            }
        }
        if (model.isAdmin) {
            for (c in model.clients) {
                ListItem(
                    headlineContent = { Text(c.fullName) },
                    supportingContent = { Text(c.login ?: "") },
                    trailingContent = {
                        Row {
                            IconButton(onClick = { model.edit(c) }) { Icon(Icons.Default.Edit, contentDescription = t("FORM.EDIT")) }
                            IconButton(onClick = {
                                scope.launch {
                                    val name = "${c.firstName} ${c.lastName}"
                                    if (confirmation.confirm(t("FORM.DELETE_CONFIRM", mapOf("name" to name)))) model.remove(c)
                                }
                            }) {
                                Icon(Icons.Outlined.Delete, contentDescription = t("FORM.DELETE"), tint = Color.Red)
                            }
                        }
                    },
                )
            }
            Card(Modifier.fillMaxWidth()) {
                Column(Modifier.padding(12.dp)) {
                    Text(t(if (model.editedId == null) "FORM.TITLE_ADD" else "FORM.TITLE_EDIT"), style = MaterialTheme.typography.titleMedium)
                    // um título "Dr" que o servidor rejeitará: para ver ERRORS.INVALID_TITLE
                    DropdownList(
                        label = t("FORM.TITLE"),
                        value = model.input["title"].orEmpty(),
                        choices = listOf("Mr", "Mme", "Melle", "Dr"),
                        onChange = { model.change("title", it) },
                        error = model.errors["title"]?.let { t(it) },
                        modifier = Modifier.width(200.dp),
                    )
                    Field("firstName")
                    Field("lastName")
                    Field("login")
                    Field("password", secret = true)
                    Row(Modifier.padding(top = 12.dp)) {
                        Button(onClick = { scope.launch { model.sending.execute { model.save() } } }, enabled = !model.sending.inProgress) {
                            Text(t("FORM.SAVE"))
                        }
                        Spacer(Modifier.width(8.dp))
                        OutlinedButton(onClick = { model.newForm() }) { Text(t("FORM.CANCEL")) }
                    }
                    model.success?.let { s ->
                        Text(t(s.key, s.params), color = Color(0xFF2E7D32), modifier = Modifier.padding(top = 12.dp))
                    }
                    // a mensagem geral, e o status HTTP, para entender
                    model.pageError?.let { e ->
                        Text(
                            buildAnnotatedString {
                                withStyle(SpanStyle(color = Color.Red)) { append(t(e.key, e.params)) }
                                withStyle(SpanStyle(color = Color.Gray, fontSize = 12.sp)) { append("  ($e)") }
                            },
                            modifier = Modifier.padding(top = 12.dp),
                        )
                    }
                }
            }
        }
    }
    ConfirmDialog(confirmation)
}
  • linhas 79–81: o dicionário e um atalho [t(...)];
  • linhas 88–96: um campo e seu erro, uma chave do servidor, traduzida;
  • linhas 106–111: o idioma, em um menu na barra superior ([DropdownMenu]);
  • linhas 170–174: a mensagem geral e o status HTTP, para referência.

Image

Image

Image

À esquerda, um registro com nome e sobrenome em branco: erro 400; no meio, um homônimo de Alice DURAND: erro 409; à direita, o mesmo erro em francês: a entrada atual sobreviveu à recriação da activity, graças ao [ViewModel].