Cette page a été traduite par l'API Cloud Translation.

Recevoir des rapports d'erreur du NDK Android

Si votre application Android contient des bibliothèques natives : Vous pouvez activer les traces de la pile complète et les rapports d'erreur détaillés pour votre code natif à partir de Firebase Crashlytics en apportant quelques petites mises à jour au build de votre application configuration.

Ce guide explique comment configurer les rapports d'erreur à l'aide de l'API SDK Firebase Crashlytics pour NDK

Si vous cherchez à vous familiariser avec Crashlytics dans Unity projets, consultez les Guide de démarrage Unity

Avant de commencer

Si ce n'est pas encore fait, ajoutez Firebase à votre projet Android. Si vous n'avez pas d'application Android, vous pouvez télécharger Une application exemple
Recommandé: Pour obtenir automatiquement journaux de fil d'Ariane pour comprendre les actions des utilisateurs ayant entraîné un plantage, une erreur non fatale ou une erreur ANR, vous devez activer Google Analytics dans votre projet Firebase.
- Si votre projet Firebase existant ne comporte pas de ressources Google Analytics vous pouvez activer Google Analytics depuis la Intégrations de votre > Paramètres du projet dans la console Firebase.
- Si vous créez un projet Firebase, activez Google Analytics pendant le workflow de création de projet.
Assurez-vous que votre application dispose des versions minimales suivantes:
- Gradle 8.0
- Plug-in Android Gradle 8.1.0
- Plug-in Gradle des services Google 4.4.1

Étape 1: Ajoutez le SDK Crashlytics pour NDK à votre application

Dans le fichier Gradle de votre module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), Ajoutez la dépendance pour la bibliothèque NDK Crashlytics pour Android. Nous vous recommandons d'utiliser Firebase Android BoM pour contrôler la gestion des versions des bibliothèques.

Pour une expérience optimale avec Crashlytics, nous vous recommandons activation de Google Analytics dans votre projet Firebase et d'ajouter le SDK Firebase pour Google Analytics à votre application.

dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.2.0"))

    // Add the dependencies for the Crashlytics NDK and Analytics libraries
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-crashlytics-ndk")
    implementation("com.google.firebase:firebase-analytics")
}

En utilisant Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

(Alternative) Ajouter des dépendances de la bibliothèque Firebase sans utiliser l'BoM

Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier chaque version de la bibliothèque Firebase dans sa ligne de dépendance.

Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, recommandent d'utiliser BoM pour gérer les versions de la bibliothèque, ce qui garantit que toutes les versions sont compatibles.

dependencies {
    // Add the dependencies for the Crashlytics NDK and Analytics libraries
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-crashlytics-ndk:19.0.3")
    implementation("com.google.firebase:firebase-analytics:22.1.0")
}

Vous recherchez un module de bibliothèque spécifique à Kotlin ? Début dans Octobre 2023 (Firebase BoM 32.5.0), les développeurs Kotlin et Java peuvent dépendent du module de bibliothèque principal (pour en savoir plus, consultez Questions fréquentes sur cette initiative).

Étape 2: Ajoutez le plug-in Gradle Crashlytics à votre application

Dans votre fichier Gradle au niveau racine (au niveau du projet) (<project>/build.gradle.kts ou <project>/build.gradle), ajoutez la Crashlytics du plug-in Gradle au bloc plugins:

Kotlin

Utilisez-vous toujours buildscript la syntaxe ? Découvrez comment Ajouter des plug-ins Firebase à l'aide de cette syntaxe.

plugins {
    // Make sure that you have the AGP plugin 8.1+ dependency
    id("com.android.application") version "8.1.4" apply false
    // ...

    // Make sure that you have the Google services Gradle plugin 4.4.1+ dependency
    id("com.google.gms.google-services") version "4.4.2" apply false

    // Add the dependency for the Crashlytics Gradle plugin
    id("com.google.firebase.crashlytics") version "3.0.2" apply false
}

Groovy

Utilisez-vous toujours buildscript la syntaxe ? Découvrez comment Ajouter des plug-ins Firebase à l'aide de cette syntaxe.

plugins {
    // Make sure that you have the AGP plugin 8.1+ dependency
    id 'com.android.application' version '8.1.4' apply false
    // ...

    // Make sure that you have the Google services Gradle plugin 4.4.1+ dependency
    id 'com.google.gms.google-services' version '4.4.2' apply false

    // Add the dependency for the Crashlytics Gradle plugin
    id 'com.google.firebase.crashlytics' version '3.0.2' apply false
}

Dans le fichier Gradle de votre module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), Ajoutez le plug-in Gradle Crashlytics:

Kotlin

plugins {
  id("com.android.application")
  // ...

  // Make sure that you have the Google services Gradle plugin
  id("com.google.gms.google-services")

  // Add the Crashlytics Gradle plugin
  id("com.google.firebase.crashlytics")
}

Groovy

plugins {
  id 'com.android.application'
  // ...

  // Make sure that you have the Google services Gradle plugin
  id 'com.google.gms.google-services'

  // Add the Crashlytics Gradle plugin
  id 'com.google.firebase.crashlytics'
}

Étape 3 : Ajouter l'extension Crashlytics à votre build

Kotlin

import com.google.firebase.crashlytics.buildtools.gradle.CrashlyticsExtension

// ...

android {
  // ...
  buildTypes {
      getByName("release") {
          // Add this extension
          configure<CrashlyticsExtension> {
              // Enable processing and uploading of native symbols to Firebase servers.
              // By default, this is disabled to improve build speeds.
              // This flag must be enabled to see properly-symbolicated native
              // stack traces in the Crashlytics dashboard.
              nativeSymbolUploadEnabled = true
          }
      }
  }
}

Groovy

// ...

android {
  // ...
  buildTypes {
      release {
          // Add this extension
          firebaseCrashlytics {
              // Enable processing and uploading of native symbols to Firebase servers.
              // By default, this is disabled to improve build speeds.
              // This flag must be enabled to see properly-symbolicated native
              // stack traces in the Crashlytics dashboard.
              nativeSymbolUploadEnabled true
          }
      }
  }
}

Étape 4: Configurez l'importation automatique de symboles natifs

Pour produire des traces de pile lisibles à partir de plantages du NDK, Crashlytics doit connaître sur les symboles de vos binaires natifs. Plug-in Gradle Crashlytics inclut l'élément uploadCrashlyticsSymbolFileBUILD_VARIANT pour automatiser ce processus.

Pour pouvoir accéder à la tâche d'importation automatique des symboles, assurez-vous que nativeSymbolUploadEnabled est défini sur true dans votre module (au niveau de l'application) ; Gradle.
Pour que les noms des méthodes apparaissent dans les traces de la pile, vous devez appeler explicitement le uploadCrashlyticsSymbolFileBUILD_VARIANT après chaque compilation de votre bibliothèque NDK. Exemple :
```
>./gradlew app:assembleBUILD_VARIANT\
           app:uploadCrashlyticsSymbolFileBUILD_VARIANT
```
Le SDK Crashlytics pour le NDK et le plug-in Gradle Crashlytics dépend de la présence de l'ID de build GNU dans les objets partagés natifs.

Vous pouvez vérifier la présence de cet ID en exécutant readelf -n sur chaque binaire. Si l'ID de build est absente, ajoutez -Wl,--build-id au fichier pour résoudre le problème.

Étape 5: Forcez un test de plantage pour terminer la configuration

Pour terminer la configuration de Crashlytics et voir les données initiales dans le tableau de bord Crashlytics de la console Firebase, vous devez forcer un test le plantage.

Ajoutez à votre application du code que vous pouvez utiliser pour forcer un plantage test.

