Unity-Spiele mit Firebase Remote Config analysieren

1. Einführung

Mit Firebase Remote Config können Sie in Ihrer App Schlüssel/Wert-Paare definieren, auch als Parameter bezeichnet, und deren Werte in der Cloud aktualisieren. So können Sie Darstellung und Verhalten Ihrer App ändern, ohne ein App-Update zu verteilen.

Sie fügen diese neue Funktion dem Beispielspiel MechaHamster: Level Up with Firebase Edition hinzu. Dieses Beispielspiel ist eine neue Version des klassischen Firebase-Spiels MechaHamster, bei dem die meisten integrierten Firebase-Funktionen entfernt wurden. So haben Sie die Möglichkeit, an ihrer Stelle neue Firebase-Funktionen zu implementieren.

Damit sich Ihre App wie vorgesehen verhält, legen Sie Standardkonfigurationen für Werte im Spielcode fest. Diese können mit Werten, die Sie in Remote Config in der Firebase Console festgelegt haben, überschrieben werden.

Lerninhalte

• Remote Config-Werte in der Cloud festlegen und abrufen
• Wie Sie Ihren Unity-C#-Code so instrumentieren, dass die abgerufenen Werte automatisch verwendet werden
• Zusammengesetzte Werte/Objekte als JSON-Werte speichern, instrumentieren und überschreiben
• Mit Remote-Config-Bedingungen unterschiedliche Wertvarianten für verschiedene Nutzergruppen ausliefern

Voraussetzungen

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

2. Entwicklungsumgebung einrichten

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

Code herunterladen

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

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

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

Level Up with Firebase im Unity-Editor öffnen

1. Starten Sie Unity Hub und klicken Sie auf dem Tab Projekte neben Öffnen auf den Drop-down-Pfeil.
2. Klicken Sie auf Projekt vom Laufwerk hinzufügen.
3. Gehen Sie zu dem Verzeichnis, das den Code enthält, und klicken Sie auf OK.
4. Wenn Sie dazu aufgefordert werden, wählen Sie eine Version des Unity-Editors und Ihre Zielplattform aus (Android oder iOS).
5. Klicken Sie auf den Projektnamen level-up-with-firebase. Das Projekt wird im Unity-Editor geöffnet.
6. Wenn Ihr Editor den Editor nicht automatisch öffnet, öffnen Sie MainGameScene unter Assets > Hamster auf dem Tab Project (Projekt) des Unity Editor.
   

Weitere Informationen zur Installation und Verwendung von Unity finden Sie unter In Unity arbeiten.

3. Firebase zu Ihrem Unity-Projekt hinzufügen

Firebase-Projekt erstellen

1. Klicken Sie in der Firebase Console auf Projekt hinzufügen.
2. Geben Sie den gewünschten Projektnamen ein, um ein neues Projekt zu erstellen.
   Dadurch wird auch die Projekt-ID (unter dem Projektnamen angezeigt) auf einen Wert festgelegt, der auf dem Projektnamen basiert. Optional können Sie bei der Projekt-ID auf das Symbol Bearbeiten klicken, um sie weiter anzupassen.
3. Lesen Sie sich die Firebase-Nutzungsbedingungen durch und akzeptieren Sie sie.
4. Klicken Sie auf Weiter.
5. Wählen Sie die Option Google Analytics für dieses Projekt aktivieren aus und klicken Sie dann auf Weiter.
6. Wählen Sie ein vorhandenes Google Analytics-Konto aus oder klicken Sie auf 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.

App bei Firebase registrieren

1. Öffnen Sie die Firebase Console und klicken Sie in der Mitte der Projektübersicht auf das Unity-Symbol, um den Einrichtungsworkflow zu starten. Wenn Sie Ihrem Firebase-Projekt bereits eine App hinzugefügt haben, klicken Sie auf App hinzufügen, um die Plattformoptionen aufzurufen.
2. Wählen Sie diese Option aus, um sowohl die Build-Ziele von Apple (iOS) als auch Android zu registrieren.
3. Geben Sie die plattformspezifischen IDs 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.
   • Android: Geben Sie com.google.firebase.level_up in das Feld Android-Paketname ein.
4. Optional können Sie die plattformspezifischen Aliasse Ihres Unity-Projekts eingeben.
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.

