Propager les mises à jour de Remote Config en temps réel

Utilisation de la fonction d'arrière - plan Config à distance fourni par le déclenchement des fonctions Cloud pour Firebase avec la FCM , vous pouvez propager à distance les mises à jour de configuration en temps réel. Dans ce scénario, vous créez une fonction qui se déclenche lorsque vous publiez ou restaurez votre modèle Remote Config à partir du tableau de bord ou de l'API. La mise à jour du modèle déclenche la fonction pour envoyer un message FCM pour informer les clients que leur configuration existante est obsolète et que leur prochaine récupération doit provenir du serveur :

Diagramme montrant une mise à jour de Remote Config déclenchant des alertes FCM via Cloud Functions

Le reste de ce document vous guide à travers ces étapes pour propager les mises à jour de Remote Config en temps réel.

Abonnez des instances d'application client à un sujet FCM

Pour cibler un message FCM sur un grand groupe d'instances d'applications clientes telles que l'ensemble de votre base d'utilisateurs, la messagerie thématique est le mécanisme le plus efficace. Chaque instance d'application qui doit recevoir en temps réel les mises à jour à distance Config doit souscrire à un nom de sujet comme, par exemple, PUSH_RC :

Rapide

extension AppDelegate : MessagingDelegate {
    func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String) {
        messaging.subscribe(toTopic: "PUSH_RC") { error in
            print("Subscribed to PUSH_RC topic")
        }
    }
}
    

Objectif c

- (void)messaging:(FIRMessaging *)messaging didReceiveRegistrationToken:(NSString *)fcmToken {
    [[FIRMessaging messaging] subscribeToTopic:@"PUSH_RC" completion:^(NSError * _Nullable error) {
        NSLog(@"Subscribed to PUSH_RC topic");
    }];
}
    

Android

@Override
public void onNewToken(String s) {
    FirebaseMessaging.getInstance().subscribeToTopic("PUSH_RC");
}
    

Créer une fonction pour envoyer un ping FCM sur les mises à jour du modèle

Vous pouvez déclencher une fonction en réponse à des événements de configuration à distance, notamment la publication d'une nouvelle version de configuration ou le retour à une ancienne version. Pour propager les mises à jour de modèle en temps réel, créez une fonction qui écoute les événements de publication de modèle, puis utilisez le SDK Admin FCM de votre fonction pour envoyer un ping silencieux aux instances d'application client :

exports.pushConfig = functions.remoteConfig.onUpdate(versionMetadata => {
  // Create FCM payload to send data message to PUSH_RC topic.
  const payload = {
    topic: "PUSH_RC",
    data: {
      "CONFIG_STATE": "STALE"
    }
  };
  // Use the Admin SDK to send the ping via FCM.
  return admin.messaging().send(payload).then(resp => {
    console.log(resp);
    return null;
  });
});

Cette fonction définit un CONFIG_STATE paramètre et envoie ensuite que la charge utile de données d'un message de la FCM à tous les clients abonnés au PUSH_RC sujet.

Définir l'état de la configuration à distance sur le client

La charge utile de données dans l'étape précédente définit toujours CONFIG_STATE à STALE dans les préférences partagées de l'application. Cela indique que le modèle Remote Config déjà stocké sur l'application est désormais obsolète en raison de la création du nouveau modèle mis à jour dont la publication a déclenché la fonction. Mettez à jour votre gestionnaire de notifications pour tester cette condition :

Rapide

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any],
                 fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {

    if (userInfo.index(forKey: "CONFIG_STATE") != nil) {
        print("Config set to stale")
        UserDefaults.standard.set(true, forKey:"CONFIG_STALE")
    }

    completionHandler(UIBackgroundFetchResult.newData)
}
    

Objectif c

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {

    if (userInfo[@"CONFIG_STATE"]) {
        NSLog(@"Config set to stale");
        [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"CONFIG_STALE"];
    }

    completionHandler(UIBackgroundFetchResultNewData);
}
    

Android

@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
    if (remoteMessage.getData().containsKey("CONFIG_STATE")) {
        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
        sharedPreferences.edit().putBoolean("CONFIG_STALE", true).apply();
    }
}
    

Récupérer les mises à jour de Remote Config au démarrage de l'application

Rapide

func fetchConfig() {
  welcomeLabel.text = remoteConfig[loadingPhraseConfigKey].stringValue

  var expirationDuration = 3600
  // If your app is using developer mode, expirationDuration is set to 0, so each fetch will
  // retrieve values from the service.
  if remoteConfig.configSettings.isDeveloperModeEnabled || UserDefaults.standard.bool(forKey: "CONFIG_STALE") {
    expirationDuration = 0
  }

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

Objectif c

- (void)fetchConfig {
    self.welcomeLabel.text = self.remoteConfig[kLoadingPhraseConfigKey].stringValue;

    long expirationDuration = 3600;
    // If your app is using developer mode, expirationDuration is set to 0, so each fetch will
    // retrieve values from the Remote Config service.
    if (self.remoteConfig.configSettings.isDeveloperModeEnabled || [[NSUserDefaults standardUserDefaults] boolForKey:@"CONFIG_STALE"]) {
        expirationDuration = 0;
    }

    [self.remoteConfig fetchWithExpirationDuration:expirationDuration completionHandler:^(FIRRemoteConfigFetchStatus status, NSError *error) {
        if (status == FIRRemoteConfigFetchStatusSuccess) {
            NSLog(@"Config fetched!");
            [self.remoteConfig activateFetched];
            [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"CONFIG_STALE"];
        } else {
            NSLog(@"Config not fetched");
            NSLog(@"Error %@", error.localizedDescription);
        }
        [self displayWelcome];
    }];
}
    

Android

private void fetchWelcomeMessage() {
    mWelcomeTextView.setText(mFirebaseRemoteConfig.getString("loading_phrase"));

    long cacheExpiration = 43200; // 12 hours in seconds.
    // If your app is using developer mode or cache is stale, cacheExpiration is set to 0,
    // so each fetch will retrieve values from the service.
    if (mFirebaseRemoteConfig.getInfo().getConfigSettings().isDeveloperModeEnabled() ||
            mSharedPreferences.getBoolean("CONFIG_STALE", false)) {
        cacheExpiration = 0;
    }

    mFirebaseRemoteConfig.fetch(cacheExpiration)
            .addOnCompleteListener(this, new OnCompleteListener<Void>() {
                @Override
                public void onComplete(@NonNull Task<Void> task) {
                    if (task.isSuccessful()) {
                        Toast.makeText(MainActivity.this, "Fetch Succeeded",
                                Toast.LENGTH_SHORT).show();

                        // After config data is successfully fetched, it must be activated before newly fetched
                        // values are returned.
                        mFirebaseRemoteConfig.activateFetched();
                    } else {
                        Toast.makeText(MainActivity.this, "Fetch Failed",
                                Toast.LENGTH_SHORT).show();
                    }
                    mWelcomeTextView.setText(mFirebaseRemoteConfig.getString("welcome_message"));
                }
            });
}
    

Enfin, ajouter une logique à votre application pour forcer une configuration à distance à partir chercher du réseau ( en ignorant le stockage local) parce CONFIG_STATE est STALE . Si votre application est récupérée trop fréquemment sur le réseau, elle peut être limitée par Firebase. Voir Throttling .