Gestisci il tuo 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 aggiornare i relativi valori nel cloud, consentendoti di modificare l'aspetto e il comportamento della tua app senza distribuire un aggiornamento dell'app.

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 che rimuove la maggior parte delle funzionalità Firebase integrate, dandoti la possibilità di implementare nuovi usi di Firebase al loro posto.

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

Cosa imparerai

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

Di cosa avrai bisogno

• Unity 2019.1.0f1 o versione successiva con supporto build iOS e/o Android
• Un dispositivo Android/iOS fisico o un simulatore/emulatore per creare ed eseguire il gioco

2. Configura il tuo ambiente di sviluppo

Le sezioni seguenti descrivono come scaricare il codice Level Up with Firebase , aprirlo in Unity e aggiungere un progetto Firebase. Questo gioco di esempio Level Up with Firebase viene utilizzato da molti altri codelab Firebase + Unity, quindi potresti aver già completato le attività in questa sezione. In tal caso, puoi saltare questi passaggi e procedere con l'aggiunta degli SDK Firebase per Unity per aggiungere Remote Config al codice del 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 git installato, puoi scaricare il repository come file ZIP .

Apri Level Up con Firebase nell'editor Unity

1. Avvia Unity Hub e, dalla scheda Progetti , fai clic sulla freccia a discesa accanto a Apri .
2. Fai clic su Aggiungi progetto da disco .
3. Passare alla directory che contiene il codice, quindi fare clic su OK .
4. Se richiesto, seleziona la 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 il tuo editor non lo apre automaticamente, apri MainGameScene in Risorse > Hamster nella scheda Progetto dell'editor Unity.
   

Per ulteriori informazioni sull'installazione e sull'utilizzo di Unity, vedere Lavorare in Unity .

3. Aggiungi Firebase al tuo progetto Unity

Crea un progetto Firebase

1. Nella console Firebase , fai clic su Aggiungi progetto .
2. Per creare un nuovo progetto, inserisci il nome del progetto desiderato.
   Ciò imposterà anche l'ID progetto (visualizzato sotto il nome del progetto) su qualcosa basato sul nome del progetto. Facoltativamente, puoi fare clic sull'icona di modifica sull'ID progetto per personalizzarlo ulteriormente.
3. Se richiesto, esamina e accetta i termini di Firebase .
4. Fare clic su Continua .
5. Seleziona l'opzione Abilita Google Analytics per questo progetto , quindi fai clic su Continua .
6. Seleziona un account Google Analytics esistente da utilizzare o seleziona Crea un nuovo account per creare un nuovo account.
7. Fare clic su Crea progetto .
8. Una volta creato il progetto, fare clic su Continua .

Registra la tua app con Firebase

1. Apri la console Firebase e, dal centro della pagina di panoramica del progetto, fai clic sull'icona Unity per avviare il flusso di lavoro di configurazione o, se hai già aggiunto un'app al tuo progetto Firebase, fai clic su Aggiungi app per visualizzare le opzioni della piattaforma.
2. Selezionare per registrare sia i target di build Apple (iOS) che quelli Android.
3. Inserisci gli ID specifici della 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 del nome del pacchetto Android .
4. Facoltativamente, inserisci i nickname specifici della piattaforma del tuo progetto Unity.
5. Fai clic su Registra app e procedi alla sezione Scarica file di configurazione .
6. Ripeti la procedura per qualsiasi destinazione di build che non hai eseguito la prima volta.

Aggiungi file di configurazione Firebase

Dopo aver fatto clic su Register app , ti verrà richiesto di scaricare due file di configurazione (un file di configurazione per ciascuna destinazione di build). Il tuo progetto Unity necessita dei metadati Firebase in questi file per connettersi con Firebase.

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 Progetto del tuo progetto Unity, quindi sposta entrambi i file di configurazione nella cartella Assets .
3. Tornando alla console Firebase, nel flusso di lavoro di configurazione, fai clic su Avanti e procedi con l'aggiunta degli SDK Firebase per Unity.

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

Aggiungi gli SDK Firebase per Unity

1. Fai clic su Scarica Firebase Unity SDK nella console Firebase.
2. Decomprimi l'SDK in un posto comodo.
3. Nel tuo progetto Unity aperto, vai a Assets > Import Package > Custom Package .
4. Nella finestra di dialogo Importa pacchetto , accedi alla directory che contiene l'SDK decompresso, seleziona FirebaseAnalytics.unitypackage e quindi fai clic su Apri .
5. Nella finestra di dialogo Importa pacchetto Unity visualizzata, fare clic su Importa .
6. Ripetere i passaggi precedenti per importare i due pacchetti seguenti:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics è un reporter leggero e in tempo reale sugli arresti anomali che ti aiuta a monitorare, stabilire le priorità e risolvere i problemi di stabilità che minano la qualità della tua app. Se non lo hai mai utilizzato in precedenza, valuta la possibilità 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 ulteriori informazioni sull'aggiunta di SDK Firebase ai progetti Unity, consulta Opzioni di installazione aggiuntive di Unity .

4. Impostare le impostazioni predefinite di Remote Config e recuperare nuovi valori

In questo codelab aggiornerai gli oggetti che utilizzano valori definiti nel codice o sono serializzati nell'editor Unity per utilizzare valori strumentati con Remote Config. Configurerai i valori predefiniti per ogni parametro utilizzando SetDefaultsAsync in modo che la tua 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, sono presenti numerosi metodi non implementati già presenti nel file Assets/Hamster/Scripts/MainGame.cs 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 all'API C# Tasks che contribuiranno a semplificare la gestione del processo di inizializzazione con i callback.
2. Aggiungi l'inizializzazione di Firebase al tuo metodo MainGame.cs Start() sostituendo il metodo esistente InitializeCommonDataAndStartGame() 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 come segue:

   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'inizializzazione di Firebase chiama SetRemoteConfigDefaults in caso di successo 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 nuovi valori (secondo necessità)

Ora dobbiamo completare il metodo FetchRemoteConfig esistente. Ciò concatena le chiamate ai metodi di Remote Config FetchAsync (che recupera nuovi valori da Remote Config) e ActivateAsync (che attiva i valori ottenuti per renderli disponibili nel codice) 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 seguito) sta passando un metodo che apre nuovi menu dell'interfaccia utente, che dipendono dai valori di Remote Config. Ciò farà sì che i menu si aprano solo dopo che tali valori siano stati recuperati e attivati.

1. Incolla il codice seguente 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 downstream 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'uso dell'app, è necessario richiamare nuovamente queste funzioni e, se qualche oggetto ha memorizzato nella cache i valori, deve essere avvisato per eseguire un aggiornamento. Per sviluppare una strategia per recuperare i valori di Remote Config, considerare quando sono necessari i nuovi valori e quando avviare il recupero e l'attivazione di nuovi valori per evitare che vengano modificati durante l'uso.

Come attualmente implementati, i valori di Remote Config vengono recuperati e attivati ​​all'avvio dell'app. I recuperi possono essere nascosti durante le modifiche al menu e allo stesso tempo bloccano l'interazione durante la transizione. Inoltre, questo è spesso il momento più rilevante per ottenere nuovi valori, poiché un cambiamento nello stato del menu può spesso essere utilizzato 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 dell'interfaccia utente è chiamarlo prima che il menu principale riprenda (in particolare quando si accede uscendo da un altro menu) e passare il metodo di visualizzazione dell'interfaccia utente come callback onFetchAndActivateSuccessful . Lo stesso può essere fatto per il menu Selezione livello .

Con il caricamento iniziale come parte dell'avvio dell'app, qualsiasi navigazione nel menu che passa attraverso il menu principale verrà gestita dal primo di questi, mentre anche qualsiasi rientro nel menu di selezione del livello causerà un aggiornamento. L'ingresso iniziale nel menu di selezione del livello non ha importanza poiché è possibile accedervi solo dal menu principale ed è quindi già coperto.

Per abilitarlo nell'app, completa i metodi pertinenti nel menu principale e seleziona i file di livello, che bloccheranno la visualizzazione dell'interfaccia utente fino al completamento di FetchAsync e ActivateAsync :

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

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

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

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

4. Salvare il file.

7. Debug/convalida dei comportamenti di recupero

A questo punto, è utile eseguire un controllo diagnostico/convalida. La seguente procedura ti consentirà di testare manualmente la tua app e come/se recupera e attiva i valori di Remote Config.

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

1. Ricostruisci ed esegui l'app (nell'editor, utilizzando un dispositivo o un simulatore).
2. Dopo che viene visualizzato il menu principale del gioco, esamina l'output del registro del gioco, che dovrebbe contenere i registri generati da Debug.Log in FetchRemoteConfig e ActivateRetrievedRemoteConfigValues ​​. Dovrebbero mostrare i messaggi "Recupero dati..." e "Dati remoti caricati e pronti". Nota i timestamp all'inizio di questi messaggi.
3. Nel gioco, premi Licenza .
4. Premi Ok .
5. Attendi che venga visualizzato il menu principale del gioco.
6. Controlla l'output del registro del tuo 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 Let's Roll .
9. Sposta la palla verso la porta utilizzando le frecce della tastiera, che aprirà il menu Livello completato.
10. Premere Livelli .
11. Attendi il caricamento del menu di selezione del livello .
12. Controlla nuovamente l'output del registro del gioco. Dovrebbe corrispondere ai messaggi di registro dei passaggi precedenti, con timestamp più recenti (corrispondenti all'ora impostata sull'orologio di sistema in cui stai eseguendo il gioco).

Se qualcuno di questi non viene visualizzato nella tua app, alcune parti del flusso di recupero e attivazione (o del tuo dispositivo) potrebbero essere configurate in modo errato. Se il primo registro non viene visualizzato, è possibile che il gioco non si avvii. Esamina la console dell'editor o i registri 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 uno dei successivi no, esaminare/reimplementare i metodi Resume in Assets/Hamster/Scripts/States/MainMenu.cs e Assets/Hamster/Scripts/States/BaseLevelSelect.cs .

8. Strumenta il tuo codice

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

Dopo aver impostato i valori nel backend Remote Config, averli recuperati e attivati ​​( o aver eseguito entrambe le operazioni contemporaneamente ), tali valori saranno disponibili per la tua app. Per utilizzare questi valori, chiamare GetValue(string key ) e scegliere una chiave di parametro come argomento. Ciò restituisce 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 dei giochi, è necessario eseguire il cast degli ultimi due tipi sui più idiomatici int e float . Per garantire che queste conversioni non causino problemi, assicurati 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 quantità di forza impartita dal riquadro di accelerazione verrà modificata in 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();
   }
   

   Qui, subtitleOverride è impostato per modificare il sottotitolo nella schermata del menu principale se tutti i relativi campi nel cloud sono impostati come valori diversi dai valori predefiniti del relativo tipo .

9. Impostare i valori dei parametri in remoto

Ora che la tua app è completamente strumentata, sei pronto per configurare parametri e valori sul server Remote Config. In questo codelab lo configureremo utilizzando la console Firebase.

1. Nella console Firebase , apri il tuo progetto.
2. Selezionare Remote Config dal menu per visualizzare il dashboard Remote Config.
3. Per ciascuno dei parametri definiti nella tua 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 Utilizza predefinito in-app e incolla il campo nuovo valore predefinito:

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

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

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

Potresti voler adattare l'esperienza dell'app all'utente in base alla lingua che parla, a dove si trova, all'ora del giorno o alla piattaforma che utilizza. Le condizioni Remote Config ti danno la possibilità di utilizzare questi e altri attributi singolarmente o in combinazione per fornire valori diversi (chiamati varianti) all'utente.

