Dostosuj swoją grę w Unity dzięki Zdalnej konfiguracji Firebase

1. Wprowadzenie

Za pomocą Zdalnej konfiguracji Firebase możesz definiować w aplikacji pary klucz-wartość, zwane też parametrami, i aktualizować ich wartości w chmurze. Dzięki temu możesz modyfikować wygląd i działanie aplikacji bez rozpowszechniania aktualizacji.

Dodasz tę nową funkcję do przykładowej gry MechaHamster: Level Up with Firebase Edition. Ta przykładowa gra to nowa wersja klasycznej gry Firebase MechaHamster, w której usunięto większość wbudowanych funkcji Firebase. Dzięki temu możesz wdrożyć w ich miejsce nowe zastosowania Firebase.

Aby mieć pewność, że aplikacja działa zgodnie z oczekiwaniami, ustawisz domyślne konfiguracje wartości w przykładowym kodzie gry. Te wartości mogą zostać zastąpione przez wartości ustawione w Zdalnej konfiguracji w konsoli Firebase.

Czego się nauczysz

  • Jak ustawiać wartości Zdalnej konfiguracji w chmurze i je pobierać
  • Jak zmodyfikować kod C# w Unity, aby automatycznie używać pobranych wartości
  • Przechowywanie, instrumentowanie i zastępowanie wartości złożonych lub obiektów jako wartości JSON
  • Jak używać warunków Zdalnej konfiguracji do wyświetlania różnych wariantów wartości różnym grupom użytkowników

Czego potrzebujesz

  • Unity 2019.1.0f1 lub nowsza z obsługą kompilacji na iOS lub Androida
  • fizyczne urządzenie z Androidem lub iOS albo symulator/emulator do tworzenia i uruchamiania gry;

2. Konfigurowanie środowiska programistycznego

W kolejnych sekcjach opisujemy, jak pobrać kod Level Up with Firebase, otworzyć go w Unity i dodać projekt Firebase. Ta przykładowa gra Level Up with Firebase jest używana w kilku innych ćwiczeniach z zakresu Firebase i Unity, więc być może zadania w tej sekcji zostały już przez Ciebie wykonane. W takim przypadku możesz pominąć te kroki i przejść do sekcji Dodawanie pakietów SDK Firebase dla Unity, aby dodać Zdalną konfigurację do przykładowego kodu gry.

Pobieranie kodu

Sklonuj repozytorium GitHub tego laboratorium z poziomu wiersza poleceń:

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

Jeśli nie masz zainstalowanego narzędzia git, możesz pobrać repozytorium jako plik ZIP.

Otwórz Level Up with Firebase w edytorze Unity.

  1. Uruchom Unity Hub i na karcie Projects (Projekty) kliknij strzałkę w dół obok opcji Open (Otwórz).
  2. Kliknij Dodaj projekt z dysku.
  3. Przejdź do katalogu zawierającego kod i kliknij OK.
  4. Jeśli pojawi się prośba, wybierz wersję edytora Unity, której chcesz używać, oraz platformę docelową (Android lub iOS).
  5. Kliknij nazwę projektu level-up-with-firebase, a projekt otworzy się w edytorze Unity.
  6. Jeśli edytor nie otworzy go automatycznie, otwórz MainGameScene w sekcji Assets > Hamster na karcie Project w edytorze Unity.

Więcej informacji o instalowaniu i używaniu Unity znajdziesz w artykule Praca w Unity.

3. Dodawanie Firebase do projektu Unity

Tworzenie projektu Firebase

  1. Zaloguj się w konsoli Firebase, korzystając ze swojego konta Google.
  2. Kliknij przycisk, aby utworzyć nowy projekt, a potem wpisz jego nazwę (np. LevelUpWithFirebase).
  3. Kliknij Dalej.
  4. Po wyświetleniu monitu przeczytaj i zaakceptuj warunki usługi Firebase, a potem kliknij Dalej.
  5. (Opcjonalnie) Włącz w konsoli Firebase pomoc AI (nazywaną „Gemini w Firebase”).
  6. W tym samouczku Google Analytics jest potrzebne do optymalnego korzystania z usług Firebase, więc pozostaw włączony przełącznik opcji Google Analytics. Aby skonfigurować Google Analytics, postępuj zgodnie z instrukcjami wyświetlanymi na ekranie.
  7. Kliknij Utwórz projekt, poczekaj, aż projekt zostanie udostępniony, a następnie kliknij Dalej.

Rejestrowanie aplikacji w Firebase

  1. Otwórz konsolę Firebase i w centrum strony „Opis” projektu kliknij ikonę Unity, aby uruchomić proces konfiguracji. Jeśli masz już dodaną aplikację do projektu Firebase, kliknij Dodaj aplikację, aby wyświetlić opcje platformy.
  2. Zarejestruj cele kompilacji na urządzenia Apple (iOS) i z Androidem.
  3. Wpisz identyfikatory specyficzne dla platformy projektu Unity. W tym ćwiczeniu wpisz te informacje:
  4. Opcjonalnie wpisz pseudonimy specyficzne dla platformy projektu Unity.
  5. Kliknij Zarejestruj aplikację i przejdź do sekcji Pobierz plik konfiguracyjny.
  6. Powtórz ten proces dla środowiska docelowego, którego nie użyto za pierwszym razem.

Dodawanie plików konfiguracyjnych Firebase

Po kliknięciu Zarejestruj aplikację pojawi się prośba o pobranie 2 plików konfiguracyjnych (po 1 na każdy docelowy typ kompilacji). Aby połączyć projekt Unity z Firebase, musisz umieścić w tych plikach metadane Firebase.

  1. Pobierz oba dostępne pliki konfiguracyjne:
    • W przypadku urządzeń Apple (iOS): pobierz plik GoogleService-Info.plist.
    • Android: pobierz plik google-services.json.
  2. Otwórz okno Project (Projekt) w projekcie Unity, a następnie przenieś oba pliki konfiguracyjne do folderu Assets (Zasoby).
  3. Wróć do konsoli Firebase i w procesie konfiguracji kliknij Dalej, a potem przejdź do sekcji Dodawanie pakietów SDK Firebase do Unity.

Uwaga: te pliki możesz zawsze pobrać ponownie, otwierając ustawienia ogólne projektu, przewijając w dół do sekcji Twoje aplikacje, a następnie klikając przycisk pobierania przy wybranym pliku konfiguracyjnym.

Dodawanie pakietów SDK Firebase dla Unity

  1. W konsoli Firebase kliknij Pobierz pakiet Firebase Unity SDK.
  2. Rozpakuj pakiet SDK w dogodnym miejscu.
  3. W otwartym projekcie Unity kliknij Assets (Zasoby) > Import Package (Importuj pakiet) > Custom Package (Własny pakiet).
  4. W oknie dialogowym Import package (Importuj pakiet) przejdź do katalogu zawierającego rozpakowany pakiet SDK, wybierz FirebaseAnalytics.unitypackage, a następnie kliknij Open (Otwórz).
  5. W wyświetlonym oknie Import Unity Package (Importowanie pakietu dla Unity) kliknij Import (Importuj).
  6. Powtórz poprzednie kroki, aby zaimportować te 2 pakiety:
    • FirebaseRemoteConfig.unitypackage
    • FirebaseCrashlytics.unitypackage
      Crashlytics to lekkie narzędzie do raportowania awarii w czasie rzeczywistym, które pomaga śledzić, określać priorytety i rozwiązywać problemy ze stabilnością, które obniżają jakość aplikacji. Jeśli nie masz doświadczenia w korzystaniu z tego narzędzia, zapoznaj się ze ścieżką szkoleniową Crashlytics dla Unity.
  7. Wróć do konsoli Firebase i w przepływie pracy konfiguracji kliknij Dalej.

Więcej informacji o dodawaniu pakietów SDK Firebase do projektów Unity znajdziesz w sekcji Dodatkowe opcje instalacji w Unity.

4. Ustawianie wartości domyślnych Zdalnej konfiguracji i pobieranie nowych wartości

W tym laboratorium nauczysz się aktualizować obiekty, które używają wartości zdefiniowanych w kodzie lub serializowanych w edytorze Unity, tak aby korzystały z wartości instrumentowanych za pomocą Zdalnej konfiguracji. Dla każdego parametru skonfigurujesz wartości domyślne za pomocą SetDefaultsAsync, aby aplikacja działała zgodnie z oczekiwaniami, zanim połączy się z backendem Zdalnej konfiguracji. Aplikacja będzie zawsze aktualna, ponieważ będzie pobierać nowe wartości ze Zdalnej konfiguracji i aktywować je, aby można było ich używać w kodzie.

Aby pobrać nowe wartości ze Zdalnej konfiguracji, musisz uzupełnić kilka niezaimplementowanych jeszcze metod w pliku Assets/Hamster/Scripts/MainGame.cs.

  1. Dodaj do pliku MainGame.cs te using:
    using Firebase.Crashlytics;
using Firebase.Extensions;
using Firebase.RemoteConfig;
    Moduł Firebase.Extensions zawiera rozszerzenia interfejsu C# Tasks API, które ułatwiają zarządzanie procesem inicjowania za pomocą wywołań zwrotnych.
  2. Dodaj inicjalizację Firebase do metody MainGame.cs Start(), zastępując istniejącą metodę InitializeCommonDataAndStartGame() metodą InitializeFirebaseAndStartGame(), która nie jest jeszcze zaimplementowana:
    void Start()
{
   Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
   InitializeFirebaseAndStartGame();
}
  3. W języku MainGame.cs znajdź InitializeFirebaseAndStartGame(). Zadeklaruj zmienną aplikacji i zastąp implementację metody w ten sposób:
    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. W przypadku powodzenia wywołania inicjalizacji Firebase wywołuje funkcję SetRemoteConfigDefaults, aby ustawić domyślne wartości w aplikacji. Zastąp niezaimplementowaną metodę SetRemoteConfigDefaults tym kodem:
    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. Pobieranie i aktywowanie nowych wartości (w razie potrzeby)

Musimy teraz dokończyć istniejącą metodę FetchRemoteConfig. Spowoduje to połączenie wywołań metod Zdalnej konfiguracji FetchAsync (która pobiera nowe wartości ze Zdalnej konfiguracji) i ActivateAsync (która aktywuje uzyskane wartości, aby były dostępne w kodzie) za pomocą parametru wywołania zwrotnego o nazwie onFetchAndActivateSuccessful.

Kod uruchamiania dodany w poprzednim kroku wywołuje funkcję FetchRemoteConfig z funkcją zwrotną InitializeCommonDataAndStartGame, aby rozpocząć grę na końcu sekwencji. Możesz przekazywać do funkcji FetchRemoteConfig alternatywne wywołania zwrotne, aby wywoływać pobieranie z różnymi wynikami. Przykładem (który zaimplementujesz później) jest przekazanie metody otwierającej nowe menu interfejsu, które zależą od wartości Zdalnej konfiguracji. Spowoduje to otwarcie menu dopiero po pobraniu i aktywacji tych wartości.

  1. Wklej poniższy kod do pliku FetchRemoteConfig:
    public void FetchRemoteConfig(System.Action onFetchAndActivateSuccessful)
{
   if(app==null)
   {
      Debug.LogError($"Do not use Firebase until it is properly initialized by calling {nameof(InitializeFirebaseAndStartGame)}.");
      return;
   }

   Debug.Log("Fetching data...");
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   remoteConfig.FetchAsync(System.TimeSpan.Zero).ContinueWithOnMainThread(
      previousTask=>
      {
         if (!previousTask.IsCompleted)
         {
         Debug.LogError($"{nameof(remoteConfig.FetchAsync)} incomplete: Status '{previousTask.Status}'");
         return;
         }
         ActivateRetrievedRemoteConfigValues(onFetchAndActivateSuccessful);
      });
}
  2. Następnie wykonaj metodę ActivateRetrievedRemoteConfigValues, która otrzymuje przekazane wywołanie zwrotne onFetchAndActivateSuccessful. Po zakończeniu aktywacji zostanie wywołane określone wywołanie zwrotne:
    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();
         });
   }
}

Gdy funkcja SetRemoteConfigDefaults jest wywoływana w dół strumienia z kontekstu inicjowania, wywołuje poprzedni punkt początkowy InitializeCommonDataAndStartGame, aby rozpocząć grę przez otwarcie menu głównego.ActivateRetrievedRemoteConfigValues

