Erste Schritte mit Remote Config unter iOS

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 Verhalten Ihrer App ändern, ohne ein App-Update veröffentlichen zu müssen. In diesem Leitfaden werden die ersten Schritte beschrieben und es wird Beispielcode bereitgestellt, den Sie aus dem GitHub-Repository firebase/quickstart-ios klonen oder herunterladen können.

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 für das bedingte Targeting von App-Instanzen auf Nutzereigenschaften und Zielgruppen erforderlich. 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

   let remoteConfig = RemoteConfig.remoteConfig()
   let settings = RemoteConfigSettings()
   settings.minimumFetchInterval = 0
   RemoteConfig.remoteConfig().configSettings = settings
   MigratedSnippets.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 In-App-Standardparameterwerte 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 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 Standardparameterwerte für die App 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.

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
   

   Sie können ein Inhabertoken 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 kurzlebig. Wenn Sie einen Authentifizierungsfehler erhalten, müssen Sie es möglicherweise neu generieren.

   Firebase-Konsole

   1. Rufen Sie in der Firebase-Konsole die Seite DevOps & Engagement > Remote Config > Parameter auf.

   2. Öffnen Sie das more_vert Menü und wählen Sie Standardwerte herunterladen aus.

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

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

   Swift

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

   Objective-C

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

Schritt 3: Parameterwerte zur Verwendung in Ihrer App abrufen

Jetzt können Sie Parameterwerte aus dem Remote Config-Objekt abrufen. Wenn Sie später Werte im Remote Config-Backend festlegen, diese 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

Eine besser lesbare und bequemere Möglichkeit, auf diese Werte in Swift zuzugreifen, ist die Subskript-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. 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 können Sie Folgendes tun:

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

Property Wrapper für die deklarative Konfiguration in SwiftUI verwenden

Property Wrapper sind ein leistungsstarkes Swift-Feature, mit dem 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 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 gemäß der gewünschten bedingten Logik oder dem gewünschten Nutzer-Targeting überschreiben. In diesem Abschnitt werden die Schritte in der Firebase Console zum Erstellen dieser Werte beschrieben.

1. Rufen Sie in der Firebase-Konsole die Seite DevOps & Engagement > Remote Config > Parameter auf.

2. 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 schließlich den Standardwert in der App überschreibt. Außerdem können Sie bedingte Werte festlegen. Weitere Informationen finden Sie unter Remote Config-Parameter und -Bedingungen.

3. 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

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 Aufruf abrufen und aktivieren möchten, verwenden Sie fetchAndActivateWithCompletionHandler:.

In diesem Beispiel werden Werte aus dem Remote Config-Backend abgerufen (nicht im Cache gespeicherte Werte) und activateWithCompletionHandler: aufgerufen, um sie der App zur Verfügung zu stellen:

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

[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 Ihrer App auswirken, sollten Sie die abgerufenen Werte zu einem Zeitpunkt aktivieren, der eine reibungslose Nutzung für den Nutzer ermöglicht, z. B. wenn der Nutzer Ihre App das nächste Mal öffnet. Weitere Informationen und Beispiele finden Sie unter Ladestrategien für Remote Config.

Schritt 6: Auf Updates in Echtzeit warten

Nachdem Sie Parameterwerte abgerufen haben, können Sie mit Echtzeit-Remote Config auf Aktualisierungen vom Remote Config-Backend warten. In Echtzeit signalisiert Remote Config verbundenen Geräten, wenn Updates verfügbar sind, und ruft die Änderungen automatisch ab, 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 auf Updates zu warten und automatisch neue oder aktualisierte 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 Ihrer Remote Config veröffentlichen, rufen Geräte, auf denen Ihre App ausgeführt wird und die auf Änderungen warten, den Abschluss-Handler auf.

Drosselung

Wenn eine App innerhalb eines kurzen Zeitraums zu viele Abrufe durchführt, werden die Abrufaufrufe gedrosselt und das SDK gibt FIRRemoteConfigFetchStatusThrottled zurück. Vor SDK-Version 6.3.0 lag das Limit bei 5 Abrufanfragen in einem 60-minütigen Zeitfenster (neuere Versionen haben weniger strenge Limits).

Während der App-Entwicklung möchten Sie möglicherweise häufiger abrufen, um den Cache sehr oft (mehrmals pro Stunde) zu aktualisieren, damit Sie Ihre App schnell entwickeln und testen können. Bei Echtzeit-Remote Config-Updates 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 in Ihrer App vorübergehend ein FIRRemoteConfigSettings-Attribut mit einem niedrigen Mindestabrufintervall (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 innerhalb von 12 Stunden nicht mehr als einmal vom Backend abgerufen werden, unabhängig davon, wie viele Abrufaufrufe tatsächlich erfolgen. 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