Cómo deshabilitar Crashlytics durante el desarrollo

245

¿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

Miguel
fuente
¿Has intentado simplemente eliminar tu clave de API del manifiesto? No recuerdo si eso es un bloqueo.
Timmetje
@timmied Se bloquea. También comentar toda la línea en la Manifestaplicación bloquea la aplicación, por lo que la pregunta es un poco más legítima.
Michael

Respuestas:

172

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

marcr
fuente
55
@marcr ¿Qué tal simplemente usando BuildConfig.DEBUG?
dannyroa
3
@dannyroa BuildConfig.DEBUG no es un indicador estándar que funcione en todos los entornos de compilación. Creo que se establece de manera consistente cuando se construye con Eclipse y ADT, pero no en otro lugar.
marzo
11
BuildConfig.DEBUGdebe usarse si está construyendo usando Gradle. Siempre se generará correctamente.
Austyn Mahoney
3
@marcr ¿qué tal en la última versión de crashlytics (ya que parece fusionada con Fabric), ¿realiza la biblioteca un control interno BuildConfig.DEBUG?
akhy
2
@akhyar No se verifica automáticamente, uso: if (! BuildConfig.DEBUG) {Fabric.with (this, new Crashlytics ());}
Björn Kechel
387

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
    }
}
xialin
fuente
2
Esto es mucho más agradable de usar y detendrá el bloqueo de su aplicación si realiza llamadas a Crashlytics en su código, fuera de su clase de aplicación.
speedynomads
1
Se desactivó en Crashlytics 2.3.0 :(
Damian Walczak
1
ext.enableCrashlytics = false tampoco funciona para mí con 2.5. En realidad, nunca funcionó. Incluso antes de la tela.
Bao-Long Nguyen-Trong
2
Tengo una preocupación aquí. ¿Esto habilitará Answer y Beta? Parece que esto debería ser más correcto: CrashlyticsCore core = new CrashlyticsCore.Builder (). Disabled (BuildConfig.DEBUG) .build (); Fabric.with (this, new Answers (), new Beta (), new Crashlytics.Builder (). Core (core) .build ());
gbero
1
ext.enableCrashlytics = false no se bloquea si usa esto correctamente. La forma de superar el bloqueo se encuentra en la documentación de Fabrics: docs.fabric.io/android/crashlytics/build-tools.html .
Frank
46

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");
}
Paul Spiesberger
fuente
2
Esto parece limpio. En lugar de inicializar en la actividad principal, ¿cuándo no en la instancia de la Aplicación?
Julio
Indican en el sitio web: Enable collection for selected users by initializing Crashlytics from one of your app's activitiespero supongo que no cambia mucho si inicializa Crashlytics en la aplicación. ¿Lo intentaste? Si funciona, entonces puedo agregarlo a mi respuesta. firebase.google.com/docs/crashlytics/customize-crash-reports
Paul Spiesberger
2
No pude hacer funcionar ninguna de las otras soluciones para deshabilitar crashlytics en tiempo de ejecución. La solución 1 funcionó perfectamente, ¿por qué no pensé en eso?
Gracias por la solucion. Cuando configuro firebase_crashlytics_collection_enabledfalso en manifiesto, el bloqueo no aparece en la consola (uso v2.9.9). Así que arreglé esto agregando un manifiesto separado para la compilación de depuración con firebase_crashlytics_collection_enabled=falsey truepara el lanzamiento
Vasily Kabunov
30

Si usa Gradle, simplemente agregue esto a un sabor:

ext.enableCrashlytics = false
usuario1998494
fuente
1
eso es solo por sabor? ¿Qué pasa con la depuración frente a la liberación? Traté de deshabilitar para depurar pero aún así envié el bloqueo
xialin
Creo que solo funciona en sabores. OMI usando la bandera que Austyn y Marcc señalaron es la más fácil.
user1998494
Encontré la solución. pero no estoy seguro si es compatible con los viejos Crashlytics. es para el nuevo Crashlytics en Fabric SDK. compruebe mi respuesta a continuación
xialin
1
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í: stackoverflow.com/questions/28339323/…
Aphex
18
Esto causó un accidente ... " This app relies on Crashlytics."
Sakiboy
27

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);
Abhishek Patidar
fuente
Lo intenté de esta manera, y todavía la aplicación fallaThis app relies on Crashlytics. Please sign up for access at
Balflear
Supongo que te falta ext.enableCrashlytics = falseen build.gradle.
Abhishek Patidar
No, he agregado el tipo de compilación de depuración en el archivo build.gradle, está en el buildTypes -> debug, also i'm applying the plugin via complemento de aplicación: 'io.fabric'`
Balflear
No estoy seguro de por qué esta solución fue votada incluso 24 veces. Se bloquea conThis app relies on Crashlytics. Please sign up for access at https://fabric.io/sign_up
TROD
24

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.

fahmy
fuente
17

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)
Albert Vila Calvo
fuente
Creo que android:value="false"tiene que cambiarse a android:value="${enableCrashlytics}". ¿No es así?
JaydeepW
Otra ventaja con la Opción # 2 es que comienza con la recopilación de análisis inicialmente deshabilitada, y luego puede preguntarle al usuario primero que está bien rastrear el uso de su aplicación (piense en GDPR). Entonces solo haría la llamada Fabric.with si el usuario consintió en el seguimiento.
Por Christian Henden
El único inconveniente de la opción # 2, es que todavía crea versiones de depuración en el panel de Firebase, a pesar de que no se mostrarán bloqueos allí (ya que están deshabilitados). Esto genera dos problemas: primero, hace que sea más difícil encontrar versiones de lanzamiento; segundo: el panel de Firebase muestra solo las últimas 100 versiones , lo que puede evitar que vea fallas en algunas versiones antiguas. En el panel de Fabric puede deshabilitar una versión en particular, esto no es posible en el panel de Firebase.
Alex Lipov
14

Use esto en MyApplication#onCreate()

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

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

Austyn Mahoney
fuente
BuildConfig.DEBUG no siempre se establece correctamente. Confiar en él para habilitar / deshabilitar Crashlytics me causó algunos problemas mientras usaba IntelliJ.
Zeb Barnett
55
¿Qué herramientas de compilación estás usando? Gradle SIEMPRE establecerá ese valor. Fue un problema hace un año, pero las nuevas herramientas de compilación son mucho mejores.
Austyn Mahoney
Estoy en v0.9. + Del complemento Gradle para IntelliJ y v1.11 para el propio Gradle.
Zeb Barnett
No he visto ningún problema en ninguna de mis aplicaciones. BuildConfiges generado por una tarea de Gradle, que se garantiza su ejecución. También uso buildConfigFieldpara configurar campos personalizados y esos siempre funcionan. tools.android.com/recent/androidstudio045released también sugiere que lo use BuildConfig.DEBUG.
Austyn Mahoney
Como idealista, seguro que me gustaría poder usarlo, ya que simplificaría el proceso de construcción no bastante automatizado para la pequeña empresa para la que trabajo. Es solo que lanzamos a producción una versión que dependía de esa bandera y Crashlytics nunca la vio en vivo. Después de que volvimos a alternarlo manualmente, Crashlytics lo vio de inmediato.
Zeb Barnett
9

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}" />
arbuz
fuente
6

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.

Ariel Cabib
fuente
6

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

Khronos
fuente
¿Eso es todo? No hay necesidad de hacer sabores?
portfoliobuilder
6

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());
}
William henderson
fuente
Está incorrecto. Registro excepciones no fatales en mi código usando Crashlytics.logException(e)y esta declaración arroja una excepción en las compilaciones de depuración porque el singleton de Fabric no está inicializado. Si usa Crashlytics, siempre inicialice Fabric Singleton. Ver la respuesta de fahmy .
naXa
5

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
    }
Kvant
fuente
3

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.

Björn Kechel
fuente
3

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;    
Neria Nachum
fuente
2

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 );
Vaiden
fuente
2

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"
    }
ribhu
fuente
2

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);
M. Reza Nasirloo
fuente
¿Cuál es el propósito ext.enableCrashlyticsy ext.alwaysUpdateBuildIdya que no parecen estar referenciados en ninguna parte? ¿Me estoy perdiendo de algo?
Julio
@jules Está en los documentos docs.fabric.io/android/crashlytics/build-tools.html
M. Reza Nasirloo
BuildConfig.BUILD_TYPE_DEBUG es redundante, BuildConfig.DEBUG puede usarse para obtener el mismo valor
Antonis Radz
@AntonisRadz Porque necesitaba una versión de lanzamiento depurable
M. Reza Nasirloo
1

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

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

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

Feliz codificación :)

sadiq
fuente
1

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.

josias
fuente
1

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

thanhbinh84
fuente
1

Este trabajo para mi:

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

y en buildTypes:

debug {
ext.enableCrashlytics = false
}
Amirhosein Heydari
fuente
¿Qué hay de los usos de Crashlytics en el código? Te dará errores de compilación.
Micer
1

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

  1. 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)

Viktor Ivanov
fuente
0

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.

Neteinstein
fuente
0
  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" />
100rbh
fuente
0

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.

Will Calderwood
fuente
-8

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

Tej42
fuente