Erste Schritte mit Remote Config unter Android

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 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-android klonen oder herunterladen können.

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

1. Falls noch nicht geschehen, fügen Sie Ihrem Android-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 Google Analytics in Ihrem Projekt aktiviert ist.

3. Fügen Sie in der Gradle-Datei des Moduls (auf App-Ebene) (normalerweise <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle) Abhängigkeiten für die Remote Config- und Analytics-Bibliotheken für Android hinzu. Wir empfehlen, die Firebase Android BoM zu verwenden, um die Bibliotheksversionierung zu steuern.

   Im Rahmen der Einrichtung von Analytics müssen Sie Ihrer App außerdem das Firebase SDK für Google Analytics hinzufügen.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:35.1.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 Verwendung der BoM hinzufügen

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

   Wenn Sie mehrere Firebase-Bibliotheken in Ihrer App verwenden, empfehlen wir dringend, die BoM zur Verwaltung der Bibliotheksversionen zu verwenden. 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:24.0.1")
       implementation("com.google.firebase:firebase-analytics:24.0.0")
   }

Hinweis: Da das Android SDK von der Remote Config REST API abhängig ist, dürfen Sie diese API nicht deaktivieren. Sie ist in einem typischen Projekt standardmäßig aktiviert.

Schritt 2: Remote Config-Singleton-Objekt abrufen

Erstellen Sie eine Remote Config-Objektinstanz und legen Sie das Mindestabrufintervall fest, um häufige Aktualisierungen zu ermöglichen:

Kotlin

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 wird empfohlen, ein relativ niedriges Mindestabrufintervall festzulegen. Weitere Informationen finden Sie unter Drosselung.

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

Wichtig: Speichern Sie keine vertraulichen Daten in Remote Config-Parameterschlüsseln oder -werten. Remote Config-Daten werden bei 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-Objekts oder einer XML-Ressourcendatei, die im Ordner res/xml Ihrer App gespeichert ist. In der Beispiel-App für den Remote Config-Schnellstart wird eine XML-Datei verwendet, um Standardparameternamen und -werte zu definieren.

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

   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
   

   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-Console die Seite DevOps & Engagement > Remote Config > Parameter auf.

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

   3. Wenn Sie dazu aufgefordert werden, aktivieren Sie .xml für Android und klicken Sie dann auf Datei herunterladen.

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

   Kotlin

   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, sie abrufen und dann aktivieren, sind diese Werte für Ihre App verfügbar. Andernfalls erhalten Sie die In-App-Parameterwerte, die mit setDefaultsAsync(int) konfiguriert wurden. Wenn Sie diese Werte abrufen möchten, rufen Sie die im folgenden Code aufgeführte Methode auf, die dem von Ihrer App erwarteten Datentyp entspricht. Geben Sie dabei den Parameterschlüssel als Argument an:

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

Schritt 5: Parameterwerte im Remote Config-Backend festlegen

Über die Firebase Console oder die Remote Config Backend APIs können Sie neue serverseitige 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-Console 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 entsprechenden In-App-Standardwert ü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.

   Kotlin

           val customSignals = customSignals {
               put("city", "Tokyo")
               put("preferred_event_category", "sports")
           }
   
           remoteConfig.setCustomSignals(customSignals)
       

   Java

           CustomSignals customSignals = new CustomSignals.Builder()
               .put("city", "Tokyo")
               .put("preferred_event_category", "sports")
               .build();
   
           mFirebaseRemoteConfig.setCustomSignals(customSignals);
   
       

Schritt 6: Werte abrufen und aktivieren

1. Wenn Sie Parameterwerte aus dem Remote Config-Backend abrufen möchten, rufen Sie die Methode fetch() auf. Alle Werte, die Sie im Backend festlegen, werden abgerufen und im Remote Config-Objekt gespeichert.

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

   Wenn Sie Werte in einem 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

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

Hinweis: Wenn Ihre App nicht mit Gradle erstellt wird, müssen Sie die richtige String-Ressource google_app_id manuell zu Ihrer App hinzufügen, damit Remote Config initialisiert werden kann. Das Gradle-Plug-in google-services fügt diesen normalerweise automatisch hinzu. Sie finden den entsprechenden Wert aber auch in der Konfigurationsdatei google-services.json, die Sie von der Firebase-Konsole herunterladen können. Weitere Informationen zum Abrufen des google_app_id-Werts aus der google-services.json-Konfigurationsdatei finden Sie unter So wird die JSON-Konfigurationsdatei verarbeitet.

Schritt 7: Echtzeit-Updates erhalten

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.

Echtzeitaktualisierungen werden vom Firebase SDK für Android ab Version 21.3.0 (Firebase BoM ab Version 31.2.4) 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 zur Überprüfung 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 und Dienste aktivieren, suchen Sie nach Firebase Remote Config Realtime API und aktivieren Sie sie.

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

   Kotlin

   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 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, die ConfigUpdateListener auf.

Drosselung

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

Tipp: Ab Android SDK-Version 21.3.0 (Firebase BoM-Version 31.3.0) können Sie mit Echtzeit-Remote Config aktualisierte Parameterwerte automatisch aus dem Remote Config-Backend abrufen, sobald sie veröffentlicht werden. Dabei wird die Einstellung für das minimale Abrufintervall umgangen. Weitere Informationen finden Sie unter Auf Aktualisierungen in Echtzeit warten.

Während der App-Entwicklung möchten Sie Konfigurationen möglicherweise sehr häufig (mehrmals pro Stunde) abrufen und aktivieren, um die App schnell zu iterieren und zu testen. Bei Echtzeit-Remote Config-Updates wird der Cache automatisch umgangen, wenn die Konfiguration auf dem Server aktualisiert wird. Wenn Sie ein Projekt mit bis zu zehn Entwicklern schnell iterieren möchten, können Sie in Ihrer App vorübergehend ein FirebaseRemoteConfigSettings-Objekt mit einem niedrigen Mindestabrufintervall (setMinimumFetchIntervalInSeconds) festlegen.

Das standardmäßige Mindestabrufintervall 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 Mindestabrufintervall wird in der folgenden Reihenfolge bestimmt:

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

Wenn Sie das minimale Abrufintervall 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 Anwendung nur mit einem kleinen Entwicklungsteam von 10 Personen testen, ist es unwahrscheinlich, dass Sie die stündlichen Kontingentlimits auf Dienstseite erreichen. Wenn Sie Ihre App jedoch mit einem sehr niedrigen Mindestabrufintervall für Tausende von Testnutzern bereitstellen, wird dieses Kontingent wahrscheinlich erreicht.