Strumenti per il gioco Unity con Firebase Remote Config

1. Introduzione

Puoi utilizzare Firebase Remote Config per definire coppie chiave-valore, note anche come parametri, nella tua app e aggiornarne i valori nel cloud, consentendoti di modificare l'aspetto e il comportamento della tua app senza distribuire un aggiornamento.

Aggiungerai questa nuova funzionalità a un gioco di esempio, MechaHamster: Level Up with Firebase Edition. Questo gioco di esempio è una nuova versione del classico gioco Firebase MechaHamster, in cui è stata rimossa la maggior parte delle funzionalità Firebase integrate, offrendoti la possibilità di implementare nuovi utilizzi di Firebase al loro posto.

Per assicurarti che la tua app si comporti come previsto, imposterai configurazioni predefinite per i valori nel codice di gioco di esempio e questi valori possono essere sostituiti da quelli impostati in Remote Config nella console Firebase.

Obiettivi didattici

• Come impostare i valori di Remote Config nel cloud e recuperarli
• Come instrumentare il codice C# di Unity per utilizzare automaticamente i valori recuperati
• Come archiviare, strumentare e sostituire valori/oggetti composti come valori JSON
• Come utilizzare le condizioni di Remote Config per pubblicare varianti di valori diversi per gruppi di utenti diversi

Che cosa ti serve

• Unity 2019.1.0f1 o versioni successive con supporto per la compilazione di iOS e/o Android
• Un dispositivo fisico Android/iOS o un simulatore/emulatore per creare ed eseguire il gioco

2. Configurazione dell'ambiente di sviluppo

Le sezioni seguenti descrivono come scaricare il codice di Level Up with Firebase, aprirlo in Unity e aggiungere un progetto Firebase. Questo gioco di esempio Level Up with Firebase viene utilizzato da diversi altri codelab Firebase + Unity, quindi potresti aver già completato le attività in questa sezione. In questo caso, puoi saltare questi passaggi e procedere ad aggiungere gli SDK Firebase per Unity per aggiungere Remote Config al codice di gioco di esempio.

Scarica il codice

Clona il repository GitHub di questo codelab dalla riga di comando:

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

In alternativa, se non hai installato git, puoi scaricare il repository come file ZIP.

Apri Level Up with Firebase nell'editor Unity

1. Avvia Unity Hub e, nella scheda Progetti, fai clic sulla freccia giù accanto ad Apri.
2. Fai clic su Aggiungi progetto dal disco.
3. Vai alla directory contenente il codice e fai clic su Ok.
4. Se richiesto, seleziona una versione dell'editor Unity da utilizzare e la piattaforma di destinazione (Android o iOS).
5. Fai clic sul nome del progetto, level-up-with-firebase, e il progetto si aprirà nell'editor Unity.
6. Se l'editor non lo apre automaticamente, apri MainGameScene in Assets > Hamster nella scheda Project di Unity Editor.
   

Per saperne di più sull'installazione e l'utilizzo di Unity, consulta Lavorare in Unity.

3. Aggiungi Firebase al tuo progetto Unity

Crea un progetto Firebase

1. Accedi alla console Firebase utilizzando il tuo Account Google.
2. Fai clic sul pulsante per creare un nuovo progetto, quindi inserisci un nome per il progetto (ad esempio LevelUpWithFirebase).
   
3. Fai clic su Continua.
4. Se richiesto, leggi e accetta i termini di Firebase, quindi fai clic su Continua.
5. (Facoltativo) Attiva l'assistenza AI nella console Firebase (denominata "Gemini in Firebase").
6. Per questo codelab, hai bisogno di Google Analytics per utilizzare in modo ottimale i prodotti Firebase, quindi mantieni l'opzione attiva per Google Analytics. Segui le istruzioni sullo schermo per configurare Google Analytics.
7. Fai clic su Crea progetto, attendi il provisioning del progetto, poi fai clic su Continua.

Registrare l'app con Firebase

1. Apri la console Firebase e, al centro della pagina di riepilogo del progetto, fai clic sull'icona Unity per avviare il flusso di lavoro di configurazione oppure, se hai già aggiunto un'app al progetto Firebase, fai clic su Aggiungi app per visualizzare le opzioni della piattaforma.
2. Seleziona per registrare le destinazioni di build Apple (iOS) e Android.
3. Inserisci gli ID specifici per la piattaforma del tuo progetto Unity. Per questo codelab, inserisci quanto segue:
   • Per Apple (iOS): inserisci com.google.firebase.level-up nel campo ID bundle iOS.
   • Per Android: inserisci com.google.firebase.level_up nel campo Nome pacchetto Android.
4. (Facoltativo) Inserisci i nickname specifici per la piattaforma del tuo progetto Unity.
5. Fai clic su Registra app e vai alla sezione Scarica il file di configurazione.
6. Ripeti la procedura per il target di build che non hai eseguito la prima volta.

Aggiungere i file di configurazione di Firebase

Dopo aver fatto clic su Registra app, ti verrà chiesto di scaricare due file di configurazione (uno per ogni target di build). Per connettersi a Firebase, il progetto Unity ha bisogno dei metadati di Firebase in questi file.

1. Scarica entrambi i file di configurazione disponibili:
   • Per Apple (iOS): scarica GoogleService-Info.plist.
   • Per Android: scarica google-services.json.
2. Apri la finestra Project (Progetto) del progetto Unity, quindi sposta entrambi i file di configurazione nella cartella Assets (Asset).
3. Nella console Firebase, nel flusso di lavoro di configurazione, fai clic su Avanti e procedi ad aggiungere gli SDK Firebase per Unity.

Nota:puoi sempre scaricare di nuovo questi file in un secondo momento aprendo le impostazioni generali del progetto, scorrendo verso il basso fino alla sezione Le tue app e facendo clic sul pulsante di download per il file di configurazione desiderato.

Aggiungi gli SDK Firebase per Unity

1. Fai clic su Scarica l'SDK Firebase Unity nella console Firebase.
2. Decomprimi l'SDK in un percorso semplice da raggiungere.
3. Nel tuo progetto Unity aperto, vai a Assets > Import Package > Custom Package (Risorse > Importa pacchetto > Pacchetto personalizzato).
4. Nella finestra di dialogo Importa pacchetto, vai alla directory che contiene l'SDK non compresso, seleziona FirebaseAnalytics.unitypackage e poi fai clic su Apri.
5. Nella finestra di dialogo Import Unity Package (Importa il pacchetto Unity) visualizzata, fai clic su Import (Importa).
6. Ripeti i passaggi precedenti per importare i due pacchetti seguenti:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics è uno strumento di reporting degli arresti anomali leggero e in tempo reale che ti aiuta a monitorare, assegnare priorità e risolvere i problemi di stabilità che compromettono la qualità della tua app. Se non l'hai mai utilizzato, ti consigliamo di completare il percorso di apprendimento di Crashlytics per Unity.
7. Torna alla console Firebase e, nel flusso di lavoro di configurazione, fai clic su Avanti.

Per saperne di più sull'aggiunta degli SDK Firebase ai progetti Unity, consulta Opzioni di installazione di Unity aggiuntive.

4. Imposta i valori predefiniti di Remote Config e recupera i nuovi valori

In questo codelab, aggiornerai gli oggetti che utilizzano valori definiti nel codice o serializzati nell'editor Unity in modo che utilizzino valori instrumentati con Remote Config. Configurerai i valori predefiniti per ogni parametro utilizzando SetDefaultsAsync, in modo che l'app si comporti come previsto prima di connettersi al backend Remote Config. La tua app rimarrà aggiornata recuperando nuovi valori da Remote Config e attivandoli per renderli utilizzabili nel codice.

Per recuperare nuovi valori da Remote Config, nel file Assets/Hamster/Scripts/MainGame.cs sono già presenti diversi metodi non implementati che devono essere completati.

1. Aggiungi le seguenti istruzioni using a MainGame.cs:

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

   Il modulo Firebase.Extensions contiene alcune estensioni dell'API C# Tasks che semplificheranno la gestione del processo di inizializzazione con i callback.
2. Aggiungi l'inizializzazione di Firebase al metodo MainGame.cs Start() sostituendo il metodo InitializeCommonDataAndStartGame() esistente con il metodo attualmente non implementato InitializeFirebaseAndStartGame():

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

3. In MainGame.cs, trova InitializeFirebaseAndStartGame(). Dichiara una variabile dell'app e sovrascrivi l'implementazione del metodo nel seguente modo:

   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. Le chiamate di inizializzazione di Firebase SetRemoteConfigDefaults in caso di esito positivo per impostare i valori predefiniti in-app. Sostituisci il metodo SetRemoteConfigDefaults non implementato con il seguente:

   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. Recupera e attiva i nuovi valori (se necessario)

Ora dobbiamo completare il metodo FetchRemoteConfig esistente. In questo modo, le chiamate ai metodi FetchAsync (che recupera nuovi valori da Remote Config) e ActivateAsync (che attiva i valori ottenuti per renderli disponibili nel codice) di Remote Config vengono concatenate utilizzando un parametro di callback denominato onFetchAndActivateSuccessful.

Il codice di avvio che abbiamo aggiunto nel passaggio precedente chiama FetchRemoteConfig con InitializeCommonDataAndStartGame come callback per avviare il gioco alla fine della sequenza. Puoi passare callback alternativi a FetchRemoteConfig per richiamare il recupero con risultati diversi. Un esempio (che implementerai in un secondo momento) è il passaggio di un metodo che apre nuovi menu dell'interfaccia utente, che dipendono dai valori di Remote Config. In questo modo, i menu si apriranno solo dopo che i valori sono stati recuperati e attivati.

1. Incolla il codice riportato di seguito in 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);
         });
   }
   

2. Successivamente, completa il metodo ActivateRetrievedRemoteConfigValues, che riceve un callback passato, onFetchAndActivateSuccessful. Al termine dell'attivazione, verrà richiamato il callback specificato:

   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();
            });
      }
   }
   

Quando viene chiamato a valle da SetRemoteConfigDefaults dal contesto di inizializzazione, ActivateRetrievedRemoteConfigValues chiama il punto di partenza precedente, InitializeCommonDataAndStartGame, per avviare il gioco aprendo il menu principale.

6. Configurare una strategia di caricamento di Remote Config

Per recuperare e attivare i valori in un altro momento durante l'utilizzo dell'app, devi chiamare di nuovo queste funzioni e, se alcuni oggetti hanno memorizzato nella cache i valori, devono essere avvisati di eseguire un aggiornamento. Per sviluppare una strategia per recuperare nuovamente i valori di Remote Config, considera quando sono necessari i nuovi valori e quando avviare il recupero e l'attivazione dei nuovi valori per evitare che cambino durante l'utilizzo.

Come attualmente implementato, i valori di Remote Config vengono recuperati e attivati all'avvio dell'app. I recuperi possono essere nascosti durante le modifiche al menu, bloccando anche l'interazione durante la transizione. Inoltre, questo è spesso il momento più pertinente per ottenere nuovi valori, poiché una modifica dello stato del menu può spesso essere utilizzata per sapere "dove" sta andando il giocatore e prevedere che un valore verrà utilizzato.

Esaminando il sistema di menu di Mechahamster, il modo più semplice per aggiungere aggiornamenti del menu di blocco della UI è chiamarlo prima della ripresa del menu principale (in particolare quando vi si accede uscendo da un altro menu) e passare il metodo di visualizzazione della UI come callback onFetchAndActivateSuccessful. Lo stesso vale per il menu Selezione livello.

Con il caricamento iniziale durante l'avvio dell'app, qualsiasi navigazione nel menu che passa attraverso il menu principale verrà gestita dal primo, mentre qualsiasi rientro nel menu Selezione livello causerà anche un aggiornamento. L'accesso iniziale al menu di selezione del livello non è importante, in quanto è accessibile solo dal menu principale ed è quindi già coperto.

Per attivare questa funzionalità nell'app, completa i metodi pertinenti nel menu principale e seleziona i file di livello, che bloccheranno la visualizzazione della UI fino al completamento di FetchAsync e ActivateAsync:

1. Apri Assets/Hamster/Scripts/States/MainMenu.cs e sostituisci il metodo Resume esistente con il seguente:

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

2. Salva il file.
3. Apri Assets/Hamster/Scripts/States/BaseLevelSelect.cs, sostituisci il metodo Resume esistente con il seguente:

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

4. Salva il file.

7. Eseguire il debug/convalidare i comportamenti di recupero

A questo punto, è utile eseguire un controllo di diagnostica/convalida. La seguente procedura ti consentirà di testare manualmente la tua app e il modo in cui recupera e attiva i valori di Remote Config.

Le informazioni verranno stampate nei log del simulatore, del dispositivo o dell'editor. Per iOS, puoi visualizzare i log del dispositivo e del simulatore in Xcode. Per Android, visualizza i log eseguendo adb logcat. Se esegui il codice in Unity premendo Play nell'editor, i log vengono visualizzati nella scheda Console.

1. Ricompila ed esegui l'app (nell'editor, utilizzando un dispositivo o un simulatore).
2. Dopo la visualizzazione del menu principale del gioco, esamina l'output del log del gioco, che dovrebbe contenere i log generati da Debug.Log in FetchRemoteConfig e ActivateRetrievedRemoteConfigValues. Dovrebbero essere visualizzati i messaggi "Recupero dati in corso…" e "Dati remoti caricati e pronti". Prendi nota dei timestamp all'inizio di questi messaggi.
3. Nel gioco, premi Licenza.
4. Premi Ok.
5. Attendi la visualizzazione del menu principale del gioco.
6. Esamina l'output del log del gioco, che dovrebbe essere simile a quelli del passaggio precedente, con nuovi timestamp (corrispondenti all'ora impostata sull'orologio di sistema in cui stai eseguendo il gioco).
7. Nel gioco, premi Gioca.
8. Premi Iniziamo.
9. Sposta la palla verso la porta utilizzando i tasti freccia della tastiera, che apriranno un menu Livello completato.
10. Premi Livelli.
11. Attendi il caricamento del menu Selezione livello.
12. Rivedi l'output del log del gioco. Devono corrispondere ai messaggi di log dei passaggi precedenti, con timestamp più recenti (corrispondenti all'ora impostata sull'orologio di sistema in cui stai eseguendo il gioco).

Se uno di questi non è visualizzato nell'app, è possibile che una parte del flusso di recupero e attivazione (o del dispositivo) sia configurata in modo errato. Se il primo log non viene visualizzato, è possibile che il gioco non si avvii. Esamina la console dell'editor o i log del dispositivo/emulatore per individuare avvisi ed errori relativi al tuo progetto/ambiente e analizzali. Il problema potrebbe essere semplice come la connessione a internet.

Se vengono visualizzati i log iniziali del caricamento del menu, ma non uno di quelli successivi, esamina/reimplementa i metodi Resume in Assets/Hamster/Scripts/States/MainMenu.cs e Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

8. Strumentare il codice

Ora che hai configurato i valori dei parametri in-app in SetDefaultsAsync() e reso disponibili le versioni più aggiornate con FetchAsync() e ActivateAsync(), farai riferimento a questi valori e li utilizzerai nel codice.

Dopo aver impostato i valori nel backend di Remote Config, recuperali e attivali (o esegui entrambe le operazioni contemporaneamente), questi valori sono disponibili per la tua app. Per utilizzarli, chiama GetValue(string key) e scegli una chiave parametro come argomento. Viene restituito un ConfigValue, che ha proprietà per accedere al valore come vari tipi supportati: string, bool, long, double. In questo progetto e nella maggior parte dei casi d'uso di gioco, devi eseguire il cast degli ultimi due tipi in int e float, che sono più idiomatici. Per assicurarti che queste conversioni non causino problemi, verifica che i valori iniziali impostati in Remote Config rientrino nell'intervallo valido dei tipi che utilizzerai nel codice dell'app.

