Premiers pas avec Firebase Remote Config

iOS+ Android Web Flutter Unity C++

Important :Cette section décrit la procédure à suivre pour configurer Remote Config avec des clients mobiles et Web. Pour les environnements serveur, consultez la section Utiliser Remote Config dans les environnements serveur.

Vous pouvez utiliser Firebase Remote Config pour définir des paramètres dans votre application et mettre à jour leurs valeurs dans le cloud. Vous pouvez ainsi modifier l'apparence et le comportement de votre application sans distribuer de mise à jour. Ce guide vous explique comment commencer et fournit des exemples de code, tous disponibles à cloner ou à télécharger à partir du dépôt GitHub firebase/quickstart-android.

Étape 1: Ajoutez Firebase et le SDK Remote Config à votre application

1. Si ce n'est pas encore fait, ajoutez Firebase à votre projet Android.

2. Pour Remote Config, Google Analytics est requis pour le ciblage conditionnel des instances d'application avec des propriétés utilisateur et des audiences. Assurez-vous d'activer Google Analytics dans votre projet.

3. Dans le fichier Gradle de votre module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), ajoutez la dépendance pour la bibliothèque Remote Config pour Android. Nous vous recommandons d'utiliser Firebase Android BoM pour contrôler le contrôle des versions de la bibliothèque.

   De plus, lors de la configuration de Analytics, vous devez ajouter le SDK Firebase pour Google Analytics à votre application.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.15.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")
   }

   En utilisant Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

   (Alternative) Ajoutez des dépendances de bibliothèque Firebase sans utiliser BoM.

   Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier chaque version de la bibliothèque Firebase dans sa ligne de dépendance.

   Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, nous vous recommandons vivement d'utiliser BoM pour gérer les versions de la bibliothèque, ce qui garantit que toutes les versions sont 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:22.1.2")
       implementation("com.google.firebase:firebase-analytics:22.4.0")
   }

   Vous recherchez un module de bibliothèque spécifique à Kotlin ? À partir d'octobre 2023 (Firebase BoM 32.5.0), les développeurs Kotlin et Java peuvent dépendre du module de bibliothèque principal (pour en savoir plus, consultez les questions fréquentes sur cette initiative).

Remarque :Étant donné que le SDK Android dépend de l'API REST Remote Config, veillez à ne pas désactiver cette API, qui est activée par défaut dans un projet typique.

Étape 2: Obtenir l'objet singleton Remote Config

Obtenez une instance d'objet Remote Config et définissez l'intervalle minimal d'extraction pour effectuer régulièrement des actualisations:

Kotlin

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

L'objet singleton permet de stocker les valeurs de paramètre par défaut dans l'application, d'extraire les valeurs de paramètre mises à jour à partir du backend et de contrôler le moment où les valeurs extraites sont mises à la disposition de votre application.

Lors du développement, il est recommandé de définir un intervalle de récupération minimal relativement faible. Pour en savoir plus, consultez la section Limitation.

Étape 3: Définir les valeurs par défaut des paramètres dans l'application

Vous pouvez définir des valeurs de paramètre par défaut dans l'application dans l'objet Remote Config afin que votre application se comporte comme prévu avant de se connecter au backend Remote Config et que des valeurs par défaut soient disponibles si aucune n'est définie dans le backend.

Important :Ne stockez pas de données confidentielles dans les clés ou les valeurs de paramètres Remote Config. Les données Remote Config sont chiffrées en transit, mais les utilisateurs finaux peuvent accéder à n'importe quel paramètre Remote Config par défaut ou extrait qui est disponible pour leur instance d'application cliente.

1. Définissez un ensemble de noms de paramètres et de valeurs de paramètres par défaut à l'aide d'un objet Map ou d'un fichier de ressources XML stocké dans le dossier res/xml de votre application. L'application exemple du guide de démarrage rapide Remote Config utilise un fichier XML pour définir les noms et valeurs de paramètres par défaut.

   Si vous avez déjà configuré les valeurs de paramètre du backend Remote Config, vous pouvez télécharger un fichier XML généré qui inclut toutes les valeurs par défaut et l'enregistrer dans le répertoire res/xml de votre application:

   REST

   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
   

   Console Firebase

   1. Dans l'onglet Paramètres, ouvrez le menu, puis sélectionnez Télécharger les valeurs par défaut.

   2. Lorsque vous y êtes invité, activez .xml pour Android, puis cliquez sur Télécharger le fichier.

2. Ajoutez ces valeurs à l'objet Remote Config à l'aide de setDefaultsAsync(int), comme illustré:

   Kotlin

   remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

   Java

   mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Étape 4: Obtenez les valeurs de paramètre à utiliser dans votre application

Vous pouvez maintenant obtenir les valeurs des paramètres à partir de l'objet Remote Config. Si vous définissez des valeurs dans le backend, les extrayez, puis les activez, ces valeurs sont disponibles pour votre application. Sinon, vous obtenez les valeurs de paramètre dans l'application configurées à l'aide de setDefaultsAsync(int). Pour obtenir ces valeurs, appelez la méthode listée ci-dessous qui correspond au type de données attendu par votre application, en fournissant la clé de paramètre comme argument:

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

Étape 5: Définir les valeurs des paramètres dans le backend Remote Config

À l'aide de la console Firebase ou des API backend Remote Config, vous pouvez créer des valeurs par défaut côté serveur qui remplacent les valeurs dans l'application en fonction de la logique conditionnelle ou du ciblage utilisateur souhaités. Cette section décrit les étapes à suivre dans la console Firebase pour créer ces valeurs.

1. Dans la console Firebase, ouvrez votre projet.
2. Sélectionnez Remote Config dans le menu pour afficher le tableau de bord Remote Config.
3. Définissez des paramètres portant les mêmes noms que ceux que vous avez définis dans votre application. Pour chaque paramètre, vous pouvez définir une valeur par défaut (qui remplacera éventuellement la valeur par défaut correspondante dans l'application), et vous pouvez également définir des valeurs conditionnelles. Pour en savoir plus, consultez la section Paramètres et conditions Remote Config.

4. Si vous utilisez des conditions de signal personnalisées, définissez les attributs et leurs valeurs. Les exemples suivants montrent comment définir une condition de signal personnalisée.

   Kotlin

       val customSignals = customSignals {
           put("city", "Tokyo")
           put("preferred_event_category", "sports")
       }
   
       remoteConfig.setCustomSignals(customSignals)

   Java

       CustomSignals customSignals = new CustomSignals.Builder()
           .put("city", "Tokyo")
           .put("preferred_event_category", "sports")
           .build();
   
       mFirebaseRemoteConfig.setCustomSignals(customSignals);

Étape 6: Extrayez et activez les valeurs

1. Pour extraire les valeurs de paramètre du backend Remote Config, appelez la méthode fetch(). Toutes les valeurs que vous définissez dans le backend sont extraites et stockées dans l'objet Remote Config.

2. Pour mettre les valeurs de paramètre récupérées à la disposition de votre application, appelez la méthode activate().

   Si vous souhaitez extraire et activer des valeurs en un seul appel, vous pouvez utiliser une requête fetchAndActivate() pour extraire des valeurs du backend Remote Config et les mettre à la disposition de l'application:

   Kotlin

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

Étant donné que ces valeurs de paramètre mises à jour affectent le comportement et l'apparence de votre application, vous devez activer les valeurs extraites à un moment qui garantit une expérience fluide pour votre utilisateur, par exemple la prochaine fois qu'il ouvrira votre application. Pour en savoir plus et obtenir des exemples, consultez la section Stratégies de chargement de Remote Config.

Remarque :Si votre application n'est pas compilée avec Gradle, vous devez ajouter manuellement la ressource de chaîne google_app_id appropriée à votre application pour que Remote Config puisse s'initialiser. Le plug-in Gradle google-services l'ajoute normalement automatiquement, mais vous pouvez trouver la valeur appropriée dans le fichier google-services.json que vous téléchargez à partir de la console Firebase. Pour en savoir plus sur l'obtention de la valeur google_app_id à partir du fichier google-services.json, consultez la section Traiter le fichier JSON.

Étape 7: Écoutez les mises à jour en temps réel

Après avoir extrait les valeurs des paramètres, vous pouvez utiliser Remote Config en temps réel pour écouter les mises à jour du backend Remote Config. Remote Config en temps réel envoie des signaux aux appareils connectés lorsque des mises à jour sont disponibles et récupère automatiquement les modifications après avoir publié une nouvelle version de Remote Config.

Les mises à jour en temps réel sont prises en charge par le SDK Firebase pour Android v21.3.0 ou version ultérieure (Firebase BoM v31.2.4 ou version ultérieure).

Important:La Remote Config en temps réel nécessite également l'API en temps réel Firebase Remote Config, qui devrait déjà être activée pour vous. Pour vérifier, ouvrez la console Google Cloud, sélectionnez votre projet, puis ouvrez la page API et services. L'API doit être activée. Si elle est manquante ou non activée, cliquez sur Activer les API et les services, recherchez l'API Firebase Remote Config en temps réel, puis activez-la.

1. Dans votre application, utilisez addOnConfigUpdateListener() pour commencer à écouter les mises à jour et à extraire automatiquement les nouvelles valeurs de paramètre. Implémentez le rappel onUpdate() pour activer la configuration mise à jour.

   Kotlin

   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<Boolean>() {
               @Override
               public void onComplete(@NonNull Task<Boolean> task) {
                   displayWelcomeMessage();
               }
           });
       }
       @Override
       public void onError(FirebaseRemoteConfigException error) {
           Log.w(TAG, "Config update error with code: " + error.getCode(), error);
       }
   });

2. La prochaine fois que vous publierez une nouvelle version de votre Remote Config, les appareils qui exécutent votre application et écoutent les modifications appelleront ConfigUpdateListener.

Limitations

Si une application effectue trop de récupérations sur une courte période, les appels de récupération sont limités et le SDK renvoie FirebaseRemoteConfigFetchThrottledException. Avant la version 17.0.0 du SDK, la limite était de cinq requêtes de récupération sur une période de 60 minutes (les versions plus récentes ont des limites plus permissives).

Conseil:À partir de la version 21.3.0 du SDK Android (Firebase BoM 31.3.0 et versions ultérieures), vous pouvez utiliser Remote Config en temps réel pour extraire automatiquement les valeurs de paramètre mises à jour à partir du backend Remote Config dès qu'elles sont publiées, en ignorant tout paramètre d'intervalle de récupération minimal. Pour en savoir plus, consultez Écouter les mises à jour en temps réel.

Lors du développement de l'application, vous pouvez être amené à extraire et à activer des configurations très fréquemment (plusieurs fois par heure) pour vous permettre d'itérer rapidement lorsque vous développez et testez votre application. Les mises à jour Remote Config en temps réel contournent automatiquement le cache lorsque la configuration est mise à jour sur le serveur. Pour permettre une itération rapide sur un projet avec jusqu'à 10 développeurs, vous pouvez définir temporairement un objet FirebaseRemoteConfigSettings avec un intervalle d'extraction minimal faible (setMinimumFetchIntervalInSeconds) dans votre application.

L'intervalle de récupération minimal par défaut pour Remote Config est de 12 heures, ce qui signifie que les configurations ne seront pas récupérées à partir du backend plus d'une fois par période de 12 heures, quel que soit le nombre d'appels de récupération effectués. Plus précisément, l'intervalle de récupération minimal est déterminé dans l'ordre suivant:

1. Paramètre dans fetch(long)
2. Paramètre dans FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
3. La valeur par défaut est de 12 heures.

Pour définir l'intervalle de récupération minimal sur une valeur personnalisée, utilisez FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long).

N'oubliez pas que ce paramètre ne doit être utilisé que pour le développement, et non pour une application en production. Si vous ne testez votre application qu'avec une petite équipe de développement de 10 personnes, vous ne risquez pas d'atteindre les limites de quota horaires côté service. Toutefois, si vous avez déployé votre application auprès de milliers d'utilisateurs tests avec un intervalle de récupération minimal très faible, votre application atteindra probablement ce quota.

Étapes suivantes

Si ce n'est pas déjà fait, explorez les Remote Config cas d'utilisation et consultez certains des concepts clés et la documentation sur les stratégies avancées, y compris:

• Gérer les versions de modèles Remote Config
• Stratégies de chargement de la configuration