Comience con Firebase Remote Config

iOS+ Android Web Flutter Unidad C++

Puedes usar Firebase Remote Config para definir 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. Esta guía lo guía a través de los pasos para comenzar y proporciona código de muestra, todo el cual está disponible para clonar o descargar desde el repositorio de GitHub firebase/quickstart-android .

Paso 1: agrega Firebase y el SDK de Remote Config a tu aplicación

1. Si aún no lo has hecho, agrega Firebase a tu proyecto de Android .

2. Para Remote Config, se requiere Google Analytics para la orientación condicional de instancias de aplicaciones a audiencias y propiedades de usuario. Asegúrese de habilitar Google Analytics en su proyecto.

3. En el archivo Gradle de su módulo (nivel de aplicación) (generalmente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle ), agregue la dependencia para Remote Config biblioteca para Android. Recomendamos utilizar Firebase Android BoM para controlar el control de versiones de la biblioteca.

   Además, como parte de la configuración de Analytics, debes agregar el SDK de Firebase para Google Analytics a tu aplicación.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:32.8.0"))
   
       // Add the dependencies for the Remote Config and Analytics libraries
       // When using the BoM, you don't specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-config")
       implementation("com.google.firebase:firebase-analytics")
   }
   

   Al usar Firebase Android BoM , su aplicación siempre usará versiones compatibles de las bibliotecas de Firebase Android.

   (Alternativa) Agregue dependencias de la biblioteca de Firebase sin usar la BoM

   Si elige no utilizar la BoM de Firebase, debe especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

   Tenga en cuenta que si usa varias bibliotecas de Firebase en su aplicación, le recomendamos encarecidamente usar la BoM para administrar las versiones de la biblioteca, lo que garantiza que todas las versiones sean compatibles.

   dependencies {
       // Add the dependencies for the Remote Config and Analytics libraries
       // When NOT using the BoM, you must specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-config:21.6.3")
       implementation("com.google.firebase:firebase-analytics:21.6.1")
   }
   

   ¿Busca un módulo de biblioteca específico de Kotlin? A partir de octubre de 2023 (Firebase BoM 32.5.0) , tanto los desarrolladores de Kotlin como los de Java podrán depender del módulo de biblioteca principal (para más detalles, consulte las preguntas frecuentes sobre esta iniciativa ).

Nota: Debido a que el SDK de Android depende de la API REST de Remote Config, asegúrese de no deshabilitar esa API, que está habilitada de forma predeterminada en un proyecto típico.

Paso 2: Obtenga el objeto singleton de Remote Config

Obtenga una instancia de objeto de Remote Config y establezca el intervalo de recuperación mínimo para permitir actualizaciones frecuentes:

Kotlin+KTX

val remoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)
MainActivity.kt

Java

FirebaseRemoteConfig mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
        .setMinimumFetchIntervalInSeconds(3600)
        .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);
MainActivity.java

El objeto singleton se utiliza para almacenar valores de parámetros predeterminados en la aplicación, recuperar valores de parámetros actualizados desde el backend y controlar cuándo los valores recuperados están disponibles para su aplicación.

Durante el desarrollo, se recomienda establecer un intervalo de recuperación mínimo relativamente bajo. Consulte Limitación para obtener más información.

Paso 3: establecer valores de parámetros predeterminados en la aplicación

Puede establecer valores de parámetros predeterminados en la aplicación en el objeto de Remote Config, de modo que su aplicación se comporte según lo previsto antes de conectarse al backend de Remote Config y para que los valores predeterminados estén disponibles si no se establece ninguno en el backend.

Importante: No almacene datos confidenciales en claves o valores de parámetros de Remote Config. Los datos de Remote Config se cifran en tránsito, pero los usuarios finales pueden acceder a cualquier parámetro de Remote Config predeterminado o recuperado que esté disponible para su instancia de aplicación cliente.

1. Defina un conjunto de nombres de parámetros y valores de parámetros predeterminados utilizando un objeto Map o un archivo de recursos XML almacenado en la carpeta res/xml de su aplicación. La aplicación de ejemplo de inicio rápido de Remote Config utiliza un archivo XML para definir nombres y valores de parámetros predeterminados.

   Si ya configuró los valores de los parámetros del backend de Remote Config, puede descargar un archivo XML generado que incluya todos los valores predeterminados y guardarlo en el directorio res/xml de su aplicación:

   DESCANSAR

   curl --compressed -D headers -H "Authorization: Bearer token" -X GET https://firebaseremoteconfig.googleapis.com/v1/projects/my-project-id/remoteConfig:downloadDefaults?format=XML -o remote_config_defaults.xml
   

   Consola de base de fuego

   1. En la pestaña Parámetros , abra el menú y seleccione Descargar valores predeterminados .

   2. Cuando se le solicite, habilite .xml para Android y luego haga clic en Descargar archivo .

2. Agregue estos valores al objeto Remote Config usando setDefaultsAsync(int) , como se muestra:

   Kotlin+KTX

   remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

   Java

   mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Paso 4: Obtenga valores de parámetros para usar en su aplicación

Ahora puede obtener valores de parámetros del objeto Remote Config. Si establece valores en el backend, los recupera y luego los activa, esos valores estarán disponibles para su aplicación. De lo contrario, obtienes los valores de los parámetros en la aplicación configurados usando setDefaultsAsync(int) . Para obtener estos valores, llame al método que se enumera a continuación que se asigna al tipo de datos esperado por su aplicación, proporcionando la clave del parámetro como argumento:

• getBoolean()
• getDouble()
• getLong()
• getString()

Paso 5: Establecer los valores de los parámetros en el backend de Remote Config

Con la consola Firebase o las API de backend de Remote Config , puedes crear nuevos valores predeterminados del lado del servidor que anulan los valores en la aplicación según la lógica condicional o la orientación del usuario que desees. Esta sección describe los pasos de Firebase console para crear estos valores.

1. En Firebase console , abre tu proyecto.
2. Seleccione Remote Config en el menú para ver el panel de Remote Config.
3. Defina parámetros con los mismos nombres que los parámetros que definió en su aplicación. Para cada parámetro, puede establecer un valor predeterminado (que eventualmente anulará el valor predeterminado correspondiente en la aplicación) y también puede establecer valores condicionales. Para obtener más información, consulte Parámetros y condiciones de Remote Config .

Paso 6: buscar y activar valores

1. Para recuperar valores de parámetros del backend de Remote Config, llame al método fetch() . Cualquier valor que establezca en el backend se recupera y almacena en el objeto de Remote Config.

2. Para que los valores de los parámetros recuperados estén disponibles para su aplicación, llame al método activate() .

   Para los casos en los que desee recuperar y activar valores en una sola llamada, puede usar una solicitud fetchAndActivate() para recuperar valores del backend de Remote Config y ponerlos a disposición de la aplicación:

   Kotlin+KTX

   remoteConfig.fetchAndActivate()
       .addOnCompleteListener(this) { task ->
           if (task.isSuccessful) {
               val updated = task.result
               Log.d(TAG, "Config params updated: $updated")
               Toast.makeText(
                   this,
                   "Fetch and activate succeeded",
                   Toast.LENGTH_SHORT,
               ).show()
           } else {
               Toast.makeText(
                   this,
                   "Fetch failed",
                   Toast.LENGTH_SHORT,
               ).show()
           }
           displayWelcomeMessage()
       }

   Java

   mFirebaseRemoteConfig.fetchAndActivate()
           .addOnCompleteListener(this, new OnCompleteListener<Boolean>() {
               @Override
               public void onComplete(@NonNull Task<Boolean> task) {
                   if (task.isSuccessful()) {
                       boolean updated = task.getResult();
                       Log.d(TAG, "Config params updated: " + updated);
                       Toast.makeText(MainActivity.this, "Fetch and activate succeeded",
                               Toast.LENGTH_SHORT).show();
   
                   } else {
                       Toast.makeText(MainActivity.this, "Fetch failed",
                               Toast.LENGTH_SHORT).show();
                   }
                   displayWelcomeMessage();
               }
           });

Debido a que estos valores de parámetros actualizados afectan el comportamiento y la apariencia de su aplicación, debe activar los valores recuperados en un momento que garantice una experiencia fluida para su usuario, como la próxima vez que el usuario abra su aplicación. Consulte Estrategias de carga de Remote Config para obtener más información y ejemplos.

Nota: Si su aplicación no se compila con Gradle, debe agregar manualmente el recurso de cadena google_app_id correcto a su aplicación para que Remote Config pueda inicializarse. El complemento Gradle google-services normalmente agrega esto automáticamente, pero puede encontrar el valor apropiado en el archivo google-services.json que descarga desde Firebase console. Para obtener más información sobre cómo obtener el valor google_app_id del archivo google-services.json , consulte Procesamiento del archivo JSON .

Paso 7: escuche las actualizaciones en tiempo real

Después de recuperar los valores de los parámetros, puede usar Remote Config en tiempo real para escuchar las actualizaciones desde el backend de Remote Config. Remote Config en tiempo real envía señales a los dispositivos conectados cuando hay actualizaciones disponibles y recupera automáticamente los cambios después de publicar una nueva versión de Remote Config.

Las actualizaciones en tiempo real son compatibles con Firebase SDK para Android v21.3.0+ (Firebase BoM v31.2.4+).

