Android Academy · Aula

Validando a entrada

Verifique a entrada e mostre erros úteis.

Validando a entrada é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

Por que validar a entrada

Os usuários cometem erros: um nome vazio, um e-mail malformado ou uma senha curta demais. Bons formulários detectam esses problemas antecipadamente e explicam claramente o que deve ser corrigido.

Nesta lição, você adicionará validação aos formulários do Compose, exibirá erros no próprio campo e desativará o botão de envio até que tudo esteja válido.

Uma regra de validação é apenas uma função

Mantenha a lógica de validação em funções Kotlin simples que recebem um valor e retornam se ele é válido (ou uma mensagem de erro). Isso torna as regras reutilizáveis e fáceis de testar.

Aqui está uma verificação simples de e-mail.

fun emailError(email: String): String? = when {
    email.isBlank() -> "Email is required"
    !email.contains("@") -> "Enter a valid email"
    else -> null
}

Exibindo o erro no campo

OutlinedTextField tem um sinalizador isError e um espaço supportingText. Combine-os para exibir um campo vermelho com uma mensagem abaixo.

O erro vem diretamente da sua função de validação.

var email by remember { mutableStateOf("") }
val error = emailError(email)

OutlinedTextField(
    value = email,
    onValueChange = { email = it },
    label = { Text("Email") },
    isError = error != null,
    supportingText = { if (error != null) Text(error) }
)

Não alerte cedo demais

Exibir "O e-mail é obrigatório" antes mesmo de o usuário tocar no campo parece hostil. Uma solução comum é acompanhar se um campo foi tocado e só então exibir os erros.

Aqui, marcamos o campo como tocado assim que ele perde o foco.

var email by remember { mutableStateOf("") }
var touched by remember { mutableStateOf(false) }
val error = if (touched) emailError(email) else null

OutlinedTextField(
    value = email,
    onValueChange = { email = it },
    label = { Text("Email") },
    isError = error != null,
    modifier = Modifier.onFocusChanged {
        if (!it.isFocused) touched = true
    }
)

Validando uma senha

As senhas geralmente têm várias regras. Retorne a primeira regra que falhar para que o usuário corrija um problema de cada vez.

Observe que esta ainda é uma função pura, sem interface do usuário.

fun passwordError(pw: String): String? = when {
    pw.length < 8 -> "At least 8 characters"
    pw.none { it.isDigit() } -> "Add a number"
    pw.none { it.isUpperCase() } -> "Add an uppercase letter"
    else -> null
}

Validação entre campos

Algumas regras envolvem dois campos, como "a confirmação da senha deve corresponder à senha". Elas não podem ficar em uma função de campo único, portanto calcule-as onde os dois valores estiverem disponíveis.

var password by remember { mutableStateOf("") }
var confirm by remember { mutableStateOf("") }

val confirmError =
    if (confirm.isNotEmpty() && confirm != password)
        "Passwords don't match"
    else null

Desativando o envio até que seja válido

O formulário inteiro é válido quando todas as regras são satisfeitas. Calcule um único booleano e use-o para ativar ou desativar o botão de envio.

Isso impede que o usuário envie dados inválidos desde o início.

val formValid =
    emailError(email) == null &&
    passwordError(password) == null &&
    confirmError == null

Button(onClick = { submit() }, enabled = formValid) {
    Text("Create Account")
}

Validando no envio

A validação no próprio campo orienta o usuário, mas você também deve verificar tudo novamente quando ele pressionar o botão de envio. O manipulador de envio decide se deve prosseguir ou exibir todos os erros de uma vez.

fun onSubmit() {
    val errors = listOfNotNull(
        emailError(email),
        passwordError(password)
    )
    if (errors.isEmpty()) {
        register(email, password)
    } else {
        // show errors / mark fields touched
    }
}

Restringindo o que pode ser digitado

A validação também pode ser preventiva. Para um número de telefone, basta ignorar os caracteres que não sejam dígitos dentro de onValueChange, para que a entrada inválida nunca chegue ao estado.

Isso é mais amigável do que repreender o usuário depois.

var phone by remember { mutableStateOf("") }

OutlinedTextField(
    value = phone,
    onValueChange = { input ->
        phone = input.filter { it.isDigit() }.take(10)
    },
    label = { Text("Phone") }
)

Centralizando a validação no ViewModel

Em telas reais, mantenha a validação no ViewModel para que a interface do usuário apenas exiba os resultados. O ViewModel disponibiliza os erros e um sinalizador isValid.

Assim, os componentes componíveis permanecem simples e suas regras podem ser testadas por testes unitários.

class SignUpViewModel : ViewModel() {
    var email by mutableStateOf("")
        private set

    val emailError: String?
        get() = emailError(email)

    val isValid: Boolean
        get() = emailError == null && email.isNotBlank()

    fun onEmailChange(value: String) { email = value }
}

Kotlin puro: testando as regras

Como os validadores são funções puras, você pode executá-los em qualquer lugar. Aqui, as regras de e-mail e senha são executadas de forma independente, assim como um teste unitário as chamaria.

fun emailError(email: String): String? = when {
    email.isBlank() -> "Email is required"
    !email.contains("@") -> "Enter a valid email"
    else -> null
}

fun main() {
    println(emailError(""))
    println(emailError("nope"))
    println(emailError("ada@dev.io"))
}

Verificação rápida

Qual par de propriedades de OutlinedTextField é usado para marcar um campo como inválido e exibir uma mensagem abaixo dele?

Recapitulação

Agora você valida formulários do Compose de forma organizada:

Mantenha as regras como funções puras que retornam uma mensagem de erro ou nulo.
Exiba erros com isError + supportingText e evite alertar antes que um campo seja tocado.
Trate regras entre campos onde os dois valores estejam visíveis.
Desative o envio até que o formulário inteiro seja válido e verifique tudo novamente no envio.
Impeça entradas inválidas com filter e centralize as regras em um ViewModel.

A seguir: tipos de teclado, ações do IME e gerenciamento de foco.

Perguntas Frequentes

A aula “Validando a entrada” é grátis?

Sim — o texto completo de “Validando a entrada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Validando a entrada”?

Verifique a entrada e mostre erros úteis. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Validando a entrada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy