Beginnen Sie mit Firebase Remote Config


Sie können Firebase Remote Config verwenden, um Parameter in Ihrer App zu definieren und ihre Werte in der Cloud zu aktualisieren, sodass Sie das Erscheinungsbild und Verhalten Ihrer App ändern können, ohne ein App-Update zu verteilen. Dieser Leitfaden führt Sie durch die Schritte für den Einstieg und stellt einige Beispielcodes bereit, die alle zum Klonen oder Herunterladen aus dem GitHub-Repository firebase/quickstart-android verfügbar sind.

Schritt 1: Fügen Sie Firebase und das Remote Config SDK zu Ihrer App hinzu

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

  2. Für Remote Config ist Google Analytics für die bedingte Ausrichtung von App-Instanzen auf Benutzereigenschaften und Zielgruppen erforderlich. Stellen Sie sicher, dass Sie Google Analytics in Ihrem Projekt aktivieren .

  3. Fügen Sie in Ihrer Modul-Gradle-Datei (auf App-Ebene) (normalerweise <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle ) die Abhängigkeit für die Remote-Konfiguration hinzu Bibliothek für Android. Wir empfehlen die Verwendung der Firebase Android BoM zur Steuerung der Bibliotheksversionierung.

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

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:32.7.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")
}

    Durch die Verwendung der Firebase Android BoM verwendet Ihre App immer kompatible Versionen der Firebase Android-Bibliotheken.

    (Alternative) Fügen Sie Firebase-Bibliotheksabhängigkeiten hinzu , ohne die Stückliste zu verwenden

    Wenn Sie die Firebase-Stückliste nicht verwenden möchten, müssen Sie jede Firebase-Bibliotheksversion in ihrer Abhängigkeitszeile angeben.

    Beachten Sie: Wenn Sie mehrere Firebase-Bibliotheken in Ihrer App verwenden, empfehlen wir dringend, die BoM zum Verwalten der 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:21.6.0")
    implementation("com.google.firebase:firebase-analytics:21.5.0")
}
    Suchen Sie nach einem Kotlin-spezifischen Bibliotheksmodul? Ab Oktober 2023 (Firebase BoM 32.5.0) können sich sowohl Kotlin- als auch Java-Entwickler auf das Hauptbibliotheksmodul verlassen (Einzelheiten finden Sie in den FAQ zu dieser Initiative ).

Schritt 2: Rufen Sie das Remote Config-Singleton-Objekt ab

Rufen Sie eine Remote Config-Objektinstanz ab und legen Sie das Mindestabrufintervall fest, 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 vom Backend abzurufen und zu steuern, wann abgerufene Werte Ihrer App zur Verfügung gestellt 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 In-App-Standardparameterwerte im Remote Config-Objekt festlegen, sodass sich Ihre App wie vorgesehen verhält, bevor sie eine Verbindung zum Remote Config-Backend herstellt, und sodass Standardwerte verfügbar sind, wenn im Backend keine festgelegt sind.

  1. Definieren Sie einen Satz von Parameternamen und Standardparameterwerten mithilfe eines Map- Objekts oder einer XML-Ressourcendatei, die im Ordner res/xml Ihrer App gespeichert ist. Die Schnellstart-Beispiel-App „Remote Config“ verwendet eine XML-Datei , um Standardparameternamen und -werte zu definieren.

    Wenn Sie bereits Parameterwerte für das Remote Config-Backend konfiguriert haben, können Sie eine generierte XML-Datei herunterladen, die alle Standardwerte enthält, und sie im Verzeichnis res/xml Ihrer App speichern:

    AUSRUHEN

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

    1. Öffnen Sie auf der Registerkarte „Parameter“ das Menü und wählen Sie „Standardwerte herunterladen“ aus.

    2. 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) zum Remote Config-Objekt hinzu, wie gezeigt:

    Kotlin+KTX

    remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java

    mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Schritt 4: Rufen Sie Parameterwerte zur Verwendung in Ihrer App ab

Jetzt können Sie Parameterwerte vom Remote Config-Objekt abrufen. Wenn Sie im Backend Werte festlegen, diese abrufen und dann aktivieren, stehen diese Werte Ihrer App zur Verfügung. Andernfalls erhalten Sie die mit setDefaultsAsync(int) konfigurierten In-App-Parameterwerte. Um diese Werte zu erhalten, rufen Sie die unten aufgeführte Methode auf, die dem von Ihrer App erwarteten Datentyp zuordnet, und geben Sie den Parameterschlüssel als Argument an:

Schritt 5: Parameterwerte im Remote Config-Backend festlegen

Mit der Firebase-Konsole oder den Remote Config-Backend-APIs können Sie neue serverseitige Standardwerte erstellen, die die In-App-Werte entsprechend Ihrer gewünschten bedingten Logik oder Benutzerausrichtung überschreiben. In diesem Abschnitt werden die Schritte der Firebase-Konsole zum Erstellen dieser Werte beschrieben.

  1. Öffnen Sie in der Firebase-Konsole Ihr Projekt.
  2. Wählen Sie „Remote-Konfiguration“ aus dem Menü, um das Remote-Konfigurations-Dashboard anzuzeigen.
  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 letztendlich den entsprechenden In-App-Standardwert überschreibt) und Sie können auch bedingte Werte festlegen. Weitere Informationen finden Sie unter Remote-Konfigurationsparameter und -Bedingungen .

Schritt 6: Werte abrufen und aktivieren

  1. Um Parameterwerte vom Remote Config-Backend abzurufen, rufen Sie die Methode fetch() auf. Alle Werte, die Sie im Backend festlegen, werden abgerufen und im Remote Config-Objekt gespeichert.

  2. Um abgerufene Parameterwerte für Ihre App verfügbar zu machen, rufen Sie die Methode activate() auf.

    In Fällen, in denen 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 sie der App zur Verfügung zu stellen:

    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 ein reibungsloses Erlebnis für Ihren Benutzer gewährleistet, z. B. wenn der Benutzer Ihre App das nächste Mal öffnet. Weitere Informationen und Beispiele finden Sie unter Ladestrategien für Remote-Konfigurationen .

Schritt 7: Warten Sie in Echtzeit auf Aktualisierungen

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

Echtzeit-Updates werden vom Firebase SDK für Android v21.3.0+ (Firebase BoM v31.2.4+) unterstützt.

  1. Verwenden Sie in Ihrer App addOnConfigUpdateListener() , um mit der Suche nach Updates zu beginnen und alle neuen Parameterwerte automatisch abzurufen. Implementieren Sie den Rückruf onUpdate() , 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() {
            @Override
            public void onComplete(@NonNull Task 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 Ihrer Remote-Konfiguration veröffentlichen, rufen Geräte, auf denen Ihre App ausgeführt wird und auf Änderungen wartet, den ConfigUpdateListener auf.

Drosselung

Wenn eine App in einem kurzen Zeitraum zu oft Abrufe durchführt, werden 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-Minuten-Fenster (neuere Versionen haben freizügigere Limits).

Während der App-Entwicklung möchten Sie Konfigurationen möglicherweise sehr häufig (mehrmals pro Stunde) abrufen und aktivieren, damit Sie beim Entwickeln und Testen Ihrer App schnell iterieren können. Remote-Konfigurationsaktualisierungen in Echtzeit umgehen automatisch den Cache, wenn die Konfiguration auf dem Server aktualisiert wird. Um eine schnelle Iteration eines Projekts 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, was bedeutet, dass Konfigurationen nicht mehr als einmal in einem 12-Stunden-Fenster vom Backend abgerufen werden, unabhängig davon, wie viele Abrufaufrufe tatsächlich getätigt werden. Insbesondere wird das minimale Abrufintervall in der folgenden Reihenfolge bestimmt:

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

Um das minimale Abrufintervall auf einen benutzerdefinierten Wert festzulegen, verwenden Sie FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long) .

Nächste Schritte

Wenn Sie es noch nicht getan haben, erkunden Sie die Remote -Konfigurations -Anwendungsfälle und sehen Sie sich einige der wichtigsten Konzepte und erweiterten Strategien an, darunter: