Comment puis-je obtenir des données crash de mon application Android?
Comment puis-je obtenir des données de crash (stack traces au moins) à partir de mon application Android? Au moins quand je travaille sur mon propre appareil étant récupéré par câble, mais idéalement à partir de n'importe quelle instance de mon application tournant sur le wild afin que je puisse l'améliorer et le rendre plus solide.
30 réponses
vous pourriez essayer le ACRA (Application Crash Report for Android) bibliothèque:
ACRA est une bibliothèque permettant à L'application Android de poster automatiquement leurs rapports de crash sur un formulaire GoogleDoc. Il est destiné aux développeurs d'applications android pour les aider à obtenir des données à partir de leurs applications quand ils plantent ou se comportent de manière erronée.
c'est facile à installer dans votre application, hautement configurable et ne vous obligez pas à héberger un script de serveur où que ce soit... les rapports sont envoyés à une feuille de calcul Google Doc !
pour des exemples d'applications et des fins de débogage, j'utilise une solution simple qui me permet d'écrire le stacktrace sur la carte sd de l'appareil et/ou de le télécharger sur un serveur. Cette solution a été inspirée par le projet android-remote-stacktrace (plus précisément, les parties save-to-device et upload-to-server) et je pense qu'elle résout le problème évoqué par Soonil. Ce n'est pas optimal, mais il fonctionne et vous pouvez l'améliorer si vous voulez l'utiliser dans une production application. Si vous décidez de télécharger le stacktraces sur le serveur, vous pouvez utiliser un script php ( index.php ) pour les afficher. Si vous êtes intéressé, vous pouvez trouver toutes les sources ci - dessous-une classe java pour votre application et deux scrips php en option pour le serveur hébergeant les stacktraces téléchargés.
dans un contexte (par exemple L'activité principale), appeler
if(!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(
"/sdcard/<desired_local_path>", "http://<desired_url>/upload.php"));
}
CustomExceptionHandler
public class CustomExceptionHandler implements UncaughtExceptionHandler {
private UncaughtExceptionHandler defaultUEH;
private String localPath;
private String url;
/*
* if any of the parameters is null, the respective functionality
* will not be used
*/
public CustomExceptionHandler(String localPath, String url) {
this.localPath = localPath;
this.url = url;
this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler();
}
public void uncaughtException(Thread t, Throwable e) {
String timestamp = TimestampFormatter.getInstance().getTimestamp();
final Writer result = new StringWriter();
final PrintWriter printWriter = new PrintWriter(result);
e.printStackTrace(printWriter);
String stacktrace = result.toString();
printWriter.close();
String filename = timestamp + ".stacktrace";
if (localPath != null) {
writeToFile(stacktrace, filename);
}
if (url != null) {
sendToServer(stacktrace, filename);
}
defaultUEH.uncaughtException(t, e);
}
private void writeToFile(String stacktrace, String filename) {
try {
BufferedWriter bos = new BufferedWriter(new FileWriter(
localPath + "/" + filename));
bos.write(stacktrace);
bos.flush();
bos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
private void sendToServer(String stacktrace, String filename) {
DefaultHttpClient httpClient = new DefaultHttpClient();
HttpPost httpPost = new HttpPost(url);
List<NameValuePair> nvps = new ArrayList<NameValuePair>();
nvps.add(new BasicNameValuePair("filename", filename));
nvps.add(new BasicNameValuePair("stacktrace", stacktrace));
try {
httpPost.setEntity(
new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
httpClient.execute(httpPost);
} catch (IOException e) {
e.printStackTrace();
}
}
}
upload.php
<?php
$filename = isset($_POST['filename']) ? $_POST['filename'] : "";
$message = isset($_POST['stacktrace']) ? $_POST['stacktrace'] : "";
if (!ereg('^[-a-zA-Z0-9_. ]+$', $filename) || $message == ""){
die("This script is used to log debug data. Please send the "
. "logging message and a filename as POST variables.");
}
file_put_contents($filename, $message . "\n", FILE_APPEND);
?>
index.php
<?php
$myDirectory = opendir(".");
while($entryName = readdir($myDirectory)) {
$dirArray[] = $entryName;
}
closedir($myDirectory);
$indexCount = count($dirArray);
sort($dirArray);
print("<TABLE border=1 cellpadding=5 cellspacing=0 \n");
print("<TR><TH>Filename</TH><TH>Filetype</th><th>Filesize</TH></TR>\n");
for($index=0; $index < $indexCount; $index++) {
if ((substr("$dirArray[$index]", 0, 1) != ".")
&& (strrpos("$dirArray[$index]", ".stacktrace") != false)){
print("<TR><TD>");
print("<a href=\"$dirArray[$index]\">$dirArray[$index]</a>");
print("</TD><TD>");
print(filetype($dirArray[$index]));
print("</TD><TD>");
print(filesize($dirArray[$index]));
print("</TD></TR>\n");
}
}
print("</TABLE>\n");
?>
vous pouvez aussi essayer BugSense . BugSense collecte et analyse tous les rapports de crash et vous donne des rapports visuels et significatifs. C'est gratuit et c'est seulement 1 ligne de code pour intégrer.
clause de non-responsabilité: je suis un co-fondateur
dans Android 2.2 il est maintenant possible d'obtenir automatiquement des rapports de Crash à partir des applications Android Market:
nouvelle fonctionnalité de rapport de bogues pour Android Le marché des applications permet aux développeurs de recevoir des rapports d'accident et de gel de la part de leurs utilisateurs. Les rapports seront disponibles lorsqu'ils se connectent à leur compte d'éditeur.
http://developer.android.com/sdk/android-2.2-highlights.html
il est possible de gérer ces exceptions avec Thread.setDefaultUncaughtExceptionHandler() , mais cela semble gâcher la méthode de traitement des exceptions D'Android. J'ai essayé d'utiliser un handler de cette nature:
private class ExceptionHandler implements Thread.UncaughtExceptionHandler {
@Override
public void uncaughtException(Thread thread, Throwable ex){
Log.e(Constants.TAG, "uncaught_exception_handler: uncaught exception in thread " + thread.getName(), ex);
//hack to rethrow unchecked exceptions
if(ex instanceof RuntimeException)
throw (RuntimeException)ex;
if(ex instanceof Error)
throw (Error)ex;
//this should really never happen
Log.e(Constants.TAG, "uncaught_exception handler: unable to rethrow checked exception");
}
}
cependant, même en repensant les exceptions, je n'ai pas été en mesure d'obtenir le comportement désiré, c'est-à-dire la journalisation de l'exception tout en permettant à Android d'arrêter le composant qu'il s'était passé, donc j'ai abandonné après un certain temps.
Ok, j'ai regardé les échantillons fournis de rrainn et Soonil, et j'ai trouvé une solution cela ne gâche pas la gestion des erreurs.
j'ai modifié le CustomExceptionHandler pour qu'il stocke le UncaughtExceptionHandler original à partir du Thread que nous associons au Nouveau. À la fin de la nouvelle "unaughtexception""- Méthode je viens d'appeler l'ancienne fonction en utilisant le UncaughtExceptionHandler stocké.
dans la classe DefaultExceptionHandler vous avez besoin de sth. comme ceci:
public class DefaultExceptionHandler implements UncaughtExceptionHandler{
private UncaughtExceptionHandler mDefaultExceptionHandler;
//constructor
public DefaultExceptionHandler(UncaughtExceptionHandler pDefaultExceptionHandler)
{
mDefaultExceptionHandler= pDefaultExceptionHandler;
}
public void uncaughtException(Thread t, Throwable e) {
//do some action like writing to file or upload somewhere
//call original handler
mStandardEH.uncaughtException(t, e);
// cleanup, don't know if really required
t.getThreadGroup().destroy();
}
}
avec cette modification sur le code à http://code.google.com/p/android-remote-stacktrace vous avez une bonne base de travail pour se connecter sur le terrain à votre serveur web ou à la carte sd.
j'ai utilisé Crittercism pour mes applications Android et iOS -- j'en ai entendu parler sur techcrunch. Assez heureux avec eux jusqu'à présent!
je vois que la question est trop ancienne, et j'espère que ma réponse est utile pour d'autres ayant la même question...
Donner Crashlytics un essai. Il donnera un aperçu approfondi de tous les accidents sur tous les appareils ayant votre application et vous envoyer une notification par e-mail..Et la meilleure partie est complètement libre d'utilisation..
Google Play Developers Console vous donne en fait les traces de pile de ces applications qui ont crashé et ont envoyé les rapports, il a également un très bon graphiques pour vous aider à voir les informations, voir l'exemple ci-dessous:
j'ai fait ma propre version ici : http://androidblogger.blogspot.com/2009/12/how-to-improve-your-application-crash.html
c'est essentiellement la même chose, mais j'utilise un mail plutôt qu'une connexion http pour envoyer le rapport, et, plus important encore, j'ai ajouté des informations comme la version d'application, la version OS, le modèle de téléphone, ou la mémoire disponible à mon rapport...
utilisez ceci pour saisir les détails de l'exception:
String stackTrace = Log.getStackTraceString(exception);
stockez ceci dans la base de données et maintenez le journal.
vous pouvez également utiliser un service entier (simple) pour elle plutôt que seulement la bibliothèque. Notre société vient de publier un service juste pour cela: http://apphance.com .
il a un simple .bibliothèque jar (pour Android) que vous ajoutez et intégrez en 5 minutes et puis la bibliothèque rassemble non seulement les informations de panne, mais aussi les journaux de l'application en cours d'exécution, ainsi qu'il permet à vos testeurs de signaler les problèmes directement à partir de l'appareil - y compris le contexte entier (rotation de l'appareil, qu'il soit connecté à un wifi ou non et plus). Vous pouvez regarder les journaux en utilisant un panneau web très agréable et utile, où vous pouvez suivre les sessions avec votre application, les accidents, les journaux, les statistiques et plus encore. Le service est en phase de test bêta fermée maintenant, mais vous pouvez demander l'accès et nous vous le donnons très rapidement.
Avertissement: je suis directeur technique de Polidea, et co-créateur du service.
remercie les ressources présentes dans Stackoverflow de m'avoir aidé à trouver cette réponse.
vous pouvez trouver vos rapports de crash Android à distance directement dans votre e-mail . rappelez-vous que vous devez mettre votre e-mail dans la classe CustomExceptionHandler .
public static String sendErrorLogsTo = "tushar.pandey@virtualxcellence.com" ;
Étapes nécessaires :
1st) dans une année de votre activité utilisez cette section de votre code.
if(!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(this));
}
2nd) utilisez cette version écrasée de CustomExceptionHandler class of ( rrainn ), selon mon phpscript.
package com.vxmobilecomm.activity;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.BufferedHttpEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.AsyncTask;
import android.util.Log;
public class CustomExceptionHandler implements UncaughtExceptionHandler {
private UncaughtExceptionHandler defaultUEH;
public static String sendErrorLogsTo = "tushar.pandey@virtualxcellence.com" ;
Activity activity;
public CustomExceptionHandler(Activity activity) {
this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler();
this.activity = activity;
}
public void uncaughtException(Thread t, Throwable e) {
final Writer result = new StringWriter();
final PrintWriter printWriter = new PrintWriter(result);
e.printStackTrace(printWriter);
String stacktrace = result.toString();
printWriter.close();
String filename = "error" + System.nanoTime() + ".stacktrace";
Log.e("Hi", "url != null");
sendToServer(stacktrace, filename);
StackTraceElement[] arr = e.getStackTrace();
String report = e.toString() + "\n\n";
report += "--------- Stack trace ---------\n\n";
for (int i = 0; i < arr.length; i++) {
report += " " + arr[i].toString() + "\n";
}
report += "-------------------------------\n\n";
report += "--------- Cause ---------\n\n";
Throwable cause = e.getCause();
if (cause != null) {
report += cause.toString() + "\n\n";
arr = cause.getStackTrace();
for (int i = 0; i < arr.length; i++) {
report += " " + arr[i].toString() + "\n";
}
}
report += "-------------------------------\n\n";
defaultUEH.uncaughtException(t, e);
}
private void sendToServer(String stacktrace, String filename) {
AsyncTaskClass async = new AsyncTaskClass(stacktrace, filename,
getAppLable(activity));
async.execute("");
}
public String getAppLable(Context pContext) {
PackageManager lPackageManager = pContext.getPackageManager();
ApplicationInfo lApplicationInfo = null;
try {
lApplicationInfo = lPackageManager.getApplicationInfo(
pContext.getApplicationInfo().packageName, 0);
} catch (final NameNotFoundException e) {
}
return (String) (lApplicationInfo != null ? lPackageManager
.getApplicationLabel(lApplicationInfo) : "Unknown");
}
public class AsyncTaskClass extends AsyncTask<String, String, InputStream> {
InputStream is = null;
String stacktrace;
final String filename;
String applicationName;
AsyncTaskClass(final String stacktrace, final String filename,
String applicationName) {
this.applicationName = applicationName;
this.stacktrace = stacktrace;
this.filename = filename;
}
@Override
protected InputStream doInBackground(String... params)
{
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(
"http://suo-yang.com/books/sendErrorLog/sendErrorLogs.php?");
Log.i("Error", stacktrace);
try {
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(
6);
nameValuePairs.add(new BasicNameValuePair("data", stacktrace));
nameValuePairs.add(new BasicNameValuePair("to",sendErrorLogsTo));
nameValuePairs.add(new BasicNameValuePair("subject",applicationName));
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity1 = response.getEntity();
BufferedHttpEntity bufHttpEntity = new BufferedHttpEntity(
entity1);
is = bufHttpEntity.getContent();
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return is;
}
@Override
protected void onPostExecute(InputStream result) {
super.onPostExecute(result);
Log.e("Stream Data", getStringFromInputStream(is));
}
}
// convert InputStream to String
private static String getStringFromInputStream(InputStream is) {
BufferedReader br = null;
StringBuilder sb = new StringBuilder();
String line;
try {
br = new BufferedReader(new InputStreamReader(is));
while ((line = br.readLine()) != null) {
sb.append(line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return sb.toString();
}
}
c'est très brutal, mais il est possible d'exécuter logcat n'importe où, donc un hack rapide et sale est à ajouter à n'importe quel bloc de capture getRuntime().exec("logcat >> /sdcard/logcat.log");
il y a un outil appelé fabric, c'est un outil d'analyse de crash, qui vous permettra d'obtenir des rapports de crash , lorsque l'application est déployée en direct et pendant le développement. Ajouter cet outil à votre application était aussi simple que cela.. Lorsque votre application crash ce rapport de l'accident peut être vu à partir de votre tissu.io tableau de bord . ce rapport a été enregistré automatiquement.il ne demandera pas la permission à l'utilisateur. S'il/elle veut envoyer le rapport de bug / plantage. Et c'est complètement gratuit... https://get.fabric.io/
Google Firebase est le dernier(2016) moyen de Google à vous fournir des données d'erreur/plantage sur votre téléphone. L'inclure dans votre construction.gradle fichier :
compile 'com.google.firebase:firebase-crash:9.0.0'
les accidents mortels sont enregistrés automatiquement sans que l'utilisateur n'ait besoin d'entrer des données et vous pouvez également enregistrer les accidents non mortels ou d'autres événements du genre:
try
{
}
catch(Exception ex)
{
FirebaseCrash.report(new Exception(ex.toString()));
}
nous utilisons notre système maison à l'intérieur de l'entreprise et il nous sert très bien. C'est une bibliothèque android qui envoie des rapports de plantage au serveur qui reçoit des rapports et fait des analyses. Groupes de serveurs exceptions par nom d'exception, stacktrace, message. Elle permet d'identifier les points les plus critiques qui doivent être corrigés. Notre service est en version bêta publique maintenant si tout le monde peut essayer. Vous pouvez créer un compte à http://watchcat.co ou vous pouvez juste regarder comment il fonctionne en utilisant l'accès démo http://watchcat.co/reports/index.php?demo .
bien que plusieurs des réponses sur cette page sont utiles, il est facile pour eux de devenir périmé. Le site Web D'AppBrain rassemble des statistiques qui vous permettent de trouver la solution la plus populaire de notification des accidents qui est à jour:
Android des rapports d'incidents bibliothèques
vous pouvez voir qu'au moment de poster cette image, Crashlytics est utilisé dans 5,24% des applis et 12,38% des install.
j'ai trouvé une application web plus grande pour suivre les rapports d'erreur.
petit nombre d'étapes à configurer.
- connectez-vous ou inscrivez-vous et configurez en utilisant le lien ci-dessus. Une fois que vous avez créé une application, ils fourniront une ligne à configurer comme ci-dessous.
Mint.initAndStartSession(YourActivity.this, "api_key");
- ajouter ce qui suit dans la construction de l'application.gradl.
android { ... repositories { maven { url "https://mint.splunk.com/gradle/"} } ... } dependencies { ... compile "com.splunk.mint:mint:4.4.0" ... }
- ajouter le code que nous avons copié ci-dessus et l'ajouter à chaque activité.
à la Menthe.initAndStartSession(YourActivity.ce, "api_key");
C'est tout. Vous vous connectez et allez à votre application dashboard, vous obtiendrez tous les rapports d'erreur.
J'espère que ça aidera quelqu'un.
il y a cette bibliothèque android appelée Sherlock . Il vous donne le rapport complet de collision avec l'appareil et les informations de l'application. Chaque fois qu'un crash se produit, il affiche une notification dans la barre de notification et en cliquant sur la notification, il ouvre les détails du crash. Vous pouvez également partager les détails du crash avec d'autres personnes par courriel ou d'autres options de partage.
Installation
android {
dataBinding {
enabled = true
}
}
compile('com.github.ajitsing:sherlock:1.0.0@aar') {
transitive = true
}
Démo
si vous voulez des réponses immédiatement, vous pouvez utiliser logcat
$adb shell logcat -f /sdcard/logoutput.txt *:E
S'il y a trop de ferraille dans votre bûche, essayez de la nettoyer d'abord.
$adb shell logcat -c
ensuite, essayez d'exécuter votre application puis logcat à nouveau.
pour un autre service de rapport d'accident/suivi des exceptions, cochez Raygun.io - il a un tas de belle logique pour gérer les accidents Android, y compris l'expérience utilisateur décente lors de la connexion à votre application (Deux lignes de code dans votre activité principale et quelques lignes de XML collé dans AndroidManifest).
quand votre application crashes, il va automatiquement saisir la trace de la pile, les données d'environnement pour le matériel / logiciel, l'information de suivi de l'utilisateur, tout données personnalisées que vous spécifiez etc. Il le poste à L'API de façon asynchrone de sorte qu'il ne bloque pas le thread de L'interface utilisateur, et le cache sur le disque s'il n'y a pas de réseau disponible.
avertissement: j'ai construit le fournisseur Android:)
de nos jours, les rapports de Crash Firebase sont très populaires et plus faciles à utiliser. Veuillez consulter le lien suivant pour plus d'informations: Firebase Rapport D'Incident
J'espère que ça vous aidera.
vient de commencer à utiliser ACRA https://github.com/ACRA/acra en utilisant Google Forms comme backend et c'est très facile à configurer et à utiliser, c'est la valeur par défaut.
mais L'envoi de rapports à Google formulaires vont être dépréciés (puis supprimé): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://github.com/ACRA/acra/wiki/Notice-on-Google-Form-Spreadsheet-usage
de toute façon, il est possible de définir votre propre expéditeur https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender vous pouvez donner un essai à l'expéditeur d'un courriel par exemple.
avec un minimum d'effort, il est possible d'envoyer des rapports à bugsense: http://www.bugsense.com/docs/android#acra
NB le compte gratuit bugsense est limité à 500 rapport / mois
en retard à la partie, je soutiens et crois ACRA est la meilleure option parmi tous. Son facile à installer et à configurer. J'ai créé un guide détaillé avec des entrées de partout pour récupérer le rapport d'accident en utilisant ACRA et envoyer le même à mon adresse email en utilisant MandrillAp.
lien vers la publication: https://androidician.wordpress.com/2015/03/29/sending-crash-reports-with-acra-over-email-using-mandrill /
Lien vers l'exemple de projet sur github: https://github.com/ayushhgoyal/AcraSample
je suis l'un des fondateurs de Bugsnag que nous avons conçu exactement dans ce but. Bugsnag saisit automatiquement les exceptions non gérées dans les applications Android et les envoie à notre tableau de bord, où vous pouvez prioriser les corrections et plonger dans les informations de diagnostic.
voici quelques éléments importants à prendre en considération lors de la sélection ou de la construction d'un système de rapports d'accident, ainsi que quelques extraits de code:
- détecte exceptions non couvertes automatiquement ( exemple de code )
- recueille des données de diagnostic telles que l'utilisation de la mémoire, l'information de l'appareil, etc ( exemple de code )
- groups Effectively crashes together by root cause
- vous permet de suivre les actions prises par l'utilisateur avant chaque plantage pour aider à la reproduction ( exemple de code )
Si vous voulez voir quelques vous pouvez consulter le code source complet de la crash reporting library de Bugsnag qui est entièrement open source, n'hésitez pas à le déchiffrer et à l'utiliser dans vos propres applications!
si votre application est téléchargée par d'autres personnes et s'écrase sur des appareils distants, vous pouvez vouloir regarder dans une bibliothèque de rapports D'erreur Android (référencée dans ce SO post ). Si C'est seulement sur votre propre appareil local, vous pouvez utiliser LogCat. Même si l'appareil n'était pas connecté à une machine hôte lors de l'accident, connecté l'appareil et l'émission d'une commande adb logcat va télécharger l'historique complet de logcat (au moins dans la mesure où il est tamponné qui est habituellement un loooot de données de log, il est tout simplement pas infinie). Est-ce que l'une ou l'autre de ces options répond à votre question? Si ce n'est pas le cas, Pouvez-vous essayer de clarifier ce que vous cherchez un peu plus?
Flurry analytics vous donne des informations sur les accidents, le modèle matériel, la version android et les statistiques d'utilisation de l'application en direct. Dans le nouveau SDK, ils semblent fournir des informations plus détaillées sur les accidents http://www.flurry.com/flurry-crash-analytics.html .
Google a changé combien de rapports d'accident vous obtenez réellement. Auparavant, vous n'aviez reçu que des rapports de bogues manuels.
depuis la dernière conférence des développeurs et l'introduction de Android vitaux vous obtenez également des rapports de panne des utilisateurs qui ont permis de partager des données de diagnostic.
vous verrez tous les accidents collectés à partir des appareils Android dont les utilisateurs ont opté pour partager automatiquement l'utilisation et des données de diagnostic. Les données sont disponibles pour les deux mois précédents.
Afficher les accidents et l'application ne répond pas (ANR) erreurs
vous pouvez le faire directement dans Android Studio. Connectez votre téléphone, lancez l'application, laissez-la s'écraser et vous pouvez voir le stactrace directement dans Android Studio.