Erste Schritte mit Firebase Remote Config

iOS+ Android Web Flutter Unity C++

Wichtig: In diesem Abschnitt wird beschrieben, wie Sie Remote Config mit mobilen und Webclients konfigurieren. 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 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-android geklont oder heruntergeladen werden kann.

Schritt 1: Firebase und das Remote Config SDK in die App einbinden

1. Falls noch nicht geschehen, Fügen Sie Ihrem Android-Projekt Firebase hinzu.

2. Für Remote Config ist Google Analytics erforderlich für: bedingtes Targeting von App-Instanzen Nutzereigenschaften und Zielgruppen. Achten Sie darauf, dass Sie aktivieren Google Analytics in Ihrem Projekt.

3. Fügen Sie in der Gradle-Datei des Moduls (auf Anwendungsebene) (in der Regel <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle) die Abhängigkeit für die Remote Config-Bibliothek für Android hinzu. Wir empfehlen die Verwendung des Firebase Android BoM um die Versionsverwaltung der Bibliothek zu steuern.

   Bei der Einrichtung von Analytics müssen Sie außerdem das Firebase SDK hinzufügen für Google Analytics zu deiner App.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.4.0"))
   
       // Add the dependencies for the Remote Config and Analytics libraries
       // When using the BoM, you don't specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-config")
       implementation("com.google.firebase:firebase-analytics")
   }
   

   Mit der Firebase Android BoM haben Sie immer eine kompatible Version der Firebase Android-Bibliotheken in Ihrer App.

   (Alternative) Firebase-Bibliotheksabhängigkeiten ohne BoM hinzufügen

   Wenn Sie Firebase BoM nicht verwenden, müssen Sie jede Firebase-Bibliotheksversion angeben in der Abhängigkeitszeile ein.

   Wenn Sie mehrere Firebase-Bibliotheken in Ihrer App verwenden, empfehlen wir Ihnen dringend, die Bibliotheksversionen mithilfe der BoM zu verwalten. So wird sichergestellt, dass alle Versionen kompatibel sind.

   dependencies {
       // Add the dependencies for the Remote Config and Analytics libraries
       // When NOT using the BoM, you must specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-config:22.0.0")
       implementation("com.google.firebase:firebase-analytics:22.1.2")
   }
   

   Sie suchen nach einem Kotlin-spezifischen Bibliotheksmodul? Beginnt in Oktober 2023 (Firebase BoM 32.5.0) können sowohl Kotlin- als auch Java-Entwickler sind vom Modul der Hauptbibliothek abhängig (Details finden Sie in der FAQs zu dieser Initiative).

Hinweis: Da das Android SDK von der Remote Config REST API abhängt, darf diese API nicht deaktiviert werden. Sie ist in einem typischen Projekt standardmäßig aktiviert.

Schritt 2: Remote Config-Singleton-Objekt abrufen

Rufen Sie eine Remote Config-Objektinstanz ab und legen Sie die minimales Abrufintervall, um häufige Aktualisierungen zu ermöglichen:

Kotlin+KTX

val remoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)
MainActivity.kt

Java

FirebaseRemoteConfig mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
        .setMinimumFetchIntervalInSeconds(3600)
        .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);
MainActivity.java

Das Singleton-Objekt wird verwendet, um In-App-Standardparameterwerte zu speichern, aktualisierte Parameterwerte aus dem Backend abzurufen und zu steuern, wann abgerufene Werte für Ihre App verfügbar gemacht werden.

Während der Entwicklung empfiehlt es sich, einen relativ niedrigen Mindestabrufwert festzulegen Intervall. Weitere Informationen finden Sie unter Drosselung. .

Schritt 3: Standardparameterwerte in der App 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 Werte. 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 mithilfe eines Map-Objekt oder ein XML-Ressourcendatei im Ordner res/xml deiner App gespeichert. Remote Config-Kurzanleitung Beispiel-App verwendet eine XML-Datei zum Definieren von Standardparameternamen und -werten.

   Wenn Sie Remote Config-Backend-Parameterwerte bereits konfiguriert haben, können Sie eine generierte XML-Datei herunterladen, die alle Standardwerte und speichern Sie sie im Verzeichnis res/xml Ihrer Anwendung:

   REST

   curl --compressed -D headers -H "Authorization: Bearer token" -X GET https://firebaseremoteconfig.googleapis.com/v1/projects/my-project-id/remoteConfig:downloadDefaults?format=XML -o remote_config_defaults.xml
   

   Firebase Console

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

   2. Aktivieren Sie auf Aufforderung .xml für Android und klicken Sie dann auf Datei herunterladen.

2. Fügen Sie diese Werte dem Remote Config-Objekt mit setDefaultsAsync(int) hinzu, wie hier gezeigt:

   Kotlin+KTX

   remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

   Java

   mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Schritt 4: Parameterwerte zur Verwendung in Ihrer App abrufen

Jetzt können Sie Parameterwerte aus dem Remote Config-Objekt abrufen. Wenn Sie Werte im Backend festlegen, abrufen und dann aktivieren, sind diese Werte für Ihre App verfügbar. Andernfalls werden die In-App-Parameterwerte zurückgegeben, die mit setDefaultsAsync(int) konfiguriert wurden. Rufen Sie dazu die unten aufgeführte Methode auf, die dem von Ihrer App erwarteten Datentyp zugeordnet ist, und geben Sie den Parameterschlüssel als Argument an:

• getBoolean()
• getDouble()
• getLong()
• getString()

Schritt 5: Parameterwerte im Remote Config-Backend festlegen

Mit der Firebase Console oder den Remote Config Backend-APIs können Sie neue serverseitige Standardwerte erstellen, die die In-App-Werte gemäß der gewünschten bedingten Logik oder dem Nutzer-Targeting überschreiben. Dieser Abschnitt beschreibt die Firebase-Konsolenschritte zum Erstellen dieser Werte.

1. Öffnen Sie in der Firebase Console Ihr Projekt.
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. Sie können für jeden Parameter einen Standardwert festlegen, der den entsprechenden In-App-Standardwert überschreibt. Außerdem können Sie bedingte Werte festlegen. Weitere Informationen finden Sie unter Remote Config Parameter und Bedingungen.

Schritt 6: Werte abrufen und aktivieren

1. Rufen Sie zum Abrufen von Parameterwerten aus dem Remote Config-Backend die Methode fetch() . Alle Werte, die Sie im Backend festlegen, werden abgerufen und im Remote Config-Objekt gespeichert.

2. Wenn Sie abgerufene Parameterwerte für Ihre App verfügbar machen möchten, rufen Sie die Methode activate() auf.

   Wenn Sie Werte in einem einzigen Aufruf abrufen und aktivieren möchten, können Sie eine fetchAndActivate()-Anfrage verwenden, um Werte aus dem Remote Config-Backend abzurufen und für die App verfügbar zu machen:

   Kotlin+KTX

   remoteConfig.fetchAndActivate()
       .addOnCompleteListener(this) { task ->
           if (task.isSuccessful) {
               val updated = task.result
               Log.d(TAG, "Config params updated: $updated")
               Toast.makeText(
                   this,
                   "Fetch and activate succeeded",
                   Toast.LENGTH_SHORT,
               ).show()
           } else {
               Toast.makeText(
                   this,
                   "Fetch failed",
                   Toast.LENGTH_SHORT,
               ).show()
           }
           displayWelcomeMessage()
       }

   Java

   mFirebaseRemoteConfig.fetchAndActivate()
           .addOnCompleteListener(this, new OnCompleteListener<Boolean>() {
               @Override
               public void onComplete(@NonNull Task<Boolean> task) {
                   if (task.isSuccessful()) {
                       boolean updated = task.getResult();
                       Log.d(TAG, "Config params updated: " + updated);
                       Toast.makeText(MainActivity.this, "Fetch and activate succeeded",
                               Toast.LENGTH_SHORT).show();
   
                   } else {
                       Toast.makeText(MainActivity.this, "Fetch failed",
                               Toast.LENGTH_SHORT).show();
                   }
                   displayWelcomeMessage();
               }
           });

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. wenn der Nutzer Ihre App das nächste Mal öffnet. Weitere Informationen und Beispiele finden Sie unter Ladestrategien für Remote Config.

Hinweis :Wenn Ihre App nicht mit Gradle erstellt wird, müssen Sie manuell den korrekten google_app_id-String-Ressource in Ihre App ein, damit Remote Config Initialisieren. Das Gradle-Plug-in google-services fügt dies normalerweise automatisch, aber Sie finden den entsprechenden Wert in der google-services.json-Datei, die Sie von der Firebase-Konsole herunterladen. Für Weitere Informationen zum Abrufen des google_app_id-Werts aus dem google-services.json-Datei, siehe JSON-Datei wird verarbeitet.

Schritt 7: In Echtzeit auf Updates warten

Nachdem Sie Parameterwerte abgerufen haben, können Sie Remote Config in Echtzeit verwenden, um Warten auf Aktualisierungen vom Remote Config-Back-End. 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 Android v21.3.0+ (Firebase BoM) unterstützt. v31.2.4 und höher).

Wichtig:Für Remote Config in Echtzeit ist außerdem die Firebase Remote Config Realtime API, die bereits für Sie aktiviert sein sollte. Öffnen Sie zum Bestätigen das Google Cloud-Konsole, wählen Sie Ihr Projekt aus und öffnen Sie die Seite APIs und Dienste. Die API sollte als aktiviert angezeigt werden. Wenn er fehlt oder nicht aktiviert ist, klicken Sie auf APIs aktivieren und Dienste suchen, suchen Sie nach Firebase Remote Config Realtime API und aktivieren.

1. Verwenden Sie in Ihrer App addOnConfigUpdateListener(), um nach Updates zu suchen und neue Parameterwerte automatisch abzurufen. Implementiere den onUpdate()-Callback, um die aktualisierte Konfiguration zu aktivieren.

   Kotlin+KTX

   remoteConfig.addOnConfigUpdateListener(object : ConfigUpdateListener {
       override fun onUpdate(configUpdate : ConfigUpdate) {
          Log.d(TAG, "Updated keys: " + configUpdate.updatedKeys);
   
          if (configUpdate.updatedKeys.contains("welcome_message")) {
              remoteConfig.activate().addOnCompleteListener {
                  displayWelcomeMessage()
              }
          }
       }
   
       override fun onError(error : FirebaseRemoteConfigException) {
           Log.w(TAG, "Config update error with code: " + error.code, error)
       }
   })
   

   Java

   mFirebaseRemoteConfig.addOnConfigUpdateListener(new ConfigUpdateListener() {
       @Override
       public void onUpdate(ConfigUpdate configUpdate) {
           Log.d(TAG, "Updated keys: " + configUpdate.getUpdatedKeys());
           mFirebaseRemoteConfig.activate().addOnCompleteListener(new OnCompleteListener<Boolean>() {
               @Override
               public void onComplete(@NonNull Task<Boolean> task) {
                   displayWelcomeMessage();
               }
           });
       }
       @Override
       public void onError(FirebaseRemoteConfigException error) {
           Log.w(TAG, "Config update error with code: " + error.getCode(), error);
       }
   });
   

2. Wenn du das nächste Mal eine neue Version von Remote Config veröffentlichst, werden die Geräte die Ihre App ausführen und auf Änderungen warten, ConfigUpdateListener.

Drosselung

Wenn eine App innerhalb eines kurzen Zeitraums zu oft Daten abruft, werden Abrufaufrufe gedrosselt und das SDK gibt FirebaseRemoteConfigFetchThrottledException Vor der SDK-Version 17.0.0 waren fünf Abrufanfragen in einem 60-Minuten-Fenster zulässig. In neueren Versionen sind die Limits großzügiger.

Tipp:Ab Android SDK Version 21.3.0 oder höher (Firebase BoM ab Version 31.3.0) können Sie in Echtzeit Remote Config, um automatisch aktualisierte Parameterwerte aus der Remote Config-Backend unmittelbar nach ihrer Veröffentlichung. Dadurch werden Mindestanforderungen umgangen. Einstellung für das Abrufintervall. Weitere Informationen finden Sie unter In Echtzeit nach Updates suchen.

Während der App-Entwicklung kann es sinnvoll sein, Konfigurationen direkt abzurufen und zu aktivieren. häufig (viele Male pro Stunde), damit Sie schnell iterieren können, während Sie um Ihre App zu testen. Echtzeitaktualisierungen von Remote Config umgehen automatisch den wenn die Konfiguration auf dem Server aktualisiert wird. Um die schnelle Wiederholung eines Projekts mit bis zu 10 Entwicklern zu ermöglichen, können Sie in Ihrer App vorübergehend ein FirebaseRemoteConfigSettings-Objekt mit einem kurzen Mindestabrufintervall (setMinimumFetchIntervalInSeconds) festlegen.

Das standardmäßige Mindestabrufintervall für 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 bedeutet das Das minimale Abrufintervall wird in dieser Reihenfolge bestimmt:

1. Der Parameter in fetch(long)
2. Der Parameter in FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
3. Der Standardwert von 12 Stunden

Wenn Sie das Mindestabrufintervall auf einen benutzerdefinierten Wert festlegen möchten, verwenden Sie FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long).

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 an, falls Sie dies noch nicht getan haben Anwendungsfälle und sehen uns einige der Schlüsselkonzepte und Dokumentation zu erweiterten Strategien, einschließlich:

• Remote Config Vorlagenversionen verwalten
• Ladestrategien für Konfigurationen