it-swarm.com.de

Wie erhalte ich von meiner Android-Anwendung Absturzdaten?

Wie kann ich Absturzdaten (mindestens Stack-Spuren) von meiner Android-Anwendung erhalten? Zumindest wenn ich an meinem eigenen Gerät arbeite, das über Kabel abgerufen wird, aber idealerweise von jeder Instanz meiner Anwendung, die auf freiem Feld läuft, damit ich es verbessern und solider machen kann.

695
pupeno

Versuchen Sie es mit der ACRA (Application Crash Report für Android) Bibliothek:

ACRA ist eine Bibliothek, mit der Android-Anwendung ihre Absturzberichte automatisch in einem GoogleDoc-Formular veröffentlichen kann. Es ist an Android-Anwendungsentwickler gerichtet, um ihnen zu helfen, Daten aus ihren Anwendungen zu erhalten, wenn sie abstürzen oder sich irrtümlich verhalten. 

Es ist einfach in Ihrer App zu installieren, hochgradig konfigurierbar und Sie müssen nicht überall ein Serverskript hosten. Berichte werden an eine Google Doc-Tabelle gesendet!

345
Kevin Gaudin

Für Beispielanwendungen und Debugging-Zwecke verwende ich eine einfache Lösung, mit der ich den Stacktrace auf die SD-Karte des Geräts schreiben und/oder auf einen Server hochladen kann. Diese Lösung wurde von Project Android-remote-stacktrace (insbesondere den Geräten für das Speichern auf dem Gerät und dem Upload auf den Server) inspiriert, und ich denke, es löst das von Soonil genannte Problem. Dies ist nicht optimal, aber es funktioniert und Sie können es verbessern, wenn Sie es in einer Produktionsanwendung verwenden möchten. Wenn Sie sich entscheiden, die Stacktraces auf den Server hochzuladen, können Sie sie mit einem PHP-Skript (index.php) anzeigen. Wenn Sie interessiert sind, finden Sie unten alle Quellen - eine Java-Klasse für Ihre Anwendung und zwei optionale PHP-Scrips für den Server, auf dem die hochgeladenen Stacktraces gehostet werden.

Anruf in einem Kontext (z. B. der Hauptaktivität)

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");
?>
287
rrainn

Sie können auch BugSense versuchen. BugSense sammelt und analysiert alle Absturzberichte und liefert aussagekräftige und visuelle Berichte. Es ist kostenlos und es ist nur eine Zeile Code, um integriert zu werden.

Haftungsausschluss: Ich bin Mitbegründer

54
PanosJee

In Android 2.2 ist es jetzt möglich, automatisch Crash-Berichte von Android Market-Anwendungen zu erhalten:

Neue Fehlerberichterstellungsfunktion für Android Market-Apps ermöglichen es Entwicklern, erhalten Absturz- und Einfrierberichte von ihre Benutzer. Die Berichte werden .__ sein. verfügbar, wenn sie sich bei ihrem Publisher-Konto.

http://developer.Android.com/sdk/Android-2.2-highlights.html

42

Es ist möglich, diese Ausnahmen mit Thread.setDefaultUncaughtExceptionHandler() zu behandeln, dies scheint jedoch mit der Methode von Android zur Behandlung von Ausnahmen zu verwechseln. Ich habe versucht, einen Handler dieser Art zu verwenden:

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");
    }
}

Trotz des erneuten Überschlags der Ausnahmen konnte ich jedoch nicht das gewünschte Verhalten feststellen, dh, die Ausnahme protokollierte, während Android die Herunterfahren der Komponente erlaubte.

24
sooniln

Ich sehe, dass die Frage zu alt ist, und hoffe, dass meine Antwort für andere hilfreich ist, die das gleiche Problem haben ...

Gib Crashlytics einen Versuch. Es gibt einen tiefen Einblick in alle Abstürze auf allen Geräten, auf denen sich Ihre Anwendung befindet, und sendet Ihnen eine Benachrichtigung per E-Mail.

19
lingareddyk

Ok, ich habe mir die mitgelieferten Samples von rrainn und Soonil angesehen und eine Lösung gefunden, die die Fehlerbehandlung nicht stört.

Ich habe den CustomExceptionHandler so geändert, dass er den ursprünglichen UncaughtExceptionHandler aus dem Thread speichert, den wir mit dem neuen verknüpfen. Am Ende der neuen "uncaughtException" - Methode rufe ich einfach die alte Funktion mit dem gespeicherten UncaughtExceptionHandler auf.

In der DefaultExceptionHandler-Klasse benötigen Sie etw. so was:

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();
  }
}

Mit dieser Änderung im Code unter http://code.google.com/p/Android-remote-stacktrace Haben Sie eine gute Arbeitsbasis, um sich vor Ort an Ihrem Webserver oder an .__ zu anmelden. SD-Karte.

19
doozy

Ich habe Crittercism für meine Android- und iOS-Apps verwendet - habe auf Techcrunch davon gehört. Ziemlich zufrieden mit ihnen bisher!

18
Julie

Die Google Play Developers Console bietet Ihnen tatsächlich die Stack-Spuren von Apps, die abgestürzt sind und die Berichte gesendet hatten. Außerdem enthält sie sehr gute Diagramme, mit denen Sie die Informationen anzeigen können. Siehe Beispiel unten:

enter image description here

18
Eefret

Ich habe hier meine eigene Version erstellt: http://androidblogger.blogspot.com/2009/12/how-to-improve-your-application-crash.html

Im Grunde ist es das Gleiche, aber ich verwende eine E-Mail-Nachricht und keine HTTP-Verbindung, um den Bericht zu senden. Wichtiger noch, ich habe meinem Bericht einige Informationen hinzugefügt, z. .

14
alocaly

verwenden Sie diese Option, um die Ausnahmedetails abzufangen:

String stackTrace = Log.getStackTraceString(exception); 

speichern Sie dies in der Datenbank und pflegen Sie das Protokoll.

11
Vicky Kapadia

Sie können auch einen ganzen (einfachen) Dienst anstelle von nur einer Bibliothek verwenden. Unser Unternehmen hat gerade einen Dienst dafür veröffentlicht: http://apphance.com

Es verfügt über eine einfache .jar-Bibliothek (für Android), die Sie in 5 Minuten hinzufügen und integrieren können. Anschließend sammelt die Bibliothek nicht nur Informationen, sondern auch Protokolle der laufenden Anwendung. Außerdem können Ihre Tester Probleme direkt vom Gerät - einschließlich der gesamter Kontext (Gerätedrehung, ob mit einem WLAN verbunden ist oder nicht und mehr). Sie können die Protokolle über ein sehr schönes und nützliches Web-Panel anzeigen, in dem Sie Sitzungen mit Ihrer Anwendung, Abstürze, Protokolle, Statistiken und mehr verfolgen können. Der Dienst befindet sich jetzt in einer geschlossenen Betatestphase, aber Sie können den Zugriff anfordern und wir geben ihn Ihnen sehr schnell.

Haftungsausschluss: Ich bin CTO von Polidea und Mitgestalter des Dienstes.

8
Jarek Potiuk

Vielen Dank an Ressourcen, die in Stackoverflow enthalten sind, um mir zu helfen, diese Antwort zu finden.

Sie können Ihre Remote-Absturzberichte für Android direkt in Ihrer E-Mail finden . remmember müssen Sie Ihre E-Mail-Adresse in die CustomExceptionHandler-Klasse einfügen .

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

Erforderliche Schritte:

1.) In onCreate Ihrer Aktivität verwenden Sie diesen Abschnitt Ihres Codes.

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

2.) Verwenden Sie diese überschriebene Version der CustomExceptionHandler-Klasse von (rrainn) gemäß meinem Skript.

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();

    }
}
7
Tushar Pandey

Dies ist sehr brutal, aber es ist möglich, logcat überall auszuführen. Ein schneller und schmutziger Hack ist das Hinzufügen zu jedem catch-Block. getRuntime().exec("logcat >> /sdcard/logcat.log"); 

5
Aleadam

Es gibt ein Tool namens Fabric. Dies ist ein Tool zur Analyse von Abstürzen, mit dem Sie Absturzberichte abrufen können, wenn eine Anwendung live bereitgestellt wird und während der Entwicklung. Das Hinzufügen dieses Tools zu Ihrer Anwendung war ebenfalls einfach Bei einem Absturz Ihrer Anwendung kann der Absturzbericht über das Dashboard von fabric.io angezeigt werden. Der Bericht wurde automatisch abgefangen. Der Benutzer wird nicht um Erlaubnis gefragt. Ob er/sie den Fehlerbericht/Absturzbericht senden möchte . Und das ist völlig kostenlos ... https://get.fabric.io/

5
HourGlass

Heutzutage sind Firebase-Absturzberichte sehr beliebt und benutzerfreundlicher. Weitere Informationen finden Sie unter folgendem Link: Firebase Crash Reporting

Hoffe es wird dir helfen.

5
Vaibhav Jadhav

Google Firebase ist die neueste (2016) Methode von Google, um Ihnen Absturz-/Fehlerdaten auf Ihrem Telefon bereitzustellen. Fügen Sie es in Ihre build.gradle -Datei ein:

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

