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, ce qui vous permet de modifier l'apparence et le comportement de votre application sans distribuer de mise à jour.

La bibliothèque Remote Config permet de stocker les valeurs de paramètres par défaut dans l'application. récupérer les valeurs de paramètres mises à jour à partir du backend Remote Config ; contrôler à quel moment les valeurs extraites sont mises à la disposition de votre application. Pour en savoir plus, consultez la section Stratégies de chargement 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é. configurés pour Firebase.

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

Retrouvez les instructions détaillées concernant ces initiales des tâches de configuration dans Ajouter Firebase à votre environnement C++ projet.

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, si vous téléchargez les fichiers de configuration Firebase depuis la console, puis déplacez-les dans votre projet C++).

Étape 2: Ajoutez Remote Config à votre application

Android

Après avoir ajouté Firebase à votre application:

1. Créez une application Firebase en transmettant l'environnement et l'activité JNI:

   app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);

2. Initialisez la bibliothèque Remote Config, comme indiqué ci-dessous:

   ::firebase::remote_config::Initialize(app);

iOS+

Après avoir ajouté Firebase à votre application:

1. Créez une application Firebase:

   app = ::firebase::App::Create(::firebase::AppOptions());

2. Initialisez la bibliothèque Remote Config, comme illustré :

   ::firebase::remote_config::Initialize(app);

Étape 3: Définissez les valeurs des paramètres par défaut 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 est définie sur 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 de paramètres et de valeurs de paramètres par défaut à l'aide d'un un objet std::map<const char*, const char*> ou un std::map<const char*, firebase::Variant>.

   • En savoir plus sur firebase::Variant

   Si vous avez déjà configuré le paramètre backend Remote Config vous pouvez télécharger un fichier contenant ces paires pour construire votre objet map. Pour en savoir plus, consultez Télécharger Paramètres par défaut du modèle Remote Config.

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

Étape 4: Obtenez les valeurs de paramètres à 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 Remote Config, les récupérer, puis les activer, sont disponibles pour votre application. Sinon, vous obtenez le paramètre "in-app" configurées à l'aide de SetDefaults()

Pour obtenir ces valeurs, appelez la méthode indiquée ci-dessous qui correspond au type de données attendue par votre application, en fournissant la clé de paramètre en tant qu'argument:

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

Étape 5: Définissez 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 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 remplaceront finalement la valeur par défaut dans l'application) et les valeurs conditionnelles. Pour en savoir plus, consultez Paramètres et conditions Remote Config.

É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 sur le backend sont récupérées et mis en cache 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 ActivateFetched()

É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. 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 C++ Firebase v11.0.0 et versions ultérieures pour les plates-formes Android et Apple.

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 apparaître comme activée. S'il est manquant ou s'il n'est pas activé, cliquez sur Activer API et Services, recherchez Firebase Remote Config Realtime API, puis activez-la.

1. Dans votre application, appelez AddOnConfigUpdateListener pour commencer à écouter les mises à jour et récupérer automatiquement les valeurs de paramètres nouvelles ou mises à jour. Les éléments suivants : exemple écoute les mises à jour et, lorsque Activate est appelé, utilise le récupérées pour afficher un message de bienvenue mis à jour.

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

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

É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