Wie deaktiviere ich Firebase Crash Reporting, wenn die App beim Debuggen ausgeführt wird?

Ich habe Firebase Crash Reporting erfolgreich implementiert, muss den Dienst jedoch deaktivieren, wenn die App ausgeführt wird, und die Build-Variante "Debuggen" rückgängig machen, um nicht echte Abstürze in der Konsole während der Entwicklung zu vermeiden.

Die offizielle Dokumentation sagt nichts darüber aus.

AKTUALISIERT: Mit Google Play Services / Firebase 11+ können Sie jetzt die Absturzberichterstattung zur Laufzeit deaktivieren. FirebaseCrash.setCrashCollectionEnabled()(Danke @ Tyler Carberry )

ALTE ANTWORT:

Es gibt keine offizielle Unterstützung dafür, soweit die Community dies vermuten konnte. Der beste Weg, dies zu tun, besteht darin, mehrere Firebase-Apps in Ihrem Dashboard einzurichten, eine für jeden Build-Typ, und mehrere google_services.json-Dateien einzurichten, die je nach Build-Variante zu jeder unterschiedlichen App geleitet werden.

Mit Google Play Services 11.0 können Sie jetzt die Absturzberichterstattung zur Laufzeit deaktivieren.

FirebaseCrash.setCrashCollectionEnabled(!BuildConfig.DEBUG);

Kürzlich wurde die Möglichkeit eingeführt, die Firebase-Absturzberichterstattung auf offizielle Weise zu deaktivieren. Sie müssen die Firebase Android SDK auf mindestens Version 11.0.0 aktualisieren

Dazu müssen Sie Ihre bearbeiten AndroidManifest.xmlund hinzufügen:

<meta-data
   android:name="firebase_crashlytics_collection_enabled"
   android:value="false" />

Im <application>Block.

Mit FirebaseCrash.isCrashCollectionEnabled () können Sie überprüfen, ob der Firebase-Absturzbericht zur Laufzeit aktiviert ist .

Unten finden Sie ein vollständiges Beispiel zum Deaktivieren der Firebase-Absturzberichterstattung in Ihren Debug-Builds.

build.gradle :

...
 buildTypes {

    release {
        ...
        resValue("bool", "FIREBASE_CRASH_ENABLED", "true")
    }

    debug {
        ...
        resValue("bool", "FIREBASE_CRASH_ENABLED", "false")

    }

}
...
dependencies {
    ...
    compile "com.google.firebase:firebase-core:11.0.0"
    compile "com.google.firebase:firebase-crash:11.0.0"
    ...
}

AndroidManifest.xml :

 <application>

    <meta-data
        android:name="firebase_crash_collection_enabled"
        android:value="@bool/FIREBASE_CRASH_ENABLED"/>
...

in meiner Anwendungsklasse onCreate ()

if (BuildConfig.DEBUG) {
    Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
        @Override
        public void uncaughtException(Thread paramThread, Throwable paramThrowable) {
            Log.wtf("Alert", paramThrowable.getMessage(), paramThrowable);
            System.exit(2); //Prevents the service/app from freezing
        }
    });
}

Es funktioniert, weil es den alten Handler braucht, der den Firebase enthält

 final UncaughtExceptionHandler oldHandler = Thread.getDefaultUncaughtExceptionHandler();

aus dem Verarbeitungspfad

Sie können die Firebase-Crash-Abhängigkeit in eine Release-Abhängigkeit ändern.

Dazu definieren Sie es als releaseCompile-Abhängigkeit

releaseCompile 'com.google.firebase:firebase-crash:9.4.0'

Jetzt wird es nur noch in den Release-Builds enthalten sein. Wenn Sie andere benutzerdefinierte Build-Typen haben, für die Sie Absturzberichte erstellen möchten, können Sie diese hinzufügen.

customBuildTypeCompile 'com.google.firebase:firebase-crash:9.4.0'

Der einfache Trick, den ich verwendet habe, besteht darin, die Abhängigkeit von Firebase-Absturzberichten in Release-Builds nur in build.gradleDateien hinzuzufügen .

Dadurch wird die Crash-Reporting-Bibliothek aus dem Debug-Build-Typ entfernt und nur im Release-Build hinzugefügt.

dependencies {
    releaseCompile 'com.google.firebase:firebase-crash:10.2.0'
}

Inspiriert von dieser verwandten Antwort und anderen hier, habe ich diese praktische Lösung gefunden.

Mit Timber für die Protokollierung habe ich verschiedene Implementierungen einer Tree-Unterklasse für Debug- und Release-Builds erstellt. Beim Debuggen wird auf DebugTree verschoben, das in logcat schreibt. In der Version werden Ausnahmen und Protokolle mit hoher Priorität an Firebase weitergeleitet, der Rest wird gelöscht.

build.gradle

dependencies {
  ...
  compile 'com.jakewharton.timber:timber:4.3.0'
  releaseCompile 'com.google.firebase:firebase-crash:9.0.2'
}

src / debug / java / [package] /ForestFire.java

import timber.log.Timber;

public class ForestFire extends Timber.DebugTree {}

src / release / java / [package] /ForestFire.java

import android.util.Log;
import com.google.firebase.crash.FirebaseCrash;
import timber.log.Timber;

public class ForestFire extends Timber.Tree {
  @Override
  protected void log(int priority, String tag, String message, Throwable t) {
    if (Log.WARN <= priority) {
      FirebaseCrash.log(message);
      if (t != null) {
        FirebaseCrash.report(t);
      }
    }
  }
}

App-Start

Timber.plant(new ForestFire());

Initialisieren Sie zuerst die Variablen in der Gradle-Datei und prüfen Sie, ob sie sich im Debug- oder im Release-Modus befinden. Der Absturzbericht kann am besten in der Anwendungsklasse eingereicht werden.

Build.gradle

    buildTypes {
         release {
             buildConfigField "Boolean", "REPORT_CRASH", '"true"'
             debuggable false
         }
         debug {
             buildConfigField "Boolean", "REPORT_CRASH", '"false"'
             debuggable true
         }
    }

Überprüfen Sie nun zuerst den Modus und senden Sie den Absturzbericht, falls er abgestürzt ist.

Application.java

    /** Report FirebaseCrash Exception if application crashed*/
    Thread.setDefaultUncaughtExceptionHandler (new Thread.UncaughtExceptionHandler()
    {
        @Override
        public void uncaughtException (Thread thread, Throwable e)
        {
            /** Check whether it is development or release mode*/
            if(BuildConfig.REPORT_CRASH)
            {
                FirebaseCrash.report( e);
            }
        }
    });

Derzeit können Sie die Firebase-Absturzberichterstattung nicht deaktivieren, obwohl Sie die Firebase-Analyse deaktivieren können.

Eine Möglichkeit, dies zu tun, besteht darin, eine andere App mit einer anderen ID innerhalb desselben Firebase-Projekts zu erstellen. Danach müssen Sie nur noch die AppID ändern, um die Firebase-Absturzberichterstattung zu aktivieren oder zu deaktivieren. Ich habe unten zwei Apps für meine Bequemlichkeit erstellt:

AppID: com.android - Für den Release-Build-Typ

AppID: com.android.debug - Für den Debug-Build-Typ

Bitte folgen Sie dem Link unten für weitere Details:

https://firebase.googleblog.com/2016/08/organizing-your-firebase-enabled-android-app-builds.html

Bearbeiten: Sie müssen die AppID im Android-Projekt nicht immer wieder ändern. Es gibt eine bessere Möglichkeit, unterschiedliche AppIDs für den Debug-Build-Typ zu verwenden.

android {
    defaultConfig {
        applicationId "com.android"
        ...
    }
    buildTypes {
        debug {
            applicationIdSuffix ".debug"
        }
    }
}

Überprüfen Sie den Link für weitere Details:

https://developer.android.com/studio/build/application-id.html

Edit2:

Grundsätzlich erstellen Sie in der obigen Lösung zwei verschiedene Apps im Firebase-Projekt. Auf diese Weise können Sie Ihre Entwicklungs- und Produktionsfehler trennen.

FYI Firebase-Absturzberichte sind veraltet. Sie sollten Fabrics Crashlytics (im Besitz von Google) verwenden. Es hat einige wirklich coole Funktionen.

Für den FirebaseAnalyticsUnterricht.
Sammlung setAnalyticsCollectionEnabled(false);
deaktivieren: Sammlung aktivieren: setAnalyticsCollectionEnabled(true); oder AndroidManifest.xmlin das Anwendungs-Tag schreiben :<meta-data android:name="firebase_analytics_collection_enabled" android:value="false" />

Mögliche Verwendung:

if (BuildConfig.DEBUG){ //disable for debug
    mFirebaseAnalytics.setAnalyticsCollectionEnabled(false);
}

Quelle

Zuerst müssen Sie Varianten erstellen debugund releaseerstellen und dann eine Variable mit einem booleschen Wert festlegen. Dann müssen Sie diesen Wert aus Ihrer Java-Datei abrufen, die sich erweitert, applicationdh von wo aus Sie die FabricAbsturzberichterstattung aktivieren .

Ein Codebeispiel ist unten angegeben.

In Ihrem App - build.gradleDatei fügen Sie die folgenden Zeilen 2 Build - Varianten zu erstellen debugund releasedann eine Variable mit boolean Wert hinzuzufügen.

defaultConfig {
    buildConfigField 'boolean', 'ENABLE_ANALYTICS', 'true'
}

buildTypes {
    debug {
        applicationIdSuffix ".debug"
        versionNameSuffix 'DEBUG'
        buildConfigField 'boolean', 'ENABLE_ANALYTICS', 'false'
    }
    release {
        minifyEnabled false
    }
}

Wenn Sie dann versuchen, Absturzberichte hinzuzufügen Fabric, überprüfen Sie den Wert fürENABLE_ANALYTICS

Test der öffentlichen Klasse erweitert Anwendung {

private GoogleAnalytics googleAnalytics;
private static Tracker tracker;

@Override
public void onCreate() {
    super.onCreate();
    if (BuildConfig.ENABLE_ANALYTICS)
        Fabric.with(this, new Crashlytics());
    }
}

Sie können den Wert für ENABLE_ANALYTICSdurch ctrl+ Klicken auf den Wert sehen. Hoffe das hilft.

Die einfachste Lösung für Benutzer, wenn sie die App im Debug- Modus oder im Release- Modus ausführen :

AndroidManifest.xml:

<meta-data
            android:name="firebase_crash_collection_enabled"
            android:value="${analytics_deactivated}"/>

build.gradle (Modul: App)

buildTypes {

        debug {
            manifestPlaceholders = [analytics_deactivated: "false"]
        }

        release {
            manifestPlaceholders = [analytics_deactivated: "true"]

        }
    }

Wenn sich die App im Release- Modus befindet, werden die Crashlatics aktiviert und die App wird im Debug- Modus ausgeführt. Sie wird dann deaktiviert .

Ich benutze versionCodeals Filter für lokale / Produktions-Builds.

gradle.properties

VERSION_CODE=1

app / build.gradle

android {
    defaultConfig {
        versionCode VERSION_CODE as int
    }
}

Wenn Sie eine neue Version der App veröffentlichen, legen Sie einfach einen neuen Wert über die Befehlszeile fest:

./gradlew build -PVERSION_CODE=new_value

Andernfalls erhalten Sie beim Erstellen von Android Studio immer das Gleiche versionCode, sodass Sie Absturzberichte in der Firebase-Konsole leicht unterscheiden können.

Wie bereits gesagt, gibt es keinen offiziellen Weg, dies zu tun. Die schlechteste Problemumgehung für mich, wie bei @ mark-d erwähnt, ist das Zurücksetzen DefaultUncaughtExceptionHandler( https://stackoverflow.com/a/39322734/4245651 ).

Wenn Sie jedoch nur System.exit(2)wie vorgeschlagen anrufen , wird die App in Ausnahmefällen sofort geschlossen, ohne dass eine Dialogmeldung angezeigt wird und Debug-Protokolle nur schwer abgerufen werden können. Wenn dies für Sie wichtig ist, gibt es eine Möglichkeit, den Standardhandler wiederherzustellen:

if (BuildConfig.DEBUG) {
        final Thread.UncaughtExceptionHandler currentHandler = Thread.getDefaultUncaughtExceptionHandler();
        if (currentHandler.getClass().getPackage().getName()
                                                .startsWith("com.google.firebase")) {
            final Thread.UncaughtExceptionHandler defaultHandler = 
                getPrivateFieldByType(currentHandler, Thread.UncaughtExceptionHandler.class);
            Thread.setDefaultUncaughtExceptionHandler(defaultHandler);
        }
}

Wo

public static <T> T getPrivateFieldByType(Object obj, Class<T> fieldType) {
    if (obj != null && fieldType != null) {
        for (Field field : obj.getClass().getDeclaredFields()) {
            if (field.getType().isAssignableFrom(fieldType)) {
                boolean accessible = field.isAccessible();
                if (!accessible) field.setAccessible(true);
                T value = null;
                try {
                    //noinspection unchecked
                    value = (T) field.get(obj);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                if (!accessible) field.setAccessible(false);
                return value;
            }
        }
    }
    return null;
}

public class MyApp extends Application {
    public static boolean isDebuggable;

    public void onCreate() {
        super.onCreate();
        isDebuggable = (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE));
        FirebaseCrash.setCrashCollectionEnabled(!isDebuggable);
    }
}