Wprowadzenie do Zdalnej konfiguracji Firebase


Za pomocą Zdalnej konfiguracji Firebase możesz definiować parametry w aplikacji i aktualizować ich wartości w chmurze. Pozwala to zmieniać wygląd i działanie aplikacji bez jej aktualizowania. Ten przewodnik zawiera omówienie pierwszych kroków oraz przykładowy kod, który możesz skopiować lub pobrać z repozytorium GitHub firebase/quickstart-ios.

Krok 1. Dodaj Zdalną konfigurację do swojej aplikacji

  1. Dodaj Firebase do swojego projektu Apple, chyba że masz to już za sobą.

  2. Zdalna konfiguracja wymaga Google Analytics do kierowania warunkowego instancji aplikacji na odbiorców i właściwości użytkowników. Pamiętaj, aby włączyć Google Analytics w swoim projekcie.

  3. Utwórz obiekt Zdalnej konfiguracji singletonu, jak pokazano w tym przykładzie:

    Swift

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

    Objective-C

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

Ten obiekt służy do przechowywania domyślnych wartości parametrów w aplikacji, pobierania zaktualizowanych wartości parametrów z backendu Zdalnej konfiguracji oraz do kontrolowania, kiedy pobrane wartości mają być udostępniane aplikacji.

Podczas programowania zalecamy ustawienie stosunkowo niskiego minimalnego odstępu pobierania. Więcej informacji znajdziesz w sekcji Ograniczanie wykorzystania.

Krok 2. Ustaw domyślne wartości parametrów w aplikacji

W obiekcie Zdalnej konfiguracji możesz ustawić domyślne wartości parametrów aplikacji, dzięki czemu aplikacja będzie działać zgodnie z oczekiwaniami przed nawiązaniem połączenia z backendem Zdalnej konfiguracji, a jeśli w backendzie nie zostaną ustawione żadne wartości domyślne, będą one dostępne.

  1. Zdefiniuj zbiór nazw parametrów i domyślne wartości parametrów za pomocą obiektu NSDictionary lub pliku plist.

    Jeśli masz już skonfigurowane wartości parametrów backendu Zdalnej konfiguracji, możesz pobrać wygenerowany plik plist zawierający wszystkie wartości domyślne i zapisać go w projekcie 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

    Konsola Firebase

    1. Na karcie Parametry otwórz menu i wybierz Pobierz wartości domyślne.

    2. Gdy pojawi się odpowiedni komunikat, włącz .plist na iOS, a następnie kliknij Pobierz plik.

  2. Dodaj te wartości do obiektu Zdalnej konfiguracji za pomocą narzędzia setDefaults:. Ten przykład służy do ustawiania domyślnych wartości w aplikacji za pomocą pliku plist:

    Swift

    remoteConfig.setDefaults(fromPlist: "RemoteConfigDefaults")
    ViewController.swift

    Objective-C

    [self.remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];
    ViewController.m

Krok 3. Pobierz wartości parametrów do wykorzystania w aplikacji

Teraz możesz pobierać wartości parametrów z obiektu Zdalnej konfiguracji. Jeśli później ustawisz wartości w backendzie Zdalnej konfiguracji, pobierzesz je i aktywujesz, będą one dostępne dla Twojej aplikacji. Jeśli nie, Twoje wartości parametrów w aplikacji zostaną skonfigurowane za pomocą parametru setDefaults:. Aby je pobrać, wywołaj metodę configValueForKey:, podając klucz parametru jako argument.

Krok 4. Ustaw wartości parametrów

Za pomocą konsoli Firebase lub interfejsów API backendu Zdalnej konfiguracji możesz utworzyć nowe domyślne wartości backendu, które zastąpią wartości w aplikacji odpowiednio do oczekiwanej logiki warunkowej lub kierowania na użytkowników. W tej sekcji znajdziesz instrukcje tworzenia tych wartości w konsoli Firebase.

  1. W konsoli Firebase otwórz projekt.
  2. Z menu wybierz Zdalna konfiguracja, aby wyświetlić panel Zdalnej konfiguracji.
  3. Zdefiniuj parametry o takich samych nazwach jak parametry zdefiniowane w aplikacji. Dla każdego parametru możesz ustawić wartość domyślną (która ostatecznie zastąpi wartość domyślną w aplikacji) albo ustawić wartości warunkowe. Więcej informacji znajdziesz w artykule Parametry i warunki Zdalnej konfiguracji.

Krok 5. Pobierz i aktywuj wartości

Aby pobrać wartości parametrów ze Zdalnej konfiguracji, wywołaj metodę fetchWithCompletionHandler: lub fetchWithExpirationDuration:completionHandler:. Wszystkie wartości ustawione w backendzie są pobierane i zapisywane w obiekcie Zdalnej konfiguracji.

Jeśli chcesz pobrać i aktywować wartości w jednym wywołaniu, użyj fetchAndActivateWithCompletionHandler:.

Ten przykład pobiera wartości z backendu Zdalnej konfiguracji (a nie wartości z pamięci podręcznej) i wywołuje activateWithCompletionHandler:, aby udostępnić je aplikacji:

Swift

remoteConfig.fetch { (status, error) -> Void in
  if status == .success {
    print("Config fetched!")
    self.remoteConfig.activate { changed, error in
      // ...
    }
  } else {
    print("Config not fetched")
    print("Error: \(error?.localizedDescription ?? "No error available.")")
  }
  self.displayWelcome()
}
ViewController.swift

Objective-C

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

Te zaktualizowane wartości parametrów wpływają na działanie i wygląd aplikacji, dlatego musisz aktywować pobrane wartości w czasie, który zapewni użytkownikom płynne działanie, np. gdy następnym razem otworzy on Twoją aplikację. Więcej informacji i przykłady znajdziesz w artykule Strategie wczytywania Zdalnej konfiguracji.

Krok 6. Nasłuchuj aktualizacji w czasie rzeczywistym

Po pobraniu wartości parametrów możesz używać Zdalnej konfiguracji w czasie rzeczywistym do nasłuchiwania aktualizacji z backendu Zdalnej konfiguracji. Zdalna konfiguracja wysyła do połączonych urządzeń sygnały w czasie rzeczywistym o dostępności aktualizacji i automatycznie pobiera zmiany po opublikowaniu nowej wersji Zdalnej konfiguracji.

Aktualizacje w czasie rzeczywistym są obsługiwane przez pakiet SDK Firebase dla platform Apple w wersji 10.7.0 lub nowszej.

  1. W swojej aplikacji wywołaj addOnConfigUpdateListener, aby zacząć nasłuchiwać aktualizacji i automatycznie pobierać nowe lub zaktualizowane wartości parametrów. Ten przykład nasłuchuje aktualizacji i po wywołaniu funkcji activateWithCompletionHandler używa nowo pobranych wartości do wyświetlenia zaktualizowanej wiadomości powitalnej.

    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. Gdy następnym razem opublikujesz nową wersję Zdalnej konfiguracji, urządzenia, na których działa Twoja aplikacja i nasłuchują zmian, wywołają moduł obsługi ukończenia.

Ograniczenia

Jeśli aplikacja pobierze zbyt wiele razy w krótkim czasie, wywołania pobierania są ograniczane, a pakiet SDK zwraca FIRRemoteConfigFetchStatusThrottled. Przed pakietem SDK w wersji 6.3.0 limit wynosił 5 żądań pobierania w 60-minutowym okresie (nowsze wersje mają bardziej rygorystyczne limity).

Podczas tworzenia aplikacji warto często pobierać dane, aby bardzo często (często na godzinę) odświeżać pamięć podręczną, co pozwoli na szybkie iteracje podczas tworzenia i testowania aplikacji. Zdalna konfiguracja w czasie rzeczywistym automatycznie pomija pamięć podręczną po zaktualizowaniu konfiguracji na serwerze. Aby dostosować ją do szybkiej iteracji projektu obejmującego wielu deweloperów, możesz tymczasowo dodać w aplikacji właściwość FIRRemoteConfigSettings z krótkim minimalnym interwałem pobierania (MinimumFetchInterval).

Domyślny i zalecany interwał pobierania w środowisku produkcyjnym w przypadku Zdalnej konfiguracji to 12 godzin, co oznacza, że konfiguracje będą pobierane z backendu tylko raz w ciągu 12 godzin, niezależnie od tego, ile rzeczywiście zostało wykonanych wywołań pobierania. Minimalny odstęp czasu pobierania jest określany w tej kolejności:

  1. Parametr w polu fetch(long)
  2. Parametr w polu FIRRemoteConfigSettings.MinimumFetchInterval
  3. Wartość domyślna to 12 godzin.

Dalsze kroki

Zapoznaj się z przypadkami użycia Zdalnej konfiguracji i zapoznaniem się z niektórymi kluczowymi pojęciami i dokumentacją zaawansowanych strategii, w tym: