Verbreiten Sie Remote Config-Updates in Echtzeit

Mithilfe der von Cloud Functions for Firebase zusammen mit FCM bereitgestellten Remote Config-Hintergrundfunktionsauslösung können Sie Remote Config-Updates in Echtzeit verbreiten. In diesem Szenario erstellen Sie eine Funktion, die ausgelöst wird, wenn Sie Ihre Remote Config-Vorlage über das Dashboard oder die API veröffentlichen oder zurücksetzen. Die Vorlagenaktualisierung löst die Funktion aus, um eine FCM-Nachricht zu senden, um Clients darüber zu informieren, dass ihre vorhandene Konfiguration veraltet ist und dass ihr nächster Abruf vom Server erfolgen sollte:

Der Rest dieses Dokuments führt Sie durch diese Schritte, um Remote Config-Updates in Echtzeit zu verbreiten.

Abonnieren Sie Client-App-Instanzen für ein FCM-Thema

Für die Ausrichtung einer FCM-Nachricht an eine große Gruppe von Client-App-Instanzen, z. B. Ihre gesamte Benutzerbasis, ist Themennachrichten der effizienteste Mechanismus. Jede App-Instanz, die Remote Config-Updates in Echtzeit erhalten soll, muss einen Themennamen wie beispielsweise PUSH_RC abonnieren:

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

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

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

Erstellen Sie eine Funktion zum Senden eines FCM-Pings bei Vorlagenaktualisierungen

Sie können eine Funktion als Reaktion auf Remote Config-Ereignisse auslösen, einschließlich der Veröffentlichung einer neuen Konfigurationsversion oder des Rollbacks auf eine ältere Version. Um Vorlagenaktualisierungen in Echtzeit zu verbreiten, erstellen Sie eine Funktion, die auf Vorlagenveröffentlichungsereignisse wartet, und verwenden Sie dann das FCM Admin SDK von Ihrer Funktion, um einen unbeaufsichtigten Ping an Client-App-Instanzen zu senden:

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

Diese Funktion setzt einen CONFIG_STATE Parameter und sendet diesen dann als Datennutzlast einer FCM-Nachricht an alle Clients, die das PUSH_RC Thema abonniert haben.

Legen Sie den Status „Remote Config“ auf dem Client fest

Die im vorherigen Schritt gezeigte Datennutzlast setzt CONFIG_STATE in den freigegebenen Einstellungen der App immer auf STALE . Dies weist darauf hin, dass die bereits in der App gespeicherte Remote Config-Vorlage jetzt veraltet ist, da die neue, aktualisierte Vorlage erstellt wurde, deren Veröffentlichung die Funktion ausgelöst hat. Aktualisieren Sie Ihren Benachrichtigungs-Handler, um diese Bedingung zu testen:

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

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

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

Rufen Sie die Remote Config-Updates beim App-Start ab

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

- (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];
    }];
}
    

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"));
                }
            });
}
    

Fügen Sie Ihrer App schließlich Logik hinzu, um einen Remote-Konfigurationsabruf aus dem Netzwerk zu erzwingen (wobei der lokale Speicher ignoriert wird), da CONFIG_STATE STALE ist. Wenn Ihre App zu häufig Daten aus dem Netzwerk abruft, wird sie möglicherweise von Firebase gedrosselt. Siehe Drosselung .