Instrumentuj swoją grę Unity za pomocą zdalnej konfiguracji Firebase

1. Wstęp

Za pomocą Firebase Remote Config możesz definiować pary klucz-wartość , zwane również parametrami, w swojej aplikacji i aktualizować ich wartości w chmurze, co pozwala modyfikować wygląd i zachowanie aplikacji bez rozpowszechniania aktualizacji aplikacji.

Tę nową funkcjonalność dodasz 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, dając ci szansę na wdrożenie nowych zastosowań Firebase w ich miejsce.

Aby mieć pewność, że aplikacja będzie działać zgodnie z oczekiwaniami, ustawisz 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ę dowiesz

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

Co będziesz potrzebował

  • Unity 2019.1.0f1 lub nowsza wersja z obsługą kompilacji na iOS i/lub Androida
  • Fizyczne urządzenie z systemem Android/iOS lub symulator/emulator do zbudowania i uruchomienia gry

2. Skonfiguruj środowisko programistyczne

W poniższych sekcjach opisano, jak pobrać kod Level Up z Firebase , otworzyć go w Unity i dodać projekt Firebase. Ta przykładowa gra Level Up with Firebase jest używana w kilku innych laboratoriach programowania Firebase + Unity, więc zadania opisane w tej sekcji mogły już zostać ukończone. Jeśli tak, możesz pominąć te kroki i przejść do sekcji Dodaj pakiety SDK Firebase dla Unity, aby dodać zdalną konfigurację do przykładowego kodu gry.

Pobierz kod

Sklonuj repozytorium GitHub tego laboratorium kodowego z wiersza poleceń:

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

Alternatywnie, jeśli nie masz zainstalowanego gita, możesz pobrać repozytorium jako plik ZIP .

Otwórz Level Up w Firebase w edytorze Unity

  1. Uruchom Unity Hub i na karcie Projekty kliknij strzałkę rozwijaną obok opcji Otwórz .
  2. Kliknij Dodaj projekt z dysku .
  3. Przejdź do katalogu zawierającego kod, a następnie kliknij OK .
  4. Jeśli zostanie wyświetlony monit, wybierz wersję edytora Unity, której chcesz używać, oraz platformę docelową (Android lub iOS).
  5. Kliknij nazwę projektu, poziom-up-with-firebase , a projekt otworzy się w edytorze Unity.
  6. Jeśli Twój edytor nie otworzy go automatycznie, otwórz MainGameScene w Zasoby > Hamster w zakładce Projekt w Edytorze Unity.

Aby uzyskać więcej informacji na temat instalowania i używania Unity, zobacz Praca w Unity .

3. Dodaj Firebase do swojego projektu Unity

Utwórz projekt Firebase

  1. W konsoli Firebase kliknij Dodaj projekt .
  2. Aby utworzyć nowy projekt, wprowadź żądaną nazwę projektu.
    Spowoduje to również ustawienie identyfikatora projektu (wyświetlanego pod nazwą projektu) na wartość opartą na nazwie projektu. Opcjonalnie możesz kliknąć ikonę edycji na identyfikatorze projektu, aby go jeszcze bardziej dostosować.
  3. Jeśli pojawi się monit, przejrzyj i zaakceptuj warunki Firebase .
  4. Kliknij Kontynuuj .
  5. Wybierz opcję Włącz Google Analytics dla tego projektu , a następnie kliknij Kontynuuj .
  6. Wybierz istniejące konto Google Analytics, którego chcesz użyć, lub wybierz opcję Utwórz nowe konto , aby utworzyć nowe konto.
  7. Kliknij opcję Utwórz projekt .
  8. Po utworzeniu projektu kliknij Kontynuuj .

Zarejestruj swoją aplikację w Firebase

  1. Otwórz konsolę Firebase i na środku strony przeglądu projektu kliknij ikonę Unity, aby uruchomić proces konfiguracji lub, jeśli dodałeś już aplikację do projektu Firebase, kliknij Dodaj aplikację , aby wyświetlić opcje platformy.
  2. Wybierz, aby zarejestrować elementy docelowe kompilacji Apple (iOS) i Androida.
  3. Wprowadź identyfikatory specyficzne dla platformy projektu Unity. W przypadku tego ćwiczenia z kodowania wprowadź następujące dane:
  4. Opcjonalnie wprowadź pseudonimy specyficzne dla platformy projektu Unity.
  5. Kliknij opcję Zarejestruj aplikację i przejdź do sekcji Pobierz plik konfiguracyjny .
  6. Powtórz ten proces dla dowolnego celu kompilacji, którego nie wykonałeś za pierwszym razem.