Firebase-Konfigurationsdateien hinzufügen

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 zu Firebase herzustellen.

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

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

3. Klicken Sie in der Firebase Console im Einrichtungsablauf auf Weiter und fahren Sie mit „Firebase SDKs für Unity hinzufügen“ fort.

Hinweis: Sie können diese Dateien jederzeit noch einmal herunterladen. Öffnen Sie dazu die Allgemeinen Einstellungen Ihres Projekts, scrollen Sie nach unten zum Bereich Meine Apps und klicken Sie dann auf die Schaltfläche „Herunterladen“ für die gewünschte Konfigurationsdatei.

Firebase SDKs für Unity hinzufügen

1. Klicken Sie in der Firebase Console auf Firebase Unity SDK herunterladen.

   Hinweis: Der Download dieses SDK kann einige Zeit dauern. Sehen Sie sich eine Vorschau der nächsten Schritte an oder machen Sie eine kurze Pause.

2. Entpacken Sie das SDK an einem für Sie geeigneten Ort.
3. Rufen Sie in Ihrem geöffneten Unity-Projekt Assets > Import Package > Custom Package auf.
4. Gehen Sie im Dialogfeld Paket importieren zum Verzeichnis, das das entpackte SDK enthält, wählen Sie FirebaseAnalytics.unitypackage aus und klicken Sie dann auf Öffnen.
5. Klicken Sie im Dialogfeld Import Unity Package (Unity-Paket importieren) auf Importieren.
6. Wiederholen Sie die vorherigen Schritte, um die folgenden beiden Pakete zu importieren:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics ist ein schlankes Echtzeit-Tool zur Erfassung von Abstürzen, mit dem Sie Stabilitätsprobleme, die die Qualität Ihrer App beeinträchtigen, in Echtzeit erfassen, priorisieren und beheben können. Sie sollten den Crashlytics-Lernpfad für Unity abschließen, falls Sie dies noch nicht getan haben.
7. Kehren Sie zur Firebase Console zurück und klicken Sie im Einrichtungsworkflow auf Weiter.

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

4. Remote Config-Standardwerte festlegen und neue Werte abrufen

In diesem Codelab aktualisieren Sie Objekte, die Werte verwenden, die im Code definiert oder im Unity-Editor serialisiert sind, um Werte zu verwenden, die mit Remote Config erfasst wurden. Mithilfe von SetDefaultsAsync konfigurieren Sie Standardwerte für jeden Parameter, damit sich Ihre App wie vorgesehen verhält, bevor eine Verbindung zum Remote Config-Backend hergestellt wird. Ihre App bleibt auf dem neuesten Stand, indem neue Werte aus Remote Config abgerufen und aktiviert werden, damit sie im Code verwendet werden können.

Damit neue Werte aus Remote Config abgerufen werden können, sind in der Assets/Hamster/Scripts/MainGame.cs-Datei 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 Modul Firebase.Extensions enthält einige Erweiterungen der C# Tasks API, die die Verwaltung des Initialisierungsprozesses mit Callbacks vereinfachen.
2. Fügen Sie der MainGame.cs-Methode Start() die Firebase-Initialisierung hinzu. Ersetzen Sie dazu die vorhandene Methode „InitializeCommonDataAndStartGame()“ durch die derzeit nicht implementierte Methode InitializeFirebaseAndStartGame():

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

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

   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. Bei der Firebase-Initialisierung wird SetRemoteConfigDefaults aufgerufen, um Standardwerte in der App festzulegen. Ersetzen Sie die nicht implementierte Methode „SetRemoteConfigDefaults“ 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 nach Bedarf abrufen und aktivieren

Jetzt müssen wir die vorhandene FetchRemoteConfig-Methode vervollständigen. Dadurch werden Aufrufe an die Remote Config-Methoden FetchAsync (die neue Werte aus Remote Config abruft) und ActivateAsync (die die abgerufenen Werte aktiviert, um sie im Code verfügbar zu machen) unter Verwendung eines Callback-Parameters mit dem Namen onFetchAndActivateSuccessful verkettet.

Der Startcode, den wir im vorherigen Schritt hinzugefügt haben, ruft FetchRemoteConfig mit InitializeCommonDataAndStartGame als Callback 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 das Übergeben 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 gibt an, wie lange zuvor abgerufene Werte im Cache gespeichert werden sollen. Während der Entwicklung können Sie dies wie oben gezeigt auf System.TimeSpan.Zero festlegen. Dadurch wird sichergestellt, dass die App immer die aktuellen Werte abgibt. Nach der Freigabe für die Produktion sollten Sie cacheExpiration jedoch auf einen höheren Wert setzen, um eine Drosselung zu vermeiden. Der Standardzeitraum (wenn FetchAsync ohne Parameter aufgerufen wird) beträgt 12 Stunden.

2. Ergänzen Sie als Nächstes die Methode ActivateRetrievedRemoteConfigValues, die einen übergebenen Callback onFetchAndActivateSuccessful empfängt. Nach Abschluss der Aktivierung wird der angegebene Callback 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 SetRemoteConfigDefaults aus dem Initialisierungskontext heraus aufgerufen wird, ruft ActivateRetrievedRemoteConfigValues den vorherigen Startpunkt, InitializeCommonDataAndStartGame, auf, um das Spiel durch Öffnen des Hauptmenüs zu starten.

6. Ladestrategie für Remote Config einrichten

Um während der Verwendung der App Werte zu einem anderen Zeitpunkt abzurufen und zu aktivieren, müssen Sie diese Funktionen noch einmal aufrufen. Wenn Objekte die Werte im Cache gespeichert haben, müssen sie benachrichtigt werden, damit sie eine Aktualisierung ausführen können. Wenn Sie eine Strategie zum erneuten Abrufen von Remote Config-Werten entwickeln möchten, sollten Sie überlegen, wann die neuen Werte benötigt werden und wann das Abrufen und Aktivieren neuer Werte gestartet werden soll, damit sie nicht während der Verwendung geändert werden.

Derzeit werden Remote Config-Werte beim Starten der App abgerufen und aktiviert. Abrufe können bei Menüänderungen ausgeblendet werden und gleichzeitig Interaktionen während des Übergangs blockieren. Außerdem ist dies oft der relevanteste Zeitpunkt, um neue Werte abzurufen, da anhand einer Änderung des Menüstatus oft ermittelt werden kann, wohin sich der Spieler bewegt, und vorhergesagt werden kann, dass ein Wert verwendet wird.

Wenn Sie sich das Menüsystem von Mechahamster ansehen, ist die einfachste Möglichkeit, Menüaktualisierungen hinzuzufügen, die die Benutzeroberfläche blockieren, sie vor dem Fortsetzen des Hauptmenüs aufzurufen (insbesondere, wenn darauf zugegriffen wird, indem aus einem anderen Menü zurückgegangen wird) und die Methode zum Anzeigen der Benutzeroberfläche als onFetchAndActivateSuccessful-Callback zu übergeben. Das Gleiche gilt für das Menü Levelauswahl.

Beim ersten Laden beim Starten der App wird die Menünavigation über das Hauptmenü von der ersten dieser Funktionen verarbeitet. Jede erneute Eingabe des Menüs Levelauswahl führt ebenfalls zu einer Aktualisierung. Der erste Aufruf des Menüs für die Levelauswahl spielt keine Rolle, da es nur über das Hauptmenü aufgerufen werden kann und daher bereits abgedeckt ist.

Wenn Sie diese Funktion in der App aktivieren möchten, müssen Sie die entsprechenden Methoden im Hauptmenü und in den Dateien für die Levelauswahl ausführen. Die Benutzeroberfläche wird erst angezeigt, wenn 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. Speichern Sie 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. Speichern Sie die Datei.

Hinweis:In diesem Codelab können Sie Remote Config-Werte laden, wenn das Hauptmenü und die Ebenenauswahlansichten aktiv sind. Es sind jedoch auch andere Ladestrategien verfügbar. Weitere Informationen finden Sie unter Ladestrategien für Firebase Remote Config.

7. Abrufverhalten debuggen und validieren

An dieser Stelle ist es von Vorteil, eine Diagnose-/Validierungsprüfung durchzuführen. Mit der folgenden Anleitung können Sie Ihre App manuell testen und prüfen, ob und wie Remote Config-Werte abgerufen und aktiviert werden.

