So deaktivieren Sie Crashlytics während der Entwicklung

Gibt es eine einfache Möglichkeit, das Crashlytics Android SDK während der Entwicklung auszuschalten?

Ich möchte nicht, dass es jedes Mal zum Absturz kommt, wenn ich etwas Dummes tue

Andererseits möchte ich nicht kommentieren Crashlytics.start()und riskiere möglicherweise zu vergessen, es zu kommentieren und zu verpflichten

Marc von Crashlytics hier. Hier sind einige Möglichkeiten, um Crashlytics zu deaktivieren, während Sie Ihre Debug-Builds ausführen!

1. Verwenden Sie ein anderes Android: versionString für Debug- und Release-Builds und deaktivieren Sie dann die Crash-Berichterstellung über das Crashlytics-Web-Dashboard für die Debug-Version.

2. Schließen Sie den Aufruf von Crashlytics.start () in eine if-Anweisung ein, die ein Debug-Flag überprüft. Sie können entweder ein benutzerdefiniertes Flag oder einen Ansatz wie den hier vorgeschlagenen verwenden: Wie kann überprüft werden, ob APK signiert ist oder "Build debuggen"?

Ich habe die Lösung von Crashlytics gefunden (mit Fabric-Integration)

Fügen Sie den folgenden Code in Ihre Anwendungsklasse ein onCreate()

Crashlytics crashlytics = new Crashlytics.Builder().disabled(BuildConfig.DEBUG).build();
Fabric.with(this, crashlytics);

BEARBEITEN:

In Crashalitics 2.3 und höher ist dies veraltet. Der richtige Code lautet:

CrashlyticsCore core = new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build();
Fabric.with(this, new Crashlytics.Builder().core(core).build());

oder

Fabric.with(this, new Crashlytics.Builder().core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()).build());

(kopiert von Crashlytics veraltete Methode deaktiviert () )

EDIT2:

Optional können Sie dies auch zu Ihrem buildTypeGradle hinzufügen. Dieser Befehl deaktiviert das Senden der Crashlytics-Zuordnungsdatei und das Generieren einer ID für jeden Build, wodurch Gradle-Builds dieser Varianten beschleunigt werden. (Crashlytics wird zur Laufzeit nicht deaktiviert.) Die Antwort von Mike B finden Sie hier.

buildTypes {
    release {
           ....
    }
    debug {
        ext.enableCrashlytics = false
    }
}

Die gewählte Antwort ist nicht mehr richtig. Google hat die Integration von Crashlytics geändert. Meine aktuelle Version ist 2.9.1und das einzige, was ich tun musste, war, sie implementation 'com.crashlytics.sdk.android:crashlytics:2.9.1'zu meiner Gradle-Datei hinzuzufügen . Keine weiteren Dinge erforderlich, schön, aber das bedeutet, dass Crashlytics immer läuft.

Lösung 1

Kompilieren Sie Crashlytics nur in der Release-Version:

dependencies {
   ...
   releaseImplementation 'com.crashlytics.sdk.android:crashlytics:2.9.1' // update version
}

Lösung 2

Wenn Sie Crashlytics zusätzlich konfigurieren möchten, funktioniert Lösung 1 nicht, da die Crashlytics-Klassen in Debug-Builds nicht gefunden werden. Ändern Sie die Gradle-Implementierung wieder in:

implementation 'com.crashlytics.sdk.android:crashlytics:2.9.1' // update version

Gehen Sie dann zu Ihrem Manifest und fügen Sie das folgende meta-dataTag in das applicationTag ein:

<application
        android:name="...>

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

...

</application>

Zu Ihrer Startaktivität hinzufügen (nur einmal erforderlich, nicht jede Aktivität)

if (!BuildConfig.DEBUG) { // only enable bug tracking in release version
   Fabric.with(this, new Crashlytics());
}

Dies aktiviert Crashlytics nur in Release-Versionen. Seien Sie vorsichtig, suchen Sie auch nach BuildConfig.DEBUG, wenn Sie dann Crashlytics konfigurieren, z.

if (!BuildConfig.DEBUG) {
   Crashlytics.setUserIdentifier("HASH_ID");
}

Wenn Sie Gradle verwenden, fügen Sie dies einfach einem Geschmack hinzu:

ext.enableCrashlytics = false

Schauen Sie sich das neueste Dokument an. https://docs.fabric.io/android/crashlytics/build-tools.html#gradle-advanced-setup .

Abgesehen vom Hinzufügen ext.enableCrashlytics = falsevon build.grade müssen Sie Folgendes tun:

Crashlytics crashlyticsKit = new Crashlytics.Builder()
    .core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build())
    .build();

// Initialize Fabric with the debug-disabled crashlytics.
Fabric.with(this, crashlyticsKit);

Ich fand dies die die einfachste Lösung sein:

    release {
        ...
        buildConfigField 'Boolean', 'enableCrashlytics', 'true'
    }
    debug {
        buildConfigField 'Boolean', 'enableCrashlytics', 'false'
    }

In den obigen Zeilen wird ein statisches boolesches Feld erstellt, das enableCrashlyticsin der BuildConfigDatei aufgerufen wird und anhand dessen Sie entscheiden können, ob Sie initiieren möchten Fabricoder nicht:

    if (BuildConfig.enableCrashlytics)
        Fabric.with(this, new Crashlytics());

HINWEIS: Bei dieser Methode wird Fabrics nur in Release-Builds initialisiert (wie im obigen Code angegeben). Dies bedeutet, dass Sie statische Methoden in der CrashlyticsKlasse in einem ifBlock aufrufen müssen, der prüft, ob Fabrics wie unten gezeigt initialisiert wurde.

if (Fabric.isInitialized())
    Crashlytics.logException(e);

Andernfalls stürzt die App Must Initialize Fabric before using singleton()beim Testen auf dem Emulator mit einem Fehler ab.

2019 Antwort

Ich habe versucht, Crashlytics nur in der Version zu aktivieren und im Debug für 2 Stunden zu deaktivieren. Dabei habe ich in der Firebase-Konsole überprüft, ob die Ausnahmen hochgeladen wurden oder nicht.

Es gibt zwei Möglichkeiten, dies zu tun.

OPTION 1

Es funktioniert, aber wenn Sie Crashlyticsbeim Debuggen eine Methode aufrufen, stürzt die App ab .

app / build.gradle

android {
    buildTypes {
        release {
            manifestPlaceholders = [crashlyticsEnabled: true]
        }
        debug {
            manifestPlaceholders = [crashlyticsEnabled: false]
        }

AndroidManifest.xml

<manifest
    <application
        <meta-data
            android:name="firebase_crashlytics_collection_enabled"
            android:value="${crashlyticsEnabled}" />

OPTION 2

Eine Alternative, wenn Sie damit CrashlyticsMethoden aufrufen können, ohne BuildConfig.DEBUGvorher zu prüfen . Mit diesem Setup können Sie sicher Methoden aufrufen wie Crashlytics.logException()- sie tun einfach nichts in Debug-Builds. Ich sehe nicht, dass die Berichte beim Debuggen hochgeladen werden.

app / build.gradle

android {
    buildTypes {
        release {
            ext.enableCrashlytics = true
        }
        release {
            ext.enableCrashlytics = false
        }

AndroidManifest.xml

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

Anwendung onCreate ()

val crashlytics = Crashlytics.Builder()
    .core(CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build())
    .build()
Fabric.with(this, crashlytics)

Verwenden Sie dies in MyApplication#onCreate()

if (!BuildConfig.DEBUG) Crashlytics.start(this);

BEARBEITEN Wenn Sie ein Upgrade auf Fabric durchgeführt haben, verwenden Sie stattdessen diese Antwort .

Verwenden Sie laut Google diesen Code, um Crashlytics zu deaktivieren, und es wird auch der Erstellungsprozess verbessert.

Referenz- https://developer.android.com/studio/build/optimize-your-build

Eine weitere einfache Lösung, die mir gefällt, da keine anderen Manifestdateien erforderlich sind:

Schritt 1 - Definieren Sie manifestierte Platzhalter in build.gradle

android {
    ...
    buildTypes {
        release {
            manifestPlaceholders = [crashlytics:"true"]
        }
        debug {
            manifestPlaceholders = [crashlytics:"false"]
        }
    }
    ...
}

Schritt 2 - Verwenden Sie sie in Ihrer AndroidManifest.xml

<meta-data
        android:name="firebase_crashlytics_collection_enabled"
        android:value="${crashlytics}" />

Beachten Sie, dass Sie auch das lästige Hochladen von Symbolen im Debug-Build deaktivieren können:

def crashlyticsUploadStoredDeobsDebug = "crashlyticsUploadStoredDeobsDebug"
def crashlyticsUploadDeobsDebug = "crashlyticsUploadDeobsDebug"
tasks.whenTaskAdded { task ->
    if (crashlyticsUploadStoredDeobsDebug.equals(task.name) ||
            crashlyticsUploadDeobsDebug.equals(task.name)) {

        println "Disabling $task.name."
        task.enabled = false
    }
}

Legen Sie es einfach in das build.gradleAnwendungsmodul ein.

Wenn Sie alle Abstürze erfassen möchten (für Debug- und Release-Builds), diese jedoch im Crashlytics-Dashboard trennen möchten, können Sie build.gradle diese Codezeile hinzufügen:

debug {
    versionNameSuffix "-DEBUG"
}

Wenn der Versionsname Ihrer App beispielsweise 1.0.0 lautet, werden Ihre Release-Builds mit 1.0.0 gekennzeichnet, während die Debug-Builds 1.0.0-DEBUG lauten

Hier gibt es viele gute Antworten, aber für meine Tests verwende ich Debug-Builds für interne Betas und Tests außerhalb des Labors, bei denen Absturzprotokolle immer noch sehr nützlich sind und ich sie weiterhin melden möchte. Wie beim OP wollte ich sie nur während der aktiven Entwicklung deaktivieren, wo ich häufig Abstürze verursache und schnell behebe.

Anstatt ALLE Debug-Abstürze zu entfernen, können Sie die Berichte nur deaktivieren, während ein Gerät mit dem folgenden Code mit Ihrem Entwicklungscomputer verbunden ist.

if (!Debug.isDebuggerConnected()) {
    Fabric.with(this, new Crashlytics());
}

Das Problem ist, dass keine der Lösungen für das neueste Crashlytics SDK funktioniert. (Ich benutze 2.9.0)

Sie können es nicht per Code deaktivieren, da es in Ihr Projekt kompiliert und bereits vor einem Aufruf von onCreate Ihrer Anwendung ausgeführt wird. Eine andere Lösung ist also einfach: Kompilieren Sie keine Crashlytics, wenn sie nicht benötigt werden. Ersetzen Sie den Aufruf 'compile' durch 'releaseCompile' in der Datei build.gradle.

 releaseCompile('com.crashlytics.sdk.android:crashlytics:2.9.0@aar') {
        transitive = true
    }

Aktuelle einfachste Version bei Verwendung von Gradle zum Erstellen:

if (!BuildConfig.DEBUG) {
    Fabric.with(this, new Crashlytics());
}

Es verwendet die neue integrierte Syntax von Fabric for Crashlytics und arbeitet automatisch mit einem Gradle-Build.

Ein seltsames Problem, auf das ich gestoßen bin: Ich habe die Antwort von Xialin (die auch auf der offiziellen Website erscheint) befolgt und es hat nicht funktioniert. Es stellte sich heraus, dass ich BuildConfigin Fabric's Paket referenziert habe, das auch eine statische DEBUG-Variable enthält, die selbst im Debug-Modus auf false gesetzt wurde.

Wenn Sie also der oben genannten Lösung folgen und dennoch Debug-Berichte erhalten, stellen Sie sicher, dass Sie auf Folgendes verweisen:

import com.yourpackagename.BuildConfig;

Und nicht das:

import io.fabric.sdk.android.BuildConfig;    

Wenn Sie befürchten, BuildConfig.DEBUGnicht richtig eingerichtet zu sein, verwenden Sie ApplicationInfostattdessen:

boolean isDebug = ( mAppContext.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE ) != 0;
Crashlytics crashlytics = new Crashlytics.Builder().disabled( isDebug ).build();
Fabric.with( uIContext, crashlytics );

Verwenden Sie Aromen oder bauen Sie Konfigurationen. Verwenden Sie eine separate Build-ID für den Dev-Build, und alle Ihre Abstürze werden weiterhin in einer separaten App angezeigt. Kann nützlich sein, wenn Sie den Build für Peers freigeben oder ohne Debugger verwenden. Etwas wie das -

    productFlavors {
    dev {
        applicationId "io.yourapp.developement"
    }
    staging {
        applicationId "io.yourapp.staging"
    }

    production {
        applicationId "io.yourapp.app"
    }

Wenn Sie einen debuggbaren Release-Build wünschen, gehen Sie wie folgt vor:

buildTypes {
    release {
        signingConfig signingConfigs.config
        debuggable true //-> debuggable release build
        minifyEnabled true
        multiDexEnabled false
        ext.enableCrashlytics = true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        buildConfigField 'boolean', 'BUILD_TYPE_DEBUG', 'false'
    }
    debug {
        minifyEnabled false
        multiDexEnabled true
        ext.enableCrashlytics = false
        ext.alwaysUpdateBuildId = false
        // Disable fabric build ID generation for debug builds
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        buildConfigField 'boolean', 'BUILD_TYPE_DEBUG', 'true'
    }
}

Wenn Sie festlegen debuggable true, dass BuildConfig.DEBUG mit true initialisiert wird, habe ich diese Variable in der BuildConfig-Klasse hinzugefügt.

Init Fabric:

Crashlytics crashlytics = new Crashlytics.Builder()
            // disable crash reporting in debug build types with custom build type variable
            .core(new CrashlyticsCore.Builder().disabled(BuildConfig.BUILD_TYPE_DEBUG).build())
            .build();

    final Fabric fabric = new Fabric.Builder(this)
            .kits(crashlytics)
            //enable debugging with debuggable flag in build type 
            .debuggable(BuildConfig.DEBUG)
            .build();

    // Initialize Fabric with the debug-disabled crashlytics.
    Fabric.with(fabric);

Wir können die isDebuggable () -Methode von Fabric verwenden.

import static io.fabric.sdk.android.Fabric.isDebuggable;

if(! isDebuggable()){
    // set Crashlytics ... 
}

Viel Spaß beim Codieren :)

Sie können eine dedizierte Manifestdatei für den Debug-Modus verwenden (funktioniert bei mir mit Crashlytics 2.9.7):

Erstellen Sie die Datei app/src/debug/AndroidManifest.xmlund fügen Sie Folgendes hinzu:

<application>

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

</application>

Beachten Sie, dass dieses Metadatenelement nur in debug / AndroidManifest.xml und nicht in die reguläre AndroidManifest.xml eingefügt werden darf

Die verwendete Lösung CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()hat bei mir nicht funktioniert, und ich habe festgestellt, dass Crashlytics vom CrashlyticsInitProvider initialisiert wird, bevor Application.onCreate () aufgerufen oder eine Aktivität gestartet wird. Dies bedeutet, dass die manuelle Initialisierung von Fabric in der Anwendung oder einer Aktivität keine hat Effekt, da der Stoff bereits initialisiert ist.

Schritt 1: In build.grade

buildTypes {
        debug {
            debuggable true
            manifestPlaceholders = [enableCrashlytic:false]
        }
        release {
            debuggable false
            manifestPlaceholders = [enableCrashlytic:true]
        }
    }

Schritt 2: Im Manifest

<meta-data
            android:name="firebase_crashlytics_collection_enabled"
            android:value="${enableCrashlytic}" />

Schritt 3: In der Anwendung oder in der ersten Aktivität

private void setupCrashReport() {
        if (BuildConfig.DEBUG) return;
        Fabric.with(this, new Crashlytics());
    }

Ich bin nicht sicher, ob Schritt 3 notwendig ist, aber um sicherzustellen, dass die Release-Version ohne Absturz funktioniert. Quelle: https://firebase.google.com/docs/crashlytics/customize-crash-reports#enable_opt-in_reporting

Diese Arbeit für mich:

    releaseCompile  'com.crashlytics.sdk.android:crashlytics:2.9.9'

und in buildTypes:

debug {
ext.enableCrashlytics = false
}

Es gibt zwei Optionen, um Firebase Crashlytics für die folgende Version zu deaktivieren: com.google.firebase: firebase-crashlytics: 17.0.0:

1. Fügen Sie dem Manifest der App ein Meta-Tag hinzu

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

ODER

2. Direkt in der App konfigurieren (denken Sie daran, wenn der Wert auf false gesetzt ist, gilt der neue Wert erst beim nächsten Ausführen der App.)

FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true)

Eine andere Möglichkeit, wenn Sie dies nur in Ihrer IDE tun möchten, besteht darin, sich vom Plugin abzumelden. Anscheinend werden keine Berichte mehr gesendet, während Sie Builds generieren, ohne sich erneut anzumelden.

1. Fügen Sie dies dem build.gradle Ihrer App hinzu:

   android {
       buildTypes {
           debug {
             // Disable fabric build ID generation for debug builds
             ext.enableCrashlytics = false
             ...

2. Deaktivieren Sie das Crashlytics-Kit zur Laufzeit. Andernfalls wird das Crashlytics-Kit den Fehler auslösen:

   // Set up Crashlytics, disabled for debug builds
   // Add These lines in your app Application class onCreate method
   
   Crashlytics crashlyticsKit = new Crashlytics.Builder()
       .core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build())
       .build();
   
   // Initialize Fabric with the debug-disabled crashlytics.
   Fabric.with(this, crashlyticsKit);

3. Fügen Sie in AndroidManifest.xml hinzu

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

2020 Post Fabric Antwort

Fügen Sie den folgenden Code in Ihre Anwendungsklasse ein und rufen Sie die Methode setCrashlyticsStateaus Ihrer Anwendung onCreate auf. Optional können Sie die IDs Ihres Testgeräts zum hinzufügendebugDevices IDs HashSet hinzufügen, damit Ihre persönlichen Geräte ignoriert werden können, selbst wenn Sie im Release-Modus erstellen.

Hinweis. Es Settings.Secure.getString(getContext().getContentResolver(), Settings.Secure.ANDROID_ID);wird nicht garantiert , dass die von zurückgegebene Geräte-ID eindeutig oder konstant ist (sie kann sich beim Zurücksetzen auf die Werkseinstellungen oder manuell bei einem gerooteten Gerät ändern). Aber es sollte gut genug sein.

private final HashSet<String> debugDevices = new HashSet<String>(Arrays.asList("6a3d5c2bae3fd32c"));

private boolean isDebugDevice(String deviceId) {
    return debugDevices.contains(deviceId);
}

private void setCrashlyticsState() {
    @SuppressLint("HardwareIds")
    String deviceId = Settings.Secure.getString(getContext().getContentResolver(), Settings.Secure.ANDROID_ID);
    if (BuildConfig.DEBUG || isDebugDevice(deviceId)) {
        Log.v("DeviceId", deviceId);
        FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(false);
    }
}

Überprüfen Sie die BuildConfig. sucht nach der richtigen BuildConfig-Klasse. Es gibt oft mehrere Optionen und die falsche könnte hineingezogen werden.

Das ist eine dumme Antwort, ich weiß.
Kommentiere es einfach aus Fabric.with(this, new Crashlytics());, arbeite daran und kommentiere es aus , wenn du es veröffentlichen willst.