Dodaj pliki konfiguracyjne Firebase

Po kliknięciu opcji Zarejestruj aplikację zostanie wyświetlony monit o pobranie dwóch plików konfiguracyjnych (po jednym pliku konfiguracyjnym dla każdego celu kompilacji). Twój projekt Unity potrzebuje metadanych Firebase w tych plikach, aby połączyć się z Firebase.

  1. Pobierz oba dostępne pliki konfiguracyjne:
    • Dla Apple (iOS) : pobierz plik GoogleService-Info.plist .
    • Dla Androida : pobierz plik google-services.json .
  2. Otwórz okno Projekt swojego projektu Unity, a następnie przenieś oba pliki konfiguracyjne do folderu Zasoby .
  3. Wróć do konsoli Firebase, w procesie konfiguracji kliknij Dalej i przejdź do Dodaj zestawy SDK Firebase dla Unity.

Uwaga: zawsze możesz ponownie pobrać te pliki później, otwierając ogólne ustawienia projektu, przewijając w dół do sekcji Twoje aplikacje , a następnie klikając przycisk pobierania odpowiadający żądanemu plikowi konfiguracyjnemu.

Dodaj pakiety SDK Firebase dla Unity

  1. Kliknij opcję Pobierz pakiet SDK Firebase Unity w konsoli Firebase.
  2. Rozpakuj SDK w dogodnym miejscu.
  3. W otwartym projekcie Unity przejdź do opcji Zasoby > Importuj pakiet > Pakiet niestandardowy .
  4. W oknie dialogowym Importuj pakiet przejdź do katalogu zawierającego rozpakowany pakiet SDK, wybierz FirebaseAnalytics.unitypackage i kliknij Otwórz .
  5. W wyświetlonym oknie dialogowym Importuj pakiet Unity kliknij opcję Importuj .
  6. Powtórz poprzednie kroki, aby zaimportować następujące dwa pakiety:
    • FirebaseRemoteConfig.unitypackage
    • FirebaseCrashlytics.unitypackage
      Crashlytics to lekkie narzędzie do raportowania awarii działające w czasie rzeczywistym, które pomaga śledzić, ustalać priorytety i naprawiać problemy ze stabilnością, które pogarszają jakość aplikacji. Jeśli jeszcze z niego nie korzystałeś, rozważ ukończenie ścieżki edukacyjnej Crashlytics dla Unity .
  7. Wróć do konsoli Firebase i w procesie konfiguracji kliknij Dalej .

Aby uzyskać więcej informacji na temat dodawania zestawów SDK Firebase do projektów Unity, zobacz Dodatkowe opcje instalacji Unity .

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

W tym laboratorium z programowania zaktualizujesz obiekty, które używają wartości zdefiniowanych w kodzie lub są serializowane w edytorze Unity, aby używać wartości instrumentowanych za pomocą zdalnej konfiguracji. Wartości domyślne dla każdego parametru skonfigurujesz przy użyciu SetDefaultsAsync , aby aplikacja zachowywała się zgodnie z oczekiwaniami, zanim połączy się z zapleczem zdalnej konfiguracji. Twoja aplikacja będzie aktualna, pobierając nowe wartości z Remote Config i aktywując je, aby można było ich używać w kodzie.

Aby pobrać nowe wartości z Remote Config, w pliku Assets/Hamster/Scripts/MainGame.cs znajduje się wiele niezaimplementowanych metod, które należy wypełnić.

  1. Dodaj następujące instrukcje using do pliku MainGame.cs :
    using Firebase.Crashlytics;
using Firebase.Extensions;
using Firebase.RemoteConfig;
    Moduł Firebase.Extensions zawiera pewne rozszerzenia interfejsu API zadań języka C# , które pomogą uprościć zarządzanie procesem inicjalizacji za pomocą wywołań zwrotnych.
  2. Dodaj inicjalizację Firebase do metody MainGame.cs Start() , zastępując istniejącą metodę IndividualizeCommonDataAndStartGame() obecnie niezaimplementowaną metodą InitializeFirebaseAndStartGame() :
    void Start()
{
   Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
   InitializeFirebaseAndStartGame();
}
  3. W MainGame.cs znajdź opcję InitializeFirebaseAndStartGame() . Zadeklaruj zmienną aplikacji i zastąp implementację metody w następujący 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. Inicjalizacja Firebase wywołuje SetRemoteConfigDefaults jeśli się powiedzie, aby ustawić wartości domyślne w aplikacji. Zamień niezaimplementowaną metodę SetRemoteConfigDefaults na następującą:
    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)

Musimy teraz dokończyć istniejącą metodę FetchRemoteConfig . Spowoduje to połączenie wywołań metod Remote Config FetchAsync (która pobiera nowe wartości z Remote Config) i ActivateAsync (która aktywuje uzyskane wartości, aby udostępnić je w kodzie) przy użyciu parametru wywołania zwrotnego o nazwie onFetchAndActivateSuccessful .

Kod startowy, który dodaliśmy w poprzednim kroku, wywołuje FetchRemoteConfig z funkcją zwrotną InitializeCommonDataAndStartGame , aby rozpocząć grę 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 zaimplementujesz później) jest przekazanie metody otwierającej nowe menu interfejsu użytkownika, które zależą od wartości Remote Config. Spowoduje to otwarcie menu dopiero po pobraniu i aktywowaniu tych wartości.

  1. Wklej poniższy kod do 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 odbiera 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();
         });
   }
}

Po wywołaniu przez SetRemoteConfigDefaults z kontekstu inicjalizacji, ActivateRetrievedRemoteConfigValues ​​wywołuje poprzedni punkt początkowy, InitializeCommonDataAndStartGame , aby rozpocząć grę, otwierając menu główne.

6. Skonfiguruj strategię ładowania zdalnej konfiguracji

Aby pobrać i aktywować wartości w innym momencie korzystania z aplikacji, należy ponownie wywołać te funkcje, a jeśli jakieś obiekty zapisały wartości w pamięci podręcznej, należy je powiadomić o konieczności przeprowadzenia aktualizacji. Aby opracować strategię ponownego pobierania wartości Remote Config, należy rozważyć, kiedy potrzebne są nowe wartości oraz kiedy zainicjować pobieranie i aktywację nowych wartości, aby uniknąć ich zmiany w trakcie użytkowania.

Zgodnie z obecnie zaimplementowanymi wartościami Zdalnej konfiguracji są pobierane i aktywowane podczas uruchamiania aplikacji. Pobrania można ukryć podczas zmian menu, blokując jednocześnie interakcję podczas przejścia. Ponadto jest to często najwłaściwszy moment na uzyskanie nowych wartości, ponieważ zmianę stanu menu można często wykorzystać, aby dowiedzieć się, „dokąd” zmierza gracz i przewidzieć, że dana wartość zostanie użyta.

Przeglądając system menu Mechahamstera, najłatwiejszym sposobem dodania odświeżeń menu blokowania interfejsu użytkownika jest wywołanie go przed wznowieniem menu głównego (szczególnie, gdy dostęp do niego jest uzyskiwany poprzez wycofanie się z innego menu) i przekazanie metody wyświetlania interfejsu użytkownika jako wywołania zwrotnego onFetchAndActivateSuccessful . To samo można zrobić z menu Level Select .

Przy początkowym ładowaniu w ramach uruchamiania aplikacji, jakakolwiek nawigacja po menu głównym będzie obsługiwana przez pierwsze z nich, a każde ponowne wejście do menu Level Select również spowoduje odświeżenie. Początkowe wejście do menu wyboru poziomu nie ma znaczenia, ponieważ można uzyskać do niego dostęp tylko z menu głównego, a zatem jest już omówione.

Aby włączyć tę opcję w aplikacji, wykonaj odpowiednie metody w menu głównym i wybierz pliki poziomu, co zablokuje wyświetlanie interfejsu użytkownika do czasu zakończenia operacji FetchAsync i ActivateAsync :

  1. Otwórz Assets/Hamster/Scripts/States/MainMenu.cs i zastąp istniejącą metodę Resume następującą:
    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 i zastąp istniejącą metodę Resume następującą metodą:
    public override void Resume(StateExitValue results) {
   CommonData.mainGame.FetchRemoteConfig(ShowUI);
}
  4. Zapisz plik.

7. Debuguj/weryfikuj zachowania pobierania

Na tym etapie korzystne jest wykonanie kontroli diagnostycznej/walidacyjnej. Poniższa procedura umożliwi ręczne przetestowanie aplikacji oraz sposobu/czy pobierania i aktywowania wartości zdalnej konfiguracji.

Informacje zostaną wydrukowane jako część dzienników symulatora, urządzenia lub edytora. W przypadku systemu iOS możesz przeglądać dzienniki urządzeń i symulatorów w Xcode. W przypadku Androida wyświetl dzienniki, uruchamiając adb logcat . Jeśli uruchomisz kod w Unity, naciskając przycisk Odtwórz w edytorze, dzienniki pojawią się na karcie Konsola.

  1. Odbuduj i uruchom aplikację (w Edytorze, używając urządzenia lub symulatora).
  2. Po wyświetleniu głównego menu gry przejrzyj dane wyjściowe dziennika gry, które powinny zawierać dzienniki wygenerowane przez Debug.Log w FetchRemoteConfig i ActivateRetrievedRemoteConfigValues ​​. Powinny one zawierać komunikaty „Pobieranie danych…” i „Zdalne załadowanie i gotowość danych”. Zwróć uwagę na znaczniki czasu znajdujące się 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, które powinny być podobne do tych z poprzedniego kroku, z nowymi znacznikami czasu (odpowiadającymi czasowi ustawionemu na zegarze systemowym, w którym uruchamiasz grę).
  7. W grze naciśnij przycisk Graj .
  8. Naciśnij Let's Roll .
  9. Poprowadź piłkę do celu za pomocą strzałek na klawiaturze, co otworzy menu Poziom ukończony.
  10. Naciśnij Poziomy .
  11. Poczekaj, aż załaduje się menu wyboru poziomu .
  12. Przejrzyj ponownie dane wyjściowe dziennika gry. Powinien pasować do komunikatów dziennika z poprzednich kroków, z nowszymi znacznikami czasu (odpowiadającymi czasowi ustawionemu na zegarze systemowym, na którym uruchamiana jest gra).

Jeśli którykolwiek z nich nie pojawił się w Twojej aplikacji, część procesu pobierania i aktywacji (lub Twojego urządzenia) może być błędnie skonfigurowana. Jeśli pierwszy dziennik nie pojawi się, istnieje ryzyko, ż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/środowiska i zbadaj je — problem może być tak prosty, jak połączenie z Internetem.

Jeśli pojawią się początkowe dzienniki ładowania menu, ale jeden z kolejnych nie, sprawdź/zaimplementuj ponownie metody Resume w Assets/Hamster/Scripts/States/MainMenu.cs i Assets/Hamster/Scripts/States/BaseLevelSelect.cs .

8. Instrumentuj swój kod

Teraz, gdy skonfigurowałeś wartości parametrów w aplikacji w SetDefaultsAsync() i udostępniłeś najbardziej aktualne wersje za pomocą FetchAsync() i ActivateAsync() , będziesz odwoływać się do tych wartości i używać ich w kodzie.

Po ustawieniu wartości w zapleczu Zdalnej konfiguracji, pobraniu ich i aktywowaniu ( lub wykonaniu obu czynności naraz ) te wartości będą dostępne dla Twojej aplikacji. Aby użyć tych wartości, wywołaj GetValue(string key ) i wybierz klucz parametru jako argument. Zwraca to ConfigValue , która 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 większości przypadków użycia w grach musisz rzucić dwa ostatnie typy na bardziej idiomatyczne int i float . Aby mieć pewność, że te konwersje nie spowodują problemów, upewnij się, że 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 górę następujących plików:
    • Assets/Hamster/Scripts/States/MainMenu.cs
    • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
  2. Zastąp metodę Start pliku AccelerationTile.cs :
    private void Start() {
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   Acceleration = (float)remoteConfig.GetValue(AccelerationTileForceKey).DoubleValue;
}
    Dzięki tej zmianie wielkość siły wywieranej przez płytkę przyspieszenia zostanie zmieniona na siłę otrzymaną z zdalnej konfiguracji.
  3. Edytuj treść metody InitializeUI 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 zmieniać napisy na ekranie menu głównego, jeśli wszystkie jego pola w chmurze są ustawione na wartości inne niż wartości domyślne ich typu .

9. Zdalnie ustaw wartości parametrów

Teraz, gdy Twoja aplikacja jest w pełni oprzyrządowana, możesz skonfigurować parametry i wartości na serwerze zdalnej konfiguracji. W tych ćwiczeniach z programowania skonfigurujemy to za pomocą konsoli Firebase.

  1. W konsoli Firebase otwórz swój projekt.
  2. Wybierz opcję Zdalna konfiguracja z menu, aby wyświetlić pulpit nawigacyjny Zdalnej konfiguracji.
  3. Dla każdego parametru zdefiniowanego w aplikacji i wymienionego w poniższej tabeli kliknij Dodaj parametr , wklej nazwę parametru (klucz), wybierz Typ danych wymieniony w tabeli, wyłącz opcję Użyj ustawień domyślnych w aplikacji i wklej w polu nowa wartość domyślna:

    Nazwa parametru (klucz)

    Typ danych

    Domyślna wartość

    przyspieszenie_tile_force

    Numer

    100

    nadpisanie_podtytułu

    JSON

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

    Remote Config Parameter editor with\nacceleration_tile_force populated
  4. Kliknij Zapisz , aby zapisać zmiany.
  5. Kliknij Publikuj , aby opublikować nową konfigurację i udostępnić nowe wartości swojej grze.
  6. Uruchom aplikację ponownie po ustawieniu tych parametrów zdalnych i obserwuj, jak zastępują one oryginalne ustawienia domyślne. Mechahamster main screen with Debug\nMenu enabled

10. Użyj warunków zdalnej konfiguracji, aby udostępnić warianty

Możesz dostosować aplikację do potrzeb 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 indywidualnie lub w połączeniu w celu udostępniania użytkownikowi różnych wartości (zwanych wariantami).

Jednym z powszechnych zastosowań warunków jest zmiana zawartości między platformami iOS i Android. Wykonaj poniższe kroki, aby zaimplementować warunek, który będzie miał inną wartość dla subtitle_override w zależności od używanej platformy.

  1. Otwórz kartę Zdalna konfiguracja swojego projektu w konsoli Firebase .
  2. Kliknij przycisk edycji subtitle_override.
  3. W lewym dolnym rogu kliknij Dodaj nowy .
  4. W wyświetlonym menu najedź kursorem na Wartość warunkowa i kliknij Utwórz nowy warunek. Remote Config parameter editor:\nConditional value option
  5. Po wyświetleniu monitu nazwij warunek „to iOS”, jeśli kierujesz reklamy na iOS, lub „to Android”, jeśli kierujesz reklamy na Androida. Jeśli celujesz w obydwa, po prostu wybierz tutaj jeden i użyj go w pozostałej części zajęć z programowania. Using the Define a new condition\ndialog to define an iOS-specific condition
  6. W sekcji Stosuje się, jeśli... kliknij listę rozwijaną Wybierz... i wybierz Platforma . Następnie wybierz odpowiednią platformę. Using the Define a new condition\neditor to select the iOS platform
  7. Kliknij opcję Utwórz warunek , aby utworzyć warunek. Pojawi się ponownie okno dialogowe Edytuj parametr, w którym możesz teraz ustawić wartość:
    • Jeśli kierujesz reklamy na Androida, 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 Publikuj , aby opublikować nową konfigurację i udostępnić nowe wartości swojej grze.

Jeśli ponownie zbudujesz i uruchomisz grę, powinieneś zobaczyć podtytuł gry zastąpiony wersją specyficzną dla platformy.

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

Aplikacja Remote Config może teraz nasłuchiwać i obsługiwać aktualizacje szablonów Remote Config w czasie rzeczywistym . Aplikacje mogą subskrybować nowy interfejs API zdalnej konfiguracji działający 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ę subskrybującą zdarzenie OnConfigUpdateListener . Gdy subskrybowany jest jeden lub więcej odbiorników aktualizacji konfiguracji, nowe szablony zdalnej konfiguracji będą pobierane automatycznie, wywoływane są subskrybowane procedury obsługi, które w odpowiedzi mogą być używane do wykonywania logiki, np. aktywowania nowych wartości i udostępniania ich pozostałej części aplikacji.

Wdrażaj zdalną konfigurację w czasie rzeczywistym

Aby zilustrować, jak to działa w grze, wprowadź następujące zmiany w swoim kodzie.

Utwórz procedurę obsługi aktualizacji konfiguracji

Pierwszym krokiem do wykorzystania zdarzenia Config Update jest utworzenie metody zdolnej do jego nasłuchiwania. Umieść następującą metodę w 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.");
         });
   }

Ta metoda wydrukuje listę zaktualizowanych kluczy i komunikat o powodzeniu w dzienniku, gdy aktywuje nowe wartości.

Zapisz się na wydarzenie Aktualizacja

Aby aktywować ActivateValuesOnConfigUpdate w momencie wywołania zdarzenia, zapisz je do zdarzenia. Zastąp metodę InitializeCommonDataAndStartGame() w Assets/Hamster/Scripts/MainGame.cs następującym 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());
   }

Nowa linia (kończąca się += ActivateValuesOnConfigUpdate; ) subskrybuje procedurę obsługi zdarzenia.

Zrezygnuj z subskrypcji, gdy przedmiot będący własnością handlera zostanie zniszczony

Aby zapobiec błędom zerowych odwołań, obiekty z metodami subskrybowanymi do zdarzeń muszą anulować subskrypcję tej metody w przypadku ich zniszczenia. Dodaj następującą metodę do Assets/Hamster/Scripts/MainGame.cs :

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

Przetestuj nową funkcjonalność

Aby sprawdzić nową funkcjonalność, wypróbuj zbudowaną aplikację. Poniższa procedura wymaga możliwości odczytania dziennika i debugowania przy użyciu prawdziwego urządzenia .

Zmień acceleration_tile_force i obserwuj

Po uruchomieniu aplikacji w sekcji Zdalna konfiguracja konsoli Firebase:

  1. Naciśnij przycisk edycji obok acceleration_tile_force .

dc602d4db54e50a4.png

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

fcbc1df848f88009.png

  1. Kliknij przycisk Opublikuj zmiany .

3785c1e00e7a6359.png

  1. Sprawdź dziennik.
  2. Jeśli zobaczysz komunikat dziennika zaczynający się od „Wystąpił błąd podczas nasłuchiwania”, przeczytaj resztę i spróbuj debugować, korzystając z wyświetlanego komunikatu o błędzie.
  3. Jeśli zobaczysz dziennik rozpoczynający się od „Zaktualizowane klucze”, oznacza to, że Twoja aplikacja otrzymała zmienione wartości.
  4. Jeśli nie widzisz żadnego z nich, przejrzyj pozostałe dzienniki, a następnie ponownie przejrzyj instrukcje z sekcji Utwórz program obsługi aktualizacji konfiguracji , przetestuj ponownie i ponownie sprawdź dzienniki, aby określić, czy coś jest nie tak.

12. Gratulacje!

Używałeś Remote Config do zdalnego kontrolowania wartości w grze, pobierając je do swojej aplikacji i używając warunków do obsługi różnych wariantów!

Co omówiliśmy

  • Jak ustawić i pobrać wartości Remote Config
  • Jak instrumentować kod Unity C#, aby używać pobranych wartości
  • Jak przechowywać, instrumentować i zastępować wartości/obiekty złożone jako wartości JSON
  • Jak używać warunków zdalnej konfiguracji do obsługi różnych wariantów wartości

Następne kroki

Przeczytaj o priorytecie wartości parametru , aby lepiej zrozumieć logikę uzyskiwania wartości przez instancję aplikacji, gdy używa parametru z wieloma wartościami (ze względu na warunki lub lokalizację).