Die Informationen werden als Teil der Simulator-, Geräte- oder Editorprotokolle ausgegeben. Unter iOS können Sie Geräte- und Simulatorprotokolle in Xcode aufrufen. Unter Android können Sie Logs mit adb logcat aufrufen. Wenn Sie den Code in Unity ausführen, indem Sie im Editor auf „Play“ drücken, werden die Protokolle auf dem Tab „Console“ angezeigt.

1. Erstellen Sie die App neu und führen Sie sie aus (im Editor mit einem Gerät oder Simulator).
2. Wenn das Hauptmenü des Spiels angezeigt wird, sehen Sie sich die Logausgabe des Spiels an. Sie sollte die von Debug.Log in FetchRemoteConfig und ActivateRetrievedRemoteConfigValues generierten Logs enthalten. Dort sollte „Daten werden abgerufen...“ angezeigt werden. und „Remote-Daten geladen und bereit“ Nachrichten. Achten Sie auf die Zeitstempel am Anfang dieser Nachrichten.
3. Drücke im Spiel auf Lizenz.
4. Klicken Sie auf OK.
5. Warten Sie, bis das Hauptmenü des Spiels angezeigt wird.
6. Sehen Sie sich die Protokollausgabe Ihres Spiels an. Sie sollte der aus dem vorherigen Schritt ähneln, aber neue Zeitstempel enthalten, die der Zeit entsprechen, die auf der Systemuhr des Computers eingestellt ist, auf dem Sie das Spiel ausführen.
7. Drücke im Spiel auf Spielen.
8. Klicken Sie auf Let's Roll.
9. Steuere den Ball mit den Pfeiltasten auf der Tastatur zum Tor. Dadurch wird ein Menü für das Levelende geöffnet.
10. Drücken Sie auf Pegel.
11. Warten Sie, bis das Menü Levelauswahl geladen ist.
12. Sehen Sie sich die Protokollausgabe Ihres Spiels noch einmal an. Die Protokollmeldungen sollten mit den Protokollmeldungen aus den vorherigen Schritten übereinstimmen, wobei die Zeitstempel neuer sein sollten (entsprechend der Zeit, die auf der Systemuhr des Computers eingestellt ist, auf dem Sie das Spiel ausführen).

Wenn einer dieser Status nicht in Ihrer App angezeigt wird, ist möglicherweise ein Teil des Abruf- und Aktivierungsvorgangs (oder Ihr Gerät) falsch konfiguriert. Wenn das erste Protokoll nicht angezeigt wird, startet das Spiel möglicherweise nicht. Prüfen Sie die Editor-Konsole oder die Geräte-/Emulatorprotokolle auf Warnungen und Fehler in Bezug auf Ihr Projekt bzw. Ihre Umgebung und untersuchen Sie diese. Möglicherweise reicht es schon, wenn Sie eine Internetverbindung herstellen.

Wenn die ersten Protokolle beim Laden des Menüs angezeigt werden, aber eines der nachfolgenden nicht, untersuchen Sie die Resume-Methoden in Assets/Hamster/Scripts/States/MainMenu.cs und Assets/Hamster/Scripts/States/BaseLevelSelect.cs und implementieren Sie sie gegebenenfalls neu.

8. Code instrumentieren

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

Nachdem Sie Werte im Remote Config-Backend festgelegt, abgerufen und aktiviert haben (oder beides gleichzeitig), sind diese Werte für Ihre App verfügbar. Wenn Sie diese Werte verwenden möchten, rufen Sie GetValue(string key) auf und wählen Sie einen Parameterschlüssel als Argument aus. Dadurch wird ein ConfigValue zurückgegeben, das Eigenschaften für den Zugriff auf den Wert als verschiedene unterstützte Typen hat: string, bool, long, double. In diesem Projekt und in den meisten Gaming-Anwendungsfällen musst du die letzten beiden Typen in die eher idiomatischeren int und float umwandeln. Damit diese Conversions keine Probleme verursachen, achten Sie darauf, 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 Remote Config, indem Sie using Firebase.RemoteConfig; an den Anfang der folgenden Dateien einfügen:
   • 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;
   }
   

   Durch diese Änderung wird die Kraft, die von der Beschleunigungskachel aufgewendet wird, in die von Remote Config empfangene geändert.
3. Bearbeiten Sie den Text der Methode InitializeUI 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 ist subtitleOverride so eingestellt, dass die Unterüberschrift auf dem Hauptmenübildschirm geändert wird, wenn alle Felder in der Cloud als andere Werte als die Standardwerte des Typs des jeweiligen Typs festgelegt sind.

Hinweis: SubtitleOverrideKey ist ein const string, das in MainMenu.cs definiert und auf den Parameter subtitle_override festgelegt ist.

9. Parameterwerte aus der Ferne festlegen

Nachdem Ihre App nun vollständig instrumentiert ist, können Sie Parameter und Werte auf dem Remote Config-Server konfigurieren. In diesem Codelab richten wir das über die Firebase Console ein.

1. Öffnen Sie in der Firebase Console Ihr Projekt.
2. Wählen Sie im Menü „Remote Config“ aus, um das Remote Config-Dashboard aufzurufen.
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-Standardwert verwenden und fügen Sie den neuen Standardwert ein:

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

   

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

4. Klicken Sie auf Speichern, um die Ä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 die App nach dem Festlegen dieser Remote-Parameter noch einmal aus und beobachten Sie, wie die ursprünglichen Standardeinstellungen überschrieben werden.

   Tipp: Für Werte, die schwieriger zu beobachten sind, z. B. physikalische Werte, können Sie den Code aktualisieren, um den Wert von ConfigValue.Source, um festzustellen, ob Werte ihre konfigurierten Standardwerte sind oder vom Remote Config-Server abgerufen wurden.

Hinweis: Verwenden Sie die Methoden ToJson und FromJson<T> von Unity von JsonUtility, um ein serialisierbares Datenobjekt in einen String und aus einem String zu decodieren (wie derzeit bei der Initialisierung von SubtitleOverrideDefault in MainMenu.cs). In der Dokumentation Serializable von Unity werden die Einschränkungen von Unity bezüglich der Serialisierung von Objekten beschrieben.

10. Remote Config-Bedingungen zum Bereitstellen von Varianten verwenden

Sie können die App-Erfahrung je nach Sprache, Standort, Tageszeit oder verwendeter Plattform anpassen. Mit Remote Config-Bedingungen können Sie diese und andere Attribute einzeln oder in Kombination verwenden, um Nutzern unterschiedliche Werte (sogenannte Varianten) zu präsentieren.

Eine gängige Verwendung von Bedingungen ist das Ändern von Inhalten zwischen iOS- und Android-Plattformen. 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 in der Firebase Console den Tab „Remote Config“ Ihres Projekts.
2. Klicken Sie auf die Schaltfläche „Bearbeiten“ für subtitle_override..
3. Klicken Sie links unten auf Hinzufügen.
4. Bewegen Sie den Mauszeiger im Drop-down-Menü auf Bedingter Wert und klicken Sie auf Neue Bedingung erstellen.
5. Wenn Sie dazu aufgefordert werden, nennen Sie die Bedingung „is iOS“. bei Ausrichtung auf iOS oder „ist Android“ wenn Ihre App auf Android ausgerichtet ist. Wenn Sie beides ansteuern möchten, wählen Sie hier einfach eine Option aus und verwenden Sie sie für den Rest des Codelabs.
6. Klicken Sie unter Gilt, wenn… auf das Drop-down-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. Das Dialogfeld „Parameter bearbeiten“ wird angezeigt und Sie können jetzt einen Wert festlegen:
   • Wenn Ihre Anzeigen auf Android ausgerichtet sind, legen Sie den Wert wie folgt fest:

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

   • Richten Sie Ihre App auf iOS aus, legen Sie für Wert Folgendes fest:

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

8. Klicken Sie auf Speichern, um die Ä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 noch einmal erstellen und ausführen, sollte der Untertitel des Spiels durch die plattformspezifische Variante ersetzt werden.

11. Remote Config für Echtzeitaktualisierungen konfigurieren

Hinweis:Remote Config-Updates in Echtzeit werden für SDK-Versionen 11.0.0 und höher auf Android- und Apple-Plattformen unterstützt. Sie wird derzeit nicht im Unity-Spielmodus unterstützt.

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

Funktionsweise

Damit auf Updates gewartet werden kann, muss Ihre App eine Methode implementieren, die das Ereignis OnConfigUpdateListener abonniert. Während ein oder mehrere Listener für Konfigurationsupdates abonniert sind, werden neue Remote Config-Vorlagen automatisch abgerufen. Die abonnierten Handler werden aufgerufen und können verwendet werden, um als Antwort Logik auszuführen, beispielsweise die neuen Werte zu aktivieren und sie für den Rest der Anwendung verfügbar zu machen.

Hinweis:Wenn alle Abonnenten aus OnConfigUpdateListener entfernt werden, überwacht es nicht mehr auf Änderungen an der Remote Config-Vorlage Ihres Projekts.

Remote Config in Echtzeit implementieren

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

Config Update-Handler erstellen

Der erste Schritt zur Verwendung des Config Update-Ereignisses besteht darin, eine Methode zu erstellen, die das Config Update überwachen 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 aktualisierter Schlüssel und eine Erfolgsmeldung im Protokoll aus, wenn die neuen Werte aktiviert werden.

Update-Ereignis abonnieren

Abonnieren Sie das Ereignis, um ActivateValuesOnConfigUpdate beim Aufruf des Ereignisses zu aktivieren. 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());
   }

Mit der neuen Zeile (die mit += ActivateValuesOnConfigUpdate; endet) wird der Event-Handler für das Ereignis registriert.

Abo beenden, wenn das Objekt des Handlers gelöscht wird

Um Null-Referenzfehler zu vermeiden, müssen Objekte mit Methoden, die Ereignisse abonniert haben, diese Methode beenden, wenn sie gelöscht werden. Fügen Sie Assets/Hamster/Scripts/MainGame.cs die folgende Methode hinzu:

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

Neue Funktionen testen

Testen Sie Ihre erstellte App, um die neue Funktionalität zu prüfen. Für das folgende Verfahren müssen Sie das Protokoll mit einem echten Gerät lesen und Fehler beheben.

acceleration_tile_force ändern und beobachten

Nachdem Sie Ihre App gestartet haben, gehen Sie in der Firebase Console im Abschnitt Remote Config so vor:

1. Drücke die Schaltfläche „Bearbeiten“ neben acceleration_tile_force.

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

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

4. Prüfen Sie das Protokoll.
5. Wenn eine Protokollmeldung mit „Fehler beim Abhören aufgetreten“ beginnt, lesen Sie den Rest der Meldung und versuchen Sie, den Fehler anhand der gedruckten Fehlermeldung zu beheben.
6. Wenn ein Log mit „Aktualisierte Schlüssel“ beginnt, hat Ihre App die geänderten Werte erhalten.
7. Wenn Sie keine dieser Meldungen sehen, sehen Sie sich die restlichen Protokolle an und lesen Sie die Anleitung unter Config Update-Handler erstellen noch einmal durch. Wiederholen Sie den Test und prüfen Sie die Protokolle noch einmal, um festzustellen, ob etwas nicht stimmt.

Warnung: Wenn Sie die Auswertung der Bedingung ändern, wird kein neuer nutzerdefinierter Wert abgerufen. Das ist beispielsweise der Fall, wenn ein Nutzer eine bestimmte Analytics-Nutzereigenschaft festgelegt hat oder zu einer Analytics-Zielgruppe gehört. Belassen Sie daher vorerst die Aufrufe von FetchRemoteConfig (die FetchAndActivate aufruft) in Assets/Hamster/Scripts/States/MainMenu.cs und Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

12. Glückwunsch!

Sie haben mithilfe von Remote Config die In-Game-Werte per Remotezugriff gesteuert, indem Sie sie in Ihrer App abgerufen und mithilfe von Bedingungen verschiedene Varianten bereitgestellt haben.

Behandelte Themen

• Remote Config-Werte festlegen und abrufen
• Unity-C#-Code so instrumentieren, dass die abgerufenen Werte verwendet werden
• Zusammengesetzte Werte/Objekte als JSON-Werte speichern, instrumentieren und überschreiben
• Remote Config-Bedingungen zum Bereitstellen verschiedener Wertevarianten verwenden

Nächste Schritte

Lesen Sie mehr über die Priorität von Parameterwerte, um besser zu verstehen, welche Werte eine App-Instanz erhält, wenn sie einen Parameter mit mehreren Werten (aufgrund von Bedingungen oder Ort) verwendet.

Fahren Sie mit dem nächsten Schritt des Pfads fort, in dem Sie mit diesen instrumentierten Werten A/B-Tests für verschiedene Varianten durchführen, um besser zu verstehen, wie sie sich auf das Nutzerverhalten auswirken.