Comment désactiver Crashlytics pendant le développement

Existe-t-il un moyen simple de désactiver le SDK Crashlytics Android pendant le développement?

Je ne veux pas qu'il envoie un crash à chaque fois que je fais quelque chose de stupide

D'un autre côté, je ne veux pas commenter Crashlytics.start()et risquerais peut-être d'oublier de le commenter et de m'engager

Marc de Crashlytics ici. Voici quelques façons de désactiver Crashlytics pendant que vous effectuez vos versions de débogage!

1. Utilisez un autre Android: versionString pour les versions de débogage et de publication, puis désactivez les rapports de plantage à partir du tableau de bord Web Crashlytics pour la version de débogage.

2. Enveloppez l'appel à Crashlytics.start () dans une instruction if qui vérifie un indicateur de débogage. Vous pouvez utiliser soit un indicateur personnalisé, soit une approche comme celles proposées ici: Comment vérifier si l'APK est signé ou "debug build"?

J'ai trouvé la solution de Crashlytics (avec intégration Fabric)

Mettez le code suivant dans votre classe Application onCreate()

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

ÉDITER:

Dans Crashalitics 2.3 et supérieur, cela est déconseillé. Le bon code est:

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

ou

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

(copié depuis la méthode obsolète de Crashlytics désactivée () )

EDIT2:

Vous pouvez également éventuellement ajouter cela à votre buildTypegradle. Cette commande désactive l'envoi du fichier de mappage crashlytics et la génération d'un ID pour chaque build, ce qui accélère les builds gradle de ces versions. (Il ne désactive pas Crashlytics au moment de l'exécution.) Voir la réponse de Mike B ici.

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

La réponse choisie n'est plus correcte. Google a changé l'intégration de Crashlytics. Ma version actuelle est 2.9.1et la seule chose que je devais faire est d'ajouter implementation 'com.crashlytics.sdk.android:crashlytics:2.9.1'à mon fichier Gradle. Aucune autre chose n'est requise, c'est bien, mais cela signifie que Crashlytics est toujours en cours d'exécution.

Solution 1

Compiler uniquement Crashlytics dans la version finale:

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

Solution 2

Si vous souhaitez également configurer Crashlytics, la solution 1 ne fonctionne pas, car les classes Crashlytics ne seront pas trouvées dans les versions de débogage. Modifiez donc à nouveau l'implémentation Gradle:

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

Accédez ensuite à votre manifeste et ajoutez la meta-databalise suivante à l'intérieur de la applicationbalise:

<application
        android:name="...>

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

...

</application>

Ajoutez à votre activité de lancement (une seule fois requise, pas toutes les activités)

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

Cela n'activera Crashlytics que dans les versions. Soyez prudent, vérifiez également BuildConfig.DEBUG lorsque vous configurez ensuite Crashlytics, par exemple:

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

Si vous utilisez Gradle, ajoutez simplement ceci à une saveur:

ext.enableCrashlytics = false

Découvrez le dernier doc. https://docs.fabric.io/android/crashlytics/build-tools.html#gradle-advanced-setup .

Outre l'ajout ext.enableCrashlytics = falsede build.grade, vous devez faire,

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

J'ai trouvé que c'était la solution la plus simple:

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

Les lignes ci-dessus créeront un champ booléen statique appelé enableCrashlyticsdans le BuildConfigfichier que vous pouvez utiliser pour décider d'initier Fabricou non:

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

REMARQUE: avec cette méthode, Fabrics n'est initialisé que dans les versions (comme indiqué dans le code ci-dessus). Cela signifie que vous devez placer les appels aux méthodes statiques dans la Crashlyticsclasse dans un ifbloc qui vérifie si Fabrics a été initialisé comme indiqué ci-dessous.

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

Sinon, l'application se bloquera avec une Must Initialize Fabric before using singleton()erreur lors des tests sur l'émulateur.

Réponse 2019

J'ai essayé d'activer Crashlytics uniquement dans la version et de le désactiver dans le débogage pendant 2 heures, en vérifiant la console Firebase pour voir si les exceptions étaient téléchargées ou non.

Il existe 2 façons possibles de procéder.

OPTION 1

Cela fonctionne, mais si vous appelez une Crashlyticsméthode sur les versions de débogage, l'application se bloquera .

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

Une alternative si cela vous permet d'appeler des Crashlyticsméthodes sans vérifier d' BuildConfig.DEBUGabord. Avec cette configuration, vous pouvez appeler en toute sécurité des méthodes telles que Crashlytics.logException()- elles ne font tout simplement rien dans les versions de débogage. Je ne vois pas les rapports téléchargés dans le débogage.

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" />

Application surCréer ()

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

Utilisez ceci dans MyApplication#onCreate()

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

MODIFIER Si vous êtes passé à Fabric, utilisez plutôt cette réponse .

Selon Google, utilisez ce code pour désactiver Crashlytics et cela améliorera également le processus de construction.

référence- https://developer.android.com/studio/build/optimize-your-build

Une autre solution simple que j'aime, car elle ne nécessite pas de fichiers manifest différents:

Étape 1 - Définissez les espaces réservés du manifeste dans build.gradle

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

Étape 2 - utilisez-les dans votre AndroidManifest.xml

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

Notez que vous pouvez également désactiver le téléchargement ennuyeux de symboles dans la version de débogage:

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
    }
}

Mettez-le simplement dans le build.gradlemodule d'application.

Si vous souhaitez capturer tous les plantages (pour les versions de débogage et de publication) mais que vous souhaitez les séparer dans le tableau de bord Crashlytics, vous pouvez ajouter cette ligne de code à build.gradle:

debug {
    versionNameSuffix "-DEBUG"
}

Par exemple, si le nom de version de votre application est 1.0.0, vos versions de version seront étiquetées comme 1.0.0 tandis que les versions de débogage seront 1.0.0-DEBUG

Il y a beaucoup de bonnes réponses ici, mais pour mes tests, j'utilise des versions de débogage pour les bêtas internes et les tests hors laboratoire où les journaux de plantage sont toujours très utiles et je voudrais toujours les signaler. Comme l'OP, tout ce que je voulais, c'était de les désactiver pendant le développement actif où je suis souvent à l'origine et résolvant rapidement des plantages.

Plutôt que de supprimer TOUS les plantages de débogage, vous pouvez choisir de désactiver uniquement les rapports lorsqu'un périphérique est connecté à votre machine de développement avec le code suivant.

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

Le problème est qu'aucune des solutions ne fonctionne pour le dernier sdk crashlytics. (J'utilise 2.9.0)

Vous ne pouvez pas le désactiver par code car il se compile dans votre projet et s'exécute avant même un appel à la création de votre application. Donc, une autre solution est simple - ne compilez pas les crashlytics lorsqu'ils ne sont pas nécessaires. Remplacez l'appel 'compile' par 'releaseCompile' dans le fichier build.gradle.

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

Version à jour la plus simple lors de l'utilisation de Gradle pour construire:

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

Il utilise la nouvelle syntaxe intégrée de Fabric for Crashlytics et fonctionne automatiquement avec la version Gradle.

Un étrange problème que j'ai rencontré: j'ai suivi la réponse de xialin (qui apparaît également sur le site officiel) et cela n'a pas fonctionné. Il s'est avéré que je faisais référenceBuildConfig dans le package de Fabric qui contient également une variable DEBUG statique qui était définie sur false même en mode débogage.

Donc, si vous suivez la solution susmentionnée et que vous obtenez toujours des rapports de débogage, assurez-vous de faire référence à ceci:

import com.yourpackagename.BuildConfig;

Et pas ça:

import io.fabric.sdk.android.BuildConfig;    

Si vous craignez de BuildConfig.DEBUGne pas être configuré correctement, utilisez ApplicationInfoplutôt:

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

Utilisez des saveurs ou créez des configurations. Utilisez un identifiant de build distinct pour la build de développement et tous vos plantages continueront à aller vers une application distincte. Peut être utile en cas de partage de la build avec des pairs ou de l'utiliser sans débogueur. Quelque chose comme ça -

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

    production {
        applicationId "io.yourapp.app"
    }

Si vous voulez une version debuggable, voici le chemin:

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'
    }
}

Lorsque vous définissez debuggable true votre BuildConfig.DEBUG sera initialisé avec true, c'est pourquoi j'ai ajouté cette variable dans la classe BuildConfig.

Tissu Init:

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

Nous pouvons utiliser la méthode isDebuggable () de fabric.

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

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

Bon codage :)

Vous pouvez utiliser un fichier manifeste dédié pour le mode débogage (fonctionne pour moi avec Crashlytics 2.9.7):

Créez le fichier app/src/debug/AndroidManifest.xmlet ajoutez ce qui suit:

<application>

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

</application>

Notez que cet élément de métadonnées doit être placé dans debug / AndroidManifest.xml uniquement , et non dans le fichier AndroidManifest.xml normal

La solution qui utilise CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()n'a pas fonctionné pour moi, et j'ai découvert que crashlytics est initialisé par CrashlyticsInitProvider avant que Application.onCreate () soit appelée ou qu'une activité soit démarrée, ce qui signifie que l'initialisation manuelle du tissu dans l'application ou une activité n'a pas effet car le tissu est déjà initialisé.

Étape 1: dans build.grade

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

Étape 2: dans le manifeste

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

Étape 3: Dans l'application ou la première activité

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

Je ne sais pas si l'étape 3 est nécessaire, mais pour m'assurer que la version finale doit fonctionner sans crash. source: https://firebase.google.com/docs/crashlytics/customize-crash-reports#enable_opt-in_reporting

Ce travail pour moi:

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

et dans buildTypes:

debug {
ext.enableCrashlytics = false
}

Il existe deux options pour désactiver Firebase Crashlytics pour la version suivante com.google.firebase: firebase-crashlytics: 17.0.0:

1. Ajouter une méta-balise au manifeste de l'application

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

OU

2. Configurez directement dans l'application (gardez à l'esprit lorsqu'elle est définie sur false, la nouvelle valeur ne s'applique que lors de la prochaine exécution de l'application)

FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true)

Une autre façon si vous ne voulez le faire que sur votre IDE est de vous déconnecter du plugin. Apparemment, il cessera d'envoyer des rapports pendant que vous générez des builds sans vous reconnecter.

1. Ajoutez ceci au build.gradle de votre application:

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

2. Désactivez le kit Crashlytics au moment de l'exécution. Sinon, le kit Crashlytics générera l'erreur:

   // 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. Dans AndroidManifest.xml, ajoutez

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

Réponse post-tissu 2020

Collez le code ci-dessous dans votre classe Application et appelez la méthode à setCrashlyticsStatepartir de votre application onCreate. Vous pouvez éventuellement ajouter vos ID d'appareil de test à ladebugDevices ID de HashSet pour que vos périphériques personnels puissent être ignorés, même lors de la construction en mode de libération.

Remarque. L'identifiant de périphérique retourné par Settings.Secure.getString(getContext().getContentResolver(), Settings.Secure.ANDROID_ID);n'est pas garanti d'être unique ou constant (il peut changer lors d'une réinitialisation d'usine ou manuellement sur un périphérique rooté). Mais cela devrait être suffisant.

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

Vérifiez que BuildConfig. examine la classe BuildConfig correcte. Il existe souvent plusieurs options et la mauvaise peut être traînée.

C'est une réponse idiote, je sais
juste commenter Fabric.with(this, new Crashlytics());, travailler dessus et décommenter quand vous voulez le libérer.