web-dev-qa-db-fra.com

Comment désactiver le rapport d'incident de Firebase lorsque l'application est en cours d'exécution sur le débogage?

J'ai implémenté avec succès Firebase Crash Reporting, mais je dois désactiver le service lorsque l'application est en cours d'exécution, annuler le Variant de construction 'debug', afin d'éviter des plantages non réels dans la console pendant le développement.

La documentation officielle ne dit rien à ce sujet.

androidfirebasefirebase-crash-reporting
72
facundomr

MISE À JOUR: Avec les services Google Play/Firebase 11+, vous pouvez désormais désactiver la génération de rapports d'incidents lors de l'exécution. FirebaseCrash.setCrashCollectionEnabled() (Merci @ Tyler Carberry )

ANCIENNE REPONSE:

Il n’ya pas d’appui officiel pour cela, dans la mesure où la communauté a pu le deviner. La meilleure façon de le faire est de configurer plusieurs applications Firebase dans votre tableau de bord, une pour chaque type de construction, et de configurer plusieurs fichiers google_services.json en les dirigeant vers chaque application différente en fonction de la variante de construction.

46
WoogieNoogie

Avec Google Play Services 11.0, vous pouvez maintenant désactiver la génération de rapports d'incident au moment de l'exécution.

FirebaseCrash.setCrashCollectionEnabled(!BuildConfig.DEBUG);
29
Tyler Carberry

Récemment a été introduit la possibilité de désactiver de manière officielle les rapports d'incidents de Firebase. Vous devez mettre à niveau la base de feu Android sdk vers la version 11.0.0 au moins).

Pour ce faire, vous devez modifier votre AndroidManifest.xml et ajouter:

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

À l'intérieur de <application> bloc.

Vous pouvez vérifier si le rapport d'incident Firebase est activé au moment de l'exécution à l'aide de FirebaseCrash.isCrashCollectionEnabled () .

Ci-dessous, un exemple complet pour désactiver le signalement des incidents dans Firebase dans vos versions de débogage.

build.gradle :

...
 buildTypes {

    release {
        ...
        resValue("bool", "FIREBASE_CRASH_ENABLED", "true")
    }

    debug {
        ...
        resValue("bool", "FIREBASE_CRASH_ENABLED", "false")

    }

}
...
dependencies {
    ...
    compile "com.google.firebase:firebase-core:11.0.0"
    compile "com.google.firebase:firebase-crash:11.0.0"
    ...
}

AndroidManifest.xml :

 <application>

    <meta-data
        Android:name="firebase_crash_collection_enabled"
        Android:value="@bool/FIREBASE_CRASH_ENABLED"/>
...
23
evi

dans ma classe d'application, onCreate ()

if (BuildConfig.DEBUG) {
    Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
        @Override
        public void uncaughtException(Thread paramThread, Throwable paramThrowable) {
            Log.wtf("Alert", paramThrowable.getMessage(), paramThrowable);
            System.exit(2); //Prevents the service/app from freezing
        }
    });
}

Cela fonctionne parce que cela prend oldHandler, qui inclut celui de Firebase

 final UncaughtExceptionHandler oldHandler = Thread.getDefaultUncaughtExceptionHandler();

hors du chemin de traitement

11
Marc

Vous pouvez modifier la dépendance de crash de Firebase à une dépendance de version uniquement.

Pour ce faire, vous le définissez comme une dépendance releaseCompile

releaseCompile 'com.google.firebase:firebase-crash:9.4.0'

À présent, il ne sera inclus que dans les versions de la version. Si vous souhaitez d'autres types de construction personnalisés pour lesquels vous souhaitez créer un rapport d'incident, vous pouvez les leur ajouter.

customBuildTypeCompile 'com.google.firebase:firebase-crash:9.4.0'
11
Martin Wallgren

L’astuce la plus simple et la plus simple que j’ai utilisée est d’ajouter la dépendance de rapport de crash de Firebase dans la version mise à jour uniquement dans build.gradle fichier.

Cela supprimera la bibliothèque de rapports sur les incidents du type de construction debug et ne l'ajoutera que dans la version finale.

dependencies {
    releaseCompile 'com.google.firebase:firebase-crash:10.2.0'
}
9
Keval Patel

Inspiré par cette réponse associée et d’autres ici, j’ai proposé cette solution pratique.

À l'aide de Timber pour la journalisation, j'ai créé différentes implémentations d'une sous-classe Tree pour les versions de débogage et de publication. En mode de débogage, il diffère de DebugTree qui écrit dans logcat. Dans sa version actuelle, il transmet les exceptions et les journaux de priorité élevée à Firebase, en supprimant le reste.

build.gradle 

dependencies {
  ...
  compile 'com.jakewharton.timber:timber:4.3.0'
  releaseCompile 'com.google.firebase:firebase-crash:9.0.2'
}

src/debug/Java/[package] /ForestFire.Java 

import timber.log.Timber;

public class ForestFire extends Timber.DebugTree {}

src/release/Java/[package] /ForestFire.Java 

import Android.util.Log;
import com.google.firebase.crash.FirebaseCrash;
import timber.log.Timber;

public class ForestFire extends Timber.Tree {
  @Override
  protected void log(int priority, String tag, String message, Throwable t) {
    if (Log.WARN <= priority) {
      FirebaseCrash.log(message);
      if (t != null) {
        FirebaseCrash.report(t);
      }
    }
  }
}

Démarrage de l'application 

Timber.plant(new ForestFire());
7
Travis Christian

Commencez par initialiser les variables dans le fichier Gradle et vérifiez s’il est en mode débogage ou publication. Le meilleur moyen de soumettre le rapport d'incident consiste à utiliser la classe Application.

Build.gradle

    buildTypes {
         release {
             buildConfigField "Boolean", "REPORT_CRASH", '"true"'
             debuggable false
         }
         debug {
             buildConfigField "Boolean", "REPORT_CRASH", '"false"'
             debuggable true
         }
    }

Maintenant, vérifiez d'abord le mode et soumettez le rapport d'incident s'il s'est écrasé.

Application.Java

    /** Report FirebaseCrash Exception if application crashed*/
    Thread.setDefaultUncaughtExceptionHandler (new Thread.UncaughtExceptionHandler()
    {
        @Override
        public void uncaughtException (Thread thread, Throwable e)
        {
            /** Check whether it is development or release mode*/
            if(BuildConfig.REPORT_CRASH)
            {
                FirebaseCrash.report( e);
            }
        }
    });
6
jazzbpn

Actuellement, vous ne pouvez pas désactiver les rapports d'incidents firebase, mais vous pouvez également désactiver les analyses Firebase.

Donc, une façon de faire est de créer une autre application avec un ID différent dans le même projet Firebase. Après cela, il vous suffit de modifier appID pour activer ou désactiver le rapport d'incidents de Firebase. J'ai créé ci-dessous deux applications pour ma commodité:

AppID: com.Android - Pour le type de build de version

AppID: com.Android.debug - Pour le type de construction de débogage

Veuillez suivre le lien ci-dessous pour plus de détails:

https://firebase.googleblog.com/2016/08/organizing-your-firebase-enabled-Android-app-builds.html

Modifier: Il n'est pas nécessaire de changer appID dans Android projet encore et encore. Il existe un meilleur moyen de utiliser un appID différent pour le type de construction debug -

Android {
    defaultConfig {
        applicationId "com.Android"
        ...
    }
    buildTypes {
        debug {
            applicationIdSuffix ".debug"
        }
    }
}

Cliquez sur le lien pour plus de détails:

https://developer.Android.com/studio/build/application-id.html

Edit2:

En gros, dans la solution ci-dessus, vous créez deux applications différentes dans le projet Firebase, ce qui vous permet de séparer vos erreurs de développement et de production.

La notification des incidents FYI Firebase est obsolète. Vous devez utiliser Fabrics Crashlytics (propriété de Google). Il a des fonctionnalités vraiment cool.

4
Vipul Kumar

Pour FirebaseAnalytics class.
Désactiver la collecte: setAnalyticsCollectionEnabled(false);
Activer la collection: setAnalyticsCollectionEnabled(true); ou écrire dans AndroidManifest.xml dans la balise d'application: <meta-data Android:name="firebase_analytics_collection_enabled" Android:value="false" />