Importante: Real-time Remote Config también requiere la API Firebase Remote Config Realtime, que ya debería estar habilitada para usted. Para verificar, abra la consola de Google Cloud , seleccione su proyecto y abra la página API y servicios . La API debería aparecer como habilitada. Si falta o no está habilitado, haga clic en Habilitar API y servicios , busque Firebase Remote Config Realtime API y habilítelo.

1. En su aplicación, use addOnConfigUpdateListener() para comenzar a escuchar actualizaciones y recuperar automáticamente cualquier valor de parámetro nuevo. Implemente la devolución de llamada onUpdate() para activar la configuración actualizada.

   Kotlin+KTX

   remoteConfig.addOnConfigUpdateListener(object : ConfigUpdateListener {
       override fun onUpdate(configUpdate : ConfigUpdate) {
          Log.d(TAG, "Updated keys: " + configUpdate.updatedKeys);
   
          if (configUpdate.updatedKeys.contains("welcome_message")) {
              remoteConfig.activate().addOnCompleteListener {
                  displayWelcomeMessage()
              }
          }
       }
   
       override fun onError(error : FirebaseRemoteConfigException) {
           Log.w(TAG, "Config update error with code: " + error.code, error)
       }
   })
   

   Java

   mFirebaseRemoteConfig.addOnConfigUpdateListener(new ConfigUpdateListener() {
       @Override
       public void onUpdate(ConfigUpdate configUpdate) {
           Log.d(TAG, "Updated keys: " + configUpdate.getUpdatedKeys());
   
           mFirebaseRemoteConfig.activate().addOnCompleteListener(new OnCompleteListener() {
               @Override
               public void onComplete(@NonNull Task task) {
                   displayWelcomeMessage();
               }
           });
       }
   
       @Override
       public void onError(FirebaseRemoteConfigException error) {
           Log.w(TAG, "Config update error with code: " + error.getCode(), error);
       }
   });
   

2. La próxima vez que publique una nueva versión de su Remote Config, los dispositivos que ejecutan su aplicación y escuchan los cambios llamarán a ConfigUpdateListener .

estrangulamiento

Si una aplicación se recupera demasiadas veces en un período corto, las llamadas de recuperación se limitan y el SDK devuelve FirebaseRemoteConfigFetchThrottledException . Antes de la versión 17.0.0 del SDK, el límite era de 5 solicitudes de recuperación en un período de 60 minutos (las versiones más nuevas tienen límites más permisivos).

Consejo: A partir del SDK de Android v21.3.0+ (Firebase BoM v31.3.0+), puedes usar Remote Config en tiempo real para recuperar automáticamente los valores de parámetros actualizados del backend de Remote Config tan pronto como se publiquen, evitando cualquier recuperación mínima. ajuste del intervalo. Para obtener más información, consulte Escuche actualizaciones en tiempo real .

Durante el desarrollo de la aplicación, es posible que desees recuperar y activar configuraciones con mucha frecuencia (muchas veces por hora) para poder iterar rápidamente a medida que desarrollas y pruebas tu aplicación. Las actualizaciones de Remote Config en tiempo real omiten automáticamente el caché cuando la configuración se actualiza en el servidor. Para permitir una iteración rápida en un proyecto con hasta 10 desarrolladores, puedes configurar temporalmente un objeto FirebaseRemoteConfigSettings con un intervalo de recuperación mínimo bajo ( setMinimumFetchIntervalInSeconds ) en tu aplicación.

El intervalo de recuperación mínimo predeterminado para Remote Config es de 12 horas, lo que significa que las configuraciones no se recuperarán del backend más de una vez en un período de 12 horas, independientemente de cuántas llamadas de recuperación se realicen realmente. Específicamente, el intervalo de recuperación mínimo se determina en el siguiente orden:

1. El parámetro en fetch(long)
2. El parámetro en FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
3. El valor predeterminado de 12 horas.

Para establecer el intervalo de recuperación mínimo en un valor personalizado, use FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long) .

Tenga en cuenta que esta configuración debe usarse solo para desarrollo, no para una aplicación que se ejecuta en producción. Si solo está probando su aplicación con un pequeño equipo de desarrollo de 10 personas, es poco probable que alcance los límites de cuota por horas del lado del servicio. Pero si envía su aplicación a miles de usuarios de prueba con un intervalo de recuperación mínimo muy bajo, su aplicación probablemente alcanzará esta cuota.

Próximos pasos

Si aún no lo ha hecho, explore los casos de uso de Remote Config y eche un vistazo a algunos de los conceptos clave y la documentación de estrategias avanzadas, que incluyen:

• Administrar versiones de plantillas de Remote Config
• Configurar estrategias de carga