Premiers pas avec Firebase Remote Config

iOS ou version ultérieure Android Web Flutter Unity C++ .

Important :Cette section décrit les étapes à suivre pour configurer Remote Config avec clients mobiles et Web. Pour les environnements de serveur, consultez Utilisez Remote Config dans les environnements de 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 déjà fait, Ajoutez Firebase à votre projet Android.

2. Pour Remote Config, Google Analytics est obligatoire pour les Ciblage conditionnel des instances d'application aux propriétés utilisateur et aux audiences. Vérifiez que vous activez 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 la gestion des versions des bibliothèques.

   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.2.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, recommandent 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.0.0")
       implementation("com.google.firebase:firebase-analytics:22.1.0")
   }

   Vous recherchez un module de bibliothèque spécifique à Kotlin ? Début dans Octobre 2023 (Firebase BoM 32.5.0), les développeurs Kotlin et Java peuvent dépendent du module de bibliothèque principal (pour en savoir plus, consultez Questions fréquentes sur cette initiative).

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

Étape 2: Récupérez l'objet singleton Remote Config

Obtenez une instance d'objet Remote Config et définissez le Intervalle de récupération minimal requis pour des actualisations fréquentes:

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

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 depuis le backend, et contrôler à quel moment les valeurs sont récupérées mis à la disposition de votre application.

Pendant le développement, nous vous recommandons de définir une valeur d'extraction minimale relativement faible l'intervalle. 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ètres par défaut dans l'application dans Remote Config , afin que votre application se comporte comme prévu avant de se connecter Remote Config, et afin que les valeurs par défaut soient disponibles si aucune n'est dans le backend.

Important :Ne stockez pas de données confidentielles dans des clés de paramètre Remote Config ou valeurs. Les données Remote Config sont chiffrées en transit, mais les utilisateurs finaux peuvent y accéder tout paramètre Remote Config par défaut ou récupéré disponible pour leurs l'instance d'application cliente.

1. Définissez un ensemble de noms et de valeurs de paramètres par défaut à l'aide d'un Map ou un objet 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é Remote Config valeurs de paramètre de backend, vous pouvez télécharger un fichier XML généré qui inclut toutes les valeurs par défaut et enregistrez-le 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 Paramètres, ouvrez l'onglet 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 avec setDefaultsAsync(int), comme indiqué ci-dessous:

   Kotlin+KTX

   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 dans le backend, les récupérer, puis les activer, ces valeurs sont disponibles pour votre application. Sinon, vous obtenez des valeurs de paramètres configurées 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éfinissez les valeurs de paramètre dans le backend Remote Config

En utilisant la console Firebase ou la 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 de création de ces valeurs dans la console Firebase.

1. Dans la console Firebase, ouvrez votre projet.
2. Sélectionnez Remote Config dans le menu pour afficher les Remote Config. tableau de bord.
3. Définissez les paramètres en leur attribuant 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 remplacer éventuellement la valeur par défaut correspondante dans l'application), et vous pouvez aussi définir des valeurs conditionnelles. Pour en savoir plus, consultez Paramètres Remote Config et et conditions.

Étape 6 : Extrayez et activez les valeurs

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

2. Pour que les valeurs des paramètres récupérées soient disponibles pour votre application, appelez la méthode activate() .

   Dans les cas où vous souhaitez récupérer et activer des valeurs en un seul appel, Utilisez une requête fetchAndActivate() pour récupérer les valeurs Remote Config et mettez-les à la disposition de l'application:

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

Étant donné que ces nouvelles valeurs de paramètres ont une incidence sur le comportement et l'apparence de votre application, vous devez activer les valeurs récupérées à un moment une expérience fluide pour l'utilisateur, comme la prochaine fois qu'il ouvrira votre l'application. Consultez l'article Stratégies de chargement Remote Config. pour obtenir plus d'informations et d'exemples.

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 ajoute normalement cette automatiquement, mais vous trouverez la valeur appropriée dans le google-services.json que vous téléchargez à partir de la console Firebase. Pour plus d'informations sur l'obtention de la valeur google_app_id à partir de Fichier google-services.json, voir Traitement du fichier JSON.

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

Après avoir récupéré les valeurs des paramètres, vous pouvez utiliser des Remote Config en temps réel pour : écouter les mises à jour du backend Remote Config. En temps réel Remote Config signale aux appareils connectés lorsque des mises à jour sont disponibles et récupère automatiquement les modifications après la publication d'une nouvelle Remote Config version.

Les mises à jour en temps réel sont compatibles avec le SDK Firebase pour Android v21.3.0+ (Firebase BoM v31.2.4+).

Important:Les Remote Config en temps réel nécessitent également Firebase Remote Config l'API Realtime, qui devrait déjà être activée pour vous. Pour le vérifier, ouvrez le Console Google Cloud, sélectionnez votre projet, puis ouvrez la page API et services. L'API doit apparaissent comme activées. S'il est manquant ou s'il n'est pas activé, cliquez sur Activer les API et Services, recherchez API Realtime Firebase Remote Config, puis l'activer.

1. Dans votre application, utilisez addOnConfigUpdateListener() pour commencer à écouter les mises à jour et récupérer automatiquement les nouvelles valeurs de paramètres. Implémenter onUpdate() pour activer la configuration mise à jour.

   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<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 ConfigUpdateListener

Limitations

Si une application récupère trop de fois sur une courte période, les appels d'extraction sont est limitée et que le SDK renvoie FirebaseRemoteConfigFetchThrottledException Avant la version 17.0.0 du SDK, le La limite était de 5 requêtes de récupération en 60 minutes (les versions plus récentes ont des limites plus permissives).

Conseil:À partir du SDK Android 21.3.0 ou version ultérieure (Firebase BoM v31.3.0 ou version ultérieure), vous pouvez utiliser les données Remote Config pour récupérer automatiquement les valeurs de paramètre mises à jour à partir de Remote Config dès leur publication, en contournant les minimums paramètre d'intervalle de récupération. Pour en savoir plus, consultez la section Écouter pour obtenir des mises à jour en temps réel.

Lors du développement de l'application, vous pouvez souhaiter extraire et activer des configurations très fréquemment (plusieurs fois par heure) pour vous permettre de parcourir rapidement le développement et le test de 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 s'adapter à une itération rapide sur un projet avec un maximum de 10 développeurs, vous pouvez définir temporairement Objet FirebaseRemoteConfigSettings avec un intervalle de récupération 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 extraites du backend plus d'une fois toutes les 12 heures quel que soit le nombre d'appels réellement effectués. Plus précisément, l'intervalle de récupération minimal est déterminé dans l'ordre suivant:

1. Le paramètre dans fetch(long)
2. Paramètre dans FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
3. La valeur par défaut 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 exécutée en production. Si vous utilisez vous testez votre application auprès d'une petite équipe de développement de 10 personnes. n'atteindrait probablement pas les limites de quota horaires côté service. Mais si vous aviez déployé votre application des milliers d'utilisateurs tests avec un intervalle d'extraction minimal très faible, votre application a probablement atteint ce quota.

Étapes suivantes

Si vous ne l'avez pas déjà fait, explorez les Remote Config cas d'utilisation, et nous allons nous intéresser la documentation sur les concepts clés et les stratégies avancées, notamment:

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