0Pricing
Android Academy · Aula

Tratamento de erros e experiência do usuário

Modele estados da interface com classes seladas (Loading/Success/Error). Exiba ProgressBar, Snackbar com ações de Retry e erros de validação em linha no TextInputLayout.

Tratamento de erros e experiência do usuário é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 3 de 6. 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 6 aulas no total.

Por que o tratamento de erros é importante

Aplicativos que travam ou congelam sem explicação parecem estar com defeito. Os usuários não sabem o que aconteceu nem o que fazer em seguida.

Um bom tratamento de erros significa:

  • O aplicativo permanece estável
  • Os usuários recebem uma mensagem clara
  • Eles podem tentar novamente ou realizar uma ação

Essa é a diferença entre uma avaliação de 2 estrelas e uma de 5 estrelas para o aplicativo.

Modelagem do estado da interface

Um padrão organizado: modele todos os estados possíveis da interface com uma classe selada:

  • Loading — a solicitação está em andamento
  • Success(data) — os dados estão disponíveis
  • Error(message) — algo deu errado

O ViewModel emite um desses estados; a interface o renderiza.

Classe selada UiState

Defina uma classe selada para todos os estados possíveis:

sealed class UiState<out T> {
    object Loading : UiState<Nothing>()
    data class Success<T>(val data: T) : UiState<T>()
    data class Error(val message: String) : UiState<Nothing>()
}

// In ViewModel:
private val _state = MutableLiveData<UiState<List<Post>>>()
val state: LiveData<UiState<List<Post>>> = _state

fun loadPosts() {
    _state.value = UiState.Loading
    viewModelScope.launch {
        try {
            val posts = withContext(Dispatchers.IO) { repo.getPosts() }
            _state.value = UiState.Success(posts)
        } catch (e: Exception) {
            _state.value = UiState.Error(e.message ?: "Unknown error")
        }
    }
}

Renderização do estado na interface

Observe o estado e exiba a visualização correta para cada caso:

viewModel.state.observe(this) { state ->
    when (state) {
        is UiState.Loading -> {
            binding.progressBar.visibility = View.VISIBLE
            binding.recyclerView.visibility = View.GONE
            binding.tvError.visibility = View.GONE
        }
        is UiState.Success -> {
            binding.progressBar.visibility = View.GONE
            binding.recyclerView.visibility = View.VISIBLE
            adapter.submitList(state.data)
        }
        is UiState.Error -> {
            binding.progressBar.visibility = View.GONE
            binding.tvError.text = state.message
            binding.tvError.visibility = View.VISIBLE
        }
    }
}

ProgressBar durante o carregamento

Exiba uma ProgressBar enquanto aguarda os dados:

  • Use android:indeterminate="true" para um indicador giratório
  • Alterne a visibilidade entre View.VISIBLE e View.GONE
  • GONE remove a visualização do layout (não apenas a torna invisível — ela não ocupa espaço)

Snackbar versus Toast

Prefira Snackbar a Toast para mensagens de erro:

  • O Snackbar pode ter um botão de ação (por exemplo, "Tentar novamente")
  • Ele fica associado à tela atual — não flutua sobre outros aplicativos
  • É dispensado automaticamente ou ao tocar nele

Snackbar com nova tentativa

Exiba um erro com um botão de ação para tentar novamente:

import com.google.android.material.snackbar.Snackbar

fun showError(message: String) {
    Snackbar.make(
        binding.root,  // root view of the screen
        message,
        Snackbar.LENGTH_INDEFINITE  // stays until dismissed
    ).setAction("Retry") {
        viewModel.loadPosts()  // retry the request
    }.show()
}

Validação de entrada

Valide os dados inseridos pelo usuário antes de enviá-los ao servidor:

  • Use TextInputLayout com a propriedade error para exibir erros diretamente abaixo do campo
  • Verifique campos vazios, o formato do e-mail e o tamanho da senha antes de chamar a API
  • Limpe os erros quando o usuário começar a digitar

Erro do TextInputLayout

Exiba erros de validação diretamente nos campos do formulário:

fun validateAndSubmit() {
    val email = binding.etEmail.text.toString().trim()
    val password = binding.etPassword.text.toString()

    var hasError = false

    if (email.isBlank() || !email.contains("@")) {
        binding.tilEmail.error = "Enter a valid email"
        hasError = true
    } else {
        binding.tilEmail.error = null  // clear error
    }

    if (password.length < 6) {
        binding.tilPassword.error = "Minimum 6 characters"
        hasError = true
    } else {
        binding.tilPassword.error = null
    }

    if (!hasError) viewModel.login(email, password)
}

Verificação rápida

Qual estado de visibilidade da visualização a remove completamente do layout, sem ocupar espaço?

Recapitulação: tratamento de erros e experiência do usuário

Agora seus aplicativos podem tratar erros adequadamente:

  • Modele o estado como Loading / Success / Error com uma classe selada
  • Exiba uma ProgressBar durante o carregamento
  • Use um Snackbar com a ação de nova tentativa para erros de rede
  • Use erros diretos do TextInputLayout para validar formulários
  • View.GONE versus View.INVISIBLE — remover versus ocultar

Lição final: publique seu aplicativo na Play Store!

Perguntas Frequentes

A aula “Tratamento de erros e experiência do usuário” é grátis?

Sim — o texto completo de “Tratamento de erros e experiência do usuário” é 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 6 aulas no total.

O que vou aprender em “Tratamento de erros e experiência do usuário”?

Modele estados da interface com classes seladas (Loading/Success/Error). Exiba ProgressBar, Snackbar com ações de Retry e erros de validação em linha no TextInputLayout. 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 6.

Quanto tempo leva a aula “Tratamento de erros e experiência do usuário”?

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

  1. Retrofit e APIs REST
  2. Carregamento de imagens com Coil
  3. Tratamento de erros e experiência do usuário
  4. Notificações push
  5. WorkManager e tarefas em segundo plano
  6. Publicação na Play Store
← Voltar para Android Academy