Pierwsze kroki ze Zdalnej konfiguracji Firebase


Możesz używać Firebase Remote Config do definiowania parametrów w aplikacji i aktualizowania ich wartości w chmurze, co pozwala modyfikować wygląd i działanie aplikacji bez rozpowszechniania jej aktualizacji. Ten przewodnik zawiera instrukcje, jak rozpocząć pracę, oraz przykładowy kod, który można sklonować lub pobrać z repozytorium GitHub firebase/quickstart-ios.

Krok 1. Dodaj Remote Config do aplikacji

  1. Jeśli jeszcze tego nie zrobiono, dodaj Firebase do projektu Apple.

  2. W przypadku Remote Config usługa Google Analytics jest wymagana do kierowania warunkowego instancji aplikacji na odbiorców i właściwości użytkowników. Sprawdź, czy w projekcie włączona jestGoogle Analytics.

  3. Utwórz pojedynczy obiekt Remote Config, jak w tym przykładzie:

    Swift

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

    Objective-C

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

Ten obiekt służy do przechowywania domyślnych wartości parametrów w aplikacji, pobierania zaktualizowanych wartości parametrów z backendu Remote Config i określania, kiedy pobrane wartości mają być udostępniane aplikacji.

Podczas tworzenia zalecamy ustawienie stosunkowo niskiego minimalnego interwału pobierania. Więcej informacji znajdziesz w sekcji Ograniczanie liczby żądań.

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

W obiekcie Remote Config możesz ustawić domyślne wartości parametrów w aplikacji, aby działała ona zgodnie z oczekiwaniami, zanim połączy się z backendem Remote Config, oraz aby wartości domyślne były dostępne, jeśli żadne nie są ustawione w backendzie.

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

    Jeśli masz już skonfigurowane Remote Configwartości parametrów backenduplist, możesz pobrać wygenerowany plik plist, który zawiera 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
    

    Firebase konsola

    1. Na karcie Parametry otwórz Menu i kliknij Pobierz wartości domyślne.

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

  2. Dodaj te wartości do obiektu Remote Config za pomocą funkcji setDefaults:. W tym przykładzie ustawiono domyślne wartości w aplikacji z pliku plist:

    Swift

    remoteConfig.setDefaults(fromPlist: "RemoteConfigDefaults")

    Objective-C

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

Krok 3. Uzyskiwanie wartości parametrów do użycia w aplikacji

Możesz teraz pobierać wartości parametrów z obiektu Remote Config. Jeśli później ustawisz wartości w Remote Configbackendzie, pobierzesz je i aktywujeszRemote Config, będą one dostępne w Twojej aplikacji. W przeciwnym razie uzyskasz wartości parametrów w aplikacji skonfigurowane za pomocą setDefaults:. Aby uzyskać te wartości, wywołaj metodę configValueForKey:, podając klucz parametru jako 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

Bardziej czytelny i wygodny sposób uzyskiwania dostępu do tych wartości w Swift to notacja indeksu w 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

Używanie protokołu Codable do konfigurowania w sposób bezpieczny pod względem typów

W przypadku bardziej złożonych konfiguracji możesz użyć protokołu Codable Swift, aby dekodować dane strukturalne z Remote Config. Zapewnia to bezpieczne pod względem typów zarządzanie konfiguracją i upraszcza pracę ze złożonymi obiektami.

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

Ta metoda pozwala:

  • Zdefiniuj złożone struktury konfiguracji.
  • Automatyczne analizowanie konfiguracji JSON.
  • Zapewnij bezpieczeństwo typów podczas uzyskiwania dostępu do wartości Remote Config.
  • Udostępnij przejrzysty, czytelny kod do obsługi szablonów uporządkowanych Remote Config.

Używanie elementów Property Wrappers do deklaratywnej konfiguracji w SwiftUI

Obiekty opakowujące właściwości to zaawansowana funkcja języka Swift, która umożliwia dodawanie niestandardowych zachowań do deklaracji właściwości. W SwiftUI otoczki właściwości służą do zarządzania stanem, powiązaniami i innymi zachowaniami właściwości. Więcej informacji znajdziesz w przewodniku po języku 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()
    }
  }
}

Użyj otoki właściwości @RemoteConfigProperty, jeśli chcesz mieć deklaratywny sposób dostępu do wartości Remote Config w SwiftUI z wbudowaną obsługą wartości domyślnych i uproszczonym zarządzaniem konfiguracją.

Krok 4. Ustaw wartości parametrów

