Détection et diagnostic des plantages

Stay organized with collections Save and categorize content based on your preferences.

Une application Android plante lorsqu'une interruption inattendue est provoquée par une exception ou un signal non géré. Une application écrite avec Java ou Kotlin plante si elle génère une exception non gérée, représentée par la classe Throwable. Une application écrite avec des langages en code natif plante en cas de signal non géré, tel que SIGSEGV, pendant son exécution.

Lorsqu'une application plante, Android met fin au processus et affiche une boîte de dialogue pour informer l'utilisateur que l'application s'est arrêtée, comme illustré dans la figure 1.

Plantage d'une application sur un appareil Android

Figure 1 : Plantage d'une application sur un appareil Android

Une application peut planter même si elle ne s'exécute au premier plan. Tout composant d'une application, même s'il s'exécute en arrière-plan, comme des broadcast receivers ou les fournisseurs de contenu, peut entraîner le plantage de l'application. Ces plantages sont souvent déroutants, car ils surviennent à un moment où les utilisateurs n'interagissaient pas activement avec votre application.

Si votre application plante, vous pouvez suivre les instructions de cette page pour diagnostiquer et résoudre le problème.

Détecter le problème

Vous ne saurez pas forcément si vos utilisateurs subissent un nombre excessif de plantages avec votre application. Si vous avez déjà publié celle-ci, Android Vitals peut vous avertir du problème.

Android Vitals

Android Vitals peut vous aider à améliorer les performances de votre application en vous envoyant une alerte via la Play Console lorsque votre application connaît un nombre excessif de plantages. Android Vitals considère les plantages comme excessifs dans les cas suivants :

  • L'application subit au moins un plantage dans au moins 1,09 % des sessions quotidiennes.
  • L'application subit au moins deux plantages dans au moins 0,18 % des sessions quotidiennes.

Une session quotidienne désigne une journée au cours de laquelle votre application a été utilisée. Pour savoir comment Google Play collecte les données Android Vitals, consultez la documentation de la Play Console.

Une fois que vous savez que votre application subit trop de plantages, l'étape suivante consiste à les diagnostiquer.

Diagnostiquer les plantages

Il peut être difficile de trouver une solution aux plantages. Toutefois, si vous pouvez en identifier la cause première, vous parviendrez sans doute à résoudre ce problème.

De nombreuses situations peuvent entraîner le plantage de votre application. Il existe de raisons simples, comme la rencontre d'une valeur nulle ou d'une chaîne vide, mais d'autres sont moins évidentes, comme la transmission d'arguments non valides à une API, voire des interactions multithread complexes.

Les plantages sur Android génèrent une trace de la pile, c'est-à-dire un instantané de la séquence des fonctions imbriquées appelées dans votre programme jusqu'au moment du plantage. Vous pouvez consulter les traces de la pile de plantage dans Android Vitals.

Lire une trace de la pile

Pour résoudre un plantage, la première étape consiste à identifier l'endroit où il se produit. Vous pouvez utiliser la trace de la pile disponible dans les détails du rapport si vous utilisez la Play Console ou la sortie de l'outil Logcat. Si aucune trace de la pile n'est disponible, vous devez reproduire le plantage localement, en testant l'application manuellement ou en contactant les utilisateurs concernés, puis en le reproduisant tout en utilisant Logcat.

La trace ci-dessous montre un exemple de plantage d'une application écrite à l'aide du langage de programmation Java :

--------- beginning of crash
AndroidRuntime: FATAL EXCEPTION: main
Process: com.android.developer.crashsample, PID: 3686
java.lang.NullPointerException: crash sample
at com.android.developer.crashsample.MainActivity$1.onClick(MainActivity.java:27)
at android.view.View.performClick(View.java:6134)
at android.view.View$PerformClick.run(View.java:23965)
at android.os.Handler.handleCallback(Handler.java:751)
at android.os.Handler.dispatchMessage(Handler.java:95)
at android.os.Looper.loop(Looper.java:156)
at android.app.ActivityThread.main(ActivityThread.java:6440)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.Zygote$MethodAndArgsCaller.run(Zygote.java:240)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:746)
--------- beginning of system

Une trace de la pile affiche deux informations essentielles au débogage d'un plantage :

  • Type d'exception générée
  • Section de code où l'exception est générée

Le type d'exception générée est généralement très révélateur. Vérifiez s'il s'agit d'un élément IOException, OutOfMemoryError ou autre, puis recherchez la documentation sur la classe d'exception concernée.

La classe, la méthode, le fichier et le numéro de ligne du fichier source où l'exception est générée figure sur la deuxième ligne d'une trace de la pile. Pour chaque fonction appelée, une ligne indique le site de l'appel précédent (appelé "bloc de pile"). En parcourant la pile et en examinant le code, vous trouverez peut-être un emplacement qui transmet une valeur incorrecte. Si votre code n'apparaît pas dans la trace de la pile, vous avez probablement transmis un paramètre non valide à une opération asynchrone. Vous pouvez généralement comprendre ce qui s'est passé en examinant chaque ligne de la trace de la pile, en recherchant les classes d'API que vous avez utilisées et en confirmant que les paramètres transmis étaient corrects et que vos appels provenaient d'un emplacement autorisé.

Les traces de pile pour les applications avec du code C et C++ fonctionnent de la même manière.

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
Build fingerprint: 'google/foo/bar:10/123.456/78910:user/release-keys'
ABI: 'arm64'
Timestamp: 2020-02-16 11:16:31+0100
pid: 8288, tid: 8288, name: com.example.testapp  >>> com.example.testapp <<<
uid: 1010332
signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x0
Cause: null pointer dereference
    x0  0000007da81396c0  x1  0000007fc91522d4  x2  0000000000000001  x3  000000000000206e
    x4  0000007da8087000  x5  0000007fc9152310  x6  0000007d209c6c68  x7  0000007da8087000
    x8  0000000000000000  x9  0000007cba01b660  x10 0000000000430000  x11 0000007d80000000
    x12 0000000000000060  x13 0000000023fafc10  x14 0000000000000006  x15 ffffffffffffffff
    x16 0000007cba01b618  x17 0000007da44c88c0  x18 0000007da943c000  x19 0000007da8087000
    x20 0000000000000000  x21 0000007da8087000  x22 0000007fc9152540  x23 0000007d17982d6b
    x24 0000000000000004  x25 0000007da823c020  x26 0000007da80870b0  x27 0000000000000001
    x28 0000007fc91522d0  x29 0000007fc91522a0
    sp  0000007fc9152290  lr  0000007d22d4e354  pc  0000007cba01b640

backtrace:
  #00  pc 0000000000042f89  /data/app/com.example.testapp/lib/arm64/libexample.so (com::example::Crasher::crash() const)
  #01  pc 0000000000000640  /data/app/com.example.testapp/lib/arm64/libexample.so (com::example::runCrashThread())
  #02  pc 0000000000065a3b  /system/lib/libc.so (__pthread_start(void*))
  #03  pc 000000000001e4fd  /system/lib/libc.so (__start_thread)

Si vous ne voyez pas d'informations au niveau de la classe et de la fonction dans les traces de la pile native, vous devrez peut-être générer un fichier de décodage natif, puis l'importer dans Google Play Console. Pour en savoir plus, consultez Désobscurcir les traces de la pile de plantage. Pour obtenir des informations générales sur les plantages natifs, consultez la page concernant le diagnostic des plantages natifs.

Conseils pour reproduire un plantage

Il est possible que vous ne puissiez pas reproduire le problème simplement en démarrant un émulateur ou en connectant votre appareil à votre ordinateur. Les environnements de développement ont tendance à disposer de plus de ressources (bande passante, mémoire et espace de stockage, par exemple). Utilisez le type d'exception pour déterminer si le problème est dû à une ressource insuffisante (et identifier laquelle) ou pour trouver une corrélation entre la version d'Android, le type d'appareil et la version de votre application.

Erreurs de mémoire

Si vous obtenez une alerte OutOfMemoryError, vous pouvez créer un émulateur avec une faible capacité de mémoire afin de réaliser vos tests. La figure 2 montre les paramètres AVD Manager, où vous pouvez contrôler la quantité de mémoire sur l'appareil.

Paramètre de mémoire sur AVD Manager

Figure 2 : Paramètre de mémoire sur AVD Manager

Exceptions réseau

Étant donné que les utilisateurs passent fréquemment d'un réseau mobile ou Wi-Fi à un autre, les exceptions réseau d'une application ne doivent généralement pas être considérées comme des erreurs, mais comme des conditions de fonctionnement normales se produisant de manière inattendue.

Si vous devez reproduire une exception réseau, telle qu'une UnknownHostException, essayez d'activer le mode Avion pendant que votre application tente d'utiliser le réseau.

Une autre option consiste à réduire la qualité du réseau dans l'émulateur en choisissant une émulation de débit réseau et/ou un délai de réseau. Vous pouvez utiliser les paramètres Speed (Vitesse) et Latency (Latence) d'AVD Manager, ou démarrer l'émulateur avec les options -netdelay et -netspeed, comme dans l'exemple de ligne de commande suivant :

emulator -avd [your-avd-image] -netdelay 20000 -netspeed gsm

Cet exemple définit un délai de 20 secondes pour toutes les requêtes réseau et une vitesse d'importation et de téléchargement de 14,4 Kbit/s. Pour en savoir plus sur les options de ligne de commande de l'émulateur, consultez la section consacrée au démarrage de l'émulateur à partir de la ligne de commande.

Lire avec Logcat

Une fois que vous savez comment reproduire le plantage, vous pouvez utiliser un outil tel que Logcat pour obtenir plus d'informations.

La sortie Logcat affiche les autres messages de journal que vous avez imprimés, ainsi que des messages du système. N'oubliez pas de désactiver les instructions Log supplémentaires que vous pouvez avoir ajoutées, car l'impression consomme du processeur et de la batterie pendant l'exécution de votre application.

Éviter les plantages causés par les exceptions de pointeur null

Les exceptions de pointeur null (identifiées par le type d'erreur d'exécution NullPointerException) se produisent lorsque vous essayez d'accéder à un objet nul, généralement en appelant ses méthodes ou en accédant à ses membres. Les exceptions de pointeur null sont la cause principale de plantages des applications sur Google Play. La valeur "null" sert à indiquer que l'objet est manquant (par exemple, il n'a pas encore été créé ou attribué). Pour éviter les exceptions de pointeur null, vous devez vous assurer que les références d'objet avec lesquelles vous travaillez ne sont pas nulles avant d'appeler des méthodes les exploitant ou d'essayer d'accéder à leurs membres. Si la référence d'objet est nulle, traitez ce cas correctement (par exemple, quittez une méthode avant d'effectuer une opération sur la référence d'objet et écrivez les informations utiles dans un journal de débogage).

Comme il ne serait pas raisonnable de vérifier qu'aucune valeur n'est nulle pour chaque paramètre de chaque méthode appelée, vous pouvez vous fier à l'IDE ou au type d'objet pour indiquer la possibilité de valeur nulle.

Langage de programmation Java

Les sections suivantes concernent le langage de programmation Java.

Avertissements au moment de la compilation

Annotez les paramètres de vos méthodes et renvoyez des valeurs avec @Nullable et @NonNull pour recevoir des avertissements de l'IDE au moment de la compilation. Les avertissements suivants vous avertissent qu'un objet a une risque de valeur nulle :

Avertissement d'exception de pointeur nul

Ces vérifications concernent des objets dont la valeur peut être nulle. Une exception sur un objet @NonNull vous indique que votre code comporte une erreur à corriger.

Erreurs au moment de la compilation

Étant donné que la possibilité d'une valeur nulle doit jouer un rôle utile, vous pouvez l'intégrer aux types que vous utilisez pour qu'une vérification ait lieu au moment de la compilation. Si vous savez qu'un objet risque d'être nul et que la possibilité de valeur nulle doit être gérée, vous pouvez l'encapsuler dans un objet tel que Optional. Il faut toujours privilégier les types indiquant la possibilité de valeur nulle.

Kotlin

En Kotlin, la possibilité de valeur nulle fait partie du système de types. Par exemple, une variable doit être déclarée dès le départ comme pouvant ou ne pouvant pas être nulle Les types pouvant être nulls sont marqués d'un ? :

// non-null
var s: String = "Hello"

// null
var s: String? = "Hello"

Les variables sans possibilité de valeur nulle ne peuvent pas recevoir une telle valeur. Les autres doivent faire l'objet d'une vérification aavant d'être utilisées comme non nulles.

Si vous ne souhaitez pas rechercher les valeurs nulles explicitement, vous pouvez utiliser l'opérateur d'appel sécurisé ?. :

val length: Int? = string?.length  // length is a nullable int
                                   // if string is null, then length is null

Une bonne pratique consiste à anticiper le cas d'une valeur nulle pour un objet pouvant avoir une telle valeur, faute de quoi votre application risque de présenter des états inattendus. Si votre application ne plante plus du fait d'erreurs NullPointerException, vous ne saurez pas que ces erreurs existent.

Il existe plusieurs façons de vérifier les valeurs nulles :

  • Contrôles if

    val length = if(string != null) string.length else 0
    

    En raison de la fonctionnalité Smart-Cast et de la vérification des valeurs nulles, le compilateur Kotlin sait que la valeur de la chaîne est non nulle. Vous pouvez donc utiliser la référence directement, sans recourir à l'opérateur d'appel sécurisé.

  • Opérateur Elvis ?:

    Cet opérateur vous permet de déclarer "si l'objet n'est pas nul, renvoyer l'objet ; sinon, renvoyer quelque chose d'autre".

    val length = string?.length ?: 0
    

Il reste possible d'obtenir un NullPointerException dans Kotlin. Voici les cas les plus fréquents où cela se produit :

  • Lorsque vous générez explicitement un NullPointerException.
  • Lorsque vous utilisez l'opérateur !! d'assertion nulle. Cet opérateur convertit n'importe quelle valeur vers un type non nul, en générant NullPointerException si la valeur est nulle.
  • Lorsque vous accédez à une référence nulle d'un type de plate-forme.

Types de plates-formes

Les types de plates-formes sont des déclarations d'objets provenant de Java. Ces types font l'objet d'un traitement spécial ; les vérifications des valeurs nulles ne sont pas appliquées aussi systématiquement. La garantie non nulle est donc identique à celle de Java. Lorsque vous accédez à une référence de type de plate-forme, Kotlin ne crée pas d'erreurs au moment de la compilation, mais ces références peuvent donner lieu à des erreurs d'exécution. Consultez l'exemple suivant dans la documentation Kotlin :

val list = ArrayList<String>() // non-null (constructor result) list.add("Item")
val size = list.size // non-null (primitive int) val item = list[0] // platform
type inferred (ordinary Java object) item.substring(1) // allowed, may throw an
                                                       // exception if item == null

Kotlin s'appuie sur l'inférence de type lorsqu'une valeur de plate-forme est attribuée à une variable Kotlin. Vous pouvez également définir le type attendu. Le meilleur moyen de garantir qu'une référence en provenance de Java se trouve dans l'état souhaité concernant la possibilité de valeur nulle consiste à utiliser des annotations le précisant (par exemple, @Nullable) dans votre code Java. Le compilateur Kotlin représentera ces références comme des types pouvant être nuls ou non plutôt que comme des types de plates-formes.

Les API Java Jetpack ont été annotées avec @Nullable ou @NonNull selon les besoins, et une approche similaire a été adoptée dans le SDK Android 11. Les types provenant de ce SDK et utilisés en Kotlin seront représentés par des types valides pouvant ou ne pouvant pas être nuls.

Grâce à ce système de types de Kotlin, nous avons constaté que les applications présentaient une réduction importante du nombre de plantages dus à l'erreur NullPointerException. Par exemple, l'application Google Home a constaté une réduction de 30 % des plantages causés par des exceptions de pointeur nul pendant l'année où a été effectuée la migration du développement de nouvelles fonctionnalités vers Kotlin.