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, in modo da modificare l'aspetto e il comportamento dell'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 sue funzionalità Firebase integrate, dando la possibilità di implementare al loro posto nuovi utilizzi di Firebase.

Per assicurarti che l'app si comporti come previsto, dovrai impostare configurazioni predefinite per i valori nel codice di gioco di esempio, che possono essere sostituiti dai valori impostati in Remote Config nella Console Firebase.

Obiettivi didattici

• Come impostare i valori di Remote Config nel cloud e recuperarli
• Come eseguire l'instrumentazione del codice C# di Unity per utilizzare automaticamente i valori recuperati
• Come memorizzare, analizzare e ignorare valori/oggetti composti come valori JSON
• Come utilizzare le condizioni di Remote Config per pubblicare varianti di valore diverse per gruppi di utenti diversi

Che cosa ti serve

• Unity 2019.1.0f1 o versioni successive con supporto per le build per iOS e/o Android
• Un dispositivo Android/iOS fisico 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 Livello superiore con Firebase, aprirlo in Unity e aggiungere un progetto Firebase. Questo gioco di esempio sali di livello con Firebase è utilizzato da diversi altri codelab Firebase e Unity, quindi potresti aver già completato le attività di questa sezione. In questo caso, puoi saltare questi passaggi e andare 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 Sali di livello con Firebase nell'editor Unity

1. Avvia l'hub Unity e, dalla scheda Progetti, fai clic sulla freccia del menu a discesa 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 Asset > Hamster nella scheda Progetto dell'editor Unity.
   

Per ulteriori informazioni sull'installazione e sull'utilizzo di Unity, consulta 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 che ti interessa.
   Verrà impostato anche l'ID progetto (visualizzato sotto il nome del progetto) su un valore basato sul nome del progetto. Se vuoi, puoi fare clic sull'icona di modifica sull'ID progetto per personalizzarlo ulteriormente.
3. Se richiesto, leggi e accetta i Termini di Firebase.
4. Fai clic su Continua.
5. Seleziona l'opzione Abilita Google Analytics per questo progetto e poi fai clic su Continua.
6. Seleziona un account Google Analytics esistente da utilizzare oppure Crea un nuovo account per crearne uno nuovo.
7. Fai clic su Crea progetto.
8. Una volta creato il progetto, fai clic su Continua.

Registra la tua app con Firebase

1. Apri la console Firebase e, al centro della pagina di riepilogo del progetto, fai clic sull'icona di 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 la registrazione sia delle destinazioni di build Apple (iOS) che di quelle Android.
3. Inserisci gli ID specifici della piattaforma del progetto Unity. Per questo codelab, inserisci quanto segue:
   • Per Apple (iOS): inserisci com.google.firebase.level-up nel campo ID pacchetto iOS.
   • Per Android: inserisci com.google.firebase.level_up nel campo Nome pacchetto Android.
4. Se vuoi, inserisci i nickname specifici della piattaforma del progetto Unity.
5. Fai clic su Registra app e vai alla sezione Scarica il file di configurazione.
6. Ripeti il processo per la destinazione di build che non hai eseguito la prima volta.

Aggiungi file di configurazione Firebase

Dopo aver fatto clic su Registra app, ti verrà chiesto di scaricare due file di configurazione (uno per ogni target di build). Il tuo progetto Unity richiede i metadati Firebase in questi file per connettersi a 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 Project (Progetto) del progetto Unity, quindi sposta entrambi i file di configurazione nella cartella Assets (Asset).

   Importante: anche se prevedi di creare solo app per iOS o Android, devi scaricare entrambi i file e aggiungerli al progetto.

3. Torna alla console Firebase, nel flusso di lavoro di configurazione, fai clic su Avanti e vai ad Aggiungi SDK Firebase per Unity.

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

Aggiungere gli SDK Firebase per Unity

