titel Wie erhalte ich von meiner Android-Anwendung Absturzdaten?




title tag länge (24)

Wie kann ich Absturzdaten (zumindest Stack-Traces) von meiner Android-Anwendung erhalten? Zumindest wenn ich an meinem eigenen Gerät arbeite, das per Kabel zurückgeholt wird, aber idealerweise von jeder Instanz meiner Anwendung, die auf der Festplatte läuft, damit ich sie verbessern und sie solider machen kann.


Gerade begonnen, ACRA https://github.com/ACRA/acra mit Google Formulare als Backend zu verwenden und es ist sehr einfach einzurichten und zu verwenden, es ist die Standardeinstellung.

ABER das Senden von Berichten an Google Formulare wird veraltet (dann entfernt): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://github.com/ACRA/acra/wiki/Notice-on-Google-Form-Spreadsheet-usage

Wie auch immer, es ist möglich, einen eigenen Absender zu definieren https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender Sie können versuchen, den Absender zum Beispiel zu mailen.

Mit minimalem Aufwand ist es möglich, Berichte an Bugsense zu senden: http://www.bugsense.com/docs/android#acra

NB Das kostenlose bugsense-Konto ist auf 500 Berichte / Monat begrenzt


Wir nutzen unser selbst entwickeltes System innerhalb des Unternehmens und es dient uns sehr gut. Es ist eine Android-Bibliothek, die Absturzberichte an Server und Server sendet, die Berichte erhalten und einige Analysen durchführen. Server gruppiert Ausnahmen nach Ausnahmebedingung, Stacktrace, Nachricht. Es hilft, die wichtigsten Probleme zu identifizieren, die behoben werden müssen. Unser Service ist jetzt in der öffentlichen Betaversion, so dass jeder es ausprobieren kann. Sie können ein Konto bei http://watchcat.co erstellen oder Sie können einfach einen Blick darauf werfen, wie es funktioniert, indem Sie den Demo-Zugang http://watchcat.co/reports/index.php?demo .


Ich habe eine weitere tolle Webanwendung gefunden, um die Fehlerberichte zu verfolgen.

https://mint.splunk.com/

Kleine Anzahl von Schritten zum Konfigurieren.

  1. Melden Sie sich an oder registrieren Sie sich und konfigurieren Sie über den obigen Link. Sobald Sie mit dem Erstellen einer Anwendung fertig sind, wird eine Zeile wie unten beschrieben bereitgestellt.
Mint.initAndStartSession(YourActivity.this, "api_key");
  1. Fügen Sie im build.gradl der Anwendung Folgendes hinzu.
android {
...
    repositories {
        maven { url "https://mint.splunk.com/gradle/"}
    }
...
}

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

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

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

Hoffe es hilft jemandem.


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

Gib Crashlytics einen Versuch. Es gibt einen tiefen Einblick in alle Abstürze auf allen Geräten mit Ihrer Anwendung und senden Sie eine Benachrichtigung per E-Mail .. Und das Beste ist, es ist völlig kostenlos zu verwenden ..


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

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

Wenn gerade zu viel Junk in deinem Log ist, versuche es zuerst zu löschen.

$adb shell logcat -c

Versuchen Sie dann, Ihre App auszuführen und logcat erneut.


Sie können BugSense auch ausprobieren. BugSense sammelt und analysiert alle Absturzberichte und gibt Ihnen aussagekräftige und visuelle Berichte. Es ist kostenlos und es ist nur 1 Zeile Code, um zu integrieren.

Disclaimer: Ich bin Mitbegründer


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

Android Absturzberichtsbibliotheken

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


Ok, nun habe ich mir die mitgelieferten Beispiele von Rrainn und Soonil angeschaut und eine Lösung gefunden, die die Fehlerbehandlung nicht durcheinander bringt.

Ich habe den CustomExceptionHandler so modifiziert, dass er den ursprünglichen UncaughtExceptionHandler aus dem Thread speichert, mit dem wir den neuen assoziieren. 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 am Code unter http://code.google.com/p/android-remote-stacktrace Sie eine gute Arbeitsgrundlage für die Anmeldung des Feldes auf Ihrem Webserver oder auf der SD-Karte.


Vielen Dank, dass die Ressourcen in mir helfen, diese Antwort zu finden.

Sie können Ihre Android Absturzberichte direkt in Ihre E-Mail finden . Remember Sie müssen Ihre E-Mail in CustomExceptionHandler-Klasse setzen .

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

Schritte erforderlich:

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

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

2.) benutze diese überschriebene Version der CustomExceptionHandler Klasse von (rrainn), laut meinem 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();

    }
}

Es gibt ein Tool namens "Fabric", das ein Crash-Analyse-Tool ist, mit dem Sie Absturzberichte erhalten können, wenn die Anwendung live und während der Entwicklung bereitgestellt wird. Das Hinzufügen dieses Tools zu Ihrer Anwendung war ebenfalls einfach. Wenn Ihre Anwendung abstürzt, kann der Bericht über den Absturz von Ihrem fabric.io-Dashboard aus angezeigt werden. Der Bericht wurde automatisch abgerufen. Er fragt den Benutzer nicht nach der Berechtigung. Ob er / sie den Fehler / Absturzbericht senden möchte. Und das ist völlig kostenlos ... https://get.fabric.io/


Es ist möglich, diese Ausnahmen mit Thread.setDefaultUncaughtExceptionHandler() , jedoch scheint dies die Android-Methode zur Behandlung von Ausnahmen zu Thread.setDefaultUncaughtExceptionHandler() . 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");
    }
}

Aber selbst mit dem erneuten Auslösen der Ausnahmen konnte ich nicht das gewünschte Verhalten erzielen, dh die Ausnahme protokollieren, während Android weiterhin die heruntergefahrene Komponente herunterfahren konnte, so dass ich nach einer Weile aufgab.


Ich bin einer der Gründer von Bugsnag die 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 Dinge zu beachten, wenn Sie ein Crash-Reporting-System zusammen mit einigen Code-Schnipsel auswählen oder erstellen:

  • Erkennt unbehandelte Ausnahmen automatisch ( Beispielcode )
  • Erfasst Diagnosedaten wie Speichernutzung, Geräteinfo usw. ( Beispielcode )
  • Effektiv stürzen Gruppen durch Grundursache zusammen
  • Ermöglicht die Verfolgung von Aktionen, die der Benutzer vor jedem Absturz ausgeführt hat, um die Reproduktion zu unterstützen ( Beispielcode )

Wenn Sie einige Best Practices rund um das Thema Crash-Handling / -Reporting auf Android sehen möchten, können Sie den vollständigen Quellcode für die Crash-Reporting-Bibliothek von Bugsnag lesen, die vollständig Open Source ist. Zögern Sie nicht, diese auseinander zu nehmen und in Ihren eigenen Anwendungen zu verwenden!


Jetzt sind einige Tage Firebase Crash-Berichte sehr beliebt und einfacher zu verwenden. Weitere Informationen finden Sie unter folgendem Link: Firebase Crash Reporting

Hoffe es wird dir helfen.



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

Es ist im Grunde das Gleiche, aber ich verwende eine E-Mail anstelle einer http-Verbindung, um den Bericht zu senden, und, was noch wichtiger ist, habe ich meinem Bericht einige Informationen wie Anwendungsversion, Betriebssystemversion, Telefonmodell oder verfügbares Gedächtnis hinzugefügt. .


Ich benutze Crittercism für meine Android- und iOS-Apps - habe sie auf techcrunch gehört. Ziemlich glücklich mit ihnen so weit!


Wenn Ihre App von anderen Personen heruntergeladen wird und auf Remote-Geräten abstürzt, können Sie in eine Android-Fehlerberichtsbibliothek (in diesem SO-Post verwiesen) suchen. Wenn es nur auf Ihrem eigenen lokalen Gerät ist, können Sie LogCat verwenden. Selbst wenn das Gerät im Falle eines Absturzes nicht mit einem Host-Computer verbunden war, wird das Gerät mit einem adb logcat-Befehl verbunden, der den gesamten Logcat-Verlauf herunterlädt (zumindest in dem Umfang, in dem er gepuffert ist, normalerweise ein großer Teil der Protokolldaten) , es ist einfach nicht unendlich). Beantwortet eine dieser Optionen Ihre Frage? Wenn nicht, können Sie versuchen zu klären, wonach Sie suchen?


Google Play Developers Console bietet Ihnen die Stack-Traces von den Apps, die abgestürzt sind und die Berichte gesendet haben, und es gibt auch sehr gute Diagramme, die Ihnen helfen, die Informationen zu sehen, siehe Beispiel unten:


Für einen alternativen Absturz-Reporting / Exception-Tracking-Service, Raygun.io Sie sich Raygun.io - es hat eine Menge an Logik für die Behandlung von Android-Abstürzen, einschließlich anständiger Benutzerfreundlichkeit beim Einstecken in Ihre App (zwei Zeilen Code in Ihrer Hauptaktivität und ein paar XML-Zeilen, die in AndroidManifest eingefügt wurden).

Wenn Ihre App abstürzt, erfasst sie automatisch den Stack-Trace, Umgebungsdaten für Hard- / Software, Benutzer-Tracking-Informationen, benutzerdefinierte Daten usw. Sie wird asynchron an die API gesendet, sodass der UI-Thread nicht blockiert und zwischengespeichert wird auf die Festplatte, wenn kein Netzwerk verfügbar ist.

Disclaimer: Ich habe den Android-Anbieter gebaut :)


Spät zur Party unterstütze ich und glaube, dass ACRA die beste Wahl unter allen ist. Es ist einfach einzurichten und zu konfigurieren. Ich habe eine detaillierte Anleitung mit Eingaben von überall her erstellt, um den Absturzbericht mithilfe von ACRA abzurufen und ihn mit MandrillAp an meine E-Mail-Adresse zu senden.

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

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


Für Beispielanwendungen und Debuggingzwecke verwende ich eine einfache Lösung, die es mir ermöglicht, den Stacktrace auf die SD-Karte des Geräts zu schreiben und / oder auf einen Server hochzuladen. Diese Lösung wurde von Project android-remote-stacktrace inspiriert (speziell die Komponenten "save-to-device" und "upload-to-server") und ich denke, es löst das von So- son erwähnte Problem. Es ist nicht optimal, aber es funktioniert und Sie können es verbessern, wenn Sie es in einer Produktionsanwendung verwenden möchten. Wenn Sie sich dazu entschließen, die Stacktraces auf den Server hochzuladen, können Sie sie mit einem PHP-Skript ( index.php ) anzeigen. Wenn Sie interessiert sind, können Sie alle unten stehenden Quellen finden - eine Java-Klasse für Ihre Anwendung und zwei optionale PHP-Skripte für den Server, der die hochgeladenen Stacktraces hostet.

Rufen Sie in einem Kontext (z. B. die Hauptaktivität) auf

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

Es gibt diese Android-Bibliothek namens Sherlock . Sie erhalten den vollständigen Absturzbericht mit Informationen zu Geräten und Anwendungen. Immer wenn ein Absturz auftritt, wird eine Benachrichtigung in der Benachrichtigungsleiste angezeigt und beim Klicken auf die Benachrichtigung werden die Absturzdetails geöffnet. Sie können auch Absturzdetails mit anderen über E-Mail oder andere Freigabeoptionen teilen.

Installation

android {
    dataBinding {
      enabled = true
    }
}

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

Demo


Sie können auch einen ganzen (einfachen) Service dafür verwenden und nicht nur die Bibliothek. Unsere Firma hat gerade einen Service nur dafür veröffentlicht: http://apphance.com .

Es hat eine einfache .jar-Bibliothek (für Android), die Sie in 5 Minuten hinzufügen und integrieren und dann sammelt die Bibliothek nicht nur Informationen zum Absturz, sondern auch Protokolle von laufenden Anwendungen, und Ihre Tester können Probleme direkt vom Gerät aus melden Gesamter Kontext (Geräte-Rotation, ob es mit einem WLAN verbunden ist oder nicht und mehr). Sie können die Protokolle mit einem sehr schönen und nützlichen Web-Panel ansehen, wo Sie Sitzungen mit Ihrer Anwendung verfolgen können, Abstürze, Logs, Statistiken und mehr. Der Dienst befindet sich jetzt in der Phase der abgeschlossenen Beta-Tests, aber Sie können Zugriff anfordern, und wir geben ihn Ihnen sehr schnell.

Haftungsausschluss: Ich bin CTO von Polidea und Co-Creator des Dienstes.


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

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

Fatale Abstürze werden automatisch protokolliert, ohne dass Benutzereingaben erforderlich sind, und Sie können auch nicht-tödliche Abstürze oder andere Ereignisse protokollieren:

try
{

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






stack-trace