Schwerwiegende Abstürze werden automatisch ohne Benutzereingaben protokolliert. Sie können auch nicht schwerwiegende Abstürze oder andere Ereignisse wie

try
{

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

Obwohl viele Antworten auf dieser Seite hilfreich sind, können sie leicht veraltet werden. Die AppBrain-Website fasst Statistiken zusammen, mit denen Sie die gängigste Crash-Reporting-Lösung finden können, die aktuell ist:

Android-Absturzberichterstellungsbibliotheken

 app brain website

Sie sehen, dass Crashlytics zum Zeitpunkt der Veröffentlichung dieses Bildes in 5,24% der Apps und 12,38% der Installationen verwendet wird.

4
David Rawson

Wir verwenden unser hausgemachtes System innerhalb des Unternehmens und es dient uns sehr gut. Es ist eine Android-Bibliothek, die Absturzberichte an Server und Server sendet, die Berichte empfangen und Analysen durchführen. Servergruppenausnahmen nach Ausnahmetitel, Stacktrace und Nachricht. Es hilft, die wichtigsten Probleme zu identifizieren, die behoben werden müssen .. _ Unser Service befindet sich jetzt in der öffentlichen Betaversion, sodass jeder es ausprobieren kann. Sie können ein Konto unter http://watchcat.co erstellen, oder Sie können einfach einen Blick darauf werfen, wie es funktioniert, indem Sie Demo - Zugriff http://watchcat.co/reports/index.php?demo verwenden.

4
Fedor

Es gibt diese Android-Bibliothek namens Sherlock . Sie erhalten den vollständigen Absturzbericht sowie Geräte- und Anwendungsinformationen. Wenn ein Absturz auftritt, wird eine Benachrichtigung in der Benachrichtigungsleiste angezeigt. Wenn Sie auf die Benachrichtigung klicken, werden die Absturzdetails geöffnet. Sie können Absturzdetails auch per E-Mail oder anderen Freigabeoptionen mit anderen Personen teilen.

Installation

Android {
    dataBinding {
      enabled = true
    }
}

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

Demo

 enter image description here

3
Ajit Singh

Ich habe eine weitere großartige Webanwendung gefunden, um die Fehlerberichte zu verfolgen.

https://mint.splunk.com/

Kleine Anzahl zu konfigurierender Schritte.

  1. Melden Sie sich an oder melden Sie sich an und konfigurieren Sie es über den obigen Link. Wenn Sie mit dem Erstellen einer Anwendung fertig sind, wird eine Zeile wie folgt konfiguriert.
Mint.initAndStartSession(YourActivity.this, "api_key");
  1. Fügen Sie Folgendes in der Anwendung build.gradl der Anwendung hinzu.
Android {
...
    repositories {
        maven { url "https://mint.splunk.com/gradle/"}
    }
...
}

dependencies {
...
    compile "com.splunk.mint:mint:4.4.0"
...
}
  1. Fügen Sie den Code hinzu, den wir oben kopiert haben, und fügen Sie ihn zu jeder Aktivität hinzu .

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

Das ist es. Sie melden sich an und wechseln zu Ihrem Anwendungs-Dashboard. Sie erhalten alle Fehlerberichte.

Hoffe es hilft jemandem.

3

Für einen alternativen Absturzberichts-/Ausnahmeverfolgungsdienst checkout Raygun.io - gibt es eine Menge Nice-Logik für die Abwicklung von Android-Abstürzen, einschließlich einer anständigen Benutzererfahrung, wenn Sie sie in Ihre App einbinden (zwei Codezeilen in Ihrem Hauptfenster) Aktivität und einige XML-Zeilen in AndroidManifest eingefügt).

Wenn Ihre App abstürzt, werden automatisch die Stack-Ablaufverfolgung, Umgebungsdaten für Hard-/Software, Informationen zum Benutzer-Tracking, alle von Ihnen angegebenen benutzerdefinierten Daten usw. abgerufen. Sie werden so asynchron an die API übermittelt, dass der UI-Thread nicht blockiert wird, und zwischenspeichern auf die Festplatte, wenn kein Netzwerk verfügbar ist.

Haftungsausschluss: Ich habe den Android-Anbieter gebaut :)

2
fundead

Wenn Sie sofort Antworten wünschen, können Sie logcat verwenden.

$adb Shell logcat -f /sdcard/logoutput.txt *:E

Wenn sich in Ihrem Protokoll jetzt zu viel Müll befindet, löschen Sie ihn zuerst.

$adb Shell logcat -c

Dann starten Sie Ihre App und logcat erneut. 

2
T. Webster

Ich habe gerade angefangen, ACRA https://github.com/ACRA/acra zu verwenden, indem Sie Google Forms als Backend verwenden. Es ist sehr einfach einzurichten und zu verwenden. Dies ist die Standardeinstellung.

BUT Das Senden von Berichten an Google Forms wird veraltet (und dann entfernt):https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6https://github.com/ACRA/acra/wiki/Notice-on-Google-Form-Spreadsheet-usage

Es ist jedoch auch möglich, einen eigenen Absender zu definieren https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender Sie können beispielsweise dem E-Mail-Absender den Versuch machen.

Mit minimalem Aufwand können Berichte an BugSense gesendet werden: http://www.bugsense.com/docs/Android#acra

NB Das kostenlose Bugsense-Konto ist auf 500 Berichte/Monat beschränkt

1

Ich bin einer der Gründer von Bugsnag das wir genau für diesen Zweck entworfen haben. Bugsnag erfasst automatisch unbehandelte Ausnahmen in Android-Apps und sendet sie an unser Dashboard, wo Sie Fixes priorisieren und in Diagnoseinformationen eintauchen können.

Hier sind einige wichtige Punkte zu beachten, wenn Sie ein Absturzberichtssystem auswählen oder erstellen, zusammen mit einigen Codeausschnitten:

  • Erkennt nicht behandelte Ausnahmen automatisch ( Beispielcode )
  • Sammelt Diagnosedaten wie Speichernutzung, Geräteinformationen usw. ( Beispielcode )
  • Gruppiert effektiv Abstürze nach Ursachen
  • Ermöglicht das Nachverfolgen von Aktionen, die der Benutzer vor jedem Absturz ausgeführt hat, um die Wiedergabe zu erleichtern ( Beispielcode )

Wenn Sie einige Best Practices zum Thema Crash-Handling Reporting unter Android sehen möchten, können Sie den vollständigen Quellcode der Bugsnag/- Crash-Berichtsbibliothek lesen, die vollständig Open Source ist. Zögern Sie nicht, diesen zu zerlegen und in Ihrem eigenen zu verwenden anwendungen!

1
loopj

Später zur Party unterstütze ich und glaube, dass ACRA die beste Option unter allen ist. Es ist einfach einzurichten und zu konfigurieren. Ich habe einen ausführlichen Leitfaden mit Eingaben von überall her erstellt, um den Absturzbericht mit ACRA abzurufen und diesen per MandrillAp an meine E-Mail-Adresse zu senden. 

Link zum Beitrag: https://androidician.wordpress.com/2015/03/29/sending-crash-reports-mit-acra-over-email-using-mandrill/

Link zum Beispielprojekt auf github: https://github.com/ayushhgoyal/AcraSample

1
Ayush Goyal

Sie können dies direkt in Android Studio tun. Verbinden Sie einfach Ihr Telefon, führen Sie die App aus, lassen Sie sie abstürzen, und Sie können den Stacktrace direkt in Android Studio anzeigen. 

0

Google hat geändert, wie viele Absturzberichte Sie tatsächlich erhalten. Bisher haben Sie nur manuell gemeldete Fehlerberichte erhalten.

Seit der letzten Entwicklerkonferenz und der Einführung von Android Vitals erhalten Sie außerdem Absturzberichte von Benutzern, die das Teilen von Diagnosedaten ermöglicht haben.

Sie sehen alle Abstürze von Android-Geräten, deren Benutzer sich für die automatische Freigabe von Nutzungs- und Diagnosedaten entschieden haben. Daten sind für die letzten zwei Monate verfügbar.

Abstürze anzeigen & Anwendungsfehler (ANR) reagieren nicht

0
woodii

Flurry-Analyse bietet Ihnen Absturzinformationen, Hardwaremodell, Android-Version und Nutzungsstatistiken für Live-Apps. Im neuen SDK scheinen sie detailliertere Absturzinformationen zu bieten: http://www.flurry.com/flurry-crash-analytics.html .

0
chughes

Wenn Ihre App von anderen Benutzern heruntergeladen wird und auf Remote-Geräten abstürzt, möchten Sie möglicherweise eine Android-Fehlerberichterstellungsbibliothek (in this SO post ) referenziert. Wenn es sich nur um ein lokales Gerät handelt, können Sie LogCat verwenden. Selbst wenn das Gerät zum Zeitpunkt des Absturzes nicht mit einem Host-Computer verbunden war, wurde das Gerät mit dem Befehl adb logcat verbunden, und der gesamte logcat-Verlauf wird heruntergeladen (zumindest in dem Maße, in dem er gepuffert ist, was in der Regel eine Fülle von Protokolldaten ist.) Es ist einfach nicht unendlich. Beantwortet eine dieser Optionen Ihre Frage? Wenn nicht, können Sie versuchen zu klären, wonach Sie ein bisschen mehr suchen?

0
user647826