Erste Schritte mit Remote Config unter iOS

Plattform auswählen :

iOS+ Android Web Flutter Unity C++

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

Schritt 1: Remote Config zu Ihrer App hinzufügen

Falls noch nicht geschehen, fügen Sie Ihrem Apple Projekt Firebase hinzu.
Für Remote Config, Google Analytics benötigen Sie um das bedingte Targeting von App-Instanzen auf Nutzereigenschaften und Zielgruppen zu ermöglichen. Achten Sie darauf, dass Sie aktivieren Google Analytics in Ihrem Projekt.

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

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

Dieses Objekt wird verwendet, um Standardparameterwerte in der App zu speichern, aktualisierte Parameterwerte aus dem Remote Config Backend abzurufen und zu steuern, wann abgerufene Werte für Ihre App verfügbar gemacht werden.

Während der Entwicklung empfiehlt es sich, ein relativ niedriges Mindestabrufintervall festzulegen. Weitere Informationen finden Sie unter Drosselung.

Schritt 2: Standardparameterwerte in der App festlegen

Sie können Standardparameterwerte in der App im Remote Config Objekt festlegen, damit sich Ihre App wie gewünscht verhält, bevor sie eine Verbindung zum Remote Config Backend herstellt. Außerdem sind so Standardwerte verfügbar, wenn im Backend keine festgelegt sind.

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
```
Sie können ein Bearertoken generieren, indem Sie den folgenden Befehl mit der Google Cloud CLI oder Cloud Shell ausführen:
```
gcloud auth print-access-token
```
Dieses Token ist nur von kurzer Dauer. Wenn ein Authentifizierungsfehler auftritt, müssen Sie es möglicherweise neu generieren.
Firebase console
1. Öffnen Sie auf dem Tab Parameter das Menü und wählen Sie Standardwerte herunterladen aus.
2. Aktivieren Sie bei entsprechender Aufforderung .plist für iOS und klicken Sie dann auf Datei herunterladen.

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

Swift

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

Objective-C

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

Schritt 3: Parameterwerte für Ihre App abrufen

Jetzt können Sie Parameterwerte aus dem Remote Config Objekt abrufen. Wenn Sie später Werte im Remote Config Backend festlegen, sie abrufen und dann aktivieren, sind diese Werte für Ihre App verfügbar. Andernfalls erhalten Sie die Parameterwerte in der App, die mit setDefaults: konfiguriert wurden. Rufen Sie die configValueForKey: Methode 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

Eine lesbarere und bequemere Möglichkeit, auf diese Werte in Swift zuzugreifen, ist die Subscript-Notation von 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

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. So erhalten Sie eine typsichere Konfigurationsverwaltung und die Arbeit mit komplexen Objekten wird vereinfacht.

// 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 können Sie Folgendes tun:

Komplexe Konfigurationsstrukturen definieren
JSON-Konfigurationen automatisch parsen
Typsicherheit beim Zugriff auf Remote Config Werte gewährleisten
Sauberen, lesbaren Code für die Verarbeitung strukturierter Remote Config Vorlagen bereitstellen

Property-Wrapper für deklarative Konfiguration in SwiftUI verwenden

Property-Wrapper sind eine leistungsstarke Swift-Funktion, mit der Sie Property-Deklarationen benutzerdefiniertes Verhalten hinzufügen können. In SwiftUI werden Property-Wrapper verwendet, um 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 auf deklarative Weise auf Remote Config Werte in SwiftUI zugreifen möchten. Er bietet integrierte Unterstützung für Standard werte und eine vereinfachte Konfigurationsverwaltung.

Schritt 4: Parameterwerte festlegen

Über die Firebase Console oder die Remote Config Backend APIs können Sie neue Standardwerte für das Backend erstellen, die die Werte in der App gemäß Ihrer gewünschten bedingten Logik oder Nutzerausrichtung überschreiben. In diesem Abschnitt werden die Schritte in der Firebase Konsole beschrieben, mit denen Sie diese Werte erstellen.

Öffnen Sie in der Firebase Console Ihr Projekt.
Wählen Sie im Menü Remote Config aus, um das Remote Config Dashboard aufzurufen.
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.

Wenn Sie benutzerdefinierte Signal bedingungen 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 die fetchWithCompletionHandler: oder fetchWithExpirationDuration:completionHandler: Methode auf, um Parameterwerte aus Remote Config abzurufen. Alle Werte, die Sie im Backend festgelegt haben, werden abgerufen und im Remote Config Objekt im Cache gespeichert.

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

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

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

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

Schritt 6: In Echtzeit auf Updates warten

Nachdem Sie Parameterwerte abgerufen haben, können Sie mit Remote Config in Echtzeit auf Updates aus dem Remote Config-Backend warten.Remote ConfigRemote Config Echtzeit Remote Config signalisiert verbundenen Geräten, wenn Updates verfügbar sind, und ruft die Änderungen automatisch ab, nachdem Sie eine neue Remote Config Version veröffentlicht haben.

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

Rufen Sie in Ihrer App addOnConfigUpdateListener auf, um auf Updates zu warten und alle neuen oder aktualisierten Parameterwerte automatisch abzurufen. Im folgenden Beispiel wird auf Updates gewartet. Wenn activateWithCompletionHandler aufgerufen wird, werden die neu abgerufenen Werte verwendet, um eine aktualisierte Begrüßungsnachricht 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];
        });
      }];
    }
  }];

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 zu oft in kurzer Zeit abruft, werden Abrufe gedrosselt und das SDK gibt FIRRemoteConfigFetchStatusThrottled zurück. Vor SDK-Version 6.3.0 lag das Limit bei 5 Abrufanfragen in einem Zeitraum von 60 Minuten. Neuere Versionen haben großzügigere Limits.

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

Das Standard- und empfohlene Abrufintervall für die Produktion für Remote Config beträgt 12 Stunden. Das bedeutet, dass Konfigurationen unabhängig von der Anzahl der tatsächlich durchgeführten Abrufe nicht mehr als einmal in einem Zeitraum von 12 Stunden aus dem Backend abgerufen werden. Das Mindestabrufintervall wird in der folgenden Reihenfolge festgelegt:

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

Erste Schritte mit Remote Config unter iOS Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Schritt 1: Remote Config zu Ihrer App hinzufügen

Swift

Objective-C

Schritt 2: Standardparameterwerte in der App festlegen

REST

Firebase console

Swift

Objective-C

Schritt 3: Parameterwerte für Ihre App abrufen

Codable für typsichere Konfiguration verwenden

Property-Wrapper für deklarative Konfiguration in SwiftUI verwenden

Schritt 4: Parameterwerte festlegen

Swift

Objective-C

Schritt 5: Werte abrufen und aktivieren

Swift

Objective-C

Schritt 6: In Echtzeit auf Updates warten

Swift

Objective-C

Drosselung

Erste Schritte mit Remote Config unter iOS