Za pomocą Firebasekonsoli lub Remote Configbackendowych interfejsów API możesz tworzyć nowe domyślne wartości backendu, które zastępują wartości w aplikacji zgodnie z wybraną logiką warunkową lub kierowaniem na użytkowników. W tej sekcji znajdziesz instrukcje dotyczące Firebase konsoli, które pomogą Ci utworzyć te wartości.

  1. W Firebasekonsoli otwórz projekt.
  2. W menu wybierz Remote Config, aby wyświetlić Remote Configpanel.
  3. Zdefiniuj parametry o takich samych nazwach jak parametry zdefiniowane w aplikacji. W przypadku każdego parametru możesz ustawić wartość domyślną (która ostatecznie zastąpi wartość domyślną w aplikacji) oraz wartości warunkowe. Więcej informacji znajdziesz w artykule Remote ConfigParametry i warunki.
  4. Jeśli używasz niestandardowych warunków sygnału, zdefiniuj atrybuty i ich wartości. Poniższe przykłady pokazują, jak zdefiniować warunek sygnału niestandardowego.

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

Krok 5. Pobierz i aktywuj wartości

Aby pobrać wartości parametrów z Remote Config, wywołaj metodę fetchWithCompletionHandler: lub fetchWithExpirationDuration:completionHandler:. Wszystkie wartości ustawione w backendzie są pobierane i buforowane w obiekcie Remote Config.

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

Ten przykład pobiera wartości z backendu Remote Config (nie z pamięci podręcznej) i wywołuje funkcję 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()
}

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

Zaktualizowane wartości parametrów wpływają na działanie i wygląd aplikacji, dlatego należy aktywować pobrane wartości w momencie, który zapewni użytkownikowi płynne działanie aplikacji, np. przy następnym otwarciu aplikacji. Więcej informacji i przykłady znajdziesz w artykule Strategie wczytywania Zdalnej konfiguracji.

Krok 6. Słuchaj aktualizacji w czasie rzeczywistym

Po pobraniu wartości parametrów możesz użyć Remote Config w czasie rzeczywistymRemote Config, aby nasłuchiwać aktualizacji z backendu. Sygnały w czasie rzeczywistymRemote Config informują połączone urządzenia o dostępności aktualizacji i automatycznie pobierają zmiany po opublikowaniu nowej Remote Config wersji.

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

  1. W aplikacji wywołaj funkcję addOnConfigUpdateListener, aby rozpocząć nasłuchiwanie aktualizacji i automatycznie pobierać nowe lub zaktualizowane wartości parametrów. Poniższy przykład nasłuchuje aktualizacji i gdy wywoływana jest funkcja activateWithCompletionHandler, używa nowo pobranych wartości do wyświetlania zaktualizowanego powitania.

    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ę Remote Config, urządzenia, na których działa Twoja aplikacja i które nasłuchują zmian, wywołają procedurę obsługi zakończenia.

Ograniczenia

Jeśli aplikacja pobiera dane zbyt wiele razy w krótkim czasie, wywołania pobierania są ograniczane, a pakiet SDK zwraca wartość FIRRemoteConfigFetchStatusThrottled. Przed wersją 6.3.0 pakietu SDK limit wynosił 5 żądań pobierania w ciągu 60 minut (nowsze wersje mają bardziej liberalne limity).

Podczas tworzenia aplikacji możesz częściej pobierać dane, aby odświeżać pamięć podręczną bardzo często (wiele razy na godzinę), co pozwoli Ci szybko wprowadzać zmiany w aplikacji i ją testować. Aktualizacje Konfiguracji zdalnej w czasie rzeczywistym automatycznie pomijają pamięć podręczną, gdy konfiguracja zostanie zaktualizowana na serwerze. Aby umożliwić szybkie iteracje w projekcie, nad którym pracuje wielu deweloperów, możesz tymczasowo dodać w aplikacji usługę FIRRemoteConfigSettings z krótkim minimalnym interwałem pobieraniaMinimumFetchInterval.

Domyślny i zalecany interwał pobierania w środowisku produkcyjnym dla Remote Config wynosi 12 godzin. Oznacza to, że konfiguracje nie będą pobierane z backendu częściej niż raz w 12-godzinnym przedziale czasu, niezależnie od tego, ile wywołań pobierania zostanie faktycznie wykonanych. Minimalny interwał pobierania jest określany w tej kolejności:

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

Dalsze kroki

Jeśli jeszcze tego nie zrobiono, zapoznaj się z Remote Config przypadkami użycia i dokumentacją dotyczącą kluczowych pojęć i zaawansowanych strategii, w tym: