1. Introduction
Les annonces jouent un rôle essentiel dans l'expérience utilisateur globale de votre application. Une bonne implémentation des annonces peut vous aider à améliorer l'expérience globale de votre application, et même à améliorer la fidélisation et l'engagement des utilisateurs. Par exemple, les annonces avec récompense vous permettent de proposer aux utilisateurs de l'argent ou des éléments dans l'application lorsqu'ils regardent des annonces vidéo. Les utilisateurs peuvent ainsi atteindre de nouveaux sommets, là où ils risqueraient de se retrouver bloqués ou perdus.
Cependant, il n'est pas facile de créer une excellente expérience publicitaire. Vous vous demandez peut-être à quelle fréquence diffuser ces annonces. Où et quand les diffuser ? Quel devrait être le prix ? Malheureusement, la réponse varie d'une application à l'autre et d'un emplacement à un autre. Il n'existe pas de solution unique.
Avec Google Analytics pour Firebase, AdMob et plusieurs autres outils puissants et faciles à utiliser proposés par Firebase, il est désormais beaucoup plus facile d'affiner et d'optimiser votre application en vous basant sur les données. Aujourd'hui, nous allons vous montrer comment vous lancer !
Objectifs de l'atelier
Cet atelier de programmation est le premier d'une série de trois qui vous aideront à créer une application appelée Awesome Drawing Quiz. Ce jeu permet aux joueurs de deviner le nom d'un dessin. Vous y découvrirez comment intégrer des annonces avec récompense et les services Firebase dans votre jeu.
Dans cet atelier de programmation, vous allez intégrer Google Analytics pour Firebase afin d'enregistrer des événements d'application importants. Vous apprendrez également à lire les données d'analyse d'applications affichées dans la console Firebase.
|
|
Si vous rencontrez des problèmes (bugs de code, erreurs grammaticales, formulation peu claire, etc.) au cours de cet atelier de programmation, veuillez les signaler via le lien Signaler une erreur situé dans l'angle inférieur gauche de l'atelier de programmation.
Points abordés
- Configurer Google Analytics pour Firebase dans votre application
- Enregistrer les événements d'application
- Interpréter les données d'analyse d'applications affichées dans la console Firebase
Prérequis
- Android Studio version 4.1 ou ultérieure
- Un compte Google
- Un appareil de test sous Android 5.0 ou version ultérieure avec un câble USB pour connecter votre appareil, ou un émulateur Android exécutant un AVD (appareil virtuel Android) avec une image système compatible avec les API Play Store/Google
Comment évalueriez-vous votre niveau d'expérience avec AdMob ?
Comment évalueriez-vous votre niveau d'expérience avec Firebase ?
<ph type="x-smartling-placeholder">2. Configurer l'environnement de développement
Télécharger le code
Cliquez sur le bouton suivant pour télécharger l'ensemble du code de cet atelier de programmation:
Décompressez le fichier ZIP téléchargé. Cette action décompresse un dossier racine nommé admob-firebase-codelabs-android.
...ou cloner le dépôt GitHub depuis la ligne de commande.
$ git clone https://github.com/googlecodelabs/admob-firebase-codelabs-android
Le dépôt contient quatre dossiers, comme suit:
101-base : code de démarrage que vous allez compiler dans cet atelier de programmation.- 101-complete_and_102-base : code final de cet atelier de programmation et pour l'atelier de programmation 102.
- 102-complete : code final de l'atelier de programmation 102.
Importer l'application de départ
Lancez Android Studio, puis sélectionnez Import project (Importer le projet) sur l'écran d'accueil. Sélectionnez ensuite le répertoire 101-base dans le code que vous avez téléchargé.
Le projet doit maintenant être ouvert dans Android Studio.
3. Configurer un bloc d'annonces vidéo avec récompense (facultatif)
Pour plus de commodité, l'application de démarrage inclut déjà un bloc d'annonces vidéo avec récompense dédié. Vous pouvez parfaitement ignorer cette étape si vous ne souhaitez pas en créer une autre dans votre compte AdMob.
Pour créer une application AdMob dans votre compte, veuillez suivre les instructions ci-dessous:
- Accédez à la console AdMob.
- Dans le menu Applications, cliquez sur Ajouter une application.
- À la question "Avez-vous publié votre application sur Google Play ou sur l'App Store ?", répondez "NON".
- Nommez l'application Awesome Drawing Quiz. sélectionnez la plate-forme Android, puis cliquez sur Add (Ajouter).
Une fois que vous avez créé une application AdMob dans votre compte, suivez les étapes décrites ci-dessous pour créer un bloc d'annonces vidéo avec récompense.
- Cliquez sur le menu Applications dans l'interface AdMob, puis sélectionnez Awesome Drawing Quiz dans la liste des applications.
- Cliquez sur AJOUTER UN BLOC D'ANNONCES pour créer un bloc d'annonces vidéo avec récompense.
- Sélectionnez le format d'annonce Avec récompense.
- Indiquez le nom du bloc d'annonces selon vos préférences. Définissez ensuite le montant de la récompense sur 1 et l'élément de récompense sur "hint" (il s'agit de la récompense actuellement accordée par l'application aux utilisateurs). Cliquez sur CRÉER UN BLOC D'ANNONCES pour créer un bloc d'annonces vidéo avec récompense.
- Une fois la création terminée, des instructions semblables à ce qui suit s'affichent:
- Revenez au projet Android, puis remplacez les constantes d'ID d'application et d'ID de bloc d'annonces AdMob par celles que vous avez créées à l'étape précédente.
strings.xml
<!-- Update the value with your AdMob app id -->
<string name="admob_app_id">YOUR_ADMOB_APP_ID</string>
GameActivity.kt
// Update the value with your Rewarded Video ad unit id
private const val AD_UNIT_ID = "<YOUR_AD_UNIT_ID>";
4. Configurer un projet Firebase
Créer un projet depuis la console Firebase
- Accédez à la console Firebase.
- Sélectionnez Ajouter un projet et nommez votre projet "Awesome Drawing Quiz". Vérifiez que la case d'option Activer Google Analytics pour ce projet est cochée.
- Sélectionnez le compte Google Analytics que vous souhaitez utiliser. Dans la plupart des cas, l'option Compte par défaut pour Firebase devrait suffire. Toutefois, si vous disposez d'un autre compte Google Analytics que vous souhaitez utiliser, sélectionnez-le ici.
- Cliquez sur Créer un projet.
Ajouter l'application Android
- Dans l'écran de présentation de votre nouveau projet, cliquez sur Ajouter Firebase à votre application Android.
- Saisissez le nom du package de l'atelier de programmation: com.codelab.awesomedrawingquiz.
- Donnez un nom à votre application: Awesome Drawing Quiz
- Laissez le champ SHA-1 vide, car SHA-1 n'est pas requis pour ce projet.
- Sélectionnez Enregistrer l'application pour enregistrer votre application.
Ajouter le fichier google-services.json à votre application
Un écran s'affiche, vous permettant de télécharger un fichier de configuration contenant toutes les métadonnées Firebase nécessaires à votre application. Cliquez sur Télécharger google-service.json et copiez le fichier dans le répertoire app de votre projet.
Déclarer des versions de dépendance
Commençons par ajouter la version de chaque dépendance requise pour intégrer Firebase au projet. Ouvrez le fichier dependencies.gradle situé à la racine du projet, puis ajoutez le plug-in Google-Services, le SDK Firebase Analytics et la version du SDK Firebase Core.
dependencies.gradle
ext {
...
// TODO: Declare google-services plugin version (101)
googleServicesPluginVersion = '4.3.4'
...
// TODO: Declare Firebase BOM version (101)
firebaseBomVersion = '26.2.0'
...
}
Appliquer le plug-in Google-Services à votre application
Le plug-in google-services utilise le fichier google-services.json pour configurer votre application afin qu'elle utilise Firebase.
Ajoutez google-services comme chemin d'accès aux classes dans le fichier build.gradle situé dans le répertoire racine du projet.
build.gradle
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
...
dependencies {
classpath "com.android.tools.build:gradle:$androidPluginVersion"
// TODO: Add google-services plugin (101)
classpath "com.google.gms:google-services:$googleServicesPluginVersion"
...
}
}
...
Appliquez ensuite le plug-in google-services en ajoutant une ligne dans le fichier app/build.gradle comme suit:
app/build.gradle
apply plugin: 'com.android.application'
// TODO: Apply google-services plugin (101)
apply plugin: 'com.google.gms.google-services'
android {
...
}
dependencies {
...
}
ajouter le SDK Firebase au projet ;
Toujours dans le fichier app/build.gradle, ajoutez le SDK Analytics aux dépendances de l'application.
app/build.gradle
apply plugin: 'com.android.application'
android {
...
}
dependencies {
...
// TODO: Import the Firebase BoM (101)
implementation platform("com.google.firebase:firebase-bom:$firebaseBomVersion")
// COMPLETE: Add Firebase Analytics dependency (101)
implementation 'com.google.firebase:firebase-analytics-ktx'
...
}
...
Synchronisez votre projet avec les fichiers Gradle.
Pour vous assurer que toutes les dépendances sont disponibles pour votre application, synchronisez votre projet avec les fichiers Gradle. Sélectionnez Fichier > Menu "Sync Project with Gradle Files" (Synchroniser le projet avec les fichiers Gradle) pour synchroniser votre projet avec les fichiers Gradle
5. Associer AdMob à un projet Firebase
Suivez les étapes ci-dessous pour associer vos applications à Firebase.
- Connectez-vous à votre compte AdMob à l'adresse https://apps.admob.com.
- Cliquez sur "Applications" dans la barre latérale.
- Sélectionnez Awesome Drawing Quiz. Si elle ne figure pas dans la liste des applications récentes, cliquez sur Afficher toutes les applications pour rechercher la liste de toutes les applications ajoutées à AdMob.
- Cliquez sur Paramètres de l'application dans la barre latérale.
- Cliquez sur Associer à Firebase.
- Sélectionnez l'option Associer à un projet Firebase existant et créer une application Firebase. Sélectionnez ensuite le projet Awesome Drawing Quiz dans le menu déroulant.
- Après avoir cliqué sur le bouton CONTINUER, le message L'association a bien été effectuée s'affiche. Cliquez sur le bouton OK pour terminer.
Une fois que vous avez associé votre application AdMob à un projet Firebase, des fonctionnalités supplémentaires sont débloquées dans la console AdMob et dans la console Firebase, comme suit:
Carte de revenus (AdMob)
À partir de la fiche "Revenus", vous pouvez obtenir une vue globale de toutes les sources de revenus possibles à partir d'un seul et même endroit. Les sources de revenus acceptées sont les suivantes:
- AdMob (estimation)
- Réseaux publicitaires par médiation (observés)
- Achats via une application
- Achats en ligne
Fiche "Métriques utilisateur" (AdMob)
La fiche "Métriques utilisateur" vous permet de voir l'impact potentiel des modifications de votre expérience publicitaire sur le comportement des utilisateurs.
Rapport sur les annonces avec récompense (AdMob)
Le rapport sur les annonces avec récompense propose différentes métriques qui aident les éditeurs à comprendre comment les utilisateurs interagissent avec leurs annonces avec récompense.
Fiche "Total des revenus" (Firebase)
Une fois que vous avez associé votre application AdMob à Firebase, la fiche "Revenu total" du tableau de bord Firebase affiche les revenus générés par AdMob, ainsi que les achats via l'application et les achats en ligne.
Rapports sur les événements d'annonce (Firebase)
Les événements propres aux annonces (clics, impressions et récompenses) sont collectés automatiquement et peuvent être utilisés dans Google Analytics pour Firebase.
6. Exécuter le projet
Une fois le projet compilé et exécuté, l'écran suivant s'affiche au démarrage de l'application.
Lorsque vous cliquez sur LANCER UN JEU,un dessin s'affiche sur l'écran. Votre mission consiste à deviner le nom du dessin à l'aide de l'indice affiché en haut de l'écran, qui vous permet de déduire la première lettre et la longueur du nom du dessin.
Si vous ne connaissez pas le nom du dessin, vous pouvez passer le niveau en cliquant sur le bouton IGNORER.
Vous aurez peut-être besoin d'un indice supplémentaire pour vous aider à deviner la réponse. Pour obtenir un indice supplémentaire, cliquez sur le bouton CONSEIL et regardez une annonce vidéo avec récompense. Une fois que vous aurez regardé l'annonce, une lettre supplémentaire apparaîtra comme récompense.
7. Ajouter des événements d'application
Pour bien comprendre le parcours utilisateur avec Awesome Drawing Quiz, vous allez définir quelques événements personnalisés qui suivent le comportement de l'utilisateur dans le jeu, comme suit:
Nom de l'événement | Déclenchement... | Paramètres |
game_start | Lorsqu'un utilisateur commence une nouvelle partie. | aucun |
level_start | Lorsqu'un utilisateur commence un nouveau niveau (un nouveau questionnaire de dessin) dans une étape. (il y a six niveaux dans une étape) | level_name |
level_wrong_answer | Lorsqu'un utilisateur soumet une réponse incorrecte. | level_name |
ad_reward_prompt | Lorsqu'un utilisateur appuie sur le bouton d'indice et est invité à regarder une annonce vidéo avec récompense | ad_unit_id |
ad_reward_impression | Lorsqu'un utilisateur commence à regarder une annonce vidéo avec récompense. | ad_unit_id |
level_success | Lorsqu'un utilisateur envoie une réponse correcte (efface un niveau). | nom_niveau, nombre_de_tentatives, temps_dépassement_seconde, indice_utilisé |
level_fail | Lorsqu'un utilisateur saute un niveau. | nom_niveau, nombre_de_tentatives, temps_dépassement_seconde, indice_utilisé |
game_complete | quand la partie sera terminée | number_of_correct_answers |
La description de chaque paramètre associé à chaque événement est la suivante:
Nom de l'événement | Nom du paramètre | Description |
level_start | level_name | Nom du dessin affiché dans le niveau (par exemple, "banane") |
level_wrong_answer | level_name | Lorsqu'un utilisateur soumet une réponse incorrecte. |
ad_reward_prompt | ad_unit_id | ID de bloc d'annonces utilisé pour afficher une annonce vidéo avec récompense |
ad_reward_impression | ad_unit_id | ID de bloc d'annonces utilisé pour afficher une annonce vidéo avec récompense |
level_success | level_name | Nom du dessin affiché dans le niveau (par exemple, "banane") |
level_success | number_of_attempts | Nombre de tentatives pour passer un niveau |
level_success | elapsed_time_sec | Temps écoulé pour terminer un niveau (en secondes) |
level_success | hint_used | Indique si l'utilisateur a utilisé un indice (a visionné une annonce vidéo avec récompense) ou non pour terminer un niveau (1: a utilisé une astuce / 0: a terminé un niveau sans indice) |
level_fail | level_name | Nom du dessin affiché dans le niveau (par exemple, "banane") |
level_fail | number_of_attempts | Nombre de tentatives pour passer un niveau |
level_fail | elapsed_time_sec | Temps écoulé pour terminer un niveau (en secondes) |
level_fail | hint_used | Indique si l'utilisateur a utilisé un indice (a visionné une annonce vidéo avec récompense) ou non pour terminer un niveau (1: a utilisé une astuce / 0: a terminé un niveau sans indice) |
game_complete | number_of_correct_answers | Nombre de niveaux terminés dans le jeu |
Créer une classe d'assistance pour la journalisation des événements personnalisés
Pour faciliter la journalisation des événements d'analyse, vous allez créer une classe d'assistance permettant de gérer les événements personnalisés.
Commencez par créer un fichier Kotlin (et non une classe Kotlin) et nommez-le QuizAnalytics.kt sous le package com.codelab.awesomedrawingquiz. Créez des champs qui définissent le nom de vos événements personnalisés et leurs paramètres.
QuizAnalytics.kt
private const val EVENT_AD_REWARD_PROMPT = "ad_reward_prompt"
private const val EVENT_AD_REWARD_IMPRESSION = "ad_reward_impression"
private const val EVENT_LEVEL_FAIL = "level_fail"
private const val EVENT_LEVEL_SUCCESS = "level_success"
private const val EVENT_LEVEL_WRONG_ANSWER = "level_wrong_answer"
private const val EVENT_GAME_START = "game_start"
private const val EVENT_GAME_COMPLETE = "game_complete"
private const val PARAM_AD_UNIT_ID = "ad_unit_id"
private const val PARAM_ELAPSED_TIME_SEC = "elapsed_time_sec"
private const val PARAM_HINT_USED = "hint_used"
private const val PARAM_NUMBER_OF_ATTEMPTS = "number_of_attempts"
private const val PARAM_NUMBER_OF_CORRECT_ANSWERS = "number_of_correct_answers"
Ensuite, ajoutez des fonctions d'extension qui vous aident à enregistrer des événements personnalisés dans votre jeu. Notez que la plupart des événements personnalisés incluent des paramètres qui vous permettent de disposer de plus de contexte pour chaque événement. Notez également que quelques noms et paramètres d'événements (FirebaseAnalytics.Event.LEVEL_NAME et FirebaseAnalytics.Event.LEVEL_START) sont déjà définis par Analytics. Nous allons donc les utiliser.
QuizAnalytics.kt
...
fun FirebaseAnalytics.logGameStart() = logEvent(EVENT_GAME_START, null)
fun FirebaseAnalytics.logLevelStart(levelName: String) {
logEvent(FirebaseAnalytics.Event.LEVEL_START) {
param(FirebaseAnalytics.Param.LEVEL_NAME, levelName)
}
}
fun FirebaseAnalytics.logLevelWrongAnswer(levelName: String) {
logEvent(EVENT_LEVEL_WRONG_ANSWER) {
param(FirebaseAnalytics.Param.LEVEL_NAME, levelName)
}
}
fun FirebaseAnalytics.logAdRewardPrompt(adUnitId: String) {
logEvent(EVENT_AD_REWARD_PROMPT) {
param(PARAM_AD_UNIT_ID, adUnitId)
}
}
fun FirebaseAnalytics.logAdRewardImpression(adUnitId: String) {
logEvent(EVENT_AD_REWARD_IMPRESSION) {
param(PARAM_AD_UNIT_ID, adUnitId)
}
}
fun FirebaseAnalytics.logLevelSuccess(
levelName: String,
numberOfAttempts: Int,
elapsedTimeSec: Int,
hintUsed: Boolean
) {
logEvent(EVENT_LEVEL_SUCCESS) {
param(FirebaseAnalytics.Param.LEVEL_NAME, levelName)
param(PARAM_NUMBER_OF_ATTEMPTS, numberOfAttempts.toLong())
param(PARAM_ELAPSED_TIME_SEC, elapsedTimeSec.toLong())
param(PARAM_HINT_USED, if (hintUsed) 1 else 0)
}
}
fun FirebaseAnalytics.logLevelFail(
levelName: String,
numberOfAttempts: Int,
elapsedTimeSec: Int,
hintUsed: Boolean
) {
logEvent(EVENT_LEVEL_FAIL) {
param(FirebaseAnalytics.Param.LEVEL_NAME, levelName)
param(PARAM_NUMBER_OF_ATTEMPTS, numberOfAttempts.toLong())
param(PARAM_ELAPSED_TIME_SEC, elapsedTimeSec.toLong())
param(PARAM_HINT_USED, if (hintUsed) 1 else 0)
}
}
fun FirebaseAnalytics.logGameComplete(
numberOfCorrectAnswers: Int
) {
logEvent(EVENT_GAME_COMPLETE) {
param(PARAM_NUMBER_OF_CORRECT_ANSWERS, numberOfCorrectAnswers.toLong())
}
}
Événements d'analyse de journaux dans le jeu
Dans la classe GameViewModel, ajoutez une propriété pour l'instance FirebaseAnalytics.
GameViewModel.kt
class GameViewModel(
...
// TODO: Accept FirebaseAnalytics instance as a parameter (101)
private val analytics: FirebaseAnalytics,
) : ViewModel() {
...
}
Ensuite, dans la classe AwesomeDrawingQuizViewModelFactory, ajoutez une propriété comme vous l'avez fait précédemment dans GameViewModel.
AwesomeDrawingQuizViewModelFactory.kt
class AwesomeDrawingQuizViewModelFactory(
...
// TODO: Accept FirebaseAnalytics instance as a parameter (101)
private val analytics: FirebaseAnalytics,
) : ViewModelProvider.Factory {
...
}
Ensuite, dans la classe AwesomeDrawingQuiz, ajoutez la fonction provideFirebaseAnalytics() et mettez à jour la fonction provideViewModelFactory() pour transmettre l'instance FirebaseAnalytics à AwesomeDrawingViewModelFactory.
AwesomeDrawingQuiz.kt
class AwesomeDrawingQuiz : Application() {
...
fun provideViewModelFactory() = AwesomeDrawingQuizViewModelFactory(
this,
provideGameSettings(),
// TODO: Pass FirebaseAnalytics instance as a parameter (101)
provideFirebaseAnalytics(),
)
// TODO: Provide FirebaseAnalytics instance (101)
private fun provideFirebaseAnalytics() = Firebase.analytics
...
}
Vous êtes maintenant prêt à implémenter des événements personnalisés. Tout d'abord, dans la fonction startGame(), appelez logGameStart() pour indiquer qu'une partie a commencé.
Comme logGameStart() est une fonction d'extension de la classe FirebaseAnalytics, vous pouvez l'appeler à partir de l'instance de la classe FirebaseAnalytics.
GameViewModel.kt
fun startGame() {
...
// TODO: Log game_start event (101)
analytics.logGameStart()
...
}
Ensuite, dans la fonction checkAnswer(), ajoutez les événements level_success et level_wrong_answer.
GameViewModel.kt
fun checkAnswer(userAnswer: String) {
...
if (correct) {
...
// TODO: Log level_success event (101)
analytics.logLevelSuccess(
levelName = drawing.word,
numberOfAttempts = numAttempts,
elapsedTimeSec = elapsedTimeInSeconds,
hintUsed = isHintUsed,
)
...
} else {
// TODO: Log level_wrong_answer event (101)
analytics.logLevelWrongAnswer(levelName = drawing.word)
...
}
}
Ensuite, dans la fonction skipLevel(), ajoutez l'événement level_fail pour marquer le niveau comme ayant échoué.
GameViewModel.kt
fun skipLevel() {
...
// TODO: Log level_fail event (101)
analytics.logLevelFail(
levelName = drawing.word,
numberOfAttempts = numAttempts,
elapsedTimeSec = elapsedTimeInSeconds,
hintUsed = isHintUsed,
)
...
}
Implémentez ensuite les fonctions logAdRewardPrompt() et logAdRewardImpression() pour suivre le comportement de l'utilisateur concernant l'annonce vidéo avec récompense.
GameViewModel.kt
fun logAdRewardPrompt(adUnitId: String) {
// TODO: Log ad_reward_prompt event (101)
analytics.logAdRewardPrompt(adUnitId)
}
fun logAdRewardImpression(adUnitId: String) {
// TODO: Log ad_reward_impression event (101)
analytics.logAdRewardImpression(adUnitId)
}
Enfin, modifiez les fonctions requestNewDrawing() et finishGame() pour ajouter des événements personnalisés level_start et game_complete.
GameViewModel.kt
private fun requestNewDrawing() {
...
drawingRequestDisposable = drawingDao.getRandomDrawings(seenWords)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { d ->
...
// TODO: Log level_start event (101)
analytics.logLevelStart(d.word)
...
}
}
private fun finishGame() {
// TODO: Log game_complete event (101)
analytics.logGameComplete(numCorrectAnswers)
...
}
8. Déboguer les événements d'analyse
Vous pouvez utiliser DebugView dans la console Firebase pour vérifier que les événements sont correctement consignés. DebugView vous permet d'afficher les données d'événements brutes enregistrées par votre application sur les appareils de développement, quasiment en temps réel.
Ceci est très utile à des fins de validation pendant la phase d'instrumentation du développement et peut vous aider à détecter d'éventuelles erreurs dans votre mise en œuvre d'analyse.
Activer le mode débogage
En général, les événements enregistrés dans votre application sont regroupés sur une période d'environ une heure et importés en même temps. Pour valider l'implémentation de vos données analytiques à la volée, vous devez activer le mode débogage sur votre appareil de développement afin d'importer les événements dans un délai minimal.
Pour activer le mode débogage, procédez comme suit:
- Ouvrez la fenêtre d'outil Terminal dans Android Studio (View > Tool Windows > Terminal (Vue > Fenêtres d'outil > Terminal).
- Exécutez la commande suivante (assurez-vous que l'appareil Android de test est connecté à votre ordinateur ou qu'Android Emulator est en cours d'exécution):
adb shell setprop debug.firebase.analytics.app com.codelab.awesomedrawingquiz
Ce comportement persiste jusqu'à ce que vous désactiviez explicitement le mode débogage en exécutant la commande suivante:
adb shell setprop debug.firebase.analytics.app .none.
Déboguer des événements Analytics avec DebugView
Une fois le mode débogage activé sur votre appareil de test, accédez à votre projet dans la console Firebase, puis sélectionnez Analytics > DebugView dans le menu. Ensuite, sur votre appareil de test, jouez à votre jeu pour voir les événements enregistrés et affichés dans le rapport DebugView.
Vous pouvez accéder à des informations détaillées sur chaque événement en cliquant sur son nom. Par exemple, la capture d'écran suivante montre les détails des paramètres associés à l'événement level_start.
Pour en savoir plus, consultez cet article du Centre d'aide sur DebugView.
9. Activer les dimensions et métriques personnalisées
Par défaut, Google Analytics pour Firebase collecte le nombre total d'événements. Pour chaque paramètre d'événement qui vous intéresse, vous devez activer explicitement la création de rapports pour ce paramètre. Google Analytics pour Firebase peut ensuite afficher des fiches supplémentaires présentant les statistiques des paramètres personnalisés.
Pour enregistrer des dimensions et des métriques personnalisées:
- Accédez à la console Firebase et sélectionnez le projet Awesome Drawing Quiz que vous avez créé précédemment.
- Cliquez sur Analytics > Événements dans le menu de navigation.
- Cliquez sur Gérer les définitions personnalisées.
- Dans l'onglet "Dimensions personnalisées", cliquez sur Créer des dimensions personnalisées.
- Dans le champ "Nom du paramètre d'événement", saisissez level_name, puis cliquez sur Enregistrer pour terminer l'enregistrement du paramètre.
- Sélectionnez ensuite l'onglet Métriques personnalisées, puis cliquez sur Créer des métriques personnalisées.
- Saisissez le nom et l'unité de mesure des paramètres suivants.
Nom du paramètre | Type de paramètre | Unité de mesure |
number_of_attempts | Nombre | Standard |
hint_used | Nombre | Standard |
elapsed_time_sec | Nombre | Secondes |
number_of_correct_answers | Nombre | Standard |
10. Obtenir des insights grâce au rapport sur les événements
Comme vous avez ajouté quelques événements au jeu, vous devriez être en mesure de répondre aux questions concernant le comportement des utilisateurs. Voici quelques informations que vous pouvez obtenir grâce au rapport sur les événements Firebase.
Quel niveau présente le plus grand nombre de mauvaises réponses ?
Pour répondre à cette question, vous devriez savoir combien d'événements level_wrong_answer ont été déclenchés pour chaque niveau.
Cliquez sur level_wrong_answer dans le rapport "Événements". Dans le rapport sur les événements level_wrong_answer, recherchez la fiche level_name. Les valeurs associées au paramètre level_name s'affichent sur cette fiche comme suit.
D'après la capture d'écran ci-dessus, vous pouvez facilement découvrir que l'horizon a le plus grand nombre de mauvaises réponses, ce qui signifie qu'il est plus difficile pour les utilisateurs par rapport aux autres niveaux.
En utilisant les informations que vous avez obtenues ici, vous pouvez décider de ne pas fournir de niveaux difficiles aux utilisateurs novices afin de maintenir un taux de rétention élevé.
En moyenne, combien de tentatives ont été effectuées pour terminer un niveau ?
Dans l'application Awesome Drawing Quiz, les utilisateurs peuvent envoyer la réponse à chaque niveau autant qu'ils le souhaitent.
Comme vous avez activé la création de rapports sur les paramètres number_of_attempts de l'événement level_success, vous pouvez afficher les métriques détaillées pour ce paramètre.
Cliquez sur l'événement level_success dans le rapport "Événements". Dans le rapport sur les événements level_success, recherchez la fiche number_of_attemps. Le nombre moyen de tentatives est indiqué comme suit:
Vous pouvez utiliser cet insight pour optimiser la difficulté moyenne du jeu. Par exemple, si le nombre moyen de tentatives est trop proche de 1, vous pouvez rendre le jeu un peu plus difficile.
Les utilisateurs ont-ils tenté de résoudre la question en obtenant un indice, même s'ils n'ont pas réussi à terminer un niveau ?
Lorsqu'un utilisateur décide de passer un niveau, un événement level_fail est déclenché. Il peut y avoir de nombreuses raisons à la décision de l'utilisateur.
Toutefois, étant donné que le jeu peut leur donner un indice après avoir visionné une annonce vidéo avec récompense, il est important de savoir si l'utilisateur a essayé de terminer le niveau à l'aide de l'indice.
Cliquez sur l'événement level_fail dans le rapport "Événements". Dans le rapport sur les événements level_fail, recherchez la fiche hint_used. Le nombre moyen de paramètres d'événement hint_used s'affiche. Notez que la valeur du paramètre est 1 si un indice a été utilisé et 0 si aucun indice n'a été utilisé.
Si les chiffres de la fiche hint_used sont proches de 0, cela signifie que la récompense (indice) n'est pas assez utile pour ces utilisateurs. De plus, vous perdez l'opportunité d'augmenter les revenus générés par les annonces vidéo avec récompense.
Par conséquent, nous vous conseillons d'offrir une récompense plus importante pour que les utilisateurs puissent interagir davantage avec le jeu, ce qui vous permettra d'augmenter les revenus générés par les annonces vidéo avec récompense.
Combien de niveaux ont été terminés en moyenne dans chaque match ?
Il y a six niveaux au total pour chaque jeu dans Awesome Drawing Quiz. Une fois que l'utilisateur termine les six niveaux (qu'il ait réussi ou non chaque niveau), un événement game_complete est déclenché avec number_of_correct_answers comme paramètre. Le paramètre number_of_correct_answers indique le nombre de niveaux auxquels l'utilisateur a fourni une bonne réponse.
Cliquez sur game_complete événement dans le rapport sur les événements. Dans le rapport sur les événements "game_complete", recherchez la fiche number_of_correct_answers. Le nombre moyen de paramètres d'événement number_of_correct_answers s'affiche.
Si le nombre moyen de niveaux terminés est trop faible, envisagez de réorganiser les niveaux du jeu pour aider les utilisateurs à battre plus facilement les niveaux précédents, afin qu'ils puissent continuer à jouer sans se désintéresser.
11. Terminé !
Vous avez terminé l'atelier de programmation AdMob et Firebase 101 sur Android. Vous trouverez le code final de cet atelier de programmation dans le dossier 101-complete_and_102-base.
Dans la prochaine partie de l'atelier de programmation AdMob + Firebase, vous découvrirez comment utiliser un entonnoir pour visualiser le flux d'événements de l'application. La partie suivante explique également comment utiliser Remote Config et les tests A/B pour optimiser la valeur des paramètres dans le jeu sans mettre à jour l'application.