Unity-Spiele mit Firebase Remote Config analysieren

1. Einführung

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

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

Damit Ihre App wie vorgesehen funktioniert, 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 Console festlegen.

Lerninhalte

  • Remote Config-Werte in der Cloud festlegen und abrufen
  • So instrumentieren Sie Ihren Unity-C#-Code, damit die abgerufenen Werte automatisch verwendet werden
  • Zusammengesetzte Werte/Objekte als JSON-Werte speichern, instrumentieren und überschreiben
  • Remote Config-Bedingungen verwenden, um verschiedenen Nutzergruppen unterschiedliche Wertvarianten bereitzustellen

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 ein 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 with Firebase herunterladen, in Unity öffnen und ein Firebase-Projekt hinzufügen. Dieses Beispielspiel aus „Level Up with Firebase“ wird in mehreren anderen Firebase + Unity-Codelabs verwendet. Möglicherweise haben Sie die Aufgaben in diesem Abschnitt also bereits erledigt. Wenn ja, können Sie diese Schritte überspringen und mit „Firebase SDKs für Unity hinzufügen“ fortfahren, um Remote Config dem Beispielspielcode hinzuzufügen.

Code herunterladen

Klonen Sie das GitHub-Repository für dieses Codelab ü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. Wechseln Sie zum Verzeichnis mit dem Code und klicken Sie auf OK.
  4. Wählen Sie bei Aufforderung eine Unity-Editor-Version und Ihre Zielplattform (Android oder iOS) aus.
  5. Klicken Sie auf den Projektnamen level-up-with-firebase. Das Projekt wird im Unity-Editor geöffnet.
  6. Wenn der Editor nicht automatisch geöffnet wird, öffnen Sie MainGameScene im Unity-Editor auf dem Tab Project (Projekt) unter Assets > Hamster.

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

3. Firebase zu einem Unity-Projekt hinzufügen

Firebase-Projekt erstellen

  1. Melden Sie sich mit Ihrem Google-Konto in der Firebase Console an.
  2. Klicken Sie auf die Schaltfläche, um ein neues Projekt zu erstellen, und geben Sie dann einen Projektnamen ein (z. B. LevelUpWithFirebase).
  3. Klicken Sie auf Weiter.
  4. Lesen und akzeptieren Sie bei Aufforderung die Firebase-Nutzungsbedingungen und klicken Sie dann auf Weiter.
  5. (Optional) Aktivieren Sie die KI-Unterstützung in der Firebase Console (als „Gemini in Firebase“ bezeichnet).
  6. Für dieses Codelab benötigen Sie Google Analytics, um Firebase-Produkte optimal nutzen zu können. Lassen Sie die Ein/Aus-Schaltfläche für die Google Analytics-Option also aktiviert. Folgen Sie der Anleitung auf dem Bildschirm, um Google Analytics einzurichten.
  7. Klicken Sie auf Projekt erstellen, warten Sie, bis Ihr Projekt bereitgestellt wurde, und klicken Sie dann 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 das Apple-Build-Ziel (iOS) als auch das Android-Build-Ziel 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 im Feld iOS-Bundle-ID com.google.firebase.level-up ein.
    • Für Android: Geben Sie im Feld Android-Paketname com.google.firebase.level_up ein.
  4. Optional können Sie plattformspezifische Aliasse für Ihr Unity-Projekt eingeben.
  5. Klicken Sie auf App registrieren und fahren Sie mit dem Bereich Konfigurationsdatei herunterladen fort.
  6. Wiederholen Sie den Vorgang für das Build-Ziel, das Sie beim ersten Mal nicht ausgewählt 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 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 Fenster Project Ihres Unity-Projekts und verschieben Sie beide Konfigurationsdateien in den Ordner Assets.
  3. Klicken Sie in der Firebase Console im Einrichtungsablauf auf Weiter und fahren Sie mit dem Hinzufügen von Firebase-SDKs für Unity fort.

Hinweis:Sie können diese Dateien jederzeit wieder herunterladen, indem Sie die allgemeinen Einstellungen Ihres Projekts öffnen, zum Bereich Ihre Apps scrollen und dann auf die Schaltfläche zum Herunterladen der gewünschten Konfigurationsdatei klicken.

Firebase SDKs für Unity hinzufügen

  1. Klicken Sie in der Firebase Console auf Firebase Unity SDK herunterladen.
  2. Entpacken Sie das SDK an einem für Sie günstigen Ort.
  3. Rufen Sie in Ihrem geöffneten Unity-Projekt Assets > Import Package > Custom Package auf.
  4. Rufen Sie im Dialogfeld Paket importieren das Verzeichnis auf, 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 auf Import.
  6. Wiederholen Sie die vorherigen Schritte, um die folgenden beiden Pakete zu importieren:
    • FirebaseRemoteConfig.unitypackage
    • FirebaseCrashlytics.unitypackage
      Crashlytics ist ein schlanker Echtzeit-Absturzreporter, mit dem Sie Stabilitätsprobleme, die die Qualität Ihrer App beeinträchtigen, erfassen, priorisieren und beheben können. Wenn Sie Crashlytics noch nicht verwendet haben, sollten Sie den Crashlytics-Lernpfad für Unity durcharbeiten.
  7. Kehren Sie zur Firebase Console zurück und klicken Sie im Einrichtungs-Workflow 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, sodass sie Werte verwenden, die mit Remote Config instrumentiert wurden. 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 aus Remote Config abruft und aktiviert, damit sie im Code verwendet werden können.

Um neue Werte aus Remote Config abzurufen, sind in der Datei Assets/Hamster/Scripts/MainGame.cs bereits einige nicht implementierte 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# Tasks API, die die Verwaltung des Initialisierungsprozesses mit Callbacks vereinfachen.
  2. Fügen Sie die Firebase-Initialisierung zu Ihrer MainGame.cs Start()-Methode hinzu, indem Sie die vorhandene Methode „InitializeCommonDataAndStartGame()“ durch die derzeit nicht implementierte Methode InitializeFirebaseAndStartGame() ersetzen:
    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 erfolgreicher 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 abrufen und aktivieren (falls erforderlich)

Wir müssen jetzt die vorhandene Methode FetchRemoteConfig vervollständigen. Dadurch werden Aufrufe der Remote Config-Methoden FetchAsync (mit der neue Werte aus Remote Config abgerufen werden) und ActivateAsync (mit der die abgerufenen Werte aktiviert werden, damit sie im Code verfügbar sind) über einen Callback-Parameter namens onFetchAndActivateSuccessful verkettet.

Der im vorherigen Schritt hinzugefügte Startcode 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 die Übergabe einer Methode, die neue Benutzeroberflächenmenü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);
      });
}
  2. Vervollständigen Sie als Nächstes die Methode ActivateRetrievedRemoteConfigValues, die einen übergebenen Callback, onFetchAndActivateSuccessful, empfängt. Wenn die Aktivierung abgeschlossen ist, 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 ActivateRetrievedRemoteConfigValues im Initialisierungskontext nachgelagert aufruft, ruft ActivateRetrievedRemoteConfigValues den vorherigen Startpunkt InitializeCommonDataAndStartGame auf, um das Spiel zu starten, indem das Hauptmenü geöffnet wird.

6. Remote Config-Ladestrategie einrichten

Wenn Sie Werte zu einem anderen Zeitpunkt während der Nutzung der App abrufen und aktivieren möchten, müssen Sie diese Funktionen noch einmal aufrufen. Wenn Objekte die Werte im Cache gespeichert haben, müssen sie benachrichtigt werden, damit sie ein Update durchführen. 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 initiiert werden soll, damit sie sich während der Verwendung nicht ändern.

In der aktuellen Implementierung werden Remote Config-Werte beim Start der App abgerufen und aktiviert. Abrufe können bei Menüänderungen ausgeblendet werden, während die Interaktion während des Übergangs blockiert wird. Außerdem ist dies oft der relevanteste Zeitpunkt, um neue Werte abzurufen, da eine Änderung des Menüzustands oft verwendet werden kann, um zu wissen, „wohin“ der Spieler geht, und vorherzusagen, dass ein Wert verwendet wird.

