Premiers pas avec Remote Config sur iOS

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 faire vos premiers pas et fournit des exemples de code, que vous pouvez cloner ou télécharger depuis le dépôt GitHub firebase/quickstart-ios.

Étape 1 : Ajoutez Remote Config à votre application

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

  2. Pour Remote Config, Google Analytics est requis pour le ciblage conditionnel d'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 singleton Remote Config, comme illustré dans l'exemple suivant :

    Swift

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

    Objective-C

    FIRRemoteConfig *remoteConfig = [FIRRemoteConfig remoteConfig];
FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init];
remoteConfigSettings.minimumFetchInterval = 0;
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 quand 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 minimal relativement faible. Pour en savoir plus, consultez Limitation du débit.

Étape 2 : Définissez les valeurs de paramètre 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, 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 des paramètres de 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

    Vous pouvez générer un jeton de support 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 de courte durée. Vous devrez peut-être le générer à nouveau si vous obtenez une erreur d'authentification.

    Console Firebase

    1. Dans la console Firebase, accédez à la page DevOps et engagement > Remote Config > Paramètres.

    2. Ouvrez le Menu , puis sélectionnez Télécharger les valeurs par défaut.

    3. Lorsque vous y êtes invité, activez .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 de l'application à partir d'un fichier plist :

    Swift

    RemoteConfig.remoteConfig().setDefaults(fromPlist: "RemoteConfigDefaults")

    Objective-C

    [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, que vous les récupérez, puis que vous 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 en tant qu'argument.

let remoteConfig = RemoteConfig.remoteConfig()

// Retrieve a parameter value using configValueForKey
let welcomeMessageValue = remoteConfig.configValue(forKey: "welcome_message")
let welcomeMessage = welcomeMessageValue.stringValue

let featureFlagValue = remoteConfig.configValue(forKey: "new_feature_flag")
let isFeatureEnabled = featureFlagValue.boolValue

Une façon plus lisible et plus pratique d'accéder à ces valeurs dans Swift consiste à utiliser la notation d'indice de Swift :

let remoteConfig = RemoteConfig.remoteConfig()

// Retrieve a string parameter value
let welcomeMessage = remoteConfig["welcome_message"].stringValue

// Retrieve a boolean parameter value
let isFeatureEnabled = remoteConfig["new_feature_flag"].boolValue

// Retrieve a number parameter value
let maxItemCount = remoteConfig["max_items"].numberValue.intValue

Utiliser Codable pour une configuration de type sécurisé

Pour les configurations plus complexes, vous pouvez utiliser le protocole Codable de Swift pour décoder les données structurées de Remote Config. Cela permet de gérer la configuration de manière sécurisée et simplifie l'utilisation d'objets complexes.

// Define a Codable struct for your configuration
struct AppFeatureConfig: Codable {
  let isNewFeatureEnabled: Bool
  let maxUploadSize: Int
  let themeColors: [String: String]
}

// Fetch and decode the configuration
func configureAppFeatures() {
  let remoteConfig = RemoteConfig.remoteConfig()
  remoteConfig.fetchAndActivate { status, error in
    guard error == nil else { return }

    do {
      let featureConfig = try remoteConfig["app_feature_config"].decoded(asType: AppFeatureConfig.self)
      configureApp(with: featureConfig)
    } catch {
      // Handle decoding errors
      print("Failed to decode configuration: \(error)")
    }
  }
}

Cette méthode vous permet d'effectuer les actions suivantes :

  • Définir des structures de configuration complexes.
  • Analysez automatiquement les configurations JSON.
  • Assurez la sûreté du typage lorsque vous accédez aux valeurs Remote Config.
  • Fournir un code propre et lisible pour gérer les modèles Remote Config structurés.

Utiliser des wrappers de propriété pour la configuration déclarative dans SwiftUI

Les wrappers de propriété sont une fonctionnalité Swift puissante qui vous permet d'ajouter un comportement personnalisé aux déclarations de propriété. Dans SwiftUI, les wrappers de propriété sont utilisés pour gérer l'état, les liaisons et d'autres comportements de propriété. Pour en savoir plus, consultez le guide du langage Swift.

struct ContentView: View {
  @RemoteConfigProperty(key: "cardColor", fallback: "#f05138")
  var cardColor

  var body: some View {
    VStack {
      Text("Dynamic Configuration")
        .background(Color(hex: cardColor))
    }
    .onAppear {
      RemoteConfig.remoteConfig().fetchAndActivate()
    }
  }
}

Utilisez le wrapper de propriété @RemoteConfigProperty lorsque vous souhaitez accéder de manière déclarative aux valeurs Remote Config dans SwiftUI, avec une compatibilité intégrée pour les valeurs par défaut et une gestion simplifiée de la configuration.

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

À l'aide de la console Firebase ou des API de backend Remote Config, vous pouvez créer des valeurs par défaut de backend qui remplacent les valeurs intégrées à l'application en fonction de la logique conditionnelle ou du ciblage des utilisateurs souhaités. Cette section vous explique comment créer ces valeurs dans la console Firebase.

  1. Dans la console Firebase, accédez à la page DevOps et engagement > Remote Config > Paramètres.

  2. 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 Paramètres et conditions de Remote Config.

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

    Swift

        Task {
        let customSignals: [String: CustomSignalValue?] = [
        "city": .string("Tokyo"),
        "preferred_event_category": .string("sports")
      ]

      do {
        try await remoteConfig.setCustomSignals(customSignals)
        print("Custom signals set successfully!")
        } catch {
            print("Error setting custom signals: \(error)")
        }
  }

    Objective-C

        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
      NSDictionary *customSignals = @{
        @"city": @"Tokyo",
        @"preferred_event_category": @"sports"
      };

      [self.remoteConfig setCustomSignals:customSignals withCompletion:^(NSError * _Nullable error) {
          if (error) {
              NSLog(@"Error setting custom signals: %@", error);
          } else {
              NSLog(@"Custom signals set successfully!");
          }
    }];
});

Étape 5 : Extrayez et activez les valeurs

Pour récupérer les valeurs des paramètres à partir 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 récupérer et activer des valeurs en un seul appel, utilisez fetchAndActivateWithCompletionHandler:.

Cet exemple extrait les valeurs du backend Remote Config (et non les valeurs 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!")
    remoteConfig.activate { changed, error in
      // ...
    }
  } else {
    print("Config not fetched")
    print("Error: \(error?.localizedDescription ?? "No error available.")")
  }
}

Objective-C

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

Étant donné que ces valeurs de paramètre mises à jour affectent le comportement et l'apparence de votre application, vous devez activer les valeurs récupérées à un moment qui garantit une expérience fluide pour l'utilisateur, par exemple la prochaine fois qu'il ouvrira votre application. Pour en savoir plus et voir des exemples, consultez Stratégies de chargement de Remote Config.

Étape 6 : Écouter 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. La fonctionnalité en temps réel Remote Config signale aux appareils connectés que 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 v10.7.0 et versions ultérieures.

  1. Dans votre application, appelez addOnConfigUpdateListener pour commencer à écouter les mises à jour et récupérer automatiquement les valeurs de paramètre 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.

    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 qui écoutent les modifications appelleront le gestionnaire d'achèvement.

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 cinq requêtes de récupération sur une période de 60 minutes (les versions plus récentes ont des limites plus permissives).

Lors du développement de l'application, vous pouvez récupérer les données plus souvent pour actualiser le cache très fréquemment (plusieurs fois par heure) afin d'itérer rapidement pendant le développement et le test de 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 permettre une itération rapide sur un projet impliquant 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 de production par défaut et recommandé pour Remote Config est de 12 heures. Cela signifie que les configurations ne seront pas récupérées à partir du backend plus d'une fois par période 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 minimal est déterminé dans l'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