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
Marc de Crashlytics ici. Voici quelques façons de désactiver Crashlytics pendant que vous créez vos versions de débogage!
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.
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"?
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
}
}
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");
}
Si vous utilisez Gradle, ajoutez simplement ceci à une saveur:
ext.enableCrashlytics = false
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);
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.
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 .
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());
}
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.
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.
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
}
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.
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
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;
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}" />
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 );
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);
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"
}
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é.
Nous pouvons utiliser la méthode isDebuggable () de fabric.
import static io.fabric.sdk.Android.Fabric.isDebuggable;
if(! isDebuggable()){
// set Crashlytics ...
}
Bonne codage :)
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" />
Ce travail pour moi:
releaseCompile 'com.crashlytics.sdk.Android:crashlytics:2.9.9'
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.
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)
É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