Wenn man sich das Menüsystem von Mechahamster ansieht, ist es am einfachsten, Menüaktualisierungen hinzuzufügen, die die Benutzeroberfläche blockieren, indem man es vor dem Fortsetzen des Hauptmenüs aufruft (insbesondere, wenn darauf zugegriffen wird, indem man aus einem anderen Menü zurückkehrt) und die Methode zur Anzeige der Benutzeroberfläche als onFetchAndActivateSuccessful-Callback übergibt. Das Gleiche gilt für das Menü Level Select (Level auswählen).

Beim ersten Laden im Rahmen des App-Starts wird jede Menünavigation über das Hauptmenü durch die erste dieser beiden Aktionen verarbeitet. Wenn das Menü Level Select (Level auswählen) erneut aufgerufen wird, wird ebenfalls eine Aktualisierung ausgelöst. Der erste Aufruf des Menüs zur Levelauswahl ist nicht relevant, da es nur über das Hauptmenü aufgerufen werden kann und somit bereits abgedeckt ist.

Wenn Sie dies in der App aktivieren möchten, führen Sie die entsprechenden Methoden im Hauptmenü und in den Dateien zur Auswahl der Ebene aus. Dadurch wird die UI-Anzeige blockiert, 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. 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.

7. Abrufverhalten debuggen/validieren

An dieser Stelle ist es sinnvoll, eine Diagnose-/Validierungsprüfung durchzuführen. Mit der folgenden Vorgehensweise können Sie manuell testen, wie und ob Ihre App Remote Config-Werte abruft und aktiviert.

Die Informationen werden in den Protokollen des Simulators, des Geräts oder des Editors ausgegeben. Unter iOS können Sie Geräte- und Simulatorprotokolle in Xcode aufrufen. Unter Android können Sie Logs mit dem Befehl adb logcat aufrufen. Wenn Sie den Code in Unity ausführen, indem Sie im Editor auf „Play“ klicken, werden die Protokolle auf dem Tab „Console“ angezeigt.

  1. Erstellen Sie die App neu und führen Sie sie aus (im Editor, auf einem Gerät oder in einem Simulator).
  2. Nachdem das Hauptmenü des Spiels angezeigt wird, sehen Sie sich die Log-Ausgabe des Spiels an. Sie sollte die von Debug.Log in FetchRemoteConfig und ActivateRetrievedRemoteConfigValues generierten Logs enthalten. Dort sollten die Meldungen „Daten werden abgerufen…“ und „Remotedaten geladen und bereit“ angezeigt werden. Achten Sie auf die Zeitstempel am Anfang dieser Nachrichten.
  3. Drücken Sie im Spiel auf Lizenz.
  4. Tippen Sie auf OK.
  5. Warte, bis das Hauptmenü des Spiels angezeigt wird.
  6. Sehen Sie sich die Logausgabe Ihres Spiels an. Sie sollte den Ausgaben im vorherigen Schritt ähneln, aber neue Zeitstempel enthalten, die der Uhrzeit entsprechen, die auf der Systemuhr des Geräts eingestellt ist, auf dem Sie das Spiel ausführen.
  7. Drücken Sie im Spiel auf Spielen.
  8. Drücken Sie auf Let's Roll.
  9. Bringen Sie den Ball mit den Pfeiltasten auf der Tastatur ins Tor. Dadurch wird das Menü „Level abgeschlossen“ geöffnet.
  10. Drücken Sie auf Pegel.
  11. Warte, bis das Menü Level Select (Level auswählen) geladen ist.
  12. Sehen Sie sich die Protokollausgabe Ihres Spiels noch einmal an. Sie sollten mit den Log-Nachrichten aus den vorherigen Schritten übereinstimmen, aber neuere Zeitstempel haben (entsprechend der Zeit, die auf der Systemuhr eingestellt ist, auf der Sie das Spiel ausführen).

Wenn einer dieser Werte nicht in Ihrer App angezeigt wurde, ist möglicherweise ein Teil des Abruf- und Aktivierungsablaufs oder Ihres Geräts falsch konfiguriert. Wenn das erste Log nicht angezeigt wird, kann es sein, dass das Spiel nicht gestartet wird. Sehen Sie in der Editor-Konsole oder in den Geräte-/Emulatorlogs nach Warnungen und Fehlern zu Ihrem Projekt/Ihrer Umgebung und untersuchen Sie diese. Das Problem kann so einfach sein wie eine fehlende Internetverbindung.

Wenn die ersten Logs vom Laden des Menüs angezeigt werden, aber einer 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 In-App-Parameterwerte in SetDefaultsAsync() konfiguriert und die aktuellen Versionen mit FetchAsync() und ActivateAsync() verfügbar gemacht haben, können Sie im Code auf diese Werte verweisen und sie verwenden.

Nachdem Sie Werte im Remote Config-Backend festgelegt haben, können Sie sie abrufen und aktivieren (oder beides gleichzeitig ausführen). Diese Werte sind dann für Ihre App verfügbar. Rufen Sie GetValue(string key) auf und wählen Sie einen Parameterschlüssel als Argument aus, um die Werte zu verwenden. 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 den meisten Gaming-Anwendungsfällen müssen Sie die letzten beiden Typen in die idiomatischen Typen int und float umwandeln. Damit diese Conversions keine Probleme verursachen, müssen die in Remote Config festgelegten Anfangswerte im gültigen Bereich der Typen liegen, die Sie im App-Code verwenden.

  1. Importieren Sie Remote Config, indem Sie using Firebase.RemoteConfig; oben in die 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 von der Beschleunigungs-Kachel ausgeübte Kraft auf einen Wert geändert, der von Remote Config empfangen wird.
  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 wird subtitleOverride so festgelegt, dass der Untertitel auf dem Hauptmenübildschirm geändert wird, wenn alle Felder in der Cloud auf andere Werte als die Standardwerte des Typs festgelegt sind.

9. Parameterwerte per Remote-Konfiguration festlegen

Nachdem Ihre App 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 Ihr Projekt in der Firebase Console.
  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

    subtitle_override

    JSON

    {"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}

    Remote Config-Parametereditor mit dem Wert „acceleration_tile_force“
  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 Ihre App nach dem Festlegen dieser Remote-Parameter noch einmal aus und beobachten Sie, wie die ursprünglichen Standardwerte überschrieben werden.Mechahamster-Hauptbildschirm mit aktiviertem Debug-Menü

10. Remote Config-Bedingungen zum Bereitstellen von Varianten verwenden

Sie können die App-Nutzung an den Nutzer anpassen, indem Sie die Sprache, den Standort, die Tageszeit oder die verwendete Plattform berücksichtigen. Mit Remote Config-Bedingungen können Sie diese und andere Attribute einzeln oder in Kombination verwenden, um dem Nutzer verschiedene Werte (Varianten) zu präsentieren.

Eine häufige Verwendung von Bedingungen ist das Ändern von Inhalten zwischen iOS- und Android-Plattformen. Gehen Sie so vor, um eine Bedingung zu implementieren, mit der je nach verwendeter Plattform ein anderer Wert für subtitle_override bereitgestellt wird.

  1. Öffnen Sie in der Firebase Console den Tab „Remote Config“ Ihres Projekts.
  2. Klicken Sie auf die Schaltfläche zum Bearbeiten von subtitle_override..
  3. Klicken Sie links unten auf Neu hinzufügen.
  4. Bewegen Sie den Mauszeiger im Drop-down-Menü, das angezeigt wird, auf Bedingter Wert und klicken Sie auf Neue Bedingung erstellen.Remote Config-Parameter-Editor: Option für bedingten Wert
  5. Geben Sie bei Aufforderung den Namen „is iOS“ ein, wenn Sie iOS-Nutzer ansprechen möchten, oder „is Android“, wenn Sie Android-Nutzer ansprechen möchten. Wenn Sie beide Plattformen als Zielgruppe festlegen, wählen Sie hier einfach eine aus und verwenden Sie sie für den Rest des Codelabs.iOS-spezifische Bedingung im Dialogfeld „Neue Bedingung definieren“ definieren
  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.iOS-Plattform mit dem Editor „Neue Bedingung definieren“ auswählen
  7. Klicken Sie auf Bedingung erstellen, um die Bedingung zu erstellen. Das Dialogfeld „Parameter bearbeiten“ wird wieder angezeigt und Sie können jetzt einen Wert festlegen:
    • Wenn Sie Android-Geräte als Zielgruppe verwenden, legen Sie den Wert auf Folgendes fest: 
      {"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
    • Wenn Sie iOS als Zielgruppe festlegen, legen Sie den Wert auf 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 den Empfang von Echtzeitupdates konfigurieren

Remote Config kann jetzt Remote Config-Vorlagen in Echtzeit abrufen und aktualisieren. Apps können die neue Echtzeit-Remote Config API abonnieren, um auf Konfigurationsänderungen und aktualisierte Werte zu reagieren.

Funktionsweise

Damit Ihre App auf Updates warten kann, muss sie eine Methode implementieren, die das OnConfigUpdateListener-Ereignis abonniert. Wenn 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 Logik als Reaktion auszuführen, z. B. die neuen Werte zu aktivieren und für den Rest der Anwendung verfügbar zu machen.

Echtzeit-Remote Config implementieren

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

Handler für Konfigurationsupdates erstellen

Der erste Schritt bei der Verwendung des Ereignisses „Config Update“ besteht darin, eine Methode zu erstellen, die darauf warten kann. Fügen Sie die folgende Methode in Assets/Hamster/Scripts/MainGame.cs ein:

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

Bei dieser Methode wird eine Liste der aktualisierten Schlüssel und eine Erfolgsmeldung im Log ausgegeben, wenn die neuen Werte aktiviert werden.

Das Update-Ereignis abonnieren

Wenn Sie ActivateValuesOnConfigUpdate aktivieren möchten, wenn das Ereignis aufgerufen wird, abonnieren Sie das 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());
   }

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

