0Pricing
Android Academy · Leçon

Gestion des erreurs et expérience utilisateur

Modélisez les états de l’interface avec des classes scellées (Loading/Success/Error). Affichez ProgressBar et Snackbar avec des actions Retry, ainsi que les erreurs de validation intégrées de TextInputLayout.

Gestion des erreurs et expérience utilisateur est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 6. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 6 leçons au total.

Pourquoi la gestion des erreurs est importante

Les applications qui se ferment ou se figent sans explication donnent l’impression d’être défectueuses. Les utilisateurs ne savent pas ce qui s’est passé ni quoi faire ensuite.

Une bonne gestion des erreurs signifie que :

  • L’application reste stable
  • Les utilisateurs reçoivent un message clair
  • Ils peuvent réessayer ou effectuer une action

C’est ce qui fait la différence entre une note de 2 étoiles et une note de 5 étoiles.

Modéliser l’état de l’interface

Un modèle clair consiste à modéliser tous les états possibles de l’interface avec une classe scellée :

  • Loading — la requête est en cours
  • Success(data) — les données sont disponibles
  • Error(message) — un problème est survenu

Le ViewModel émet l’un de ces états : l’interface l’affiche.

Classe scellée UiState

Définissez une classe scellée pour tous les états possibles :

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")
        }
    }
}

Afficher l’état dans l’interface

Observez l’état et affichez la vue appropriée pour chaque cas :

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 pendant le chargement

Affichez une ProgressBar pendant l’attente des données :

  • Utilisez android:indeterminate="true" pour afficher un indicateur tournant
  • Basculez la visibilité entre View.VISIBLE et View.GONE
  • GONE retire la vue de la mise en page (elle ne devient pas seulement invisible : elle n’occupe aucun espace)

Snackbar ou Toast

Préférez Snackbar à Toast pour les messages d’erreur :

  • La Snackbar peut comporter un bouton d’action (par exemple « Réessayer »)
  • Elle est attachée à l’écran actuel et ne flotte pas au-dessus des autres applications
  • Elle disparaît automatiquement ou lorsqu’elle est touchée

Snackbar avec réessai

Affichez une erreur avec un bouton d’action Réessayer :

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()
}

Validation des saisies

Validez les saisies de l’utilisateur avant de les envoyer au serveur :

  • Utilisez TextInputLayout avec la propriété error pour afficher les erreurs directement sous le champ
  • Vérifiez les champs vides, le format de l’adresse e-mail et la longueur du mot de passe avant d’appeler l’API
  • Effacez les erreurs lorsque l’utilisateur commence à saisir du texte

Erreur TextInputLayout

Affichez les erreurs de validation directement dans les champs du formulaire :

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)
}

Vérification rapide

Quel état de visibilité retire complètement une vue de la mise en page (elle n’occupe aucun espace) ?

Récapitulatif&nbsp;: gestion des erreurs et expérience utilisateur

Vos applications peuvent désormais gérer correctement les erreurs :

  • Modélisez l’état avec Loading / Success / Error au moyen d’une classe scellée
  • Affichez une ProgressBar pendant le chargement
  • Utilisez une Snackbar avec l’action Réessayer pour les erreurs réseau
  • Utilisez les erreurs intégrées de TextInputLayout pour valider les formulaires
  • View.GONE contre View.INVISIBLE — retirer ou masquer

Dernière leçon : publiez votre application sur le Play Store !

Questions Fréquemment Posées

La leçon « Gestion des erreurs et expérience utilisateur » est-elle gratuite ?

Oui — le texte complet de « Gestion des erreurs et expérience utilisateur » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestion des erreurs et expérience utilisateur » ?

Modélisez les états de l’interface avec des classes scellées (Loading/Success/Error). Affichez ProgressBar et Snackbar avec des actions Retry, ainsi que les erreurs de validation intégrées de TextInp… Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 6.

Combien de temps prend la leçon « Gestion des erreurs et expérience utilisateur » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Retrofit et API REST
  2. Charger des images avec Coil
  3. Gestion des erreurs et expérience utilisateur
  4. Notifications push
  5. WorkManager et tâches en arrière-plan
  6. Publier sur le Play Store
← Retour à Android Academy