Instrumentieren Sie Ihr Unity-Spiel mit Firebase Remote Config

1. Einleitung

Sie können Firebase Remote Config verwenden, um Schlüssel-Wert-Paare, auch Parameter genannt, in Ihrer App zu definieren und ihre Werte in der Cloud zu aktualisieren, sodass Sie das Erscheinungsbild und Verhalten Ihrer App ändern können, ohne ein App-Update zu verteilen.

Sie werden diese neue Funktionalität einem Beispielspiel hinzufügen, MechaHamster: Level Up with Firebase Edition . Bei diesem Beispielspiel handelt es sich um eine neue Version des klassischen Firebase-Spiels MechaHamster, das die meisten seiner integrierten Firebase-Funktionen entfernt und Ihnen die Möglichkeit gibt, stattdessen neue Verwendungsmöglichkeiten von Firebase zu implementieren.

Um sicherzustellen, dass sich Ihre App wie vorgesehen verhält, legen Sie Standardkonfigurationen für Werte im Beispielspielcode fest. Diese Werte können durch Werte überschrieben werden , die Sie in Remote Config in der Firebase-Konsole festlegen .

Was Sie lernen werden

• So legen Sie Remote-Konfigurationswerte in der Cloud fest und rufen sie ab
• So instrumentieren Sie Ihren Unity C#-Code, um die abgerufenen Werte automatisch zu verwenden
• So speichern, instrumentieren und überschreiben Sie zusammengesetzte Werte/Objekte als JSON-Werte
• So verwenden Sie Remote Config-Bedingungen, um verschiedenen Benutzergruppen unterschiedliche Wertvarianten bereitzustellen

Was du brauchen wirst

• Unity 2019.1.0f1 oder höher mit iOS- und/oder Android-Build-Unterstützung
• Ein physisches Android-/iOS- Gerät oder ein Simulator/Emulator zum Erstellen und Ausführen des Spiels

2. Richten Sie Ihre Entwicklungsumgebung ein

In den folgenden Abschnitten wird beschrieben, wie Sie den Level Up with Firebase- Code herunterladen, ihn in Unity öffnen und ein Firebase-Projekt hinzufügen. Dieses Level Up with Firebase-Beispielspiel wird von mehreren anderen Firebase + Unity-Codelabs verwendet, sodass Sie die Aufgaben in diesem Abschnitt möglicherweise bereits abgeschlossen haben. Wenn ja, können Sie diese Schritte überspringen und mit „Firebase SDKs für Unity hinzufügen“ fortfahren, um Remote Config zum Beispielspielcode hinzuzufügen.

Laden Sie den Code herunter

Klonen Sie das GitHub-Repository dieses Codelabs über die Befehlszeile:

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

Alternativ können Sie, wenn Sie Git nicht installiert haben, das Repository als ZIP-Datei herunterladen .

Öffnen Sie Level Up mit Firebase im Unity-Editor

1. Starten Sie den Unity Hub und klicken Sie auf der Registerkarte „Projekte“ auf den Dropdown-Pfeil neben „Öffnen“ .
2. Klicken Sie auf Projekt von Datenträger hinzufügen .
3. Navigieren Sie zu dem Verzeichnis, das den Code enthält, und klicken Sie dann auf OK .
4. Wenn Sie dazu aufgefordert werden, wählen Sie eine zu verwendende Unity-Editor-Version und Ihre Zielplattform (Android oder iOS) aus.
5. Klicken Sie auf den Projektnamen „ level-upwith-firebase“ und das Projekt wird im Unity-Editor geöffnet.
6. Wenn Ihr Editor es nicht automatisch öffnet, öffnen Sie MainGameScene unter Assets > Hamster auf der Registerkarte „ Projekt“ des Unity-Editors.
   

Weitere Informationen zur Installation und Verwendung von Unity finden Sie unter Arbeiten in Unity .

3. Fügen Sie Firebase zu Ihrem Unity-Projekt hinzu

Erstellen Sie ein Firebase-Projekt

1. Klicken Sie in der Firebase-Konsole auf Projekt hinzufügen .
2. Um ein neues Projekt zu erstellen, geben Sie den gewünschten Projektnamen ein.
   Dadurch wird auch die Projekt-ID (die unter dem Projektnamen angezeigt wird) auf etwas basierend auf dem Projektnamen festgelegt. Sie können optional auf das Bearbeitungssymbol der Projekt-ID klicken, um sie weiter anzupassen.
3. Wenn Sie dazu aufgefordert werden, lesen Sie die Firebase-Bedingungen durch und akzeptieren Sie sie.
4. Klicken Sie auf Weiter .
5. Wählen Sie die Option „Google Analytics für dieses Projekt aktivieren“ und klicken Sie dann auf „Weiter“ .
6. Wählen Sie ein vorhandenes Google Analytics-Konto aus, das Sie verwenden möchten, oder wählen Sie „Neues Konto erstellen“ , um ein neues Konto zu erstellen.
7. Klicken Sie auf Projekt erstellen .
8. Wenn das Projekt erstellt wurde, klicken Sie auf Weiter .

Registrieren Sie Ihre App bei Firebase

1. Öffnen Sie die Firebase-Konsole und klicken Sie in der Mitte der Projektübersichtsseite auf das Unity-Symbol, um den Setup-Workflow zu starten. Wenn Sie Ihrem Firebase-Projekt bereits eine App hinzugefügt haben, klicken Sie auf App hinzufügen , um die Plattformoptionen anzuzeigen.
2. Wählen Sie diese Option aus, um sowohl die Build-Ziele Apple (iOS) als auch Android zu registrieren.
3. Geben Sie die plattformspezifischen ID(s) Ihres Unity-Projekts ein. Geben Sie für dieses Codelab Folgendes ein:
   • Für Apple (iOS) – Geben Sie com.google.firebase.level-up in das Feld iOS-Bundle-ID ein.
   • Für Android : Geben Sie com.google.firebase.level_up in das Feld „Android-Paketname“ ein.
4. Geben Sie optional die plattformspezifischen Spitznamen Ihres Unity-Projekts ein.
5. Klicken Sie auf App registrieren und fahren Sie mit dem Abschnitt Konfigurationsdatei herunterladen fort.
6. Wiederholen Sie den Vorgang für jedes Build-Ziel, das Sie beim ersten Mal nicht ausgeführt haben.

Fügen Sie Firebase-Konfigurationsdateien hinzu

Nachdem Sie auf „App registrieren“ geklickt haben, werden Sie aufgefordert, zwei Konfigurationsdateien herunterzuladen (eine Konfigurationsdatei für jedes Build-Ziel). Ihr Unity-Projekt benötigt die Firebase-Metadaten in diesen Dateien, um eine Verbindung mit Firebase herzustellen.

1. Laden Sie beide verfügbaren Konfigurationsdateien herunter:
   • Für Apple (iOS) : Laden Sie GoogleService-Info.plist herunter.
   • Für Android : Laden Sie google-services.json herunter.
2. Öffnen Sie das Projektfenster Ihres Unity-Projekts und verschieben Sie dann beide Konfigurationsdateien in den Ordner „Assets“ .

   Wichtig: Auch wenn Sie nur iOS oder Android erstellen möchten, sollten Sie beide Dateien herunterladen und Ihrem Projekt hinzufügen.

3. Klicken Sie zurück in der Firebase-Konsole im Setup-Workflow auf Weiter und fahren Sie mit Firebase SDKs für Unity hinzufügen fort.

Hinweis: Sie können diese Dateien zu einem späteren Zeitpunkt jederzeit erneut herunterladen, indem Sie die allgemeinen Einstellungen Ihres Projekts öffnen, nach unten zum Abschnitt „Ihre Apps“ scrollen und dann auf die Download-Schaltfläche für die gewünschte Konfigurationsdatei klicken.

Fügen Sie Firebase SDKs für Unity hinzu

1. Klicken Sie in der Firebase-Konsole auf Firebase Unity SDK herunterladen .

   Hinweis: Das Herunterladen dieses SDK kann etwas dauern. Schauen Sie sich die nächsten Schritte an oder machen Sie eine kurze Pause.

2. Entpacken Sie das SDK an einem geeigneten Ort.
3. Navigieren Sie in Ihrem geöffneten Unity-Projekt zu Assets > Paket importieren > Benutzerdefiniertes Paket .
4. Navigieren Sie im Dialogfeld „Paket importieren“ zu dem Verzeichnis, das das entpackte SDK enthält, wählen Sie FirebaseAnalytics.unitypackage aus und klicken Sie dann auf „Öffnen“ .
5. Klicken Sie im angezeigten Dialogfeld „Unity-Paket importieren“ auf „Importieren“ .
6. Wiederholen Sie die vorherigen Schritte, um die folgenden zwei Pakete zu importieren:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics ist ein kompakter Echtzeit-Crash-Reporter, der Ihnen hilft, Stabilitätsprobleme zu verfolgen, zu priorisieren und zu beheben, die die Qualität Ihrer App beeinträchtigen. Wenn Sie es noch nicht verwendet haben, sollten Sie den Crashlytics Learning Pathway for Unity absolvieren.
7. Kehren Sie zur Firebase-Konsole zurück und klicken Sie im Setup-Workflow auf Weiter .

Weitere Informationen zum Hinzufügen von Firebase SDKs zu Unity-Projekten finden Sie unter Zusätzliche Unity-Installationsoptionen .

4. Legen Sie die Standardeinstellungen für die Remote-Konfiguration fest und rufen Sie neue Werte ab

In diesem Codelab aktualisieren Sie Objekte, die im Code definierte oder im Unity-Editor serialisierte Werte verwenden, um mit Remote Config instrumentierte Werte zu verwenden. Sie konfigurieren Standardwerte für jeden Parameter mit SetDefaultsAsync , damit sich Ihre App wie vorgesehen verhält, bevor sie eine Verbindung zum Remote Config-Backend herstellt. Ihre App bleibt auf dem neuesten Stand, indem sie neue Werte von Remote Config abruft und aktiviert, um sie im Code nutzbar zu machen.

Um neue Werte aus Remote Config abzurufen, sind in der Datei Assets/Hamster/Scripts/MainGame.cs bereits eine Reihe nicht implementierter Methoden vorhanden, die abgeschlossen werden müssen.

1. Fügen Sie MainGame.cs die folgenden using Anweisungen hinzu:

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

   Das Firebase.Extensions Modul enthält einige Erweiterungen der C#-Aufgaben-API , die dazu beitragen, die Verwaltung des Initialisierungsprozesses mit Rückrufen zu vereinfachen.
2. Fügen Sie Ihrer MainGame.cs Start() Methode eine Firebase-Initialisierung hinzu, indem Sie die vorhandene InitializeCommonDataAndStartGame()-Methode durch die derzeit nicht implementierte Methode InitializeFirebaseAndStartGame() :

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

   ersetzen
3. Suchen Sie in MainGame.cs nach InitializeFirebaseAndStartGame() . Deklarieren Sie eine App-Variable und überschreiben Sie die Implementierung der Methode wie folgt:

   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. Die Firebase-Initialisierung ruft bei Erfolg SetRemoteConfigDefaults auf, um In-App-Standardwerte festzulegen. Ersetzen Sie die nicht implementierte SetRemoteConfigDefaults-Methode durch Folgendes:

   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. Neue Werte abrufen und aktivieren (nach Bedarf)

Wir müssen nun die vorhandene FetchRemoteConfig Methode vervollständigen. Dadurch werden Aufrufe an die Remote Config-Methoden FetchAsync (die neue Werte von Remote Config abruft) und ActivateAsync (die diese erhaltenen Werte aktiviert, um sie im Code verfügbar zu machen) mithilfe eines Rückrufparameters namens onFetchAndActivateSuccessful verkettet.

Der Startcode, den wir im vorherigen Schritt hinzugefügt haben, ruft FetchRemoteConfig mit InitializeCommonDataAndStartGame als Rückruf auf, um das Spiel am Ende der Sequenz zu starten. Sie können alternative Rückrufe an FetchRemoteConfig übergeben, um den Abruf mit unterschiedlichen Ergebnissen aufzurufen. Ein Beispiel (das Sie später implementieren werden) ist die Übergabe einer Methode, die neue UI-Menüs öffnet, die von Remote Config-Werten abhängen. Dadurch werden die Menüs erst geöffnet, nachdem diese Werte abgerufen und aktiviert wurden.

1. Fügen Sie den folgenden Code in FetchRemoteConfig ein:

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

   Hinweis: Der an FetchAsync übergebene Wert cacheExpiration definiert, wie lange zuvor abgerufene Werte zwischengespeichert werden sollen. Während der Entwicklung können Sie dies wie oben gezeigt auf System.TimeSpan.Zero setzen. Dadurch wird sichergestellt, dass die App immer die aktuellsten Werte widerspiegelt. Bei der Produktionsfreigabe sollten Sie jedoch den cacheExpiration auf einen höheren Wert festlegen, um eine Drosselung zu vermeiden. Der Standardzeitraum (wenn FetchAsync ohne Parameter aufgerufen wird) beträgt 12 Stunden.

2. Vervollständigen Sie als Nächstes die Methode ActivateRetrievedRemoteConfigValues , die den übergebenen Rückruf onFetchAndActivateSuccessful empfängt. Wenn die Aktivierung abgeschlossen ist, wird der angegebene Rückruf aufgerufen:

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

Wenn ActivateRetrievedRemoteConfigValues ​​stromabwärts von SetRemoteConfigDefaults aus dem Initialisierungskontext aufgerufen wird, ruft ActivateRetrievedRemoteConfigValues ​​den vorherigen Startpunkt InitializeCommonDataAndStartGame auf, um das Spiel durch Öffnen des Hauptmenüs zu starten.

6. Richten Sie eine Ladestrategie für die Remote-Konfiguration ein

Um Werte zu einem anderen Zeitpunkt während der Nutzung der App abzurufen und zu aktivieren, müssen Sie diese Funktionen erneut aufrufen. Wenn Objekte die Werte zwischengespeichert haben, müssen sie benachrichtigt werden, um eine Aktualisierung durchzuführen. Um eine Strategie zum erneuten Abrufen von Remote-Konfigurationswerten zu entwickeln, überlegen Sie, wann die neuen Werte benötigt werden und wann das Abrufen und Aktivieren neuer Werte eingeleitet werden muss, um zu verhindern, dass sie sich während der Verwendung ändern.

Wie derzeit implementiert, werden Remote-Konfigurationswerte abgerufen und aktiviert, wenn die App gestartet wird. Abrufe können während Menüänderungen ausgeblendet werden und gleichzeitig die Interaktion während des Übergangs blockieren. Darüber hinaus ist dies oft der relevanteste Zeitpunkt, um neue Werte zu erhalten, da eine Änderung des Menüstatus oft dazu genutzt werden kann, zu wissen, wohin der Spieler geht, und vorherzusagen, dass ein Wert verwendet werden würde.

Wenn man sich das Menüsystem von Mechahamster ansieht, ist der einfachste Weg, UI-blockierende Menüaktualisierungen hinzuzufügen, darin, es aufzurufen , bevor das Hauptmenü wieder aufgenommen wird (insbesondere, wenn darauf durch Zurückkehren aus einem anderen Menü zugegriffen wird) und die UI-Anzeigemethode als onFetchAndActivateSuccessful Rückruf zu übergeben. Dasselbe kann für das Level Select- Menü durchgeführt werden.

Beim ersten Laden als Teil des App-Starts wird jede Menünavigation, die durch das Hauptmenü führt, von der ersten dieser Menüs übernommen, während jeder erneute Zugriff auf das Ebenenauswahlmenü ebenfalls eine Aktualisierung bewirkt. Der anfängliche Einstieg in das Level-Auswahlmenü spielt keine Rolle, da dieser nur über das Hauptmenü zugänglich ist und somit bereits abgedeckt ist.

Um dies in der App zu aktivieren, schließen Sie die entsprechenden Methoden im Hauptmenü ab und wählen Sie Dateien auf der Ebene aus, wodurch die UI-Anzeige blockiert wird, bis FetchAsync und ActivateAsync abgeschlossen sind:

1. Öffnen Sie Assets/Hamster/Scripts/States/MainMenu.cs und ersetzen Sie die vorhandene Resume Methode durch Folgendes:

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

2. Speicher die Datei.
3. Öffnen Sie Assets/Hamster/Scripts/States/BaseLevelSelect.cs und ersetzen Sie die vorhandene Resume Methode durch Folgendes:

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

4. Speicher die Datei.

Hinweis: Dieses Codelab bietet zwar eine Möglichkeit zum Laden von Remote-Konfigurationswerten, wenn das Hauptmenü und die Ebenenauswahlansichten aktiv sind, es stehen jedoch auch andere Ladestrategien zur Verfügung. Weitere Informationen finden Sie unter Ladestrategien für Firebase Remote Config .

7. Abrufverhalten debuggen/validieren

An diesem Punkt ist es sinnvoll, eine Diagnose-/Validierungsprüfung durchzuführen. Mit dem folgenden Verfahren können Sie Ihre App manuell testen und prüfen, wie/ob sie Remote-Konfigurationswerte abruft und aktiviert.

Die Informationen werden als Teil Ihrer Simulator-, Geräte- oder Editorprotokolle ausgedruckt. Für iOS können Sie Geräte- und Simulatorprotokolle in Xcode anzeigen. Für Android können Sie Protokolle anzeigen, indem Sie adb logcat ausführen. Wenn Sie den Code in Unity ausführen, indem Sie im Editor auf „Play“ klicken, werden Protokolle auf der Registerkarte „Konsole“ angezeigt.

1. Erstellen Sie die App neu und führen Sie sie aus (im Editor, mit einem Gerät oder Simulator).
2. Nachdem das Hauptmenü des Spiels angezeigt wird, überprüfen Sie die Protokollausgabe Ihres Spiels, die die von Debug.Log in FetchRemoteConfig und ActivateRetrievedRemoteConfigValues ​​generierten Protokolle enthalten sollte. Diese sollten die Meldungen „Daten werden abgerufen …“ und „Remote-Daten geladen und bereit“ anzeigen. Beachten Sie die Zeitstempel am Anfang dieser Nachrichten.
3. Drücken Sie im Spiel auf Lizenz .
4. Drücken Sie OK .
5. Warten Sie, bis das Hauptmenü des Spiels angezeigt wird.
6. Überprüfen Sie die Protokollausgabe Ihres Spiels, die denen im vorherigen Schritt ähneln sollte, mit neuen Zeitstempeln (entsprechend der Zeit, die auf der Systemuhr eingestellt ist, auf der Sie das Spiel ausführen).
7. Drücken Sie im Spiel auf „Play“ .
8. Drücken Sie „Let's Roll“ .
9. Navigieren Sie den Ball mithilfe der Tastaturpfeile zum Ziel. Dadurch wird ein Level-Abschlussmenü geöffnet.
10. Drücken Sie Ebenen .
11. Warten Sie, bis das Level- Auswahlmenü geladen ist.
12. Überprüfen Sie die Protokollausgabe Ihres Spiels noch einmal. Es sollte mit den Protokollmeldungen der vorherigen Schritte übereinstimmen, mit neueren Zeitstempeln (entsprechend der auf der Systemuhr eingestellten Zeit, auf der Sie das Spiel ausführen).

Wenn eines davon nicht in Ihrer App angezeigt wird, ist möglicherweise ein Teil des Abruf- und Aktivierungsablaufs (oder Ihr Gerät) falsch konfiguriert. Wenn das erste Protokoll nicht angezeigt wird, besteht die Möglichkeit, dass Ihr Spiel nicht startet. Überprüfen Sie die Protokolle der Editor-Konsole oder des Geräts/Emulators auf Warnungen und Fehler zu Ihrem Projekt/Ihrer Umgebung und untersuchen Sie diese – das Problem kann so einfach sein wie die Verbindung mit dem Internet.

Wenn die ersten Protokolle vom Laden des Menüs angezeigt werden, eines der folgenden jedoch nicht, untersuchen/implementieren Sie die Resume Methoden in Assets/Hamster/Scripts/States/MainMenu.cs und Assets/Hamster/Scripts/States/BaseLevelSelect.cs .

8. Instrumentieren Sie Ihren Code

Nachdem Sie nun In-App-Parameterwerte in SetDefaultsAsync() konfiguriert und mit FetchAsync() und ActivateAsync() die aktuellsten Versionen verfügbar gemacht haben, werden Sie diese Werte im Code referenzieren und verwenden.

Nachdem Sie Werte im Remote Config-Backend festgelegt, abgerufen und aktiviert haben ( oder beides gleichzeitig tun ), stehen diese Werte Ihrer App zur Verfügung. Um diese Werte zu verwenden, rufen Sie GetValue(string key ) auf und wählen Sie einen Parameterschlüssel als Argument aus. Dies gibt einen ConfigValue zurück, der über Eigenschaften für den Zugriff auf den Wert in verschiedenen unterstützten Typen verfügt: string , bool , long , double . In diesem Projekt und den meisten Gaming-Anwendungsfällen müssen Sie die letzten beiden Typen in die idiomatischeren int und float umwandeln. Um sicherzustellen, dass diese Konvertierungen keine Probleme verursachen, stellen Sie sicher, dass die in Remote Config festgelegten Anfangswerte innerhalb des gültigen Bereichs der Typen liegen, die Sie in Ihrem App-Code verwenden werden.