1. Fai clic su Scarica l'SDK Firebase Unity nella console Firebase.

   Nota: il download di questo SDK potrebbe richiedere un po' di tempo. Visualizza un'anteprima dei passaggi successivi o fai una breve pausa.

2. Decomprimi l'SDK in una posizione comoda.
3. Nel progetto Unity aperto, vai a Asset > Importa pacchetto > Pacchetto personalizzato.
4. Nella finestra di dialogo Importa pacchetto, vai alla directory che contiene l'SDK non compresso, seleziona FirebaseAnalytics.unitypackage e fai clic su Apri.
5. Nella finestra di dialogo Importa pacchetto Unity visualizzata, fai clic su Importa.
6. Ripeti i passaggi precedenti per importare i seguenti due pacchetti:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics è uno strumento di reporting degli arresti anomali leggero e in tempo reale che ti aiuta a monitorare, dare la priorità e risolvere i problemi di stabilità che compromettono la qualità della tua app. Se non l'hai mai utilizzata in precedenza, considera il completamento del 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 di SDK Firebase ai progetti Unity, consulta Opzioni di installazione aggiuntive di Unity.

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

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

Per recuperare nuovi valori da Remote Config, è necessario completare una serie di metodi non implementati già presenti nel file Assets/Hamster/Scripts/MainGame.cs.

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 Tasks C# che ti aiuteranno a semplificare 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 InitializeFirebaseAndStartGame() attualmente non implementato:

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

3. In MainGame.cs, trova InitializeFirebaseAndStartGame(). Dichiara una variabile 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. L'inizializzazione di Firebase chiama SetRemoteConfigDefaults in caso di esito positivo per impostare i valori predefiniti in-app. Sostituisci il metodo SetRemoteConfigDefaults non implementato con quanto segue:

   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 (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 verranno messe in catena 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) viene trasmesso in 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 saranno 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);
         });
   }
   

   Nota: il valore cacheExpiration passato a FetchAsync definisce per quanto tempo i valori recuperati in precedenza devono essere memorizzati nella cache. Durante lo sviluppo, puoi impostarlo su System.TimeSpan.Zero come mostrato sopra. In questo modo, l'app riflette sempre i valori più aggiornati. Tuttavia, quando viene rilasciato in produzione, devi impostare cacheExpiration su un valore più alto per evitare la limitazione. Il periodo di tempo predefinito (quando FetchAsync viene chiamato senza parametri) è di 12 ore.

2. A questo punto, completa il metodo ActivateRetrievedRemoteConfigValues, che riceve un callback di passaggio, onFetchAndActivateSuccessful. Al termine dell'attivazione, viene 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 eventuali oggetti hanno memorizzato nella cache i valori, devono essere avvisati per eseguire un aggiornamento. Per sviluppare una strategia per recuperare nuovamente i valori di Remote Config, valuta quando sono necessari i nuovi valori e quando avviare il recupero e l'attivazione dei nuovi valori per evitare che vengano modificati 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 del menu e bloccare l'interazione durante la transizione. Inoltre, questo è spesso il momento più pertinente per ottenere nuovi valori, poiché una modifica dello stato del menu può essere spesso utilizzata per sapere "dove" sta andando il giocatore e prevedere che verrà utilizzato un valore.

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

Con il caricamento iniziale nell'ambito dell'avvio dell'app, qualsiasi navigazione nel menu tramite il menu principale verrà gestita dal primo, mentre qualsiasi nuovo accesso al menu Selezione livello causerà anche un aggiornamento. L'entrata iniziale nel menu di selezione dei livelli non ha importanza in quanto è accessibile solo dal menu principale ed è quindi già coperta.

Per attivare questa funzionalità nell'app, completa i metodi pertinenti nel menu principale e seleziona i livelli dei file, che bloccheranno la visualizzazione dell'interfaccia utente fino a quando FetchAsync e ActivateAsync non saranno completati:

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.

Nota: sebbene questo codelab fornisca un modo per caricare i valori di Remote Config quando il menu principale e le visualizzazioni di selezione dei livelli sono attivi, sono disponibili altre strategie di caricamento. Per ulteriori informazioni, consulta le strategie di caricamento di Firebase Remote Config.

7. Debug/convalida comportamenti di recupero

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

Le informazioni verranno stampate all'interno dei 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 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 aver visualizzato il menu principale del gioco, controlla l'output del log del gioco, che dovrebbe contenere i log generati da Debug.Log in FetchRemoteConfig e ActivateRetrievedRemoteConfigValues. Dovresti visualizzare i messaggi "Recupero dei dati…" 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 che venga visualizzato il Menu principale del gioco.
6. Esamina l'output del log del gioco, che dovrebbe essere simile a quello del passaggio precedente, con nuovi timestamp (che corrispondono all'ora impostata sull'orologio di sistema su cui stai eseguendo il gioco).
7. Nel gioco, premi Gioca.
8. Premi Inizia.
9. Porta la palla verso l'obiettivo con le frecce della tastiera: si aprirà il menu Livello completato.
10. Premi Livelli.
11. Attendi il caricamento del menu Selezione livello.
12. Rivedi l'output del log del gioco. Dovrebbe corrispondere ai messaggi di log dei passaggi precedenti, con timestamp più recenti (che corrispondono all'ora impostata sull'orologio di sistema in cui stai eseguendo il gioco).

Se uno di questi non è stato visualizzato nella tua app, è possibile che una parte del flusso di recupero e attivazione (o del dispositivo) sia configurata in modo errato. Se il primo log non appare, è possibile che il gioco non si avvii. Controlla la console di Editor o i log del dispositivo/dell'emulatore per verificare la presenza di avvisi ed errori relativi al progetto/all'ambiente e esaminali. Il problema potrebbe essere semplice come la connessione a internet.

Se vengono visualizzati i log iniziali relativi al 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. Strumenti per il 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 a questi valori e li utilizzerai nel codice.

Dopo aver impostato i valori nel backend di Remote Config, averli recuperati e attivati (o aver eseguito entrambe le operazioni contemporaneamente), questi valori sono disponibili per la tua app. Per utilizzarli, chiama GetValue(string key) e scegli una chiave del 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 trasmettere gli ultimi due tipi ai più idiomatici int e float. Per assicurarti 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, l'intensità della 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();
   }
   

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

Nota: SubtitleOverrideKey è un const string definito in MainMenu.cs impostato sul parametro subtitle_override.

9. Imposta i valori dei parametri da remoto

Ora che l'app è completamente dotata, puoi configurare parametri e valori sul server Remote Config. In questo codelab, eseguiremo la configurazione utilizzando la console Firebase.

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

   Nome parametro (chiave)	Tipo di dati	Valore predefinito
   forza_tile_accelerazione	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}}

   

   Nota: per ogni parametro puoi impostare un valore predefinito che sostituisce il valore predefinito in-app. Per scoprire di più, consulta Parametri e condizioni di Remote Config.

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.

   Suggerimento: per i valori più difficili da osservare, come i valori fisici, puoi aggiornare il codice per registrare il valore di ConfigValue.Source per determinare se i valori sono quelli predefiniti configurati o se sono stati recuperati dal server Remote Config.

Nota: utilizza i metodi ToJson e FromJson<T> di JsonUtility di Unity per codificare e decodificare un oggetto dati Serializable da e verso una stringa (come avviene attualmente nell'inizializzazione di SubtitleOverrideDefault in MainMenu.cs). La documentazione di Serializable di Unity descrive le limitazioni di Unity relative alla serializzazione degli oggetti.

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

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

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

1. Apri la scheda Remote Config del tuo progetto nella console di 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 "è iOS" se scegli come target iOS o "è Android" se scegli come target Android. Se scegli come target entrambi, scegline uno qui e utilizzalo per il resto del codelab.
6. In Si applica se..., fai clic sul menu a discesa Seleziona... e seleziona Piattaforma. A questo punto, 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 puoi impostare un valore:
   • Se scegli 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 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 sviluppi ed esegui di nuovo il gioco, dovresti vedere il sottotitolo del gioco sostituito con la variante specifica per la piattaforma.

11. Configura Remote Config per ricevere aggiornamenti in tempo reale

Nota: gli aggiornamenti di configurazione remota in tempo reale sono supportati per la versione dell'SDK 11.0.0 e successive per le piattaforme Android e Apple. Al momento non è supportato nella modalità Play Unity.

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

Come funziona

Per rimanere in ascolto degli aggiornamenti, la tua app deve implementare un metodo di sottoscrizione all'evento OnConfigUpdateListener. Quando sono iscritti uno o più ascoltatori di aggiornamento della configurazione, i nuovi modelli Remote Config vengono recuperati automaticamente, i gestori iscritti vengono chiamati e possono essere utilizzati per eseguire la logica in risposta, ad esempio attivare i nuovi valori e renderli disponibili per il resto dell'applicazione.

Nota: se tutti gli iscritti vengono rimossi da OnConfigUpdateListener, quest'ultimo smetterà di monitorare le modifiche al modello di configurazione remota del progetto.

Implementa Remote Config in tempo reale

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

Crea un gestore Config Update

Il primo passaggio per utilizzare l'evento di aggiornamento della configurazione consiste nel 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 stampa un elenco di chiavi aggiornate e un messaggio di successo nel log quando attiva i nuovi valori.

Iscriviti all'evento Aggiornamento

Per attivare ActivateValuesOnConfigUpdate quando viene chiamato l'evento, abbonalo 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 di eventi all'evento.

Annulla l'iscrizione quando l'oggetto proprietario dell'handler viene distrutto

Per evitare errori di riferimento null, gli oggetti con metodi iscritti agli eventi devono annullare l'iscrizione a quel metodo quando vengono distrutti. Aggiungi il seguente metodo a Assets/Hamster/Scripts/MainGame.cs:

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

Testa la nuova funzionalità

Per convalidare la nuova funzionalità, prova l'app creata. La procedura che segue richiede che tu possa leggere il log e eseguire il debug utilizzando un dispositivo reale.

Modifica acceleration_tile_force e osserva

Una volta avviata l'app, nella sezione Remote Config della Console Firebase:

1. Premi il pulsante di modifica accanto a acceleration_tile_force.

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

3. Fai clic sul pulsante Pubblica modifiche.

4. Esamina il diario.
5. Se visualizzi un messaggio di log che inizia con "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 "Chiavi aggiornate", la tua app abbia ricevuto i valori modificati.
7. Se non vedi nessuna di queste opzioni, esamina il resto dei log e poi rivedi le istruzioni in Creare un gestore Config Update, ripeti il test e ricontrolla i log per determinare se ci sono errori.

Avviso: tieni presente che non verrà recuperato un nuovo valore condizionale se modifichi la valutazione della relativa condizione (ad esempio se un utente ha impostato determinate proprietà utente di Analytics o se fa parte di un segmento di pubblico di Analytics). Per il momento, mantieni le chiamate a FetchRemoteConfig (che chiama FetchAndActivate) in Assets/Hamster/Scripts/States/MainMenu.cs e Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

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 eseguire l'instrumentazione del codice C# di Unity per utilizzare i valori recuperati
• Archiviare, instrumentare ed eseguire l'override di valori/oggetti composti come valori JSON
• Come utilizzare le condizioni Remote Config per pubblicare varianti di valori diverse

Passaggi successivi

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

Vai al passaggio successivo del percorso,in cui utilizzerai questi valori strumentati per eseguire test A/B di diverse varianti al fine di comprendere meglio come influiscono sul comportamento degli utenti.