6. Konfigurowanie strategii wczytywania Zdalnej konfiguracji

Aby pobrać i aktywować wartości w innym momencie podczas korzystania z aplikacji, musisz ponownie wywołać te funkcje. Jeśli jakiekolwiek obiekty mają wartości w pamięci podręcznej, muszą zostać powiadomione o konieczności aktualizacji. Aby opracować strategię ponownego pobierania wartości Zdalnej konfiguracji, zastanów się, kiedy potrzebne są nowe wartości i kiedy należy rozpocząć pobieranie i aktywowanie nowych wartości, aby uniknąć ich zmiany podczas używania.

Obecnie wartości Zdalnej konfiguracji są pobierane i aktywowane podczas uruchamiania aplikacji. Pobieranie można ukryć podczas zmian w menu, a także zablokować interakcję podczas przejścia. Jest to też często najbardziej odpowiedni moment na uzyskanie nowych wartości, ponieważ zmiana stanu menu może często służyć do określenia, „gdzie” zmierza gracz, i przewidzenia, że dana wartość zostanie użyta.

Przyglądając się systemowi menu Mechahamstera, najprostszym sposobem na dodanie odświeżania menu blokującego interfejs jest wywołanie go przed wznowieniem działania menu głównego (zwłaszcza gdy jest ono dostępne po wycofaniu się z innego menu) i przekazanie metody wyświetlania interfejsu jako wywołania zwrotnego onFetchAndActivateSuccessful. To samo można zrobić w przypadku menu Wybór poziomu.

W przypadku początkowego wczytywania w ramach uruchamiania aplikacji wszelkie nawigowanie po menu, które przechodzi przez menu główne, będzie obsługiwane przez pierwsze z tych zdarzeń, a ponowne wejście do menu wyboru poziomu również spowoduje odświeżenie. Początkowe wejście do menu wyboru poziomu nie ma znaczenia, ponieważ jest ono dostępne tylko z menu głównego, a to już zostało uwzględnione.

Aby włączyć tę funkcję w aplikacji, wykonaj odpowiednie metody w menu głównym i plikach wyboru poziomu, które zablokują wyświetlanie interfejsu do czasu zakończenia działań FetchAsync i ActivateAsync:

  1. Otwórz Assets/Hamster/Scripts/States/MainMenu.cs i zastąp dotychczasową metodę Resume tym kodem:
    public override void Resume(StateExitValue results) {
   CommonData.mainGame.SelectAndPlayMusic(CommonData.prefabs.menuMusic, true);
   CommonData.mainGame.FetchRemoteConfig(InitializeUI);
}
  2. Zapisz plik.
  3. Otwórz plik Assets/Hamster/Scripts/States/BaseLevelSelect.cs i zastąp istniejącą metodę Resume tym kodem:
    public override void Resume(StateExitValue results) {
   CommonData.mainGame.FetchRemoteConfig(ShowUI);
}
  4. Zapisz plik.

7. Debugowanie i weryfikowanie zachowań pobierania

W tym momencie warto przeprowadzić diagnostykę lub weryfikację. Poniższa procedura pozwoli Ci ręcznie przetestować aplikację i sprawdzić, czy pobiera i aktywuje wartości Zdalnej konfiguracji.

Informacje zostaną wydrukowane w ramach dzienników symulatora, urządzenia lub edytora. W przypadku iOS możesz wyświetlać dzienniki urządzeń i symulatorów w Xcode. W przypadku Androida wyświetl logi, uruchamiając polecenie adb logcat. Jeśli uruchomisz kod w Unity, naciskając Play w edytorze, logi pojawią się na karcie Console.

  1. Zbuduj i uruchom aplikację (w edytorze, na urządzeniu lub w symulatorze).
  2. Gdy pojawi się menu główne gry, sprawdź dane wyjściowe dziennika gry, które powinny zawierać dzienniki wygenerowane przez Debug.Log w FetchRemoteConfig i ActivateRetrievedRemoteConfigValues. Powinny wyświetlać się komunikaty „Fetching data...” (Pobieranie danych...) i „Remote data loaded and ready” (Dane zdalne załadowane i gotowe). Zwróć uwagę na sygnatury czasowe na początku tych wiadomości.
  3. W grze naciśnij Licencja.
  4. Kliknij OK.
  5. Poczekaj, aż pojawi się menu główne gry.
  6. Sprawdź dane wyjściowe dziennika gry. Powinny być podobne do tych z poprzedniego kroku, ale z nowymi sygnaturami czasowymi (odpowiadającymi godzinie ustawionej na zegarze systemowym, na którym uruchamiasz grę).
  7. W grze kliknij Zagraj.
  8. Naciśnij Zaczynajmy.
  9. Za pomocą strzałek na klawiaturze poprowadź piłkę do bramki. Otworzy się menu Ukończono poziom.
  10. Naciśnij Poziomy.
  11. Poczekaj, aż załaduje się menu Wybór poziomu.
  12. Ponownie sprawdź dane wyjściowe dziennika gry. Powinien on być zgodny z komunikatami dziennika z poprzednich kroków, ale z nowszymi sygnaturami czasowymi (zgodnymi z czasem ustawionym na zegarze systemowym, na którym uruchamiasz grę).

Jeśli któreś z tych zdarzeń nie pojawiło się w aplikacji, może to oznaczać, że część procesu pobierania i aktywowania (lub urządzenie) jest nieprawidłowo skonfigurowana. Jeśli pierwszy dziennik się nie pojawi, gra może się nie uruchomić. Sprawdź konsolę edytora lub dzienniki urządzenia/emulatora pod kątem ostrzeżeń i błędów dotyczących projektu lub środowiska i zbadaj je. Problem może być tak prosty, jak brak połączenia z internetem.

Jeśli początkowe logi z wczytywania menu są widoczne, ale jeden z kolejnych nie, sprawdź lub ponownie wdróż metody Resume w Assets/Hamster/Scripts/States/MainMenu.cs i Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

8. Instrumentowanie kodu

Po skonfigurowaniu wartości parametrów w aplikacji w SetDefaultsAsync() i udostępnieniu najnowszych wersji za pomocą FetchAsync() i ActivateAsync() możesz odwoływać się do tych wartości w kodzie i ich używać.

Po ustawieniu wartości w backendzie Zdalnej konfiguracji pobierz je i aktywuj (lub zrób to jednocześnie), aby były dostępne w aplikacji. Aby użyć tych wartości, wywołaj GetValue(string key) i jako argument wybierz klucz parametru. Zwraca to obiekt ConfigValue, który ma właściwości umożliwiające dostęp do wartości w różnych obsługiwanych typach: string, bool, long, double. W tym projekcie i w większości przypadków użycia w grach musisz przekształcić 2 ostatnie typy na bardziej idiomatyczne int i float. Aby mieć pewność, że te konwersje nie spowodują problemów, sprawdź, czy wartości początkowe ustawione w Zdalnej konfiguracji mieszczą się w prawidłowym zakresie typów, których będziesz używać w kodzie aplikacji.

  1. Zaimportuj Zdalną konfigurację, dodając using Firebase.RemoteConfig; na początku tych plików:
    • Assets/Hamster/Scripts/States/MainMenu.cs
    • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
  2. Zastąp metodę Start w przypadku AccelerationTile.cs:
    private void Start() {
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   Acceleration = (float)remoteConfig.GetValue(AccelerationTileForceKey).DoubleValue;
}
    W ramach tej zmiany siła wywierana przez kafelek przyspieszenia zostanie zmieniona na siłę otrzymaną z Remote Config.
  3. Edytuj treść metody InitializeUI w usłudze 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();
}
    W tym przypadku subtitleOverride jest ustawione tak, aby zmienić podtytuł na ekranie menu głównego, jeśli wszystkie jego pola w chmurze mają wartości inne niż wartości domyślne typu.

9. Zdalne ustawianie wartości parametrów

Po pełnym zintegrowaniu aplikacji możesz skonfigurować parametry i wartości na serwerze Zdalnej konfiguracji. W tym laboratorium skonfigurujemy to za pomocą konsoli Firebase.

  1. W konsoli Firebase otwórz projekt.
  2. W menu wybierz Zdalna konfiguracja, aby wyświetlić panel Zdalnej konfiguracji.
  3. W przypadku każdego parametru zdefiniowanego w aplikacji i wymienionego w tabeli poniżej kliknij Dodaj parametr, wklej nazwę parametru (klucz), wybierz Typ danych wymieniony w tabeli, wyłącz opcję Użyj domyślnej wartości w aplikacji i wklej nową wartość domyślną:

    Nazwa parametru (klucz)

    Typ danych

    Wartość domyślna

    acceleration_tile_force

    Liczba

    100

    subtitle_override

    JSON

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

    Edytor parametru Zdalnej konfiguracji z wypełnionym polem acceleration_tile_force
  4. Kliknij Zapisz, aby zapisać zmiany.
  5. Kliknij Opublikuj, aby opublikować nową konfigurację i udostępnić nowe wartości w grze.
  6. Po ustawieniu tych parametrów zdalnych uruchom ponownie aplikację i sprawdź, jak zastępują one pierwotne wartości domyślne.Ekran główny Mechahamster z włączonym menu Debug

10. Używanie warunków Zdalnej konfiguracji do wyświetlania wariantów

Możesz dostosować aplikację do użytkownika na podstawie języka, którym się posługuje, miejsca, w którym się znajduje, pory dnia lub platformy, z której korzysta. Warunki Zdalnej konfiguracji umożliwiają używanie tych i innych atrybutów pojedynczo lub w połączeniu, aby wyświetlać użytkownikowi różne wartości (zwane wariantami).

Jednym z częstych zastosowań warunków jest zmiana treści na platformach iOS i Android. Aby wdrożyć warunek, który wyświetla inną wartość w przypadku parametru subtitle_override w zależności od używanej platformy, wykonaj te czynności:

  1. Otwórz kartę Zdalna konfiguracja projektu w konsoli Firebase.
  2. Kliknij przycisk edytowania elementu subtitle_override..
  3. W lewym dolnym rogu kliknij Dodaj nowe.
  4. W wyświetlonym menu najedź kursorem na Wartość warunkowa i kliknij Utwórz nowy warunek.Edytor parametrów Zdalnej konfiguracji: opcja wartości warunkowej
  5. Gdy pojawi się taka prośba, nazwij warunek „is iOS”, jeśli kierujesz reklamy na urządzenia z iOS, lub „is Android”, jeśli kierujesz reklamy na urządzenia z Androidem. Jeśli kierujesz reklamy na oba typy urządzeń, wybierz jeden z nich i używaj go w pozostałej części tego przewodnika.Określanie warunku dotyczącego iOS w oknie dialogowym Zdefiniuj nowy warunek
  6. W sekcji Dotyczy, jeśli... kliknij menu Wybierz... i wybierz Platforma. Następnie wybierz odpowiednią platformę.Wybieranie platformy iOS w edytorze Zdefiniuj nowy warunek
  7. Aby utworzyć warunek, kliknij Utwórz warunek. Ponownie pojawi się okno dialogowe Edytuj parametr, w którym możesz teraz ustawić wartość:
    • Jeśli kierujesz reklamy na urządzenia z Androidem, ustaw Wartość na: 
      {"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
    • Jeśli kierujesz reklamy na iOS, ustaw Wartość na: 
      {"text":"Level Up iOS Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
  8. Kliknij Zapisz, aby zapisać zmiany.
  9. Kliknij Opublikuj, aby opublikować nową konfigurację i udostępnić nowe wartości w grze.

Jeśli ponownie skompilujesz i uruchomisz grę, zobaczysz, że podtytuł został zastąpiony wariantem dostosowanym do platformy.

11. Konfigurowanie Zdalnej konfiguracji do odbierania aktualizacji w czasie rzeczywistym

Zdalna konfiguracja może teraz nasłuchiwać aktualizacji szablonów Zdalnej konfiguracji w czasie rzeczywistym i je obsługiwać. Aplikacje mogą subskrybować nowy interfejs API Zdalnej konfiguracji w czasie rzeczywistym, aby nasłuchiwać zmian konfiguracji i zaktualizowanych wartości.

Jak to działa

Aby nasłuchiwać aktualizacji, aplikacja musi zaimplementować metodę, która subskrybuje zdarzenie OnConfigUpdateListener. Gdy subskrybowany jest co najmniej 1 odbiorca aktualizacji konfiguracji, nowe szablony Zdalnej konfiguracji są pobierane automatycznie, wywoływane są subskrybowane moduły obsługi, które mogą być używane do wykonywania logiki w odpowiedzi na zdarzenie, np. aktywowania nowych wartości i udostępniania ich reszcie aplikacji.

Wdrażanie Zdalnej konfiguracji w czasie rzeczywistym

Aby pokazać, jak to działa w grze, wprowadź w kodzie te zmiany.

Tworzenie modułu obsługi aktualizacji konfiguracji

Pierwszym krokiem w korzystaniu ze zdarzenia aktualizacji konfiguracji jest utworzenie metody, która będzie je wykrywać. Wstaw poniższą metodę w miejscu 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.");
         });
   }

Gdy ta metoda aktywuje nowe wartości, w dzienniku zostanie wydrukowana lista zaktualizowanych kluczy i komunikat o sukcesie.

Subskrybowanie zdarzenia Update

Aby aktywować ActivateValuesOnConfigUpdate po wywołaniu zdarzenia, zasubskrybuj je. Zastąp metodę InitializeCommonDataAndStartGame() w pliku Assets/Hamster/Scripts/MainGame.cs tym kodem:

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

Nowy wiersz (kończący się znakiem += ActivateValuesOnConfigUpdate;) subskrybuje moduł obsługi zdarzeń w zdarzeniu.

Anuluj subskrypcję, gdy obiekt będący właścicielem modułu obsługi zostanie zniszczony

Aby zapobiec błędom odwołania do wartości null, obiekty z metodami subskrybowanymi w wydarzeniach muszą anulować subskrypcję tych metod, gdy są niszczone. Dodaj do pliku Assets/Hamster/Scripts/MainGame.cs tę metodę:

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

Testowanie nowej funkcji

Aby sprawdzić nową funkcję, wypróbuj utworzoną aplikację. Poniższa procedura wymaga odczytywania logów i debugowania na prawdziwym urządzeniu.

Zmień acceleration_tile_force i obserwuj

Po uruchomieniu aplikacji w sekcji Zdalna konfiguracja w konsoli Firebase:

  1. Kliknij przycisk edycji obok opcji acceleration_tile_force.

dc602d4db54e50a4.png

  1. Zmień wartość na „120” i kliknij Zapisz.

fcbc1df848f88009.png

  1. Kliknij przycisk Opublikuj zmiany.

3785c1e00e7a6359.png

  1. Sprawdź dziennik.
  2. Jeśli zobaczysz komunikat w dzienniku zaczynający się od „Error occurred while listening” (Wystąpił błąd podczas słuchania), przeczytaj jego dalszą część i spróbuj debugować, korzystając z wyświetlonego komunikatu o błędzie.
  3. Jeśli zobaczysz log, który zaczyna się od „Updated keys” (Zaktualizowane klucze), oznacza to, że aplikacja otrzymała zmienione wartości.
  4. Jeśli nie widzisz żadnego z tych wpisów, przejrzyj pozostałe logi, a potem ponownie zapoznaj się z instrukcjami w sekcji Tworzenie modułu obsługi aktualizacji konfiguracji, ponownie przetestuj i sprawdź logi, aby ustalić, czy coś jest nie tak.

12. Gratulacje!

Za pomocą Zdalnej konfiguracji możesz zdalnie kontrolować wartości w grze, pobierając je w aplikacji i używając warunków do wyświetlania różnych wariantów.

Omówione zagadnienia

  • Jak ustawiać i pobierać wartości Zdalnej konfiguracji
  • Jak zaimplementować kod C# w Unity, aby używać pobranych wartości
  • Przechowywanie, instrumentowanie i zastępowanie wartości złożonych lub obiektów jako wartości JSON
  • Jak używać warunków Zdalnej konfiguracji do wyświetlania różnych wariantów wartości

Dalsze kroki

Przeczytaj artykuł o priorytecie wartości parametrów, aby lepiej zrozumieć logikę, według której instancja aplikacji uzyskuje wartości, gdy używa parametru z wieloma wartościami (z powodu warunków lub lokalizacji).