Un uso comune delle condizioni è modificare il contenuto tra le piattaforme iOS e Android. Segui i passaggi seguenti per implementare una condizione che offra un valore diverso per subtitle_override a seconda della piattaforma in uso.

1. Apri la scheda Configurazione remota 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 su Valore condizionale e fai clic su Crea nuova condizione.
5. Quando richiesto, denomina la condizione "è iOS" se hai scelto come target iOS o "è Android" se hai scelto come target Android. Se li vuoi prendere di mira entrambi, scegline semplicemente uno qui e usalo per il resto del codelab.
6. In Si applica se... , fai clic sul menu a discesa Seleziona... e seleziona Piattaforma . Quindi, seleziona la piattaforma appropriata.
7. Fare clic su Crea condizione per creare la condizione. Viene nuovamente visualizzata la finestra di dialogo Modifica parametro ed è ora possibile impostare un valore:
   • Se hai scelto come target Android, imposta il valore su:

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

   • Se hai scelto come target iOS, imposta il valore su:

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

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

Se crei ed esegui nuovamente il gioco, dovresti vedere il sottotitolo del gioco sostituito con la sua variante specifica della piattaforma.

11. Configurare Remote Config per ricevere aggiornamenti in tempo reale

Remote Config ora può ascoltare e gestire gli aggiornamenti ai modelli Remote Config in tempo reale . Le app possono iscriversi alla nuova API Remote Config in tempo reale per ascoltare le modifiche di configurazione e i valori aggiornati.

Come funziona

Per ascoltare gli aggiornamenti, la tua app deve implementare un metodo che sottoscriva l'evento OnConfigUpdateListener . Mentre vengono sottoscritti uno o più listener di aggiornamento della configurazione, i nuovi modelli Remote Config verranno recuperati automaticamente, i gestori sottoscritti vengono chiamati e possono essere utilizzati per eseguire la logica in risposta, come attivare i nuovi valori e renderli disponibili al resto dell'applicazione.

Implementare la configurazione remota in tempo reale

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

Creare un gestore di aggiornamento della configurazione

Il primo passaggio per utilizzare l'evento Config Update è creare un metodo in grado di ascoltarlo. 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 stamperà un elenco di chiavi aggiornate e un messaggio di successo nel registro quando attiva i nuovi valori.

Iscriviti all'evento di aggiornamento

Per attivare ActivateValuesOnConfigUpdate quando viene chiamato l'evento, iscriverlo 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; ) sottoscrive il gestore eventi all'evento.

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

Per evitare errori di riferimento null, gli oggetti con metodi sottoscritti agli eventi devono annullare la sottoscrizione di quel metodo quando vengono distrutti. 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 che sia possibile leggere il registro ed eseguire il debug utilizzando un dispositivo reale .

Cambia acceleration_tile_force e osserva

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

1. Premi il pulsante di modifica accanto a acceleration_tile_force .

2. Modificare il valore in "120" e premere Salva .

3. Fare clic sul pulsante Pubblica modifiche .

4. Ispezionare il registro.
5. Se vedi un messaggio di registro che inizia con "Si è verificato un errore durante l'ascolto", leggi il resto e prova a eseguire il debug con il messaggio di errore stampato.
6. Se vedi un registro che inizia con "Chiavi aggiornate", la tua app ha ricevuto i valori modificati.
7. Se non vedi nessuno di questi, esamina il resto dei tuoi log e poi rivedi le istruzioni da Create a Config Update handler , riprova e ricontrolla i log per determinare se c'è qualcosa che non va.

12. Congratulazioni!

Hai utilizzato Remote Config per controllare i valori di gioco da remoto recuperandoli nella tua app e utilizzando le condizioni per servire diverse varianti!

Di cosa abbiamo parlato

• Come impostare e recuperare i valori di Remote Config
• Come strumentare il codice Unity C# per utilizzare i valori recuperati
• Come archiviare, strumentare e sovrascrivere valori/oggetti composti come valori JSON
• Come utilizzare le condizioni di Remote Config per servire diverse varianti di valore

Prossimi passi

Leggi informazioni 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à).