Erste Schritte mit Firebase Remote Config

iOS+ Android Web Flutter Unity C++

Wichtig :In diesem Abschnitt wird beschrieben, wie du Remote Config mit mobilen und Webclients konfigurierst. Informationen zu Serverumgebungen finden Sie unter Remote Config in Serverumgebungen verwenden.

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 bereitzustellen. In dieser Anleitung werden die ersten Schritte erläutert und es wird Beispielcode bereitgestellt, der aus dem GitHub-Repository firebase/quickstart-ios geklont oder heruntergeladen werden kann.

Schritt 1: Remote Config zur App hinzufü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. Aktivieren Sie Google Analytics in Ihrem Projekt.

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 In-App-Standardparameterwerte gespeichert, aktualisierte Parameterwerte aus dem Remote Config-Backend abgerufen und festgelegt, wann abgerufene Werte für Ihre App verfügbar gemacht werden.

Während der Entwicklung wird empfohlen, ein relativ niedriges Mindestabrufintervall festzulegen. Weitere Informationen finden Sie unter Drosselung.

Schritt 2: In-App-Standardparameterwerte festlegen

Sie können im Remote Config-Objekt In-App-Standardparameterwerte festlegen, damit sich Ihre App wie vorgesehen verhält, bevor eine Verbindung zum Remote Config-Backend hergestellt wird. Außerdem sind dann Standardwerte verfügbar, falls im Backend keine festgelegt sind.

Wichtig: Speichern Sie keine vertraulichen Daten in Remote Config-Parameterschlüsseln oder ‑werten. Remote Config-Daten werden während der Übertragung verschlüsselt, aber Endnutzer können auf alle Standard- oder abgerufenen Remote Config-Parameter zugreifen, die für ihre Client-App-Instanz verfügbar 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-Konsole

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

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

2. Fügen Sie diese Werte dem Remote Config-Objekt mit setDefaults: 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

Hinweis: Diese Code-Snippets beziehen sich auf die Datei RemoteConfigDefaults.plist aus dem Beispielprojekt quickstart-ios. Wenn Sie die heruntergeladene Standarddatei verwenden, verwenden Sie remote_config_defaults.

Schritt 3: Parameterwerte für die Verwendung in Ihrer 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 werden die In-App-Parameterwerte verwendet, die mit setDefaults: konfiguriert wurden. Rufen Sie dazu die Methode configValueForKey: mit dem Parameterschlüssel als Argument auf.

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 übersichtlichere und praktischere Möglichkeit, in Swift auf diese Werte zuzugreifen, ist die Unterindizierung:

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 eine typsichere Konfiguration verwenden

Bei komplexeren 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
• Sorgen Sie für Typsicherheit beim Zugriff auf Remote Config-Werte.
• Verwenden Sie sauberen, gut lesbaren Code für die Verarbeitung strukturierter Remote Config-Vorlagen.

Property Wrappers für die 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-Verhalten zu verwalten. Weitere Informationen finden Sie im Swift-Sprachleitfaden.

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 deklarativ auf Remote Config-Werte in SwiftUI zugreifen möchten. Er bietet integrierte Unterstützung für Standardwerte und eine vereinfachte Konfigurationsverwaltung.

Schritt 4: Parameterwerte festlegen

Mit der Firebase Console oder den Remote Config Backend-APIs können Sie neue Backend-Standardwerte erstellen, die die In-App-Werte gemäß der gewünschten bedingten Logik oder dem Nutzer-Targeting überschreiben. In diesem Abschnitt wird beschrieben, wie Sie diese Werte in der Firebase-Konsole erstellen.

1. Öffnen Sie in der Firebase Console Ihr Projekt.
2. Wählen Sie im Menü Remote Config aus, um das Dashboard für Remote Config aufzurufen.
3. Definieren Sie Parameter mit denselben Namen wie die Parameter in Ihrer App. Sie können für jeden Parameter einen Standardwert festlegen, der den In-App-Standardwert überschreibt, und auch 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 eine benutzerdefinierte Signalbedingung definiert wird.

   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

Wenn Sie Parameterwerte aus Remote Config abrufen möchten, rufen Sie die Methode fetchWithCompletionHandler: oder fetchWithExpirationDuration:completionHandler: auf. Alle Werte, die Sie im Backend festlegen, werden abgerufen und im Remote Config-Objekt im Cache gespeichert.

Wenn Sie Werte in einem einzigen 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: 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 das Erscheinungsbild Ihrer App auswirken, sollten Sie die abgerufenen Werte zu einem Zeitpunkt aktivieren, der eine reibungslose Nutzung für Ihre Nutzer gewährleistet, z. B. beim nächsten Öffnen Ihrer App. Weitere Informationen und Beispiele finden Sie unter Ladestrategien für Remote Config.

Schritt 6: Updates in Echtzeit abrufen

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

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

Wichtig:Für Echtzeit-Remote Config ist auch die Firebase Remote Config-Realtime API erforderlich, die bereits für Sie aktiviert sein sollte. Öffnen Sie dazu die Google Cloud Console, wählen Sie Ihr Projekt aus und öffnen Sie die Seite APIs und Dienste. Die API sollte als aktiviert angezeigt werden. Wenn sie fehlt oder nicht aktiviert ist, klicken Sie auf APIs & Dienste aktivieren, suchen Sie nach Firebase Remote Config Realtime API und aktivieren Sie sie.

1. Rufen Sie in Ihrer App addOnConfigUpdateListener auf, um nach Updates zu suchen und neue oder aktualisierte Parameterwerte automatisch abzurufen. Im folgenden Beispiel wird auf Aktualisierungen 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];
         });
       }];
     }
   }];

2. Wenn Sie das nächste Mal eine neue Version Ihrer Remote Config veröffentlichen, wird der Abschluss-Handler auf Geräten aufgerufen, auf denen Ihre App ausgeführt wird und die auf Änderungen warten.

Drosselung

Wenn eine App innerhalb kurzer Zeit zu oft abgerufen wird, werden Abrufaufrufe gedrosselt und das SDK gibt FIRRemoteConfigFetchStatusThrottled zurück. Vor der SDK-Version 6.3.0 waren maximal fünf Abrufanfragen innerhalb eines Zeitraums von 60 Minuten zulässig. In neueren Versionen sind die Limits großzügiger.

Tipp:Ab der SDK-Version 10.7.0 für Apple-Plattformen können Sie mithilfe von Remote Config in Echtzeit aktualisierte Parameterwerte automatisch aus dem Remote Config-Backend abrufen, sobald sie veröffentlicht werden. Dabei wird das Mindestabrufintervall ignoriert. Sie können Echtzeitaktualisierungen verwenden, anstatt den Cache häufig abzurufen. Weitere Informationen finden Sie unter In Echtzeit nach Updates suchen.

Während der App-Entwicklung sollten Sie die Daten häufiger abrufen, um den Cache sehr häufig (mehrmals pro Stunde) zu aktualisieren. So können Sie bei der Entwicklung und dem Testen Ihrer App schnell iterieren. Bei Echtzeit-Remote-Config-Aktualisierungen wird der Cache automatisch umgangen, wenn die Konfiguration auf dem Server aktualisiert wird. Wenn Sie ein Projekt mit zahlreichen Entwicklern schnell iterieren möchten, können Sie Ihrer App vorübergehend eine FIRRemoteConfigSettings-Property mit einem kurzen Mindestabrufintervall (MinimumFetchInterval) hinzufügen.

Das standardmäßige und empfohlene Abrufintervall für die Produktion von Remote Config beträgt 12 Stunden. Das bedeutet, dass Konfigurationen innerhalb eines 12-Stunden-Zeitraums nicht mehr als einmal aus dem Backend abgerufen werden, unabhängig davon, wie viele Abrufaufrufe tatsächlich ausgeführt werden. Konkret wird das minimale Abrufintervall in der folgenden Reihenfolge ermittelt:

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

Diese Einstellung sollte nur für die Entwicklung verwendet werden, nicht für eine App, die in der Produktion ausgeführt wird. Wenn Sie Ihre App nur mit einem kleinen Entwicklungsteam von 10 Personen testen, werden Sie die stündlichen kontingentbasierten Limits für den Dienst wahrscheinlich nicht erreichen. Wenn Sie Ihre App jedoch mit einem sehr kurzen Mindestabrufintervall für Tausende von Testnutzern veröffentlichen, wird dieses Kontingent wahrscheinlich erreicht.

Nächste Schritte

Sehen Sie sich die Remote Config Anwendungsfälle an und lesen Sie die Dokumentation zu wichtigen Konzepten und erweiterten Strategien, darunter:

• Remote Config-Vorlagenversionen verwalten
• Strategien zum Laden von Konfigurationen