1. Importieren Sie die Remote-Konfiguration durch Hinzufügen using Firebase.RemoteConfig; an den Anfang der folgenden Dateien:
   • Assets/Hamster/Scripts/States/MainMenu.cs
   • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
2. Ersetzen Sie die Start Methode von AccelerationTile.cs :

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

   . Mit dieser Änderung wird die von der Beschleunigungskachel ausgeübte Kraft auf eine von Remote Config empfangene Kraft geändert.
3. Bearbeiten Sie den Hauptteil der InitializeUI Methode von 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();
   }
   

   Hier wird subtitleOverride so eingestellt, dass der Untertitel auf dem Hauptmenübildschirm geändert wird, wenn alle Felder in der Cloud auf andere Werte als die Standardwerte ihres Typs festgelegt sind.

Hinweis: SubtitleOverrideKey ist eine in MainMenu.cs definierte const string , die auf den Parameter subtitle_override gesetzt ist.

9. Parameterwerte aus der Ferne einstellen

Da Ihre App nun vollständig instrumentiert ist, können Sie Parameter und Werte auf dem Remote Config-Server konfigurieren. In diesem Codelab richten wir dies mithilfe der Firebase-Konsole ein.

1. Öffnen Sie in der Firebase-Konsole Ihr Projekt.
2. Wählen Sie „Remote-Konfiguration“ aus dem Menü, um das Remote-Konfigurations-Dashboard anzuzeigen.
3. Klicken Sie für jeden Parameter, den Sie in Ihrer App definiert und in der folgenden Tabelle aufgeführt haben, auf Parameter hinzufügen , fügen Sie den Parameternamen (Schlüssel) ein, wählen Sie den in der Tabelle aufgeführten Datentyp aus, deaktivieren Sie „In-App-Standard verwenden“ und fügen Sie ihn ein neuer Standardwert:

   Parametername (Schlüssel)	Datentyp	Standardwert
   Beschleunigung_Tile_Force	Nummer	100
   subtitle_override	JSON	{"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}

   

   Hinweis: Für jeden Parameter können Sie einen Standardwert festlegen, der den In-App-Standardwert überschreibt. Weitere Informationen finden Sie unter Parameter und Bedingungen für die Remote-Konfiguration .

4. Klicken Sie auf Speichern , um Ihre Änderungen zu speichern.
5. Klicken Sie auf „Veröffentlichen“ , um die neue Konfiguration zu veröffentlichen und die neuen Werte für Ihr Spiel verfügbar zu machen.
6. Führen Sie Ihre App erneut aus, nachdem Sie diese Remote-Parameter festgelegt haben, und beobachten Sie, wie sie die ursprünglichen Standardeinstellungen überschreiben.

   Tipp: Für Werte, die schwieriger zu beobachten sind, wie z. B. physikalische Werte, können Sie den Code aktualisieren, um den Wert von ConfigValue.Source zu protokollieren, um festzustellen, ob es sich bei den Werten um ihre konfigurierten Standardwerte handelt oder ob sie vom Remote-Konfigurationsserver abgerufen wurden .

Hinweis: Verwenden Sie die JsonUtility- Methoden ToJson und FromJson<T> von Unity, um ein serialisierbares Datenobjekt in und aus einer Zeichenfolge zu kodieren und zu dekodieren (wie dies derzeit bei der Initialisierung von SubtitleOverrideDefault in MainMenu.cs geschieht). In der Serializable- Dokumentation von Unity werden die Einschränkungen von Unity hinsichtlich der Serialisierung von Objekten beschrieben.

10. Verwenden Sie Remote-Konfigurationsbedingungen, um Varianten bereitzustellen

Möglicherweise möchten Sie die App-Erfahrung an den Benutzer anpassen, basierend auf der Sprache, die er spricht, seinem Aufenthaltsort, der Tageszeit oder der von ihm verwendeten Plattform. Remote-Konfigurationsbedingungen geben Ihnen die Möglichkeit, diese und andere Attribute einzeln oder in Kombination zu verwenden, um dem Benutzer unterschiedliche Werte (sogenannte Varianten) bereitzustellen.

Bedingungen werden häufig zum Ändern von Inhalten zwischen iOS- und Android-Plattformen verwendet. Führen Sie die folgenden Schritte aus, um eine Bedingung zu implementieren, die je nach verwendeter Plattform einen anderen Wert für subtitle_override bereitstellt.

1. Öffnen Sie die Registerkarte „Remote-Konfiguration“ Ihres Projekts in der Firebase-Konsole .
2. Klicken Sie auf die Schaltfläche „Bearbeiten“ für subtitle_override.
3. Klicken Sie unten links auf „Neu hinzufügen“ .
4. Bewegen Sie im angezeigten Dropdown-Menü den Mauszeiger über den Bedingungswert und klicken Sie auf Neue Bedingung erstellen.
5. Wenn Sie dazu aufgefordert werden, nennen Sie die Bedingung „ist iOS“, wenn Sie auf iOS abzielen, oder „ist Android“, wenn Sie auf Android abzielen. Wenn Sie auf beides abzielen, wählen Sie hier einfach eines aus und verwenden Sie es für den Rest des Codelabs.
6. Klicken Sie unter Gilt, wenn... auf das Dropdown- Menü Auswählen... und wählen Sie Plattform aus. Wählen Sie dann die entsprechende Plattform aus.
7. Klicken Sie auf Bedingung erstellen , um die Bedingung zu erstellen. Der Dialog Parameter bearbeiten erscheint erneut und Sie können nun einen Wert festlegen:
   • Wenn Sie auf Android abzielen, legen Sie den Wert auf „

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

     fest
   • Wenn Sie auf iOS abzielen, legen Sie den Wert auf „

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

     fest
8. Klicken Sie auf Speichern , um Ihre Änderungen zu speichern.
9. Klicken Sie auf „Veröffentlichen“ , um die neue Konfiguration zu veröffentlichen und die neuen Werte für Ihr Spiel verfügbar zu machen.

Wenn Sie das Spiel erneut erstellen und ausführen, sollte der Untertitel des Spiels durch die plattformspezifische Variante ersetzt werden.

11. Konfigurieren Sie Remote Config für den Empfang von Echtzeit-Updates

Hinweis: Remote-Konfigurationsaktualisierungen in Echtzeit werden für SDK-Version 11.0.0 und höher für Android- und Apple-Plattformen unterstützt. Es wird derzeit im Unity Play-Modus nicht unterstützt.

Remote Config kann jetzt in Echtzeit auf Aktualisierungen von Remote Config-Vorlagen warten und diese verarbeiten. Apps können die neue Echtzeit-Remote-Konfigurations-API abonnieren, um auf Konfigurationsänderungen und aktualisierte Werte zu warten.

Wie es funktioniert

Um auf Updates zu warten, muss Ihre App eine Methode implementieren, die das OnConfigUpdateListener Ereignis abonniert. Während ein oder mehrere Konfigurationsaktualisierungs-Listener abonniert sind, werden neue Remote-Konfigurationsvorlagen automatisch abgerufen, die abonnierten Handler werden aufgerufen und können verwendet werden, um als Antwort Logik auszuführen, wie zum Beispiel die Aktivierung der neuen Werte und deren Bereitstellung für den Rest der Anwendung.

Hinweis: Wenn alle Abonnenten aus OnConfigUpdateListener entfernt werden, hört es auf, auf Änderungen an der Remote Config-Vorlage Ihres Projekts zu warten.

Implementieren Sie eine Remote-Konfiguration in Echtzeit

Um zu veranschaulichen, wie dies im Spiel funktioniert, nehmen Sie die folgenden Änderungen an Ihrem Code vor.

Erstellen Sie einen Konfigurationsaktualisierungshandler

Der erste Schritt zur Verwendung des Config Update-Ereignisses besteht darin, eine Methode zu erstellen, die darauf warten kann. Platzieren Sie die folgende Methode 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.");
         });
   }

