web-dev-qa-db-fra.com

Comment désactiver Crashlytics pendant le développement

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

Je ne veux pas que ça envoie un crash chaque fois que je fais quelque chose de stupide

D'autre part, je ne veux pas commenter Crashlytics.start() et risque risquer d'oublier de le décommenter et de commettre

210
Michael

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

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

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

150
marcr

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

Mettez le code suivant dans votre classe d'application onCreate()

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

MODIFIER:

Dans Crashalitics 2.3 et supérieur, ceci est déconseillé. Le code correct 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é à partir de Méthode obsolète Crashlytics disabled () )


EDIT2:

Vous pouvez également éventuellement ajouter ceci à votre buildType in gradle. Cette commande désactive l’envoi du fichier de mappage crashlytics et la génération d’un ID pour chaque construction, ce qui accélère les générations de versions de ces versions. (Cela 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
    }
}
352
xialin

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

Solution 1

Compilez uniquement Crashlytics dans la version finale:

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

Solution 2

Si vous voulez configurer en plus Crashlytics alors la solution 1 ne fonctionne pas, car les classes Crashlytics ne seront pas trouvées dans les versions de débogage. Alors changez l'implémentation Gradle en:

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

Ensuite, accédez à votre manifeste et ajoutez la balise meta-data suivante dans la balise application:

<application
        Android:name="...>

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

...

</application>

Ajoutez à votre activité de lancement (une seule fois, pas pour chaque activité)

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

Cela activera uniquement Crashlytics dans les versions finales. Attention, vérifiez également BuildConfig.DEBUG lorsque vous configurez ensuite Crashlytics, E.g:

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

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

ext.enableCrashlytics = false
26
user1998494

Découvrez la dernière documentation . https://docs.fabric.io/Android/crashlytics/build-tools.html#gradle-advanced-setup .

En plus d’ajouter ext.enableCrashlytics = false dans build.grade, vous devez le 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);
24
Abhishek Patidar

J'ai trouvé ceci être 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é enableCrashlytics dans le fichier BuildConfig que vous pourrez utiliser pour décider si vous souhaitez lancer Fabric ou non:

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

NOTE: Avec cette méthode, Fabrics n'est initialisé que dans les versions release (comme indiqué dans le code ci-dessus). Cela signifie que vous devez placer des appels aux méthodes statiques dans la classe Crashlytics dans un bloc if qui vérifie si Fabrics a été initialisé comme indiqué ci-dessous.

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

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

22
fahmy

Utilisez ceci dans MyApplication#onCreate()

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

EDIT Si vous avez mis à niveau vers Fabric, utilisez plutôt ceci réponse .

14
Austyn Mahoney

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 externes, où les journaux d'accidents sont toujours très utiles et que je souhaite toujours signaler. Comme pour le PO, tout ce que je voulais, c’était de les désactiver pendant le développement actif, où je suis souvent à l’origine de la résolution rapide des collisions. 

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

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

Si vous souhaitez capturer toutes les pannes (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 versions seront marquées 1.0.0, tandis que les versions de débogage seront 1.0.0-DEBUG.

6
Khronos

Notez que vous pouvez également désactiver le téléchargement gênant de symboles dans la construction 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
    }
}

Il suffit de le mettre dans le build.gradle de votre module d'application.

5
Ariel Cabib

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

Vous ne pouvez pas le désactiver par code car il est compilé dans votre projet et exécuté avant même un appel onCreate de votre application. Donc, une autre solution est simple: ne compilez pas crashlytics si vous n'en avez pas besoin ... Remplacez l'appel 'compile' par 'releaseCompile' dans le fichier build.gradle.

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

Version la plus simple à jour lors de l'utilisation de Gradle pour créer:

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 construction Gradle.

3
Björn Kechel

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

 enter image description here

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

3

Un problème étrange 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é. En fait, je faisais référence à BuildConfig dans le package de Fabric, qui contient également une variable statique DEBUG 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 bien référencer ceci:

import com.yourpackagename.BuildConfig;

Et pas ça:

import io.fabric.sdk.Android.BuildConfig;    
3
Neria Nachum

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

Étape 1 - Définir les espaces réservés de 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}" />
2
arbuz

Si vous craignez que BuildConfig.DEBUG ne soit pas configuré correctement, utilisez plutôt ApplicationInfo:

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

Si vous voulez une version validée, 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 est 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);
2
M. Reza Nasirloo

Utilisez des saveurs ou construisez des configurations. Utilisez un identifiant de construction distinct pour dev build et tous vos plantages continueront d’aller vers une application séparée. Peut être utile en cas de partage de la construction avec des pairs ou de l’utiliser sans un débogueur. Quelque chose comme ça - 

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

    production {
        applicationId "io.yourapp.app"
    }
2
ribhu

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.xml et ajoutez les éléments suivants:

<application>

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

</application>

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

La solution qui utilise CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build() ne fonctionnait pas pour moi et j'ai découvert que crashlytics était initialisé par CrashlyticsInitProvider avant l'appel de Application.onCreate () ou le démarrage d'une activité quelconque, ce qui signifie que l'initialisation manuelle de la structure dans l'application aucun effet car le tissu est déjà initialisé.

1
josias

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

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

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

Bonne codage :)

0
sadiq
1. Add this to your app’s build.gradle:

    Android {
        buildTypes {
            debug {
              // Disable fabric build ID generation for debug builds
              ext.enableCrashlytics = false
              ...
    2. Disable the Crashlytics kit at runtime. Otherwise, the Crashlytics kit will throw the error:

    // 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. In AndroidManifest.xml, add
    <meta-data Android:name="firebase_crashlytics_collection_enabled" Android:value="false" />
0
100rbh

Ce travail pour moi:

    releaseCompile  'com.crashlytics.sdk.Android:crashlytics:2.9.9'
0
Amirhosein Heydari

Si vous ne souhaitez le faire que sur votre IDE, vous pouvez également vous déconnecter du plug-in. Apparemment, il cessera d'envoyer des rapports pendant que vous générez des versions sans vous reconnecter.

0
neteinstein

Réponse 2019

Cela fait 2 heures que j'essaie d'activer uniquement Crashlytics dans la version et de le désactiver dans le débogage, en vérifiant si la console Firebase est installée ou non.

Il y a 2 façons possibles de le faire.

OPTION 1

Cela fonctionne, mais si vous appelez une méthode Crashlytics sur les versions de débogage, l'application sera crash.

app/build.gradle

Android {
    buildTypes {
        release {
            manifestPlaceholders = [crashlyticsEnabled: true]
        }
        release {
            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 méthodes Crashlytics sans vérifier d'abord BuildConfig.DEBUG. 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 onCreate ()

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

Étape 1: dans build.grade

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

Étape 2: En manifeste

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

Étape 3: En application ou première activité

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

Je ne suis pas sûr que l'étape 3 soit nécessaire, mais pour m'assurer que la version finale fonctionne sans panne. source: https://firebase.google.com/docs/crashlytics/customize-crash-reports#enable_opt-in_reporting

0
thanhbinh84