Erste Schritte mit Firebase Remote Config


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 zu verteilen. In dieser Anleitung werden die ersten Schritte beschrieben und es wird Beispielcode bereitgestellt, der aus dem firebase/quickstart-android-GitHub-Repository geklont oder heruntergeladen werden kann.

Schritt 1: Firebase und das Remote Config SDK in die App einfügen

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

  2. Für Remote Config ist Google Analytics erforderlich, um das bedingte Targeting von App-Instanzen auf Nutzereigenschaften und Zielgruppen zu ermöglichen. Achten Sie darauf, dass Sie Google Analytics in Ihrem Projekt aktivieren.

  3. Fügen Sie in der Gradle-Datei Ihres Moduls (auf App-Ebene) (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 Firebase Android BoM zu verwenden, um die Versionsverwaltung der Bibliothek zu steuern.

    Außerdem müssen Sie im Rahmen der Einrichtung von Analytics das Firebase SDK für Google Analytics in Ihre App einfügen.

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:34.0.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 von 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 zum Verwalten von Bibliotheksversionen zu verwenden, um sicherzustellen, 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:23.0.0")
    implementation("com.google.firebase:firebase-analytics:23.0.0")
}

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 Standardparameterwerte in der App 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 Mindestintervall für den Abruf festzulegen. Weitere Informationen finden Sie unter Drosselung.

Schritt 3: In-App-Standardparameterwerte festlegen

Sie können Standardparameterwerte für In-App-Konfigurationen im Remote Config-Objekt festlegen, damit sich Ihre App wie vorgesehen 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 Map-Objekt oder einer XML-Ressourcendatei, die im Ordner res/xml Ihrer App gespeichert ist. In der Remote Config-Schnellstart-Beispiel-App werden Standardparameternamen und -werte in einer XML-Datei definiert.

    Wenn Sie bereits Remote Config-Backend-Parameterwerte konfiguriert haben, können Sie eine generierte XML-Datei mit allen Standardwerten herunterladen und im res/xml-Verzeichnis Ihrer App 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

    Firebase Console

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

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

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

    Kotlin 

    remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java 

    mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Schritt 4: Parameterwerte für die Verwendung in Ihrer App abrufen

Sie können jetzt 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 erhalten Sie die In-App-Parameterwerte, die mit setDefaultsAsync(int) konfiguriert wurden. Rufen Sie die unten aufgeführte Methode auf, die dem von Ihrer App erwarteten Datentyp entspricht, und geben Sie den Parameterschlüssel als Argument an, um diese Werte abzurufen:

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 entsprechend der gewünschten bedingten Logik oder des Nutzer-Targetings überschreiben. In diesem Abschnitt wird beschrieben, wie Sie diese Werte in der Firebase-Konsole erstellen.

  1. Öffnen Sie Ihr Projekt in der Firebase-Konsole.
  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. Für jeden Parameter können Sie 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.

  4. 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. Damit abgerufene Parameterwerte für Ihre App verfügbar sind, 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 Erscheinungsbild Ihrer App auswirken, sollten Sie die abgerufenen Werte zu einem Zeitpunkt aktivieren, der für eine reibungslose Nutzererfahrung sorgt, z. B. beim nächsten Öffnen der App durch den Nutzer. Weitere Informationen und Beispiele finden Sie unter Remote Config-Ladestrategien.

Schritt 7: Echtzeit-Updates anhören

Nachdem Sie Parameterwerte abgerufen haben, können Sie mit Echtzeit-Remote Config auf Aktualisierungen vom Remote Config-Backend warten. Remote Config-Signale in Echtzeit werden an verbundene Geräte gesendet, wenn Updates verfügbar sind. Die Änderungen werden automatisch abgerufen, nachdem Sie eine neue Remote Config-Version veröffentlicht haben.

Echtzeit-Updates werden vom Firebase SDK für Android 21.3.0+ (Firebase BoM 31.2.4+) unterstützt.

  1. Verwenden Sie in Ihrer App addOnConfigUpdateListener(), um mit dem Abrufen von Updates zu beginnen und automatisch alle neuen 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 Abrufe gedrosselt und das SDK gibt FirebaseRemoteConfigFetchThrottledException zurück. Vor SDK-Version 17.0.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 Konfigurationen sehr häufig (mehrmals pro Stunde) abrufen und aktivieren, um schnell Iterationen durchführen zu können. Bei Echtzeit-Remote Config-Updates wird der Cache automatisch umgangen, wenn die Konfiguration auf dem Server aktualisiert wird. Um schnelle Iterationen an einem Projekt mit bis zu 10 Entwicklern zu ermöglichen, 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 unabhängig davon, wie viele Abrufe tatsächlich erfolgen, nicht öfter als einmal innerhalb von 12 Stunden vom Backend abgerufen werden. Das minimale Abrufintervall 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 Mindestabrufintervall auf einen benutzerdefinierten Wert festlegen möchten, verwenden Sie FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long).

Nächste Schritte

Falls Sie das noch nicht getan haben, sehen Sie sich die Remote Config Anwendungsfälle an und lesen Sie die Dokumentation zu einigen der wichtigsten Konzepte und erweiterten Strategien, darunter: