Instrumenter votre jeu Unity avec Firebase Remote Config

1. Introduction

Vous pouvez utiliser Firebase Remote Config pour définir des paires clé-valeur, également appelées paramètres, dans votre application et mettre à jour leurs valeurs dans le cloud. Vous pouvez ainsi modifier l'apparence et le comportement de votre application sans distribuer de mise à jour.

Vous allez ajouter cette nouvelle fonctionnalité à un exemple de jeu, MechaHamster: Level Up with Firebase Edition. Cet exemple de jeu est une nouvelle version du jeu Firebase classique MechaHamster qui supprime la plupart de ses fonctionnalités Firebase intégrées. Vous pouvez ainsi implémenter de nouvelles utilisations de Firebase à la place.

Pour vous assurer que votre application se comporte comme prévu, vous allez définir des configurations par défaut pour les valeurs de l'exemple de code de jeu. Ces valeurs peuvent être remplacées par celles que vous définissez dans Remote Config dans la console Firebase.

Points abordés

• Définir des valeurs Remote Config dans le cloud et les récupérer
• Instrumenter votre code C# Unity pour utiliser automatiquement les valeurs récupérées
• Stocker, instrumenter et remplacer des valeurs/objets composés en tant que valeurs JSON
• Utiliser des conditions Remote Config pour diffuser différentes variantes de valeur à différents groupes d'utilisateurs

Prérequis

• Unity 2019.1.0f1 ou version ultérieure avec prise en charge de la compilation pour iOS et/ou Android
• Un appareil Android/iOS physique ou un simulateur/émulateur pour créer et exécuter le jeu

2. Configurer l'environnement de développement

Les sections suivantes expliquent comment télécharger le code Passer à la vitesse supérieure avec Firebase, l'ouvrir dans Unity et ajouter un projet Firebase. Cet exemple de jeu "Level Up with Firebase" est utilisé dans plusieurs autres ateliers de programmation Firebase et Unity. Vous avez donc peut-être déjà effectué les tâches de cette section. Si c'est le cas, vous pouvez ignorer ces étapes et passer à la section "Ajouter les SDK Firebase pour Unity" pour ajouter Remote Config à l'exemple de code de jeu.

Télécharger le code

Clonez le dépôt GitHub de cet atelier de programmation à partir de la ligne de commande :

git clone https://github.com/firebase/level-up-with-firebase

Si git n'est pas installé, vous pouvez également télécharger le dépôt sous forme de fichier ZIP.

Ouvrez Passez au niveau supérieur avec Firebase dans l'éditeur Unity.

1. Lancez Unity Hub, puis, dans l'onglet Projects (Projets), cliquez sur la flèche du menu déroulant à côté de Open (Ouvrir).
2. Cliquez sur Ajouter un projet à partir du disque.
3. Accédez au répertoire contenant le code, puis cliquez sur OK.
4. Si vous y êtes invité, sélectionnez une version de l'éditeur Unity à utiliser et votre plate-forme cible (Android ou iOS).
5. Cliquez sur le nom du projet, level-up-with-firebase, pour l'ouvrir dans l'éditeur Unity.
6. Si votre éditeur ne l'ouvre pas automatiquement, ouvrez MainGameScene dans Composants > Hamster dans l'onglet Project (Projet) de l'éditeur Unity ;
   

Pour en savoir plus sur l'installation et l'utilisation d'Unity, consultez la page Utiliser Unity.

3. Ajouter Firebase à votre projet Unity

Créer un projet Firebase

1. Dans la console Firebase, cliquez sur Ajouter un projet.
2. Pour créer un projet, saisissez son nom.
   Cette opération définit également l'ID du projet (affiché sous le nom du projet) sur une valeur basée sur le nom du projet. Vous pouvez également cliquer sur l'icône Modifier à côté de l'ID de projet pour le personnaliser davantage.
3. Si vous y êtes invité, lisez et acceptez les Conditions d'utilisation de Firebase.
4. Cliquez sur Continuer.
5. Sélectionnez l'option Activer Google Analytics pour ce projet, puis cliquez sur Continuer.
6. Sélectionnez un compte Google Analytics existant à utiliser ou cliquez sur Créer un compte.
7. Cliquez sur Create Project (Créer un projet).
8. Une fois le projet créé, cliquez sur Continuer.

Enregistrer votre application auprès de Firebase

