android - firebasecrash - firebase crashlytics web

¿Cómo deshabilitar Firebase Crash Reporting cuando la aplicación se ejecuta en depuración?

Question

He implementado con éxito Firebase Crash Reporting, pero necesito deshabilitar el servicio cuando la aplicación se está ejecutando deshacer la variante de compilación ''depurar'' para evitar bloqueos no reales en la consola durante el desarrollo.

La documentación oficial no dice nada al respecto.

Answer 1

ACTUALIZADO: Con los servicios de Google Play / Firebase 11+ ahora puede deshabilitar los informes de fallas en tiempo de ejecución. FirebaseCrash.setCrashCollectionEnabled() (Gracias @Tyler Carberry )

ANTIGUA RESPUESTA:

No hay apoyo oficial para esto, hasta donde la comunidad ha podido suponer. La mejor forma en que sugeriría hacer esto es configurar varias aplicaciones de Firebase en su tablero, una para cada tipo de compilación, y configurar múltiples archivos google_services.json que dirijan a cada aplicación diferente dependiendo de la variante de compilación.

Answer 2

Actualmente no puede deshabilitar los informes de fallas de Firebase, aunque puede desactivar el análisis de Firebase.

Entonces, una forma de hacerlo es crear otra aplicación con una ID diferente dentro del mismo proyecto de Firebase. Después de esto, solo necesita cambiar la ID de aplicación para habilitar o deshabilitar los informes de fallas de Firebase. Creé a continuación dos aplicaciones para mi conveniencia:

AppID: com.android - Para el tipo de compilación de lanzamiento

ID de aplicación: com.android.debug : para el tipo de compilación de depuración

Siga el siguiente enlace para obtener más detalles:

firebase.googleblog.com/2016/08/…

Editar: no necesita cambiar la ID de aplicación en el proyecto de Android una y otra vez. Hay una mejor manera de usar diferentes ID de aplicación para el tipo de compilación de depuración.

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

Consulte el enlace para más detalles:

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

Edit2:

Básicamente, en la solución anterior, está creando dos aplicaciones diferentes en el proyecto Firebase, y de esta manera puede separar sus errores de desarrollo y producción.

El informe de fallas de Firebase FYI está en desuso. Debe usar Fabrics Crashlytics (propiedad de Google). Tiene algunas características realmente geniales.

Answer 3

Como se ha dicho antes, no hay una forma oficial de hacerlo. Pero la peor solución para mí como mencioné @ mark-d es restablecer DefaultUncaughtExceptionHandler ( https://.com/a/39322734/4245651 ).

Pero si solo llama a System.exit(2) como se sugirió, la aplicación se cerrará instantáneamente con excepción, sin ningún mensaje de diálogo y sin obtener registros de depuración. Si esto es importante para usted, hay una manera de restaurar el controlador predeterminado:

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

Dónde

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

Answer 4

Con Google Play Services 11.0 ahora puede deshabilitar los informes de fallas en tiempo de ejecución.

FirebaseCrash.setCrashCollectionEnabled(!BuildConfig.DEBUG);

Answer 5

El truco simple y fácil que utilicé es agregar dependencia de informes de fallas de Firebase en la versión de compilación solo en el archivo build.gradle .

Esto eliminará la biblioteca de informes de fallas del tipo de compilación de depuración y agregará esto solo en la compilación de lanzamiento.

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

Answer 6

Inspirado por esta respuesta relacionada y otras aquí, se me ocurrió esta práctica solución.

Usando Timber para iniciar sesión, creé diferentes implementaciones de una subclase de Tree para depurar y liberar compilaciones. En la depuración, difiere a DebugTree que escribe en logcat. En el lanzamiento, reenvía excepciones y registros de alta prioridad a Firebase, eliminando el resto.

build.gradle

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

src / debug / java / [paquete] /ForestFire.java

import timber.log.Timber;

public class ForestFire extends Timber.DebugTree {}

src / release / java / [paquete] /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);
      }
    }
  }
}

Inicio de la aplicación

Timber.plant(new ForestFire());

Answer 7

Para la clase FirebaseAnalytics .
Deshabilitar colección: setAnalyticsCollectionEnabled(false);
Habilitar colección: setAnalyticsCollectionEnabled(true); o escriba a AndroidManifest.xml en la etiqueta de la aplicación: <meta-data android:name="firebase_analytics_collection_enabled" android:value="false" />

Posible uso:

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

Source

Answer 8

Primero inicialice las variables en el archivo gradle y verifique si está en modo de depuración o de liberación. La mejor manera de enviar el informe de bloqueo es dentro de la clase Aplicación.

Build.gradle

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

Ahora primero verifique el modo y envíe el informe de bloqueo si falla.

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

Answer 9

Primero tendrá que crear una release debug y release variantes de compilación y luego establecer una variable con valor booleano. Entonces necesitará obtener ese valor de su archivo java que extiende la application es decir, desde donde habilita los informes de fallas de Fabric .

Un ejemplo de código se da a continuación.

En el archivo build.gradle su aplicación, agregue las siguientes líneas para crear 2 variantes de compilación de debug y release y luego agregue una variable con valor booleano.

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

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

Luego, cuando intente agregar informes de ENABLE_ANALYTICS Fabric , verifique el valor de ENABLE_ANALYTICS

Test de clase pública extiende la aplicación {

private GoogleAnalytics googleAnalytics;
private static Tracker tracker;

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

Puede ver el valor de ENABLE_ANALYTICS mediante ctrl + clic en el valor. Espero que esto ayude.

Answer 10

Puede cambiar la dependencia de bloqueo de Firebase a una dependencia de solo liberación.

Para hacer esto, lo define como una dependencia de ReleaseCompile

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

Ahora solo se incluirá en las versiones de lanzamiento. Si tiene otros tipos de compilación personalizados para los que desea informes de fallas, puede agregarlos a ellos.

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

Answer 11

Uso versionCode como filtro para compilaciones locales / de producción.

gradle.properties

VERSION_CODE=1

app / build.gradle

android {
    defaultConfig {
        versionCode VERSION_CODE as int
    }
}

Al publicar una nueva versión de la aplicación, simplemente establezca un nuevo valor desde la línea de comando:

./gradlew build -PVERSION_CODE=new_value

De lo contrario, cuando esté compilando desde Android Studio, siempre obtendrá el mismo versionCode , por lo que podrá distinguir fácilmente los informes de fallas en la consola de Firebase.

Answer 12

en mi clase de aplicación, 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
        }
    });
}

Funciona porque toma el OldHandler, que incluye el Firebase

 final UncaughtExceptionHandler oldHandler = Thread.getDefaultUncaughtExceptionHandler();

fuera de la ruta de procesamiento

Answer 13

Recently se introdujo la posibilidad de deshabilitar los informes de fallas de Firebase de manera oficial. Debe actualizar el sdk de Android Firebase a al menos la versión 11.0.0

Para hacerlo, debe editar su AndroidManifest.xml y agregar:

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

Dentro del bloque <application> .

Puede verificar si el informe de bloqueo de Firebase está habilitado en tiempo de ejecución utilizando FirebaseCrash.isCrashCollectionEnabled() .

A continuación se muestra un ejemplo completo para deshabilitar los informes de fallas de Firebase en sus compilaciones de depuración.

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

Answer 14

public class MyApp extends Application {
    public static boolean isDebuggable;

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