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. Ce guide vous explique comment commencer et fournit des exemples de code, que vous pouvez cloner ou télécharger à partir du dépôt GitHub firebase/quickstart-ios.

Étape 1 : Ajouter Remote Config à votre application

Si ce n'est pas encore fait, ajoutez Firebase à votre projet Apple.
Pour Remote Config, Google Analytics est requis pour le ciblage conditionnel de propriétés utilisateur et d'audiences avec des instances d'application. Assurez-vous d'activer Google Analytics dans votre projet.

Créez l'objet singleton Remote Config comme indiqué dans l'exemple suivant :

Swift

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

Objective-C

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

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

Lors du développement, il est recommandé de définir un intervalle d'extraction minimal relativement faible. Pour en savoir plus, consultez la section Limitations.

Étape 2 : Définir les valeurs de paramètre 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 . Ainsi, votre application se comporte comme prévu avant de se connecter au backend Remote Config, et des valeurs par défaut sont disponibles si aucune n'est définie dans le backend.

Définissez un ensemble de noms de paramètres et de valeurs de paramètre par défaut à l'aide d'un NSDictionary objet 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
```
Vous pouvez générer un jeton porteur en exécutant la commande suivante à l'aide de la Google Cloud CLI ou de Cloud Shell :
```
gcloud auth print-access-token
```
Ce jeton a une courte durée de vie. Vous devrez peut-être le regénérer si vous recevez une erreur d'authentification.
Firebase console
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 .plist pour iOS, puis cliquez sur Télécharger le fichier.

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.remoteConfig().setDefaults(fromPlist: "RemoteConfigDefaults")MigratedSnippets.swift

Objective-C

[remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];ObjCMigratedSnippets.m

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

Vous pouvez désormais obtenir les valeurs de paramètre à partir de l'objet Remote Config. Si vous définissez ultérieurement des valeurs dans le Remote Config backend, extrayez-les, puis activez-les. Ces valeurs seront alors 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 configValueForKey: méthode, en fournissant la clé de paramètre comme 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 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 sécurisée

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 de simplifier 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 opérations suivantes :

Définir des structures de configuration complexes.
Analyser automatiquement les configurations JSON.
Garantir la sécurité des types lors de l'accès 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 une configuration déclarative dans SwiftUI

Les wrappers de propriété sont une fonctionnalité puissante de Swift 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 aux valeurs Remote Config dans SwiftUI de manière déclarative, avec une prise en charge intégrée des valeurs par défaut et une gestion de la configuration simplifiée.

É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 par défaut dans le backend qui remplacent les valeurs dans l'application en fonction de la logique conditionnelle ou du ciblage utilisateur souhaités. Cette section vous explique comment créer ces valeurs dans la Firebase console étapes.

Dans la Firebase console, ouvrez votre projet.
Sélectionnez Remote Config dans le menu pour afficher le tableau de bord Remote Config.
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 finira par remplacer la valeur par défaut dans l'application) et des valeurs conditionnelles. Pour en savoir plus, consultez la section Remote Config Paramètres et conditions.

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 : Extraire et activer les valeurs

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

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

Cet exemple extrait les valeurs du Remote Config backend (et non les valeurs mises en cache ) et appelleactivateWithCompletionHandler: 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.")")
  }
}MigratedSnippets.swift

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);
  }
}];ObjCMigratedSnippets.m

Étant donné que ces valeurs de paramètre 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 pour votre utilisateur, par exemple la prochaine fois qu'il ouvre votre application. Pour en savoir plus et obtenir des exemples, consultez Stratégies de chargement de Remote Config.

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

Une fois que vous avez extrait les valeurs de paramètre, vous pouvez utiliser Remote Config en temps réel pour écouter les mises à jour du backend Remote Config. Real-time Remote Config signale aux appareils connectés lorsque des mises à jour sont disponibles et extrait automatiquement les modifications après la publication d'une nouvelle Remote Config version.

Les mises à jour en temps réel sont compatibles avec le Firebase SDK pour les plates-formes Apple v10.7.0 et versions ultérieures.

Dans votre application, appelez addOnConfigUpdateListener pour commencer à écouter les mises à jour et extraire automatiquement les valeurs de paramètre nouvelles ou mises à jour. L'exemple suivant écoute les mises à jour et, lorsque activateWithCompletionHandler est appelé, utilise les nouvelles valeurs extraites 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];
        });
      }];
    }
  }];

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 saisie semi-automatique.

Limitations

Si une application extrait trop de fois sur une courte période, les appels d'extraction sont limités et le SDK renvoie FIRRemoteConfigFetchStatusThrottled. Avant la version 6.3.0 du SDK, la limite était de cinq requêtes d'extraction sur une période de 60 minutes (les versions plus récentes ont des limites plus permissives).

Lors du développement d'une application,vous pouvez extraire plus souvent pour actualiser le cache très fréquemment (plusieurs fois par heure). Cela vous permet d'itérer rapidement lors du développement et du 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 avec de nombreux développeurs, vous pouvez ajouter temporairement une propriété FIRRemoteConfigSettings avec un intervalle d'extraction minimal faible (MinimumFetchInterval) dans votre application.

L'intervalle d'extraction de production par défaut et recommandé pour Remote Config est de 12 heures. Cela signifie que les configurations ne seront extraites du backend qu'une seule fois sur une 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 :

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

Premiers pas avec Remote Config sur iOS Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Étape 1 : Ajouter Remote Config à votre application

Swift

Objective-C

Étape 2 : Définir les valeurs de paramètre par défaut dans l'application

REST

Firebase console

Swift

Objective-C

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

Utiliser Codable pour une configuration sécurisée

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

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

Swift

Objective-C

Étape 5 : Extraire et activer les valeurs

Swift

Objective-C

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

Swift

Objective-C

Limitations

Premiers pas avec Remote Config sur iOS