Premiers pas avec Firebase Remote Config


Vous pouvez utiliser Firebase Remote Config pour définir des paramètres dans votre application et mettre à jour leurs valeurs dans le cloud, vous permettant ainsi de modifier l'apparence et le comportement de votre application sans distribuer de mise à jour d'application. Ce guide vous guide à travers les étapes de démarrage et fournit des exemples de code, tous disponibles pour être clonés ou téléchargés à partir du référentiel GitHub Firebase/quickstart-android .

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

  1. Si vous ne l'avez pas déjà fait, ajoutez Firebase à votre projet Android .

  2. Pour Remote Config, Google Analytics est requis pour le ciblage conditionnel des instances d'application sur les propriétés et les audiences des utilisateurs. 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 configuration à distance bibliothèque pour Android. Nous vous recommandons d'utiliser la BoM Android Firebase pour contrôler la gestion des versions de la bibliothèque.

    De plus, dans le cadre de la configuration d'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:32.7.2"))
    
        // 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) Ajouter des dépendances de la bibliothèque Firebase sans utiliser la BoM

    Si vous choisissez de ne pas utiliser la BoM Firebase, 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 fortement d'utiliser la BoM pour gérer les versions de 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:21.6.1")
        implementation("com.google.firebase:firebase-analytics:21.5.1")
    }
    
    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 s'appuyer sur le module de bibliothèque principal (pour plus de détails, consultez la FAQ sur cette initiative ).

Étape 2 : Obtenez l'objet singleton Remote Config

Obtenez une instance d'objet Remote Config et définissez l'intervalle de récupération minimum pour permettre des actualisations fréquentes :

Kotlin+KTX

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

Java

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

L'objet singleton est utilisé pour stocker les valeurs des paramètres par défaut dans l'application, récupérer les valeurs des paramètres mises à jour à partir du backend et contrôler le moment où les valeurs récupérées sont mises à la disposition de votre application.

Pendant le développement, il est recommandé de définir un intervalle de récupération minimum relativement faible. Voir Limitation pour plus d’informations.

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

Vous pouvez définir les valeurs des paramètres par défaut de 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 pour que les valeurs par défaut soient disponibles si aucune n'est définie dans le backend.

  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’exemple d’application de démarrage rapide Remote Config utilise un fichier XML pour définir les noms et valeurs des paramètres par défaut.

    Si vous avez déjà configuré les valeurs des paramètres backend de 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 :

    REPOS

    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 et 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 indiqué :

    Kotlin+KTX

    remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java

    mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Étape 4 : Obtenez les valeurs des paramètres à utiliser dans votre application

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

É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 de nouvelles valeurs par défaut côté serveur qui remplacent les valeurs de l'application en fonction de la logique conditionnelle ou du ciblage des utilisateurs souhaités. Cette section décrit les étapes de 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 les paramètres 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 Paramètres et conditions de configuration à distance .

Étape 6 : Récupérer et activer les valeurs

  1. Pour récupérer les valeurs des paramètres à 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ées dans l'objet Remote Config.
  2. Pour rendre les valeurs des paramètres récupérées 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, vous pouvez utiliser une requête fetchAndActivate() pour récupérer les valeurs du backend Remote Config et les rendre disponibles pour 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 valeurs de paramètres mises à jour affectent le comportement et l'apparence de votre application, vous devez activer les valeurs récupérées à un moment qui garantit une expérience fluide à votre utilisateur, par exemple la prochaine fois que l'utilisateur ouvrira votre application. Consultez les stratégies de chargement de Remote Config pour plus d’informations et des exemples.

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

Après avoir récupéré 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 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 version de Remote Config.

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

  1. Dans votre application, utilisez addOnConfigUpdateListener() pour commencer à écouter les mises à jour et récupérer automatiquement toutes les nouvelles valeurs de paramètres. Implémentez le rappel 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() {
                @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 prochaine fois que vous publierez une nouvelle version de votre configuration à distance, les appareils qui exécutent votre application et écoutent les modifications appelleront ConfigUpdateListener .

Étranglement

Si une application récupère trop de fois 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 5 requêtes d'extraction dans une fenêtre de 60 minutes (les versions les plus récentes ont des limites plus permissives).

Pendant le développement d'une application, vous souhaiterez peut-être récupérer et activer des configurations très fréquemment (plusieurs fois par heure) pour vous permettre d'itérer rapidement pendant que vous développez et testez votre application. Les mises à jour de configuration à distance 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 comptant jusqu'à 10 développeurs, vous pouvez définir temporairement un objet FirebaseRemoteConfigSettings avec un intervalle de récupération minimum faible ( setMinimumFetchIntervalInSeconds ) dans votre application.

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

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

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

Prochaines étapes

Si vous ne l'avez pas déjà fait, explorez les cas d'utilisation de la configuration à distance et jetez un œil à certains des concepts clés et des stratégies avancées, notamment: