Catch up on everthing we announced at this year's Firebase Summit. Learn more

Mettre à niveau vers le SDK Firebase Crashlytics

Vous pouvez désormais configurer Crashlytics dans votre application à l'aide du nouveau SDK officiel Firebase Crashlytics, qui propose des API améliorées, plus cohérentes avec les autres produits Firebase et plus intuitives à utiliser.

Ce guide explique comment effectuer une mise à niveau vers le nouveau SDK à partir de l'ancien SDK Fabric. Il décrit les modifications apportées avec les nouvelles API, la raison des modifications et comment mettre à jour votre code, si nécessaire.

Avant que tu commences

Le SDK Firebase Crashlytics utilise AndroidX comme une dépendance, donc si votre application utilise les anciennes versions de la bibliothèque de soutien App, d' abord migrer votre application à AndroidX .

Étape 1: Ajouter un fichier de configuration Firebase

  1. Ouvrez votre Paramètres du projet . Dans la carte Votre apps, sélectionnez le nom du package de l'application pour laquelle vous avez besoin d' un fichier de configuration.

  2. Cliquez sur Télécharger google-services.json pour obtenir votre fichier de configuration Firebase Android ( google-services.json ).

    • Vous pouvez télécharger le fichier de configuration Firebase Android à tout moment.

    • Assurez - vous que le nom du fichier de configuration n'est pas ajouté avec des caractères supplémentaires, comme (2) .

  3. Déplacez votre fichier de configuration dans le répertoire du module (au niveau de l'application) de votre application.

Étape 2: Ajouter le Firebase Crashlytics SDK

  1. Dans votre niveau racine de l' application (niveau du projet) build.gradle :

    • Remplacez le référentiel Maven de Fabric par le référentiel Maven de Google.

    • Remplacez le plug-in Fabric Gradle par le plug-in Firebase Crashlytics Gradle. Si vous utilisez Android 4.1 Studio de Canary, assurez - vous d'ajouter le plugin Gradle Crashlytics version 2.0.0 ou ultérieure.

    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'
      }
    }
    
  2. Dans votre niveau d'application build.gradle , remplacez le plugin tissu avec le plugin 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'
    
  3. Enfin, ajoutez le SDK Firebase Crashlytics. Dans votre niveau d'application build.gradle , remplacer l'héritage Tissu Crashlytics SDK avec le nouveau SDK Firebase Crashlytics. Assurez-vous d'ajouter la version 17.0.0 ou une version ultérieure (à partir du 15 novembre 2020, cela est nécessaire pour que vos rapports d'erreur s'affichent dans la console Firebase).

    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.5'
    
      // Recommended: Add the Google Analytics SDK
      implementation 'com.google.firebase:firebase-analytics:20.0.0'
    }
    

(Facultatif) Configuration de rapports d'accident NDK

Firebase Crashlytics propose des rapports de plantage pour les applications créées à l'aide du kit de développement natif Android (NDK).

Pour détecter et signaler les plantages natifs :

  1. Dans votre niveau d'application build.gradle fichier, remplacez la dépendance en tissu NDK avec la dépendance Firebase Crashlytics NDK. Ensuite, ajoutez la firebaseCrashlytics l' extension et assurez - vous de permettre au nativeSymbolUploadEnabled drapeau. Cela permet à votre application de traiter et de télécharger des symboles natifs à Crashlytics afin que vous puissiez voir les traces de pile correctement-symbolicated dans le tableau de bord 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.5'
    }
    // ...
    
    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
    }
    
  2. Exécutez les tâches Gradle spécifiques au NDK suivantes :

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

Pour plus d' informations sur l' utilisation Crashlytics pour les rapports d'accident NDK, consultez la documentation Crashlytics NDK .

Etape 3: Mettre à jour votre code

Examinez les modifications suivantes du SDK et apportez les mises à jour appropriées à votre code :


Crashlytics fait désormais pivoter les identifiants en fonction des identifiants d'installation de Firebase.

Crashlytics utilise l'UUID d'installation de Crashlytics pour identifier les instances de votre application et associer les données de vos utilisateurs à leurs appareils. Auparavant, Crashlytics faisait pivoter l'UUID d'installation de votre utilisateur lorsque l'ID publicitaire de son appareil changeait. Désormais, Crashlytics fait pivoter l'UUID d'installation en fonction de l'ID d'installation Firebase (FID) de l'utilisateur. Pour plus d' informations, visitez le site Gérer les ID d'installation Firebase .

Raison du changement

L'utilisation des FID est cohérente avec les autres SDK Firebase.


Le nouveau package et le nouveau nom de classe pour Crashlytics sont com.google.firebase.crashlytics.FirebaseCrashlytics.

Vous pouvez désormais appeler des fonctionnalités Crashlytics à l'aide de méthodes d'instance dans le singleton FirebaseCrashlytics au lieu de fonctions statiques dans la classe FirebaseCrashlytics. Le FirebaseCrashlytics singleton est globalement accessible par l'intermédiaire du getInstance() fonction statique.

Kit de développement logiciel (SDK) 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 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()

Raison du changement

Le package racine et le point d'entrée du nouveau SDK sont désormais cohérents avec les autres SDK Firebase. De plus, les méthodes d'instance sont plus faciles à simuler que les fonctions statiques et créent moins de problèmes de testabilité.


FirebaseCrashlytics ne fonctionne plus avec le SDK Fabric.

Désormais, Crashlytics démarre automatiquement à l'aide d'un ContentProvider défini dans le nouveau SDK Firebase Crashlytics, qui n'utilise plus la clé API Fabric. Crashlytics utilise maintenant votre application de google-services.json fichier à associer l'application à votre projet Firebase et conserver vos données d'accident historique.

Si vous avez la clé API Fabric ( io.fabric.ApiKey ) a déclaré dans votre AndroidManifest.xml fichier, retirez - le:

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

Par défaut, Crashlytics automatiquement collecte et rapports se bloque pour toutes les instances de votre application, mais vous pouvez choisir de l' activer uniquement pour les utilisateurs qui choisissent. Pour désactiver la mise automatique de collision, dans la <application> bloc de votre AndroidManifest.xml fichier, ensemble firebase_crashlytics_collection_enabled à false :

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

Raison du changement

Pour être cohérent avec les autres SDK Firebase, Crashlytics démarre désormais automatiquement via un ContentProvider. Comme avec d' autres SDKs, il fournit maintenant un manifeste indicateur pour désactiver la collecte automatique des données, que vous pouvez remplacer à tout moment en utilisant setCrashlyticsCollectionEnabled . La méthode vous donne plus de contrôle sur le comportement de rapport de plantage de votre application.


Crashlytics.log est désormais une méthode d'instance.

Le nouveau SDK ne comprend plus statique Crashlytics.log méthode. Pour ajouter des messages de journaux personnalisés, utilisez la nouvelle méthode d' instance crashlytics.log à la place. Notez que la nouvelle méthode ne renvoie plus à logcat (nous vous recommandons d'écrire un wrapper si vous souhaitez conserver ce comportement). Pour plus d' informations, visitez ajouter des messages de journaux personnalisés .

Kit de développement logiciel (SDK) 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 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")

Raison du changement

À votre demande, nous avons cessé de renvoyer les journaux Crashlytics à logcat. L'utilisation de méthodes d'instance facilite également le test de votre code.


setBool, setDouble, setFloat et setInt, setLong et setString sont agrégés dans setCustomKey.

Nous avons regroupé les setters clés personnalisé dans la méthode setCustomKey . Auparavant, vous pouviez utiliser les paramètres de clé personnalisés pour définir des paires clé/valeur à envoyer avec votre rapport de plantage. Maintenant, vous pouvez utiliser setCustomKey(String, value) , qui est surchargée d'accepter les types primitifs et cordes. Pour plus d' informations, consultez Ajout de clés personnalisées.

Kit de développement logiciel (SDK) 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 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")

Raison du changement

Le nouveau nom de méthode est unique à Crashlytics et indique clairement que Crashlytics n'est pas conforme à la valeur-clé.


setUserIdentifier est maintenant setUserId. setUserName et setUserEmail sont supprimés.

Auparavant, vous pouvez définir un nom ou e - mail associée à un accident en utilisant setUserName et setUserEmail , mais ces méthodes ne sont plus définies. La nouvelle méthode préférée pour les ID définis pour vos utilisateurs est d'utiliser setUserId . Pour plus d' informations, consultez Définir les identifiants de l' utilisateur.

Kit de développement logiciel (SDK) 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 Firebase Crashlytics

Java

crashlytics.setUserId("myAppUserId");

Kotlin+KTX

crashlytics.setUserId("myAppUserId")

Raison du changement

Nous avons adopté le nom de la méthode setUserId pour être compatible avec d' autres API Firebase et enlevé setUserName et setUserEmail pour décourager l' exploitation forestière PII par Crashlytics.


Crashlytics.logException(Throwable) est remplacé par FirebaseCrashlytics.recordException(Throwable).

Crashlytics prend désormais également en charge la journalisation des types d'erreur et d'exception intégrés pour les applications Apple et Android.

Kit de développement logiciel (SDK) 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 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)
}

Raison du changement

La nouvelle méthode recordException(Throwable) est plus facile à distinguer de log(String) , qui se comporte différemment. De plus, nous avons renommé la nouvelle API pour qu'elle soit plus cohérente sur toutes les plateformes.


Le CrashlyticsListener est remplacé par didCrashOnPreviousExecution().

Le CrashlyticsListener autorisait auparavant Crashlytics à indiquer quand une session d'application précédente se termine par un plantage, ce qui est utile pour les applications qui affichent des messages après le plantage au redémarrage. Maintenant, le rappel est remplacé par l'appel API synchrone didCrashOnPreviousExecution() .

Kit de développement logiciel (SDK) 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 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.
}

Raison du changement

La nouvelle API est moins détaillée et moins difficile à utiliser que CrashlyticsListener, car elle ne nécessite ni texte passe-partout ni rappel. Auparavant, le rappel asynchrone ne garantissait pas quand le rappel serait appelé.


La méthode crash est supprimée.

Le nouveau SDK n'inclut plus la méthode de plantage, que vous pouviez auparavant utiliser pour valider votre configuration Crashlytics en forçant un plantage dans votre application. Jetez un RuntimeException pour forcer un accident.

Kit de développement logiciel (SDK) Fabric

Java

Crashlytics.getInstance().crash();

Kotlin+KTX

Crashlytics.getInstance().crash()

SDK Firebase Crashlytics

Java

throw new RuntimeException("Test Crash");

Kotlin+KTX

throw RuntimeException("Test Crash")

Raison du changement

Les nouvelles méthodes spécifient clairement si les plantages résultants de votre application se sont produits pendant l'exécution ou dans le SDK natif de l'application.


Le plugin Crashlytics Gradle contient de nouveaux indicateurs.

Le plug-in Gradle continue de configurer et d'exécuter automatiquement les tâches Gradle spécifiques à Crashlytics. Si votre construction nécessite de faire appel des tâches du plug - in Crashlytics Gradle, reportez - vous aux tâches disponibles Firebase Crashlytics en exécutant ./gradlew app:tasks . Si votre application utilise un NDK, vous devez appeler explicitement le uploadCrashlyticsSymbolFile[ BUILD_VARIANT ] tâche Gradle à continuer de transférer des symboles indigènes Crashlytics.

Les drapeaux de construction Crashlytics spécifiques ext.alwaysUpdateBuildId et ext.enableCrashlytics ne sont plus pris en charge. Supprimez-les de votre configuration Gradle s'ils existent. Si votre application utilise un obfuscateur bytecode (par exemple, R8 ou Proguard) et que vous ne souhaitez pas télécharger le fichier de mappage de votre construction à Crashlytics, utilisez le nouveau mappingFileUploadEnabled drapeau dans la firebaseCrashlytics l' extension Gradle. Lorsqu'il est défini sur false, Crashlytics ne peut pas désobscurcir les traces de pile de votre application. Pour les configurations de Obfuscator non standard, utilisez le mappingFile paramètre pour définir un nouvel emplacement pour votre fichier de mappage. Ces indicateurs peuvent être utilisés pour defaultConfig, ainsi que pour tout type ou saveur de build.

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

Raison du changement

Nous avons mis à jour les tâches et les options de configuration de Gradle pour qu'elles soient plus cohérentes avec les conventions de Gradle.


Crashlytics ne peut utiliser que les données collectées par Google Analytics.

Vous ne pouvez plus collecter de données avec Fabric Answers après la mise à niveau vers le SDK Firebase Crashlytics. Pour obtenir des métriques pour les utilisateurs et les fils d'Ariane sans plantage, passez plutôt à l'utilisation de Google Analytics. Notez que vos données Answers historiques ne peuvent pas migrer vers Firebase.

Visitez utiliser Google Analytics pour savoir comment ajouter Google Analytics à votre application.

Raison du changement

Nous proposons désormais Google Analytics pour vous aider à mieux comprendre vos données de crash. Avec Analytics, vous pouvez continuer à collecter des statistiques pour votre application dans la console Firebase.


Prochaines étapes