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

1. Wprowadzenie

Za pomocą Zdalnej konfiguracji Firebase możesz definiować pary klucz-wartość (nazywane też parametrami) w aplikacji i aktualizować ich wartości w chmurze. Pozwala to na modyfikowanie wyglądu i działania aplikacji bez jej aktualizowania.

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, która usuwa większość wbudowanych funkcji Firebase, dzięki czemu możesz wdrożyć nowe zastosowania Firebase zamiast niej.

Aby aplikacja działała prawidłowo, ustaw domyślne konfiguracje wartości w przykładowym kodzie gry, a wartości te można zastąpić wartościami ustawionymi w Zdalnej konfiguracji w konsoli Firebase.

Czego się nauczysz

• Jak ustawić wartości Zdalnej konfiguracji w chmurze i je pobierać
• Jak dostosować kod Unity C#, aby automatycznie używać pobranych wartości
• Jak przechowywać, instrumentować i zastępować złożone wartości/obiekty jako wartości JSON
• Jak używać warunków Zdalnej konfiguracji, aby udostępniać różne warianty wartości różnym grupom użytkowników

Czego potrzebujesz

• Unity w wersji 2019.1.0f1 lub nowszej 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 poniższych sekcjach opisano, jak pobrać kod Kolejny poziom dzięki Firebase, otworzyć go w Unity i dodać projekt Firebase. Ta przykładowa gra z Firebase jest już wykorzystywana w innych ćwiczeniach z programowania Firebase i Unity, więc możliwe, że masz już za sobą zadania z tej sekcji. Jeśli tak, możesz pominąć te kroki i przejść do dodawania pakietów SDK Firebase dla Unity, aby dodać Zdalną konfigurację do przykładowego kodu gry.

Pobieranie kodu

Skopiuj repozytorium GitHub tego ćwiczenia z programowania za pomocą wiersza poleceń:

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

Jeśli nie masz zainstalowanej aplikacji git, możesz pobrać repozytorium jako plik ZIP.

Otwórz Przejdź na wyższy poziom dzięki 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ę taka prośba, wybierz wersję edytora Unity, której chcesz użyć, oraz platformę docelową (Android lub iOS).
5. Kliknij nazwę projektu level-up-with-firebase, aby otworzyć projekt w edytorze Unity.
6. Jeśli edytor nie otworzy się automatycznie, otwórz MainGameScene w sekcji Zasoby > Hamster (Hamster) na karcie Project (Projekt) w edytorze Unity.
   

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

3. Dodaj Firebase do projektu Unity

Tworzenie projektu Firebase

1. W konsoli Firebase kliknij Dodaj projekt.
2. Aby utworzyć nowy projekt, wpisz odpowiednią nazwę.
   Spowoduje to również ustawienie identyfikatora projektu (wyświetlanego pod nazwą projektu) na podstawie nazwy projektu. Opcjonalnie możesz kliknąć ikonę edytuj przy identyfikatorze projektu, aby jeszcze bardziej go dostosować.
3. W razie potrzeby przeczytaj i zaakceptuj warunki korzystania z Firebase.
4. Kliknij Dalej.
5. Wybierz opcję Włącz Google Analytics dla tego projektu, a potem kliknij Dalej.
6. Wybierz istniejące konto Google Analytics, którego chcesz użyć, lub kliknij Utwórz nowe konto, aby utworzyć nowe konto.
7. Kliknij Utwórz projekt.
8. Po utworzeniu projektu kliknij Dalej.

Zarejestruj aplikację w Firebase

1. Otwórz konsolę Firebase i na środku strony przeglądu projektu kliknij ikonę Unity, aby uruchomić przepływ pracy konfiguracji. Jeśli masz już aplikację w projekcie Firebase, kliknij Dodaj aplikację, aby wyświetlić opcje platformy.
2. Wybierz, aby zarejestrować cele kompilacji dla Apple (iOS) i Androida.
3. Wpisz identyfikatory platformy projektu Unity. W ramach tego ćwiczenia w Codelabs wpisz następujące informacje:
   • Apple (iOS) – wpisz com.google.firebase.level-up w polu Identyfikator pakietu na iOS.
   • Android – wpisz com.google.firebase.level_up w polu Nazwa pakietu na Androida.
4. Opcjonalnie wpisz pseudonimy związane z platformą projektu Unity.
5. Kliknij Zarejestruj aplikację i przejdź do sekcji Pobierz plik konfiguracyjny.
6. Powtórz te czynności w przypadku każdego celu kompilacji, który nie został wykonany za pierwszym razem.

Dodaj pliki konfiguracji Firebase

Po kliknięciu Zarejestruj aplikację wyświetli się prośba o pobranie 2 plików konfiguracji (po 1 pliku konfiguracji dla każdego celu kompilacji). Twój projekt w Unity wymaga metadanych Firebase w tych plikach, aby połączyć się z Firebase.

1. Pobierz oba dostępne pliki konfiguracyjne:
   • Apple (iOS): pobierz plik GoogleService-Info.plist.
   • Android: pobierz plik google-services.json.
2. Otwórz okno Projekt projektu Unity, a następnie przenieś oba pliki konfiguracyjne do folderu Assets (Zasoby).

   Ważne: nawet jeśli planujesz utworzyć tylko aplikacje na iOS lub Androida, pobierz oba pliki i dodaj je do projektu.

3. Wróć do konsoli Firebase, w procesie konfiguracji kliknij Dalej i przejdź do dodawania pakietów SDK Firebase dla Unity.

Uwaga: zawsze możesz ponownie pobrać te pliki. Aby to zrobić, otwórz ustawienia ogólne projektu, przewiń w dół do sekcji Twoje aplikacje i kliknij przycisk pobierania odpowiedniego pliku konfiguracji.

Dodaj pakiety SDK Firebase dla Unity

1. W konsoli Firebase kliknij Pobierz pakiet SDK Firebase Unity.

   Uwaga: pobieranie tego pakietu SDK może trochę potrwać. Zobacz podgląd kolejnych kroków lub zrób sobie krótką przerwę.

2. Rozpakuj pakiet SDK w dogodnym miejscu.
3. W otwartym projekcie Unity przejdź do opcji Assets (Zasoby) > Importuj pakiet > Pakiet niestandardowy.
4. W oknie Importuj pakiet przejdź do katalogu zawierającego rozpakowany pakiet SDK, wybierz FirebaseAnalytics.unitypackage i kliknij Otwórz.
5. W wyświetlonym oknie Import Unity Package (Importuj pakiet Unity) kliknij Importuj.
6. Powtórz poprzednie kroki, aby zaimportować następujące dwa pakiety:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics to niewielka aplikacja do raportowania awarii w czasie rzeczywistym, która pomaga śledzić i nadawać priorytety problemom ze stabilnością, które obniżają jakość aplikacji, oraz określać ich priorytety. Jeśli dopiero zaczynasz korzystać z tej usługi, rozważ ukończenie ścieżki edukacyjnej Crashlytics dla Unity.
7. Wróć do konsoli Firebase i w procesie konfiguracji kliknij Dalej.

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

4. Ustaw wartości domyślne Zdalnej konfiguracji i pobierz nowe wartości

W ramach tego ćwiczenia w Codelabs dowiesz się, jak zaktualizować obiekty, które używają wartości zdefiniowanych w kodzie lub są serializowane w edytorze Unity, aby używać wartości powiązanych z funkcją Zdalnej konfiguracji. Za pomocą SetDefaultsAsync skonfigurujesz domyślne wartości każdego parametru, aby aplikacja działała prawidłowo, 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 korzystać z nich w kodzie.

Aby pobrać nowe wartości z Zdalnej konfiguracji, plik Assets/Hamster/Scripts/MainGame.cs musi zawierać kilka niezaimplementowanych metod.

1. Dodaj do MainGame.cs następujące oświadczenia using:

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

   Moduł Firebase.Extensions zawiera pewne rozszerzenia do 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 obecnie nie jest zaimplementowana:

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

3. W aplikacji 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. Po udanym inicjowaniu Firebase wywołuje metodę SetRemoteConfigDefaults, aby ustawić domyślne wartości w aplikacji. Zastąp nieimplementowaną metodę SetRemoteConfigDefaults następującym:

   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. Pobierz i aktywuj nowe wartości (w razie potrzeby)

Teraz musimy dokończyć obecną metodę FetchRemoteConfig. Spowoduje to łańcuch wywołań metod Zdalnej konfiguracji FetchAsync (które pobiera nowe wartości z Zdalnej konfiguracji) i ActivateAsync (która aktywuje uzyskane wartości w celu udostępnienia ich w kodzie) z użyciem parametru wywołania zwrotnego o nazwie onFetchAndActivateSuccessful.

Kod startowy dodany w poprzednim kroku wywołuje FetchRemoteConfig z wywołaniem zwrotnym InitializeCommonDataAndStartGame, aby umożliwić uruchomienie gry na końcu sekwencji. Możesz przekazać alternatywne wywołania zwrotne do FetchRemoteConfig, aby wywołać pobieranie z różnymi wynikami. Przykładem (który wdrożysz później) jest metoda otwierająca nowe menu interfejsu zależne od wartości Zdalnej konfiguracji. Spowoduje to, że menu otworzą się dopiero po pobraniu i aktywowaniu tych wartości.

1. Wklej poniższy kod do komórki 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);
         });
   }
   

   Uwaga: wartość cacheExpiration przekazywana do FetchAsync określa, jak długo pobrane wcześniej wartości mają być przechowywane w pamięci podręcznej. W trakcie programowania możesz ustawić tę wartość na System.TimeSpan.Zero, jak pokazano powyżej. Dzięki temu aplikacja zawsze odzwierciedla najbardziej aktualne wartości. Jednak po opublikowaniu wersji produkcyjnej dla parametru cacheExpiration ustaw wyższą wartość, aby uniknąć ograniczania. Domyślny okres (w przypadku wywołania funkcji FetchAsync bez parametrów) to 12 godzin.

2. Następnie ukończ metodę ActivateRetrievedRemoteConfigValues, która otrzymuje przekazane wywołanie zwrotne onFetchAndActivateSuccessful. Po zakończeniu aktywacji wywoływane jest 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 wywołuje metodę pobierania z kontekstu inicjowania, funkcja ActivateRetrievedRemoteConfigValues wywołuje poprzedni punkt początkowy (InitializeCommonDataAndStartGame), aby rozpocząć grę przez otwarcie menu głównego.

6. Skonfiguruj strategię wczytywania Zdalnej konfiguracji

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

Obecnie wartości Zdalnej konfiguracji są pobierane i aktywowane po uruchomieniu aplikacji. Pobrania można ukryć podczas wprowadzania zmian w menu, a jednocześnie blokować interakcję podczas przejścia. Jest to też często najkorzystniejszy moment na pobranie nowych wartości, ponieważ zmiana stanu menu pozwala często określić miejsce i przewiduje, że zostanie użyta wartość.

Z punktu widzenia systemu menu Mechahamstera najłatwiej dodać odświeżanie menu blokującego UI. W tym celu wywołaj je przed wznowieniem menu głównego (zwłaszcza wtedy, gdy otworzysz je, wychodząc z innego menu) i przekażesz metodę wyświetlania interfejsu jako wywołanie zwrotne onFetchAndActivateSuccessful. To samo możesz zrobić w menu Wybór poziomu.

Podczas początkowego wczytywania w ramach uruchamiania aplikacji każda nawigacja w menu przechodząca przez menu główne będzie obsługiwana przez pierwszy z tych elementów, a ponowne wyświetlenie menu Wybór poziomu spowoduje odświeżenie. Początkowe wejście do menu wyboru poziomu nie ma znaczenia, ponieważ jest dostępne tylko z menu głównego, więc jest już uwzględnione.

Aby włączyć tę funkcję w aplikacji, wykonaj odpowiednie czynności w menu głównym i wybierz pliki do wyboru poziomu. Spowoduje to zablokowanie wyświetlania interfejsu użytkownika do czasu ukończenia wszystkich działań w FetchAsync i ActivateAsync:

1. Otwórz plik Assets/Hamster/Scripts/States/MainMenu.cs i zastąp istniejącą metodę Resume tymi:

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

2. Zapisz plik.
3. Otwórz Assets/Hamster/Scripts/States/BaseLevelSelect.cs. Zastąp obecną metodę Resume tymi:

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

4. Zapisz plik.

Uwaga: to ćwiczenie w Codelabs pozwala wczytywać wartości Zdalnej konfiguracji, gdy aktywne jest menu główne i widoki wyboru poziomu. Dostępne są jednak inne strategie wczytywania. Więcej informacji znajdziesz w artykule o strategiach wczytywania Zdalnej konfiguracji Firebase.

7. Debuguj/weryfikuj zachowania związane z pobieraniem

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

Te informacje zostaną wydrukowane jako część dzienników symulatora, urządzenia lub edytora. W przypadku iOS logi urządzenia i symulatorów można wyświetlać w Xcode. W przypadku Androida logi możesz wyświetlać, uruchamiając adb logcat. Jeśli uruchomisz kod w Unity przez naciśnięcie Play (Play) w edytorze, na karcie Console (Konsola) pojawią się logi.

1. Ponownie skompiluj i uruchom aplikację (w Edytorze za pomocą urządzenia lub symulatora).
2. Po wyświetleniu menu głównego gry przejrzyj dane wyjściowe jej dziennika. Powinny one zawierać dzienniki wygenerowane przez Debug.Log w programach FetchRemoteConfig i ActivateRetrievedRemoteConfigValues. Powinno wyświetlić się komunikat „Pobieram dane...” oraz „Dane zdalne wczytane i gotowe” wiadomości. Zwróć uwagę na sygnatury czasowe na początku tych wiadomości.
3. W grze naciśnij Licencja.
4. Naciśnij OK.
5. Poczekaj, aż pojawi się menu główne gry.
6. Przejrzyj dane wyjściowe dziennika gry – powinny być podobne do tych z poprzedniego kroku, z nowymi sygnaturami czasowymi (odpowiadającymi zegarowi systemowemu, na którym grasz).
7. W grze naciśnij Zagraj.
8. Naciśnij Let's Roll.
9. Nawiguj piłką do celu za pomocą strzałek na klawiaturze. Otworzy się menu Ukończono poziom.
10. Kliknij Poziomy.
11. Poczekaj, aż wczyta się menu Level Select.
12. Ponownie przejrzyj dane wyjściowe dziennika gry. Powinien odpowiadać komunikatom dziennika z wcześniejszych kroków z nowszymi sygnaturami czasowymi (odpowiadającymi godzinom ustawionym na zegarze systemowym, w którym uruchamiasz grę).

Jeśli któregoś z nich nie ma w aplikacji, może to oznaczać, że jakaś część procesu pobierania i aktywacji (lub Twoje urządzenie) jest nieprawidłowa. Jeśli nie widzisz pierwszego logu, możliwe, że gra się nie uruchomi. Przejrzyj konsolę edytora lub dzienniki urządzenia/emulatora pod kątem ostrzeżeń i błędów dotyczących projektu bądź środowiska, a następnie zbadaj je – do ich problemu może wystarczyć połączenie z internetem.

Jeśli wyświetlają się początkowe logi wczytywania menu, ale jeden z kolejnych się nie wyświetla, sprawdź lub ponownie zaimplementuj metody Resume w Assets/Hamster/Scripts/States/MainMenu.cs i Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

8. Wdrożenie kodu

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

Gdy ustawisz wartości w backendzie Zdalnej konfiguracji, pobierzesz je i aktywujesz (lub wykonaj obie te czynności naraz), będą one dostępne w Twojej aplikacji. Aby użyć tych wartości, wywołaj GetValue(string key) i jako argument wybierz klucz parametru. Zwraca wartość ConfigValue, która zawiera 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 gier ostatnie 2 typy musisz rzutować na bardziej idiomatyczne wartości int i float. Aby mieć pewność, że te konwersje nie powodują problemów, upewnij się, że początkowe wartości ustawione w Zdalnej konfiguracji mieszczą się w 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 metody AccelerationTile.cs:

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

   W wyniku tej zmiany siła wywierana przez kafelek przyspieszenia zmieni się na tę otrzymaną ze Zdalnej konfiguracji.
3. Edytuj treść metody InitializeUI metody 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 miejscu funkcja subtitleOverride zmienia podtytuł na ekranie menu głównego, jeśli wszystkie jego pola w chmurze są ustawione jako wartości inne niż wartości domyślne ich typu.

Uwaga: SubtitleOverrideKey to const string zdefiniowany w MainMenu.cs z parametrem subtitle_override.

9. Zdalne ustawianie wartości parametrów

Teraz, gdy aplikacja jest w pełni uporządkowana, możesz zacząć konfigurować parametry i wartości na serwerze Zdalnej konfiguracji. W ramach tego ćwiczenia w Codelabs skonfigurujemy to za pomocą konsoli Firebase.

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

   Nazwa (klucz) parametru	Typ danych	Wartość domyślna
   acceleration_tile_force	Liczba	100
   Caption_override	JSON	{"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}

   

   Uwaga: dla każdego parametru możesz ustawić wartość domyślną, która zastąpi domyślną wartość w aplikacji. Więcej informacji znajdziesz w artykule Parametry i warunki Zdalnej konfiguracji.

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 aplikację ponownie i sprawdź, jak zastępują one pierwotne wartości domyślne.

   Wskazówka: w przypadku wartości, które są trudniejsze do obserwowania, np. wartości fizycznych, możesz zaktualizować kod tak, aby rejestrował wartość ConfigValue.Source w celu określenia, czy wartości są ich skonfigurowanymi wartościami domyślnymi czy zostały pobrane z serwera Zdalnej konfiguracji.

Uwaga: użyj metod ToJson i FromJson<T> Unity w zakresie ToJson i FromJson<T> do kodowania i dekodowania obiektów danych z możliwością serializacji do i z ciągu (jak to jest obecnie podczas inicjowania funkcji SubtitleOverrideDefault w MainMenu.cs). Dokumentacja Unity dotycząca serializacji opisuje ograniczenia Unity dotyczące serializacji obiektów.

10. Używanie warunków Zdalnej konfiguracji do obsługi wariantów

Możesz dostosować aplikację do użytkownika na podstawie języka, którym się on posługuje, miejsca pobytu, pory dnia lub platformy, z której korzysta. Warunki Zdalnej konfiguracji pozwalają używać tych i innych atrybutów pojedynczo lub w połączeniu z innymi wartościami (nazywanymi wariantami).

Częstym zastosowaniem warunków jest zmienianie treści między platformami iOS i Android. Wykonaj opisane poniżej czynności, aby wdrożyć warunek, który ma różną wartość parametru subtitle_override w zależności od używanej platformy.

1. Otwórz kartę Zdalna konfiguracja projektu w konsoli Firebase.
2. Kliknij przycisk edycji elementu subtitle_override.
3. W lewym dolnym rogu kliknij Dodaj nowy.
4. W wyświetlonym menu najedź kursorem na opcję Wartość warunkowa i kliknij Utwórz nowy warunek.
5. Gdy pojawi się prośba, nadaj warunekowi nazwę „iOS”. jeśli kierujesz reklamy na iOS lub Androida jeśli kierujesz aplikację na Androida. Jeśli kierujesz reklamy na obie te grupy, po prostu wybierz jeden z nich i wykorzystaj go w pozostałych ćwiczeniach z programowania.
6. W sekcji Dotyczy, jeśli... kliknij menu Wybierz... i wybierz Platforma. Następnie wybierz odpowiednią platformę.
7. Aby utworzyć warunek, kliknij Utwórz warunek. Ponownie wyświetli się okno Edytuj parametr, w którym możesz ustawić wartość:
   • Jeśli kierujesz aplikację na Androida, w polu Wartość wpisz:

     {"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, w polu Wartość wpisz:

     {"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 skompilujesz i uruchomisz grę ponownie, podtytuł powinien pojawić się pod jej wersją dostępną na danej platformie.

11. Skonfiguruj Zdalną konfigurację, aby otrzymywać aktualizacje w czasie rzeczywistym

Uwaga: aktualizacje Zdalnej konfiguracji w czasie rzeczywistym są obsługiwane przez pakiet SDK w wersji 11.0.0 lub nowszej na platformy Android i Apple. Nie jest obecnie obsługiwana w trybie odtwarzania w Unity.

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

Jak to działa

Aby nasłuchiwać aktualizacji, aplikacja musi zaimplementować metodę, która subskrybuje zdarzenie OnConfigUpdateListener. Co najmniej jeden detektor aktualizacji konfiguracji jest subskrybowany, ale nowe szablony Zdalnej konfiguracji będą pobierane automatycznie, a subskrybowane moduły obsługi są wywoływane i mogą służyć do wykonywania działań logicznych, np. aktywowania nowych wartości i udostępniania ich reszcie aplikacji.

Uwaga: jeśli wszyscy subskrybenci zostaną usunięci z listy OnConfigUpdateListener, przestanie ona nasłuchiwać zmian w szablonie Zdalnej konfiguracji Twojego projektu.

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 do zastosowania zdarzenia Config Update jest utworzenie metody nasłuchującej go. Umieść w Assets/Hamster/Scripts/MainGame.cs tę metodę:

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

Ta metoda spowoduje wyświetlenie w dzienniku listy zaktualizowanych kluczy i komunikatu o powodzeniu, gdy aktywuje nowe wartości.

Subskrybuj zdarzenie aktualizacji

Aby aktywować funkcję ActivateValuesOnConfigUpdate w momencie wywołania zdarzenia, zasubskrybuj je. Zastąp metodę InitializeCommonDataAndStartGame() w obiekcie Assets/Hamster/Scripts/MainGame.cs tym:

   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ę ciągiem += ActivateValuesOnConfigUpdate;) subskrybuje moduł obsługi zdarzeń.

Anuluj subskrypcję w przypadku zniszczenia obiektu należącego do modułu obsługi

Aby zapobiec błędom odwołań o wartości null, obiekty z metodami subskrybującymi zdarzenia muszą anulować subskrypcję tej metody po ich zniszczeniu. Dodaj do Assets/Hamster/Scripts/MainGame.cs tę metodę:

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

Przetestuj nową funkcję

Aby sprawdzić działanie nowych funkcji, wypróbuj utworzoną aplikację. Opisana poniżej procedura wymaga odczytania dziennika 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 acceleration_tile_force.

2. Zmień wartość na „120” i naciśnij Zapisz.

3. Kliknij przycisk Opublikuj zmiany.

4. Sprawdź dziennik.
5. Jeśli zobaczysz komunikat dziennika zaczynający się od „Podczas słuchania wystąpił błąd”, przeczytaj je i spróbuj przeprowadzić debugowanie z wyświetlonym komunikatem o błędzie.
6. Jeśli widzisz dziennik, który zaczyna się od tekstu „Zaktualizowane klucze”, aplikacja otrzymała zmienione wartości.
7. Jeśli nie widzisz żadnego z tych elementów, przejrzyj pozostałe logi, a następnie ponownie przeczytaj instrukcje z sekcji Tworzenie modułu obsługi aktualizacji konfiguracji, a następnie jeszcze raz przetestuj logi, aby sprawdzić, czy coś jest nie tak.

Ostrzeżenie: nie spowoduje to pobrania nowej wartości warunkowej, jeśli zmienisz ocenę jego stanu (np. czy użytkownik ma ustawioną określoną właściwość użytkownika w Analytics lub czy należy do listy odbiorców Analytics). Na razie zachowaj wywołania FetchRemoteConfig (czyli FetchAndActivate) w Assets/Hamster/Scripts/States/MainMenu.cs i Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

12. Gratulacje!

Udało Ci się wykorzystać Zdalną konfigurację do zdalnego sterowania wartościami w grze, pobierając je w aplikacji i używając warunków do udostępniania różnych wariantów.

Omówione zagadnienia

• Ustawianie i pobieranie wartości Zdalnej konfiguracji
• Jak instrumentować kod Unity C#, aby wykorzystać pobrane wartości
• Jak przechowywać, instrumentować i zastępować złożone wartości/obiekty jako wartości JSON
• Jak używać warunków Zdalnej konfiguracji do obsługi różnych wariantów wartości

Dalsze kroki

Przeczytaj o priorytecie wartości parametru, aby lepiej zrozumieć, jakie wartości są pobierane przez wystąpienie aplikacji, gdy używa ona parametru o wielu wartościach (z powodu warunków lub lokalizacji).

Przejdź do następnego kroku ścieżki, w którym użyjesz tych wartości instrumentowanych do przeprowadzenia testów A/B różnych wariantów, aby lepiej zrozumieć ich wpływ na zachowania użytkowników.