Instrumentez 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 permettant ainsi de modifier l'apparence et le comportement de votre application sans distribuer de mise à jour d'application.

Vous ajouterez 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 donnant la possibilité d'implémenter de nouvelles utilisations de Firebase à leur place.

Pour garantir que votre application se comporte comme prévu, vous définirez les configurations par défaut pour les valeurs dans l'exemple de code de jeu, et ces valeurs peuvent être remplacées par les valeurs que vous définissez dans Remote Config dans la console Firebase .

Ce que vous apprendrez

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

Ce dont vous aurez besoin

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

2. Configurez votre environnement de développement

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

Téléchargez 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

Alternativement, si git n'est pas installé, vous pouvez télécharger le référentiel sous forme de fichier ZIP .

Ouvrez Level Up avec Firebase dans l'éditeur Unity

1. Lancez Unity Hub et, dans l'onglet Projets , cliquez sur la flèche déroulante en regard de 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 , et le projet s'ouvrira dans l'éditeur Unity.
6. Si votre éditeur ne l'ouvre pas automatiquement, ouvrez MainGameScene dans Assets > Hamster dans l'onglet Projet de l'éditeur Unity.
   

Pour plus d'informations sur l'installation et l'utilisation de Unity, consultez Travailler dans Unity .

3. Ajoutez Firebase à votre projet Unity

Créer un projet Firebase

1. Dans la console Firebase , cliquez sur Ajouter un projet .
2. Pour créer un nouveau projet, entrez le nom du projet souhaité.
   Cela définira également l'ID du projet (affiché sous le nom du projet) sur quelque chose basé sur le nom du projet. Vous pouvez éventuellement cliquer sur l'icône d'édition sur l'ID du projet pour le personnaliser davantage.
3. Si vous y êtes invité, consultez 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 sélectionnez Créer un nouveau compte pour créer un nouveau compte.
7. Cliquez sur Créer un projet .
8. Une fois le projet créé, cliquez sur Continuer .

Enregistrez votre application avec Firebase

1. Ouvrez la console Firebase et, depuis le centre de la page de présentation du projet, cliquez sur l'icône Unity pour lancer le workflow de configuration ou, si vous avez déjà ajouté une application à votre projet Firebase, cliquez sur Ajouter une application pour afficher les options de la plateforme.
2. Sélectionnez pour enregistrer les cibles de build Apple (iOS) et Android.
3. Saisissez le(s) ID spécifique(s) à la plateforme de votre projet Unity. Pour cet atelier de programmation, saisissez les informations suivantes :
   • 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 du nom du package Android .
4. Vous pouvez éventuellement saisir le(s) surnom(s) spécifique(s) à 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 build que vous n'avez pas effectuée la première fois.

Ajouter des fichiers de configuration Firebase

Après avoir cliqué sur Register app , vous serez invité à télécharger deux fichiers de configuration (un fichier de configuration pour chaque cible de build). Votre projet Unity a besoin des métadonnées Firebase contenues dans 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 Projet de votre projet Unity, puis déplacez les deux fichiers de configuration dans le dossier Assets .

   Important : même si vous envisagez de créer uniquement 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 Suivant et passez à Ajouter des SDK Firebase pour Unity.

Remarque : Vous pouvez toujours retélécharger ces fichiers ultérieurement en ouvrant les paramètres généraux de votre projet, en faisant défiler jusqu'à 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 Firebase Unity dans la console Firebase.

   Remarque : Le téléchargement de ce SDK peut prendre un certain temps. Prévisualisez les prochaines étapes ou faites une courte pause.

2. Décompressez le SDK dans un endroit pratique.
3. Dans votre projet Unity ouvert, accédez à Assets > Import Package > Custom Package .
4. Dans la boîte de dialogue Importer le package , accédez au répertoire contenant le SDK décompressé, sélectionnez FirebaseAnalytics.unitypackage , puis cliquez sur Ouvrir .
5. Dans la boîte de dialogue Importer un package Unity qui apparaît, cliquez sur Importer .
6. Répétez les étapes précédentes pour importer les deux packages suivants :
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics est un rapporteur de crash léger en temps réel qui vous aide à suivre, prioriser et résoudre les problèmes de stabilité qui érodent la qualité de votre application. Si vous ne l'avez jamais utilisé auparavant, envisagez de suivre le parcours d'apprentissage Crashlytics pour Unity .
7. Revenez à la console Firebase et, dans le workflow de configuration, cliquez sur Suivant .

Pour plus d'informations sur l'ajout de SDK Firebase aux projets Unity, consultez Options d'installation supplémentaires de Unity .

4. Définissez les valeurs par défaut de Remote Config et récupérez de nouvelles valeurs

Dans cet atelier de programmation, vous mettrez à 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 configurerez les 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. Votre application restera à jour en récupérant de nouvelles valeurs depuis Remote Config et en les activant pour les rendre utilisables dans le code.

Pour récupérer de nouvelles valeurs à partir 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 complétées.

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

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

   Le module Firebase.Extensions contient quelques extensions de l' API C# Tasks qui contribueront à simplifier la gestion du processus d'initialisation avec des rappels.
2. Ajoutez l'initialisation Firebase à votre méthode MainGame.cs Start() 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. Récupérer et activer de nouvelles valeurs (si nécessaire)

Nous devons maintenant compléter la méthode FetchRemoteConfig existante. Cela enchaînera les appels aux méthodes FetchAsync de Remote Config (qui récupère les 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 des rappels alternatifs à FetchRemoteConfig afin d'invoquer la récupération avec des résultats différents. Un exemple (que vous implémenterez plus tard) consiste à transmettre une méthode qui ouvre de nouveaux menus d'interface utilisateur, qui dépendent des valeurs de Remote Config. Cela entraînera l'ouverture des menus uniquement après que ces valeurs auront été 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 ceci sur System.TimeSpan.Zero comme indiqué ci-dessus. Cela garantit que l'application reflète toujours les valeurs les plus récentes. Toutefois, lors de la mise en production, vous devez définir cacheExpiration sur une valeur plus élevée pour éviter toute limitation . La période par défaut (lorsque FetchAsync est appelé sans paramètres) est de 12 heures.

2. Ensuite, complétez la méthode ActivateRetrievedRemoteConfigValues , qui reçoit un rappel transmis, onFetchAndActivateSuccessful . Une fois l'activation terminée, le rappel spécifié sera invoqué :

   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. Mettre en place une stratégie de chargement de Remote Config

Pour récupérer et activer des valeurs à un autre moment pendant l'utilisation de l'application, vous devez appeler à nouveau ces fonctions et, si des objets ont mis les valeurs en cache, ils doivent être avertis pour effectuer une mise à jour. Afin de développer une stratégie pour récupérer les valeurs de Remote Config, déterminez quand les nouvelles valeurs sont nécessaires et quand lancer la récupération et l'activation de nouvelles valeurs pour éviter qu'elles ne soient modifiées pendant leur utilisation.

Dans la forme actuelle, les valeurs de 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 changements de menu tout en bloquant également les interactions pendant la transition. De plus, c'est souvent le moment le plus pertinent pour obtenir de nouvelles valeurs, car un changement d'état du menu peut souvent être utilisé pour savoir "où" le joueur va et 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'interface utilisateur est de l'appeler avant la reprise du menu principal (en particulier lorsqu'il est accessible en sortant d'un autre menu) et de transmettre la méthode d'affichage de l'interface utilisateur en tant que rappel onFetchAndActivateSuccessful . La même chose peut être faite pour le menu Level Select .

Avec le chargement initial dans le cadre du démarrage de l'application, toute navigation dans les menus passant par le menu principal sera gérée par le premier d'entre eux, tandis que toute réentrée dans le menu Level Select entraînera également une actualisation. L'entrée initiale dans le menu de sélection de niveau n'a pas d'importance car elle n'est accessible qu'à partir du menu principal et est donc déjà couverte.

Pour activer cela dans l'application, complétez les méthodes appropriées dans le menu principal et les fichiers de sélection de niveau, ce qui bloquera l'affichage de l'interface utilisateur 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 ce qui suit :

   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 , remplacez la méthode Resume existante par ce qui suit :

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

4. Enregistrez le fichier.

Remarque : Bien que cet atelier de programmation fournisse un moyen de charger les valeurs de configuration à distance lorsque le menu principal et les vues de sélection de niveau sont actifs, d'autres stratégies de chargement sont disponibles. Consultez les stratégies de chargement de Firebase Remote Config pour plus d'informations.

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

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

Les informations seront imprimées dans le cadre des journaux de votre simulateur, appareil ou éditeur. Pour iOS, vous pouvez afficher les journaux des appareils 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 dans l'éditeur, les journaux apparaissent dans l'onglet Console.

1. Reconstruisez 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 ​​. Ceux-ci devraient afficher les messages « Récupération des données... » et « Données distantes chargées et prêtes ». Notez les horodatages au début de ces messages.
3. Dans le jeu, appuyez sur Licence .
4. Appuyez sur OK .
5. Attendez que le menu principal du jeu apparaisse.
6. Examinez la sortie du journal de votre jeu, qui devrait être similaire à celle de l'étape précédente, avec de nouveaux horodatages (correspondant à l'heure définie sur l'horloge système sur laquelle vous exécutez le jeu).
7. Dans le jeu, appuyez sur Jouer .
8. Appuyez sur Allons-y .
9. Déplacez le ballon vers le but à l'aide des flèches du clavier, ce qui ouvrira un menu Niveau terminé.
10. Appuyez sur Niveaux .
11. Attendez que le menu Level Select se charge.
12. Vérifiez à nouveau la sortie du journal de votre jeu. Il doit correspondre aux messages du journal des étapes précédentes, avec des horodatages 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, une partie du flux de récupération et d’activation (ou votre appareil) peut être 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 du périphérique/émulateur pour rechercher les avertissements et les erreurs concernant votre projet/environnement et étudiez-les : le problème peut être aussi simple que la connexion à Internet.

Si les journaux initiaux du chargement du menu apparaissent, mais pas l'un des suivants, étudiez/réimplémentez les méthodes Resume dans Assets/Hamster/Scripts/States/MainMenu.cs et Assets/Hamster/Scripts/States/BaseLevelSelect.cs .

8. Instrumentez votre code

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

Après avoir défini des valeurs dans le backend Remote Config, les avoir récupérées et activées ( ou fait les deux à la fois ), ces valeurs sont disponibles pour votre application. Pour utiliser ces valeurs, appelez GetValue(string key ) et choisissez une clé de paramètre comme argument. Cela renvoie un ConfigValue , qui possède des propriétés permettant d'accéder à la valeur sous différents types pris en charge : string , bool , long , double . Dans ce projet et dans la plupart des cas d'utilisation de jeux, vous devez convertir les deux derniers types en int et float plus idiomatiques. Pour garantir que ces conversions ne posent 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 d' 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 tuile 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 comme des valeurs autres que les valeurs par défaut de leur type .

Remarque : SubtitleOverrideKey est une const string définie dans MainMenu.cs définie 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 êtes prêt à configurer les paramètres et les 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 que vous avez 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 répertorié dans le tableau, désactivez Utiliser les paramètres par défaut de l'application et collez le nouvelle valeur par défaut :

   Nom du paramètre (clé)	Type de données	Valeur par défaut
   accélération_tile_force	Nombre	100
   subtitle_override	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 de l'application. Pour en savoir plus, consultez Paramètres et conditions de Remote Config .

4. Cliquez sur Enregistrer pour enregistrer vos modifications.
5. Cliquez sur Publier pour publier la nouvelle configuration et rendre les nouvelles valeurs disponibles pour votre jeu.
6. Exécutez à nouveau votre application après avoir défini ces paramètres distants et observez comment 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.Source afin de déterminer si les valeurs correspondent à leurs valeurs par défaut configurées ou si elles ont été récupérées à partir du serveur Remote Config .

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

10. Utiliser les conditions de configuration à distance pour diffuser des variantes

Vous souhaiterez peut-être adapter l'expérience de l'application à l'utilisateur en fonction de la langue qu'il parle, de l'endroit où il se trouve, de l'heure de la journée ou de la plate-forme qu'il utilise. Les conditions de configuration à distance vous donnent la possibilité d'utiliser ces attributs et d'autres individuellement ou en combinaison pour fournir différentes valeurs (appelées variantes) à l'utilisateur.

Une utilisation courante des conditions consiste à modifier le contenu entre les plates-formes iOS et Android. Suivez les étapes ci-dessous pour implémenter une condition qui sert 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. Dans le coin inférieur gauche, cliquez sur Ajouter un nouveau .
4. Dans la liste déroulante qui apparaît, passez la souris sur Valeur conditionnelle et cliquez sur Créer une nouvelle 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... et sélectionnez Plateforme . Ensuite, sélectionnez la plateforme appropriée.
7. Cliquez sur Créer une condition pour créer la condition. La boîte de dialogue Modifier le paramètre réapparaît et vous pouvez maintenant définir une valeur :
   • Si vous ciblez Android, définissez la 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 vos modifications.
9. Cliquez sur Publier pour publier la nouvelle configuration et rendre les nouvelles valeurs disponibles pour votre jeu.

Si vous créez et exécutez à nouveau le jeu, vous devriez voir le sous-titre du jeu remplacé par sa variante spécifique à la plate-forme.

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

Remarque : Les mises à jour de Remote Config en temps réel sont prises en charge pour la version 11.0.0 et ultérieure du SDK pour les plateformes Android et Apple. Il n’est actuellement pas pris en charge dans le mode Unity Play.

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 fonctionne

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 de configuration à distance seront 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, comme 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 cessera d'écouter les modifications apportées au modèle de configuration à distance de votre projet.

Implémenter la configuration à distance en temps réel

Pour illustrer comment cela fonctionne dans le jeu, apportez les modifications suivantes à votre code.

Créer un gestionnaire de mise à jour de configuration

La première étape pour utiliser l’événement Config Update consiste à 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 imprimera une liste des clés mises à jour et un message de réussite dans le journal lorsqu'elle activera les nouvelles valeurs.

Abonnez-vous à l'événement Mise à jour

Afin d'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 (se terminant par += ActivateValuesOnConfigUpdate; ) abonne le gestionnaire d'événements à l'événement.

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

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

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

Testez la nouvelle fonctionnalité

Pour valider la nouvelle fonctionnalité, essayez votre application créée. La procédure suivante nécessite que vous puissiez lire le journal et déboguer à l'aide d'un véritable périphérique .

Modifiez acceleration_tile_force et observez

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

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

2. Modifiez la valeur en « 120 » et appuyez sur Enregistrer .

3. Cliquez sur le bouton Publier les modifications .

4. Inspectez le journal.
5. Si vous voyez un message de journal commençant par « Une erreur s'est produite lors de l'écoute », lisez le reste et essayez de déboguer avec le message d'erreur qu'il imprime.
6. Si vous voyez un journal commençant par « Clés mises à jour », votre application a reçu les valeurs modifiées.
7. Si vous ne voyez aucun de ces éléments, parcourez le reste de vos journaux, puis relisez les instructions de Create a Config Update handler , testez à nouveau et revérifiez les journaux pour déterminer si quelque chose ne va pas.

Avertissement : Notez que cela ne récupérera pas de nouvelle valeur conditionnelle si vous modifiez l'évaluation de sa condition (par exemple, si un utilisateur dispose de certaines propriétés d'utilisateur Analytics ou s'il fait partie d'une audience Analytics). Donc pour le moment, conservez 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 les valeurs du jeu à distance en les récupérant dans votre application et en utilisant des conditions pour servir différentes variantes !

Ce que nous avons couvert

• Comment définir et récupérer les valeurs de configuration à distance
• Comment instrumenter votre code Unity C# pour utiliser les valeurs récupérées
• Comment stocker, instrumenter et remplacer des valeurs/objets composés en tant que valeurs JSON
• Comment utiliser les conditions Remote Config pour servir différentes variantes de valeur

Prochaines étapes

Découvrez la 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 localité).

Passez à l' étape suivante du parcours, où vous utiliserez ces valeurs instrumentées pour tester A/B différentes variantes afin de mieux comprendre comment elles affectent le comportement des utilisateurs.