Cómo deshabilitar Crashlytics durante el desarrollo

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

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

Por otro lado, no quiero comentar Crashlytics.start()y posiblemente me arriesgue a olvidar descomentarlo y comprometerme

Marc de Crashlytics aquí. ¡Aquí hay un par de formas de deshabilitar Crashlytics mientras realiza las compilaciones de depuración!

1. Use un Android diferente: versionString para depurar y liberar compilaciones 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 verifica un indicador de depuración. Puede usar un indicador personalizado o un enfoque como los propuestos aquí: ¿Cómo verificar si el APK está firmado o "compilación de depuración"?

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

Ponga 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 superior, 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 del método obsoleto de Crashlytics deshabilitado () )

EDIT2:

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

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

La respuesta elegida ya no es correcta. Google cambió la integración de Crashlytics. Mi versión actual es 2.9.1y lo único que tuve que hacer es agregar 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 la versión de lanzamiento:

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

Solución 2

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

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

Luego vaya a su Manifiesto y agregue la siguiente meta-dataetiqueta dentro de la applicationetiqueta:

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

Si usa Gradle, simplemente agregue esto a un sabor:

ext.enableCrashlytics = false

Mira el último documento. https://docs.fabric.io/android/crashlytics/build-tools.html#gradle-advanced-setup .

Además de agregar ext.enableCrashlytics = falsebuild.grade, debes hacerlo,

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

Encontré que esta 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 enableCrashlyticsen el BuildConfigarchivo que puede usar para decidir si iniciar Fabrico no:

    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 debe poner llamadas a métodos estáticos en la Crashlyticsclase en un ifbloque que verifique 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 un Must Initialize Fabric before using singleton()error al probar en el emulador.

Respuesta 2019

He estado tratando de habilitar Crashlytics solo en la versión y deshabilitarlo en la depuración durante 2 horas, comprobando la consola de Firebase para ver si las Excepciones estaban cargadas o no.

Hay 2 formas posibles de hacer esto.

OPCIÓN 1

Funciona, pero si llama a cualquier Crashlyticsmétodo de compilación de depuración, la aplicación se bloqueará .

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

OPCION 2

Una alternativa si eso le permite llamar a Crashlyticsmétodos sin verificar BuildConfig.DEBUGprimero. Con esta configuración, puede llamar con seguridad a métodos como Crashlytics.logException(): simplemente no hacen nada en las compilaciones de depuración. No veo que los informes se carguen en depuración.

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

Aplicación onCreate ()

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

Use esto en MyApplication#onCreate()

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

EDITAR Si actualizó a Fabric, use esta respuesta en su lugar.

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

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

Otra solución simple que me gusta, porque no requiere diferentes archivos de manifiesto:

Paso 1: defina marcadores de posición de manifiesto en build.gradle

android {
    ...
    buildTypes {
        release {
            manifestPlaceholders = [crashlytics:"true"]
        }
        debug {
            manifestPlaceholders = [crashlytics:"false"]
        }
    }
    ...
}

Paso 2: úsalos en tu AndroidManifest.xml

<meta-data
        android:name="firebase_crashlytics_collection_enabled"
        android:value="${crashlytics}" />

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

Simplemente colóquelo en el build.gradlemódulo de su aplicación.

Si desea capturar todos los bloqueos (para las versiones de depuración y lanzamiento) pero desea 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 versiones de lanzamiento se etiquetarán como 1.0.0, mientras que las versiones de depuración serán 1.0.0-DEBUG

Hay muchas buenas respuestas aquí, pero para mis pruebas uso compilaciones de depuración para versiones beta internas y pruebas fuera del laboratorio donde los registros de fallas 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 fallas rápidamente.

En lugar de eliminar TODOS los bloqueos de depuración, puede optar por desactivar 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());
}

El problema es que ninguna de las soluciones funciona para el último sdk de crashlytics. (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 al Crear 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
    }

La versión más fácil y actualizada al usar Gradle para compilar:

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

Utiliza la nueva sintaxis incorporada de Fabric para Crashlytics y funciona automáticamente con la construcción de Gradle.

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

Por lo tanto, si sigue la solución mencionada y aún recibe informes de depuración, asegúrese de hacer referencia a esto:

import com.yourpackagename.BuildConfig;

Y no esto:

import io.fabric.sdk.android.BuildConfig;    

Si le preocupa BuildConfig.DEBUGno estar configurado correctamente, use ApplicationInfoen su lugar:

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

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

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

    production {
        applicationId "io.yourapp.app"
    }

Si desea una versión de lanzamiento depurable, esta es la forma:

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 configura debuggable truesu BuildConfig.DEBUG se inicializará con verdadero, es por eso que agregué esa variable en la clase BuildConfig.

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

Podemos usar el método isDebuggable () de fabric.

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

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

Feliz codificación :)

Puede usar un archivo de manifiesto dedicado para el modo de depuración (funciona para mí con Crashlytics 2.9.7):

Cree el archivo app/src/debug/AndroidManifest.xmly agregue lo siguiente:

<application>

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

</application>

Tenga en cuenta que este elemento de metadatos se debe poner en debug / AndroidManifest.xml solamente , y no en el AndroidManifest.xml regulares

La solución que utiliza CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()no funcionó para mí, y descubrí que CrashlyticsInitProvider inicializa crashlytics antes de que se llame a Application.onCreate () o que se inicie cualquier actividad, lo que significa que inicializar manualmente la tela en la aplicación o una actividad no tiene efecto porque la tela ya está inicializada.

Paso 1: en build.grade

buildTypes {
        debug {
            debuggable true
            manifestPlaceholders = [enableCrashlytic:false]
        }
        release {
            debuggable false
            manifestPlaceholders = [enableCrashlytic:true]
        }
    }

Paso 2: en manifiesto

<meta-data
            android:name="firebase_crashlytics_collection_enabled"
            android:value="${enableCrashlytic}" />

Paso 3: en la aplicación o primera actividad

private void setupCrashReport() {
        if (BuildConfig.DEBUG) return;
        Fabric.with(this, new Crashlytics());
    }

No estoy seguro de si el paso 3 es necesario, pero para asegurarme de que la versión de lanzamiento funcione sin fallar. fuente: https://firebase.google.com/docs/crashlytics/customize-crash-reports#enable_opt-in_reporting

Este trabajo para mi:

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

y en buildTypes:

debug {
ext.enableCrashlytics = false
}

Hay dos opciones para deshabilitar Firebase Crashlytics para la siguiente versión com.google.firebase: firebase-crashlytics: 17.0.0:

1. Agregar metaetiqueta al manifiesto de la aplicación

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

O

2. Configure directamente en la aplicación (tenga en cuenta que cuando se establece en falso, el nuevo valor no se aplica hasta la próxima ejecución de la aplicación)

FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true)

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

1. Agregue esto al build.gradle de su aplicación:

   android {
       buildTypes {
           debug {
             // Disable fabric build ID generation for debug builds
             ext.enableCrashlytics = false
             ...

2. Deshabilita el kit Crashlytics en tiempo de ejecución. De lo contrario, el kit Crashlytics arrojará el 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. En AndroidManifest.xml, agregue

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

Respuesta de 2020 Post Fabric

Pegue el código a continuación en su clase de Aplicación y llame al método setCrashlyticsStatedesde su aplicación en Crear. Opcionalmente, también puede agregar sus ID de dispositivo de prueba al debugDevicesHashSet para que sus dispositivos personales puedan ser ignorados, incluso cuando se construye en modo de lanzamiento.

Nota. El ID del dispositivo devuelto porSettings.Secure.getString(getContext().getContentResolver(), Settings.Secure.ANDROID_ID);No se garantiza que la sea ​​única o constante (puede cambiar en un restablecimiento de fábrica o manualmente en un dispositivo rooteado). Pero debería ser lo suficientemente bueno.

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

Verifique que BuildConfig. está mirando la clase BuildConfig correcta. A menudo hay varias opciones y se puede arrastrar la incorrecta.

Esta es una respuesta tonta, lo sé.
Solo comente Fabric.with(this, new Crashlytics());, trabaje en eso y descomente cuando quiera lanzarlo.