Comment obtenir des données de crash à partir de mon application Android?
Comment puis-je obtenir des données d'incident (traces de pile au moins) à partir de mon application Android? Du moins lorsque je travaille sur mon propre périphérique récupéré par câble, mais idéalement depuis n'importe quelle instance de mon application fonctionnant à l'état sauvage afin que je puisse l'améliorer et le rendre plus solide.
Vous pouvez essayer le ACRA (Application Crash Report pour Android) bibliothèque:
ACRA est une bibliothèque permettant à une application Android de publier automatiquement ses rapports d'incident sur un formulaire GoogleDoc. Il est destiné aux développeurs d’applications Android afin de les aider à récupérer les données de leurs applications lorsqu’ils se bloquent ou se comportent de manière erronée.
Il est facile à installer dans votre application, hautement configurable et ne vous oblige pas à héberger un script serveur n'importe où ... les rapports sont envoyés à une feuille de calcul Google Doc!
Pour des exemples d'applications et 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 Project Android-remote-stacktrace (plus précisément par les éléments de sauvegarde sur périphérique et de téléchargement sur serveur) et je pense que cela résout le problème mentionné par Soonil. Ce n'est pas optimal, mais cela fonctionne et vous pouvez l'améliorer si vous souhaitez l'utiliser dans une application de production. Si vous décidez de télécharger les 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 scripts php facultatifs pour le serveur hébergeant les stacktraces téléchargées.
Dans un contexte (par exemple l'activité principale), appelez
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 également essayer BugSense . BugSense collecte et analyse tous les rapports d'incident et vous fournit des rapports significatifs et visuels. C'est gratuit et ce n'est qu'une ligne de code à intégrer.
Disclaimer: Je suis un co-fondateur
Dans Android 2.2, il est maintenant possible d'obtenir automatiquement des rapports d'incident à partir d'applications Android Market:
Nouvelle fonctionnalité de rapport de bogue pour Android Les applications du marché permettent aux développeurs de recevoir un crash et geler les rapports de leurs utilisateurs. Les rapports seront disponible quand ils se connectent à leur compte é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 déranger la méthode de gestion des exceptions d'Android. J'ai essayé d'utiliser un gestionnaire 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 réintégrant les exceptions, je ne pouvais pas obtenir le comportement souhaité, c'est-à-dire que je consignais l'exception tout en permettant à Android d'éteindre le composant.
Je vois que la question est trop ancienne et espère que ma réponse sera utile pour les autres personnes ayant le même problème ...
Donnez Crashlytics a essayer. Il vous donnera un aperçu complet de toutes les pannes sur tous les appareils ayant votre application et vous enverra une notification par e-mail. Et la meilleure partie est son utilisation totalement gratuite.
Ok, eh bien, j’ai examiné les échantillons fournis par rrainn et Soonil et j’ai trouvé une solution Qui ne gâche pas le traitement des erreurs.
J'ai modifié le CustomExceptionHandler pour qu'il stocke le UncaughtExceptionHandler d'origine à partir du thread auquel nous associons le nouveau. À la fin de la nouvelle méthode "uncaughtException" - J'appelle simplement l'ancienne fonction à l'aide de l'UncaughtExceptionHandler stocké.
Dans la classe DefaultExceptionHandler, vous avez besoin de sth. comme ça:
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 à l’adresse http://code.google.com/p/Android-remote-stacktrace Vous disposez d’une bonne base de travail pour vous connecter sur le terrain à votre serveur Web ou à carte SD.
J'utilise Crittercism pour mes applications Android et iOS - j'en ai entendu parler sur Techcrunch. Assez heureux avec eux jusqu'à présent!
La console des développeurs de Google Play vous fournit en fait les traces de la pile des applications qui sont tombées en panne et qui ont envoyé les rapports. Elle contient également de très bons graphiques pour vous aider à voir les informations. Voir l'exemple ci-dessous:
J'ai créé ma propre version ici: http://androidblogger.blogspot.com/2009/12/how-to-improve-your-application-crash.html
C’est fondamentalement la même chose, mais j’utilise un courrier plutôt qu’une connexion http pour envoyer le rapport et, plus important encore, j’ai ajouté des informations telles que la version de l’application, la version du système d’exploitation, le modèle de téléphone ou la mémoire disponible à mon rapport. .
utilisez-le pour intercepter les détails de l'exception:
String stackTrace = Log.getStackTraceString(exception);
stockez-le dans la base de données et maintenez le journal.
Vous pouvez également utiliser un service complet (simple) pour celui-ci plutôt que seulement une bibliothèque. Notre société vient de publier un service spécialement conçu à cet effet: http://apphance.com .
Il contient une bibliothèque .jar simple (pour Android) que vous ajoutez et intégrez en 5 minutes. Elle rassemble non seulement les informations sur les incidents, mais également les journaux des applications en cours, et permet également aux testeurs de signaler les problèmes directement depuis le périphérique, y compris le contexte entier (rotation de l'appareil, qu'il soit connecté à un réseau wifi ou non et plus). Vous pouvez consulter les journaux à l’aide d’un panneau Web très agréable et utile, dans lequel vous pouvez suivre les sessions avec votre application, les plantages, les journaux, les statistiques, etc. Le service est en phase de test bêta fermé, mais vous pouvez demander un accès et nous vous le fournissons très rapidement.
Disclaimer: Je suis CTO de Polidea et co-créateur du service.
Merci aux ressources présentes dans Stackoverflow pour m'aider à trouver cette réponse.
Vous pouvez trouver vos rapports d'incident Android à distance directement dans votre courrier électronique . souvenez-vous que vous devez mettre votre email dans la classe CustomExceptionHandler .
public static String sendErrorLogsTo = "[email protected]" ;
Étapes requises:
1er) dans onCreate de votre activité, utilisez cette section de votre code.
if(!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(this));
}
2nd) utiliser cette version remplacée de la classe CustomExceptionHandler de (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 = "[email protected]" ;
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ù. Un hack rapide et sale consiste donc à ajouter à tout bloc catch getRuntime().exec("logcat >> /sdcard/logcat.log");
Il existe un outil appelé matrice, il s'agit d'un outil d'analyse des incidents qui vous permettra d'obtenir des rapports d'incident lorsque l'application est déployée en direct et pendant le développement . L'ajout de cet outil à votre application était également simple ... votre application qui bloque ce rapport peut être visualisée à partir de votre tableau de bord fabric.io. Ce rapport a été capturé automatiquement. Il ne demandera pas la permission à l'utilisateur. Qu'il/elle veuille envoyer le rapport de bug/crash . Et ceci est totalement gratuit ... https://get.fabric.io/
Google Firebase est le dernier moyen (2016) de Google de vous fournir des données sur les accidents et les erreurs sur votre téléphone. Incluez-le dans votre fichier build.gradle:
compile 'com.google.firebase:firebase-crash:9.0.0'
Les collisions fatales sont automatiquement enregistrées, sans intervention de l'utilisateur. Vous pouvez également consigner les collisions non fatales ou d'autres événements tels que:
try
{
}
catch(Exception ex)
{
FirebaseCrash.report(new Exception(ex.toString()));
}
Bien que de nombreuses réponses sur cette page soient utiles, il leur est facile de devenir obsolètes. Le site Web AppBrain regroupe des statistiques qui vous permettent de trouver la solution de génération de rapports d'incident la plus populaire actuellement:
Bibliothèques de rapports de crash Android
Vous pouvez constater qu'au moment de publier cette image, Crashlytics est utilisé dans 5,24% des applications et 12,38% des installations.
Nous utilisons notre système maison au sein de l'entreprise et il nous sert très bien. C'est une bibliothèque Android qui envoie des rapports d'incident au serveur et le serveur reçoit des rapports et effectue des analyses. Les exceptions de groupe de serveurs par nom d'exception, stacktrace, message. Il est utile d’identifier les problèmes les plus critiques qui doivent être résolus. Notre service est maintenant en version bêta publique afin que tout le monde puisse l’essayer. Vous pouvez créer un compte sur http://watchcat.co ou vous pouvez simplement regarder comment cela fonctionne à l'aide de l'accès démo http://watchcat.co/reports/index.php?demo .
Les rapports d'incident Firebase sont très populaires et faciles à utiliser . Veuillez vous reporter au lien suivant pour plus d'informations: Rapport d'incidents Firebase
J'espère que cela vous aidera.
Il y a cette bibliothèque Android appelée Sherlock . Il vous donne le rapport complet de l’incident ainsi que des informations sur l’appareil et l’application ..__ Chaque fois qu’un incident se produit, il affiche une notification dans la barre de notification et, en cliquant sur la notification, ouvre les détails de l’incident. Vous pouvez également partager les détails d'un incident avec d'autres personnes via un courrier électronique ou d'autres options de partage.
Installation
Android {
dataBinding {
enabled = true
}
}
compile('com.github.ajitsing:sherlock:1.0.0@aar') {
transitive = true
}
Démo
J'ai trouvé une application Web supplémentaire 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 fini de créer une application, ils fourniront une ligne à configurer comme ci-dessous.
Mint.initAndStartSession(YourActivity.this, "api_key");
- Ajoutez les éléments suivants dans le fichier build.gradl de l'application.
Android { ... repositories { maven { url "https://mint.splunk.com/gradle/"} } ... } dependencies { ... compile "com.splunk.mint:mint:4.4.0" ... }
- Ajoutez le code que nous avons copié ci-dessus et ajoutez-le à chaque activité .
Mint.initAndStartSession (YourActivity.this, "clé_api");
C'est tout. Vous vous connectez et accédez au tableau de bord de votre application, vous obtiendrez tous les rapports d'erreur.
J'espère que ça aide quelqu'un.
Pour une autre solution de signalement d’incident/service de suivi des exceptions Raygun.io - vous disposez de plusieurs logiques Nice pour la gestion des pannes Android, y compris une expérience utilisateur décente lorsque vous la connectez à votre application Activité et quelques lignes de XML collées dans AndroidManifest).
Lorsque votre application se bloque, elle récupère automatiquement la trace de pile, les données d'environnement pour le matériel/logiciel, les informations de suivi des utilisateurs, les données personnalisées que vous spécifiez, etc. sur le disque s'il n'y a pas de réseau disponible.
Disclaimer: J'ai construit le fournisseur Android :)
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 fichiers indésirables dans votre journal, essayez de le nettoyer en premier.
$adb Shell logcat -c
Ensuite, essayez d'exécuter votre application, puis connectez-vous à nouveau.
Je viens juste de commencer à utiliser ACRA https://github.com/ACRA/acra en utilisant Google Forms en tant que backend. Il est très facile à configurer et à utiliser, il s’agit du comportement par défaut.
BUT L'envoi de rapports à Google Forms va être déconseillé (puis supprimé):https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6https://github.com/ACRA/acra/wiki/Notice-on-Google-Form-Spreadsheet-usage
Quoi qu'il en soit, il est possible de définir votre propre expéditeur https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender Vous pouvez essayer d'envoyer un e-mail à l'expéditeur, 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 sans bugsense est limité à 500 rapports/mois
Je suis l’un des fondateurs de Bugsnag que nous avons conçu dans ce but précis. Bugsnag capture automatiquement les exceptions non gérées dans les applications Android et les envoie à notre tableau de bord, où vous pouvez hiérarchiser les correctifs et plonger dans les informations de diagnostic.
Voici quelques éléments importants à prendre en compte lors de la sélection ou de la création d'un système de signalement des incidents, ainsi que des extraits de code:
- Détecte automatiquement les exceptions non gérées ( example code )
- Collecte des données de diagnostic telles que l'utilisation de la mémoire, les informations sur le périphérique, etc. ( exemple de code )
- Groupe efficacement se bloque ensemble par cause fondamentale
- Vous permet de suivre les actions que l'utilisateur a entreprises avant chaque incident pour aider à reproduire ( exemple de code )
Si vous souhaitez connaître les meilleures pratiques en matière de gestion des accidents et de rapports sur les accidents sur Android, vous pouvez consulter le code source complet de la bibliothèque de Bugsnag rapports sur les incidents qui est entièrement open source, n'hésitez pas à le séparer et à l'utiliser vous-même applications!
En retard pour le parti, 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'incident à l'aide d'ACRA et l'envoyer à l'adresse électronique à l'aide de MandrillAp.
Lien vers le message: https://androidician.wordpress.com/2015/03/29/sending-crash-reports-with-acra-over-email-using-mandrill/
Lien vers un exemple de projet sur github: https://github.com/ayushhgoyal/AcraSample
Vous pouvez le faire directement dans Android Studio. Il suffit de connecter votre téléphone, d'exécuter l'application, de le laisser planter et d'afficher le stacktrace directement dans Android Studio.
Google a modifié le nombre de rapports d'accident que vous recevez réellement. Auparavant, vous ne receviez que des rapports de bogues rapportés manuellement.
Depuis la dernière conférence des développeurs et l'introduction de Android Vitals , vous obtenez également des rapports d'incident de la part d'utilisateurs qui ont permis de partager des données de diagnostic.
Vous verrez tous les collisions collectées à partir d'appareils Android dont les utilisateurs ont choisi de partager automatiquement les données d'utilisation et de diagnostic. Les données sont disponibles pour les deux mois précédents.
Afficher les blocages et les erreurs de réponse des applications (ANR)
Flurry analytics vous donne des informations sur les collisions, le modèle de matériel, la version d'Android et les statistiques d'utilisation en direct des applications. Dans le nouveau SDK, ils semblent fournir des informations plus détaillées sur les accidents http://www.flurry.com/flurry-crash-analytics.html .
Si votre application est en cours de téléchargement par d'autres personnes et se bloque sur des appareils distants, vous voudrez peut-être consulter une bibliothèque de rapports d'erreur Android (référencée dans cet SO post ). S'il ne s'agit que de votre propre appareil local, vous pouvez utiliser LogCat. Même si le périphérique n'était pas connecté à une machine hôte lorsque l'incident s'est produit, connectez-le et émettez une commande adb logcat pour télécharger l'intégralité de l'historique logcat (au moins dans la mesure où il est mis en mémoire tampon, ce qui correspond généralement à une longueur d'avance , ce n’est tout simplement pas infini). Est-ce que l'une ou l'autre de ces options répond à votre question? Sinon, pouvez-vous essayer de clarifier ce que vous cherchez un peu plus?