Erste Schritte mit Firebase Remote Config


Mit Firebase Remote Config können Sie Parameter in Ihrer App definieren und ihre Werte in der Cloud aktualisieren. So können Sie die Darstellung und das Verhalten Ihrer App ändern, ohne ein App-Update zu verteilen. In dieser Anleitung werden die ersten Schritte beschrieben und Beispielcode bereitgestellt, der im GitHub-Repository firebase/quickstart-ios geklont oder heruntergeladen werden kann.

Schritt 1: Remote Config in Ihre App einfügen

  1. Falls noch nicht geschehen, fügen Sie Ihrem Apple-Projekt Firebase hinzu.

  2. Für Remote Config ist Google Analytics erforderlich, um das bedingte Targeting von App-Instanzen auf Nutzereigenschaften und Zielgruppen zu ermöglichen. Achten Sie darauf, dass Sie Google Analytics in Ihrem Projekt aktivieren.

  3. Erstellen Sie das Singleton-Objekt Remote Config, wie im folgenden Beispiel gezeigt:

    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

Mit diesem Objekt werden Standardparameterwerte in der App gespeichert, aktualisierte Parameterwerte aus dem Remote Config-Backend abgerufen und gesteuert, wann abgerufene Werte für Ihre App verfügbar gemacht werden.

Während der Entwicklung wird empfohlen, ein relativ niedriges Mindestintervall für den Abruf festzulegen. Weitere Informationen finden Sie unter Drosselung.

Schritt 2: In-App-Standardparameterwerte festlegen

Sie können Standardparameterwerte für In-App-Konfigurationen im Remote Config-Objekt festlegen, damit sich Ihre App wie vorgesehen verhält, bevor sie eine Verbindung zum Remote Config-Backend herstellt. Außerdem sind so Standardwerte verfügbar, wenn im Backend keine festgelegt sind.

  1. Definieren Sie eine Reihe von Parameternamen und Standardparameterwerten mit einem NSDictionary-Objekt oder einer plist-Datei.

    Wenn Sie bereits Remote Config-Backend-Parameterwerte konfiguriert haben, können Sie eine generierte plist-Datei mit allen Standardwerten herunterladen und in Ihrem Xcode-Projekt speichern.

    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 Console

    1. Öffnen Sie auf dem Tab Parameter das Menü und wählen Sie Standardwerte herunterladen aus.

    2. Aktivieren Sie bei Aufforderung .plist für iOS und klicken Sie dann auf Datei herunterladen.

  2. Fügen Sie diese Werte mit setDefaults: zum Objekt Remote Config hinzu. Im folgenden Beispiel werden In-App-Standardwerte aus einer PLIST-Datei festgelegt:

    Swift

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

    Objective-C

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

Schritt 3: Parameterwerte für Ihre App abrufen

Sie können jetzt Parameterwerte aus dem Remote Config-Objekt abrufen. Wenn Sie später Werte im Remote Config-Backend festlegen, abrufen und dann aktivieren, sind diese Werte für Ihre App verfügbar. Andernfalls erhalten Sie die In-App-Parameterwerte, die mit setDefaults: konfiguriert wurden. Rufen Sie die Methode configValueForKey: auf und geben Sie den Parameterschlüssel als Argument an, um diese Werte abzurufen.

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

In Swift können Sie mit der Subscript-Notation auf diese Werte zugreifen. Das ist übersichtlicher und praktischer:

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

Codable für typsichere Konfiguration verwenden

Für komplexere Konfigurationen können Sie das Codable-Protokoll von Swift verwenden, um strukturierte Daten aus Remote Config zu decodieren. Dies ermöglicht eine typsichere Konfigurationsverwaltung und vereinfacht die Arbeit mit komplexen Objekten.

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

Mit dieser Methode haben Sie folgende Möglichkeiten:

  • Komplexe Konfigurationsstrukturen definieren
  • JSON-Konfigurationen automatisch parsen.
  • Achten Sie beim Zugriff auf Remote Config-Werte auf Typsicherheit.
  • Stellen Sie sauberen, gut lesbaren Code für die Verarbeitung strukturierter Remote Config-Vorlagen bereit.

Property-Wrapper für die deklarative Konfiguration in SwiftUI verwenden

Property-Wrapper sind eine leistungsstarke Swift-Funktion, mit der Sie benutzerdefiniertes Verhalten zu Property-Deklarationen hinzufügen können. In SwiftUI werden Property-Wrapper verwendet, um den Status, Bindungen und andere Property-Verhaltensweisen zu verwalten. Weitere Informationen finden Sie im Swift Language 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()
    }
  }
}

Verwenden Sie den Property-Wrapper @RemoteConfigProperty, wenn Sie in SwiftUI deklarativ auf Remote Config-Werte zugreifen möchten. Er bietet integrierte Unterstützung für Standardwerte und eine vereinfachte Konfigurationsverwaltung.

Schritt 4: Parameterwerte festlegen

Über die Firebase-Konsole oder die Remote Config-Backend-APIs können Sie neue Backend-Standardwerte erstellen, die die In-App-Werte entsprechend Ihrer gewünschten bedingten Logik oder Ausrichtung auf Nutzer überschreiben. In diesem Abschnitt werden die Schritte in der Firebase-Konsole zum Erstellen dieser Werte beschrieben.

  1. Öffnen Sie Ihr Projekt in der Firebase-Konsole.
  2. Wählen Sie im Menü Remote Config aus, um das Remote Config-Dashboard aufzurufen.
  3. Definieren Sie Parameter mit denselben Namen wie die Parameter, die Sie in Ihrer App definiert haben. Für jeden Parameter können Sie einen Standardwert festlegen, der den Standardwert in der App überschreibt. Außerdem können Sie bedingte Werte festlegen. Weitere Informationen finden Sie unter Remote Config-Parameter und ‑Bedingungen.

  4. Wenn Sie benutzerdefinierte Signalbedingungen verwenden, definieren Sie die Attribute und ihre Werte. In den folgenden Beispielen wird gezeigt, wie Sie eine benutzerdefinierte Signalbedingung definieren.

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

Schritt 5: Werte abrufen und aktivieren

Rufen Sie zum Abrufen von Parameterwerten aus Remote Config die Methode fetchWithCompletionHandler: oder fetchWithExpirationDuration:completionHandler: auf. Alle Werte, die Sie im Backend festlegen, werden abgerufen und im Remote Config-Objekt zwischengespeichert.

Wenn Sie Werte in einem Aufruf abrufen und aktivieren möchten, verwenden Sie fetchAndActivateWithCompletionHandler:.

In diesem Beispiel werden Werte aus dem Remote Config-Backend abgerufen (keine im Cache gespeicherten Werte) und activateWithCompletionHandler: wird aufgerufen, um sie für die App verfügbar zu machen:

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

Da sich diese aktualisierten Parameterwerte auf das Verhalten und Erscheinungsbild Ihrer App auswirken, sollten Sie die abgerufenen Werte zu einem Zeitpunkt aktivieren, der für eine reibungslose Nutzererfahrung sorgt, z. B. beim nächsten Öffnen der App durch den Nutzer. Weitere Informationen und Beispiele finden Sie unter Remote Config-Ladestrategien.

Schritt 6: Updates in Echtzeit anhören

Nachdem Sie Parameterwerte abgerufen haben, können Sie mit Echtzeit-Remote Config auf Aktualisierungen vom Remote Config-Backend warten. Remote Config-Signale in Echtzeit werden an verbundene Geräte gesendet, wenn Updates verfügbar sind. Die Änderungen werden automatisch abgerufen, nachdem Sie eine neue Remote Config-Version veröffentlicht haben.

Echtzeitupdates werden vom Firebase SDK für Apple-Plattformen ab Version 10.7.0 unterstützt.

  1. Rufen Sie in Ihrer App addOnConfigUpdateListener auf, um mit dem Abhören von Updates zu beginnen und automatisch alle neuen oder aktualisierten Parameterwerte abzurufen. Im folgenden Beispiel wird auf Aktualisierungen gewartet. Wenn activateWithCompletionHandler aufgerufen wird, werden die neu abgerufenen Werte verwendet, um eine aktualisierte Willkommensnachricht anzuzeigen.

    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. Wenn Sie das nächste Mal eine neue Version von Remote Config veröffentlichen, rufen Geräte, auf denen Ihre App ausgeführt wird und die auf Änderungen warten, den Completion-Handler auf.

Drosselung

Wenn eine App innerhalb eines kurzen Zeitraums zu viele Abrufe durchführt, werden die Abrufe gedrosselt und das SDK gibt FIRRemoteConfigFetchStatusThrottled zurück. Vor SDK-Version 6.3.0 lag das Limit bei 5 Abrufanfragen in einem 60-Minuten-Zeitraum. Neuere Versionen haben großzügigere Limits.

Während der App-Entwicklung möchten Sie möglicherweise häufiger Daten abrufen, um den Cache sehr häufig (mehrmals pro Stunde) zu aktualisieren, damit Sie Ihre App schnell iterieren können. Bei Echtzeit-Remote Config-Updates wird der Cache automatisch umgangen, wenn die Konfiguration auf dem Server aktualisiert wird. Um schnelle Iterationen in einem Projekt mit zahlreichen Entwicklern zu ermöglichen, können Sie Ihrer App vorübergehend eine FIRRemoteConfigSettings-Property mit einem niedrigen minimalen Abrufintervall (MinimumFetchInterval) hinzufügen.

Das standardmäßige und empfohlene Abrufintervall für die Produktion für Remote Config beträgt 12 Stunden. Das bedeutet, dass Konfigurationen unabhängig davon, wie viele Abrufe tatsächlich erfolgen, nicht öfter als einmal innerhalb von 12 Stunden vom Backend abgerufen werden. Das minimale Abrufintervall wird in der folgenden Reihenfolge bestimmt:

  1. Der Parameter in fetch(long)
  2. Der Parameter in FIRRemoteConfigSettings.MinimumFetchInterval
  3. Der Standardwert von 12 Stunden

Nächste Schritte

Falls Sie das noch nicht getan haben, sehen Sie sich die Remote Config Anwendungsfälle an und lesen Sie die Dokumentation zu einigen der wichtigsten Konzepte und erweiterten Strategien, darunter: