Comment désactiver Crashlytics pendant le développement

245

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

Michael
la source
Avez-vous essayé de supprimer votre clé API du manifeste, je ne me souviens pas si c'est un crash.
Timmetje
@timmied Il se bloque. Commentant également toute la ligne dans les Manifestplantages de l'application, cela rend la question un peu plus légitime.
Michael

Réponses:

172

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

marcr
la source
5
@marcr Et si vous utilisiez simplement BuildConfig.DEBUG?
dannyroa
3
@dannyroa BuildConfig.DEBUG n'est pas un indicateur standard qui fonctionne dans tous les environnements de génération. Je crois qu'il est défini de manière cohérente lors de la construction avec Eclipse et ADT, mais pas ailleurs.
mars 2014
11
BuildConfig.DEBUGdoit être utilisé si vous construisez avec Gradle. Il sera toujours généré correctement.
Austyn Mahoney
3
@marcr qu'en est-il dans la dernière version de crashlytics (car il semble fusionné avec Fabric), la bibliothèque effectue-t-elle un contrôle interne BuildConfig.DEBUG?
akhy
2
@akhyar Ce n'est pas vérifié automatiquement, j'utilise: if (! BuildConfig.DEBUG) {Fabric.with (this, new Crashlytics ());}
Björn Kechel
387

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
    }
}
xialine
la source
2
Ceci est beaucoup plus agréable à utiliser et arrêtera le plantage de votre application si vous appelez Crashlytics dans votre code, en dehors de votre classe Application.
speedynomads
1
Il est devenu obsolète dans Crashlytics 2.3.0 :(
Damian Walczak
1
ext.enableCrashlytics = false ne fonctionne pas pour moi non plus avec 2.5. En fait, cela n'a jamais fonctionné. Même avant le tissu.
Bao-Long Nguyen-Trong
2
J'ai une préoccupation ici. Est-ce que cela activera Answer et Beta? Il semble que cela devrait être plus correct: CrashlyticsCore core = new CrashlyticsCore.Builder (). Disabled (BuildConfig.DEBUG) .build (); Fabric.with (this, new Answers (), new Beta (), new Crashlytics.Builder (). Core (core) .build ());
gbero
1
ext.enableCrashlytics = false ne se bloque pas si vous l'utilisez correctement. Comment surmonter l' incident se trouve dans la documentation Fabrics: docs.fabric.io/android/crashlytics/build-tools.html .
Frank
46

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");
}
Paul Spiesberger
la source
2
Cela semble propre. Au lieu de s'initialiser dans l'activité principale, lorsque vous n'êtes pas dans l'instance d'application à la place?
jules
Ils déclarent sur le site Web: Enable collection for selected users by initializing Crashlytics from one of your app's activitiesmais je suppose que cela ne change pas grand-chose si vous initialisez Crashlytics dans l'application. Est-ce que tu l'as essayé? Si cela fonctionne, je peux l'ajouter à ma réponse. firebase.google.com/docs/crashlytics/customize-crash-reports
Paul Spiesberger
2
Je n'ai pu faire fonctionner aucune des autres solutions afin de désactiver les crashlytics lors de l'exécution. La solution 1 a parfaitement fonctionné - pourquoi n'y ai-je pas pensé.
Merci pour la solution. Lorsque je mets firebase_crashlytics_collection_enabledà false dans le manifeste, le crash n'apparaît pas sur la console (j'utilise la v2.9.9). J'ai donc résolu ce firebase_crashlytics_collection_enabled=falsetrue
problème
30

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

ext.enableCrashlytics = false
user1998494
la source
1
c'est seulement pour la saveur? qu'en est-il du débogage par rapport à la version? J'ai essayé de désactiver le débogage mais j'envoie toujours le plantage
xialin
Je pense que cela ne fonctionne que sur les saveurs. L'OMI utilisant le drapeau Austyn et Marcc pointu est la plus simple.
user1998494
J'ai trouvé la solution. mais je ne sais pas s'il est compatible avec les anciens Crashlytics. c'est pour le nouveau Crashlytics in Fabric SDK. vérifier ma réponse ci
xialin
1
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: stackoverflow.com/questions/28339323/…
Aphex
18
Cela a provoqué un crash ... " This app relies on Crashlytics."
Sakiboy
27

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);
Abhishek Patidar
la source
J'ai essayé de cette façon, et l'application se bloque toujours avecThis app relies on Crashlytics. Please sign up for access at
Balflear
Je suppose que vous ext.enableCrashlytics = falsemanquez dans build.gradle.
Abhishek Patidar
Non, j'ai ajouté dans le type de build de débogage dans le fichier build.gradle, c'est dans le buildTypes -> debug, also i'm applying the plugin via plugin apply: 'io.fabric'`
Balflear
Je ne sais pas pourquoi cette solution a même été votée 24 fois. Crashes avecThis app relies on Crashlytics. Please sign up for access at https://fabric.io/sign_up
TROD
24

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.

fahmy
la source
17

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)
Albert Vila Calvo
la source
Je pense android:value="false"qu'il faut changer pour android:value="${enableCrashlytics}". N'est-ce pas?
JaydeepW
Un autre avantage de l'option n ° 2 est que vous commencez avec la collection d'analyse initialement désactivée, puis pouvez demander à l'utilisateur d'abord qu'il est OK de suivre l'utilisation de son application (pensez au RGPD). Ensuite, vous ne feriez l'appel Fabric.with que si l'utilisateur acceptait le suivi.
Par Christian Henden
Le seul inconvénient de l'option # 2, c'est qu'elle crée toujours des versions de débogage dans le tableau de bord Firebase, même si aucun plantage n'y sera affiché (car ils sont désactivés). Cela pose deux problèmes - tout d'abord, il est plus difficile de trouver des versions de sortie; deuxième - le tableau de bord Firebase n'affiche que les 100 dernières versions - ce qui pourrait vous empêcher de voir des plantages dans certaines anciennes versions. Dans le tableau de bord Fabric, vous pouvez désactiver une version particulière, ce n'est pas possible dans le tableau de bord de Firebase.
Alex Lipov
14

Utilisez ceci dans MyApplication#onCreate()

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

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

Austyn Mahoney
la source
BuildConfig.DEBUG n'est pas toujours défini correctement. Compter dessus pour activer / désactiver Crashlytics m'a causé pas mal de problèmes lors de l'utilisation d'IntelliJ.
Zeb Barnett
5
Quels outils de build utilisez-vous? Gradle définira TOUJOURS cette valeur. C'était un problème il y a un an, mais les nouveaux outils de construction sont bien meilleurs.
Austyn Mahoney
Je suis sur v0.9. + Du plugin Gradle pour IntelliJ et v1.11 pour Gradle lui-même.
Zeb Barnett
Je n'ai vu aucun problème dans aucune de mes applications. BuildConfigest généré par une tâche Gradle, dont l'exécution est garantie. J'utilise également buildConfigFieldpour définir des champs personnalisés et ceux qui fonctionnent toujours. tools.android.com/recent/androidstudio045released suggère également que vous l' utilisiezBuildConfig.DEBUG .
Austyn Mahoney
En tant qu'idéaliste, j'aimerais vraiment pouvoir l'utiliser car cela simplifierait le processus de construction pas assez automatisé pour la petite entreprise pour laquelle je travaille. C'est juste que nous avons mis en production une version qui dépendait de ce drapeau et Crashlytics ne l'a jamais vu en direct. Après que nous ayons recommencé à le basculer manuellement, Crashlytics l'a vu immédiatement.
Zeb Barnett du
9

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}" />
arbuz
la source
6

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.

Ariel Cabib
la source
6

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

Khronos
la source
Ça y est? Pas besoin de faire des saveurs?
portfoliobuilder
6

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());
}
William Henderson
la source
C'est faux. Je consigne des exceptions non fatales dans mon code à l'aide de Crashlytics.logException(e)et cette instruction lève une exception dans les versions de débogage car Fabric singleton n'est pas initialisé. Si vous utilisez Crashlytics, initialisez toujours Fabric Singleton. Voir la réponse de fahmy .
naXa
5

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
    }
Kvant
la source
3

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.

Björn Kechel
la source
3

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;    
Neria Nachum
la source
2

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 );
Vaiden
la source
2

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"
    }
ribhu
la source
2

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);
M. Reza Nasirloo
la source
Quel est le but de ext.enableCrashlyticset ext.alwaysUpdateBuildIdpuisqu'ils ne semblent être référencés nulle part. Suis-je en train de manquer quelque chose?
jules
@jules C'est dans les documents docs.fabric.io/android/crashlytics/build-tools.html
M. Reza Nasirloo
BuildConfig.BUILD_TYPE_DEBUG est redondant, BuildConfig.DEBUG peut être utilisé pour obtenir la même valeur
Antonis Radz
@AntonisRadz Parce que j'avais besoin d'une version debuggable
M. Reza Nasirloo
1

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

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

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

Bon codage :)

sadiq
la source
1

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é.

josias
la source
1

É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

thanhbinh84
la source
1

Ce travail pour moi:

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

et dans buildTypes:

debug {
ext.enableCrashlytics = false
}
Amirhosein Heydari
la source
Que diriez-vous des utilisations de Crashlytics dans le code? Cela vous donnera des erreurs de compilation.
Micer
1

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

  1. 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)

Viktor Ivanov
la source
0

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.

neteinstein
la source
0
  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" />
100rbh
la source
0

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.

Will Calderwood
la source
-8

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.

Tej42
la source