Instrumenta tu juego de Unity con Firebase Remote Config

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 muestra, MechaHamster: Sube de nivel con Firebase Edition. Este juego de muestra 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 da la oportunidad de implementar nuevos usos de Firebase en su lugar.

Para asegurarte de que la app se comporte según lo previsto, establece parámetros de configuración predeterminados para los valores del código de juego de muestra, que se pueden anular con valores que configuraste 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 valores o objetos compuestos como valores JSON
• Cómo usar condiciones de Remote Config para publicar diferentes variantes de valores a distintos grupos de usuarios

Requisitos

• Unity 2019.1.0f1 o una versión posterior compatible con compilaciones de iOS o Android
• Un dispositivo físico Android/iOS o un simulador o 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 para subir de nivel con Firebase, abrirlo en Unity y agregar un proyecto de Firebase. Este juego de muestra de Sube de nivel con Firebase se usa en muchos 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 proceder a Agregar los SDK de Firebase para Unity para agregar Remote Config al código de juego de muestra.

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

Como alternativa, si no tienes Git instalado, puedes descargar el repositorio como archivo ZIP.

Abre Sube de nivel con Firebase en el editor de Unity

1. Inicia Unity Hub y, en la pestaña Projects, haz clic en la flecha desplegable junto a Open.
2. Haz clic en Agregar proyecto desde el disco.
3. Navega al directorio que contiene el código y, luego, haz clic en OK.
4. Si se te solicita, selecciona una versión del editor de Unity y tu plataforma de segmentación (Android o iOS).
5. Haz clic en el nombre del proyecto, level-up-with-firebase, y el proyecto 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 de Unity Editor.
   

Para obtener más información sobre la instalación y el uso de Unity, consulta Cómo trabajar en Unity.

3. Agrega Firebase a tu proyecto de Unity

Crea un proyecto de Firebase

1. En Firebase console, haz clic en Agregar proyecto.
2. Para crear un proyecto nuevo, ingresa el nombre que quieras.
   Con esto, también se configurará el ID del proyecto (que se muestra debajo del nombre del proyecto) según ese nombre. De manera opcional, puedes hacer clic en el ícono de edición en el ID del proyecto para personalizarlo aún más.
3. Si se te solicita, revisa y acepta las Condiciones de Firebase.
4. Haz clic en Continuar.
5. Selecciona la opción Habilitar Google Analytics para este proyecto y, luego, haz clic en Continuar.
6. Selecciona una cuenta de Google Analytics existente para usar o elige Crear una cuenta nueva para crear una nueva.
7. Haz clic en Crear proyecto.
8. Cuando se haya creado el proyecto, 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 que se muestren las opciones de la plataforma.
2. Selecciona esta opción para registrar los destinos de compilación de Apple (iOS) y Android.
3. Ingresa los IDs específicos de la plataforma del proyecto de Unity. En este codelab, ingresa lo siguiente:
   • En Apple (iOS): Ingresa com.google.firebase.level-up en el campo ID del paquete de iOS.
   • En Android: Ingresa com.google.firebase.level_up en el campo Nombre del paquete de Android.
4. De manera opcional, ingresa el sobrenombre específico de la 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 hayas usado 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:
   • En Apple (iOS): Descarga GoogleService-Info.plist.
   • Para Android: Descarga google-services.json.
2. Abre la ventana Project de tu proyecto de Unity y transfiere ambos archivos de configuración a la carpeta Assets.

   Importante: Incluso si planeas compilar solo para iOS o Android, debes descargar ambos archivos y agregarlos a tu proyecto.

3. Vuelve a Firebase console, en el flujo de trabajo de configuración, haz clic en Siguiente y continúa con la sección Agregar los SDK de Firebase para Unity.

Nota: Puedes volver a descargar estos archivos en cualquier momento. Para ello, abre la configuración general del 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 SDK de Firebase para Unity

1. Haz clic en Descargar el SDK de Firebase Unity en Firebase console.

   Nota: Este SDK podría tardar un poco en descargarse. Obtén una vista previa de los próximos pasos o tómate un breve descanso.

2. Descomprime el SDK en el lugar que prefieras.
3. Abre el proyecto de Unity, 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 Abrir.
5. En el diálogo Import Unity Package que aparece, haz clic en Import.
6. Repite los pasos anteriores para importar los dos paquetes siguientes:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics es una herramienta ligera 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 la has usado antes, te recomendamos 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.

Si quieres obtener más información para agregar los SDK de Firebase a proyectos de Unity, consulta Opciones adicionales de instalación de Unity.

4. Establece la configuración predeterminada de Remote Config y recupera valores nuevos

En este codelab, actualizarás objetos que usen valores definidos en el código o que se serializan en el editor de Unity para usar valores instrumentados con Remote Config. Configurarás los valores predeterminados de cada parámetro con SetDefaultsAsync para que la app se comporte según lo previsto antes de que se conecte 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, hay varios métodos sin implementar que ya se encuentran en el archivo Assets/Hamster/Scripts/MainGame.cs y que deben completarse.

1. Agrega las siguientes sentencias using a MainGame.cs:

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

   El módulo Firebase.Extensions contiene algunas extensiones de la API de C# Tasks que ayudarán a simplificar la administración del proceso de inicialización con devoluciones de llamada.
2. Para agregar la inicialización de Firebase a tu método Start() de MainGame.cs, reemplaza el método InitializeCommonDataAndStartGame() existente por el método que no está implementado actualmente, InitializeFirebaseAndStartGame():

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

3. En MainGame.cs, busca InitializeFirebaseAndStartGame(). Declara una variable de app y reemplaza 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. La inicialización de Firebase llama a SetRemoteConfigDefaults si se ejecuta de forma correcta para establecer valores predeterminados en la app. Reemplaza el método SetRemoteConfigDefaults sin implementar 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 nuevos valores (según sea necesario)

Ahora debemos completar el método FetchRemoteConfig existente. Esto encadenará llamadas a los métodos FetchAsync de Remote Config (que recupera valores nuevos desde Remote Config) y ActivateAsync (que activa esos valores obtenidos para que estén disponibles en el código) mediante 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 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 IU, que dependen de los valores de Remote Config. Esto hará que los menús se abran solo después de que esos valores se hayan recuperado y activado.

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

   Nota: El valor cacheExpiration que se pasa a FetchAsync define por cuánto tiempo se deben almacenar en caché los valores recuperados anteriormente. Durante el desarrollo, puedes establecer esto en System.TimeSpan.Zero, como se muestra más arriba. Esto garantiza que la app siempre refleje los valores más actualizados. Sin embargo, cuando se lance a producción, deberás configurar cacheExpiration en un valor más alto para evitar la regulación. El período predeterminado (cuando se llama a FetchAsync sin parámetros) es de 12 horas.

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 lo llama de manera 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 debe notificar a este para que realice una actualización. Para desarrollar una estrategia para volver a recuperar 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 están en uso.

Como se implementa actualmente, los valores de Remote Config se recuperan y activan cuando se inicia la app. Las recuperaciones se pueden ocultar durante los cambios en el menú y, al mismo tiempo, bloquear la interacción durante la transición. Además, este suele ser el momento más relevante para obtener valores nuevos, ya que un cambio en el estado del menú a menudo se puede usar para saber hacia “dónde” se dirige el jugador y predecir que se usará un valor.

Si observas el sistema de menú de Mechahamster, la manera más fácil de agregar actualizaciones del menú de bloqueo de la IU es llamarlo antes de que se reanude el menú principal (específicamente cuando se accede a él desde otro menú) y pasar el método de visualización de la IU como la devolución de llamada onFetchAndActivateSuccessful. Lo mismo puede hacerse con el menú Level Select.

Con la carga inicial como parte del inicio de la app, cualquier navegación por el menú principal será controlada por el primero, mientras que cualquier regreso al menú Level Select también provocará una actualización. La entrada inicial al menú de selección de nivel no es importante, ya que solo se puede acceder desde el menú principal y, por lo tanto, ya está cubierto.

Para habilitar esto en la app, completa los métodos correspondientes en el menú principal y selecciona los archivos 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.

Nota: Si bien este codelab proporciona una forma de cargar valores de Remote Config cuando el menú principal y las vistas de selección de niveles están activos, hay otras estrategias de carga disponibles. Consulta Estrategias de carga de Firebase Remote Config para obtener más información.

7. Depurar/validar comportamientos de recuperación

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

La información se imprimirá como parte de los registros del simulador, dispositivo o 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 ejecuta la app (en el editor, mediante un dispositivo o simulador).
2. Después de que aparezca el Menú principal del juego, revisa el resultado del registro del juego, que debe contener los registros generados por Debug.Log en FetchRemoteConfig y ActivateRetrievedRemoteConfigValues. Deberían aparecer los mensajes "Recuperando datos..." y "Datos remotos cargados y listos". Toma nota de las marcas de tiempo al comienzo de estos mensajes.
3. En el juego, presiona Licencia.
4. Presiona Aceptar.
5. Espera a que aparezca el Menú principal del juego.
6. Revisa el resultado del registro del juego, que debería ser similar a los del paso anterior, con marcas de tiempo nuevas (que coincidan con la hora establecida en el reloj del sistema donde ejecutas el juego).
7. En el juego, presiona Jugar.
8. Presiona Let's Roll.
9. Mueve la pelota hasta la meta 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 resultado del registro de tu juego. Debería coincidir con los mensajes de registro de los pasos anteriores con marcas de tiempo más nuevas (que coincidan con la hora establecida en el reloj del sistema donde ejecutas el juego).

Si alguno de estos no aparece en tu app, es posible que parte del flujo de recuperación y activación (o tu dispositivo) esté mal configurado. 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 detectar advertencias y errores sobre tu proyecto o entorno, y analizarlos. El problema puede ser tan simple como conectarte a Internet.

Si aparecen los registros iniciales de la carga del menú, pero uno de los posteriores no aparece, 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 el código

Ahora que configuraste los valores de los parámetros en la app en SetDefaultsAsync() y hiciste que las versiones más actualizadas estén disponibles con FetchAsync() y ActivateAsync(), deberás hacer referencia a esos valores y usarlos en el código.

Después de que configures los valores en el backend de Remote Config, los recuperes y los actives (o realices ambas acciones a la vez), esos valores estarán disponibles para tu app. Para usar estos valores, llama a GetValue(string key) y elige una clave de parámetro como argumento. Esto muestra un ConfigValue, que tiene propiedades para acceder al valor como varios tipos compatibles: string, bool, long y double. En este proyecto y en la mayoría de los casos de uso de videojuegos, debes transmitir los dos últimos tipos a int y float más idiomáticos. Para garantizar que estas conversiones no causen problemas, asegúrate de que los valores iniciales establecidos en Remote Config estén 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 aplicada por la tarjeta de aceleración se cambiará a una que se reciba 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 están configurados como valores distintos de los valores predeterminados de su tipo.

Nota: SubtitleOverrideKey es un const string definido en MainMenu.cs configurado en el parámetro subtitle_override.

9. Configura los valores de los 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, lo configuraremos con Firebase console.

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

   Nombre del parámetro (clave)	Tipo de datos	Valor predeterminado
   aceleración_tile_force	Número	100
   anulación_subtítulo	JSON	{"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}

   

   Nota: Para cada parámetro, puedes establecer un valor predeterminado que anule el valor predeterminado en la app. Para obtener más información, consulta Parámetros y condiciones de Remote Config.

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.

   Sugerencia: En el caso de los valores que son más difíciles de observar, como los valores físicos, puedes actualizar el código para registrar el valor de ConfigValue.Source para determinar si los valores son sus valores predeterminados configurados o si se recuperaron del servidor de Remote Config.

Nota: Usa los métodos ToJson y FromJson<T> de JsonUtility de Unity para codificar y decodificar un objeto de datos serializable en una cadena y desde ella (como se hace actualmente en la inicialización de SubtitleOverrideDefault en MainMenu.cs). En la documentación Serializable de Unity, se describen las restricciones de Unity respecto a la serialización de objetos.

10. Usa condiciones de Remote Config para entregar variantes

Te recomendamos que ofrezcas la experiencia de la app al usuario en función del idioma que habla, el lugar en el que se encuentra, la hora del día o la plataforma que utiliza. Las condiciones de Remote Config te permiten usar estos y otros atributos de forma individual o en combinación para publicar diferentes valores (llamadas variantes) al usuario.

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

1. Abre la pestaña Remote Config del 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 nueva.
4. En el menú desplegable que aparece, coloca el cursor sobre Valor condicional y haz clic en Crear condición nueva.
5. Cuando se te solicite, asigna a la condición el nombre "es iOS" si te orientas a iOS o "es Android" si te orientas a Android. Si vas a orientarte a ambos, simplemente elige uno y úsalo durante el resto del codelab.
6. En Se aplica si..., haz clic en el menú desplegable Seleccionar... y selecciona Plataforma. Luego, selecciona la plataforma adecuada.
7. Haz clic en Crear condición para crear la condición. Volverá a aparecer el diálogo Editar parámetro y ahora podrás establecer un valor:
   • Si orientas tus anuncios a Android, establece el valor en:

     {"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
     

   • Si orientas tus anuncios a iOS, establece el valor en:

     {"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 del juego reemplazado por su variante específica de la plataforma.

11. Configura Remote Config para recibir actualizaciones en tiempo real

Nota: Las actualizaciones de Remote Config en tiempo real son compatibles con la versión 11.0.0 del SDK y versiones posteriores para plataformas de Apple y Android. Por el momento, no es compatible con el modo de juego de Unity.

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

Cómo funciona

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

Nota: Si se quitan todos los suscriptores de OnConfigUpdateListener, se dejarán de escuchar los cambios que se realicen en la plantilla de Remote Config de tu proyecto.

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 Config Update

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 claves actualizadas y un mensaje de éxito en el registro cuando active los valores nuevos.

Cómo suscribirse al evento Update

Para activar ActivateValuesOnConfigUpdate cuando se llame 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 nueva línea (que termina con += ActivateValuesOnConfigUpdate;) suscribe el controlador del evento 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 que están 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 tu 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 la app, haz lo siguiente en la sección Remote Config de Firebase console:

1. Presiona el botón Editar junto a acceleration_tile_force.

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

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

4. Inspecciona el registro.
5. Si ves un mensaje de registro que comienza con "Error failed while Listen", lee el resto y realiza la depuración con el mensaje de error que se muestra.
6. Si ves un registro que comienza con "Claves actualizadas", tu app recibió los valores modificados.
7. Si no ves ninguno de estos datos, revisa el resto de tus registros y, luego, vuelve a revisar las instrucciones de Crea un controlador de actualizaciones de configuración. Vuelve a probar y a verificar los registros para determinar si hay algún error.

Advertencia: Ten en cuenta que esto no recuperará un nuevo valor condicional si cambias la evaluación de su condición (por ejemplo, si un usuario tiene configurada una propiedad del usuario de Analytics determinada o si forma parte de un público de Analytics). Por el momento, mantén las llamadas a FetchRemoteConfig (que llama a FetchAndActivate) en Assets/Hamster/Scripts/States/MainMenu.cs y Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

12. ¡Felicitaciones!

Usaste Remote Config para controlar de forma remota los valores dentro del juego. Para ello, los recuperaste en tu app y usas condiciones para publicar diferentes variantes.

Temas abordados

• Cómo configurar y recuperar valores de Remote Config
• Cómo instrumentar tu código C# de Unity para usar los valores recuperados
• Cómo almacenar, instrumentar y anular valores o objetos 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 del valor del parámetro para comprender mejor la lógica de qué valores obtiene una instancia de app cuando usa un parámetro con varios valores (debido a condiciones o localidad).

Continúa con el siguiente paso de la ruta de aprendizaje,en el que usarás estos valores instrumentados para hacer pruebas A/B de diferentes variantes y comprender mejor cómo afectan el comportamiento de los usuarios.