Descubre las novedades de Firebase en Google I/O 2022. Más información

Actualiza al SDK de Firebase Crashlytics

Ahora puedes configurar Crashlytics en tu app con el nuevo SDK oficial de Firebase Crashlytics, que ofrece API mejoradas que son más coherentes con otros productos de Firebase y más intuitivas de usar.

En esta guía, se describe cómo realizar la actualización al nuevo SDK desde el SDK heredado de Fabric. También se describen los cambios que traen las nuevas API, el motivo de los cambios y cómo actualizar tu código, si es necesario.

Antes de comenzar

El SDK de Firebase Crashlytics usa AndroidX como dependencia. Por ello, si tu app usa versiones anteriores de la biblioteca de compatibilidad de apps, primero debes migrar tu app a AndroidX.

Paso 1: Agrega un archivo de configuración de Firebase

Abre la Configuración del proyecto. En la tarjeta Tus apps, selecciona el nombre del paquete de la app cuyo archivo de configuración necesitas.
Haz clic en Descargar google-services.json a fin de obtener el archivo de configuración de Firebase para Android (google-services.json).
- Puedes volver a descargar el archivo de configuración de Firebase para Android cuando quieras.
- Asegúrate de que no se hayan agregado caracteres adicionales, como (2), al nombre del archivo de configuración.
Transfiere tu archivo de configuración al directorio del módulo (nivel de app) de tu app.

Paso 2: Agrega el SDK de Firebase Crashlytics

En el nivel de raíz de tu app (nivel de proyecto) build.gradle:

Reemplaza el repositorio Maven de Fabric por el repositorio Maven de Google.
Reemplaza el complemento de Fabric para Gradle por el de Firebase Crashlytics. Si usas Android Studio 4.1 Canary, asegúrate de agregar la versión 2.0.0 del complemento de Crashlytics para Gradle (o una versión posterior).

buildscript {
  // ...

  repositories {
    // ...

    // Remove Fabric's Maven repository
    maven { url 'https://maven.fabric.io/public' }

    // Add Google's Maven repository (if it's not there already)
    google()
  }

  dependencies {
    // ..

    // Add the Google Services Gradle plugin (if it's not there already)
    classpath 'com.google.gms:google-services:4.3.10'

    // Remove the Fabric Gradle plugin
    classpath 'io.fabric.tools:gradle:1.31.2'

    // Add the Crashlytics Gradle plugin (use v2.0.0+ if you built
    // your app with Android Studio 4.1).
    classpath 'com.google.firebase:firebase-crashlytics-gradle:2.8.1'
  }
}

En tu build.gradle de nivel de app, reemplaza el complemento de Fabric por el de Firebase Crashlytics:

apply plugin: 'com.android.application'

// Apply the Google Services plugin (if it's not there already)
apply plugin: 'com.google.gms.google-services'

// Remove the Fabric plugin
apply plugin: 'io.fabric'

// Add the Firebase Crashlytics plugin
apply plugin: 'com.google.firebase.crashlytics'

Por último, agrega el SDK de Firebase Crashlytics. En tu build.gradle de nivel de app, reemplaza el SDK de Crashlytics heredado de Fabric por el nuevo SDK de Firebase Crashlytics. Asegúrate de agregar la versión 17.0.0 o posterior (a partir del 15 de noviembre de 2020, esto es necesario para que se muestren tus informes de fallas en Firebase console).

Recomendación: Para obtener una experiencia óptima con Firebase Crashlytics, recomendamos que también agregues el SDK de Firebase para Google Analytics a tu app (asegúrate de agregar la versión 17.2.3 o una posterior a fin de obtener información en tiempo real sobre los usuarios que no experimentaron fallas y las rutas de navegación).
```
dependencies {
  // Remove the Fabric Crashlytics SDK
  implementation 'com.crashlytics.sdk.android:crashlytics:2.10.1'

  // Add the Firebase Crashlytics SDK
  implementation 'com.google.firebase:firebase-crashlytics:18.2.7'

  // Recommended: Add the Google Analytics SDK
  implementation 'com.google.firebase:firebase-analytics:20.0.2'
}
```

Configura los informes de fallas del NDK (opcional)

Firebase Crashlytics ofrece informes de fallas para apps compiladas con el kit de desarrollo nativo (NDK) de Android.

Para detectar e informar las fallas por errores en el código nativo, haz lo siguiente:

En tu build.gradle de nivel de app, reemplaza la dependencia del NDK de Fabric por la dependencia del NDK de Firebase Crashlytics. Luego, agrega la extensión firebaseCrashlytics y asegúrate de habilitar la marca nativeSymbolUploadEnabled. Esto permite que tu app procese y suba símbolos nativos a Crashlytics para que puedas ver los seguimientos de pila correctamente simbolizados en el panel de Crashlytics.

dependencies {
  // Remove the Fabric NDK dependency
  implementation 'com.crashlytics.sdk.android:crashlytics-ndk:2.1.1'

  // Add the Firebase Crashlytics NDK dependency
  implementation 'com.google.firebase:firebase-crashlytics-ndk:18.2.7'
}
// ...

android {
    // ...

    buildTypes {
        release {
            /* Add the firebaseCrashlytics extension (by default,
            * it's disabled to improve build speeds) and set
            * nativeSymbolUploadEnabled to true. */

            firebaseCrashlytics {
                nativeSymbolUploadEnabled true
            }
        }
    }
}

// Remove this extension (it previously enabled Crashlytics NDK reporting in Fabric)
crashlytics {
  enableNdk true
}

Ejecuta las siguientes tareas de Gradle específicas del NDK:

> ./gradlew app:assembleBUILD_VARIANT
> ./gradlew app:uploadCrashlyticsSymbolFileBUILD_VARIANT

Si necesitas más información sobre cómo usar Crashlytics para los informes de fallas del NDK, consulta la documentación del NDK de Crashlytics.

Paso 3: Actualiza tu código

Revisa los siguientes cambios del SDK y realiza las actualizaciones correspondientes en tu código:

Crashlytics ahora rota los ID en función de los ID de instalación de Firebase

Crashlytics usa el UUID de instalación de Crashlytics para identificar instancias de tu app y asociar los datos de los usuarios con sus dispositivos. Anteriormente, Crashlytics rotaba el UUID de instalación del usuario cuando cambiaba el ID de publicidad de su dispositivo. Ahora Crashlytics rota el UUID de instalación según el ID de instalación de Firebase (FID) del usuario. Para obtener más información, consulta cómo administrar los ID de instalación de Firebase.

Motivo del cambio

El uso de FID es coherente con otros SDK de Firebase.

El nuevo paquete y nombre de clase para Crashlytics es com.google.firebase.crashlytics.FirebaseCrashlytics

Ahora puedes invocar funciones de Crashlytics con métodos de instancia en el singleton de FirebaseCrashlytics en lugar de funciones estáticas en la clase de FirebaseCrashlytics. Se puede acceder de forma global al singleton de FirebaseCrashlytics mediante la función estática getInstance().

SDK de Fabric

Java

import com.crashlytics.android.Crashlytics;

// ...

// Operations on Crashlytics.
Crashlytics.someAction()

Kotlin+KTX

import com.crashlytics.android.Crashlytics

// ...

// Operations on Crashlytics.
Crashlytics.someAction()

SDK de Firebase Crashlytics

Java

import com.google.firebase.crashlytics.FirebaseCrashlytics;

// ...

// Operations on FirebaseCrashlytics.
FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();
crashlytics.someAction();

Kotlin+KTX

import com.google.firebase.crashlytics.FirebaseCrashlytics

// ...

// Operations on FirebaseCrashlytics.
val crashlytics = FirebaseCrashlytics.getInstance()
crashlytics.someAction()

Motivo del cambio

El paquete de raíz y el punto de entrada del nuevo SDK ahora son coherentes con otros SDK de Firebase. Además, los métodos de instancia son más fáciles de simular que las funciones estáticas y crean menos desafíos de prueba.

FirebaseCrashlytics ya no funciona con el SDK de Fabric

Ahora Crashlytics se inicia automáticamente con un ContentProvider definido en el nuevo SDK de Firebase Crashlytics, que ya no usa la clave de API de Fabric. Crashlytics ahora usa el archivo google-services.json de tu app para asociarla con tu proyecto de Firebase y conservar los datos de fallas históricas.

Si tienes la clave de API de Fabric (io.fabric.ApiKey) declarada en tu archivo AndroidManifest.xml, quítala:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.example.your_app_package">

   <application>
      <activity android:name=".MainActivity"/>

      <!-- Remove this line if it exists -->
      <meta-data android:name="io.fabric.ApiKey"
          android:value="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" />

   </application>
</manifest>

De forma predeterminada, Crashlytics recopila e informa automáticamente las fallas de todas las instancias de la app, pero puedes elegir habilitar esta función solo para los usuarios que la acepten. Para desactivar el informe de fallas automático, configura firebase_crashlytics_collection_enabled como false en el bloque <application> de tu archivo AndroidManifest.xml:

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

Motivo del cambio

Para ser coherente con otros SDK de Firebase, Crashlytics ahora se inicia automáticamente a través de un ContentProvider. Al igual que con otros SDK, ahora proporciona una marca de manifiesto para inhabilitar la recopilación automática de datos, la cual puedes anular en cualquier momento mediante setCrashlyticsCollectionEnabled. El método te brinda más control sobre el comportamiento de los informes de fallas de tu app.

Crashlytics.log ahora es un método de instancia

El SDK nuevo ya no incluye un método Crashlytics.log estático. Para agregar mensajes de registro personalizados, usa el nuevo método de instancia crashlytics.log. Ten en cuenta que el nuevo método ya no muestra mensajes en logcat (te recomendamos que escribas un wrapper si quieres mantener este comportamiento). Para obtener más información, visita Agrega mensajes de registro personalizados.

SDK de Fabric

Java

Crashlytics.log("my message");

Crashlytics.log(
 Log.ERROR,
 "TAG",
 "my message");

Kotlin+KTX

Crashlytics.log("my message")

Crashlytics.log(
 Log.ERROR,
 "TAG",
 "my message")

SDK de Firebase Crashlytics

Java

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

crashlytics.log("my message");

// To log a message to a crash report, use the following syntax:
crashlytics.log("E/TAG: my message");

Kotlin+KTX

val crashlytics = FirebaseCrashlytics.getInstance()

crashlytics.log("my message")

// To log a message to a crash report, use the following syntax:
crashlytics.log("E/TAG: my message")

Motivo del cambio

A pedido de los usuarios, dejamos de repetir los registros de Crashlytics en logcat. El uso de métodos de instancia también facilita probar el código.

Se agregaron setBool, setDouble, setFloat, setInt, setLong y setString a setCustomKey

Agregamos los métodos set de claves personalizadas al método setCustomKey. Anteriormente, se podían usar los métodos set de claves personalizadas para establecer pares clave-valor y enviarlos junto con el informe de fallas. Ahora, puedes usar setCustomKey(String, value), que se sobrecarga para aceptar tipos básicos y de string. Para obtener más información, consulta Agrega claves personalizadas.

SDK de Fabric

Java

Crashlytics.setBool("bool_key",true);

Crashlytics.setDouble("double_key",42.0);

Crashlytics.setFloat("float_key",42.0F);

Crashlytics.setInt("int_key",42);

Crashlytics.setLong("long_key",42L);

Crashlytics.setString("str_key","str_value");

Kotlin+KTX

Crashlytics.setBool("bool_key",true)

Crashlytics.setDouble("double_key",42.0)

Crashlytics.setFloat("float_key",42.0F)

Crashlytics.setInt("int_key",42)

Crashlytics.setLong("long_key",42L)

Crashlytics.setString("str_key","str_value")

SDK de Firebase Crashlytics

Java

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

crashlytics.setCustomKey("bool_key",true);

crashlytics.setCustomKey("double_key",42.0);

crashlytics.setCustomKey("float_key",42.0F);

crashlytics.setCustomKey("int_key",42);

crashlytics.setCustomKey("long_key",42L);

crashlytics.setCustomKey("str_key","42");

Kotlin+KTX

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance()

crashlytics.setCustomKey("bool_key",true)

crashlytics.setCustomKey("double_key",42.0)

crashlytics.setCustomKey("float_key",42.0F)

crashlytics.setCustomKey("int_key",42)

crashlytics.setCustomKey("long_key",42L)

crashlytics.setCustomKey("str_key","42")

Motivo del cambio

El nombre del método nuevo es exclusivo de Crashlytics y deja en claro que Crashlytics no cumple con el formato clave-valor.

setUserIdentifier ahora es setUserId, y se quitaron setUserName y setUserEmail

Anteriormente, podías configurar un nombre o correo electrónico asociado con una falla mediante setUserName y setUserEmail, pero estos métodos ya no están definidos. A fin de establecer ID para los usuarios ahora se prefiere el método setUserId. Para obtener más información, visita Configura identificadores de usuario.

SDK de Fabric

Java

Crashlytics.setUserIdentifier("myAppUserId");

Crashlytics.setUserEmail("abc@example.com");

Crashlytics.setUserName("John Doe");

Kotlin+KTX

Crashlytics.setUserIdentifier("myAppUserId")

Crashlytics.setUserEmail("abc@example.com")

Crashlytics.setUserName("John Doe")

SDK de Firebase Crashlytics

Java

crashlytics.setUserId("myAppUserId");

Kotlin+KTX

crashlytics.setUserId("myAppUserId")

Motivo del cambio

Adoptamos el nombre de método setUserId para que sea coherente con otras API de Firebase y quitamos setUserName y setUserEmail a fin de evitar el registro de PII a través de Crashlytics.

Se reemplazó Crashlytics.logException(Throwable) por FirebaseCrashlytics.recordException(Throwable)

Ahora Crashlytics también admite el registro de los tipos de errores y excepciones integrados para las apps para Apple y Android.

SDK de Fabric

Java

try {
/* Code that can throw checked
exceptions. */

// ...

} catch (Exception e) {
Crashlytics.logException(e);
}

Kotlin+KTX

try {
/* Code that can throw checked
exceptions. */

// ...

catch (e: Exception) {
Crashlytics.logException(e)
}

SDK de Firebase Crashlytics

Java

try {
/* Code that can throw checked
exceptions. */

// ...

} catch (Exception e) {
FirebaseCrashlytics.getInstance().recordException(e);
}

Kotlin+KTX

try {
/* Code that can throw checked
exceptions. */

// ...

catch (e: Exception) {
FirebaseCrashlytics.getInstance().recordException(e)
}

Motivo del cambio

El nuevo método recordException(Throwable) se distingue más fácilmente de log(String), que se comporta de manera diferente. Además, cambiamos el nombre de la nueva API para que sea más coherente en todas las plataformas.

Se reemplazó CrashlyticsListener por didCrashOnPreviousExecution()

Anteriormente, CrashlyticsListener permitía que Crashlytics indicara cuando una sesión de app anterior terminaba por una falla, lo cual es útil para las apps que muestran mensajes posteriores a una falla al momento de reiniciarlas. Ahora, su devolución de llamada se reemplaza por la llamada síncrona didCrashOnPreviousExecution() a la API.

SDK de Fabric

Java

CrashlyticsListener crashlyticsListener =
new CrashlyticsListener() {
  @Override
  public void crashlyticsDidDetectCrashDuringPreviousExecution() {
    // ...App code to execute if a crash occurred during previous execution.
  }
};

CrashlyticsCore crashlyticsCore = new CrashlyticsCore.Builder()
                                      .listener(crashlyticsListener)
                                      .build();

Crashlytics crashlytics = new Crashlytics.Builder().core(crashlyticsCore).build();

Fabric.with(getContext(), crashlytics);

Kotlin+KTX

val crashlyticsListener = CrashlyticsListener {
  // ...App code to execute if a crash occurred during previous execution.
}
val crashlyticsCore = CrashlyticsCore.Builder()
  .listener(crashlyticsListener)
  .build()
val crashlytics = Crashlytics.Builder().core(crashlyticsCore).build()
Fabric.with(getContext(), crashlytics)

SDK de Firebase Crashlytics

Java

if (FirebaseCrashlytics.getInstance().didCrashOnPreviousExecution()) {
// ...App code to execute if a crash occurred during previous execution.
}

Kotlin+KTX

if (FirebaseCrashlytics.getInstance().didCrashOnPreviousExecution()) {
// ...App code to execute if a crash occurred during previous execution.
}

Motivo del cambio

La API nueva es más concisa y más sencilla de usar que CrashlyticsListener, porque no requiere texto estándar ni una devolución de llamada. Anteriormente, la devolución de llamada asíncrona no garantizaba cuándo se invocaría la devolución de llamada.

Se quitó el método crash

El nuevo SDK ya no incluye el método de falla, en el cual podías forzar una falla en tu app para validar la configuración de Crashlytics. Para generar una falla, arroja un RuntimeException.

SDK de Fabric

Java

Crashlytics.getInstance().crash();

Kotlin+KTX

Crashlytics.getInstance().crash()

SDK de Firebase Crashlytics

Java

throw new RuntimeException("Test Crash");

Kotlin+KTX

throw RuntimeException("Test Crash")

Motivo del cambio

Los nuevos métodos especifican claramente si las fallas resultantes de tu app ocurrieron durante el tiempo de ejecución o en el SDK nativo de la app.

El complemento de Crashlytics para Gradle contiene marcas nuevas

El complemento de Gradle aún configura y ejecuta automáticamente tareas de Gradle específicas de Crashlytics. Si tu compilación requiere invocar tareas del complemento Gradle de Crashlytics, ejecuta ./gradlew app:tasks para consultar las tareas de Firebase Crashlytics disponibles. Si tu app usa un NDK, debes invocar explícitamente la tarea de Gradle uploadCrashlyticsSymbolFile[BUILD_VARIANT] para continuar subiendo símbolos nativos a Crashlytics.

Las marcas de compilación específicas de Crashlytics ext.alwaysUpdateBuildId y ext.enableCrashlytics ya no son compatibles. Si existen, quítalas de la configuración de Gradle. Si tu app usa un ofuscador de código de bytes (p. ej., R8 o Proguard) y no quieres subir el archivo de asignación de tu compilación a Crashlytics, usa la nueva marca mappingFileUploadEnabled en la extensión firebaseCrashlytics de Gradle. Cuando se configura como falso, Crashlytics no puede desofuscar los seguimientos de pila de la app. Para configuraciones de ofuscación no estándar, usa el parámetro mappingFile a fin de establecer una ubicación nueva para el archivo de asignación. Estas marcas se pueden usar para defaultConfig, así como para cualquier tipo de compilación o variante.

SDK de Firebase Crashlytics

apply plugin: 'com.android.application'
apply plugin: 'com.google.firebase.crashlytics'
apply plugin: 'com.google.gms.google-services'

android {
    // ...

    buildTypes {
        debug {
            minifyEnabled true
            firebaseCrashlytics {
                // If you don't need crash reporting for your debug build,
                // you can speed up your build by disabling mapping file uploading.
                mappingFileUploadEnabled false
            }
        }

        release {
            minifyEnabled true
            // When minifyEnabled is set to true, Crashlytics automatically
            // uploads mapping files because the plugin detects that obfuscation
            // is enabled. mappingFileUploadEnabled defaults to true if
            // minifyEnabled is true.
        }
    }
}

Motivo del cambio

Actualizamos las tareas y opciones de configuración de Gradle para que sean más coherentes con las convenciones de Gradle.

Crashlytics solo puede usar los datos que recopila Google Analytics

Una vez que actualices al SDK de Firebase Crashlytics, ya no podrás recopilar datos con Fabric Answers. Para obtener métricas de rutas de navegación y usuarios que no experimentaron fallas, cambia a Google Analytics. Ten en cuenta que los datos históricos de Answers no se pueden migrar a Firebase.

Consulta los primeros pasos para usar Google Analytics si necesitas información sobre cómo agregar este servicio a tu app.

Motivo del cambio

Ahora ofrecemos Google Analytics para ayudarte a recopilar datos de fallas más detallados. Con Analytics, puedes seguir recopilando estadísticas de tu app en Firebase console.

Próximos pasos

Prueba la implementación. Para ello, fuerza una falla de prueba que envíe un informe de fallas al panel de Crashlytics en Firebase console.
Personaliza la configuración de informes de fallas agregando informes, registros y claves opcionales, así como seguimiento de errores recuperables.
Agrega Google Analytics a tu app. Combina la potencia de Google Analytics con Firebase Crashlytics para ver estadísticas de los usuarios sin fallas en Firebase console.