Diese Methode gibt eine Liste der aktualisierten Schlüssel und eine Erfolgsmeldung im Protokoll aus, wenn die neuen Werte aktiviert werden.

Abonnieren Sie das Update-Event

Um ActivateValuesOnConfigUpdate beim Aufruf des Ereignisses zu aktivieren, abonnieren Sie es beim Ereignis. Ersetzen Sie die Methode InitializeCommonDataAndStartGame() in Assets/Hamster/Scripts/MainGame.cs durch Folgendes:

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

Die neue Zeile (die mit += ActivateValuesOnConfigUpdate; endet) abonniert den Ereignishandler für das Ereignis.

Abbestellen, wenn das besitzende Objekt des Handlers zerstört wird

Um Nullreferenzfehler zu verhindern, müssen Objekte mit Methoden, die Ereignisse abonniert haben, diese Methode abbestellen, wenn sie zerstört werden. Fügen Sie die folgende Methode zu Assets/Hamster/Scripts/MainGame.cs hinzu:

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

Testen Sie die neue Funktionalität

Um die neue Funktionalität zu validieren, testen Sie Ihre erstellte App. Für das folgende Verfahren ist es erforderlich, dass Sie das Protokoll lesen und mit einem echten Gerät debuggen können.

acceleration_tile_force ändern und beobachten

