Wprowadzenie do Zdalnej konfiguracji na iOS

Wybierz platformę:

iOS+ Android Web Flutter Unity C++

Za pomocą Firebase Remote Config możesz definiować parametry w aplikacji i aktualizować ich wartości w chmurze. Dzięki temu możesz modyfikować wygląd i zachowanie aplikacji bez konieczności dystrybuowania aktualizacji aplikacji. Ten przewodnik zawiera instrukcje dotyczące rozpoczęcia pracy oraz przykładowy kod, który można sklonować lub pobrać z repozytorium firebase/quickstart-ios w GitHubie.

Krok 1. Dodaj Remote Config do aplikacji

Dodaj Firebase do projektu Apple, jeśli nie korzystasz w nim jeszcze z tej usługi.
W przypadku Remote Config, Google Analytics jest wymagana do kierowania warunkowego instancji aplikacji na odbiorców i właściwości użytkowników. Upewnij się, że masz włączoną usługę w swoim projekcie.Google Analytics

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

Swift

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

Objective-C

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

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 oraz kontrolowania, kiedy pobrane wartości mają być dostępne dla aplikacji.

Podczas programowania zalecamy ustawienie stosunkowo krótkiego minimalnego interwału pobierania. Więcej informacji znajdziesz w sekcji Ograniczenia.

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 aplikacja działała zgodnie z oczekiwaniami, zanim połączy się z Remote Config backendem, oraz aby wartości domyślne były dostępne, jeśli w backendzie nie ustawiono żadnych wartości.

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

Jeśli masz już skonfigurowane wartości parametrów backendu Remote Config, 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
```
Token okaziciela możesz wygenerować, uruchamiając to polecenie za pomocą Google Cloud CLI lub Cloud Shell:
```
gcloud auth print-access-token
```
Ten token ma krótki okres ważności, więc jeśli wystąpi błąd uwierzytelniania, może być konieczne jego ponowne wygenerowanie.
Firebase konsola
1. Na karcie Parametry otwórz Menu, i kliknij Pobierz wartości domyślne.
2. Gdy pojawi się prośba, włącz .plist dla iOS, a następnie kliknij Pobierz plik.

Dodaj te wartości do obiektu Remote Config za pomocą setDefaults:. Ten przykład ustawia domyślne wartości w aplikacji z pliku plist:

Swift

RemoteConfig.remoteConfig().setDefaults(fromPlist: "RemoteConfigDefaults")MigratedSnippets.swift

Objective-C

[remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];ObjCMigratedSnippets.m

Krok 3. Uzyskaj wartości parametrów, które będą używane w Twojej aplikacji

Teraz możesz pobierać wartości parametrów z obiektu Remote Config. Jeśli później ustawisz wartości w backendzie Remote Config, pobierzesz je i aktywujesz, będą one dostępne dla Twojej aplikacji. W przeciwnym razie otrzymasz wartości parametrów w aplikacji skonfigurowane za pomocą setDefaults:. Aby uzyskać te wartości, wywołaj metodę configValueForKey: i podaj 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 języku Swift to użycie notacji indeksowej 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żywaj protokołu Codable do bezpiecznej konfiguracji

W przypadku bardziej złożonych konfiguracji możesz użyć protokołu Codable w języku Swift, aby dekodować dane strukturalne ze Remote Config. Umożliwia to bezpieczne 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 umożliwia:

definiowanie złożonych struktur konfiguracji;
automatyczne analizowanie konfiguracji JSON;
zapewnianie bezpieczeństwa typów podczas uzyskiwania dostępu do wartości Remote Config
zapewnianie przejrzystego i czytelnego kodu do obsługi strukturalnych Remote Config szablonów.

Używaj otoczek właściwości do deklaratywnej konfiguracji w SwiftUI

Otoczki właściwości to zaawansowana funkcja języka Swift, która umożliwia dodawanie niestandardowego zachowania 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 Guide.

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żywaj otoczki właściwości @RemoteConfigProperty, gdy chcesz mieć deklaratywny sposób uzyskiwania dostępu do Remote Config wartości w SwiftUI, z wbudowaną obsługą wartości domyślnych i uproszczonym zarządzaniem konfiguracją.

Krok 4. Ustaw wartości parametrów

Za pomocą konsoli Firebase lub backendowych interfejsów API Remote Config 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 opisujemy, jak utworzyć te wartości w konsoli Firebase.

W konsoli FirebaseFirebase otwórz swój projekt.
W menu wybierz Remote Config , aby wyświetlić panel Remote Config.
Zdefiniuj parametry o tych samych nazwach co 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 sekcji Remote Config Parametry i warunki.

Jeśli używasz niestandardowych warunków sygnałów , zdefiniuj atrybuty i ich wartości. W tych przykładach pokazujemy, 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 zapisywane w pamięci podręcznej w obiekcie Remote Config.

Jeśli chcesz pobrać i aktywować wartości za pomocą jednego wywołania, użyj fetchAndActivateWithCompletionHandler:.

Ten przykład pobiera wartości z backendu Remote Config (nie z pamięci podręcznej wartości) i wywołujeactivateWithCompletionHandler:, aby udostępnić je aplikacji:

Swift

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

Objective-C

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

Ponieważ te zaktualizowane wartości parametrów wpływają na zachowanie i wygląd aplikacji, należy aktywować pobrane wartości w taki sposób, aby zapewnić użytkownikowi płynne działanie, np. przy następnym otwarciu aplikacji. Więcej informacji i przykładów znajdziesz w sekcji Strategie wczytywania Zdalnej konfiguracji.

Krok 6. Nasłuchuj aktualizacji w czasie rzeczywistym

Po pobraniu wartości parametrów możesz użyć Zdalnej konfiguracji w czasie rzeczywistym, aby nasłuchiwać aktualizacji z backendu Zdalnej konfiguracji.Remote ConfigRemote Config W czasie rzeczywistym Remote Config sygnalizuje podłączonym urządzeniom, kiedy dostępne są aktualizacje, i automatycznie pobiera zmiany po opublikowaniu nowej Remote Config wersji.

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

W aplikacji wywołaj addOnConfigUpdateListener, aby rozpocząć nasłuchiwanie aktualizacji i automatycznie pobierać nowe lub zaktualizowane wartości parametrów. Ten przykład nasłuchuje aktualizacji i gdy wywoływana jest funkcja activateWithCompletionHandler, używa nowo pobranych wartości do wyświetlania 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];
        });
      }];
    }
  }];

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 FIRRemoteConfigFetchStatusThrottled. Przed wersją 6.3.0 pakietu SDK limit wynosił 5 żądań pobierania w ciągu 60 minut (nowe wersje mają bardziej liberalne limity).

Podczas tworzenia aplikacji możesz chcieć częściej pobierać dane, aby bardzo często odświeżać pamięć podręczną (wiele razy na godzinę), co pozwoli Ci szybko iterować podczas tworzenia i testowania aplikacji. Aktualizacje Zdalnej konfiguracji w czasie rzeczywistym automatycznie pomijają pamięć podręczną, gdy konfiguracja jest aktualizowana na serwerze. Aby umożliwić szybkie iterowanie w projekcie z wieloma deweloperami, 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 Remote Config wynosi 12 godzin. Oznacza to, że konfiguracje nie będą pobierane z backendu częściej niż raz na 12 godzin, niezależnie od tego, ile wywołań pobierania zostanie faktycznie wykonanych. Minimalny interwał pobierania jest określany w tej kolejności:

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

Wprowadzenie do Zdalnej konfiguracji na iOS Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Krok 1. Dodaj Remote Config do aplikacji

Swift

Objective-C

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

REST

Firebase konsola

Swift

Objective-C

Krok 3. Uzyskaj wartości parametrów, które będą używane w Twojej aplikacji

Używaj protokołu Codable do bezpiecznej konfiguracji

Używaj otoczek właściwości do deklaratywnej konfiguracji w SwiftUI

Krok 4. Ustaw wartości parametrów

Swift

Objective-C

Krok 5. Pobierz i aktywuj wartości

Swift

Objective-C

Krok 6. Nasłuchuj aktualizacji w czasie rzeczywistym

Swift

Objective-C

Ograniczenia

Wprowadzenie do Zdalnej konfiguracji na iOS