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 pouvez ainsi modifier l'apparence et le comportement de votre application sans distribuer de mise à jour. Ce guide vous explique les étapes à suivre pour vous lancer et fournit un exemple de code. Vous pouvez tous les cloner ou les télécharger à partir du dépôt GitHub firebase/quickstart-ios.

Étape 1: Ajoutez Remote Config à votre application

  1. Si ce n'est pas encore fait, ajoutez Firebase à votre projet Apple.

  2. Pour Remote Config, Google Analytics est requis pour le ciblage conditionnel des instances d'application avec des propriétés utilisateur et des audiences. Assurez-vous d'activer Google Analytics dans votre projet.

  3. Créez l'objet Remote Config singleton, comme illustré dans l'exemple suivant:

    Swift

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

    Objective-C

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

Cet objet permet de stocker les valeurs de paramètre par défaut dans l'application, de récupérer les valeurs de paramètre mises à jour à partir du backend Remote Config et de contrôler le moment où les valeurs récupérées sont mises à la disposition de votre application.

Lors du développement, nous vous recommandons de définir un intervalle de récupération minimal relativement faible. Pour en savoir plus, consultez la section Limitation.

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

Vous pouvez définir des valeurs de paramètre par défaut dans 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 que des 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é les valeurs de paramètre du backend Remote Config, 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.

    REST

    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, puis sélectionnez Télécharger les valeurs par défaut.

    2. Lorsque vous y êtes invité, activez le fichier .plist pour iOS, puis cliquez sur Télécharger le fichier.

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

    Swift

    remoteConfig.setDefaults(fromPlist: "RemoteConfigDefaults")

    Objective-C

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

Étape 3: Obtenez les valeurs de paramètre à utiliser dans votre application

Vous pouvez maintenant obtenir les valeurs des paramètres à partir de l'objet Remote Config. Si vous définissez ultérieurement des valeurs dans le backend Remote Config, les extrayez, puis les activez, ces valeurs sont disponibles pour votre application. Sinon, vous obtenez les valeurs de paramètre dans l'application configurées à l'aide de setDefaults:. Pour obtenir ces valeurs, appelez la méthode configValueForKey: en 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 Remote Config, vous pouvez créer de nouvelles valeurs backend par défaut qui remplacent les valeurs dans l'application en fonction de la logique conditionnelle ou du ciblage utilisateur souhaités. Cette section vous guide tout au long des étapes de création de ces valeurs dans la console Firebase.

  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 ceux 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 dans l'application) et vous pouvez également définir des valeurs conditionnelles. Pour en savoir plus, consultez la section Paramètres et conditions Remote Config.

Étape 5: Extrayez et activez les valeurs

Pour extraire les valeurs de paramètre de Remote Config, appelez la méthode fetchWithCompletionHandler: ou fetchWithExpirationDuration:completionHandler:. Toutes les valeurs que vous définissez sur le backend sont récupérées et mises en cache dans l'objet Remote Config.

Si vous souhaitez extraire et activer des valeurs en un seul appel, utilisez fetchAndActivateWithCompletionHandler:.

Cet exemple extrait des valeurs du backend Remote Config (valeurs non mises en cache) et appelle activateWithCompletionHandler: pour les mettre à la disposition de l'application:

Swift

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

Objective-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 extraites à un moment qui garantit une expérience fluide à votre utilisateur, par exemple la prochaine fois qu'il ouvrira votre application. Pour en savoir plus et obtenir des exemples, consultez Stratégies de chargement Remote Config.

Étape 6: É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 envoie des signaux 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 compatibles avec le SDK Firebase pour les plates-formes Apple version 10.7.0 ou ultérieure.

  1. Dans votre application, appelez addOnConfigUpdateListener pour commencer à écouter les mises à jour et à extraire automatiquement les nouvelles valeurs de paramètre ou celles mises à jour. L'exemple suivant écoute les mises à jour et, lorsque activateWithCompletionHandler est appelé, utilise les valeurs nouvellement extraites pour afficher un message d'accueil mis à jour.

    Swift

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

    Objective-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 publierez une nouvelle version de votre Remote Config, les appareils qui exécutent votre application et écoutent les modifications appelleront le gestionnaire de finalisation.

Limitations

Si une application effectue trop de récupérations sur une courte période, les appels de récupération sont limités et le SDK renvoie FIRRemoteConfigFetchStatusThrottled. Avant la version 6.3.0 du SDK, la limite était de 5 requêtes d'extraction dans une fenêtre de 60 minutes (les versions plus récentes présentaient des limites plus permissives).

Au cours du développement de l'application,vous souhaiterez peut-être effectuer une récupération plus fréquente pour actualiser le cache très fréquemment (plusieurs fois par heure) afin de vous permettre d'effectuer rapidement des itérations lorsque vous développez et testez votre application. Les mises à jour Remote Config en temps réel contournent automatiquement le cache lorsque la configuration est mise à jour sur le serveur. Pour vous adapter à l'itération rapide sur un projet avec de nombreux développeurs, vous pouvez ajouter temporairement une propriété FIRRemoteConfigSettings avec un intervalle de récupération minimal faible (MinimumFetchInterval) dans votre application.

L'intervalle de récupération en production par défaut et recommandé pour Remote Config est de 12 heures. Cela signifie que les configurations ne seront pas extraites du backend plus d'une fois par période de 12 heures, quel que soit le nombre d'appels d'extraction réellement effectués. Plus précisément, l'intervalle d'extraction minimal est déterminé dans l'ordre suivant:

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

Étapes suivantes

Si ce n'est pas déjà fait, explorez les Remote Config cas d'utilisation et consultez certains des concepts clés et la documentation sur les stratégies avancées, y compris: