Instrumenta tu juego 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 aplicación y actualizar sus valores en la nube, lo que te permite modificar la apariencia y el comportamiento de tu aplicación sin distribuir una actualización de la aplicación.

Agregarás esta nueva funcionalidad a un juego de muestra, MechaHamster: Level Up with Firebase Edition . Este juego de muestra es una nueva versión del clásico juego de Firebase, MechaHamster, que elimina la mayor parte de su funcionalidad integrada de Firebase, lo que te brinda la oportunidad de implementar nuevos usos de Firebase en su lugar.

Para garantizar que tu aplicación se comporte según lo previsto, establecerás configuraciones predeterminadas para los valores en el código del juego de muestra, y estos valores se pueden anular con los valores que establezcas en Remote Config en Firebase console .

lo que aprenderás

  • Cómo configurar valores de Remote Config en la nube y recuperarlos
  • Cómo instrumentar su código Unity C# para usar automáticamente los valores recuperados
  • Cómo almacenar, instrumentar y anular valores/objetos compuestos como valores JSON
  • Cómo utilizar las condiciones de Remote Config para ofrecer diferentes variantes de valores a diferentes grupos de usuarios

Lo que necesitarás

  • Unity 2019.1.0f1 o superior con compatibilidad con versiones de iOS y/o Android
  • Un dispositivo físico Android/iOS o un simulador/emulador para crear y ejecutar el juego.

2. Configure su entorno de desarrollo

Las siguientes secciones describen cómo descargar el código de Level Up with Firebase , abrirlo en Unity y agregar un proyecto de Firebase. Este juego de muestra Level Up with Firebase lo utilizan varios otros codelabs de Firebase + 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 Agregar SDK de Firebase para Unity para agregar Remote Config al código del juego de muestra.

Descarga el código

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

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

Alternativamente, si no tienes git instalado, puedes descargar el repositorio como un archivo ZIP .

Abra Level Up con Firebase en el editor de Unity

  1. Inicie Unity Hub y, desde la pestaña Proyectos , haga clic en la flecha desplegable junto a Abrir .
  2. Haga clic en Agregar proyecto desde el disco .
  3. Navegue hasta el directorio que contiene el código y luego haga clic en Aceptar .
  4. Si se le solicita, seleccione una versión del editor de Unity para usar y su plataforma de destino (Android o iOS).
  5. Haga clic en el nombre del proyecto, subir de nivel con firebase , y el proyecto se abrirá en el editor de Unity.
  6. Si su editor no lo abre automáticamente, abra MainGameScene en Activos > Hamster en la pestaña Proyecto del Editor de Unity.

Para obtener más información sobre la instalación y el uso de Unity, consulte Trabajar en Unity .

3. Agrega Firebase a tu proyecto de Unity

Crear un proyecto de Firebase

  1. En Firebase console , haz clic en Agregar proyecto .
  2. Para crear un nuevo proyecto, ingrese el nombre del proyecto deseado.
    Esto también establecerá el ID del proyecto (que se muestra debajo del nombre del proyecto) en algo basado en el nombre del proyecto. Opcionalmente, puede hacer clic en el icono de edición en el ID del proyecto para personalizarlo aún más.
  3. Si se te solicita, revisa y acepta los términos de Firebase .
  4. Haga clic en Continuar .
  5. Seleccione la opción Habilitar Google Analytics para este proyecto y luego haga clic en Continuar .
  6. Seleccione una cuenta de Google Analytics existente para usar o seleccione Crear una cuenta nueva para crear una cuenta nueva.
  7. Haga clic en Crear proyecto .
  8. Cuando se haya creado el proyecto, haga clic en Continuar .

Registra tu aplicación con Firebase

  1. Abra Firebase console y, desde el centro de la página de descripción general del proyecto, haga clic en el ícono de Unity para iniciar el flujo de trabajo de configuración o, si ya agregó una aplicación a su proyecto de Firebase, haga clic en Agregar aplicación para mostrar las opciones de la plataforma.
  2. Seleccione para registrar los objetivos de compilación de Apple (iOS) y Android.
  3. Ingrese los ID específicos de la plataforma de su proyecto de Unity. Para este codelab, ingresa lo siguiente:
  4. Opcionalmente, ingrese los apodos específicos de la plataforma de su proyecto de Unity.
  5. Haga clic en Registrar aplicación y continúe con la sección Descargar archivo de configuración .
  6. Repita el proceso para cualquier objetivo de compilación que no haya realizado la primera vez.

Agregar archivos de configuración de Firebase

Después de hacer clic en Registrar aplicación , se le pedirá que descargue dos archivos de configuración (un archivo de configuración para cada objetivo de compilación). Tu proyecto de Unity necesita los metadatos de Firebase en estos archivos para conectarse con Firebase.

  1. Descargue ambos archivos de configuración disponibles:
    • Para Apple (iOS) : descargue GoogleService-Info.plist .
    • Para Android : descargue google-services.json .
  2. Abra la ventana Proyecto de su proyecto de Unity, luego mueva ambos archivos de configuración a la carpeta Activos .
  3. De vuelta en Firebase console, en el flujo de trabajo de configuración, haga clic en Siguiente y continúe con Agregar SDK de Firebase para Unity.

Nota: Siempre puedes volver a descargar estos archivos más adelante abriendo la configuración general de tu proyecto, desplazándote hacia abajo hasta la sección Tus aplicaciones y luego haciendo clic en el botón de descarga del archivo de configuración deseado.

Agregar SDK de Firebase para Unity

  1. Haga clic en Descargar Firebase Unity SDK en Firebase console.
  2. Descomprima el SDK en algún lugar conveniente.
  3. En su proyecto Unity abierto, navegue hasta Activos > Importar paquete > Paquete personalizado .
  4. En el cuadro de diálogo Importar paquete , navegue hasta el directorio que contiene el SDK descomprimido, seleccione FirebaseAnalytics.unitypackage y luego haga clic en Abrir .
  5. En el cuadro de diálogo Importar paquete de Unity que aparece, haga clic en Importar .
  6. Repita los pasos anteriores para importar los dos paquetes siguientes:
    • FirebaseRemoteConfig.unitypackage
    • FirebaseCrashlytics.unitypackage
      Crashlytics es un reportero de fallas liviano y en tiempo real que lo ayuda a rastrear, priorizar y solucionar problemas de estabilidad que erosionan la calidad de su aplicación. Si no lo ha usado anteriormente, considere completar el Camino de aprendizaje de Crashlytics para Unity .
  7. Regrese a Firebase console y, en el flujo de trabajo de configuración, haga clic en Siguiente .

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

4. Establezca los valores predeterminados de Remote Config y obtenga nuevos valores

En este codelab, actualizará objetos que usan valores definidos en código o que están serializados en el editor de Unity para usar valores instrumentados con Remote Config. Configurará los valores predeterminados para cada parámetro usando SetDefaultsAsync para que su aplicación se comporte según lo previsto antes de conectarse al backend de Remote Config. Su aplicación se mantendrá actualizada obteniendo nuevos valores de Remote Config y activándolos para que sean utilizables en el código.

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

  1. Agregue las siguientes declaraciones 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 tareas de C# que ayudarán a simplificar la administración del proceso de inicialización con devoluciones de llamadas.
  2. Agregue la inicialización de Firebase a su método MainGame.cs Start() reemplazando el método existente InitializeCommonDataAndStartGame() con el método actualmente no implementado, InitializeFirebaseAndStartGame() :
    void Start()
{
   Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
   InitializeFirebaseAndStartGame();
}
  3. En MainGame.cs , busque InitializeFirebaseAndStartGame() . Declare una variable de aplicación y sobrescriba 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 en caso de éxito para establecer los valores predeterminados en la aplicación. Reemplace 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. Obtener y activar nuevos valores (según sea necesario)

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

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

  1. Pegue 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, complete 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 en sentido descendente desde el contexto de inicialización, ActivateRetrievedRemoteConfigValues ​​llama al punto de partida anterior, InitializeCommonDataAndStartGame , para iniciar el juego abriendo el menú principal.

6. Configure una estrategia de carga de Remote Config

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

Tal como se implementa actualmente, los valores de Remote Config se obtienen y activan cuando se inicia la aplicación. Las recuperaciones se pueden ocultar durante los cambios de 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 a menudo se puede utilizar un cambio en el estado del menú para saber "adónde" va el jugador y predecir que se utilizará un valor.

Al observar el sistema de menús de Mechahamster, la forma más fácil de agregar actualizaciones del menú de bloqueo de la UI 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 UI como devolución de llamada onFetchAndActivateSuccessful . Se puede hacer lo mismo con el menú de selección de nivel .

Con la carga inicial como parte del inicio de la aplicación, cualquier navegación por el menú que pase por el menú principal será manejada por el primero de ellos, 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 sólo se puede acceder a él desde el menú principal y, por lo tanto, ya está cubierto.

Para habilitar esto en la aplicación, complete los métodos relevantes en el menú principal y seleccione los archivos de nivel, lo que bloqueará la visualización de la interfaz de usuario hasta que se completen FetchAsync y ActivateAsync :

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

7. Depurar/validar comportamientos de recuperación

En este punto, es beneficioso realizar una verificación de diagnóstico/validación. El siguiente procedimiento le permitirá probar manualmente su aplicación y saber si recupera y activa los valores de Remote Config.

La información se imprimirá como parte de los registros de su simulador, dispositivo o editor. Para iOS, puede ver los registros del dispositivo y del simulador en Xcode. Para Android, vea los registros ejecutando adb logcat . Si ejecuta el código en Unity presionando Reproducir en el editor, los registros aparecen en la pestaña Consola.

  1. Reconstruya y ejecute la aplicación (en el Editor, usando un dispositivo o simulador).
  2. Después de que aparezca el menú principal del juego, revisa la salida del registro del juego, que debe contener los registros generados por Debug.Log en FetchRemoteConfig y ActivateRetrievedRemoteConfigValues . Estos deberían mostrar los mensajes "Obteniendo datos..." y "Datos remotos cargados y listos". Tenga en cuenta las marcas de tiempo al principio de estos mensajes.
  3. En el juego, presiona Licencia .
  4. Presione Aceptar .
  5. Espera a que aparezca el menú principal del juego.
  6. Revisa la salida del registro de tu juego, que debería ser similar a la del paso anterior, con nuevas marcas de tiempo (que coincidan con la hora establecida en el reloj del sistema donde estás ejecutando el juego).
  7. En el juego, presiona Jugar .
  8. Pulsa Let's Roll .
  9. Lleva la pelota a la portería usando las flechas del teclado, lo que abrirá un menú de nivel completo.
  10. Presione Niveles .
  11. Espere a que se cargue el menú de selección de nivel .
  12. Revisa la salida del registro de tu juego nuevamente. Debe coincidir con los mensajes de registro de los pasos anteriores, con las marcas de tiempo más recientes (que coincidan con la hora establecida en el reloj del sistema donde estás ejecutando el juego).

Si alguno de ellos no apareció en su aplicación, es posible que alguna parte del flujo de búsqueda y activación (o su dispositivo) esté mal configurada. Si el primer registro no aparece, existe la posibilidad de que el juego no se inicie. Revise los registros de la consola del editor o del dispositivo/emulador para detectar advertencias y errores sobre su proyecto/entorno e investiguelos; el problema puede ser tan simple como conectarse a Internet.

Si aparecen los registros iniciales de carga del menú, pero uno de los posteriores no, investigue/vuelva 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 configuró los valores de los parámetros en la aplicación en SetDefaultsAsync() y que las versiones más actualizadas están disponibles con FetchAsync() y ActivateAsync() , hará referencia y usará esos valores en el código.

Después de establecer valores en el backend de Remote Config, recuperarlos y activarlos ( o hacer ambas cosas a la vez ), esos valores estarán disponibles para su aplicación. Para usar estos valores, llame a GetValue(string key ) y elija 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 garantizar que estas conversiones no causen problemas, asegúrese de que los valores iniciales establecidos en Remote Config estén dentro del rango válido de los tipos que usará en el código de su aplicación.

  1. Importe Remote Config agregando using Firebase.RemoteConfig; al principio de los siguientes archivos:
    • Assets/Hamster/Scripts/States/MainMenu.cs
    • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
  2. Reemplace 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 impartida por el mosaico de aceleración cambiará a la recibida desde Remote Config.
  3. Edite 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 a los valores predeterminados de su tipo .

9. Establecer los valores de los parámetros de forma remota

Ahora que su aplicación está completamente instrumentada, está listo para configurar parámetros y valores en el servidor de Remote Config. En este codelab, configuraremos esto usando Firebase console.

  1. En Firebase console , abre tu proyecto.
  2. Seleccione Remote Config en el menú para ver el panel de Remote Config.
  3. Para cada uno de los parámetros que definió en su aplicación y que se enumeran en la tabla siguiente, haga clic en Agregar parámetro , pegue el nombre del parámetro (clave), seleccione el tipo de datos que figura en la tabla, deshabilite Usar valor predeterminado en la aplicación y pegue el nuevo valor predeterminado:

    Nombre del parámetro (clave)

    Tipo de datos

    Valor por defecto

    aceleración_tile_force

    Número

    100

    subtítulo_override

    JSON

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

    Remote Config Parameter editor with\nacceleration_tile_force populated
  4. Haga clic en Guardar para guardar sus cambios.
  5. Haz clic en Publicar para publicar la nueva configuración y hacer que los nuevos valores estén disponibles para tu juego.
  6. Ejecute su aplicación nuevamente después de configurar estos parámetros remotos y observe cómo anulan los valores predeterminados originales. Mechahamster main screen with Debug\nMenu enabled

10. Utilice las condiciones de Remote Config para ofrecer variantes

Es posible que desee adaptar la experiencia de la aplicación al usuario en función del idioma que habla, dónde se encuentra, la hora del día o qué plataforma utiliza. Las condiciones de Remote Config le brindan la posibilidad de usar estos y otros atributos individualmente o en combinación para ofrecer diferentes valores (llamados variantes) al usuario.

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

  1. Abre la pestaña Remote Config de tu proyecto en Firebase console .
  2. Haga clic en el botón editar para subtitle_override.
  3. En la esquina inferior izquierda, haz clic en Agregar nuevo .
  4. En el menú desplegable que aparece, coloque el cursor sobre Valor condicional y haga clic en Crear nueva condición. Remote Config parameter editor:\nConditional value option
  5. Cuando se le solicite, asigne un nombre a la condición "es iOS" si su objetivo es iOS, o "es Android" si su objetivo es Android. Si tiene como objetivo ambos, simplemente elija uno aquí y úselo para el resto del codelab. Using the Define a new condition\ndialog to define an iOS-specific condition
  6. En Se aplica si... , haga clic en el menú desplegable Seleccionar... y seleccione Plataforma . Luego, seleccione la plataforma adecuada. Using the Define a new condition\neditor to select the iOS platform
  7. Haga clic en Crear condición para crear la condición. El cuadro de diálogo Editar parámetro vuelve a aparecer y ahora puede establecer un valor:
    • Si su objetivo es Android, establezca el valor en: 
      {"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
    • Si su objetivo es iOS, establezca el valor en: 
      {"text":"Level Up iOS Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
  8. Haga clic en Guardar para guardar sus cambios.
  9. Haz clic en Publicar para publicar la nueva configuración y hacer que los nuevos valores estén disponibles para tu juego.

Si compilas y ejecutas el juego nuevamente, deberías ver el subtítulo del juego reemplazado por su variante específica de la plataforma.

11. Configure Remote Config para recibir actualizaciones en tiempo real

Remote Config ahora puede escuchar y gestionar actualizaciones de las plantillas de Remote Config en tiempo real . Las aplicaciones 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 actualizaciones, su aplicación debe implementar un método que se suscriba al evento OnConfigUpdateListener . Mientras uno o más oyentes de actualizaciones de configuración están suscritos, las nuevas plantillas de Remote Config se recuperarán automáticamente, se llama a los controladores suscritos y se pueden usar para realizar lógica en respuesta, como activar los nuevos valores y ponerlos a disposición del resto de la aplicación.

Implementar configuración remota en tiempo real

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

Crear un controlador de actualización de configuración

El primer paso para utilizar el evento Config Update es crear un método capaz de escucharlo. Coloque 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 nuevos valores.

Suscríbete al evento de actualización

Para activar ActivateValuesOnConfigUpdate cuando se llama al evento, suscríbelo al evento. Reemplace 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 nueva línea (que termina en += ActivateValuesOnConfigUpdate; ) suscribe el controlador de eventos al evento.

Darse de baja 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 cancelar la suscripción a ese método cuando se destruyen. Agregue el siguiente método a Assets/Hamster/Scripts/MainGame.cs :

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

Pruebe la nueva funcionalidad

Para validar la nueva funcionalidad, pruebe su aplicación integrada. El siguiente procedimiento requiere que pueda leer el registro y depurarlo utilizando un dispositivo real .

Cambie acceleration_tile_force y observe

Después de iniciar tu aplicación, en la sección Remote Config de Firebase console:

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

dc602d4db54e50a4.png

  1. Cambie el valor a '120' y presione Guardar .

fcbc1df848f88009.png

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

3785c1e00e7a6359.png

  1. Inspeccione el registro.
  2. Si ve un mensaje de registro que comienza con "Se produjo un error al escuchar", lea el resto e intente depurar con el mensaje de error que imprime.
  3. Si ve un registro que comienza con "Claves actualizadas", su aplicación recibió los valores modificados.
  4. Si no ve ninguno de estos, revise el resto de sus registros y luego vuelva a revisar las instrucciones de Crear un controlador de actualización de configuración , vuelva a probar y verificar los registros para determinar si hay algo mal.

12. ¡Felicitaciones!

¡Has usado Remote Config para controlar los valores del juego de forma remota, buscándolos en tu aplicación y usando condiciones para ofrecer diferentes variantes!

Lo que hemos cubierto

  • Cómo configurar y recuperar valores de Remote Config
  • Cómo instrumentar su código Unity C# para usar los valores recuperados
  • Cómo almacenar, instrumentar y anular valores/objetos compuestos como valores JSON
  • Cómo utilizar las condiciones de Remote Config para ofrecer diferentes variantes de valores

Próximos pasos

Lea acerca de la prioridad del valor del parámetro para comprender mejor la lógica de qué valores obtiene una instancia de aplicación cuando usa un parámetro con múltiples valores (debido a condiciones o localidad).