Nachdem Sie Ihre App gestartet haben, gehen Sie im Abschnitt „Remote-Konfiguration“ der Firebase-Konsole wie folgt vor:

1. Klicken Sie auf die Schaltfläche „Bearbeiten“ neben acceleration_tile_force .

2. Ändern Sie den Wert auf „120“ und klicken Sie auf „Speichern“ .

3. Klicken Sie auf die Schaltfläche „Änderungen veröffentlichen“ .

4. Überprüfen Sie das Protokoll.
5. Wenn Sie eine Protokollmeldung sehen, die mit „Beim Abhören ist ein Fehler aufgetreten“ beginnt, lesen Sie den Rest und versuchen Sie, anhand der ausgegebenen Fehlermeldung ein Debugging durchzuführen.
6. Wenn Sie ein Protokoll sehen, das mit „Aktualisierte Schlüssel“ beginnt, hat Ihre App die geänderten Werte erhalten.
7. Wenn Sie keines davon sehen, sehen Sie sich die restlichen Protokolle an und überprüfen Sie dann die Anweisungen unter „Konfigurationsaktualisierungshandler erstellen“ erneut, testen Sie die Protokolle erneut und überprüfen Sie sie erneut, um festzustellen, ob etwas nicht stimmt.

Warnung: Beachten Sie, dass dadurch kein neuer Bedingungswert abgerufen wird, wenn Sie die Auswertung seiner Bedingung ändern (z. B. ob für einen Benutzer bestimmte Analytics-Benutzereigenschaften festgelegt sind oder ob er Teil einer Analytics-Zielgruppe ist). Behalten Sie daher vorerst die Aufrufe von FetchRemoteConfig (die FetchAndActivate aufruft) in Assets/Hamster/Scripts/States/MainMenu.cs und Assets/Hamster/Scripts/States/BaseLevelSelect.cs bei.

12. Herzlichen Glückwunsch!

Sie haben Remote Config verwendet, um In-Game-Werte aus der Ferne zu steuern, indem Sie sie in Ihrer App abrufen und Bedingungen verwenden, um verschiedene Varianten bereitzustellen!

Was wir abgedeckt haben

• So legen Sie Remote-Konfigurationswerte fest und rufen sie ab
• So instrumentieren Sie Ihren Unity C#-Code, um die abgerufenen Werte zu verwenden
• So speichern, instrumentieren und überschreiben Sie zusammengesetzte Werte/Objekte als JSON-Werte
• So verwenden Sie Remote-Konfigurationsbedingungen, um verschiedene Wertvarianten bereitzustellen

Nächste Schritte

Lesen Sie mehr über die Priorität von Parameterwerten, um die Logik besser zu verstehen, welche Werte von einer App-Instanz abgerufen werden, wenn sie einen Parameter mit mehreren Werten verwendet (aufgrund von Bedingungen oder Lokalität).

Fahren Sie mit dem nächsten Schritt des Pfades fort, in dem Sie diese instrumentierten Werte verwenden, um verschiedene Varianten A/B-Tests durchzuführen, um besser zu verstehen, wie sie sich auf das Benutzerverhalten auswirken.