Abonnement beenden, wenn das zugehörige Objekt des Handlers zerstört wird

Um Null-Referenzfehler zu vermeiden, müssen Objekte mit Methoden, die Ereignisse abonnieren, die Methode abmelden, wenn sie zerstört werden. Fügen Sie Assets/Hamster/Scripts/MainGame.cs die folgende Methode hinzu:

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

Neue Funktion testen

Um die neue Funktion zu testen, probieren Sie die erstellte App aus. Für das folgende Verfahren ist es erforderlich, dass Sie das Log lesen und auf einem echten Gerät debuggen können.

acceleration_tile_force ändern und beobachten

Nachdem Sie Ihre App gestartet haben, gehen Sie in der Firebase Console zum Abschnitt „Remote Config“:

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

dc602d4db54e50a4.png

  1. Ändern Sie den Wert in „120“ und drücken Sie Speichern.

fcbc1df848f88009.png

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

3785c1e00e7a6359.png

  1. Prüfen Sie das Log.
  2. Wenn Sie eine Log-Meldung sehen, die mit „Error occurred while listening“ (Fehler beim Zuhören) beginnt, lesen Sie den Rest der Meldung und versuchen Sie, den Fehler anhand der Fehlermeldung zu beheben.
  3. Wenn Sie ein Log sehen, das mit „Updated keys“ beginnt, hat Ihre App die geänderten Werte erhalten.
  4. Wenn Sie keines der beiden sehen, sehen Sie sich den Rest Ihrer Logs an und lesen Sie dann die Anleitung unter Config Update-Handler erstellen noch einmal. Führen Sie den Test noch einmal aus und prüfen Sie die Logs noch einmal, um festzustellen, ob etwas nicht stimmt.

12. Glückwunsch!

Sie haben Remote Config verwendet, um In-Game-Werte remote zu steuern, indem Sie sie in Ihrer App abgerufen und Bedingungen verwendet haben, um verschiedene Varianten bereitzustellen.

Behandelte Themen

  • Remote Config-Werte festlegen und abrufen
  • Unity-C#-Code instrumentieren, um die abgerufenen Werte zu verwenden
  • Zusammengesetzte Werte/Objekte als JSON-Werte speichern, instrumentieren und überschreiben
  • Bedingungen in Remote Config verwenden, um verschiedene Wertvarianten bereitzustellen

Nächste Schritte

Weitere Informationen zur Priorität von Parameterwerten