1. Introduction
Les annonces sont un élément essentiel de l'expérience utilisateur globale de votre application. Une bonne implémentation des annonces peut améliorer l'expérience globale de votre application, et même la fidélisation et l'engagement des utilisateurs. Par exemple, les annonces avec récompense vous permettent de fournir aux utilisateurs des devises ou des articles dans l'application en échange du visionnage d'annonces vidéo. Les utilisateurs peuvent ainsi atteindre de nouveaux sommets alors qu'ils auraient pu être bloqués et abandonner l'application.
Toutefois, offrir une excellente expérience publicitaire n'est pas facile. Vous vous demandez peut-être à quelle fréquence vous devez diffuser ces annonces. Où et quand devez-vous les diffuser ? Quelle doit être la récompense ? Malheureusement, la réponse varie d'une application à l'autre et d'un emplacement à l'autre. Il n'existe pas de réponse unique.
Grâce à Google Analytics pour Firebase, à AdMob et à plusieurs autres outils puissants et faciles à utiliser proposés par Firebase, il est devenu beaucoup plus simple et efficace d'affiner votre application de manière axée 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. Dans ce jeu, les joueurs doivent deviner le nom d'un dessin. Vous y découvrirez comment intégrer des annonces avec récompense et des services Firebase dans votre jeu.
Dans cet atelier de programmation, vous allez intégrer Google Analytics for Firebase pour enregistrer certains événements importants de l'application. Vous apprendrez également à lire les données analytiques de l'application 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
- Lire les données analytiques sur les applications affichées dans la console Firebase
Prérequis
- Android Studio, version 4.1 ou ultérieure
- Un compte Google
- Un appareil de test équipé d'Android 5.0 ou version ultérieure avec un câble USB pour connecter votre appareil, ou un émulateur Android exécutant AVD (Android Virtual Device) avec une image système compatible avec le Play Store/les API Google
Comment évalueriez-vous votre niveau d'expérience avec AdMob ?
Comment évalueriez-vous votre niveau d'expérience avec Firebase ?
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 le dossier racine, nommé admob-firebase-codelabs-android.
Vous pouvez également cloner le dépôt GitHub à partir de la ligne de commande.
$ git clone https://github.com/googlecodelabs/admob-firebase-codelabs-android
Le dépôt contient quatre dossiers :
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 code de démarrage de 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 un projet) sur l'écran d'accueil. Sélectionnez ensuite le répertoire 101-base à partir du code que vous avez téléchargé.
Le projet devrait 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 êtes libre d'ignorer cette étape si vous ne souhaitez pas en créer un 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.
- Lorsque la question "Avez-vous publié votre application sur Google Play ou sur l'App Store ?" s'affiche, répondez NON.
- Nommez l'application Awesome Drawing Quiz,sélectionnez Android comme plate-forme, 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 Avec récompense comme format d'annonce.
- Attribuez le nom de votre choix au bloc d'annonces. Ensuite, définissez le montant de la récompense sur 1 et l'élément de récompense sur "hint" (indice, qui est la récompense que l'application offre actuellement 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 clé créée, des instructions semblables à celles-ci s'affichent :
- Revenez au projet Android et mettez à jour les constantes d'ID d'application AdMob et d'ID de bloc d'annonces avec 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 dans la console Firebase
- Accédez à la console Firebase.
- Sélectionnez Ajouter un projet, puis nommez votre projet "Awesome Drawing Quiz". Assurez-vous que la case d'option Activer Google Analytics pour ce projet est activée.
- Sélectionnez le compte Google Analytics que vous prévoyez d'utiliser. Pour la plupart des utilisateurs, il suffit de sélectionner l'option Compte par défaut pour Firebase. Toutefois, si vous souhaitez utiliser un autre compte Google Analytics, 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 : com.codelab.awesomedrawingquiz.
- Définissez un pseudo pour votre application : Awesome Drawing Quiz.
- Laissez le champ SHA-1 vide, car il n'est pas obligatoire pour ce projet.
- Sélectionnez Enregistrer l'application pour enregistrer votre application.
Ajouter le fichier google-services.json à votre application
Vous serez ensuite invité à télécharger un fichier de configuration contenant toutes les métadonnées Firebase nécessaires pour votre application. Cliquez sur Télécharger google-service.json et copiez le fichier dans le répertoire app de votre projet.
Déclarer les versions des dépendances
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, ainsi que la version du SDK Firebase Analytics et 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 en tant que classpath 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 votre 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'
...
}
...
Synchroniser 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 le menu File > Sync Project with Gradle Files (Fichier > Synchroniser le projet avec les fichiers Gradle) pour synchroniser votre projet avec les fichiers Gradle.
5. Associer AdMob à un projet Firebase
Pour associer vos applications à Firebase :
- Connectez-vous à votre compte AdMob sur https://apps.admob.com.
- Dans la barre latérale, cliquez sur "Applications".
- Sélectionnez Quiz de dessin génial. Si elle ne figure pas dans la liste des applications récentes, cliquez sur Afficher toutes les applications pour la rechercher dans 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 "Quiz de dessin génial" dans le menu déroulant.
- Après avoir cliqué sur le bouton CONTINUER, le message Association réussie s'affiche. Cliquez sur le bouton OK pour terminer.
Une fois votre application AdMob associée à un projet Firebase, vous pourrez accéder à des fonctionnalités supplémentaires dans les consoles AdMob et Firebase :
Fiche "Revenus" (AdMob)
La fiche "Revenus" vous permet d'obtenir une vue d'ensemble de toutes les sources de revenus possibles au même endroit. Voici les sources de revenus acceptées :
- AdMob (estimation)
- Réseaux publicitaires avec médiation (observés)
- Achats via une application
- Achats d'e-commerce
Fiche "Métriques utilisateur" (AdMob)
La fiche des métriques utilisateur vous permet de voir comment les modifications apportées à votre expérience publicitaire peuvent avoir un impact 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 "Revenu total" (Firebase)
Une fois votre application AdMob associée à Firebase, la fiche "Revenus totaux" du tableau de bord Firebase affichera les revenus générés par AdMob, ainsi que ceux issus des achats via l'application et de l'e-commerce.
Rapports sur les événements publicitaires (Firebase)
Les événements spécifiques aux annonces (événements de clic, d'impression et de récompense) sont collectés automatiquement et peuvent être utilisés dans Google Analytics pour Firebase.
6. Exécuter le projet
Une fois que vous avez compilé et exécuté le projet, l'écran suivant s'affiche au démarrage de l'application.
Une fois que vous avez cliqué sur COMMENCER UNE PARTIE,un dessin s'affiche à l'écran. Votre mission consiste à deviner le nom du dessin en utilisant 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 savez pas quel est le nom du dessin, vous pouvez passer le niveau en cliquant sur le bouton PASSER.
Vous pouvez demander un indice supplémentaire pour vous aider à deviner la réponse. Vous pouvez obtenir un indice supplémentaire en cliquant sur le bouton INDICE et en regardant une annonce vidéo avec récompense. Une fois l'annonce regardée, une lettre supplémentaire sera dévoilée en guise de récompense.
7. Ajouter des événements d'application
Pour bien comprendre le parcours utilisateur dans le Quiz de dessin génial,vous allez définir quelques événements personnalisés qui suivent le comportement des utilisateurs dans le jeu :
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 quiz de dessin) dans une étape. (il y a six niveaux dans une étape) | level_name |
level_wrong_answer | Lorsqu'un utilisateur envoie une mauvaise réponse | 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 vidéo avec récompense | ad_unit_id |
level_success | Lorsqu'un utilisateur envoie une bonne réponse (termine un niveau) | level_name, number_of_attempts, elapsed_time_sec, hint_used |
level_fail | Lorsqu'un utilisateur passe un niveau | level_name, number_of_attempts, elapsed_time_sec, hint_used |
game_complete | à la fin du jeu ; | number_of_correct_answers |
Voici la description de chaque paramètre associé à chaque événement :
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 envoie une mauvaise réponse |
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 terminer un niveau |
level_success | elapsed_time_sec | Temps écoulé pour terminer un niveau, en secondes |
level_success | hint_used | Indique si un utilisateur a utilisé une astuce (regardé une annonce vidéo avec récompense) ou non pour terminer un niveau (1 : a utilisé une astuce ; 0 : a terminé un niveau sans astuce). |
level_fail | level_name | Nom du dessin affiché dans le niveau (par exemple, "banane") |
level_fail | number_of_attempts | Nombre de tentatives pour terminer un niveau |
level_fail | elapsed_time_sec | Temps écoulé pour terminer un niveau, en secondes |
level_fail | hint_used | Indique si un utilisateur a utilisé une astuce (regardé une annonce vidéo avec récompense) ou non pour terminer un niveau (1 : a utilisé une astuce ; 0 : a terminé un niveau sans astuce). |
game_complete | number_of_correct_answers | Nombre de niveaux terminés dans le jeu |
Créer une classe d'assistance pour consigner les événements personnalisés
Pour enregistrer facilement l'événement Analytics, vous allez créer une classe d'assistance pour 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"
Ajoutez ensuite des fonctions d'extension qui vous aident à consigner des événements personnalisés dans votre jeu. Notez que la plupart des événements personnalisés incluent des paramètres pour vous donner plus de contexte sur chaque événement. Notez également que certains 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())
}
}
Consigner les événements d'analyse 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 échoué.
GameViewModel.kt
fun skipLevel() {
...
// TODO: Log level_fail event (101)
analytics.logLevelFail(
levelName = drawing.word,
numberOfAttempts = numAttempts,
elapsedTimeSec = elapsedTimeInSeconds,
hintUsed = isHintUsed,
)
...
}
Ensuite, implémentez 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 les é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 Analytics
Vous pouvez utiliser DebugView dans la console Firebase pour vérifier que les événements sont correctement enregistrés. DebugView vous permet d'afficher les données brutes des événements enregistrés par votre application sur les appareils de développement en temps quasi réel.
Cela est très utile à des fins de validation lors de la phase d'instrumentation du développement et peut vous aider à découvrir les erreurs dans votre implémentation Analytics.
Activer le mode débogage
En général, les événements enregistrés dans votre application sont regroupés par lots sur une période d'environ une heure et importés ensemble. Pour valider votre implémentation Analytics à la volée, vous devez activer le mode débogage sur votre appareil de développement afin d'importer les événements avec un minimum de retard.
Pour activer le mode Débogage, procédez comme suit :
- Ouvrez la fenêtre d'outil Terminal dans Android Studio (Affichage > Fenêtres d'outils > Terminal).
- Exécutez la commande suivante (assurez-vous que l'appareil Android de test est connecté à votre ordinateur ou que l'émulateur Android 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 les é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.
Pour accéder à des informations détaillées sur chaque événement, cliquez 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, veuillez consulter l'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 les rapports correspondants. Google Analytics pour Firebase peut ensuite afficher des fiches supplémentaires pour présenter les statistiques des paramètres personnalisés.
Pour enregistrer des dimensions et des métriques personnalisées :
- Accédez à la console Firebase, puis sélectionnez le projet Awesome Drawing Quiz que vous avez créé précédemment.
- Dans le menu de navigation, cliquez sur Analytics > Événements.
- 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.
- Ensuite, sélectionnez 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 à partir du rapport "Événements"
Comme vous avez ajouté quelques événements dans le jeu, vous devriez pouvoir répondre aux questions concernant le comportement des utilisateurs dans le jeu. Voici quelques insights que vous pouvez obtenir à partir du rapport sur les événements Firebase.
Quel niveau comporte le plus de mauvaises réponses ?
Pour répondre à cette question, vous devez déterminer le nombre d'événements level_wrong_answer déclenchés pour chaque niveau.
Cliquez sur level_wrong_answer dans le rapport sur les événements. Dans le rapport sur l'événement level_wrong_answer, recherchez la fiche level_name. Vous verrez les valeurs associées au paramètre level_name sur cette fiche, comme suit.
Selon la capture d'écran ci-dessus, vous pouvez facilement constater que le niveau Horizon est celui qui comporte le plus de mauvaises réponses, ce qui signifie qu'il est difficile pour les utilisateurs par rapport aux autres niveaux.
Grâce aux insights obtenus, vous pouvez décider de ne pas proposer de niveaux difficiles aux utilisateurs débutants pour maintenir un taux de rétention élevé.
Combien de tentatives ont été nécessaires en moyenne pour terminer un niveau ?
Dans le Quiz de dessin génial, les utilisateurs peuvent envoyer la réponse à chaque niveau autant de fois qu'ils le souhaitent.
Comme vous avez activé le reporting des paramètres pour le paramètre number_of_attempts dans l'événement level_success, vous pouvez consulter les métriques détaillées pour ce paramètre.
Cliquez sur l'événement level_success dans le rapport sur les événements. Dans le rapport sur l'événement level_success, recherchez la fiche number_of_attemps. Le nombre moyen de tentatives s'affiche dans la fiche comme suit :
Vous pouvez utiliser ces informations pour optimiser la difficulté moyenne du jeu. Par exemple, si le nombre moyen de tentatives est trop proche de 1, vous pouvez envisager de rendre le jeu un peu plus difficile.
Les utilisateurs ont-ils essayé 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é. Plusieurs raisons peuvent expliquer la décision de l'utilisateur.
Toutefois, comme le jeu peut lui donner un indice après qu'il a regardé 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 sur les événements. Dans le rapport sur l'événement level_fail, recherchez la fiche hint_used. Vous verrez le nombre moyen de paramètres d'événement hint_used. 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 nombres sur la fiche hint_used sont proches de 0, cela signifie que la récompense (indice) n'est pas assez utile pour ces utilisateurs. Vous passez également à côté de l'opportunité d'augmenter les revenus générés par les annonces vidéo avec récompense.
Vous devriez donc envisager de proposer une récompense plus importante afin que les utilisateurs puissent s'investir davantage dans le jeu, ce qui vous permettra d'augmenter vos revenus grâce aux annonces vidéo avec récompense.
Combien de niveaux ont été terminés en moyenne dans chaque jeu ?
Chaque jeu du Quiz de dessin génial comporte six niveaux. Une fois que l'utilisateur a terminé six niveaux (qu'il ait réussi ou échoué à 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 répondu correctement.
Cliquez sur l'événement game_complete dans le rapport sur les événements. Dans le rapport sur l'événement game_complete, recherchez la fiche number_of_correct_answers. Vous verrez le nombre moyen de paramètres d'événement number_of_correct_answers.
Si le nombre moyen de niveaux terminés est trop faible, envisagez de réorganiser les niveaux du jeu pour aider les joueurs à terminer plus facilement les premiers niveaux, afin qu'ils puissent continuer à jouer sans se lasser.
11. Terminé !
Vous avez terminé l'atelier de programmation AdMob+Firebase 101 pour 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 apprendrez à utiliser un entonnoir pour visualiser le flux d'événements de l'application. La partie suivante expliquera également comment utiliser Remote Config et les tests A/B pour optimiser la valeur du paramètre dans le jeu sans mise à jour de l'application.