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 juego clásico de Firebase MechaHamster que quita la mayor parte de su funcionalidad integrada de Firebase, lo que te da la oportunidad de implementar nuevos usos de Firebase en su lugar.

Para garantizar que tu app se comporte según lo previsto, establece una configuración predeterminada para los valores del código del juego de muestra. Estos valores se pueden anular a través de los valores que estableces 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 valor para distintos grupos de usuarios

Requisitos

• Unity 2019.1.0f1 o una versión posterior compatible con la compilación en 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 para subir de nivel con 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 proceder a Agregar los SDK de Firebase para Unity para agregar Remote Config al código del 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 instalado Git, puedes descargar el repositorio como un archivo ZIP.

Abre Level Up with 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 haz clic en OK.
4. Si se te solicita, selecciona la versión del editor de Unity que quieres usar y tu plataforma de segmentación (Android o iOS).
5. Haz clic en el nombre del proyecto, level-up-with-firebase, para que el proyecto se abra 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 cómo instalar y usar 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.
   Esto también establecerá el ID del proyecto (que se muestra debajo del nombre) en un valor basado en el nombre del proyecto. 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 la cuenta de Google Analytics existente que deseas usar o elige la opción Crear una cuenta nueva para crear una.
7. Haz clic en Crear proyecto.
8. Una vez que 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 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. También puedes ingresar el sobrenombre específico de la plataforma del 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 cualquier objetivo de compilación que no realizaste 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 la plataforma.

1. Descargar los dos archivos de configuración disponibles:
   • En Apple (iOS): Descarga GoogleService-Info.plist.
   • En Android: Descarga google-services.json.
2. Abre la ventana Project de tu proyecto de Unity y mueve ambos archivos de configuración a la carpeta Assets.

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

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

Nota: Puedes volver a descargar estos archivos cuando quieras. Para ello, abre la configuración general del proyecto, desplázate hacia abajo hasta la sección Tus apps y haz clic en el botón de descarga del archivo de configuración que desees.

Agrega los SDK de Firebase para Unity

1. En Firebase console, haz clic en Descargar el SDK de Firebase Unity.

   Nota: Es posible que la descarga de este SDK demore un poco. Obtén una vista previa de los próximos pasos o toma un breve descanso.

2. Descomprime el SDK en la ubicación que prefieras.
3. Abre tu 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 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 aún no lo has usado, te recomendamos completar la ruta de aprendizaje de Crashlytics para Unity.
7. Regresa 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 los valores predeterminados de Remote Config y recupera valores nuevos

En este codelab, actualizarás objetos que usan 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 mediante SetDefaultsAsync para que la app se comporte según lo previsto antes de que se conecte al backend de Remote Config. Para mantenerse actualizada, tu app recupera valores nuevos de Remote Config y los activa para que se puedan usar en el código.

Para recuperar valores nuevos de Remote Config, ya hay una serie de métodos sin implementar en el archivo Assets/Hamster/Scripts/MainGame.cs que se deben completar.

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 cuando se completa de forma correcta para establecer valores predeterminados en la app. Reemplaza el método sin implementar SetRemoteConfigDefaults 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. De esta forma, se encadenarán las llamadas a los métodos FetchAsync (que recupera valores nuevos de Remote Config) y ActivateAsync (que activa los 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 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 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);
         });
   }
   

   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 lanza a producción, debes establecer el 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 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 mientras usas la app, debes volver a llamar a estas funciones y, si algún objeto almacenó en caché los valores, se les debe notificar para que realicen una actualización. Para desarrollar una estrategia que permita 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 los valores nuevos para evitar que cambien durante su uso.

Tal 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 del 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 nuevos valores, ya que un cambio en el estado del menú a menudo se puede usar para saber “hacia dónde” se dirige el reproductor y predecir que se usará un valor.

Si observas el sistema de menús 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 acceda a él saliendo de otro menú) y pasar el método de visualización de la IU como la devolución de llamada onFetchAndActivateSuccessful. Puede hacer lo mismo para el menú Selección de niveles.

Con la carga inicial como parte del inicio de la app, cualquier navegación del menú que pase por el menú principal será controlada por la primera de estas, mientras que cualquier reingreso del menú Level Select también causará una actualización. La entrada inicial al menú de selección de nivel no importa, ya que solo se puede acceder desde el menú principal y, por lo tanto, ya está cubierta.

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

Nota: Si bien este codelab proporciona una manera de cargar valores de Remote Config cuando el menú principal y las vistas de selección de nivel están activas, 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 determinar si recupera y activa valores de Remote Config.

La información se imprimirá como parte de los registros del simulador, del dispositivo o del 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. Una vez que aparezca el menú principal del juego, revisa el resultado del registro de tu juego, que debe contener los registros que generó Debug.Log en FetchRemoteConfig y ActivateRetrievedRemoteConfigValues. Deberían aparecer los mensajes "Obteniendo 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 los resultados del registro de tu juego, que deberían ser similares a los del paso anterior, con nuevas marcas de tiempo (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 el objetivo con las flechas del teclado, que abrirán un menú de nivel completo.
10. Presiona Niveles.
11. Espera a que se cargue el menú Level Select.
12. Revisa nuevamente el resultado del registro 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 donde ejecutas el juego).

Si alguna de estas opciones no apareció en tu app, es posible que alguna parte del flujo de recuperación y activación (o tu dispositivo) esté mal configurada. 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 en busca de advertencias y errores relacionados con tu proyecto o entorno y, luego, infórmalos. El problema puede ser tan simple como conectarte a Internet.

Si aparecen los registros iniciales de carga del menú, pero uno de los siguientes 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 parámetros 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 establecer valores en el backend de Remote Config, recuperarlos y activarlos (o realizar ambos al mismo tiempo), esos valores estarán disponibles para la app. Para usarlos, 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 admitidos: string, bool, long y double. En este proyecto y en la mayoría de los casos de uso de videojuegos, debes convertir los dos últimos tipos en los 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 se encuentren dentro del rango válido de los tipos que utilizarás en el código de tu app.

1. Importa Remote Config agregando using Firebase.RemoteConfig; a 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 el mosaico 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 está configurado 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 establecido en el parámetro subtitle_override.

9. Configura 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 esta información 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 la app y que figuran en la tabla siguiente, 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
   fuerza_fija_aceleración	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 anula el valor predeterminado de la app. Para obtener más información, consulta los parámetros y condiciones de Remote Config.

4. Haz clic en Guardar para guardar los cambios.
5. Haz clic en Publish a fin de publicar la nueva configuración y hacer que los nuevos valores 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.Sourcepara determinar si los valores son los 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 hacia y desde una cadena (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 en relación con la serialización de objetos.

10. Usa condiciones de Remote Config para entregar variantes

Es posible que quieras ofrecer la experiencia de la aplicación al usuario según el 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 (llamados 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 de 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 orientas tus anuncios a iOS o "es Android" si te orientas a Android. Si ese es tu caso, elige uno aquí y úsalo para 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 cuadro de diálogo Editar parámetro y podrás configurar un valor:
   • Si orientas tu app a Android, establece el Valor de la siguiente manera:

     {"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 Publish a fin de publicar la nueva configuración y hacer que los nuevos valores estén disponibles para tu juego.

Si vuelves a compilar y ejecutar el juego, deberías ver que el subtítulo del juego se reemplaza por la 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 en las plataformas de Apple y Android. Por el momento, no es compatible con el modo de juego de Unity.

Remote Config ahora 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 la respuesta, como activar los valores nuevos y ponerlos a disposición del resto de la aplicación.

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

Implementa Remote Config en tiempo real

Para ilustrar cómo funciona 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 que pueda 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.

Suscribirse al evento Actualizar

Para activar ActivateValuesOnConfigUpdate cuando se llame al evento, suscríbete al evento. Reemplaza el método InitializeCommonDataAndStartGame() en Assets/Hamster/Scripts/MainGame.cs con 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 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 de edición 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 el mensaje “Se produjo un error durante la escucha”, lee el resto y prueba con el mensaje de error que imprime.
6. Si ves un registro que comienza con "Claves actualizadas", significa que tu app recibió los valores modificados.
7. Si no ves ninguno de estos, revisa el resto de tus registros y vuelve a revisar las instrucciones de Crea un controlador de Config Update, vuelve a probar y a verificar los registros para determinar si hay algún error.

Advertencia: Ten en cuenta que no se 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 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 en el juego 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 instrumentar 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 valor

Próximos pasos

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

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