Comment obtenir des données de plantage depuis mon application Android?

Comment puis-je obtenir des données de plantage (traces de pile au moins) à partir de mon application Android? Au moins lorsque je travaille sur mon propre appareil récupéré par câble, mais idéalement à partir de n'importe quelle instance de mon application s'exécutant à l'état sauvage afin que je puisse l'améliorer et la rendre plus solide.

Vous pouvez essayer la bibliothèque ACRA (Application Crash Report pour Android) :

ACRA est une bibliothèque permettant à l'application Android de publier automatiquement ses rapports de plantage sur un formulaire GoogleDoc. Il est destiné aux développeurs d'applications Android pour les aider à obtenir des données de leurs applications en cas de panne ou de comportement erroné.

Il est facile à installer dans votre application, hautement configurable et ne nécessite pas d'héberger un script de serveur n'importe où ... les rapports sont envoyés vers 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 (en particulier, les parties d'enregistrement sur l'appareil et de téléchargement sur le serveur) et je pense qu'elle 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 traces de pile 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] ^{Reason: Spam Redirect vers une autre URL} . BugSense recueille et analyse tous les rapports d'erreur et vous fournit des rapports significatifs et visuels. C'est gratuit et c'est seulement 1 ligne de code pour s'intégrer.

Avertissement: je suis co-fondateur

Dans Android 2.2, il est désormais possible d'obtenir automatiquement les rapports de plantage des applications Android Market:

La nouvelle fonctionnalité de rapport de bogues pour les applications Android Market permet aux développeurs de recevoir des rapports de plantage et de gel de leurs utilisateurs. Les rapports seront disponibles lorsqu'ils se connecteront à 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 Android de gestion des exceptions. J'ai tenté 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 avec l'annulation des exceptions, je n'ai pas pu obtenir le comportement souhaité, c'est-à-dire la journalisation de l'exception tout en permettant à Android de fermer le composant.

Je vois que la question est trop ancienne et j'espère que ma réponse sera utile pour d'autres ayant le même problème ...

Essayez Crashlytics . Il donnera un aperçu approfondi de tous les plantages sur tous les appareils ayant votre application et vous enverra une notification par e-mail. Et la meilleure partie est son utilisation entièrement gratuite.

Ok, eh bien j'ai regardé les échantillons fournis par rrainn et Soonil, et j'ai trouvé une solution qui ne gâche pas la gestion des erreurs.

J'ai modifié le CustomExceptionHandler afin qu'il stocke le UncaughtExceptionHandler d'origine à partir du thread que nous associons au nouveau. À la fin de la nouvelle "uncaughtException" - Méthode, j'appelle simplement l'ancienne fonction en utilisant le UncaughtExceptionHandler stocké.

Dans la classe DefaultExceptionHandler, vous avez besoin de qch. 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 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 à la carte SD.

Google Play Developers Console vous donne en fait les traces de la pile des applications qui se sont écrasées et qui ont envoyé les rapports, il a également de très bons graphiques pour vous aider à voir les informations, voir l'exemple ci-dessous:

J'utilise Crittercism pour mes applications Android et iOS - j'en ai entendu parler sur techcrunch. Assez heureux avec eux jusqu'à présent!

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 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 ceci pour attraper les détails de l'exception:

String stackTrace = Log.getStackTraceString(exception); 

stocker cela dans la base de données et maintenir le journal.

Vous pouvez également utiliser un service complet (simple) pour celui-ci plutôt qu'une seule bibliothèque. Notre société vient de publier un service juste pour cela: http://apphance.com .

Il possède une simple bibliothèque .jar (pour Android) que vous ajoutez et intégrez en 5 minutes, puis la bibliothèque rassemble non seulement des informations sur les plantages, mais également des journaux de l'application en cours d'exécution, et permet à vos testeurs de signaler les problèmes directement à partir de l'appareil - y compris le tout le contexte (rotation de l'appareil, qu'il soit connecté ou non à un wifi et plus). Vous pouvez consulter les journaux à l'aide d'un panneau Web très agréable et utile, où vous pouvez suivre les sessions avec votre application, les plantages, les journaux, les statistiques et plus encore. Le service est actuellement en phase de test bêta fermé, mais vous pouvez demander l'accès et nous vous le donnons très rapidement.

Avertissement: je suis CTO de Polidea et co-créateur du service.

Merci aux ressources présentes de Stackoverflowm'aider à trouver cette réponse.

Vous pouvez trouver vos rapports de plantage Android à distance directement dans votre e-mail . rappelez-vous que vous devez mettre votre e-mail dans la classe CustomExceptionHandler .

public static String sendErrorLogsTo = "[email protected]" ;

Étapes requises:

1er) dans la création de votre activité, utilisez cette section de votre code.

    if(!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
        Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(this));
    }   

2e) utiliser cette version redéfinie 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();

    }
}

Aujourd'hui, les rapports d'incidents Firebase sont très populaires et plus faciles à utiliser. Veuillez consulter le lien suivant pour plus d'informations: Firebase Crash Reporting

J'espère que cela vous aidera.

C'est très brut, mais il est possible d'exécuter logcat n'importe où, donc un hack rapide et sale est d'ajouter à n'importe quel bloc catch getRuntime().exec("logcat >> /sdcard/logcat.log");

Il existe un outil appelé fabric, c'est un outil d'analyse des plantages, qui vous permettra d'obtenir des rapports de plantages, lors du déploiement de l'application en direct et pendant le développement. L'ajout de cet outil à votre application a également été simple. Lorsque votre application se bloque, le rapport de l'accident peut être affiché à partir de votre tableau de bord fabric.io. Le rapport a été capturé automatiquement. Il ne demandera pas la permission à l'utilisateur. S'il souhaite envoyer le rapport de bug / crash. Et c'est totalement gratuit ... https://get.fabric.io/

Google Firebase est la dernière façon (2016) de Google de vous fournir des données de plantage / erreur sur votre téléphone. Incluez-le dans votre fichier build.gradle:

compile 'com.google.firebase:firebase-crash:9.0.0'

Les plantages fatals sont enregistrés automatiquement sans nécessiter la saisie de l'utilisateur et vous pouvez également consigner les plantages non fatals ou d'autres événements comme ceci:

try
{

}
catch(Exception ex)
{
    FirebaseCrash.report(new Exception(ex.toString()));
}

Il y a cette bibliothèque Android appelée Sherlock . Il vous donne le rapport complet de l'accident ainsi que les informations sur l'appareil et 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 plantage avec d'autres par e-mail ou par d'autres options de partage.

Installation

android {
    dataBinding {
      enabled = true
    }
}

compile('com.github.ajitsing:sherlock:1.0.0@aar') {
    transitive = true
}

Démo

Bien que de nombreuses réponses sur cette page soient utiles, il est facile pour elles de devenir obsolètes. Le site Web AppBrain regroupe des statistiques qui vous permettent de trouver la solution de rapport d'incident la plus populaire qui soit actuelle:

Bibliothèques de rapports de plantage Android

Vous pouvez voir 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 local au sein de l'entreprise et il nous sert très bien. Il s'agit d'une bibliothèque Android qui envoie des rapports de plantage au serveur et au serveur qui reçoit les rapports et effectue des analyses. Le serveur regroupe les exceptions par nom d'exception, trace de pile, message. Il aide à 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 voir comment cela fonctionne en utilisant l'accès démo http://watchcat.co/reports/index.php?demo .

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 déchets dans votre journal en ce moment, essayez d'abord de les supprimer.

$adb shell logcat -c

Ensuite, essayez d'exécuter votre application, puis de nouveau logcat.

J'ai trouvé une autre excellente application Web pour suivre les rapports d'erreur.

https://mint.splunk.com/

Petit nombre d'étapes à configurer.

1. 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");

2. Ajoutez ce qui suit dans le build.gradl de l'application.

android {
...
    repositories {
        maven { url "https://mint.splunk.com/gradle/"}
    }
...
}

dependencies {
...
    compile "com.splunk.mint:mint:4.4.0"
...
}

3. Ajoutez le code que nous avons copié ci-dessus et ajoutez-le à chaque activité.

   Mint.initAndStartSession (YourActivity.this, "api_key");

C'est ça. Vous vous connectez et accédez à votre tableau de bord d'application, vous obtiendrez tous les rapports d'erreur.

J'espère que cela aide quelqu'un.

Pour un autre service de rapport d' incident / suivi des exceptions, consultez Raygun.io - il a un tas de logique agréable pour gérer les plantages Android, y compris une 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ées dans AndroidManifest).

Lorsque votre application se bloque, elle récupère automatiquement la trace de la pile, les données d'environnement pour le matériel / logiciel, les informations de suivi des utilisateurs, toutes les données personnalisées que vous spécifiez, etc. Elle les publie de manière asynchrone dans l'API, donc pas de blocage du thread d'interface utilisateur, et les met en cache sur le disque s'il n'y a pas de réseau disponible.

Avertissement: j'ai construit le fournisseur Android :)

Je viens 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 Forms sera obsolète (puis supprimé): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://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 par exemple essayer d'envoyer un e-mail à l'expéditeur.

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 rapports / mois

Tard dans la soirée, je soutiens et crois que l'ACRA est la meilleure option parmi toutes. C'est facile à installer et à configurer. J'ai créé un guide détaillé avec des entrées de partout pour récupérer le rapport de plantage en utilisant ACRA et l'envoyer par la poste à mon adresse e-mail en utilisant MandrillAp.

Lien vers l'article: 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

Je suis l'un des fondateurs de Bugsnag que nous avons conçu exactement dans ce but. 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 rapport d'incident, ainsi que des extraits de code:

• Détecte automatiquement les exceptions non gérées ( exemple de code )
• Collecte des données de diagnostic telles que l'utilisation de la mémoire, les informations sur l'appareil, etc. ( exemple de code )
• Regroupe efficacement les plantages par cause première
• Vous permet de suivre les actions que l'utilisateur a effectuées avant chaque crash pour faciliter la reproduction ( exemple de code )

Si vous souhaitez voir certaines des meilleures pratiques concernant la gestion des incidents / rapports sur Android, vous pouvez consulter le code source complet de la bibliothèque de rapports de crash de Bugsnag qui est entièrement open source, n'hésitez pas à la déchirer et à l'utiliser dans vos propres applications!

Si votre application est téléchargée par d'autres personnes et se bloque sur des appareils distants, vous souhaiterez peut-être consulter une bibliothèque de rapport d'erreurs Android (référencée dans cet article SO ). Si c'est uniquement sur votre propre appareil local, vous pouvez utiliser LogCat. Même si le périphérique n'était pas connecté à une machine hôte lorsque le crash s'est produit, la connexion du périphérique et l'émission d'une commande adb logcat téléchargeront l'intégralité de l'historique de logcat (au moins dans la mesure où il est mis en mémoire tampon, ce qui est généralement un loooot de données de journal , ce n'est tout simplement pas infini). L'une ou l'autre de ces options répond-elle à votre question? Si non, pouvez-vous essayer de clarifier un peu plus ce que vous recherchez?

Les analyses Flurry vous fournissent des informations sur les plantages, le modèle matériel, la version Android et les statistiques d'utilisation des applications en direct. Dans le nouveau SDK, ils semblent fournir des informations plus détaillées sur les plantages http://www.flurry.com/flurry-crash-analytics.html .

Google a modifié le nombre de rapports d'erreur que vous obtenez réellement. Auparavant, vous ne disposiez que de rapports de bogues signalés manuellement.

Depuis la dernière conférence des développeurs et l'introduction d' Android Vitals, vous obtenez également des rapports de plantage d'utilisateurs qui ont permis de partager des données de diagnostic.

Vous verrez tous les plantages collectés à 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 plantages et les erreurs d'application ne répondant pas (ANR)

Vous pouvez le faire directement dans Android Studio. Connectez simplement votre téléphone, exécutez l'application, laissez-la planter et vous pouvez afficher la trace de pile directement dans Android Studio.