5. Capítulo 4 - O cliente Kotlin da aplicação RdvMedecins
5.1. Visão geral da arquitetura

Este cliente se comunica com o servidor [rdvmedecins-nestjs-server] do curso, que permanece totalmente inalterado, pelas mesmas rotas HTTP (POST [/login], GET [/getAllDoctors], GET [/getAllClients], GET [/getDoctorScheduleOfDay/:doctorId/:day], POST [/addAppointment], POST [/deleteAppointment]), com o mesmo envelope JSON [{ status, data }] e a mesma autenticação por token [JWT] (cabeçalho [Authorization: Bearer <token>]).
5.2. Árvore do projeto
| rdvmedecins-kotlin-client/
├── settings.gradle.kts, build.gradle.kts, gradle/ Gradle configuration
└── app/
├── build.gradle.kts Android configuration + dependencies
└── src/main/
├── AndroidManifest.xml permissions, Application class, activity
├── assets/i18n/ translation dictionaries (fr.json, en.json)
├── res/ app icon, name and theme
└── java/fr/rdvmedecins/client/
├── RdvMedecinsApplication.kt builds the services (once)
├── MainActivity.kt the screen: provides the services, displays App
├── App.kt the root screen (conductor + guard)
├── AppViewModel.kt the state and logic of the root screen
├── core/
│ ├── Locals.kt the CompositionLocals (equivalent of provider)
│ ├── models/ data classes (mirror of the server's JSON)
│ ├── services/ SettingsService, AuthService, AppointmentService
│ ├── http/ AuthInterceptor (JWT token + logout on 401)
│ ├── i18n/ TranslationsService (French/English)
│ └── ui/ DropdownList (reusable component)
└── features/ one component per feature
|
Essa estrutura de diretórios reflete, pasta por pasta, a do cliente Flutter ([lib/core/models], [lib/core/services], [lib/core/http], [lib/core/i18n], [lib/features]), que por sua vez se baseia no cliente Vue.js. Duas adições específicas do Android: a classe Application ([RdvMedecinsApplication.kt]) e o ViewModel da tela ([AppViewModel.kt]), cuja finalidade foi explicada no Capítulo 3; e uma pequena pasta chamada [core/ui] para uma lista suspensa reutilizável. Os nomes das pastas Kotlin ficam em minúsculas e sem hífens ([doctordaypicker], [bookingdialog]): são nomes de pacotes.
5.3. Arquivos de configuração do projeto
5.3.1. gradle/libs.versions.toml
O catálogo de versões: todas as bibliotecas e plugins do Gradle do projeto, com suas versões, em um só lugar. É o equivalente da seção [dependencies] do arquivo [pubspec.yaml] da versão Flutter. O arquivo foi gerado pelo Android Studio e depois complementado.
| # =========================================================================
# libs.versions.toml - o "version catalog" do projeto: TODAS as
# versões dos plugins e bibliotecas, em um único lugar. Os
# arquivos build.gradle.kts os referenciam por nome (libs.okhttp,
# libs.plugins.kotlin.compose...) - o equivalente aos números de versão
# do pubspec.yaml da versão Flutter, ou do package.json do Node.js.
# =========================================================================
[versions]
agp = "9.4.1"
kotlin = "2.2.10"
coreKtx = "1.17.0"
lifecycle = "2.9.4"
activityCompose = "1.11.0"
composeBom = "2026.02.01"
okhttp = "4.12.0"
kotlinxSerializationJson = "1.9.0"
junit = "4.13.2"
junitVersion = "1.1.5"
espressoCore = "3.5.1"
[libraries]
# gerado pelo Android Studio (template "Empty Activity")
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
androidx-compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
junit = { group = "junit", name = "junit", version.ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
# adicionado para este cliente
# viewModel { ... } em uma função @Composable (veja App.kt)
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
# os ícones básicos do Material (logout, calendar)
androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
# o cliente HTTP
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
# (de)serialização JSON
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
# adicionado para este cliente: gera o código de (de)serialização das classes @Serializable
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
|
Vamos comentar este código:
- linha 10: [agp = "9.4.1"]: a versão do Android Gradle Plugin ([AGP]), o plugin do Gradle que compila um aplicativo Android. A partir da versão 9, ele compila o código Kotlin por conta própria: não há mais um plugin Kotlin separado a declarar;
- linha 11: [kotlin = "2.2.10"]: a versão dos dois plugins de compilação do Kotlin declarados abaixo (Compose e serialização);
- linha 15: [composeBom]: a versão do “BOM” do Compose (Bill of Materials), que define versões compatíveis para todas as bibliotecas do Compose de uma só vez (veja [app/build.gradle.kts]);
- linhas 38–46: as quatro bibliotecas adicionadas para este cliente: [lifecycle-viewmodel-compose] (a função [viewModel { ... }]), [material-icons-core] (os ícones de logout e de calendário), [OkHttp] (o cliente HTTP, equivalente ao pacote [http] do Flutter) e [kotlinx-serialization-json] (a conversão JSON <-> objetos Kotlin). As duas primeiras não têm versão; ela é determinada pelo BOM do Compose;
- linha 52: o plugin de compilação [kotlinx.serialization], que gera o código de conversão JSON das classes anotadas com [@Serializable] (veja [core/models]).
5.3.2. app/build.gradle.kts
A configuração do módulo [app], a aplicação em si, incluindo os plugins aplicados, as configurações do Android e as dependências.
| // =========================================================================
// app/build.gradle.kts - a configuração do módulo "app": a própria
// aplicação Android. Gerado pelo Android Studio (template "Empty Activity"),
// depois completado para este cliente (linhas marcadas com "added").
// =========================================================================
plugins {
// o plugin Android: compila o código Kotlin (o Android Gradle Plugin 9
// já inclui suporte a Kotlin) e produz o .apk
alias(libs.plugins.android.application)
// o compilador do Compose: transforma as funções @Composable
alias(libs.plugins.kotlin.compose)
// adicionado: o plugin kotlinx.serialization (classes @Serializable)
alias(libs.plugins.kotlin.serialization)
}
android {
// o "package" Kotlin base do código-fonte (classe R, BuildConfig...)
namespace = "fr.rdvmedecins.client"
// a versão da API do Android usada para COMPILAR
compileSdk {
version = release(37)
}
defaultConfig {
// o identificador ÚNICO da aplicação em um celular (e na
// Play Store)
applicationId = "fr.rdvmedecins.client"
// a versão mais antiga do Android aceita: Android 8.0 (API 26),
// a primeira a oferecer java.time (LocalDate, veja DoctorDayPicker)
minSdk = 26
// a versão do Android para a qual a aplicação foi testada
targetSdk = 37
versionCode = 1
versionName = "1.0"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
optimization {
enable = false
}
}
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}
buildFeatures {
compose = true
}
}
dependencies {
// o "BOM" (Bill Of Materials) do Compose: define de uma só vez versões
// mutuamente compatíveis para todas as bibliotecas do Compose, que
// são portanto declaradas abaixo SEM número de versão
implementation(platform(libs.androidx.compose.bom))
implementation(libs.androidx.activity.compose)
implementation(libs.androidx.compose.material3)
implementation(libs.androidx.compose.ui)
implementation(libs.androidx.compose.ui.graphics)
implementation(libs.androidx.compose.ui.tooling.preview)
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx)
// adicionado para este cliente
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.compose.material.icons.core)
implementation(libs.okhttp)
implementation(libs.kotlinx.serialization.json)
// testes (gerados pelo Android Studio, não usados neste documento)
testImplementation(libs.junit)
androidTestImplementation(platform(libs.androidx.compose.bom))
androidTestImplementation(libs.androidx.compose.ui.test.junit4)
androidTestImplementation(libs.androidx.espresso.core)
androidTestImplementation(libs.androidx.junit)
debugImplementation(libs.androidx.compose.ui.test.manifest)
debugImplementation(libs.androidx.compose.ui.tooling)
}
|
Vamos comentar este código:
- linhas 6–13: os três plugins aplicados ao módulo: o plugin do Android, o compilador do Compose (que transforma as funções [@Composable]) e o plugin kotlinx.serialization;
- linha 18: [namespace]: o pacote base do código Kotlin;
- linhas 20–21: [compileSdk]: a versão da API do Android usada na compilação (37 = Android 17). [targetSdk] (linha 32) é a versão para a qual o aplicativo foi testado: o Android aplica a ele os comportamentos dessa versão;
- linha 27: [applicationId] - o identificador único do aplicativo em um celular e na Play Store;
- linha 30: [minSdk = 26] - Android 8.0 ou superior, a primeira versão a oferecer a API [java.time] ([LocalDate]), usada pelo [DoctorDayPicker];
- linha 51: [compose = true]: habilita o Compose para este módulo;
- linha 59: o BOM do Compose, declarado como uma “platform”: as bibliotecas do Compose seguintes são declaradas sem versão;
- linhas 67–71: as quatro dependências adicionadas para este cliente (veja [libs.versions.toml]). A sintaxe [libs.okhttp] refere-se ao catálogo de versões: o Gradle gera um getter Kotlin para cada entrada do catálogo, o que habilita o autocompletar no Android Studio.
5.3.3. app/src/main/AndroidManifest.xml
O manifesto do aplicativo. A versão Flutter não tinha um: a pasta [android/], que o contém, foi gerada pelo [flutter create] e não foi examinada. Aqui, ele faz parte do código do aplicativo.
| <?xml version="1.0" encoding="utf-8"?>
<!-- =====================================================================
AndroidManifest.xml
............................................................................
A "carteira de identidade" da aplicação para o sistema Android: suas
permissões, sua classe Application, suas activities (telas).
===================================================================== -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<!-- acesso à rede: sem esta permissão, qualquer requisição HTTP ao
servidor NestJS falha (nenhum diálogo é exibido ao
usuário para esta permissão: ela é concedida automaticamente) -->
<uses-permission android:name="android.permission.INTERNET" />
<!-- android:name: a classe Application que constrói os serviços
(veja RdvMedecinsApplication.kt).
android:usesCleartextTraffic="true": permite HTTP "em texto puro"
(http:// e não https://), bloqueado por padrão desde o Android 9.
Essencial com o servidor NestJS deste curso, que escuta em
HTTP simples - a ser removido para um servidor de produção em https
(veja o capítulo 5). -->
<application
android:name=".RdvMedecinsApplication"
android:allowBackup="true"
android:dataExtractionRules="@xml/data_extraction_rules"
android:fullBackupContent="@xml/backup_rules"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.RdvMedecins"
android:usesCleartextTraffic="true"
tools:targetApi="31">
<!-- a única tela da aplicação. exported="true" + o
filtro MAIN/LAUNCHER: é a activity iniciada pelo
ícone da aplicação. windowSoftInputMode="adjustResize": quando o
teclado aparece, a tela é reduzida (e continua rolável) em vez de
ficar escondida pelo teclado. -->
<activity
android:name=".MainActivity"
android:exported="true"
android:windowSoftInputMode="adjustResize"
android:theme="@style/Theme.RdvMedecins">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
|
Vamos comentar este código:
- linha 14: [android.permission.INTERNET]: sem essa permissão, qualquer conexão com o servidor falhará. É uma permissão “normal”: ela é concedida na instalação, sem perguntar ao usuário;
- linha 24: [android:name=".RdvMedecinsApplication"]: a classe Application da aplicação (a entrada inicial [.] é substituída por [namespace]);
- linha 33: [android:usesCleartextTraffic="true"]: permite HTTP “em texto puro” ([http://], e não [https://]), que é bloqueado por padrão a partir do Android 9. Como o servidor NestJS deste curso escuta na porta HTTP simples, essa configuração é essencial (veja o Capítulo 5);
- linhas 41–50: a única activity, [MainActivity]. O filtro [MAIN]/[LAUNCHER] faz dela a activity iniciada pelo ícone do aplicativo; [exported="true"] permite que ela seja iniciada por outro aplicativo, neste caso, o launcher de aplicativos do celular;
- Linha 44: [windowSoftInputMode="adjustResize"]: quando o teclado aparece, a tela é redimensionada para caber no espaço restante (e continua rolável) em vez de ficar parcialmente encoberta pelo teclado.
O restante da pasta [res/] vem do template do Android Studio: o ícone do aplicativo ([mipmap-*], [drawable/]), seu nome ([values/strings.xml]), seu tema “Android”, usado apenas durante a inicialização, antes de o Compose exibir a primeira tela com o seu próprio tema ([values/themes.xml]), e as regras de backup de dados ([xml/]).
5.4. Inicialização do aplicativo
O [lib/main.dart] da versão Flutter fazia duas coisas: construir os serviços e depois exibir a primeira tela. No Android, esses dois papéis são divididos entre a classe Application e a activity.
5.4.1. RdvMedecinsApplication.kt
Inicializa os quatro serviços do cliente uma única vez, na inicialização do aplicativo.
| // =========================================================================
// RdvMedecinsApplication.kt
// -------------------------------------------------------------------------
// Primeira metade do lib/main.dart da versão Flutter: construção,
// UMA ÚNICA VEZ, dos serviços da aplicação.
//
// Por que uma classe Application? No Android, a tela (a Activity, veja
// MainActivity) é DESTRUÍDA e depois RECRIADA a cada rotação do celular, a
// cada mudança do idioma do sistema, etc. Serviços construídos na
// Activity seriam, portanto, reconstruídos a cada rotação. O
// objeto Application, por outro lado, é criado quando o processo inicia e
// vive enquanto ele durar: é o lugar certo para objetos que devem
// durar toda a vida da aplicação. Ele é declarado no
// AndroidManifest.xml (atributo android:name da tag <application>).
//
// A ORDEM de construção importa, como na versão Flutter:
// AuthService precisa de SettingsService (a URL do servidor); o cliente
// HTTP autenticado precisa de AuthService (o token); AppointmentService precisa
// do cliente HTTP autenticado e de SettingsService.
// =========================================================================
package fr.rdvmedecins.client
import android.app.Application
import android.content.Context
import fr.rdvmedecins.client.core.http.AuthInterceptor
import fr.rdvmedecins.client.core.i18n.TranslationsService
import fr.rdvmedecins.client.core.services.AuthService
import fr.rdvmedecins.client.core.services.AppointmentService
import fr.rdvmedecins.client.core.services.SettingsService
import okhttp3.OkHttpClient
import java.util.concurrent.TimeUnit
class RdvMedecinsApplication : Application() {
// lateinit: estas propriedades não nulas serão inicializadas em
// onCreate(), e não no construtor (veja o curso de Kotlin)
lateinit var settings: SettingsService
private set
lateinit var auth: AuthService
private set
lateinit var api: AppointmentService
private set
lateinit var translations: TranslationsService
private set
// chamado pelo Android quando a aplicação inicia, antes de qualquer tela
override fun onCreate() {
super.onCreate()
// as preferências da aplicação: um pequeno arquivo privado de chave/valor
// que sobrevive à parada da aplicação - o equivalente ao
// localStorage de um navegador
val prefs = getSharedPreferences("rdvmedecins", Context.MODE_PRIVATE)
// 1. SettingsService primeiro: os outros dependem dele
settings = SettingsService(prefs)
// 2. um cliente HTTP OkHttp "simples", usado por AuthService para
// POST /login. Timeouts curtos: no mobile, uma mensagem de erro rápida
// é melhor que uma espera sem fim se o servidor estiver
// inacessível (URL errada, Wi-Fi desligado...).
val plainHttp = OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(15, TimeUnit.SECONDS)
.build()
auth = AuthService(settings, prefs, plainHttp)
// 3. o cliente HTTP autenticado: uma CÓPIA do anterior
// (newBuilder() reaproveita sua configuração e suas conexões),
// mais o interceptor que adiciona o token JWT
val authHttp = plainHttp.newBuilder()
.addInterceptor(AuthInterceptor(auth))
.build()
api = AppointmentService(authHttp, settings)
// 4. as traduções: sem dependência dos outros serviços
translations = TranslationsService(assets, prefs)
}
}
|
Vamos comentar este código:
- linha 34: a classe estende [android.app.Application]. O Android cria uma única instância dela quando o processo do aplicativo é iniciado, antes de qualquer activity, e a mantém até o fim do processo;
- linhas 38–44: os quatro serviços, declarados como [lateinit var ... private set]: não nulos, inicializados depois (em [onCreate]) e modificáveis apenas por esta classe;
- linha 54: [getSharedPreferences(...)]: as preferências da aplicação, um pequeno arquivo privado de chave/valor que sobrevive ao encerramento do aplicativo: o equivalente do [localStorage] de um navegador e do pacote [shared_preferences] do Flutter;
- Linhas 63–66: um cliente [OkHttp] “simples”, com timeouts curtos. Um cliente OkHttp foi projetado para ser COMPARTILHADO: ele gerencia seu próprio pool de conexões reutilizáveis;
- linha 67: o [AuthService] recebe o cliente simples: a rota [/login] é a única rota pública do servidor; ela não exige token;
- linhas 72–75: o cliente autenticado, [newBuilder()], cria uma cópia dele (que compartilha as conexões do primeiro) complementada pelo interceptor [AuthInterceptor], que adiciona o token JWT a cada requisição (veja [core/http]). [AppointmentService] o recebe: nenhum de seus métodos precisa se preocupar com o token;
- linha 78: [assets]: acesso aos arquivos da pasta [assets/] da aplicação, passado ao [TranslationsService].
Uma diferença notável em relação à versão Flutter: nenhuma inicialização assíncrona é necessária antes de exibir a primeira tela. Os objetos [SharedPreferences] são lidos de forma síncrona (são carregados na memória no primeiro acesso): [AuthService] e [TranslationsService] leem a sessão e o idioma armazenados assim que são criados, ao passo que o [lib/main.dart] precisava aguardar [await auth.init()] e [await translations.init()].
5.4.2. MainActivity.kt
A única activity do aplicativo: ela disponibiliza os serviços para todas as funções @Composable e, em seguida, exibe a tela raiz.
| // =========================================================================
// MainActivity.kt
// -------------------------------------------------------------------------
// Segunda metade do lib/main.dart da versão Flutter: exibição da
// primeira tela.
//
// Uma aplicação Android é feita de "activities" (Activity): uma
// activity é uma tela, iniciada pelo sistema. Esta é declarada no
// AndroidManifest.xml como a activity de inicialização (LAUNCHER): é a que o
// Android inicia quando o usuário toca no ícone da aplicação.
//
// ComponentActivity é a activity base projetada para o Jetpack Compose:
// setContent { ... } substitui o antigo sistema de views do Android (arquivos
// de layout XML) por funções @Composable - o equivalente ao
// runApp(...) do Flutter.
// =========================================================================
package fr.rdvmedecins.client
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.runtime.CompositionLocalProvider
import fr.rdvmedecins.client.core.LocalAuth
import fr.rdvmedecins.client.core.LocalApi
import fr.rdvmedecins.client.core.LocalSettings
import fr.rdvmedecins.client.core.LocalTranslations
class MainActivity : ComponentActivity() {
// chamado a cada criação da activity: na inicialização, mas também
// após cada rotação de tela (veja RdvMedecinsApplication)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// a aplicação desenha sob a barra de status e a barra de
// navegação do sistema; o Scaffold (veja App.kt) cuida de
// deixar o espaço de que essas barras precisam
enableEdgeToEdge()
// os serviços, construídos de uma vez por todas por
// RdvMedecinsApplication - e não aqui, onde seriam reconstruídos
// a cada rotação
val app = application as RdvMedecinsApplication
setContent {
// CompositionLocalProvider: disponibiliza os quatro serviços
// a toda função @Composable chamada no bloco - o
// MultiProvider da versão Flutter (veja core/Locals.kt)
CompositionLocalProvider(
LocalSettings provides app.settings,
LocalAuth provides app.auth,
LocalApi provides app.api,
LocalTranslations provides app.translations,
) {
RdvMedecinsApp()
}
}
}
}
|
Vamos comentar este código:
- linha 34: [onCreate(...)] é chamado TODA vez que a activity é criada: na inicialização, mas também após cada rotação da tela. É por isso que os serviços são criados pela classe Application, e não aqui;
- linha 39: [enableEdgeToEdge()]—o aplicativo desenha em toda a tela, inclusive sob a barra de status do sistema (na parte superior) e a barra de navegação (na parte inferior). [Scaffold] (veja [App.kt]) fornece as margens necessárias para que o conteúdo não fique oculto por essas barras;
- linha 44: [application as RdvMedecinsApplication]—a propriedade [application] de uma activity retorna o objeto Application: ele é convertido para o seu tipo real a fim de acessar os serviços;
- linha 46: [setContent { ... }]—o equivalente de [runApp(...)]: a interface da activity passa a ser descrita pelas funções @Composable do bloco;
- linhas 50–56: [CompositionLocalProvider(LocalSettings provides app.settings, ...)]—fornece os quatro serviços a toda a árvore de funções @Composable chamadas dentro do bloco: o equivalente do [MultiProvider] da versão Flutter. [provides] é uma função “infixa”: [a provides b] é escrito sem ponto nem parênteses (veja o curso de Kotlin).
5.4.3. core/Locals.kt
As quatro “chaves” dos serviços fornecidos por [MainActivity].
| // =========================================================================
// Locals.kt
// -------------------------------------------------------------------------
// Os "CompositionLocal" da aplicação: o mecanismo do Jetpack Compose
// para disponibilizar um objeto a uma subárvore INTEIRA de
// funções @Composable, sem passá-lo como parâmetro de chamada em chamada.
// É o equivalente ao pacote provider da versão Flutter
// (MultiProvider / context.read<...>()), ao provide/inject do lado Vue.js ou
// a um Context do React.
//
// - MainActivity FORNECE as instâncias:
// CompositionLocalProvider(LocalAuth provides auth, ...) { ... }
// - qualquer função @Composable descendente as LÊ:
// val auth = LocalAuth.current
//
// staticCompositionLocalOf (em vez de compositionLocalOf): estes serviços
// nunca são SUBSTITUÍDOS por outras instâncias durante a vida da
// aplicação, apenas seu CONTEÚDO muda - e esse conteúdo já é
// observado pelo Compose graças ao mutableStateOf de cada serviço.
// O bloco { error(...) } dá o valor padrão: aqui, uma exceção
// explícita se uma tela for exibida sem que o serviço tenha sido fornecido.
// =========================================================================
package fr.rdvmedecins.client.core
import androidx.compose.runtime.staticCompositionLocalOf
import fr.rdvmedecins.client.core.i18n.TranslationsService
import fr.rdvmedecins.client.core.services.AuthService
import fr.rdvmedecins.client.core.services.AppointmentService
import fr.rdvmedecins.client.core.services.SettingsService
val LocalSettings = staticCompositionLocalOf<SettingsService> { error("SettingsService not provided") }
val LocalAuth = staticCompositionLocalOf<AuthService> { error("AuthService not provided") }
val LocalApi = staticCompositionLocalOf<AppointmentService> { error("AppointmentService not provided") }
val LocalTranslations = staticCompositionLocalOf<TranslationsService> { error("TranslationsService not provided") }
|
Vamos comentar este código:
- linha 33: [staticCompositionLocalOf<AuthService> { ... }]—declara um CompositionLocal do tipo [AuthService]. O bloco especifica o valor padrão, usado caso nenhum valor seja fornecido: aqui, uma exceção explícita ([error(...)]), mais clara do que um erro obscuro mais adiante;
- [static...] em vez de [compositionLocalOf]: um CompositionLocal “estático” não acompanha as SUBSTITUIÇÕES da instância fornecida (o que seria mais custoso). Isso funciona aqui: os serviços nunca são substituídos por outras instâncias; apenas o seu conteúdo muda, e esse conteúdo já é observado por meio de suas propriedades [mutableStateOf].
5.4.4. App.kt
Porte de [lib/app.dart]: a tela raiz. Ela monta os componentes de [features/], repassa suas ações ao ViewModel e atua como um “guard”: enquanto o usuário não estiver autenticado, exibe apenas a tela de login. Seu estado e sua lógica são definidos em [AppViewModel]: este arquivo apenas EXIBE.
| // =========================================================================
// App.kt
// -------------------------------------------------------------------------
// Port de lib/app.dart (cliente Flutter): a tela RAIZ da aplicação.
// Como em todas as variantes deste curso, ela faz o papel de
// "conductor" - monta as telas de lib/features/
// (aqui features/) e repassa suas ações - e o de "guard": enquanto
// o usuário não estiver logado, ela só exibe a tela de login.
//
// Seu estado e sua lógica foram movidos para AppViewModel (veja esse
// arquivo para o motivo): este arquivo apenas EXIBE.
//
// Três funções @Composable:
// - RdvMedecinsApp: o tema da aplicação (MaterialApp no lado Flutter);
// - AppRoot : a tela em si (barra de título + conteúdo);
// - ServerUrlField e LanguageSelector: dois pequenos elementos da tela.
// =========================================================================
package fr.rdvmedecins.client
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ExitToApp
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import fr.rdvmedecins.client.core.LocalAuth
import fr.rdvmedecins.client.core.LocalApi
import fr.rdvmedecins.client.core.LocalSettings
import fr.rdvmedecins.client.core.LocalTranslations
import fr.rdvmedecins.client.core.i18n.TranslationsService
import fr.rdvmedecins.client.features.schedule.ScheduleView
import fr.rdvmedecins.client.features.bookingdialog.BookingDialog
import fr.rdvmedecins.client.features.doctordaypicker.DoctorDayPicker
import fr.rdvmedecins.client.features.login.LoginPage
// -------------------------------------------------------------------------
// o tema: um azul "primary" para a barra de título e os botões, como
// o banner azul (navbar bg-primary) das variantes web deste curso
// -------------------------------------------------------------------------
private val appColors = lightColorScheme(
primary = Color(0xFF1565C0),
onPrimary = Color.White,
)
@Composable
fun RdvMedecinsApp() {
MaterialTheme(colorScheme = appColors) {
AppRoot()
}
}
// -------------------------------------------------------------------------
// a tela principal
// -------------------------------------------------------------------------
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun AppRoot() {
// os serviços, fornecidos por MainActivity (veja core/Locals.kt)
val auth = LocalAuth.current
val api = LocalApi.current
val translations = LocalTranslations.current
// uma referência ao método t(...): t("APP.TITLE") é então lido
// como nas outras variantes do curso
val t = translations::t
// viewModel { ... }: RECUPERA o ViewModel desta tela se ele já
// existir (após uma rotação), ou o CRIA com o bloco dado na primeira
// vez. Por isso nunca se deve escrever
// "val vm = AppViewModel(auth, api)": um novo ViewModel vazio
// seria construído a cada exibição.
val vm = viewModel { AppViewModel(auth, api) }
// tela estreita (celular em retrato): a barra de título é aliviada
val narrow = LocalConfiguration.current.screenWidthDp < 600
// Scaffold: a estrutura padrão de uma tela Material (barra de título,
// conteúdo...) - o mesmo widget, e o mesmo nome, que no Flutter
Scaffold(
topBar = {
TopAppBar(
// em tela estreita, um título curto: não há espaço suficiente para o
// título completo ao lado dos botões FR/EN, do papel e do
// botão de logout
title = {
Text(
text = if (narrow) "RdvMedecins" else t("APP.TITLE"),
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
},
colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primary,
titleContentColor = MaterialTheme.colorScheme.onPrimary,
actionIconContentColor = MaterialTheme.colorScheme.onPrimary,
),
// actions: os elementos alinhados à direita da barra de título
actions = {
// seletor FR/EN: SEMPRE visível, mesmo antes do login
LanguageSelector(translations)
// um simples if do Kotlin: o badge do papel, o nome e o
// botão de logout só existem depois do login
if (auth.isLoggedIn) {
Surface(
shape = RoundedCornerShape(8.dp),
color = Color.White.copy(alpha = 0.2f),
contentColor = MaterialTheme.colorScheme.onPrimary,
) {
Text(
text = auth.role?.name ?: "",
style = MaterialTheme.typography.labelMedium,
modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
)
}
// em tela estreita, o nome é ocultado por falta de espaço
if (!narrow) {
Spacer(Modifier.width(8.dp))
Text(auth.name ?: "", color = MaterialTheme.colorScheme.onPrimary)
}
IconButton(onClick = vm::logOut) {
Icon(Icons.AutoMirrored.Filled.ExitToApp, contentDescription = t("APP.LOGOUT"))
}
}
},
)
},
) { systemInsets ->
// systemInsets: o espaço ocupado pela barra de título e pelas barras do
// sistema, que deve ficar livre (veja enableEdgeToEdge())
Column(
modifier = Modifier
.padding(systemInsets)
.fillMaxSize()
// o equivalente ao SingleChildScrollView da versão Flutter
.verticalScroll(rememberScrollState())
.padding(16.dp),
) {
// a URL do servidor, editável antes e depois do login
ServerUrlField(label = t("APP.SERVER_URL_LABEL"))
Spacer(Modifier.height(16.dp))
// a mensagem de erro, se houver
vm.error?.let { message ->
Surface(
color = MaterialTheme.colorScheme.errorContainer,
contentColor = MaterialTheme.colorScheme.onErrorContainer,
shape = RoundedCornerShape(4.dp),
modifier = Modifier.fillMaxWidth(),
) {
Text(message, modifier = Modifier.padding(12.dp))
}
Spacer(Modifier.height(16.dp))
}
// o "guard": não logado -> nada além da tela de login
if (!auth.isLoggedIn) {
LoginPage()
} else {
// 1. escolha do médico e do dia
DoctorDayPicker(doctors = vm.doctors, onSearch = vm::searchSchedule)
Spacer(Modifier.height(16.dp))
// 2. a agenda; canEdit oculta "Book"/"Cancel"
// para o papel USER
ScheduleView(
schedule = vm.schedule,
canEdit = auth.isAdmin,
onBook = vm::requestBooking,
onCancel = vm::cancelAppointment,
)
}
}
// 3. o diálogo de reserva: exibido enquanto um
// horário estiver sendo reservado (veja AppViewModel)
vm.slotBeingBooked?.let { slot ->
BookingDialog(
slot = slot,
clients = vm.clients,
onConfirm = vm::confirmBooking,
onClose = vm::closeBooking,
)
}
}
}
// -------------------------------------------------------------------------
// o campo "Server URL". A versão Flutter precisava de um
// StatefulWidget dedicado para criar e depois descartar um TextEditingController.
// No Compose, um campo de texto não tem estado oculto: ele EXIBE o valor e
// INFORMA cada tecla digitada por meio de onValueChange - cabe a nós atualizar o estado,
// o que faz o campo ser reexibido com o novo valor.
// É o "v-model" do Vue.js escrito em duas metades explícitas.
// -------------------------------------------------------------------------
@Composable
private fun ServerUrlField(label: String) {
val settings = LocalSettings.current
OutlinedTextField(
value = settings.apiBaseUrl,
onValueChange = settings::changeUrl,
label = { Text(label) },
singleLine = true,
// teclado adequado para digitar uma URL (teclas "/", ".", ":"...)
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri),
modifier = Modifier.widthIn(max = 360.dp).fillMaxWidth(),
)
}
// -------------------------------------------------------------------------
// os dois botões FR / EN da barra de título: o idioma atual é
// exibido em branco e negrito, o outro em branco atenuado
// -------------------------------------------------------------------------
@Composable
private fun LanguageSelector(translations: TranslationsService) {
listOf("fr", "en").forEach { language ->
val current = language == translations.currentLanguage
TextButton(onClick = { translations.changeLanguage(language) }) {
Text(
text = language.uppercase(),
fontWeight = if (current) FontWeight.Bold else FontWeight.Normal,
color = MaterialTheme.colorScheme.onPrimary.copy(alpha = if (current) 1f else 0.6f),
)
}
}
}
|
Vamos comentar este código:
- linhas 70–72: o esquema de cores: azul como cor primária ([primary]), branco para o texto sobre ela ([onPrimary]). As demais cores são as cores padrão do Material 3;
- linhas 76–78: [RdvMedecinsApp] aplica o tema a toda a tela ([MaterialTheme]), de forma semelhante ao [MaterialApp] do Flutter;
- linha 85: [@OptIn(ExperimentalMaterial3Api::class)]—[TopAppBar] ainda é marcado como “experimental” pelo Material 3: a anotação indica que ele é usado com pleno conhecimento dos riscos (sem ela, o compilador rejeita o código);
- linhas 89–91: os serviços, lidos como CompositionLocal—o equivalente de [context.read<...>()] / [context.watch<...>()];
- linha 94: [val t = translations::t]—uma REFERÊNCIA ao método [t] do objeto [translations]: em seguida, escrevemos [t("APP.TITLE")], como nas outras variantes do curso;
- Linha 101: [viewModel { AppViewModel(auth, api) }] - RECUPERA o ViewModel desta tela se ele já existir (após uma rotação) ou o CRIA com o bloco fornecido na primeira vez. Assim, o ViewModel sobrevive quando a activity é recriada;
- linha 104: a largura da tela, em dp, lida da configuração atual: abaixo de 600 dp (celular em modo retrato), a barra de título é simplificada—título curto (linha 116) e nome de usuário oculto (linha 145);
- linha 108: [Scaffold(topBar = { ... }) { systemInsets -> ... }]—a estrutura padrão de uma tela Material, como no Flutter. O último parâmetro, uma lambda, é o conteúdo da tela; ele recebe as margens a serem respeitadas (barra de título e barras do sistema);
- linha 110: [TopAppBar] – a barra de título, colorida com a cor primária do tema;
- linhas 127–132: [actions = { ... }]—os elementos alinhados à direita da barra: o seletor de idioma, SEMPRE visível; depois, com um simples [if], o selo do papel, o nome e o botão de logout, que só aparecem após o login. Como [auth.isLoggedIn] é um estado observável, a barra é recomposta automaticamente no login e no logout;
- linha 149: [onClick = vm::logOut]—uma referência de método passada como manipulador de clique;
- linhas 159–165: o conteúdo: uma [Column] com rolagem ([verticalScroll], o equivalente do [SingleChildScrollView] do Flutter);
- linha 172: a mensagem de erro do ViewModel, se houver: [vm.error?.let { message -> ... }] só emite o bloco se [error] for diferente de [null];
- linhas 185–197: o “guard”: se não estiver autenticado, a tela de login; se estiver, a seleção do médico e do dia, seguida do calendário. [canEdit = auth.isAdmin] oculta os botões de agendamento de consultas para o papel USER;
- linhas 204–209: a caixa de diálogo de agendamento, exibida enquanto [vm.slotBeingBooked] for diferente de [null] (veja [AppViewModel] e [BookingDialog]);
- linhas 224–232: [ServerUrlField]—o campo “Server URL”. No Compose, um campo de entrada não tem estado oculto: ele EXIBE [value] e INFORMA cada tecla digitada por meio de [onValueChange]. Aqui, cada tecla digitada é enviada a [settings.changeUrl(...)], que atualiza o estado observado—e o campo é redesenhado com o novo valor. A versão Flutter exigia um [TextEditingController] e, portanto, um [StatefulWidget] dedicado para criá-lo e liberá-lo;
- linhas 242–245: [LanguageSelector]—duas instâncias de [TextButton] , “FR” e “EN”, geradas por um laço sobre a lista de idiomas; o idioma atual aparece em negrito.
5.4.5. AppViewModel.kt
O estado e a lógica da tela raiz: a parte [_AppRootState] de [lib/app.dart].
| // =========================================================================
// AppViewModel.kt
// -------------------------------------------------------------------------
// O ESTADO e a LÓGICA da tela principal: a parte "_AppRootState" do
// lib/app.dart da versão Flutter (médicos, pacientes, agenda
// exibida, erro, última busca...) e as reações às ações do
// usuário (buscar uma agenda, reservar, cancelar).
//
// Por que um ViewModel, em vez de estados locais na função
// @Composable AppRoot (veja App.kt)? Porque a Activity é destruída e
// recriada a cada rotação de tela (veja RdvMedecinsApplication): um
// estado local seria perdido - a agenda exibida sumiria à menor
// inclinação do celular. Um ViewModel (biblioteca "lifecycle" do Android Jetpack)
// SOBREVIVE a essas recriações: o Android o mantém e
// o entrega à nova Activity. Ele só é destruído quando a tela
// é abandonada de vez. O Flutter não tem esse problema: lá a rotação
// não destrói nada, apenas o tamanho da tela muda.
//
// A divisão resultante é clássica no Android: App.kt EXIBE, este
// ViewModel DECIDE e chama os serviços.
// =========================================================================
package fr.rdvmedecins.client
import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshotFlow
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import fr.rdvmedecins.client.core.models.DoctorDaySchedule
import fr.rdvmedecins.client.core.models.Client
import fr.rdvmedecins.client.core.models.SlotJson
import fr.rdvmedecins.client.core.models.Doctor
import fr.rdvmedecins.client.core.models.AppointmentJson
import fr.rdvmedecins.client.core.services.AuthService
import fr.rdvmedecins.client.core.services.AppointmentService
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.launch
class AppViewModel(
private val auth: AuthService,
private val api: AppointmentService,
) : ViewModel() {
// estado exibido por App.kt (leitura pública, escrita privada)
var doctors by mutableStateOf<List<Doctor>>(emptyList())
private set
var clients by mutableStateOf<List<Client>>(emptyList())
private set
var schedule by mutableStateOf<DoctorDaySchedule?>(null)
private set
var error by mutableStateOf<String?>(null)
private set
// o horário em reserva: não nulo = o diálogo de reserva
// está aberto (veja App.kt e BookingDialog.kt)
var slotBeingBooked by mutableStateOf<SlotJson?>(null)
private set
// a última busca (médico + dia), para atualizar a agenda após
// uma reserva ou um cancelamento. Nunca exibida: propriedades
// simples bastam, sem necessidade de torná-las estados do Compose.
private var lastDoctorId: Int? = null
private var lastDay: String? = null
init {
// snapshotFlow { ... } transforma a leitura de um estado do Compose em um
// FLOW de valores: ele emite imediatamente o valor atual de auth.isLoggedIn
// e depois cada novo valor. É o equivalente exato do
// "watch(() => auth.isLoggedIn, ..., { immediate: true })" do Vue.js
// - e da assinatura addListener(...) + chamada inicial
// que a versão Flutter precisava escrever à mão.
// viewModelScope: as corrotinas iniciadas neste escopo são
// canceladas automaticamente quando o ViewModel é destruído (não é mais
// preciso o removeListener(...) do dispose() do lado Flutter).
viewModelScope.launch {
snapshotFlow { auth.isLoggedIn }.collect { loggedIn ->
if (loggedIn) {
loadInitialLists()
} else {
reset()
}
}
}
}
// -----------------------------------------------------------------------
// no login (ou quando uma sessão lembrada é restaurada):
// carregamos os médicos e os pacientes de uma vez por todas. Duas
// corrotinas separadas: as duas requisições são enviadas EM PARALELO.
// -----------------------------------------------------------------------
private fun loadInitialLists() {
runSafely { doctors = api.getAllDoctors() }
runSafely { clients = api.getAllClients() }
}
// -----------------------------------------------------------------------
// no logout (botão, ou token rejeitado pelo servidor):
// limpamos o estado de negócio, para que um novo usuário não veja, nem por um
// instante, a agenda do usuário anterior
// -----------------------------------------------------------------------
private fun reset() {
doctors = emptyList()
clients = emptyList()
schedule = null
error = null
slotBeingBooked = null
lastDoctorId = null
lastDay = null
}
// botão "Log out": basta fazer o logout do AuthService -
// o snapshotFlow (veja init) então dispara reset()
fun logOut() {
auth.logOut()
}
// -----------------------------------------------------------------------
// botão "View schedule" do DoctorDayPicker
// -----------------------------------------------------------------------
fun searchSchedule(doctorId: Int, day: String) {
error = null
lastDoctorId = doctorId
lastDay = day
loadSchedule()
}
// -----------------------------------------------------------------------
// botão "Book" do ScheduleView: apenas ABRIMOS o
// diálogo, lembrando o horário em questão. No Compose, um diálogo
// faz parte da exibição como todo o resto: ele é
// exibido enquanto slotBeingBooked não for nulo (veja App.kt) -
// o mesmo princípio da prop "open" do BookingDialog.vue da
// variante Vue.js, o oposto do showDialog(...) do Flutter.
// -----------------------------------------------------------------------
fun requestBooking(slot: SlotJson) {
slotBeingBooked = slot
}
// botão "Cancel" (ou toque fora) do diálogo
fun closeBooking() {
slotBeingBooked = null
}
// botão "Confirm" do diálogo
fun confirmBooking(clientId: Int) {
val slot = slotBeingBooked ?: return
val day = lastDay ?: return
slotBeingBooked = null // fecha o diálogo
runSafely {
api.addAppointment(day, clientId, slot.id)
loadSchedule() // o horário agora aparece ocupado
}
}
// -----------------------------------------------------------------------
// botão "Cancel" de um horário ocupado, no ScheduleView
// -----------------------------------------------------------------------
fun cancelAppointment(appointment: AppointmentJson) {
runSafely {
api.deleteAppointment(appointment.id)
loadSchedule() // o horário volta a ficar livre
}
}
private fun loadSchedule() {
val doctorId = lastDoctorId ?: return
val day = lastDay ?: return
runSafely { schedule = api.getDoctorScheduleOfDay(doctorId, day) }
}
// -----------------------------------------------------------------------
// executa [action] em uma corrotina do ViewModel e transforma qualquer
// exceção em uma mensagem de erro exibida na tela. Fatorar este
// try/catch evita repeti-lo em cada método acima.
// Uma CancellationException NÃO é um erro: é o sinal de cancelamento
// de uma corrotina (ViewModel destruído), que deve ser deixado
// propagar.
// -----------------------------------------------------------------------
private fun runSafely(action: suspend () -> Unit) {
viewModelScope.launch {
try {
action()
} catch (e: CancellationException) {
throw e
} catch (e: Exception) {
Log.w("RdvMedecins", "a server call failed", e) // veja o Logcat
error = e.message ?: e.toString()
}
}
}
}
|
Vamos comentar este código:
- linha 45: a classe estende [ViewModel]; ela recebe pelo construtor os dois serviços de que precisa;
- linhas 48–54: o estado exibido por [App.kt]: propriedades de [by mutableStateOf(...)], legíveis por todos ([App.kt] as lê), mas modificáveis apenas pelo ViewModel ([private set]);
- linha 59: [slotBeingBooked]—o horário que está sendo agendado no momento. Se for diferente de [null], a caixa de diálogo de agendamento é exibida;
- linhas 65–66: a pesquisa mais recente (médico e dia), usada para atualizar o calendário após um agendamento ou cancelamento. São simples propriedades privadas: nunca são exibidas;
- linhas 78–83: [snapshotFlow { auth.isLoggedIn }] converte a leitura de um estado do Compose em um FLOW, uma sequência de valores: o valor atual imediatamente e, depois, cada novo valor. [collect { ... }] processa cada um deles: quando conectado, carrega médicos e pacientes; quando desconectado, limpa o estado. É o equivalente do [watch(..., { immediate: true })] do Vue.js, que a versão Flutter precisava replicar com [addListener(...)] e uma chamada inicial escrita à mão;
- linhas 94–96: [loadInitialLists()]—duas corrotinas separadas: as duas requisições são enviadas EM PARALELO;
- Linhas 116–117: [logOut()] simplesmente desconecta o [AuthService]; é o [snapshotFlow] que, então, dispara a limpeza do estado. O mesmo ocorre quando [AuthInterceptor] desconecta o usuário (token rejeitado pelo servidor): o ViewModel não precisa conhecer a causa da desconexão;
- Linhas 138–139: [requestBooking(...)] NÃO ABRE uma caixa de diálogo; ele apenas armazena o horário. A exibição segue o estado—é [App.kt] que emite [BookingDialog] enquanto [slotBeingBooked] for diferente de [null]. Essa caixa de diálogo, portanto, também sobrevive à rotação da tela (veja o Capítulo 5);
- linhas 148–154: [confirmBooking(...)]—fecha a caixa de diálogo, depois chama o servidor e atualiza o calendário: o horário aparece como agendado;
- linhas 182–190: [runSafely(action)]—executa [action] (uma função [suspend]) em uma corrotina do ViewModel e converte qualquer exceção em uma mensagem de erro exibida. [CancellationException] é relançada: isso não é um erro, mas um sinal de cancelamento da corrotina (o ViewModel é destruído), que deve poder se propagar. [Log.w(...)] grava o erro completo no log do Android, que pode ser consultado na aba [Logcat] do Android Studio.
5.5. A camada core/models
5.5.1. core/models/AppointmentModels.kt
Porte de [lib/core/models/appointment_models.dart]: as classes de dados trocadas com o servidor.
| // =========================================================================
// AppointmentModels.kt
// -------------------------------------------------------------------------
// As data classes trocadas com o servidor NestJS: o espelho, em
// Kotlin, do JSON retornado por suas rotas. Port de
// lib/core/models/appointment_models.dart (cliente Flutter deste curso).
//
// Grande diferença em relação à versão Flutter: NENHUM construtor
// fromJson(...) escrito à mão. A anotação @Serializable pede ao plugin de compilador
// kotlinx.serialization (veja app/build.gradle.kts)
// para GERAR, em tempo de compilação, o código que lê e escreve cada classe como
// JSON. Como em Dart (e ao contrário do TypeScript), os tipos são
// verificados em tempo de execução: uma chave obrigatória ausente, ou de
// tipo inesperado, lança uma exceção imediata (SerializationException).
//
// Uma "data class" do Kotlin (veja o curso de Kotlin) também traz, sem uma única
// linha de código: equals/hashCode (comparação por valor), toString e
// copy(...). Todas as propriedades são somente leitura (val): esses
// objetos são IMUTÁVEIS, o que combina perfeitamente com o Jetpack Compose,
// que compara o estado antigo e o novo para saber o que redesenhar.
// =========================================================================
package fr.rdvmedecins.client.core.models
import kotlinx.serialization.Serializable
// um médico, como retornado por GET /getAllDoctors (o servidor também envia
// um campo "version", ignorado aqui graças a ignoreUnknownKeys, veja
// Response.kt)
@Serializable
data class Doctor(
val id: Int,
val title: String,
val lastName: String,
val firstName: String,
)
// um paciente (cliente do consultório médico), retornado por GET /getAllClients
@Serializable
data class Client(
val id: Int,
val title: String,
val lastName: String,
val firstName: String,
)
// um horário de consulta: startHour/startMinute -> endHour/endMinute
@Serializable
data class SlotJson(
val id: Int,
val startHour: Int,
val startMinute: Int,
val endHour: Int,
val endMinute: Int,
)
// uma consulta: um dia, um paciente, um horário. Os valores padrão
// "= null" tornam as chaves opcionais no JSON recebido.
@Serializable
data class AppointmentJson(
val id: Int,
val day: String, // formato "yyyy-MM-dd"
val client: Client? = null,
val slot: SlotJson? = null,
)
// uma linha da agenda: um horário e, se estiver ocupado, sua consulta
@Serializable
data class DoctorDaySlot(
val slot: SlotJson,
val appointment: AppointmentJson? = null, // null = horário livre
)
// a agenda de um médico para um dia, retornada por
// GET /getDoctorScheduleOfDay/{doctorId}/{day}
@Serializable
data class DoctorDaySchedule(
val doctor: Doctor,
val day: String,
val slots: List<DoctorDaySlot>,
)
// -------------------------------------------------------------------------
// Autenticação
// -------------------------------------------------------------------------
// os dois papéis da aplicação. Os nomes das constantes são
// EXATAMENTE as strings enviadas pelo servidor ("ADMIN", "USER"):
// o kotlinx.serialization converte portanto a string JSON diretamente em uma
// constante de enum, enquanto a versão Flutter precisava escrever à mão
// Role.fromString(...) e asString().
@Serializable
enum class Role { ADMIN, USER }
// o corpo JSON enviado para POST /login
@Serializable
data class LoginRequest(
val login: String,
val password: String,
)
// o conteúdo de "data" na resposta de POST /login
@Serializable
data class LoginResult(
val accessToken: String, // o token JWT a apresentar em cada requisição seguinte
val login: String,
val name: String,
val role: Role,
)
// os corpos JSON enviados para POST /addAppointment e POST /deleteAppointment
@Serializable
data class AddAppointmentRequest(
val day: String,
val clientId: Int,
val slotId: Int,
)
@Serializable
data class DeleteAppointmentRequest(
val appointmentId: Int,
)
|
Vamos comentar este código:
- linhas 30–31: [@Serializable data class Doctor(...)]—uma “data class” (veja o curso de Kotlin): [equals]/[hashCode] por valor, [toString], [copy(...)], sem uma única linha de código. A anotação [@Serializable] instrui o plugin kotlinx.serialization a gerar, em tempo de compilação, o código que lê e grava a classe em JSON—onde a versão Flutter escrevia manualmente um construtor [fromJson(...)] por classe;
- linha 63: [val client: Client? = null]—um tipo anulável com valor padrão: a chave [client] pode estar ausente do JSON recebido ou pode ser [null];
- linha 71: [val appointment: AppointmentJson? = null] - [null] significa que o horário está disponível;
- linha 93: [enum class Role { ADMIN, USER }]—os nomes das constantes são exatamente as strings enviadas pelo servidor: o kotlinx.serialization converte diretamente ["ADMIN"] em [Role.ADMIN], enquanto a versão Flutter escrevia [Role.fromString(...)] e [asString()];
- Linhas 97, 113 e 120: as classes dos corpos JSON ENVIADOS ao servidor ([LoginRequest], [AddAppointmentRequest], [DeleteAppointmentRequest]): a mesma anotação, [@Serializable], é usada na codificação. A versão Flutter construía esses corpos com valores literais de [Map].
5.5.2. core/models/Response.kt
Decodificação do envelope [{ status, data }] comum a todas as respostas de negócio do servidor.
| // =========================================================================
// Response.kt
// -------------------------------------------------------------------------
// Todas as respostas de negócio do servidor NestJS têm o mesmo formato:
//
// { "status": 0, "data": ... }
//
// onde status é 0 em caso de sucesso (veja ResponseStatus no lado do servidor).
// A versão Flutter decodificava esse envelope com uma classe genérica
// ServerResponse<T>. Aqui procedemos em DUAS etapas, por um motivo específico: em caso
// de erro, o servidor coloca uma lista de mensagens em "data"
// (List<String>) onde, em caso de sucesso, esperamos por exemplo uma agenda.
// Decodificar {status, data} diretamente como ServerResponse<DoctorDaySchedule>
// falharia, portanto, em uma resposta de erro, antes mesmo de ler o status.
// 1. lemos o envelope como uma árvore JSON genérica (JsonObject);
// 2. verificamos status; somente se for 0 decodificamos "data" no
// tipo esperado.
// =========================================================================
package fr.rdvmedecins.client.core.models
import kotlinx.serialization.DeserializationStrategy
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.json.int
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
// a configuração JSON compartilhada por todo o cliente:
// - ignoreUnknownKeys: o servidor envia campos que este cliente
// não usa (p. ex. o "version" de um médico) - nós os ignoramos em vez de
// lançar uma exceção;
// - explicitNulls = false: na codificação, uma propriedade nula não é
// escrita (sem efeito nas classes deste cliente, mas mais próximo do
// comportamento de JSON.stringify no lado JavaScript).
val ApiJson = Json {
ignoreUnknownKeys = true
explicitNulls = false
}
// exceção lançada quando o servidor responde com um status de negócio
// diferente de 0 (recurso não encontrado, data inválida, erro do servidor)
class ResponseException(val status: Int) :
Exception("The server responded with error status $status")
// decodifica o corpo de uma resposta {status, data} e retorna "data" no
// tipo T descrito por [deserializer] (p. ex. Doctor.serializer(), ou
// ListSerializer(Doctor.serializer()) para uma lista de médicos)
fun <T> decodeResponse(body: String, deserializer: DeserializationStrategy<T>): T {
// 1. o envelope, como uma árvore JSON genérica
val envelope = ApiJson.parseToJsonElement(body).jsonObject
// 2. o status de negócio
val status = envelope.getValue("status").jsonPrimitive.int
if (status != 0) {
throw ResponseException(status)
}
// 3. "data", decodificado somente agora, no tipo esperado
val data = envelope["data"] ?: JsonNull
return ApiJson.decodeFromJsonElement(deserializer, data)
}
|
Vamos comentar este código:
- linhas 36–38: [ApiJson]—a configuração JSON compartilhada por todo o cliente. [ignoreUnknownKeys = true]: o servidor envia campos que o cliente não utiliza (por exemplo, [version] de um médico); sem essa configuração, o kotlinx.serialization lançaria uma exceção ao encontrar a primeira chave desconhecida;
- linha 43: [ResponseException]—a exceção lançada quando o servidor responde com um status de negócio diferente de 0;
- Linha 49: [decodeResponse(body, deserializer)] - uma função genérica: o parâmetro [deserializer] (por exemplo, [Doctor.serializer()], gerado pelo plugin) especifica o tipo [T] no qual decodificar [data];
- Linhas 51–59: a decodificação ocorre em DUAS etapas. Primeiro, o envelope é lido como uma árvore JSON genérica ([JsonObject]); depois, somente se [status] for 0, [data] é decodificado no tipo esperado. Motivo: em caso de erro, o servidor coloca uma lista de mensagens em [data], ao passo que, em caso de sucesso, espera-se, por exemplo, um calendário. Decodificar o envelope inteiro no tipo de sucesso logo de início falharia diante de uma resposta de erro, antes mesmo de se poder ler o status.
5.6. A camada core/services
5.6.1. core/services/SettingsService.kt
Porte de [lib/core/services/settings_service.dart]: a URL do servidor.
| // =========================================================================
// SettingsService.kt
// -------------------------------------------------------------------------
// Port de lib/core/services/settings_service.dart: guarda a URL do
// servidor NestJS, editável a partir da tela (campo "Server URL").
//
// A versão Flutter estendia ChangeNotifier e precisava chamar
// notifyListeners() após cada mudança. Aqui, a propriedade é
// declarada com "by mutableStateOf(...)": é um ESTADO OBSERVÁVEL do
// Jetpack Compose. Qualquer função @Composable que LEIA apiBaseUrl durante
// sua exibição é reexibida automaticamente quando o valor muda -
// sem notifyListeners(), sem context.watch<...>(): o Compose registra
// cada leitura por conta própria (o mesmo princípio de reactive(...) / ref(...)
// no lado Vue.js).
//
// Pequena melhoria em relação à versão Flutter: a URL é
// armazenada nas SharedPreferences do celular, para que não precise
// ser digitada de novo a cada inicialização da aplicação (no mobile, ela difere
// quase sempre do valor padrão, veja o capítulo 5).
// =========================================================================
package fr.rdvmedecins.client.core.services
import android.content.SharedPreferences
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.core.content.edit
class SettingsService(private val prefs: SharedPreferences) {
// o valor inicial é relido das preferências,
// SINCRONAMENTE: getString(...) responde imediatamente (as preferências são
// carregadas em memória no primeiro acesso). "private set": somente esta
// classe pode modificar a URL, por meio de changeUrl(...).
var apiBaseUrl: String by mutableStateOf(prefs.getString(URL_KEY, null) ?: DEFAULT_URL)
private set
fun changeUrl(url: String) {
if (url == apiBaseUrl) {
return // evita uma reexibição e uma escrita inúteis
}
apiBaseUrl = url
// edit { ... }: função de extensão do androidx.core (core-ktx);
// ela abre um editor, executa o bloco e depois chama apply(), que
// grava em disco em segundo plano, sem bloquear a UI.
prefs.edit { putString(URL_KEY, url) }
}
companion object {
// 10.0.2.2: no emulador Android, este endereço especial
// designa a máquina host, aquela onde roda o servidor NestJS
// (localhost designaria o próprio emulador, veja o capítulo 5)
const val DEFAULT_URL = "http://10.0.2.2:8080"
private const val URL_KEY = "rdvmedecins.apiBaseUrl"
}
}
|
Vamos comentar este código:
- linhas 36–37: [var apiBaseUrl: String by mutableStateOf(...)]—um estado observável, inicializado com o valor armazenado nas preferências ou com o valor padrão. [private set]: somente esta classe pode modificá-lo;
- linha 39: [changeUrl(...)]—o método não pode se chamar [setApiBaseUrl]: esse nome já é usado pelo “setter” privado que o Kotlin gera para a propriedade [apiBaseUrl] (ambos teriam a mesma assinatura para a JVM);
- linha 47: [prefs.edit { putString(...) }]—uma função de extensão da biblioteca [core-ktx]: ela abre um editor, executa o bloco e depois chama [apply()], que grava em disco em segundo plano. A URL é, assim, mantida na próxima inicialização (uma pequena melhoria em relação à versão Flutter, útil em um celular, onde a URL quase sempre difere do valor padrão);
- linha 54: [DEFAULT_URL = "http://10.0.2.2:8080"]—o endereço do servidor visto do emulador Android (veja o Capítulo 5). A versão Flutter, que também se destinava à web e ao desktop, usava [localhost].
5.6.2. core/services/AuthService.kt
Porte de [lib/core/services/auth_service.dart]: a sessão do usuário autenticado, o login e o logout.
| // =========================================================================
// AuthService.kt
// -------------------------------------------------------------------------
// Port de lib/core/services/auth_service.dart: a sessão do
// usuário logado (token JWT, login, nome, papel), o login
// (POST /login) e o logout.
//
// Como em SettingsService, as propriedades exibidas pela UI são
// estados do Compose (mutableStateOf): a exibição passa AUTOMATICAMENTE
// da tela de login para a agenda assim que isLoggedIn se torna true.
//
// A sessão é armazenada nas SharedPreferences: um usuário que
// reinicia a aplicação a recupera sem fazer login de novo (enquanto o token
// não tiver expirado - veja AuthInterceptor para o caso do token expirado).
// Diferença em relação ao Flutter: SharedPreferences (a API original do Android,
// cujo nome o pacote shared_preferences do Flutter tomou emprestado) é lida
// SINCRONAMENTE. A sessão é portanto restaurada logo no construtor (bloco
// init), sem método init() assíncrono a aguardar antes de exibir a
// primeira tela.
// =========================================================================
package fr.rdvmedecins.client.core.services
import android.content.SharedPreferences
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.core.content.edit
import fr.rdvmedecins.client.core.models.ApiJson
import fr.rdvmedecins.client.core.models.LoginRequest
import fr.rdvmedecins.client.core.models.LoginResult
import fr.rdvmedecins.client.core.models.Role
import fr.rdvmedecins.client.core.models.decodeResponse
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException
class AuthService(
private val settings: SettingsService,
private val prefs: SharedPreferences,
// um cliente HTTP SEM o interceptor de autenticação: POST /login
// é a única rota pública do servidor, não há token a
// enviar (veja RdvMedecinsApplication)
private val http: OkHttpClient,
) {
// estado da sessão, observado pela UI
var isLoggedIn by mutableStateOf(false)
private set
var login by mutableStateOf<String?>(null)
private set
var name by mutableStateOf<String?>(null)
private set
var role by mutableStateOf<Role?>(null)
private set
// o token nunca é EXIBIDO: não é preciso torná-lo um estado do Compose.
// Ele é porém lido por AuthInterceptor em uma thread de rede:
// @Volatile garante que essa thread sempre veja o último valor
// escrito pela thread principal.
@Volatile
var accessToken: String? = null
private set
// propriedade calculada: relê role a cada acesso (e, quando lida durante
// uma exibição, inscreve a exibição nas mudanças de role)
val isAdmin: Boolean
get() = role == Role.ADMIN
init {
restoreSession()
}
// -----------------------------------------------------------------------
// relê uma sessão possivelmente armazenada durante uma inicialização anterior
// -----------------------------------------------------------------------
private fun restoreSession() {
val raw = prefs.getString(SESSION_KEY, null) ?: return // nenhuma sessão armazenada
try {
// a sessão foi armazenada como um LoginResult
// serializado em JSON (veja logIn): nós a relemos como está
applySession(ApiJson.decodeFromString(LoginResult.serializer(), raw))
} catch (e: Exception) {
// conteúdo ilegível (p. ex. o formato de uma versão antiga da
// aplicação): nós o esquecemos, o usuário fará login de novo
prefs.edit { remove(SESSION_KEY) }
}
}
// -----------------------------------------------------------------------
// POST /login. "suspend": esta função pode pausar pelo
// tempo que o servidor levar para responder, SEM bloquear a thread chamadora -
// o equivalente a uma função async que retorna um Future<LoginResult>
// no lado Dart. Ela lança uma exceção se o login falhar.
// -----------------------------------------------------------------------
suspend fun logIn(login: String, password: String): LoginResult {
// withContext(Dispatchers.IO): o bloco executa em uma thread
// reservada para entrada/saída. O Android PROÍBE qualquer acesso à rede
// a partir da thread principal (NetworkOnMainThreadException): ela é
// quem desenha a UI, nunca deve esperar.
val result = withContext(Dispatchers.IO) {
val body = ApiJson.encodeToString(LoginRequest.serializer(), LoginRequest(login, password))
val request = Request.Builder()
.url("${settings.apiBaseUrl}/login")
.post(body.toRequestBody(JSON_TYPE))
.build()
// execute(): uma chamada BLOQUEANTE - inofensiva aqui, estamos em uma thread
// de entrada/saída. use { } fecha a resposta ao final do
// bloco, aconteça o que acontecer (o equivalente ao
// try-with-resources do Java, veja o curso de Kotlin).
http.newCall(request).execute().use { response ->
// credenciais erradas: o servidor responde 401 Unauthorized
if (!response.isSuccessful) {
throw IOException("Login failed (HTTP ${response.code})")
}
decodeResponse(response.body!!.string(), LoginResult.serializer())
}
}
// de volta à thread do chamador (a thread principal):
// é aqui, e não na thread de entrada/saída, que modificamos o
// estado observado pela UI
applySession(result)
prefs.edit { putString(SESSION_KEY, ApiJson.encodeToString(LoginResult.serializer(), result)) }
return result
}
// -----------------------------------------------------------------------
// logout: esquecemos a sessão, em memória e nas preferências.
// Deve ser chamado na thread principal (veja AuthInterceptor).
// -----------------------------------------------------------------------
fun logOut() {
accessToken = null
login = null
name = null
role = null
isLoggedIn = false
prefs.edit { remove(SESSION_KEY) }
}
private fun applySession(session: LoginResult) {
accessToken = session.accessToken
login = session.login
name = session.name
role = session.role
isLoggedIn = true
}
companion object {
private const val SESSION_KEY = "rdvmedecins.session"
private val JSON_TYPE = "application/json; charset=utf-8".toMediaType()
}
}
|
Vamos comentar este código:
- linhas 51–57: o estado da sessão, como observado pela interface: [isLoggedIn], [login], [name], [role];
- linhas 64–65: [accessToken] nunca é exibido: não há necessidade de torná-lo um estado do Compose. No entanto, ele é lido por [AuthInterceptor] em uma thread de rede: [@Volatile] garante que essa thread sempre veja o último valor gravado pela thread principal;
- linhas 70–71: [isAdmin]—uma propriedade calculada ([get() = ...]), relida a cada acesso;
- linhas 73–85: o bloco [init] restaura qualquer sessão em cache assim que o serviço é inicializado: as preferências são lidas de forma síncrona. A sessão é armazenada como um [LoginResult] serializado em JSON, que é então relido com [decodeFromString(LoginResult.serializer(), raw)];
- linha 99: [suspend fun logIn(...)]—uma função suspensa: ela fica em pausa enquanto aguarda a resposta do servidor, sem bloquear a thread chamadora;
- linha 104: [withContext(Dispatchers.IO) { ... }]—a requisição é executada em uma thread de E/S; o valor da última expressão do bloco (o [LoginResult] decodificado) é o resultado;
- linhas 106–109: a requisição OkHttp: [Request.Builder()], URL e, em seguida, [.post(body.toRequestBody(JSON_TYPE))]—o corpo JSON, com o seu tipo MIME;
- Linha 114: [execute()] executa a requisição de forma BLOQUEANTE—com segurança, em uma thread de E/S. [use { response -> ... }] fecha a resposta ao final do bloco, aconteça o que acontecer: o equivalente do `try-with-resources` do Java;
- Linhas 116–117: credenciais incorretas: o servidor retorna uma resposta 401 Unauthorized; uma exceção é lançada, que [LoginPage] converte em uma mensagem de erro;
- linhas 125–126: de volta à thread chamadora (a thread principal), a sessão é aplicada—o que altera o estado observado: a tela passa automaticamente para o calendário—e, em seguida, é salva nas preferências;
- linhas 134–140: [logOut()]—descarta a sessão, tanto na memória quanto nas preferências.
5.6.3. core/services/AppointmentService.kt
Porte de [lib/core/services/appointment_service.dart]: um método por rota de negócio usada pelo cliente.
| // =========================================================================
// AppointmentService.kt
// -------------------------------------------------------------------------
// Port de lib/core/services/appointment_service.dart: um método por rota
// de negócio do servidor NestJS usada por este cliente. Cada método é uma
// função "suspend" (veja AuthService.logIn) que retorna
// diretamente os dados úteis ("data" do envelope {status, data}), ou
// lança uma exceção.
//
// O cliente HTTP recebido no construtor contém AuthInterceptor (veja
// RdvMedecinsApplication): nenhum dos métodos abaixo precisa, portanto,
// se preocupar com o token JWT.
//
// Este serviço NÃO tem estado observável (nada nele varia depois de construído):
// é uma classe comum, sem mutableStateOf - o equivalente ao
// simples Provider.value(value: api) (e não ChangeNotifierProvider) da
// versão Flutter.
// =========================================================================
package fr.rdvmedecins.client.core.services
import fr.rdvmedecins.client.core.models.DoctorDaySchedule
import fr.rdvmedecins.client.core.models.AddAppointmentRequest
import fr.rdvmedecins.client.core.models.Client
import fr.rdvmedecins.client.core.models.ApiJson
import fr.rdvmedecins.client.core.models.Doctor
import fr.rdvmedecins.client.core.models.AppointmentJson
import fr.rdvmedecins.client.core.models.DeleteAppointmentRequest
import fr.rdvmedecins.client.core.models.decodeResponse
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.DeserializationStrategy
import kotlinx.serialization.builtins.ListSerializer
import kotlinx.serialization.json.JsonElement
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException
class AppointmentService(
private val http: OkHttpClient,
private val settings: SettingsService,
) {
// -----------------------------------------------------------------------
// as rotas GET
// -----------------------------------------------------------------------
suspend fun getAllDoctors(): List<Doctor> =
call(getRequest("/getAllDoctors"), ListSerializer(Doctor.serializer()))
suspend fun getAllClients(): List<Client> =
call(getRequest("/getAllClients"), ListSerializer(Client.serializer()))
suspend fun getDoctorScheduleOfDay(doctorId: Int, day: String): DoctorDaySchedule =
call(getRequest("/getDoctorScheduleOfDay/$doctorId/$day"), DoctorDaySchedule.serializer())
// -----------------------------------------------------------------------
// as rotas POST (reservadas ao papel ADMIN pelo servidor)
// -----------------------------------------------------------------------
suspend fun addAppointment(day: String, clientId: Int, slotId: Int): AppointmentJson {
val body = ApiJson.encodeToString(
AddAppointmentRequest.serializer(),
AddAppointmentRequest(day, clientId, slotId),
)
return call(postRequest("/addAppointment", body), AppointmentJson.serializer())
}
suspend fun deleteAppointment(appointmentId: Int) {
val body = ApiJson.encodeToString(DeleteAppointmentRequest.serializer(), DeleteAppointmentRequest(appointmentId))
// "data" é null em caso de sucesso: nós o decodificamos como um elemento
// JSON qualquer e o ignoramos
call(postRequest("/deleteAppointment", body), JsonElement.serializer())
}
// -----------------------------------------------------------------------
// construção das requisições
// -----------------------------------------------------------------------
private fun getRequest(path: String): Request =
Request.Builder().url(settings.apiBaseUrl + path).get().build()
private fun postRequest(path: String, jsonBody: String): Request =
Request.Builder()
.url(settings.apiBaseUrl + path)
.post(jsonBody.toRequestBody(JSON_TYPE))
.build()
// -----------------------------------------------------------------------
// executa uma requisição em uma thread de entrada/saída e decodifica a
// resposta {status, data}. O parâmetro genérico <T> e o
// [deserializer] que o acompanha indicam em qual tipo decodificar
// "data" - o papel do parâmetro parseData da versão Flutter.
// -----------------------------------------------------------------------
private suspend fun <T> call(request: Request, deserializer: DeserializationStrategy<T>): T =
withContext(Dispatchers.IO) {
http.newCall(request).execute().use { response ->
// 401 (token rejeitado), 403 (papel insuficiente), 404...: o
// corpo não é um envelope {status, data}
if (!response.isSuccessful) {
throw IOException("HTTP error ${response.code}")
}
decodeResponse(response.body!!.string(), deserializer)
}
}
companion object {
private val JSON_TYPE = "application/json; charset=utf-8".toMediaType()
}
}
|
Vamos comentar este código:
- linhas 48–55: as três rotas GET. Cada método é uma função [suspend] escrita como expressão: ela constrói a requisição e especifica o tipo esperado de [data]. [ListSerializer(Doctor.serializer())] descreve um [List<Doctor>];
- linhas 60–72: as duas rotas POST: o corpo JSON é codificado a partir das classes [AddAppointmentRequest] e [DeleteAppointmentRequest]. Para [/deleteAppointment], [data] equivale a [null] em caso de sucesso: ele é decodificado como qualquer elemento JSON ([JsonElement.serializer()]) e ignorado;
- linhas 93–101: [call(...)]—o método padrão: executado em uma thread de E/S, verifica o código HTTP (401 token rejeitado, 403 papel insuficiente: o corpo, portanto, não é um envelope [{status, data}]) e, em seguida, decodifica com [decodeResponse(...)].
Este serviço não tem estado observável: nada muda depois que ele é construído. É uma classe comum—o equivalente do simples [Provider.value(value: api)] (e não de [ChangeNotifierProvider]) na versão Flutter.
5.7. A camada core/http
5.7.1. core/http/AuthInterceptor.kt
Porte de [lib/core/http/auth_http_client.dart]: adição do token JWT a cada requisição e logout ao receber uma resposta 401.
| // =========================================================================
// AuthInterceptor.kt
// -------------------------------------------------------------------------
// Port de lib/core/http/auth_http_client.dart. Duas responsabilidades,
// as mesmas de todas as variantes deste curso:
// 1. adicionar o cabeçalho "Authorization: Bearer <token>" a cada requisição;
// 2. fazer o logout do usuário se o servidor responder 401 Unauthorized
// (token expirado ou inválido).
//
// A versão Flutter envolvia o cliente HTTP em uma classe própria,
// por falta de um mecanismo de interceptação no pacote http. O OkHttp, por outro lado,
// oferece INTERCEPTORS: objetos pelos quais cada
// requisição passa antes de ser enviada, e cada resposta antes de voltar ao
// chamador - exatamente a noção de interceptor HTTP do Angular
// (auth.interceptor.ts na variante Angular deste curso).
// =========================================================================
package fr.rdvmedecins.client.core.http
import android.os.Handler
import android.os.Looper
import fr.rdvmedecins.client.core.services.AuthService
import okhttp3.Interceptor
import okhttp3.Response
class AuthInterceptor(private val auth: AuthService) : Interceptor {
// um Handler ligado à thread principal: ele nos permite repassar-lhe
// trabalho a partir de outra thread (veja intercept abaixo)
private val mainThread = Handler(Looper.getMainLooper())
// chamado pelo OkHttp para CADA requisição, em uma thread de rede
override fun intercept(chain: Interceptor.Chain): Response {
// 1. a requisição original, mais o token, se houver. Uma
// requisição OkHttp é imutável: newBuilder() faz dela uma cópia
// modificável.
val token = auth.accessToken
val request = if (token == null) {
chain.request()
} else {
chain.request().newBuilder()
.header("Authorization", "Bearer $token")
.build()
}
// 2. deixamos a requisição seguir seu caminho até o servidor
val response = chain.proceed(request)
// 3. token rejeitado: fazemos o logout do usuário. Este método
// executa em uma thread de rede; porém logOut() modifica o
// estado exibido pela UI: então repassamos essa chamada à
// thread principal (post), sem esperar que ela execute - o
// equivalente ao unawaited(auth.logOut()) da versão Flutter.
if (response.code == 401) {
mainThread.post { auth.logOut() }
}
return response
}
}
|
Vamos comentar este código:
- Linha 26: a classe implementa a interface [okhttp3.Interceptor]. O OkHttp faz cada requisição passar pelos interceptors do cliente antes de enviá-la, e cada resposta antes de devolvê-la ao chamador: é o conceito dos interceptors HTTP do Angular. A versão Flutter, sem esse mecanismo no pacote [http], encapsulava o cliente HTTP em uma classe própria;
- linha 30: um [Handler] associado à thread principal ([Looper.getMainLooper()]): isso permite delegar trabalho a ela a partir de outra thread;
- linhas 41–43: uma requisição OkHttp é IMUTÁVEL; [newBuilder()] cria uma cópia modificável dela, acrescida do cabeçalho [Authorization];
- linha 46: [chain.proceed(request)]—a requisição segue para o servidor; o método retorna a resposta;
- linhas 52–53: token rejeitado (401): [intercept] é executado em uma thread de rede, mas [logOut()] modifica o estado exibido. A chamada é, portanto, delegada à thread principal ([post { ... }]), sem esperar pela execução—o equivalente de [unawaited(auth.logOut())] na versão Flutter.
5.8. A camada core/i18n
5.8.1. core/i18n/TranslationsService.kt
Porte de [lib/core/i18n/translations_service.dart]: alternância da interface entre francês e inglês em tempo real.
| // =========================================================================
// TranslationsService.kt
// -------------------------------------------------------------------------
// Port de lib/core/i18n/translations_service.dart: alternar a UI entre
// francês e inglês, na hora, sem reiniciar
// a aplicação. Os dicionários são os MESMOS arquivos JSON que os
// dos clientes Flutter e Vue.js deste curso (fr.json, en.json), colocados aqui
// em app/src/main/assets/i18n/: a pasta assets/ de um projeto Android
// é embutida como está na aplicação (o arquivo .apk), como os
// assets declarados no pubspec.yaml da versão Flutter.
//
// Nota: a maneira "oficial" do Android de traduzir uma
// aplicação se baseia em arquivos de recursos res/values/strings.xml
// (inglês) e res/values-fr/strings.xml (francês), com o sistema
// escolhendo o arquivo certo conforme o idioma do CELULAR. Este documento
// mantém os dicionários JSON compartilhados por todas as variantes do curso,
// e a troca FR/EN dentro da própria aplicação, como fazia a
// aplicação original (2014).
// =========================================================================
package fr.rdvmedecins.client.core.i18n
import android.content.SharedPreferences
import android.content.res.AssetManager
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.core.content.edit
import fr.rdvmedecins.client.core.models.ApiJson
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonObject
class TranslationsService(
private val assets: AssetManager,
private val prefs: SharedPreferences,
) {
// o idioma exibido: um estado do Compose. Como t(...) abaixo LÊ
// esta propriedade, qualquer texto exibido com t(...) é automaticamente
// reexibido quando o idioma muda - sem context.watch<...>() a
// escrever, ao contrário da versão Flutter.
var currentLanguage by mutableStateOf(prefs.getString(LANGUAGE_KEY, null) ?: DEFAULT_LANGUAGE)
private set
// os dicionários já carregados, por idioma ("fr" -> {...})
private val dictionaries = mutableMapOf<String, JsonObject>()
fun changeLanguage(language: String) {
if (language == currentLanguage) {
return
}
dictionary(language) // carrega o dicionário ANTES de mudar o idioma
currentLanguage = language
prefs.edit { putString(LANGUAGE_KEY, language) }
}
// -----------------------------------------------------------------------
// t("LOGIN.TITLE"): percorre o dicionário do idioma atual
// segmento por segmento ("LOGIN", depois "TITLE"). Se a chave não
// for encontrada, a própria chave é retornada: o texto ausente permanece assim
// visível na tela, sem derrubar a aplicação.
// -----------------------------------------------------------------------
fun t(key: String): String {
var currentValue: JsonElement = dictionary(currentLanguage)
for (segment in key.split('.')) {
currentValue = (currentValue as? JsonObject)?.get(segment) ?: return key
}
val primitive = currentValue as? JsonPrimitive
return if (primitive != null && primitive.isString) primitive.content else key
}
// -----------------------------------------------------------------------
// o dicionário de um idioma, carregado na primeira vez em que é necessário e depois mantido
// em memória. getOrPut: retorna o valor associado à chave, ou executa
// o bloco, armazena seu resultado e o retorna. A leitura é
// síncrona: os dois arquivos têm apenas algumas centenas de
// bytes, lê-los é instantâneo.
// -----------------------------------------------------------------------
private fun dictionary(language: String): JsonObject =
dictionaries.getOrPut(language) {
assets.open("i18n/$language.json").bufferedReader().use { reader ->
ApiJson.parseToJsonElement(reader.readText()).jsonObject
}
}
companion object {
private const val LANGUAGE_KEY = "rdvmedecins.language"
private val DEFAULT_LANGUAGE = if (java.util.Locale.getDefault().language == "fr") "fr" else "en"
}
}
|
Vamos comentar este código:
- Linhas 43–44: [currentLanguage]—um estado observável. Como [t(...)] LÊ essa propriedade, qualquer função @Composable que exiba texto com [t(...)] é recomposta automaticamente quando o idioma muda: não é necessário escrever nenhum [context.watch<...>()];
- linhas 49–55: [changeLanguage(...)]—carrega o dicionário ANTES de trocar de idioma, depois salva a seleção nas preferências;
- Linhas 64–70: [t("LOGIN.TITLE")]—percorre o dicionário segmento por segmento. [as?] é a conversão de tipo “segura” do Kotlin: ela retorna [null] (em vez de lançar uma exceção) se o objeto não for do tipo solicitado; combinada com [?: return key], faz com que a própria chave seja retornada assim que um segmento não puder ser encontrado—o texto ausente permanece visível na tela;
- linhas 80–83: [dictionary(language)] – [getOrPut] retorna o dicionário já carregado ou executa o bloco (leitura de [assets/i18n/<language>.json]), armazena o resultado e o retorna. A leitura é síncrona: os dois arquivos têm apenas algumas centenas de bytes.
5.8.2. assets/i18n/fr.json e assets/i18n/en.json
Os dicionários são os dos clientes Flutter e Vue.js, com quatro pequenos ajustes: o título do aplicativo, os rótulos do seletor de data ([DOCTOR_DAY_PICKER.PICK_DAY], [OK], [CANCEL]), a mensagem de instrução do calendário (“toque” em vez de “clique”) e a remoção de uma chave que não é mais necessária. Trecho de [fr.json]:
| {
"APP": {
"TITLE": "RdvMedecins - Kotlin / Android",
"SERVER_URL_LABEL": "URL du serveur",
"LOGOUT": "Se déconnecter"
},
"LOGIN": {
"TITLE": "Connexion",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Mot de passe",
"SUBMIT": "Se connecter",
"SUBMITTING": "Connexion...",
"ERROR": "Login ou mot de passe incorrect.",
"DEMO_ACCOUNTS_PREFIX": "Comptes de démonstration :",
"DEMO_ACCOUNTS_ADMIN": "(rôle ADMIN, accès complet)",
"DEMO_ACCOUNTS_OR": "ou",
"DEMO_ACCOUNTS_USER": "(rôle USER, lecture seule)"
},
"DOCTOR_DAY_PICKER": {
"DOCTOR_LABEL": "Médecin",
"CHOOSE_DOCTOR": "-- choisir un médecin --",
"DAY_LABEL": "Jour",
"VIEW_SCHEDULE": "Voir l'agenda",
"PICK_DAY": "Choisir le jour",
"OK": "OK",
"CANCEL": "Annuler"
},
|
Nota: o método “oficial” do Android para traduzir um aplicativo baseia-se em arquivos de recursos [res/values/strings.xml] (inglês) e [res/values-fr/strings.xml] (francês), com o sistema selecionando o arquivo correto de acordo com o idioma do CELULAR. Este documento mantém os dicionários JSON comuns a todas as variantes do curso e a alternância FR/EN dentro do próprio aplicativo, exatamente como no aplicativo original (2014). Uma consequência perceptível: componentes fornecidos pelo sistema, como o seletor de data, seguem a configuração de idioma do celular, e não o idioma selecionado dentro do aplicativo.
5.9. A camada core/ui
5.9.1. core/ui/DropdownList.kt
Uma lista suspensa genérica, usada duas vezes: para selecionar um médico e para selecionar um paciente. O Flutter tinha um widget pronto para isso, [DropdownButtonFormField]; o Material 3 para Compose oferece uma combinação de três elementos, reunidos aqui de uma vez por todas.
| // =========================================================================
// DropdownList.kt
// -------------------------------------------------------------------------
// Uma lista suspensa genérica (o <select> do HTML), usada duas vezes
// neste cliente: escolha do médico (DoctorDayPicker) e escolha do paciente
// (BookingDialog). A versão Flutter tinha um widget pronto para
// isso, DropdownButtonFormField; o Material 3 para Compose oferece uma
// montagem de três elementos - ExposedDropdownMenuBox, um campo de
// texto somente leitura e o menu ExposedDropdownMenu - que agrupamos aqui
// de uma vez por todas.
//
// A função é GENÉRICA (<T>): ela exibe uma lista de médicos
// tanto quanto uma lista de pacientes. [itemLabel] diz como exibir um item,
// [idOf] como identificá-lo.
// =========================================================================
package fr.rdvmedecins.client.core.ui
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ExposedDropdownMenuBox
import androidx.compose.material3.ExposedDropdownMenuDefaults
import androidx.compose.material3.ExposedDropdownMenuAnchorType
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.setValue
import androidx.compose.ui.Modifier
// as APIs ExposedDropdownMenu* ainda são marcadas como "experimental" pelo
// Material 3: @OptIn declara que as usamos conscientemente
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun <T> DropdownList(
label: String,
placeholder: String, // texto exibido enquanto nada for escolhido
items: List<T>,
selectedId: Int?, // id do item escolhido, ou null
idOf: (T) -> Int,
itemLabel: (T) -> String,
onSelect: (Int) -> Unit,
modifier: Modifier = Modifier,
) {
// menu aberto ou fechado: um estado LOCAL a esta função, lembrado de uma
// exibição para a seguinte por remember (veja o capítulo 3)
var menuOpen by remember { mutableStateOf(false) }
val selected = items.firstOrNull { idOf(it) == selectedId }
ExposedDropdownMenuBox(
expanded = menuOpen,
onExpandedChange = { menuOpen = it },
modifier = modifier,
) {
// o campo que exibe a escolha atual; menuAnchor(...) o torna o
// ponto de ancoragem do menu (um clique nele abre o menu)
OutlinedTextField(
value = selected?.let(itemLabel) ?: "",
onValueChange = {},
readOnly = true,
singleLine = true,
label = { Text(label) },
placeholder = { Text(placeholder) },
trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = menuOpen) },
modifier = Modifier
.menuAnchor(ExposedDropdownMenuAnchorType.PrimaryNotEditable)
.fillMaxWidth(),
)
// o próprio menu: um DropdownMenuItem por item
ExposedDropdownMenu(expanded = menuOpen, onDismissRequest = { menuOpen = false }) {
items.forEach { item ->
DropdownMenuItem(
text = { Text(itemLabel(item)) },
onClick = {
onSelect(idOf(item))
menuOpen = false
},
)
}
}
}
}
|
Vamos detalhar este código:
- linhas 38–46: [fun <T> DropdownList(...)]—uma função @Composable GENÉRICA: ela exibe tanto médicos quanto pacientes. [idOf] especifica como identificar um elemento, [itemLabel] como exibi-lo e [onSelect] indica o identificador escolhido;
- linha 46: [modifier: Modifier = Modifier]—a convenção do Compose: todo componente reutilizável aceita um modifier, aplicado ao seu elemento raiz, para que o chamador possa ajustar seu tamanho ou suas margens;
- linha 50: [var menuOpen by remember { mutableStateOf(false) }]—o estado local do componente: menu aberto ou fechado;
- linha 53: [ExposedDropdownMenuBox]—o contêiner, que gerencia a abertura e o fechamento do menu;
- linhas 60–69: o campo somente leitura que exibe a seleção atual. [menuAnchor(...)] serve como ponto de ancoragem do menu: tocar nele abre o menu;
- linhas 73–79: o próprio menu: um [DropdownMenuItem] por item, gerado por um laço [forEach].
5.10. A camada features
Como em todas as versões do curso, cada funcionalidade da tela é um componente: ele recebe seus dados como parâmetros (entradas) e sinaliza as ações do usuário por meio de funções (saídas). Apenas [LoginPage] chama diretamente um serviço ([AuthService]).
5.10.1. features/login/LoginPage.kt
Porte de [lib/features/login/login_page.dart]: a tela de login.
| // =========================================================================
// LoginPage.kt
// -------------------------------------------------------------------------
// Port de lib/features/login/login_page.dart: a tela de login
// (login, senha, botão "Log in", mensagem de erro).
//
// A versão Flutter precisava de DUAS classes (_LoginForm e
// _LoginFormState) e de dois TextEditingControllers a descartar em
// dispose(). Uma única função @Composable basta aqui: seus estados locais são
// declarados diretamente na função, com remember / rememberSaveable.
// =========================================================================
package fr.rdvmedecins.client.features.login
import android.util.Log
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
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.layout.widthIn
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Surface
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.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import fr.rdvmedecins.client.core.LocalAuth
import fr.rdvmedecins.client.core.LocalTranslations
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.launch
@Composable
fun LoginPage() {
val auth = LocalAuth.current
val t = LocalTranslations.current::t
// estado local da tela
// rememberSaveable: o valor é lembrado de uma exibição para a seguinte
// E sobrevive à recriação da Activity (rotação de tela) - um
// login pela metade não se perde se o celular for girado.
var login by rememberSaveable { mutableStateOf("") }
var password by rememberSaveable { mutableStateOf("") }
// a chave de tradução da mensagem de erro (e não a mensagem traduzida:
// assim ela acompanha uma mudança de idioma), ou null
var error by rememberSaveable { mutableStateOf<String?>(null) }
// somente remember: um login em andamento não precisa sobreviver a uma rotação
var inProgress by remember { mutableStateOf(false) }
// um escopo de corrotinas ligado a esta tela: as corrotinas
// iniciadas nele são canceladas se a tela desaparecer
val scope = rememberCoroutineScope()
// uma função local (veja o curso de Kotlin): a validação do
// formulário, chamada pelo botão E pela tecla "Done" do teclado
fun submit() {
if (login.isBlank() || password.isEmpty() || inProgress) {
return
}
error = null
inProgress = true
scope.launch {
try {
// em caso de sucesso, AuthService define isLoggedIn como true:
// App.kt então substitui AUTOMATICAMENTE esta tela pela
// agenda - nada mais a fazer aqui
auth.logIn(login.trim(), password)
} catch (e: CancellationException) {
throw e
} catch (e: Exception) {
// a causa exata (servidor inacessível, credenciais erradas...)
// é escrita no log do Android (aba Logcat do Android
// Studio); o usuário vê uma mensagem simples
Log.w("RdvMedecins", "login failed", e)
error = "LOGIN.ERROR"
} finally {
inProgress = false
}
}
}
// Box + Alignment.TopCenter: o card fica centralizado horizontalmente
Box(modifier = Modifier.fillMaxWidth(), contentAlignment = Alignment.TopCenter) {
Card(modifier = Modifier.widthIn(max = 420.dp).fillMaxWidth()) {
Column(
modifier = Modifier.padding(24.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
Text(t("LOGIN.TITLE"), style = MaterialTheme.typography.titleLarge)
error?.let { key ->
Surface(
color = MaterialTheme.colorScheme.errorContainer,
contentColor = MaterialTheme.colorScheme.onErrorContainer,
shape = RoundedCornerShape(4.dp),
modifier = Modifier.fillMaxWidth(),
) {
Text(t(key), modifier = Modifier.padding(8.dp))
}
}
OutlinedTextField(
value = login,
onValueChange = { login = it },
label = { Text(t("LOGIN.LOGIN_LABEL")) },
singleLine = true,
// tecla "Next" do teclado: passa para o próximo campo
keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),
modifier = Modifier.fillMaxWidth(),
)
OutlinedTextField(
value = password,
onValueChange = { password = it },
label = { Text(t("LOGIN.PASSWORD_LABEL")) },
singleLine = true,
// exibe pontos no lugar dos caracteres
visualTransformation = PasswordVisualTransformation(),
keyboardOptions = KeyboardOptions(
keyboardType = KeyboardType.Password,
imeAction = ImeAction.Done,
),
// tecla "Done" do teclado: envia o formulário
keyboardActions = KeyboardActions(onDone = { submit() }),
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(4.dp))
Button(
onClick = { submit() },
enabled = !inProgress,
modifier = Modifier.fillMaxWidth(),
) {
Text(if (inProgress) t("LOGIN.SUBMITTING") else t("LOGIN.SUBMIT"))
}
Text(
text = "${t("LOGIN.DEMO_ACCOUNTS_PREFIX")} admin / admin ${t("LOGIN.DEMO_ACCOUNTS_ADMIN")} " +
"${t("LOGIN.DEMO_ACCOUNTS_OR")} user / user ${t("LOGIN.DEMO_ACCOUNTS_USER")}.",
style = MaterialTheme.typography.bodySmall,
)
}
}
}
}
|
Vamos comentar este código:
- linhas 60–66: os estados locais da tela. [rememberSaveable] para o nome de usuário, a senha e a mensagem de erro: esses estados persistem durante uma rotação da tela. [remember] é usado apenas para [inProgress]: uma conexão em andamento não precisa sobreviver a ela;
- linha 70: [rememberCoroutineScope()]—um escopo de corrotinas associado a esta tela: as corrotinas iniciadas nele são canceladas se a tela desaparecer;
- linha 74: [fun submit()]—uma função LOCAL (declarada dentro de outra função; veja o curso de Kotlin), chamada pelo botão e pela tecla “Done” do teclado;
- Linhas 80–93: [scope.launch { ... }] inicia a conexão em uma corrotina. Em caso de sucesso, não há mais nada a fazer: [AuthService] altera [isLoggedIn] para [true], e [App.kt] substitui AUTOMATICAMENTE esta tela pela agenda. Se a operação falhar, a CHAVE da mensagem de erro é armazenada (e não a mensagem traduzida: isso garante a consistência quando o idioma muda);
- linha 92: [Log.w(...)]—a causa exata da falha (servidor inacessível, credenciais incorretas etc.) é registrada no log do Android, especificamente na aba [Logcat] do Android Studio. Foi graças a esse log que o problema com o endereço [10.0.2.2], descrito no Capítulo 5, foi diagnosticado;
- linhas 120–122: [OutlinedTextField(value = login, onValueChange = { login = it }, ...)]—o campo exibe o estado e o atualiza a cada tecla digitada: o [v-model] do Vue.js escrito em duas partes;
- linha 126: [ImeAction.Next]—a tecla “Next” do teclado virtual passa para o campo seguinte;
- linhas 136–142: a senha: [PasswordVisualTransformation()] exibe pontos no lugar dos caracteres; [KeyboardType.Password] desativa as sugestões do teclado; [onDone] envia o formulário;
- linhas 147–152: o botão, que fica desabilitado ([enabled = !inProgress]) durante o processo de login, com o rótulo “Signing in...”.
5.10.2. features/doctordaypicker/DoctorDayPicker.kt
Porte de [lib/features/doctor_day_picker/doctor_day_picker.dart]: a seleção do médico e do dia.
| // =========================================================================
// DoctorDayPicker.kt
// -------------------------------------------------------------------------
// Port de lib/features/doctor_day_picker/doctor_day_picker.dart: a
// escolha de um médico (lista suspensa) e de um dia (calendário), depois o
// botão "View schedule".
//
// Este componente não conhece o servidor nem AppointmentService: ele recebe a lista
// de médicos como PARÂMETRO (entrada) e informa a escolha do usuário
// por meio da função onSearch (saída) - o mesmo contrato de todas
// as variantes do curso (props/emit no Vue.js, parâmetros do construtor
// no Flutter).
// =========================================================================
package fr.rdvmedecins.client.features.doctordaypicker
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Button
import androidx.compose.material3.Card
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.OutlinedTextField
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.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import fr.rdvmedecins.client.core.LocalTranslations
import fr.rdvmedecins.client.core.models.Doctor
import fr.rdvmedecins.client.core.ui.DropdownList
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun DoctorDayPicker(
doctors: List<Doctor>,
onSearch: (doctorId: Int, day: String) -> Unit,
) {
val t = LocalTranslations.current::t
// estado local, mantido entre rotações de tela
var doctorId by rememberSaveable { mutableStateOf<Int?>(null) }
// o dia escolhido, no formato "yyyy-MM-dd": LocalDate.toString() produz
// exatamente esse formato (ISO 8601), o que o servidor espera - não é mais
// preciso o pacote intl da versão Flutter
var day by rememberSaveable { mutableStateOf(LocalDate.now().toString()) }
var calendarOpen by remember { mutableStateOf(false) }
// os três elementos do componente, preparados uma vez e depois
// dispostos de modo diferente conforme a largura disponível (veja abaixo). São
// LAMBDAS @Composable: só são EXIBIDOS quando chamados.
val doctorField = @Composable { modifier: Modifier ->
DropdownList(
label = t("DOCTOR_DAY_PICKER.DOCTOR_LABEL"),
placeholder = t("DOCTOR_DAY_PICKER.CHOOSE_DOCTOR"),
items = doctors,
selectedId = doctorId,
idOf = { it.id },
itemLabel = { "${it.title} ${it.firstName} ${it.lastName}" },
onSelect = { doctorId = it },
modifier = modifier,
)
}
val dayField = @Composable { modifier: Modifier ->
OutlinedTextField(
value = day,
onValueChange = {},
readOnly = true,
singleLine = true,
label = { Text(t("DOCTOR_DAY_PICKER.DAY_LABEL")) },
// o ícone de calendário abre o seletor de data
trailingIcon = {
IconButton(onClick = { calendarOpen = true }) {
Icon(Icons.Filled.DateRange, contentDescription = t("DOCTOR_DAY_PICKER.PICK_DAY"))
}
},
modifier = modifier,
)
}
val scheduleButton = @Composable { modifier: Modifier ->
Button(
// botão desabilitado enquanto nenhum médico for escolhido
enabled = doctorId != null,
onClick = { doctorId?.let { onSearch(it, day) } },
modifier = modifier,
) {
Text(t("DOCTOR_DAY_PICKER.VIEW_SCHEDULE"))
}
}
Card(modifier = Modifier.fillMaxWidth()) {
// BoxWithConstraints: dá acesso à largura REALMENTE
// disponível (maxWidth) - o LayoutBuilder da versão Flutter.
// Tela estreita (celular em retrato): os três elementos um
// abaixo do outro; tela larga: em uma única linha.
BoxWithConstraints(modifier = Modifier.padding(16.dp)) {
if (maxWidth < 600.dp) {
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
doctorField(Modifier.fillMaxWidth())
dayField(Modifier.fillMaxWidth())
scheduleButton(Modifier.fillMaxWidth())
}
} else {
Row(
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically,
) {
// weight(...): divide a largura entre os três
// elementos (5/12, 4/12, 3/12) - o flex: 5, 4, 3 do
// Expanded da versão Flutter
doctorField(Modifier.weight(5f))
dayField(Modifier.weight(4f))
scheduleButton(Modifier.weight(3f))
}
}
}
}
// o calendário: um diálogo exibido enquanto
// calendarOpen for true (mesmo princípio de BookingDialog)
if (calendarOpen) {
// DatePicker trabalha em milissegundos desde 1º de janeiro de 1970,
// à meia-noite UTC: convertemos nos dois sentidos com java.time
val state = rememberDatePickerState(
initialSelectedDateMillis = LocalDate.parse(day)
.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(),
)
DatePickerDialog(
onDismissRequest = { calendarOpen = false },
confirmButton = {
TextButton(onClick = {
state.selectedDateMillis?.let { millis ->
day = Instant.ofEpochMilli(millis).atZone(ZoneOffset.UTC).toLocalDate().toString()
}
calendarOpen = false
}) { Text(t("DOCTOR_DAY_PICKER.OK")) }
},
dismissButton = {
TextButton(onClick = { calendarOpen = false }) {
Text(t("DOCTOR_DAY_PICKER.CANCEL"))
}
},
) {
DatePicker(state = state)
}
}
}
|
Vamos comentar este código:
- linhas 54–56: as entradas e saídas do componente: a lista de médicos e a função [onSearch(doctorId, day)]. Os nomes dados aos parâmetros do tipo função ([doctorId: Int, day: String]) servem apenas como documentação;
- linha 65: o dia selecionado, armazenado no formato [yyyy-MM-dd]: [LocalDate.now().toString()] produz exatamente esse formato (ISO 8601), que é o esperado pelo servidor. O pacote [intl] da versão Flutter deixa de ser necessário;
- linhas 71–99: os três elementos do componente, preparados como LAMBDAS @Composable ([@Composable { modifier: Modifier -> ... }]): eles só são exibidos quando chamados, com o modifier desejado. Isso permite dispô-los de duas maneiras diferentes sem precisar escrever seu código duas vezes;
- linhas 91–93: o campo do dia, que é somente leitura; o ícone de calendário à direita abre o seletor de data;
- linhas 115–132: [BoxWithConstraints] dá acesso à largura disponível ([maxWidth]) — o [LayoutBuilder] da versão Flutter. Abaixo de 600 dp: os três elementos empilhados um abaixo do outro ([Column]); caso contrário, em uma única linha ([Row]), com pesos 5/4/3 ([Modifier.weight(...)], o equivalente dos [Expanded(flex: ...)] da versão Flutter);
- Linhas 140–163: o seletor de data: um [DatePickerDialog] exibido enquanto [calendarOpen] for igual a [true]. O [DatePicker] do Material 3 opera em milissegundos desde a meia-noite de 1º de janeiro de 1970 (UTC): a conversão funciona nos dois sentidos com [java.time] ([atStartOfDay(ZoneOffset.UTC)] e [Instant.ofEpochMilli(...)]).
5.10.3. features/schedule/ScheduleView.kt
Porte de [lib/features/schedule/schedule_view.dart]: a agenda diária de um médico.
| // =========================================================================
// ScheduleView.kt
// -------------------------------------------------------------------------
// Port de lib/features/schedule/schedule_view.dart: a exibição da
// agenda de um médico para um dia - uma linha por horário, livre ou
// ocupado, com um botão "Book" (horário livre) ou "Cancel" (horário
// ocupado) para o papel ADMIN.
//
// Como DoctorDayPicker, este componente é "stateless": tudo o que ele
// exibe lhe é dado como parâmetro, e ele informa os cliques por meio de
// onBook / onCancel. É AppViewModel quem chama o servidor.
// =========================================================================
package fr.rdvmedecins.client.features.schedule
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
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.foundation.layout.widthIn
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Surface
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
import fr.rdvmedecins.client.core.LocalTranslations
import fr.rdvmedecins.client.core.models.DoctorDaySchedule
import fr.rdvmedecins.client.core.models.DoctorDaySlot
import fr.rdvmedecins.client.core.models.SlotJson
import fr.rdvmedecins.client.core.models.AppointmentJson
// largura da coluna de horário ("10:40 - 11:00")
private val TIME_COLUMN_WIDTH = 116.dp
// "8:00", "8:20"...: os minutos sempre com dois dígitos
private fun formatTime(h: Int, m: Int): String = "$h:${m.toString().padStart(2, '0')}"
@Composable
fun ScheduleView(
schedule: DoctorDaySchedule?,
canEdit: Boolean,
onBook: (SlotJson) -> Unit,
onCancel: (AppointmentJson) -> Unit,
) {
val t = LocalTranslations.current::t
// ainda sem agenda: uma simples mensagem de convite
if (schedule == null) {
Text(
text = t("SCHEDULE.EMPTY_STATE"),
color = MaterialTheme.colorScheme.outline,
modifier = Modifier.padding(vertical = 24.dp),
)
return // uma função @Composable pode parar aqui: nada mais é exibido
}
Card(modifier = Modifier.fillMaxWidth()) {
Column(modifier = Modifier.padding(16.dp)) {
val doctor = schedule.doctor
Text(
text = "${t("SCHEDULE.TITLE_PREFIX")} ${schedule.day} - ${doctor.title} ${doctor.firstName} ${doctor.lastName}",
style = MaterialTheme.typography.titleMedium,
)
// cabeçalhos das colunas: mesma largura da primeira coluna que
// em cada linha (TIME_COLUMN_WIDTH), para que as colunas fiquem
// alinhadas
Row(modifier = Modifier.fillMaxWidth().padding(top = 12.dp, bottom = 4.dp)) {
Text(t("SCHEDULE.COLUMN_SLOT"), fontWeight = FontWeight.Bold, modifier = Modifier.width(TIME_COLUMN_WIDTH))
Spacer(Modifier.width(8.dp)) // o espaçamento entre as colunas das linhas
Text(t("SCHEDULE.COLUMN_STATUS"), fontWeight = FontWeight.Bold)
}
HorizontalDivider()
// uma linha por horário. Um simples laço forEach, em uma
// Column: sem LazyColumn aqui (a lista "lazy" do Compose,
// que só constrói as linhas visíveis), porque esta
// agenda já está colocada em uma Column rolável (veja App.kt),
// e uma dúzia de linhas não justifica essa otimização.
schedule.slots.forEach { daySlot ->
SlotRow(daySlot, canEdit, onBook, onCancel)
HorizontalDivider()
}
}
}
}
// -------------------------------------------------------------------------
// uma linha da agenda: horário | status (livre ou paciente) | botão
// -------------------------------------------------------------------------
@Composable
private fun SlotRow(
daySlot: DoctorDaySlot,
canEdit: Boolean,
onBook: (SlotJson) -> Unit,
onCancel: (AppointmentJson) -> Unit,
) {
val t = LocalTranslations.current::t
val slot = daySlot.slot
val appointment = daySlot.appointment
Row(
modifier = Modifier.fillMaxWidth().padding(vertical = 6.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(8.dp),
) {
// o horário: largura fixa, a mesma do cabeçalho
Text(
text = "${formatTime(slot.startHour, slot.startMinute)} - ${formatTime(slot.endHour, slot.endMinute)}",
modifier = Modifier.width(TIME_COLUMN_WIDTH),
)
// o status: um badge verde "Free", ou o nome do paciente
Surface(
shape = RoundedCornerShape(8.dp),
color = if (appointment == null) Color(0xFFC8E6C9) else MaterialTheme.colorScheme.secondaryContainer,
// weight(1f): o status ocupa toda a largura deixada livre pelo
// horário e pelo botão
modifier = Modifier.weight(1f),
) {
val client = appointment?.client
Text(
text = if (appointment == null) t("SCHEDULE.FREE") else "${client?.title ?: ""} ${client?.firstName ?: ""} ${client?.lastName ?: ""}",
style = MaterialTheme.typography.bodyMedium,
modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
)
}
// o botão só existe para o papel ADMIN; ele reserva um horário
// livre, ou cancela a consulta de um horário ocupado
if (canEdit) {
// SEM weight(...) aqui: o botão ocupa a largura de seu texto.
// Uma primeira versão lhe impunha um quarto da linha
// (weight(0.25f)): em um celular em retrato, o rótulo
// "Réserver" (UI em francês) era então truncado para "Rése" (veja o capítulo 5).
OutlinedButton(
onClick = { if (appointment == null) onBook(slot) else onCancel(appointment) },
// padding interno reduzido (24 dp por padrão de cada lado)
contentPadding = PaddingValues(horizontal = 12.dp),
// uma largura mínima comum: os botões "Book" e
// "Cancel" têm assim a mesma largura, e as colunas permanecem
// alinhadas de uma linha para a outra
modifier = Modifier.widthIn(min = 96.dp),
) {
Text(if (appointment == null) t("SCHEDULE.BOOK") else t("SCHEDULE.CANCEL_APPOINTMENT"), maxLines = 1)
}
}
}
}
|
Vamos comentar este código:
- linhas 60–66: ainda sem agenda—uma mensagem de convite, seguida de [return]. Uma função @Composable pode terminar aqui: nada mais é emitido;
- linhas 79–82: os cabeçalhos das colunas: a primeira coluna tem a mesma largura fixa ([TIME_COLUMN_WIDTH]) que o horário em cada linha, para que as colunas fiquem alinhadas. O Compose não tem um equivalente ao [DataTable] do Flutter: a tabela é construída com [Row];
- Linhas 90–91: uma linha por horário, com um simples laço [forEach] dentro de uma [Column]. Sem [LazyColumn] (a lista “lazy” do Compose, que constrói apenas as linhas visíveis): a agenda já está colocada em uma coluna com rolagem (veja [App.kt])—uma [LazyColumn] dentro de uma coluna com rolagem causa, na verdade, um erro em tempo de execução—e uma dúzia de linhas não justifica essa otimização;
- linhas 122–128: o status: um selo verde “Free” ou o nome do paciente. [Modifier.weight(1f)]: o status ocupa toda a largura deixada livre pelo horário e pelo botão;
- linhas 139–151: o botão, apenas para o papel ADMIN ([if (canEdit)]): “Book” em um horário disponível, “Cancel” em um horário agendado. Ele não tem largura fixa: ocupa a largura do seu texto, com uma largura mínima comum. Uma versão anterior o limitava a um quarto da linha: em um celular em orientação retrato, o rótulo era então truncado (veja o Capítulo 5).
5.10.4. features/bookingdialog/BookingDialog.kt
Porte de [lib/features/booking_dialog/booking_dialog.dart]: a caixa de diálogo de agendamento.
| // =========================================================================
// BookingDialog.kt
// -------------------------------------------------------------------------
// Port de lib/features/booking_dialog/booking_dialog.dart: o diálogo de
// reserva de um horário (escolha do paciente, depois
// "Confirm" ou "Cancel").
//
// Diferença estrutural em relação à versão Flutter: o Flutter ABRIA o
// diálogo com showDialog(...) e AGUARDAVA seu resultado (um Future<int?>).
// No Compose, um diálogo é um elemento de exibição como qualquer
// outro: AlertDialog é exibido enquanto a função que o chama
// o chamar (veja App.kt: enquanto vm.slotBeingBooked não for
// nulo). Ele não "retorna" nada: informa a escolha por meio de duas
// funções, onConfirm e onClose - exatamente os dois eventos
// "confirm" / "close" do BookingDialog.vue da variante Vue.js.
// =========================================================================
package fr.rdvmedecins.client.features.bookingdialog
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
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.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import fr.rdvmedecins.client.core.LocalTranslations
import fr.rdvmedecins.client.core.models.Client
import fr.rdvmedecins.client.core.models.SlotJson
import fr.rdvmedecins.client.core.ui.DropdownList
@Composable
fun BookingDialog(
slot: SlotJson,
clients: List<Client>,
onConfirm: (clientId: Int) -> Unit,
onClose: () -> Unit,
) {
val t = LocalTranslations.current::t
// o paciente escolhido (seu id), ou null enquanto nenhum for escolhido
var clientId by rememberSaveable { mutableStateOf<Int?>(null) }
AlertDialog(
// toque fora do diálogo, ou a tecla "voltar" do celular
onDismissRequest = onClose,
title = { Text(t("BOOKING_DIALOG.TITLE")) },
text = {
Column(verticalArrangement = Arrangement.spacedBy(16.dp)) {
Text(
"${t("BOOKING_DIALOG.SLOT_FROM")} ${slot.startHour}:${slot.startMinute.toString().padStart(2, '0')} " +
"${t("BOOKING_DIALOG.SLOT_TO")} ${slot.endHour}:${slot.endMinute.toString().padStart(2, '0')}",
)
DropdownList(
label = t("BOOKING_DIALOG.PATIENT_LABEL"),
placeholder = t("BOOKING_DIALOG.CHOOSE_PATIENT"),
items = clients,
selectedId = clientId,
idOf = { it.id },
itemLabel = { "${it.title} ${it.firstName} ${it.lastName}" },
onSelect = { clientId = it },
modifier = Modifier.fillMaxWidth(),
)
}
},
// "Confirm": desabilitado enquanto nenhum paciente for escolhido
confirmButton = {
Button(
enabled = clientId != null,
onClick = { clientId?.let(onConfirm) },
) { Text(t("BOOKING_DIALOG.CONFIRM")) }
},
dismissButton = {
TextButton(onClick = onClose) { Text(t("BOOKING_DIALOG.CANCEL")) }
},
)
}
|
Vamos comentar este código:
- linhas 8–15: o comentário de cabeçalho resume a diferença estrutural em relação à versão Flutter. O Flutter ABRIA a caixa de diálogo com [showDialog(...)] e AGUARDAVA o seu resultado (um [Future<int?>]). No Compose, uma caixa de diálogo é um elemento de view como qualquer outro: ela permanece exibida enquanto a função que a chama continuar chamando-a. Ela não “retorna” nada: sinaliza a seleção por meio de duas funções, [onConfirm] e [onClose]—exatamente os dois eventos [confirm] / [close] do componente [BookingDialog.vue] na variante Vue.js;
- linha 48: o paciente selecionado: [rememberSaveable]; o paciente continua selecionado mesmo depois que a tela gira com a caixa de diálogo aberta;
- linhas 50–52: [AlertDialog(...)]—a caixa de diálogo do Material 3, com um título, um conteúdo ([text]) e dois botões. [onDismissRequest] é chamado quando o usuário toca fora da caixa de diálogo ou pressiona o botão “Voltar” do celular;
- linhas 73–76: o botão “Confirm”, que fica desabilitado até que um paciente seja selecionado. [clientId?.let(onConfirm)]: se [clientId] não for [null], [onConfirm] é chamado com o seu valor.
5.11. Guia passo a passo de uso do aplicativo
As capturas de tela a seguir foram feitas no emulador Pixel 8 (Android 17) do Capítulo 1, com o aplicativo conectado ao servidor por meio de [adb reverse] (veja o Capítulo 5), daí a URL [http://localhost:8080].
5.11.1. 1. Tela de login
Na primeira inicialização, nenhuma sessão está armazenada: [AuthService.isLoggedIn] é igual a [false], e [App.kt] exibe [LoginPage]. Uma tentativa com uma combinação inválida de nome de usuário e senha—ou com um servidor inacessível—exibe a mensagem de erro (chave [LOGIN.ERROR]):


5.11.2. 2. Login como administrador (papel ADMIN, acesso total)
Depois do login com [admin]/[admin], a tela de login dá lugar à seleção do médico e do dia; a barra de título exibe o selo do papel e o botão de logout. Em segundo plano, [AppViewModel] carregou os médicos e os pacientes:


- À esquerda, a tela imediatamente após o login: o botão “View schedule” fica desabilitado até que um médico seja selecionado;
- à direita, a lista suspensa de médicos, aberta.
O ícone de calendário abre o seletor de data; “View schedule” exibe a agenda do médico para o dia selecionado:


“Book” abre a caixa de diálogo de seleção do paciente; “Confirm” envia o agendamento ao servidor e a agenda é recarregada: o horário aparece como agendado, com um botão “Cancel”:



“Cancel”, ao ser clicado em um horário agendado, exclui a consulta e o horário volta a ficar disponível. O botão “FR” alterna toda a tela para o francês, inclusive os rótulos da agenda; o botão de logout leva de volta à tela de login:


5.11.3. 3. Login como usuário (papel USER, somente leitura)
Uma conexão com [user]/[user] exibe o selo “USER”. A agenda continua visível, mas nenhum botão “Book”/“Cancel” aparece ([canEdit] equivale a [false])—de qualquer forma, o servidor negaria essas duas ações a esse papel (403 Forbidden, veja o Capítulo 2).

5.12. O que fica fora do escopo ou adiado
- Como os outros clientes deste curso, não há um modo demo/debug específico.
- Nenhum atraso de rede artificial é introduzido no lado do cliente para fins didáticos.
- Sem navegação entre telas: o aplicativo cabe em uma única tela (excluindo as caixas de diálogo). Um aplicativo Android mais completo usaria a biblioteca [Navigation Compose].
- Sem testes automatizados: as pastas [src/test] e [src/androidTest] geradas pelo Android Studio foram removidas do projeto.