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.

La bibliothèque Remote Config est utilisée 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 Remote Config et contrôler le moment où les valeurs récupérées sont mises à la disposition de votre application. Pour en savoir plus, consultez Stratégies de chargement de Remote Config .

Étape 1 : Ajoutez Firebase à votre application

Avant de pouvoir utiliser Remote Config , vous devez :

• Enregistrez votre projet C++ et configurez-le pour utiliser Firebase.

  Si votre projet C++ utilise déjà Firebase, il est déjà enregistré et configuré pour Firebase.

• Ajoutez le SDK Firebase C++ à votre projet C++.

Notez que l'ajout de Firebase à votre projet C++ implique des tâches à la fois dans la console Firebase et dans votre projet C++ ouvert (par exemple, vous téléchargez les fichiers de configuration Firebase depuis la console, puis vous les déplacez dans votre projet C++).

Étape 2 : Ajoutez Remote Config à votre application

É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 sur 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 std::map<const char*, const char*> ou d'un std::map<const char*, firebase::Variant> .

   • En savoir plus sur firebase::Variant .

   Si vous avez déjà configuré les valeurs des paramètres backend de Remote Config, vous pouvez télécharger un fichier contenant ces paires clé/valeur et l'utiliser pour construire votre objet map . Pour plus d'informations, consultez Télécharger les valeurs par défaut du modèle de configuration à distance .

2. Ajoutez ces valeurs à l'objet Remote Config à l'aide de SetDefaults() .

É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 Remote Config, 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 SetDefaults() .

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 :

• GetBoolean()
• GetData()
• GetDouble()
• GetLong()
• GetString()

Étape 5 : Connectez votre application dans la console Firebase

Dans la console Firebase , ajoutez votre application à votre projet Firebase.

Étape 6 : Définir les valeurs des paramètres

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. For each parameter, you can set a default value (which will eventually override the in-app default value) and conditional values. To learn more, see Remote Config parameters and conditions .

Step 7: Fetch and activate values

1. To fetch parameter values from the Remote Config backend, call the Fetch() method. Any values that you set on the backend are fetched and cached in the Remote Config object.
2. To make fetched parameter values available to your app, call the ActivateFetched()

Step 8: Listen for updates in real time

After you fetch parameter values, you can use real-time Remote Config to listen for updates from the Remote Config backend. Real-time Remote Config signals to connected devices when updates are available and automatically fetches the changes after you publish a new Remote Config version.

Real-time updates are supported by the Firebase C++ SDK v11.0.0+ and higher for Android and Apple platforms.

1. In your app, call AddOnConfigUpdateListener to start listening for updates and automatically fetch any new or updated parameter values. The following example listens for updates and, when Activate is called, uses the newly fetched values to display an updated welcome message.

remote_config->AddOnConfigUpdateListener(
    [](firebase::remote_config::ConfigUpdate&& config_update,
       firebase::remote_config::RemoteConfigError remote_config_error) {
      if (remote_config_error != firebase::remote_config::kRemoteConfigErrorNone) {
        printf("Error listening for config updates: %d", remote_config_error);
      }
      // Search the `updated_keys` set for the key "welcome_message."
      // `updated_keys` represents the keys that have changed since the last
      // fetch.
      if (std::find(config_update.updated_keys.begin(),
                    config_update.updated_keys.end(),
                    "welcome_message") != config_update.updated_keys.end()) {
        remote_config->Activate().OnCompletion(
            [&](const firebase::Future& completed_future,
               void* user_data) {
              // The key "welcome_message" was found within `updated_keys` and
              // can be activated.
              if (completed_future.error() == 0) {
                DisplayWelcomeMessage();
              } else {
                printf("Error activating config: %d", completed_future.error());
              }
            },
            nullptr);
      }
    });

The next time you publish a new version of your Remote Config, devices that are running your app and listening for changes will call the config update listener.

Next steps

If you haven't already, explore the Remote Config use cases , and take a look at some of the key concepts and advanced strategies documentation, including:

• Manage Remote Config template versions
• Config loading strategies