Propaguj aktualizacje Remote Config w czasie rzeczywistym

Korzystając z wyzwalania funkcji Zdalnej konfiguracji w tle udostępnianej przez Cloud Functions dla Firebase wraz z FCM , możesz rozpowszechniać aktualizacje Zdalnej konfiguracji w czasie rzeczywistym. W tym scenariuszu tworzysz funkcję, która jest wyzwalana po opublikowaniu lub wycofaniu szablonu Zdalnej konfiguracji z pulpitu nawigacyjnego lub interfejsu API. Aktualizacja szablonu wyzwala funkcję, aby wysłać wiadomość FCM, aby poinformować klientów, że ich istniejąca konfiguracja jest przestarzała i że następne pobranie powinno pochodzić z serwera:

Pozostała część tego dokumentu przeprowadzi Cię przez te kroki, aby rozpowszechniać aktualizacje Zdalnej konfiguracji w czasie rzeczywistym.

Subskrybuj instancje aplikacji klienckich do tematu FCM

W przypadku kierowania wiadomości FCM do dużej grupy wystąpień aplikacji klienckich, takich jak cała baza użytkowników, najbardziej wydajnym mechanizmem jest przesyłanie komunikatów tematów. Każda instancja aplikacji, która powinna otrzymywać aktualizacje Zdalnej konfiguracji w czasie rzeczywistym, musi subskrybować nazwę tematu, taką jak na przykład PUSH_RC :

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

Utwórz funkcję do wysyłania pingów FCM w przypadku aktualizacji szablonów

Funkcję można wyzwolić w odpowiedzi na zdarzenia Remote Config, w tym publikację nowej wersji konfiguracji lub wycofanie do starszej wersji. Aby propagować aktualizacje szablonów w czasie rzeczywistym, utwórz funkcję, która nasłuchuje zdarzeń publikacji szablonu, a następnie użyj pakietu FCM Admin SDK ze swojej funkcji, aby wysłać cichy ping do instancji aplikacji klienckich:

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

Ta funkcja ustawia parametr CONFIG_STATE , a następnie wysyła go jako ładunek danych komunikatu FCM do wszystkich klientów subskrybujących temat PUSH_RC .

Ustaw stan zdalnej konfiguracji na kliencie

Ładunek danych pokazany w poprzednim kroku zawsze ustawia CONFIG_STATE na STALE we wspólnych preferencjach aplikacji. Oznacza to, że szablon zdalnej konfiguracji już przechowywany w aplikacji jest teraz nieaktualny z powodu utworzenia nowego, zaktualizowanego szablonu, którego publikacja wyzwoliła funkcję. Zaktualizuj moduł obsługi powiadomień, aby przetestować ten stan:

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

Pobierz aktualizacje Zdalnej konfiguracji podczas uruchamiania aplikacji

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

Na koniec dodaj logikę do swojej aplikacji, aby wymusić pobranie zdalnej konfiguracji z sieci (ignorując magazyn lokalny), ponieważ CONFIG_STATE jest STALE . Jeśli Twoja aplikacja jest zbyt często pobierana z sieci, może zostać zablokowana przez Firebase. Zobacz Ograniczanie .