Incorpora Firebase Remote Config en tu juego de Unity

1. Introducción

Puedes usar Firebase Remote Config para definir pares clave-valor, también conocidos como parámetros, en tu app y actualizar sus valores en la nube, lo que te permite modificar el aspecto y el comportamiento de la app sin distribuir una actualización.

Agregarás esta nueva funcionalidad a un juego de ejemplo, MechaHamster: Sube de nivel con Firebase Edition. Este juego de ejemplo es una versión nueva del clásico juego de Firebase MechaHamster que quita la mayoría de sus funciones integradas de Firebase, lo que te brinda la oportunidad de implementar nuevos usos de Firebase en su lugar.

Para asegurarte de que tu app se comporte según lo previsto, establecerás parámetros de configuración predeterminados para los valores en el código de muestra del juego, y estos valores se pueden anular con los valores que establezcas en Remote Config en Firebase console.

Qué aprenderás

  • Cómo establecer valores de Remote Config en la nube y recuperarlos
  • Cómo instrumentar tu código C# de Unity para usar automáticamente los valores recuperados
  • Cómo almacenar, instrumentar y anular objetos o valores compuestos como valores JSON
  • Cómo usar las condiciones de Remote Config para publicar diferentes variantes de valores para distintos grupos de usuarios

Requisitos

  • Unity 2019.1.0f1 o versiones posteriores con compatibilidad para la compilación de iOS o Android
  • Un dispositivo físico Android/iOS o un simulador/emulador para compilar y ejecutar el juego

2. Configura tu entorno de desarrollo

En las siguientes secciones, se describe cómo descargar el código de Level Up with Firebase, abrirlo en Unity y agregar un proyecto de Firebase. Este juego de ejemplo de Level Up with Firebase se usa en varios otros Codelabs de Firebase y Unity, por lo que es posible que ya hayas completado las tareas de esta sección. Si es así, puedes omitir estos pasos y continuar con Agrega los SDKs de Firebase para Unity para agregar Remote Config al código de ejemplo del juego.

Descarga el código

Clona el repositorio de GitHub de este codelab desde la línea de comandos:

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

También tienes la opción de descargar el repositorio como archivo ZIP si no tienes instalado git.

Abre Level Up with Firebase en el editor de Unity.

  1. Inicia Unity Hub y, en la pestaña Proyectos, haz clic en la flecha desplegable junto a Abrir.
  2. Haz clic en Agregar proyecto desde el disco.
  3. Navega al directorio que contiene el código y, luego, haz clic en Aceptar.
  4. Si se te solicita, selecciona una versión del editor de Unity para usar y tu plataforma de destino (Android o iOS).
  5. Haz clic en el nombre del proyecto, level-up-with-firebase, y se abrirá en el editor de Unity.
  6. Si el editor no lo abre automáticamente, abre MainGameScene en Assets > Hamster en la pestaña Project del editor de Unity.

Para obtener más información sobre cómo instalar y usar Unity, consulta Trabaja en Unity.

3. Agrega Firebase a tu proyecto de Unity

Crea un proyecto de Firebase

  1. Accede a la consola de Firebase con tu Cuenta de Google.
  2. Haz clic en el botón para crear un proyecto nuevo y, luego, ingresa un nombre (por ejemplo, LevelUpWithFirebase).
  3. Haz clic en Continuar.
  4. Si se te solicita, revisa y acepta las Condiciones de Firebase y, luego, haz clic en Continuar.
  5. (Opcional) Habilita la asistencia de IA en Firebase console (llamada "Gemini en Firebase").
  6. Para este codelab, necesitas Google Analytics para usar de forma óptima los productos de Firebase, así que mantén activado el botón de activación de la opción de Google Analytics. Sigue las instrucciones en pantalla para configurar Google Analytics.
  7. Haz clic en Crear proyecto, espera a que se aprovisione y, luego, haz clic en Continuar.

Registra tu app en Firebase

  1. Abre Firebase console y, en el centro de la página de descripción general del proyecto, haz clic en el ícono de Unity para iniciar el flujo de trabajo de configuración o, si ya agregaste una app a tu proyecto de Firebase, haz clic en Agregar app para mostrar las opciones de plataforma.
  2. Selecciona para registrar los objetivos de compilación de Apple (iOS) y Android.
  3. Ingresa el ID del proyecto de Unity específico de cada plataforma. Para este codelab, ingresa lo siguiente:
  4. De manera opcional, ingresa el sobrenombre específico de cada plataforma para tu proyecto de Unity.
  5. Haz clic en Registrar app y ve a la sección Descargar archivo de configuración.
  6. Repite el proceso para el destino de compilación que no usaste la primera vez.

Agrega archivos de configuración de Firebase

Después de hacer clic en Registrar app, se te pedirá que descargues dos archivos de configuración (uno para cada destino de compilación). Tu proyecto de Unity necesita los metadatos de Firebase en estos archivos para conectarse con Firebase.

  1. Descarga los dos archivos de configuración disponibles:
    • Para Apple (iOS): Descarga GoogleService-Info.plist.
    • Android: Descarga google-services.json.
  2. Abre la ventana Project de tu proyecto de Unity y, luego, transfiere ambos archivos de configuración a la carpeta Assets.
  3. Vuelve a Firebase console y, en el flujo de trabajo de configuración, haz clic en Siguiente y continúa con la sección Add Firebase SDKs for Unity.

Nota: Siempre puedes volver a descargar estos archivos más adelante. Para ello, abre la configuración general de tu proyecto, desplázate hacia abajo hasta la sección Tus apps y, luego, haz clic en el botón de descarga del archivo de configuración deseado.

Agrega los SDKs de Firebase para Unity

  1. Haz clic en Descargar el SDK de Firebase Unity en Firebase console.
  2. Descomprime el SDK en la ubicación que prefieras.
  3. En tu proyecto de Unity abierto, ve a Assets > Import Package > Custom Package.
  4. En el diálogo Import package, navega al directorio que contiene el SDK descomprimido, selecciona FirebaseAnalytics.unitypackage y, luego, haz clic en Open.
  5. En el diálogo Import Unity Package que aparece, haz clic en Import.
  6. Repite los pasos anteriores para importar los siguientes dos paquetes:
    • FirebaseRemoteConfig.unitypackage
    • FirebaseCrashlytics.unitypackage
      Crashlytics es una herramienta liviana para informar fallas en tiempo real que te ayuda a hacer un seguimiento de los problemas de estabilidad que afectan la calidad de tu app, a priorizarlos y a corregirlos. Si no lo usaste antes, considera completar la ruta de aprendizaje de Crashlytics para Unity.
  7. Vuelve a Firebase console y, en el flujo de trabajo de configuración, haz clic en Siguiente.

Para obtener más información sobre cómo agregar los SDKs de Firebase a proyectos de Unity, consulta Opciones de instalación adicionales de Unity.

4. Establece valores predeterminados de Remote Config y recupera valores nuevos

En este codelab, actualizarás los objetos que usan valores definidos en el código o que se serializan en el editor de Unity para que usen valores instrumentados con Remote Config. Configurarás valores predeterminados para cada parámetro con SetDefaultsAsync para que tu app se comporte según lo previsto antes de conectarse al backend de Remote Config. Tu app se mantendrá actualizada recuperando valores nuevos de Remote Config y activándolos para que se puedan usar en el código.

Para recuperar valores nuevos de Remote Config, ya hay varios métodos no implementados presentes en el archivo Assets/Hamster/Scripts/MainGame.cs que se deben completar.

  1. Agrega las siguientes instrucciones using a MainGame.cs:
    using Firebase.Crashlytics;
using Firebase.Extensions;
using Firebase.RemoteConfig;
    El módulo Firebase.Extensions contiene algunas extensiones para la API de Tasks de C# que ayudarán a simplificar la administración del proceso de inicialización con devoluciones de llamada.
  2. Reemplaza el método InitializeCommonDataAndStartGame() existente por el método InitializeFirebaseAndStartGame(), que aún no se implementó, para agregar la inicialización de Firebase a tu método MainGame.cs Start():
    void Start()
{
   Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
   InitializeFirebaseAndStartGame();
}
  3. En MainGame.cs, busca InitializeFirebaseAndStartGame(). Declara una variable de la app y anula la implementación del método de la siguiente manera:
    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. Si la inicialización de Firebase se realiza correctamente, se llama a SetRemoteConfigDefaults para establecer los valores predeterminados en la app. Reemplaza el método SetRemoteConfigDefaults no implementado por lo siguiente:
    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. Recupera y activa valores nuevos (según sea necesario)

Ahora debemos completar el método FetchRemoteConfig existente. Esto encadenará llamadas a los métodos de Remote Config FetchAsync (que recupera valores nuevos de Remote Config) y ActivateAsync (que activa esos valores obtenidos para que estén disponibles en el código) con un parámetro de devolución de llamada llamado onFetchAndActivateSuccessful.

El código de inicio que agregamos en el paso anterior llama a FetchRemoteConfig con InitializeCommonDataAndStartGame como su devolución de llamada para iniciar el juego al final de la secuencia. Puedes pasar devoluciones de llamada alternativas a FetchRemoteConfig para invocar la recuperación con diferentes resultados. Un ejemplo (que implementarás más adelante) es pasar un método que abre nuevos menús de la IU, que dependen de los valores de Remote Config. Esto hará que los menús se abran solo después de que se recuperen y activen esos valores.

  1. Pega el siguiente código en 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. A continuación, completa el método ActivateRetrievedRemoteConfigValues, que recibe una devolución de llamada pasada, onFetchAndActivateSuccessful. Cuando finalice la activación, se invocará la devolución de llamada especificada:
    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();
         });
   }
}

Cuando SetRemoteConfigDefaults llama a ActivateRetrievedRemoteConfigValues de forma descendente desde el contexto de inicialización, ActivateRetrievedRemoteConfigValues llama al punto de partida anterior, InitializeCommonDataAndStartGame, para iniciar el juego abriendo el menú principal.

6. Configura una estrategia de carga de Remote Config

Para recuperar y activar valores en otro momento durante el uso de la app, debes volver a llamar a estas funciones y, si algún objeto almacenó en caché los valores, se le debe notificar que realice una actualización. Para desarrollar una estrategia para volver a recuperar los valores de Remote Config, considera cuándo se necesitan los valores nuevos y cuándo iniciar la recuperación y activación de valores nuevos para evitar que cambien mientras se usan.

Según la implementación actual, los valores de Remote Config se recuperan y activan cuando se inicia la app. Las recuperaciones se pueden ocultar durante los cambios de menú y, al mismo tiempo, bloquear la interacción durante la transición. Además, suele ser el momento más pertinente para obtener valores nuevos, ya que un cambio en el estado del menú se puede usar para saber "hacia dónde" va el jugador y predecir que se usará un valor.

Al revisar el sistema de menús de Mechahamster, la forma más fácil de agregar actualizaciones de menú que bloquean la IU es llamarlo antes de que se reanude el menú principal (específicamente cuando se accede a él saliendo de otro menú) y pasar el método de visualización de la IU como la devolución de llamada de onFetchAndActivateSuccessful. Lo mismo se puede hacer con el menú Selección de nivel.

Con la carga inicial como parte del inicio de la app, el primero de estos controladores se encargará de cualquier navegación por el menú que pase por el menú principal, mientras que cualquier reingreso al menú de Selección de nivel también provocará una actualización. La entrada inicial al menú de selección de nivel no importa, ya que solo se puede acceder a él desde el menú principal y, por lo tanto, ya está cubierta.

Para habilitar esta opción en la app, completa los métodos pertinentes en los archivos del menú principal y de selección de nivel, que bloquearán la visualización de la IU hasta que se completen FetchAsync y ActivateAsync:

  1. Abre Assets/Hamster/Scripts/States/MainMenu.cs y reemplaza el método Resume existente por lo siguiente:
    public override void Resume(StateExitValue results) {
   CommonData.mainGame.SelectAndPlayMusic(CommonData.prefabs.menuMusic, true);
   CommonData.mainGame.FetchRemoteConfig(InitializeUI);
}
  2. Guarda el archivo.
  3. Abre Assets/Hamster/Scripts/States/BaseLevelSelect.cs y reemplaza el método Resume existente por lo siguiente:
    public override void Resume(StateExitValue results) {
   CommonData.mainGame.FetchRemoteConfig(ShowUI);
}
  4. Guarda el archivo.

7. Depura o valida los comportamientos de recuperación

En este punto, es beneficioso realizar una verificación de diagnóstico o validación. El siguiente procedimiento te permitirá probar manualmente tu app y cómo recupera y activa los valores de Remote Config.

La información se imprimirá como parte de los registros del simulador, el dispositivo o el editor. En iOS, puedes ver los registros del dispositivo y del simulador en Xcode. En Android, ejecuta adb logcat para ver los registros. Si ejecutas el código en Unity presionando Play en el editor, los registros aparecerán en la pestaña Console.

  1. Vuelve a compilar y ejecutar la app (en el editor, con un dispositivo o simulador).
  2. Después de que aparezca el menú principal del juego, revisa el registro de salida del juego, que debería contener los registros generados por Debug.Log en FetchRemoteConfig y ActivateRetrievedRemoteConfigValues. Deberían mostrar los mensajes "Fetching data…" y "Remote data loaded and ready". Ten en cuenta las marcas de tiempo al comienzo de estos mensajes.
  3. En el juego, presiona License.
  4. Presiona Aceptar.
  5. Espera a que aparezca el menú principal del juego.
  6. Revisa el registro de salida del juego, que debería ser similar a los del paso anterior, con nuevas marcas de tiempo (que coincidan con la hora establecida en el reloj del sistema en el que ejecutas el juego).
  7. En el juego, presiona Play.
  8. Presiona Comencemos.
  9. Navega la pelota hasta el objetivo con las flechas del teclado, lo que abrirá un menú de Nivel completado.
  10. Presiona Niveles.
  11. Espera a que se cargue el menú Level Select.
  12. Vuelve a revisar el registro de salida del juego. Debe coincidir con los mensajes de registro de los pasos anteriores, con marcas de tiempo más recientes (que coincidan con la hora establecida en el reloj del sistema en el que ejecutas el juego).

Si alguno de esos elementos no apareció en tu app, es posible que alguna parte del flujo de recuperación y activación (o tu dispositivo) esté configurada de forma incorrecta. Si no aparece el primer registro, es posible que el juego no se inicie. Revisa la consola del editor o los registros del dispositivo o emulador para ver advertencias y errores sobre tu proyecto o entorno, y luego investiga los problemas. Es posible que el problema sea tan simple como conectarse a Internet.

Si aparecen los registros iniciales de la carga del menú, pero no uno de los posteriores, investiga o vuelve a implementar los métodos Resume en Assets/Hamster/Scripts/States/MainMenu.cs y Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

8. Instrumenta tu código

Ahora que configuraste los valores de los parámetros integrados en la app en SetDefaultsAsync() y pusiste a disposición las versiones más actualizadas con FetchAsync() y ActivateAsync(), harás referencia a esos valores y los usarás en el código.

Después de configurar valores en el backend de Remote Config, recupéralos y actívalos (o haz ambas acciones a la vez) para que estén disponibles en tu app. Para usar estos valores, llama a GetValue(string key) y elige una clave de parámetro como argumento. Esto devuelve un ConfigValue, que tiene propiedades para acceder al valor como varios tipos admitidos: string, bool, long, double. En este proyecto y en la mayoría de los casos de uso de juegos, debes convertir los dos últimos tipos a los más idiomáticos int y float. Para asegurarte de que estas conversiones no causen problemas, verifica que los valores iniciales establecidos en Remote Config se encuentren dentro del rango válido de los tipos que usarás en el código de tu app.

  1. Importa Remote Config agregando using Firebase.RemoteConfig; en la parte superior de los siguientes archivos:
    • Assets/Hamster/Scripts/States/MainMenu.cs
    • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
  2. Reemplaza el método Start de AccelerationTile.cs:
    private void Start() {
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   Acceleration = (float)remoteConfig.GetValue(AccelerationTileForceKey).DoubleValue;
}
    Con este cambio, la cantidad de fuerza que imparte la tarjeta de aceleración se cambiará a una recibida de Remote Config.
  3. Edita el cuerpo del método InitializeUI de 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();
}
    Aquí, subtitleOverride se configura para cambiar el subtítulo en la pantalla del menú principal si todos sus campos en la nube se establecen como valores distintos de los valores predeterminados de su tipo.

9. Cómo establecer valores de parámetros de forma remota

Ahora que tu app está completamente instrumentada, puedes configurar parámetros y valores en el servidor de Remote Config. En este codelab, configuraremos esto con Firebase console.

  1. Abre el proyecto en Firebase console.
  2. Selecciona Remote Config en el menú para ver el panel de Remote Config.
  3. Para cada uno de los parámetros que definiste en tu app y que se enumeran en la siguiente tabla, haz clic en Agregar parámetro, pega el nombre del parámetro (clave), selecciona el Tipo de datos que se indica en la tabla, inhabilita Usar valor predeterminado en la app y pega el nuevo valor predeterminado:

    Nombre del parámetro (clave)

    Tipo de datos

    Valor predeterminado

    acceleration_tile_force

    Número

    100

    subtitle_override

    JSON

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

    Editor de parámetros de Remote Config con el campo\nacceleration_tile_force completado
  4. Haz clic en Guardar para guardar los cambios.
  5. Haz clic en Publicar para publicar la configuración nueva y hacer que los valores nuevos estén disponibles para tu juego.
  6. Vuelve a ejecutar la app después de configurar estos parámetros remotos y observa cómo anulan los valores predeterminados originales.Pantalla principal de Mechahamster con el menú Debug habilitado

10. Usa condiciones de Remote Config para publicar variantes

Es posible que desees adaptar la experiencia de la app al usuario según el idioma que hable, su ubicación, la hora del día o la plataforma que use. Las condiciones de Remote Config te permiten usar estos y otros atributos de forma individual o combinada para entregar diferentes valores (llamados variantes) al usuario.

Un uso común de las condiciones es cambiar el contenido entre las plataformas de iOS y Android. Sigue los pasos que se indican a continuación para implementar una condición que muestre un valor diferente para subtitle_override según la plataforma que se use.

  1. Abre la pestaña Remote Config de tu proyecto en Firebase console.
  2. Haz clic en el botón de edición de subtitle_override..
  3. En la esquina inferior izquierda, haz clic en Agregar nuevo.
  4. En el menú desplegable que aparece, coloca el cursor sobre Valor condicional y haz clic en Crear condición nueva.Editor de parámetros de Remote Config:\nOpción de valor condicional
  5. Cuando se te solicite, asigna el nombre "is iOS" a la condición si segmentas para iOS, o "is Android" si segmentas para Android. Si segmentas anuncios para ambos, simplemente elige uno aquí y úsalo para el resto del codelab.Cómo usar el diálogo Define a new condition para definir una condición específica para iOS
  6. En Se aplica si…, haz clic en el menú desplegable Seleccionar… y elige Plataforma. Luego, selecciona la plataforma adecuada.Usa el editor Define a new condition para seleccionar la plataforma de iOS
  7. Haz clic en Crear condición para crear la condición. Reaparece el diálogo Editar parámetro y ahora puedes establecer un valor:
    • Si segmentas tus anuncios para Android, establece el Valor en lo siguiente: 
      {"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
    • Si segmentas tus anuncios para iOS, establece el valor de la siguiente manera: 
      {"text":"Level Up iOS Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
  8. Haz clic en Guardar para guardar los cambios.
  9. Haz clic en Publicar para publicar la configuración nueva y hacer que los valores nuevos estén disponibles para tu juego.

Si vuelves a compilar y ejecutar el juego, deberías ver el subtítulo reemplazado por su variante específica para la plataforma.

11. Configura Remote Config para recibir actualizaciones en tiempo real

Remote Config ahora puede detectar y controlar actualizaciones de plantillas de Remote Config en tiempo real. Las apps pueden suscribirse a la nueva API de Remote Config en tiempo real para escuchar los cambios de configuración y los valores actualizados.

Cómo funciona

Para escuchar las actualizaciones, tu app debe implementar un método que se suscriba al evento OnConfigUpdateListener. Mientras haya suscritos uno o más objetos de escucha de actualización de la configuración, se recuperarán automáticamente las nuevas plantillas de Remote Config, se llamará a los controladores suscritos y se podrán usar para realizar la lógica en respuesta, como activar los valores nuevos y ponerlos a disposición del resto de la aplicación.

Implementa Remote Config en tiempo real

Para ilustrar cómo funciona esto en el juego, realiza los siguientes cambios en tu código.

Crea un controlador de actualización de la configuración

El primer paso para usar el evento Config Update es crear un método capaz de escucharlo. Coloca el siguiente método en 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.");
         });
   }

Este método imprimirá una lista de las claves actualizadas y un mensaje de éxito en el registro cuando active los valores nuevos.

Suscríbete al evento Update

Para activar ActivateValuesOnConfigUpdate cuando se llama al evento, suscríbete al evento. Reemplaza el método InitializeCommonDataAndStartGame() en Assets/Hamster/Scripts/MainGame.cs por lo siguiente:

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

La línea nueva (que termina con += ActivateValuesOnConfigUpdate;) suscribe el controlador de eventos al evento.

Anula la suscripción cuando se destruye el objeto propietario del controlador

Para evitar errores de referencia nula, los objetos con métodos suscritos a eventos deben anular la suscripción de ese método cuando se destruyen. Agrega el siguiente método a Assets/Hamster/Scripts/MainGame.cs:

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

Prueba la nueva funcionalidad

Para validar la nueva funcionalidad, prueba la app compilada. El siguiente procedimiento requiere que puedas leer el registro y depurar con un dispositivo real.

Cambia acceleration_tile_force y observa

Después de iniciar tu app, en la sección Remote Config de Firebase console, haz lo siguiente:

  1. Presiona el botón de edición junto a acceleration_tile_force.

dc602d4db54e50a4.png

  1. Cambia el valor a "120" y presiona Guardar.

fcbc1df848f88009.png

  1. Haz clic en el botón Publicar cambios.

3785c1e00e7a6359.png

  1. Inspecciona el registro.
  2. Si ves un mensaje de registro que comienza con "Error occurred while listening", lee el resto y trata de depurar con el mensaje de error que imprime.
  3. Si ves un registro que comienza con "Updated keys", significa que tu app recibió los valores modificados.
  4. Si no ves ninguno de estos, revisa el resto de los registros y, luego, vuelve a revisar las instrucciones de Cómo crear un controlador de actualización de la configuración, vuelve a realizar las pruebas y vuelve a verificar los registros para determinar si hay algún problema.

12. ¡Felicitaciones!

Usaste Remote Config para controlar los valores del juego de forma remota recuperándolos en tu app y usando condiciones para publicar diferentes variantes.

Temas abordados

  • Cómo establecer y recuperar valores de Remote Config
  • Cómo configurar tu código C# de Unity para usar los valores recuperados
  • Cómo almacenar, instrumentar y anular objetos o valores compuestos como valores JSON
  • Cómo usar las condiciones de Remote Config para publicar diferentes variantes de valores

Próximos pasos

Lee sobre la prioridad de los valores de los parámetros para comprender mejor la lógica de qué valores obtiene una instancia de la app cuando usa un parámetro con varios valores (debido a condiciones o localidad).