android - how - Cómo deshabilitar Crashlytics durante el desarrollo

install fabric

Question

¿Hay alguna forma sencilla de desactivar el SDK de Crashlytics durante el desarrollo?

No quiero que envíe un crash cada vez que hago algo estúpido.

Por otro lado, no quiero comentar Crashlytics.start() y posiblemente arriesgarme a olvidar descomentarlo y cometer.

Answer 1

Echa un vistazo a la última doc. https://docs.fabric.io/android/crashlytics/build-tools.html#gradle-advanced-setup .

Además de agregar ext.enableCrashlytics = false en build.grade que debe hacer,

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

Answer 2

El problema es que ninguna de las soluciones funciona para la última versión de crashlytics sdk. (Estoy usando 2.9.0)

No puede deshabilitarlo por código, ya que se compila en su proyecto y se ejecuta incluso antes de una llamada enCreate de su aplicación. Por lo tanto, otra solución es simple: no compile crashlytics cuando no sea necesario. Reemplace la llamada ''compilar'' con ''releaseCompile'' dentro del archivo build.gradle.

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

Answer 3

Encontré la solución de Crashlytics (con integración de Fabric)

Coloque el siguiente código dentro de su clase de aplicación onCreate()

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

EDITAR:

En Crashalitics 2.3 y superiores, esto está en desuso. El código correcto es:

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

o

Fabric.with(this, new Crashlytics.Builder().core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()).build());

( Copiado de un método obsoleto de Crashlytics deshabilitado () )

EDIT2:

También puede agregar esto opcionalmente a su buildType en gradle. Este comando desactiva el envío del archivo de mapeo crashlytics y genera una ID para cada compilación, lo que acelera las compilaciones gradle de esos sabores. (No desactiva los Crashlytics en tiempo de ejecución). Vea la respuesta de Mike B aquí.

buildTypes {
    release {
           ....
    }
    debug {
        ext.enableCrashlytics = false
    }
}

Answer 4

Encontré que this es la solución más fácil:

    release {
        ...
        buildConfigField ''Boolean'', ''enableCrashlytics'', ''true''
    }
    debug {
        buildConfigField ''Boolean'', ''enableCrashlytics'', ''false''
    }

Las líneas anteriores crearán un campo booleano estático llamado enableCrashlytics en el archivo BuildConfig que puede usar para decidir si iniciar o no Fabric :

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

NOTA: Con este método, Fabrics se inicializa solo en versiones de lanzamiento (como se indica en el código anterior). Esto significa que necesita poner llamadas a métodos estáticos en la clase Crashlytics en un bloque if que compruebe si Fabrics se ha inicializado como se muestra a continuación.

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

De lo contrario, la aplicación se bloqueará con Must Initialize Fabric before using singleton() error de Must Initialize Fabric before using singleton() al realizar pruebas en el emulador.

Answer 5

Esta es una respuesta tonta, lo sé
Simplemente comente Fabric.with(this, new Crashlytics()); , trabaja en eso y descoméntalo cuando quieras liberarlo.

Answer 6

Hay muchas respuestas buenas aquí, pero para mis pruebas utilizo compilaciones de depuración para betas internas y pruebas fuera del laboratorio donde los registros de fallos siguen siendo muy útiles y todavía me gustaría informarlos. Al igual que el OP, todo lo que quería era deshabilitarlos durante el desarrollo activo, donde a menudo estoy causando y resolviendo fallos rápidamente.

En lugar de eliminar TODOS los bloqueos de depuración, puede elegir deshabilitar solo los informes mientras un dispositivo está conectado a su máquina de desarrollo con el siguiente código.

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

Answer 7

La respuesta elegida ya no es correcta. Google cambió la integración de Crashlytics. Mi versión actual es 2.9.1 y lo único que tenía que hacer es agregar la implementation ''com.crashlytics.sdk.android:crashlytics:2.9.1'' a mi archivo Gradle. No se requieren más cosas, bueno, pero esto significa que Crashlytics siempre se está ejecutando.

Solución 1

Solo compila Crashlytics en versión de lanzamiento:

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

Solucion 2

Si desea configurar Crashlytics adicionalmente, entonces la Solución 1 no funciona, ya que las clases de Crashlytics no se encontrarán en Debug Builds. Así que cambia la implementación de Gradle de nuevo a:

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

Luego vaya a su Manifiesto y agregue la siguiente etiqueta de meta-data dentro de la etiqueta de la application :

<application
        android:name="...>

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

...

</application>

Agregue a su actividad de lanzamiento (solo se requiere una vez, no todas las actividades)

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

Esto solo habilitará Crashlytics en las versiones de lanzamiento. Tenga cuidado, también verifique BuildConfig.DEBUG cuando configure Crashlytics, por ejemplo:

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

Mejor paul

Answer 8

Marc de Crashlytics aquí. ¡Aquí hay un par de maneras de deshabilitar Crashlytics mientras estás haciendo tus versiones de depuración!

1. Use una versión diferente de android: versionString para las compilaciones de depuración y lanzamiento y luego deshabilite los informes de fallas desde el panel web de Crashlytics para la versión de depuración.

2. Envuelva la llamada a Crashlytics.start () en una instrucción if que verifique un indicador de depuración. Puede usar una bandera personalizada o un enfoque como los que se proponen aquí: ¿Cómo verificar si APK está firmado o "construir compilación"?

Answer 9

Otra forma si solo desea hacerlo en su IDE es cerrar la sesión del complemento. Aparentemente, dejará de enviar informes mientras estás generando compilaciones sin volver a iniciar sesión.

Answer 10

Podemos usar el método isDebuggable () de la tela.

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

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

Feliz codificacion :)

Answer 11

Según Google, use este código para deshabilitar Crashlytics y también mejorará el proceso de construcción.

referencia- https://developer.android.com/studio/build/optimize-your-build

Answer 12

Si desea capturar todos los bloqueos (para las compilaciones de depuración y lanzamiento) pero quiere separarlos en el Panel de control de Crashlytics, puede agregar esta línea de código a build.gradle:

debug {
    versionNameSuffix "-DEBUG"
}

Por ejemplo, si el nombre de la versión de su aplicación es 1.0.0, sus compilaciones de lanzamiento se etiquetarán como 1.0.0, mientras que las compilaciones de depuración serán 1.0.0-DEBUG

Answer 13

Si desea una versión de lanzamiento debuggable, aquí está la manera:

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

Cuando establezca debuggable true su BuildConfig.DEBUG se inicializará con true, por eso agregué esa variable en la clase BuildConfig.

Tela Inicial:

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

Answer 14

Si le preocupa que BuildConfig.DEBUG no se configure correctamente, use ApplicationInfo lugar:

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

Answer 15

Si usas Gradle solo agrega esto a un sabor:

ext.enableCrashlytics = false

Answer 16

Tenga en cuenta que también puede deshabilitar la carga molesta de símbolos en la compilación de depuración:

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

Solo póngalo en el build.gradle de su módulo de aplicación.

Answer 17

Un problema extraño que encontré: seguí la respuesta de (que también aparece en el sitio web oficial) y no funcionó. Resultó que estaba BuildConfig referencia a BuildConfig en el paquete de Fabric, que también contiene una variable DEBUG estática que se estableció en false incluso en el modo de depuración.

Entonces, si sigue la solución mencionada y aún recibe informes de depuración, asegúrese de que está haciendo referencia a esto:

import com.yourpackagename.BuildConfig;

Y no esto:

import io.fabric.sdk.android.BuildConfig;    

Answer 18

Usa sabores o crea configuraciones. Use un identificador de compilación separado para la compilación de desarrollo y todos sus bloqueos continuarán yendo a una aplicación separada. Puede ser útil en caso de compartir la compilación con compañeros o usarla sin un depurador. Algo como esto -

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

    production {
        applicationId "io.yourapp.app"
    }

Answer 19

Use esto en MyApplication#onCreate()

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

EDITAR Si actualizó a Fabric, use esta answer lugar.

Answer 20

Versión actualizada más fácil cuando se usa Gradle para construir:

if (!BuildConfig.DEBUG) {
    Fabric.with(this, new Crashlytics());
}

Utiliza la nueva sintaxis incorporada de Fabric for Crashlytics y funciona automáticamente con una compilación de Gradle.