1. Ouvrez la console Firebase, puis au centre de la page de présentation du projet, cliquez sur l'icône Unity pour lancer le workflow de configuration. Si vous avez déjà ajouté une application à votre projet Firebase, cliquez sur Ajouter une application pour afficher les options de plate-forme.
2. Sélectionnez cette option pour enregistrer les cibles de compilation Apple (iOS) et Android.
3. Saisissez le ou les ID spécifiques à la plate-forme de votre projet Unity. Pour cet atelier de programmation, saisissez ce qui suit :
   • Pour Apple (iOS) : saisissez com.google.firebase.level-up dans le champ ID du bundle iOS.
   • Pour Android : saisissez com.google.firebase.level_up dans le champ Nom du package Android.
4. Vous pouvez éventuellement saisir le ou les surnoms spécifiques à la plate-forme de votre projet Unity.
5. Cliquez sur Enregistrer l'application et passez à la section Télécharger le fichier de configuration.
6. Répétez le processus pour la cible de compilation que vous n'avez pas effectuée la première fois.

Ajouter des fichiers de configuration Firebase

Après avoir cliqué sur Enregistrer l'application, vous serez invité à télécharger deux fichiers de configuration (un fichier de configuration pour chaque cible de compilation). Votre projet Unity a besoin des métadonnées Firebase de ces fichiers pour se connecter à Firebase.

1. Téléchargez les deux fichiers de configuration disponibles:
   • Pour Apple (iOS) : téléchargez GoogleService-Info.plist.
   • Pour Android : téléchargez google-services.json.
2. Ouvrez la fenêtre Project (Projet) de votre projet Unity, puis déplacez les deux fichiers de configuration dans le dossier Assets (Éléments).

   Important : Même si vous ne prévoyez de compiler que pour iOS ou Android, vous devez télécharger les deux fichiers et les ajouter à votre projet.

3. De retour dans la console Firebase, dans le workflow de configuration, cliquez sur Next (Suivant), puis accédez à "Add Firebase SDK for Unity" (Ajouter des SDK Firebase pour Unity).

Remarque : Vous pouvez toujours télécharger à nouveau ces fichiers ultérieurement en ouvrant les paramètres généraux de votre projet, en faisant défiler la section Vos applications, puis en cliquant sur le bouton de téléchargement du fichier de configuration souhaité.

Ajouter des SDK Firebase pour Unity

1. Cliquez sur Télécharger le SDK Unity Firebase dans la console Firebase.

   Remarque : Le téléchargement de ce SDK peut prendre un certain temps. Affichez un aperçu des prochaines étapes ou faites une petite pause.

2. Décompressez le SDK à l'emplacement de votre choix.
3. Dans votre projet Unity ouvert, accédez à Assets (Éléments) > Import Package (Importer un package) > Custom Package (Package personnalisé).
4. Dans la boîte de dialogue Import package (Importer un package), accédez au répertoire contenant le SDK décompressé, sélectionnez FirebaseAnalytics.unitypackage, puis cliquez sur Open (Ouvrir).
5. Dans la boîte de dialogue Import Unity Package (Importer un package Unity) qui s'affiche, cliquez sur Import (Importer).
6. Répétez les étapes précédentes pour importer les deux packages suivants:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics est un outil de création de rapports de plantage en temps réel et léger qui vous aide à suivre, hiérarchiser et résoudre les problèmes de stabilité qui nuisent à la qualité de votre application. Si vous ne l'avez pas encore utilisée, nous vous conseillons de suivre le parcours de formation Crashlytics pour Unity.
7. Revenez à la console Firebase et, dans le workflow de configuration, cliquez sur Next (Suivant).

Pour en savoir plus sur l'ajout de SDK Firebase à des projets Unity, consultez Options d'installation Unity supplémentaires.

4. Définir les paramètres par défaut de Remote Config et récupérer de nouvelles valeurs

Dans cet atelier de programmation, vous allez mettre à jour les objets qui utilisent des valeurs définies dans le code ou qui sont sérialisés dans l'éditeur Unity pour utiliser des valeurs instrumentées avec Remote Config. Vous allez configurer des valeurs par défaut pour chaque paramètre à l'aide de SetDefaultsAsync afin que votre application se comporte comme prévu avant de se connecter au backend Remote Config. Pour que votre application reste à jour, elle récupère les nouvelles valeurs dans Remote Config et les active pour les rendre utilisables dans le code.

Pour extraire de nouvelles valeurs de Remote Config, un certain nombre de méthodes non implémentées sont déjà présentes dans le fichier Assets/Hamster/Scripts/MainGame.cs et doivent être finalisées.

1. Ajoutez les instructions using suivantes à MainGame.cs :

   using Firebase.Crashlytics;
   using Firebase.Extensions;
   using Firebase.RemoteConfig;
   

   Le module Firebase.Extensions contient des extensions de l'API Tasks C# qui faciliteront la gestion du processus d'initialisation avec des rappels.
2. Ajoutez l'initialisation de Firebase à votre méthode Start() MainGame.cs en remplaçant la méthode InitializeCommonDataAndStartGame() existante par la méthode actuellement non implémentée, InitializeFirebaseAndStartGame():

   void Start()
   {
      Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
      InitializeFirebaseAndStartGame();
   }
   

3. Dans MainGame.cs, recherchez InitializeFirebaseAndStartGame(). Déclarez une variable d'application et écrasez l'implémentation de la méthode comme suit:

   public Firebase.FirebaseApp app = null;
   
   // Begins the firebase initialization process and afterwards, opens the main menu.
   private void InitializeFirebaseAndStartGame()
   {
      Firebase.FirebaseApp.CheckAndFixDependenciesAsync()
      .ContinueWithOnMainThread(
         previousTask =>
         {
            var dependencyStatus = previousTask.Result;
            if (dependencyStatus == Firebase.DependencyStatus.Available) {
            // Create and hold a reference to your FirebaseApp,
            app = Firebase.FirebaseApp.DefaultInstance;
            // Set the recommended Crashlytics uncaught exception behavior.
            Crashlytics.ReportUncaughtExceptionsAsFatal = true;
            SetRemoteConfigDefaults();
            } else {
            UnityEngine.Debug.LogError(
               $"Could not resolve all Firebase dependencies: {dependencyStatus}\n" +
               "Firebase Unity SDK is not safe to use here");
            }
         });
   }
   

4. L'initialisation de Firebase appelle SetRemoteConfigDefaults en cas de succès pour définir les valeurs par défaut dans l'application. Remplacez la méthode SetRemoteConfigDefaults non implémentée par ce qui suit :

   private void SetRemoteConfigDefaults()
   {
      var defaults = new System.Collections.Generic.Dictionary < string, object > ();
      defaults.Add(
         Hamster.MapObjects.AccelerationTile.AccelerationTileForceKey,
         Hamster.MapObjects.AccelerationTile.AccelerationTileForceDefault);
      defaults.Add(
         Hamster.States.MainMenu.SubtitleOverrideKey,
         Hamster.States.MainMenu.SubtitleOverrideDefault);
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      remoteConfig.SetDefaultsAsync(defaults).ContinueWithOnMainThread(
         previousTask =>
         {
            FetchRemoteConfig(InitializeCommonDataAndStartGame);
         }
      );
   }
   

5. Extraire et activer de nouvelles valeurs (si nécessaire)

Nous devons maintenant finaliser la méthode FetchRemoteConfig existante. Cela enchainera les appels aux méthodes FetchAsync (qui extrait de nouvelles valeurs de Remote Config) et ActivateAsync (qui active ces valeurs obtenues pour les rendre disponibles dans le code) à l'aide d'un paramètre de rappel nommé onFetchAndActivateSuccessful.

Le code de démarrage que nous avons ajouté à l'étape précédente appelle FetchRemoteConfig avec InitializeCommonDataAndStartGame comme rappel afin de démarrer le jeu à la fin de la séquence. Vous pouvez transmettre d'autres rappels à FetchRemoteConfig afin d'appeler la récupération avec différents résultats. Par exemple (que vous implémenterez plus tard), vous pouvez transmettre une méthode qui ouvre de nouveaux menus d'interface utilisateur, qui dépendent des valeurs Remote Config. Les menus ne s'ouvriront qu'une fois ces valeurs récupérées et activées.

1. Collez le code ci-dessous dans FetchRemoteConfig :

   public void FetchRemoteConfig(System.Action onFetchAndActivateSuccessful)
   {
      if(app==null)
      {
         Debug.LogError($"Do not use Firebase until it is properly initialized by calling {nameof(InitializeFirebaseAndStartGame)}.");
         return;
      }
   
      Debug.Log("Fetching data...");
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      remoteConfig.FetchAsync(System.TimeSpan.Zero).ContinueWithOnMainThread(
         previousTask=>
         {
            if (!previousTask.IsCompleted)
            {
            Debug.LogError($"{nameof(remoteConfig.FetchAsync)} incomplete: Status '{previousTask.Status}'");
            return;
            }
            ActivateRetrievedRemoteConfigValues(onFetchAndActivateSuccessful);
         });
   }
   

   Remarque : La valeur cacheExpiration transmise à FetchAsync définit la durée pendant laquelle les valeurs précédemment récupérées doivent être mises en cache. Pendant le développement, vous pouvez définir ce paramètre sur System.TimeSpan.Zero, comme indiqué ci-dessus. Cela permet de garantir que l'application reflète toujours les valeurs les plus récentes. Toutefois, lors de la publication en production, vous devez définir une valeur plus élevée pour cacheExpiration pour éviter tout ralentissement. La période par défaut (lorsque la méthode FetchAsync est appelée sans paramètres) est de 12 heures.

2. Terminez ensuite la méthode ActivateRetrievedRemoteConfigValues, qui reçoit un rappel transmis, onFetchAndActivateSuccessful. Une fois l'activation terminée, le rappel spécifié est appelé :

   private void ActivateRetrievedRemoteConfigValues(System.Action onFetchAndActivateSuccessful)
   {
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      var info = remoteConfig.Info;
      if(info.LastFetchStatus == LastFetchStatus.Success)
      {
         remoteConfig.ActivateAsync().ContinueWithOnMainThread(
            previousTask =>
            {
            Debug.Log($"Remote data loaded and ready (last fetch time {info.FetchTime}).");
            onFetchAndActivateSuccessful();
            });
      }
   }
   

Lorsqu'il est appelé en aval par SetRemoteConfigDefaults à partir du contexte d'initialisation, ActivateRetrievedRemoteConfigValues appelle le point de départ précédent, InitializeCommonDataAndStartGame, pour démarrer le jeu en ouvrant le menu principal.

6. Configurer une stratégie de chargement Remote Config

Pour récupérer et activer des valeurs à un autre moment au cours de l'utilisation de l'application, vous devez appeler à nouveau ces fonctions. Si des objets ont mis les valeurs en cache, vous devez leur demander d'effectuer une mise à jour. Pour développer une stratégie de récupération des valeurs Remote Config, réfléchissez à quand les nouvelles valeurs sont nécessaires et à quand lancer l'extraction et l'activation des nouvelles valeurs pour éviter qu'elles ne changent pendant leur utilisation.

Tel qu'elles sont actuellement implémentées, les valeurs Remote Config sont récupérées et activées au démarrage de l'application. Les récupérations peuvent être masquées lors des modifications de menu, tout en bloquant l'interaction pendant la transition. De plus, il s'agit souvent du moment le plus opportun pour obtenir de nouvelles valeurs, car un changement d'état du menu peut souvent être utilisé pour savoir "où" le joueur va et pour prédire qu'une valeur sera utilisée.

En examinant le système de menus de Mechahamster, le moyen le plus simple d'ajouter des actualisations de menu bloquant l'UI consiste à l'appeler avant la reprise du menu principal (en particulier lorsqu'il y a accès en revenant d'un autre menu) et à transmettre la méthode d'affichage de l'UI comme rappel onFetchAndActivateSuccessful. Vous pouvez faire de même avec le menu Level Select (Sélection du niveau).

Lors du chargement initial au démarrage de l'application, toute navigation de menu via le menu principal sera gérée par le premier de ces éléments, tandis que toute nouvelle entrée dans le menu Sélection de niveau entraînera également une actualisation. L'accès initial au menu de sélection de niveau n'a pas d'importance, car il n'est accessible que depuis le menu principal et est donc déjà couvert.

Pour activer cette fonctionnalité dans l'application, effectuez les méthodes appropriées dans le menu principal et sélectionnez des fichiers de niveau, ce qui bloquera l'affichage de l'UI jusqu'à ce que FetchAsync et ActivateAsync soient terminés :

1. Ouvrez Assets/Hamster/Scripts/States/MainMenu.cs et remplacez la méthode Resume existante par la méthode suivante :

   public override void Resume(StateExitValue results) {
      CommonData.mainGame.SelectAndPlayMusic(CommonData.prefabs.menuMusic, true);
      CommonData.mainGame.FetchRemoteConfig(InitializeUI);
   }
   

2. Enregistrez le fichier.
3. Ouvrez Assets/Hamster/Scripts/States/BaseLevelSelect.cs, puis remplacez la méthode Resume existante par la méthode suivante :

   public override void Resume(StateExitValue results) {
      CommonData.mainGame.FetchRemoteConfig(ShowUI);
   }
   

4. Enregistrez le fichier.

Remarque : Bien que cet atelier de programmation vous permette de charger les valeurs Remote Config lorsque le menu principal et les vues de sélection de niveau sont actifs, d'autres stratégies de chargement sont disponibles. Pour en savoir plus, consultez la section Stratégies de chargement de Firebase Remote Config.

7. Déboguer/Valider les comportements de récupération

À ce stade, il est judicieux d'effectuer un diagnostic/contrôle de validation. La procédure suivante vous permet de tester manuellement votre application et de déterminer comment/si elle récupère et active les valeurs Remote Config.

Les informations seront imprimées dans les journaux de votre simulateur, de votre appareil ou de votre éditeur. Sur iOS, vous pouvez consulter les journaux de l'appareil et du simulateur dans Xcode. Pour Android, affichez les journaux en exécutant adb logcat. Si vous exécutez le code dans Unity en appuyant sur "Play" (Lecture) dans l'éditeur, les journaux s'affichent dans l'onglet "Console".

1. Recréez et exécutez l'application (dans l'éditeur, à l'aide d'un appareil ou d'un simulateur).
2. Une fois le menu principal du jeu affiché, examinez la sortie du journal de votre jeu, qui doit contenir les journaux générés par Debug.Log dans FetchRemoteConfig et ActivateRetrievedRemoteConfigValues. Le message "Récupération des données en cours..." devrait s'afficher. et « Données distantes chargées et prêtes » messages. Notez les codes temporels au début de ces messages.
3. Dans le jeu, appuyez sur License (Licence).
4. Appuyez sur OK.
5. Attendez que le menu principal du jeu s'affiche.
6. Examinez la sortie du journal de votre jeu, qui devrait être semblable à celle de l'étape précédente, avec de nouveaux codes temporels (correspondant à l'heure définie sur l'horloge système sur laquelle vous exécutez le jeu).
7. Dans le jeu, appuyez sur Play (Jouer).
8. Appuyez sur Let's Roll (C'est parti).
9. Dirigez la balle vers le but à l'aide des touches fléchées du clavier. Un menu "Niveau terminé" s'affiche alors.
10. Appuyez sur Niveaux.
11. Attendez que le menu Level Select (Sélection du niveau) se charge.
12. Examinez à nouveau la sortie du journal de votre jeu. Il doit correspondre aux messages de journal des étapes précédentes, avec des codes temporels plus récents (correspondant à l'heure définie sur l'horloge système sur laquelle vous exécutez le jeu).

Si l'un de ces éléments n'apparaît pas dans votre application, il est possible qu'une partie du processus d'extraction et d'activation (ou de votre appareil) soit mal configurée. Si le premier journal n'apparaît pas, il est possible que votre jeu ne démarre pas. Consultez la console Editor ou les journaux de l'appareil/de l'émulateur pour détecter les avertissements et les erreurs concernant votre projet/environnement, et examinez-les. Le problème peut être aussi simple qu'une connexion à Internet.

Si les journaux initiaux issus du chargement du menu s'affichent, mais que l'un des suivants ne s'affiche pas, examinez/réimplémentez les méthodes Resume dans Assets/Hamster/Scripts/States/MainMenu.cs et Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

8. Instrumenter votre code

Maintenant que vous avez configuré les valeurs de paramètres dans l'application dans SetDefaultsAsync() et que vous avez rendu les versions les plus récentes disponibles avec FetchAsync() et ActivateAsync(), vous allez référencer et utiliser ces valeurs dans le code.

Une fois que vous avez défini des valeurs dans le backend Remote Config, les avez extraites et les avez activées (ou les deux à la fois), elles sont disponibles pour votre application. Pour les utiliser, appelez GetValue(string key) et choisissez une clé de paramètre comme argument. Cette opération renvoie un ConfigValue, qui possède des propriétés permettant d'accéder à la valeur sous différents types acceptés : string, bool, long et double. Dans ce projet et dans la plupart des cas d'utilisation des jeux, vous devez caster les deux derniers types en int et float, qui sont plus idiomatiques. Pour vous assurer que ces conversions ne causent pas de problèmes, assurez-vous que les valeurs initiales définies dans Remote Config se situent dans la plage valide des types que vous utiliserez dans le code de votre application.

1. Importez Remote Config en ajoutant using Firebase.RemoteConfig; en haut des fichiers suivants:
   • Assets/Hamster/Scripts/States/MainMenu.cs
   • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
2. Remplacez la méthode Start de AccelerationTile.cs :

   private void Start() {
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      Acceleration = (float)remoteConfig.GetValue(AccelerationTileForceKey).DoubleValue;
   }
   

   Avec ce changement, la quantité de force transmise par la carte d'accélération sera remplacée par celle reçue de Remote Config.
3. Modifiez le corps de la méthode InitializeUI de MainMenu.cs:

   private void InitializeUI() {
      if (menuComponent == null) {
         menuComponent = SpawnUI<Menus.MainMenuGUI>(StringConstants.PrefabMainMenu);
      }
   
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      var subtitleOverride = JsonUtility.FromJson<Menus.MainMenuGUI.SubtitleOverride>(
         remoteConfig.GetValue(SubtitleOverrideKey).StringValue);
      // Only sets values if all fields of the override are non-default.
      if(subtitleOverride != null && subtitleOverride.IsValidOverride())
      {
         menuComponent.MenuSubtitleText.text = subtitleOverride.text;
         menuComponent.MenuSubtitleText.fontSize = subtitleOverride.fontSize;
         menuComponent.MenuSubtitleText.color = subtitleOverride.textColor;
      }
      ShowUI();
   }
   

   Ici, subtitleOverride est configuré pour modifier le sous-titre sur l'écran du menu principal si tous ses champs dans le cloud sont définis en tant que valeurs autres que les valeurs par défaut de leur type.

Remarque : SubtitleOverrideKey est un const string défini dans MainMenu.cs défini sur le paramètre subtitle_override.

9. Définir les valeurs des paramètres à distance

Maintenant que votre application est entièrement instrumentée, vous pouvez configurer des paramètres et des valeurs sur le serveur Remote Config. Dans cet atelier de programmation, nous allons configurer cela à l'aide de la console Firebase.

1. Dans la console Firebase, ouvrez votre projet.
2. Sélectionnez Remote Config dans le menu pour afficher le tableau de bord Remote Config.
3. Pour chacun des paramètres définis dans votre application et répertoriés dans le tableau qui suit, cliquez sur Ajouter un paramètre, collez le nom du paramètre (clé), sélectionnez le type de données indiqué dans le tableau, désactivez l'option Utiliser les paramètres par défaut dans l'application et collez la nouvelle valeur par défaut:

   Nom du paramètre (clé)	Type de données	Valeur par défaut
   acceleration_tile_force	Nombre	100
   remplacement_sous-titres	JSON	{"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}

   

   Remarque:Pour chaque paramètre, vous pouvez définir une valeur par défaut, qui remplace la valeur par défaut dans l'application. Pour en savoir plus, consultez Paramètres et conditions de Remote Config.

4. Cliquez sur Enregistrer pour enregistrer les modifications.
5. Cliquez sur Publier pour publier la nouvelle configuration et mettre les nouvelles valeurs à la disposition de votre jeu.
6. Exécutez à nouveau votre application après avoir défini ces paramètres distants et observez la manière dont ils remplacent les valeurs par défaut d'origine.

   Conseil: Pour les valeurs plus difficiles à observer, telles que les valeurs physiques, vous pouvez mettre à jour le code pour enregistrer la valeur de ConfigValue.Sourcepour déterminer si les valeurs sont leurs valeurs par défaut configurées ou ont été extraites du serveur Remote Config.

Remarque:Utilisez les méthodes ToJson et FromJson<T> d'Unity JsonUtility pour encoder et décoder un objet de données sérialisable vers et depuis une chaîne (comme c'est actuellement le cas lors de l'initialisation de SubtitleOverrideDefault dans MainMenu.cs). La documentation Serializable d'Unity décrit les restrictions d'Unity concernant la sérialisation des objets.

10. Diffuser des variantes à l'aide des conditions Remote Config

Vous pouvez adapter l'expérience de l'application à l'utilisateur en fonction de sa langue, de son emplacement, de l'heure de la journée ou de la plate-forme qu'il utilise. Les conditions Remote Config vous permettent d'utiliser ces attributs et d'autres individuellement ou en combinaison pour diffuser différentes valeurs (appelées variantes) auprès de l'utilisateur.

Une utilisation courante de ces conditions consiste à modifier le contenu entre les plates-formes iOS et Android. Suivez les étapes ci-dessous pour implémenter une condition qui fournit une valeur différente pour subtitle_override en fonction de la plate-forme utilisée.

1. Ouvrez l'onglet Remote Config de votre projet dans la console Firebase.
2. Cliquez sur le bouton Modifier pour subtitle_override..
3. En bas à gauche, cliquez sur Ajouter.
4. Dans la liste déroulante qui s'affiche, pointez sur Valeur conditionnelle, puis cliquez sur Créer une condition.
5. Lorsque vous y êtes invité, nommez la condition "est iOS" si vous ciblez iOS ou "est Android" si vous ciblez Android. Si vous ciblez les deux, choisissez-en simplement un ici et utilisez-le pour le reste de l'atelier de programmation.
6. Sous S'applique si, cliquez sur la liste déroulante Sélectionner, puis sélectionnez Plate-forme. Sélectionnez ensuite la plate-forme appropriée.
7. Cliquez sur Créer une condition pour créer la condition. La boîte de dialogue "Modifier le paramètre" s'affiche à nouveau et vous pouvez définir une valeur:
   • Si vous ciblez Android, définissez Valeur sur :

     {"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
     

   • Si vous ciblez iOS, définissez la valeur sur :

     {"text":"Level Up iOS Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
     

8. Cliquez sur Enregistrer pour enregistrer les modifications.
9. Cliquez sur Publier pour publier la nouvelle configuration et mettre les nouvelles valeurs à la disposition de votre jeu.

Si vous compilez et exécutez à nouveau le jeu, le sous-titre devrait être remplacé par sa variante spécifique à la plate-forme.

11. Configurer Remote Config pour recevoir des mises à jour en temps réel

Remarque:Les mises à jour de Remote Config en temps réel sont compatibles avec le SDK 11.0.0 ou version ultérieure pour les plates-formes Android et Apple. Elle n'est actuellement pas compatible avec le mode de lecture Unity.

Remote Config peut désormais écouter et gérer les mises à jour des modèles Remote Config en temps réel. Les applications peuvent s'abonner à la nouvelle API Remote Config en temps réel pour écouter les modifications de configuration et les valeurs mises à jour.

Comment ça marche

Pour écouter les mises à jour, votre application doit implémenter une méthode qui s'abonne à l'événement OnConfigUpdateListener. Lorsqu'un ou plusieurs écouteurs de mise à jour de configuration sont abonnés, les nouveaux modèles Remote Config sont récupérés automatiquement. Les gestionnaires abonnés sont appelés et peuvent être utilisés pour exécuter une logique en réponse, par exemple pour activer les nouvelles valeurs et les rendre disponibles pour le reste de l'application.

Remarque:Si tous les abonnés sont supprimés de OnConfigUpdateListener, il n'écoutera plus les modifications apportées au modèle Remote Config de votre projet.

Implémenter Remote Config en temps réel

Pour illustrer son fonctionnement dans le jeu, apportez les modifications suivantes à votre code.

Créer un gestionnaire de mise à jour de configuration

Pour utiliser l'événement de mise à jour de la configuration, vous devez d'abord créer une méthode capable de l'écouter. Placez la méthode suivante dans Assets/Hamster/Scripts/MainGame.cs :

   void ActivateValuesOnConfigUpdate( object sender, ConfigUpdateEventArgs args)
   {
      if (args.Error != RemoteConfigError.None) {
         Debug.Log($"Error occurred while listening: {args.Error}");
         return;
      }

      Debug.Log("Updated keys: " + string.Join(", ", args.UpdatedKeys));
      // Activate all fetched values and then logs.
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      remoteConfig.ActivateAsync().ContinueWithOnMainThread(
         task => {
            Debug.Log($"Keys from {nameof(ActivateValuesOnConfigUpdate)} activated.");
         });
   }

Cette méthode affiche la liste des clés mises à jour et un message de réussite dans le journal lorsqu'elle active les nouvelles valeurs.

S'abonner à l'événement Update

Pour activer ActivateValuesOnConfigUpdate lorsque l'événement est appelé, abonnez-le à l'événement. Remplacez la méthode InitializeCommonDataAndStartGame() dans Assets/Hamster/Scripts/MainGame.cs par ce qui suit :

   void InitializeCommonDataAndStartGame()
   {
      CommonData.prefabs = FindObjectOfType<PrefabList>();
      CommonData.mainCamera = FindObjectOfType<CameraController>();
      CommonData.mainGame = this;

      Screen.orientation = ScreenOrientation.LandscapeLeft;

      musicPlayer = CommonData.mainCamera.GetComponentInChildren<AudioSource>();

      CommonData.gameWorld = FindObjectOfType<GameWorld>();

      // Set up volume settings.
      MusicVolume = PlayerPrefs.GetInt(StringConstants.MusicVolume, MaxVolumeValue);
      // Set the music to ignore the listeners volume, which is used for sound effects.
      CommonData.mainCamera.GetComponentInChildren<AudioSource>().ignoreListenerVolume = true;
      SoundFxVolume = PlayerPrefs.GetInt(StringConstants.SoundFxVolume, MaxVolumeValue);

      // Subscribes to on config update after first initial fetch and activate
      FirebaseRemoteConfig.DefaultInstance.OnConfigUpdateListener += ActivateValuesOnConfigUpdate;

      stateManager.PushState(new States.MainMenu());
   }

La nouvelle ligne (qui se termine par += ActivateValuesOnConfigUpdate;) abonne le gestionnaire d'événements à l'événement.

Se désabonner lorsque l'objet propriétaire du gestionnaire est détruit

Pour éviter les erreurs de référence nulle, les objets dont les méthodes sont abonnées à des événements doivent les désabonner lorsqu'ils sont détruits. Ajoutez la méthode suivante à Assets/Hamster/Scripts/MainGame.cs:

   private void OnDestroy() 
   {
      FirebaseRemoteConfig.DefaultInstance.OnConfigUpdateListener -= ActivateValuesOnConfigUpdate;
   }

Tester la nouvelle fonctionnalité

Pour valider la nouvelle fonctionnalité, testez votre application compilée. La procédure suivante nécessite que vous puissiez lire le journal et déboguer à l'aide d'un appareil physique.

Modifier acceleration_tile_force et observer

Après avoir démarré votre application, dans la section Remote Config (Remote Config) de la console Firebase :

1. Appuyez sur le bouton Modifier à côté de acceleration_tile_force.

2. Modifiez la valeur sur "120", puis appuyez sur Enregistrer.

3. Cliquez sur le bouton Publier les modifications.

4. Examinez le journal.
5. Si un message de journal commençant par "Une erreur s'est produite lors de l'écoute" s'affiche, lisez la suite et essayez de le déboguer avec le message d'erreur qu'il affiche.
6. Si vous voyez un journal qui commence par « Clés mises à jour », votre application a reçu les valeurs modifiées.
7. Si aucun de ces éléments ne s'affiche, parcourez les autres journaux, puis consultez à nouveau les instructions de la section Créer un gestionnaire de mise à jour de configuration. Effectuez un nouveau test et vérifiez de nouveau les journaux pour déterminer si quelque chose ne fonctionne pas.

Avertissement:Notez que cette action ne récupérera pas de nouvelle valeur conditionnelle si vous modifiez l'évaluation de sa condition (par exemple, si un utilisateur a défini une propriété utilisateur Analytics spécifique ou s'il fait partie d'une audience Analytics). Pour le moment, conservez donc les appels à FetchRemoteConfig (qui appelle FetchAndActivate) dans Assets/Hamster/Scripts/States/MainMenu.cs et Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

12. Félicitations !

Vous avez utilisé Remote Config pour contrôler à distance les valeurs du jeu en les extrayant dans votre application et en utilisant des conditions pour diffuser différentes variantes.

Points abordés

• Définir et récupérer des valeurs Remote Config
• Instrumenter votre code C# Unity pour utiliser les valeurs récupérées
• Stocker, instrumenter et remplacer des valeurs/objets composés en tant que valeurs JSON
• Utiliser les conditions Remote Config pour diffuser différentes variantes de valeur

Étapes suivantes

Consultez la section Priorité des valeurs de paramètre pour mieux comprendre la logique selon laquelle les valeurs sont obtenues par une instance d'application lorsqu'elle utilise un paramètre avec plusieurs valeurs (en raison de conditions ou de la localité).

Passez à l'étape suivante du parcours,au cours de laquelle vous utiliserez ces valeurs instrumentées pour effectuer des tests A/B sur différentes variantes afin de mieux comprendre leur impact sur le comportement des utilisateurs.