Vous pouvez utiliser le code suivant dans le fichier MainActivity de votre application pour ajouter un bouton à votre application qui, si vous appuyez dessus, provoque un plantage. Le bouton est étiqueté "Tester le plantage".

Kotlin+KTX

val crashButton = Button(this)
crashButton.text = "Test Crash"
crashButton.setOnClickListener {
   throw RuntimeException("Test Crash") // Force a crash
}

addContentView(crashButton, ViewGroup.LayoutParams(
       ViewGroup.LayoutParams.MATCH_PARENT,
       ViewGroup.LayoutParams.WRAP_CONTENT))

Java

Button crashButton = new Button(this);
crashButton.setText("Test Crash");
crashButton.setOnClickListener(new View.OnClickListener() {
   public void onClick(View view) {
       throw new RuntimeException("Test Crash"); // Force a crash
   }
});

addContentView(crashButton, new ViewGroup.LayoutParams(
       ViewGroup.LayoutParams.MATCH_PARENT,
       ViewGroup.LayoutParams.WRAP_CONTENT));

Créez et exécutez votre application.
Forcez le plantage de test afin d'envoyer le premier rapport de plantage de votre application :
1. Ouvrez votre application depuis votre appareil de test ou votre émulateur.
2. Dans votre application, appuyez sur le bouton "Tester le plantage" que vous avez ajouté à l'aide du code ci-dessus.
3. Après un plantage, redémarrez-la pour qu'elle puisse envoyer le plantage dans Firebase.
Accédez au tableau de bord Crashlytics de la Firebase pour voir le plantage du test.

Si vous avez actualisé la console et que le plantage du test ne s'affiche toujours pas après cinq minutes, Activer la journalisation du débogage pour voir si votre appli envoie des rapports d'erreur.

Et voilà ! Crashlytics surveille désormais votre application pour détecter les plantages, et vous pouvez consulter et analyser les rapports d'erreur et les statistiques dans le Tableau de bord Crashlytics.

Étapes suivantes

(Recommandé) Obtenez de l'aide pour déboguer les plantages causés par des erreurs de mémoire native en collecter Rapports GWP-ASan Ces erreurs liées à la mémoire peuvent être associées à une corruption de la mémoire dans votre application, qui est la principale cause de failles de sécurité des applications. Pour profiter de cette fonctionnalité de débogage, assurez-vous que votre application a GWP-ASan est explicitement activé et utilise le dernier SDK Crashlytics pour NDK (version 18.3.6+ ou ultérieure Firebase BoM v31.3.0+).
Personnalisez la configuration des rapports d'erreur en ajoutant des rapports, des journaux, des clés et un suivi des erreurs non fatales.
Procédez à l'intégration avec Google Play pour que Vous pouvez filtrer les rapports d'erreur de votre application Android à l'aide du suivi Google Play directement dans le Crashlytics. Vous pouvez ainsi concentrer votre tableau de bord sur des builds spécifiques.

Dépannage

Si vous voyez des traces de pile différentes dans la console Firebase et dans Logcat, consultez le guide de dépannage.

Autres options pour importer des symboles

Le workflow principal de cette page ci-dessus s'applique aux builds Gradle standards. Cependant, certaines applications utilisent une configuration ou des outils différents (par exemple, un build autre que Gradle). Dans ces situations, les options suivantes peuvent vous aider à importer des symboles.

Option: importer des symboles pour les modules de bibliothèque et les dépendances externes

Cette option peut être utile dans les situations suivantes:

Si vous utilisez un processus de compilation NDK personnalisé dans Gradle
Si vos bibliothèques natives sont compilées dans un module de bibliothèque/fonction ou fournies par un tiers
Si la tâche d'importation automatique des symboles ou que vous constatez des plantages non symbolisés dans le tableau de bord

Afficher les instructions pour cette option

La tâche d'importation de symboles Crashlytics standard suppose que vous compilez vos bibliothèques natives dans le cadre de la compilation Gradle de votre module d'application, à l'aide d'outils de compilation NDK standards tels que CMake.

Toutefois, si vous utilisez un processus de compilation NDK personnalisé dans Gradle ou que votre les bibliothèques natives sont créées dans un module de bibliothèque/fonctionnalités ou fournies par par un tiers, vous devrez peut-être indiquer explicitement le chemin d'accès bibliothèques. Pour ce faire, vous pouvez ajouter unstrippedNativeLibsDir dans l'extension Crashlytics de votre fichier de compilation Gradle.

Assurez-vous d'avoir effectué les tâches initiales suivantes le workflow précédent sur cette page:

Pour que la tâche d'importation automatique des symboles puisse trouver votre symbole informations, ajoutez ce qui suit au fichier Gradle du module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle):

Kotlin

import com.google.firebase.crashlytics.buildtools.gradle.CrashlyticsExtension

// ...

android {
    // ...
    buildTypes {
        release {
            configure<CrashlyticsExtension> {
                nativeSymbolUploadEnabled = true
                unstrippedNativeLibsDir = file("PATH/TO/UNSTRIPPED/DIRECTORY")
            }
        }
    }
}

Groovy

// ...

android {
    // ...
    buildTypes {
        release {
            firebaseCrashlytics {
                nativeSymbolUploadEnabled true
                unstrippedNativeLibsDir file("PATH/TO/UNSTRIPPED/DIRECTORY")
            }
        }
    }
}

Le plug-in Crashlytics recherche de manière récursive le répertoire spécifié pour les bibliothèques natives avec une extension .so. Crashlytics extrait ensuite les symboles de débogage de toutes ces bibliothèques et les importe sur les serveurs Firebase.

Voici ce que vous pouvez spécifier dans la propriété unstrippedNativeLibsDir:

Tout argument autorisé pour org.gradle.api.Project#files(Object...) y compris: java.lang.String, java.io.File ou org.gradle.api.file.FileCollection
Plusieurs répertoires pour un même type de compilation en fournissant une liste ou FileCollection instance
(À partir de la version 3.0.0 du plug-in Gradle Crashlytics) Accumulez plusieurs répertoires dans des produits et des types de compilation individuels.

Voir un exemple avec plusieurs répertoires

  buildTypes {
    release {
      configure<CrashlyticsExtension> {
        nativeSymbolUploadEnabled = true
        unstrippedNativeLibsDir = file("MY/NATIVE/LIBS")
      }
    }
    productFlavors {
      flavorDimensions += "feature"
      create("basic") {
        dimension = "feature"
        // ...
      }
      create("featureX") {
        dimension = "feature"
        configure<CrashlyticsExtension> {
          unstrippedNativeLibsDir = file("MY/FEATURE_X/LIBS")
        }
      }
    }
  }

La tâche uploadCrashlyticsSymbolFilesBasicRelease n'importera que les dans MY/NATIVE/LIBS, mais uploadCrashlyticsSymbolFilesFeatureXRelease importera les symboles dans les deux MY/NATIVE/LIBS et MY/FEATURE_X/LIBS.

Enfin, forcez un plantage de test pour terminer la configuration de Crashlytics et afficher les données initiales dans le tableau de bord Crashlytics de la console Firebase.

Option: importer des symboles pour des builds non-Gradle ou des bibliothèques natives complètes inaccessibles

Cette option peut être utile dans les situations suivantes:

Si vous utilisez un processus de compilation autre que Gradle
Si vos bibliothèques natives complètes vous sont fournies d'une manière qui ils ne sont pas accessibles pendant les compilations Gradle

Afficher les instructions pour cette option

Cette option nécessite d'exécuter une commande CLI Firebase lorsque vous créez un build ou tout build pour lequel vous souhaitez voir les traces de pile décodées dans la console Firebase.

Assurez-vous d'avoir effectué les tâches initiales suivantes le workflow précédent sur cette page:
1. Activation de Crashlytics dans la console Firebase.
2. Ajout du SDK Crashlytics pour le NDK et du plug-in Gradle Crashlytics.
Notez qu'avec cette option, vous n'avez pas besoin d'ajouter le firebaseCrashlytics ou configurez l'importation automatique des symboles. La CLI Firebase (voir les étapes ci-dessous) pour générer et importer votre symbole .
Configurez votre environnement et votre projet pour l'importation de symboles:
1. Suivez les instructions pour installer la CLI Firebase.
  
  Si vous avez déjà installé la CLI, veillez à passer à la dernière version.
2. (uniquement pour les applications utilisant le niveau d'API Android 30 ou version ultérieure) Mettez à jour le modèle AndroidManifest.xml de votre application pour désactiver le taggage du pointeur :
  1. Cochez la case Paramètres du lecteur Android > Paramètres de publication > Créer > Fichier manifeste principal personnalisé.
  2. Ouvrez le modèle de fichier manifeste situé à l'adresse Assets/Plugins/Android/AndroidManifest.xml
  3. Ajoutez l'attribut suivant à la balise d'application : <application android:allowNativeHeapPointerTagging="false" ... />
Compilez votre projet.

Importez les informations sur vos symboles.

Une fois la compilation terminée, générez un symbole compatible avec Crashlytics et l'importer sur les serveurs Firebase en exécutant la commande suivante : Commande CLI Firebase:

firebase crashlytics:symbols:upload --app=FIREBASE_APP_ID PATH/TO/SYMBOLS

FIREBASE_APP_ID: votre ID d'application Android Firebase (et non votre nom du package)
Exemple d'ID d'application Android Firebase: 1:567383003300:android:17104a2ced0c9b9b
Vous avez besoin de votre ID d'application Firebase ?
Vous pouvez trouver votre ID d'application Firebase de deux façons:
- Dans votre fichier google-services.json, l'ID de votre application correspond au Valeur mobilesdk_app_id ; ou
- Dans la console Firebase, accédez à votre Paramètres du projet : Faites défiler la page jusqu'à la fiche Vos applications, puis cliquez sur les applications Firebase de votre choix Application pour trouver son ID.
PATH/TO/SYMBOLS: chemin d'accès au fichier de symboles généré par CLI
- Exportées vers un projet Android Studio : PATH/TO/SYMBOLS peut correspondre à n'importe quel répertoire. La CLI Firebase recherche de manière récursive les bibliothèques natives dans le répertoire spécifié avec une extension .so.
- L'APK a été créé directement dans Unity. PATH/TO/SYMBOLS est le chemin d'accès du fichier de symboles compressé généré dans le répertoire racine du projet à la fin de la compilation (par exemple : myproject/myapp-1.0-v100.symbols.zip).

Afficher les options avancées pour utiliser la commande CLI Firebase pour générer et importer des fichiers de symboles

Option	Description
`--generator=csym`	Utilise l'ancien générateur de fichiers de symboles cSYM au lieu du générateur Breakpad par défaut Non recommandé. Nous vous recommandons d'utiliser Générateur de fichiers de symboles Breakpad.
`--generator=breakpad`	Utilise le générateur de fichiers de symboles Breakpad Notez que le paramètre par défaut pour la génération de fichiers de symboles est Breakpad. N'utilisez cet indicateur que si vous avez ajouté `symbolGenerator { csym() }` dans votre configuration de compilation et que vous souhaitez la remplacer Breakpad à la place.
`--dry-run`	Génère les fichiers de symboles, mais ne les importe pas Cet indicateur est utile si vous souhaitez inspecter le contenu fichiers qui sont envoyés.
`--debug`	Fournit des informations de débogage supplémentaires

Enfin, forcez un plantage test pour terminer la configuration. Crashlytics et afficher les données initiales dans le tableau de bord Crashlytics de la console Firebase.

Après avoir compilé votre application pour forcer un plantage, veillez à exécuter la commande crashlytics:symbols:upload de la CLI Firebase pour importer votre fichier de symboles.