Utilisation possible:

if (BuildConfig.DEBUG){ //disable for debug
    mFirebaseAnalytics.setAnalyticsCollectionEnabled(false);
}

Source

2
t0m

Vous devez d’abord créer les variantes de construction debug et release, puis définir une variable avec une valeur booléenne. Vous devrez ensuite obtenir cette valeur de votre fichier Java qui étend application, c'est-à-dire à partir duquel vous activez Fabric rapport de plantage.).

Un exemple de code est donné ci-dessous.

Dans votre application build.gradle fichier, ajoutez les lignes suivantes pour créer 2 variantes de construction debug et release, puis ajoutez une variable avec une valeur booléenne.

defaultConfig {
    buildConfigField 'boolean', 'ENABLE_ANALYTICS', 'true'
}

buildTypes {
    debug {
        applicationIdSuffix ".debug"
        versionNameSuffix 'DEBUG'
        buildConfigField 'boolean', 'ENABLE_ANALYTICS', 'false'
    }
    release {
        minifyEnabled false
    }
}

Ensuite, lorsque vous essayez d’ajouter Fabric, le rapport d’incident vérifie la valeur de ENABLE_ANALYTICS

public class Test étend l'application {

private GoogleAnalytics googleAnalytics;
private static Tracker tracker;

@Override
public void onCreate() {
    super.onCreate();
    if (BuildConfig.ENABLE_ANALYTICS)
        Fabric.with(this, new Crashlytics());
    }
}

Vous pouvez voir la valeur pour ENABLE_ANALYTICS _ par ctrl + clic sur la valeur. J'espère que cela t'aides.

1
viper

J'utilise versionCode comme filtre pour les constructions locales/de production.

gradle.properties

VERSION_CODE=1

app/build.gradle

Android {
    defaultConfig {
        versionCode VERSION_CODE as int
    }
}

Lors de la publication d'une nouvelle version de l'application, définissez simplement la nouvelle valeur à partir de la ligne de commande:

./gradlew build -PVERSION_CODE=new_value

Sinon, lorsque vous compilez à partir de Android Studio, vous obtiendrez toujours le même versionCode, afin que vous puissiez facilement distinguer les rapports d'incidents dans la console Firebase.

0
Oleksii K.

Comme cela a été dit auparavant, il n’existe aucun moyen officiel de le faire. Mais la solution de contournement la plus difficile pour moi, telle que mentionnée @ mark-d, est de réinitialiser DefaultUncaughtExceptionHandler ( https://stackoverflow.com/a/39322734/4245651 ).

Mais si vous appelez simplement System.exit(2) comme cela a été suggéré - l'application sera instantanément fermée sauf exception, sans message de dialogue et sans obtenir de journal de débogage. Si cela est important pour vous, il existe un moyen de restaurer le gestionnaire par défaut:

if (BuildConfig.DEBUG) {
        final Thread.UncaughtExceptionHandler currentHandler = Thread.getDefaultUncaughtExceptionHandler();
        if (currentHandler.getClass().getPackage().getName()
                                                .startsWith("com.google.firebase")) {
            final Thread.UncaughtExceptionHandler defaultHandler = 
                getPrivateFieldByType(currentHandler, Thread.UncaughtExceptionHandler.class);
            Thread.setDefaultUncaughtExceptionHandler(defaultHandler);
        }
}

Où

public static <T> T getPrivateFieldByType(Object obj, Class<T> fieldType) {
    if (obj != null && fieldType != null) {
        for (Field field : obj.getClass().getDeclaredFields()) {
            if (field.getType().isAssignableFrom(fieldType)) {
                boolean accessible = field.isAccessible();
                if (!accessible) field.setAccessible(true);
                T value = null;
                try {
                    //noinspection unchecked
                    value = (T) field.get(obj);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                if (!accessible) field.setAccessible(false);
                return value;
            }
        }
    }
    return null;
}
0
Roman_D
public class MyApp extends Application {
    public static boolean isDebuggable;

    public void onCreate() {
        super.onCreate();
        isDebuggable = (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE));
        FirebaseCrash.setCrashCollectionEnabled(!isDebuggable);
    }
}
0
Hamzeh Soboh