1. Importa Remote Config aggiungendo using Firebase.RemoteConfig; all'inizio dei seguenti file:
   • Assets/Hamster/Scripts/States/MainMenu.cs
   • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
2. Sostituisci il metodo Start di AccelerationTile.cs:

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

   Con questa modifica, la forza impartita dal riquadro dell'accelerazione verrà modificata in base a quella ricevuta da Remote Config.
3. Modifica il corpo del metodo InitializeUI di 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();
   }
   

   In questo caso, subtitleOverride è impostato per modificare il sottotitolo nella schermata del menu principale se tutti i suoi campi nel cloud sono impostati su valori diversi da quelli predefiniti del tipo.

9. Impostare i valori dei parametri da remoto

Ora che la tua app è completamente strumentata, puoi configurare parametri e valori sul server Remote Config. In questo codelab, configureremo questa funzionalità utilizzando la console Firebase.

1. Nella console Firebase, apri il tuo progetto.
2. Seleziona Remote Config dal menu per visualizzare la dashboard di Remote Config.
3. Per ciascuno dei parametri definiti nell'app ed elencati nella tabella seguente, fai clic su Aggiungi parametro, incolla il nome del parametro (chiave), seleziona il Tipo di dati elencato nella tabella, disattiva Usa valore predefinito in-app e incolla il nuovo valore predefinito:

   Nome parametro (chiave)	Tipo di dati	Valore predefinito
   acceleration_tile_force	Numero	100
   subtitle_override	JSON	{"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}

   
4. Fai clic su Salva per salvare le modifiche.
5. Fai clic su Pubblica per pubblicare la nuova configurazione e rendere disponibili i nuovi valori per il tuo gioco.
6. Esegui di nuovo l'app dopo aver impostato questi parametri remoti e osserva come sostituiscono i valori predefiniti originali.

10. Utilizzare le condizioni di Remote Config per pubblicare le varianti

Potresti voler personalizzare l'esperienza dell'app in base alla lingua parlata dall'utente, alla sua posizione, all'ora del giorno o alla piattaforma che utilizza. Le condizioni Remote Config ti consentono di utilizzare questi e altri attributi singolarmente o in combinazione per mostrare all'utente valori diversi (chiamati varianti).

Un utilizzo comune delle condizioni è quello di modificare i contenuti tra le piattaforme iOS e Android. Segui i passaggi riportati di seguito per implementare una condizione che restituisce un valore diverso per subtitle_override a seconda della piattaforma in uso.

1. Apri la scheda Remote Config del tuo progetto nella console Firebase.
2. Fai clic sul pulsante di modifica per subtitle_override..
3. Nell'angolo in basso a sinistra, fai clic su Aggiungi nuovo.
4. Nel menu a discesa visualizzato, passa il mouse sopra Valore condizionale e fai clic su Crea nuova condizione.
5. Quando richiesto, assegna alla condizione il nome "is iOS" se scegli come target iOS o "is Android" se scegli come target Android. Se hai scelto come target entrambi, scegli uno dei due e utilizzalo per il resto del codelab.
6. Nella sezione Applicabile se…, fai clic sul menu a discesa Seleziona… e seleziona Piattaforma. Poi, seleziona la piattaforma appropriata.
7. Fai clic su Crea condizione per creare la condizione. Viene visualizzata di nuovo la finestra di dialogo Modifica parametro e ora puoi impostare un valore:
   • Se il targeting è Android, imposta Valore su:

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

   • Se scegli come target iOS, imposta Valore su:

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

8. Fai clic su Salva per salvare le modifiche.
9. Fai clic su Pubblica per pubblicare la nuova configurazione e rendere disponibili i nuovi valori per il tuo gioco.

Se crei ed esegui di nuovo il gioco, dovresti vedere il sottotitolo sostituito con la variante specifica per la piattaforma.

11. Configurare Remote Config per ricevere aggiornamenti in tempo reale

Remote Config ora può ascoltare e gestire gli aggiornamenti dei modelli Remote Config in tempo reale. Le app possono abbonarsi alla nuova API Remote Config in tempo reale per rilevare modifiche alla configurazione e valori aggiornati.

Come funziona

Per ascoltare gli aggiornamenti, la tua app deve implementare un metodo che si iscriva all'evento OnConfigUpdateListener. Mentre uno o più listener di aggiornamento della configurazione sono iscritti, i nuovi modelli di Remote Config vengono recuperati automaticamente, vengono chiamati i gestori iscritti e possono essere utilizzati per eseguire la logica in risposta, ad esempio attivando i nuovi valori e rendendoli disponibili al resto dell'applicazione.

Implementare Remote Config in tempo reale

Per illustrare come funziona nel gioco, apporta le seguenti modifiche al codice.

Creare un gestore di aggiornamenti della configurazione

Il primo passaggio per utilizzare l'evento di aggiornamento della configurazione consiste nel creare un metodo in grado di rilevarlo. Inserisci il seguente metodo in 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.");
         });
   }

Questo metodo stampa un elenco delle chiavi aggiornate e un messaggio di conferma nel log quando attiva i nuovi valori.

Iscriviti all'evento Update

Per attivare ActivateValuesOnConfigUpdate quando viene chiamato l'evento, iscriviti all'evento. Sostituisci il metodo InitializeCommonDataAndStartGame() in Assets/Hamster/Scripts/MainGame.cs con quanto segue:

   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 nuova riga (che termina con += ActivateValuesOnConfigUpdate;) iscrive il gestore di eventi all'evento.

Annulla l'iscrizione quando l'oggetto proprietario del gestore viene eliminato

Per evitare errori di riferimento nullo, gli oggetti con metodi iscritti agli eventi devono annullare la sottoscrizione del metodo quando vengono eliminati. Aggiungi il seguente metodo a Assets/Hamster/Scripts/MainGame.cs:

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

Testare la nuova funzionalità

Per convalidare la nuova funzionalità, prova l'app creata. La seguente procedura richiede di poter leggere il log ed eseguire il debug utilizzando un dispositivo reale.

Modifica acceleration_tile_force e osserva

Dopo aver avviato l'app, nella sezione Remote Config della console Firebase:

1. Premi il pulsante Modifica accanto a acceleration_tile_force.

2. Modifica il valore in "120" e premi Salva.

3. Fai clic sul pulsante Pubblica modifiche.

4. Controlla il log.
5. Se visualizzi un messaggio di log che inizia con "Error occurred while listening" (Si è verificato un errore durante l'ascolto), leggi il resto del messaggio e prova a eseguire il debug con il messaggio di errore stampato.
6. Se vedi un log che inizia con "Updated keys" (Chiavi aggiornate), la tua app ha ricevuto i valori modificati.
7. Se non vedi nessuno di questi elementi, esamina il resto dei log, rivedi le istruzioni riportate in Crea un gestore di aggiornamenti della configurazione, esegui nuovamente il test e controlla di nuovo i log per determinare se c'è qualcosa che non va.

12. Complimenti!

Hai utilizzato Remote Config per controllare i valori in-game da remoto recuperandoli nella tua app e utilizzando le condizioni per pubblicare varianti diverse.

Argomenti trattati

• Come impostare e recuperare i valori di Remote Config
• Come instrumentare il codice C# di Unity per utilizzare i valori recuperati
• Come archiviare, strumentare e sostituire valori/oggetti composti come valori JSON
• Come utilizzare le condizioni di Remote Config per pubblicare varianti di valori diversi

Passaggi successivi

Scopri di più sulla priorità dei valori dei parametri per comprendere meglio la logica di quali valori vengono ottenuti da un'istanza dell'app quando utilizza un parametro con più valori (a causa di condizioni o località).