repond - mes applications ne s'ouvrent plus android




Comment puis-je obtenir des données de crash à partir de mon application Android? (20)

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 génération de rapports sur les collisions la plus populaire actuellement:

Bibliothèques de rapports de plantage Android

Vous pouvez voir qu'au moment de poster cette image, Crashlytics est utilisé dans 5,24% des applications et 12,38% des installations.

Comment puis-je obtenir des données d'accident (traces de pile au moins) de mon application Android? Au moins lorsque 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 fonctionnant sur la nature afin que je puisse l'améliorer et le rendre plus solide.


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 catch getRuntime().exec("logcat >> /sdcard/logcat.log");


Dans Android 2.2, il est désormais possible d'obtenir automatiquement des rapports d'erreur à partir des applications Android Market:

La nouvelle fonction de rapport de bogue pour les applications Android Market permet aux développeurs de recevoir des rapports de blocage et de blocage 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


En retard à la fête, je soutiens et je crois que ACRA est la meilleure option parmi toutes. C'est facile à configurer 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 e-mail 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 un exemple de projet sur github: https://github.com/ayushhgoyal/AcraSample


Google a modifié le nombre de rapports d'erreur réellement obtenus. Auparavant, vous n'aviez que des rapports de bogues rapportés manuellement.

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

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


Il est possible de gérer ces exceptions avec Thread.setDefaultUncaughtExceptionHandler() , mais cela semble Thread.setDefaultUncaughtExceptionHandler() 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 avec la reprise des exceptions, je n'ai pas réussi à obtenir le comportement souhaité, c'est-à-dire consigner l'exception tout en permettant à Android d'éteindre le composant qui lui était arrivé, j'ai donc abandonné après un certain temps.


Il y a cette bibliothèque android appelée Sherlock . Il vous donne le rapport complet de l'accident avec les informations sur l'appareil et l'application. Chaque fois qu'un accident 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 d'un accident avec d'autres personnes par courrier électronique ou via d'autres options de partage.

Installation

android {
    dataBinding {
      enabled = true
    }
}

compile('com.github.ajitsing:sherlock:[email protected]') {
    transitive = true
}

Démo



J'ai utilisé Crittercism pour mes applications Android et iOS - entendu parler d'eux sur techcrunch. Assez content avec eux jusqu'à présent!


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 génération de rapports de plantage, 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 )
  • Grouper efficacement les accidents ensemble par cause racine
  • Vous permet de suivre les actions que l'utilisateur a prises avant chaque crash pour vous aider à reproduire ( exemple de code )

Si vous voulez voir quelques bonnes pratiques concernant la gestion des crashs / ​​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émonter et à l'utiliser dans vos propres applications!


Maintenant, les rapports Firebase Crash sont très populaires et faciles à utiliser. Veuillez vous référer au lien suivant pour plus d'informations: Firebase Crash Reporting

J'espère que cela vous aidera.


Merci ressources présentes dans pour m'aider à trouver cette réponse.

Vous pouvez trouver vos rapports de crash Android à distance directement dans votre email . Rappelez-vous que vous devez mettre votre email dans la classe CustomExceptionHandler .

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

Étapes requises:

1er) dans surCréer votre activité, utilisez cette section de votre code.

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

2ème) utiliser cette version substituée de la classe CustomExceptionHandler de (rrainn), d'après 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();

    }
}

Ok, 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 du Thread auquel nous associons le nouveau. A la fin de la nouvelle méthode "uncaughtException", j'appelle simplement l'ancienne fonction en utilisant le fichier 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' http://code.google.com/p/android-remote-stacktrace vous disposez d'une bonne base de travail pour vous connecter au serveur Web ou à la carte SD.


Pour un autre service de génération de rapports d'accident / suivi d'exception, consultez Raygun.io - il a une bonne logique de gestion des plantages Android, y compris une expérience utilisateur décente lorsque vous le connectez à votre application (deux lignes de code dans votre activité principale et quelques lignes de XML collées dans AndroidManifest).

Lorsque votre application tombe en panne, elle saisit automatiquement la trace de pile, les données d'environnement pour le disque dur / logiciel, les informations de suivi utilisateur, les données personnalisées que vous spécifiez, etc. Elle les stocke dans l'API de manière asynchrone. 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 courrier indésirable dans votre journal, essayez d'abord de le supprimer.

$adb shell logcat -c

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


Vous pouvez également essayer BugSense . BugSense recueille et analyse tous les rapports d'erreur et vous donne des rapports significatifs et visuels. C'est gratuit et c'est seulement 1 ligne de code pour s'intégrer.

Disclaimer: Je suis un co-fondateur


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 d'erreur dans un formulaire GoogleDoc. Il est destiné aux développeurs d'applications Android pour les aider à obtenir des données de leurs applications lorsqu'ils se plantent 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!


Vous pouvez le faire directement dans Android Studio. Il suffit de connecter votre téléphone, lancer l'application, le laisser tomber et vous pouvez voir la pile directement dans Android Studio.



Google Firebase est le dernier moyen (2016) de Google pour vous fournir des données d'erreur / d'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 de saisie utilisateur et vous pouvez également enregistrer des plantages non fatals ou d'autres événements comme:

try
{

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




stack-trace