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-ios .

Étape 1 : Ajoutez Remote Config à votre application

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

  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. Créez l'objet singleton Remote Config, comme indiqué dans l'exemple suivant :

    Rapide

    remoteConfig = RemoteConfig.remoteConfig()
    let settings = RemoteConfigSettings()
    settings.minimumFetchInterval = 0
    remoteConfig.configSettings = settings

    Objectif c

    self.remoteConfig = [FIRRemoteConfig remoteConfig];
    FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init];
    remoteConfigSettings.minimumFetchInterval = 0;
    self.remoteConfig.configSettings = remoteConfigSettings;

Cet objet 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 Remote Config 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 2 : 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 NSDictionary ou d'un fichier plist .

    Si vous avez déjà configuré des valeurs de paramètres de backend de configuration distante, vous pouvez télécharger un fichier plist généré qui inclut toutes les valeurs par défaut et l'enregistrer dans votre projet Xcode.

    REPOS

    curl --compressed -D headers -H "Authorization: Bearer token -X GET https://firebaseremoteconfig.googleapis.com/v1/projects/my-project-id/remoteConfig:downloadDefaults?format=PLIST -o RemoteConfigDefaults.plist
    

    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 .plist pour iOS , puis cliquez sur Télécharger le fichier .

  2. Ajoutez ces valeurs à l'objet de configuration distant à l'aide setDefaults: . L'exemple suivant définit les valeurs par défaut dans l'application à partir d'un fichier PLIST:

    Rapide

    remoteConfig.setDefaults(fromPlist: "RemoteConfigDefaults")

    Objectif c

    [self.remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];

Étape 3: Obtenez des valeurs de paramètres à utiliser dans votre application

Vous pouvez maintenant obtenir des valeurs de paramètres à partir de l'objet de configuration distant. Si vous définissez plus tard des valeurs dans le backend de configuration distant, les récupérez, puis activez-les, 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 configValueForKey: fournissant la clé de paramètre comme argument.

Étape 4: définir les valeurs des paramètres

À l'aide de la console Firebase ou des API Backend de configuration distante , vous pouvez créer de nouvelles valeurs par défaut de backend qui remplacent les valeurs intégrées à l'application en fonction de la logique conditionnelle ou du ciblage utilisateur souhaité. Cette section vous guide à travers 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 finira par remplacer la valeur par défaut en application) et vous pouvez également définir des valeurs conditionnelles. Pour en savoir plus, consultez les paramètres et conditions de configuration distants .

Étape 5: récupérer et activer les valeurs

Pour récupérer les valeurs des paramètres à partir de la configuration distante, appelez le fetchWithCompletionHandler: ou fetchWithExpirationDuration:completionHandler: Méthode. Toutes les valeurs que vous définissez sur le backend sont récupérées et mises en cache dans l'objet de configuration distante.

Pour les cas où vous souhaitez récupérer et activer les valeurs en un seul appel, utilisez fetchAndActivateWithCompletionHandler: .

Cet exemple récupère les valeurs du backend de configuration distant (non cached valeurs) et les appels activateWithCompletionHandler: pour les rendre à la disposition de l'application:

Rapide

remoteConfig.fetch { (status, error) -> Void in
  if status == .success {
    print("Config fetched!")
    self.remoteConfig.activate { changed, error in
      // ...
    }
  } else {
    print("Config not fetched")
    print("Error: \(error?.localizedDescription ?? "No error available.")")
  }
  self.displayWelcome()
}

Objectif c

[self.remoteConfig fetchWithCompletionHandler:^(FIRRemoteConfigFetchStatus status, NSError *error) {
    if (status == FIRRemoteConfigFetchStatusSuccess) {
        NSLog(@"Config fetched!");
      [self.remoteConfig activateWithCompletion:^(BOOL changed, NSError * _Nullable error) {
        if (error != nil) {
          NSLog(@"Activate error: %@", error.localizedDescription);
        } else {
          dispatch_async(dispatch_get_main_queue(), ^{
            [self displayWelcome];
          });
        }
      }];
    } else {
        NSLog(@"Config not fetched");
        NSLog(@"Error %@", error.localizedDescription);
    }
}];

É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 assure une expérience fluide pour votre utilisateur, comme la prochaine fois que l'utilisateur ouvre votre application. Voir les stratégies de chargement de configuration distantes pour plus d'informations et d'exemples.

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

Après avoir récupéré les valeurs des paramètres, vous pouvez utiliser la configuration à distance en temps réel pour écouter les mises à jour du backend de configuration distante. Les signaux de configuration distants en temps réel vers les périphériques connectés lorsque les mises à jour sont disponibles et récupère automatiquement les modifications après avoir publié une nouvelle version de configuration distante.

Les mises à jour en temps réel sont prises en charge par le SDK Firebase pour les plates-formes Apple V10.7.0 + et plus.

  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. L'exemple suivant écoute les mises à jour et lorsque activateWithCompletionHandler est appelé, utilise les valeurs nouvellement récupérées pour afficher un message de bienvenue mis à jour.

    Rapide

    remoteConfig.addOnConfigUpdateListener { configUpdate, error in
      guard let configUpdate, error == nil else {
        print("Error listening for config updates: \(error)")
      }
    
      print("Updated keys: \(configUpdate.updatedKeys)")
    
      self.remoteConfig.activate { changed, error in
        guard error == nil else { return self.displayError(error) }
        DispatchQueue.main.async {
          self.displayWelcome()
        }
      }
    }
    

    Objectif c

    __weak __typeof__(self) weakSelf = self;
    [self.remoteConfig addOnConfigUpdateListener:^(FIRRemoteConfigUpdate * _Nonnull configUpdate, NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error listening for config updates %@", error.localizedDescription);
      } else {
        NSLog(@"Updated keys: %@", configUpdate.updatedKeys);
    
        __typeof__(self) strongSelf = weakSelf;
        [strongSelf.remoteConfig activateWithCompletion:^(BOOL changed, NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Activate error %@", error.localizedDescription);
          }
    
          dispatch_async(dispatch_get_main_queue(), ^{
            [strongSelf displayWelcome];
          });
        }];
      }
    }];
    
  2. La prochaine fois que vous publiez une nouvelle version de votre configuration distante, les appareils qui exécutent votre application et écoutent les modifications appellent le gestionnaire d'achèvement.

Étranglement

Si une application récupère trop de fois dans une courte période, les appels de récupération sont étranglés et le SDK renvoie FIRRemoteConfigFetchStatusThrottled . Avant le SDK version 6.3.0, la limite était de 5 demandes de récupération dans une fenêtre de 60 minutes (les versions plus récentes ont des limites plus permissives).

Pendant le développement des applications, vous voudrez peut-être aller plus souvent pour actualiser le cache très fréquemment (plusieurs fois par heure) pour vous permettre d'itérer rapidement à mesure 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 accueillir une itération rapide sur un projet avec de nombreux développeurs, vous pouvez temporairement ajouter une propriété FIRRemoteConfigSettings avec un faible intervalle de récupération minimum ( MinimumFetchInterval ) dans votre application.

L'intervalle de récupération de production par défaut et recommandé pour la configuration distante est de 12 heures, ce qui signifie que les configurations ne seront pas récupérées à partir du 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 minimale est déterminé dans cet ordre suivant:

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

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: