Premiers pas avec Remote Config sur Android

Sélectionnez une plate-forme :

iOS+ Android Web Flutter Unity C++

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 d'application. Ce guide vous explique comment commencer et fournit un exemple de code que vous pouvez cloner ou télécharger à partir du dépôt GitHub firebase/quickstart-android.

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

Si ce n'est pas déjà fait, ajoutez Firebase à votre projet Android.
Pour Remote Config, Google Analytics est requis pour le ciblage conditionnel de propriétés utilisateur et d'audiences avec des instances d'application. Assurez-vous d'activer Google Analytics dans votre projet.
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 des dépendances pour les bibliothèques Remote Config et Analytics pour Android. Nous vous recommandons d'utiliser la Firebase Android BoM pour contrôler la gestion 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:34.12.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 les Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.
(Autre solution) Ajouter des dépendances de bibliothèque Firebase sans utiliser la BoM

Si vous choisissez de ne pas utiliser la 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 la 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:23.0.1")
    implementation("com.google.firebase:firebase-analytics:23.2.0")
}
```

Étape 2 : Extraire l'objet singleton Remote Config

Extrayez 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 est utilisé pour stocker les valeurs de paramètres par défaut dans l'application, extraire les valeurs de paramètres mises à jour à partir du backend et 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 minimal d'extraction relativement faible. Pour en savoir plus, consultez la section Limitations.

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

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

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

Si vous avez déjà configuré les valeurs des paramètres 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
```
Vous pouvez générer un jeton porteur en exécutant la commande suivante à l'aide de la Google Cloud CLI ou de Cloud Shell :
```
gcloud auth print-access-token
```
Ce jeton est éphémère. Vous devrez peut-être le régénérer si vous recevez une erreur d'authentification.
Firebase console
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.

Ajoutez ces valeurs à l'objet Remote Config à l'aide de setDefaultsAsync(int), comme indiqué ci-dessous :

Kotlin

remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

Java

mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

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

Vous pouvez désormais obtenir les valeurs de paramètre à partir de l'objet Remote Config. Si vous définissez des valeurs dans le backend, que vous les extrayez, puis que vous les activez, ces valeurs sont disponibles pour votre application. Sinon, vous obtenez les valeurs de paramètres dans l'application configurées à l'aide setDefaultsAsync(int). Pour obtenir ces valeurs, appelez la méthode listée dans le code suivant 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 de paramètres dans le backend Remote Config

À l'aide de la Firebase console ou des Remote Config backend API, 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 la procédure à suivre dans la console Firebase pour créer ces valeurs.

Dans la Firebase console, ouvrez votre projet.
Sélectionnez Remote Config dans le menu pour afficher le tableau de bord Remote Config.
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 finira par remplacer la valeur par défaut correspondante dans l'application) et des valeurs conditionnelles. Pour en savoir plus, consultez la section Remote Config Paramètres et conditions.

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 : Extraire et activer les valeurs

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

Pour mettre les valeurs de paramètres extraites à la disposition de votre application, appelez la activate() méthode.

Si vous souhaitez extraire et activer des valeurs en un seul appel, vous pouvez utiliser une requête fetchAndActivate() pour extraire des valeurs du Remote Config backend 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ètres 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 ouvre votre application. Pour en savoir plus et obtenir des exemples, consultez Stratégies de chargement de Remote Config.

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

Une fois que vous avez extrait les valeurs de paramètres, vous pouvez utiliser Remote Config en temps réel pour écouter les mises à jour du backend Remote Config. Real-time Remote Config signale aux appareils connectés lorsque des mises à jour sont disponibles et extrait automatiquement les modifications après la publication d'une nouvelle Remote Config version.

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

Dans votre application, utilisez addOnConfigUpdateListener() pour commencer à écouter les mises à jour et extraire automatiquement toutes les nouvelles valeurs de paramètres. 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);
        }
    });

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

Limitations

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

Lors du développement d'une application, vous pouvez extraire et activer des configurations très fréquemment (plusieurs fois par heure) pour itérer rapidement lors du développement et du test de votre application. Les mises à jour de 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 minimal d'extraction faible (setMinimumFetchIntervalInSeconds) dans votre application.

L'intervalle minimal d'extraction par défaut pour Remote Config est de 12 heures, ce qui signifie que les configurations ne seront extraites du backend qu'une seule fois sur une période de 12 heures, quel que soit le nombre d'appels d'extraction réellement effectués. Plus précisément, l'intervalle minimal d'extraction est déterminé dans l'ordre suivant :

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

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

Premiers pas avec Remote Config sur Android Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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

Étape 2 : Extraire l'objet singleton Remote Config

Kotlin

Java

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

REST

Firebase console

Kotlin

Java

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

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

Kotlin

Java

Étape 6 : Extraire et activer les valeurs

Kotlin

Java

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

Kotlin

Java

Limitations

Premiers pas avec Remote Config sur Android