Zacznij korzystać ze zdalnej konfiguracji Firebase


Za pomocą Firebase Remote Config możesz definiować parametry w swojej aplikacji i aktualizować ich wartości w chmurze, co pozwala modyfikować wygląd i zachowanie aplikacji bez rozpowszechniania aktualizacji aplikacji. Ten przewodnik przeprowadzi Cię przez kolejne kroki i zawiera przykładowy kod, który można sklonować lub pobrać z repozytorium GitHub Firebase/quickstart-Android .

Krok 1: Dodaj Firebase i pakiet SDK do zdalnej konfiguracji do swojej aplikacji

  1. Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu na Androida .

  2. W przypadku zdalnej konfiguracji wymagana jest usługa Google Analytics do warunkowego kierowania instancji aplikacji na właściwości użytkownika i odbiorców. Upewnij się, że masz włączoną usługę Google Analytics w swoim projekcie.

  3. W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle ) dodaj zależność dla Remote Config biblioteka dla Androida. Zalecamy używanie Firebase Android BoM do kontrolowania wersji bibliotek.

    Ponadto w ramach konfigurowania Analytics musisz dodać do swojej aplikacji pakiet SDK Firebase dla Google Analytics.

    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")
}

    Korzystając z Firebase Android BoM , Twoja aplikacja będzie zawsze korzystać z kompatybilnych wersji bibliotek Firebase Android.

    (Alternatywa) Dodaj zależności biblioteki Firebase bez użycia BoM

    Jeśli zdecydujesz się nie używać BoM Firebase, musisz określić każdą wersję biblioteki Firebase w jej wierszu zależności.

    Pamiętaj, że jeśli używasz w swojej aplikacji wielu bibliotek Firebase, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co gwarantuje, że wszystkie wersje będą kompatybilne.

    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")
}
    Szukasz modułu bibliotecznego specyficznego dla Kotlina? Począwszy od października 2023 r. (Firebase BoM 32.5.0) zarówno programiści Kotlin, jak i Java mogą polegać na głównym module biblioteki (więcej informacji można znaleźć w często zadawanych pytaniach dotyczących tej inicjatywy ).

Krok 2: Pobierz pojedynczy obiekt Remote Config

Pobierz instancję obiektu Remote Config i ustaw minimalny interwał pobierania, aby umożliwić częste odświeżanie:

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

Obiekt singleton służy do przechowywania domyślnych wartości parametrów w aplikacji, pobierania zaktualizowanych wartości parametrów z zaplecza i kontrolowania, kiedy pobrane wartości są udostępniane aplikacji.

Podczas opracowywania zaleca się ustawienie stosunkowo niskiego minimalnego interwału pobierania. Aby uzyskać więcej informacji, zobacz Ograniczanie .

Krok 3: Ustaw domyślne wartości parametrów w aplikacji

Możesz ustawić domyślne wartości parametrów w aplikacji w obiekcie Remote Config, tak aby aplikacja zachowywała się zgodnie z oczekiwaniami przed połączeniem się z backendem Remote Config i aby dostępne były wartości domyślne, jeśli w backendzie nie ustawiono żadnych wartości.

  1. Zdefiniuj zestaw nazw parametrów i domyślnych wartości parametrów, korzystając z obiektu Map lub pliku zasobów XML przechowywanego w folderze res/xml aplikacji. Przykładowa aplikacja szybkiego startu Remote Config używa pliku XML do definiowania domyślnych nazw i wartości parametrów.

    Jeśli wartości parametrów zaplecza usługi Remote Config zostały już skonfigurowane, możesz pobrać wygenerowany plik XML zawierający wszystkie wartości domyślne i zapisać go w katalogu res/xml aplikacji:

    ODPOCZYNEK

    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

    Konsola Firebase

    1. Na karcie Parametry otwórz menu i wybierz opcję Pobierz wartości domyślne .

    2. Po wyświetleniu monitu włącz plik .xml dla systemu Android , a następnie kliknij opcję Pobierz plik .

  2. Dodaj te wartości do obiektu Remote Config za pomocą setDefaultsAsync(int) , jak pokazano:

    Kotlin+KTX

    remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java

    mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Krok 4: Uzyskaj wartości parametrów do wykorzystania w swojej aplikacji

Teraz możesz uzyskać wartości parametrów z obiektu Remote Config. Jeśli ustawisz wartości w backendie, pobierzesz je, a następnie aktywujesz, te wartości będą dostępne dla Twojej aplikacji. W przeciwnym razie wartości parametrów w aplikacji zostaną skonfigurowane przy użyciu setDefaultsAsync(int) . Aby uzyskać te wartości, wywołaj poniższą metodę, która odwzorowuje typ danych oczekiwany przez Twoją aplikację, podając klucz parametru jako argument:

Krok 5: Ustaw wartości parametrów w zapleczu zdalnej konfiguracji

Korzystając z konsoli Firebase lub interfejsów API zaplecza Remote Config , możesz utworzyć nowe wartości domyślne po stronie serwera, które zastępują wartości w aplikacji zgodnie z żądaną logiką warunkową lub kierowaniem na użytkownika. W tej sekcji opisano kroki konsoli Firebase umożliwiające utworzenie tych wartości.

  1. W konsoli Firebase otwórz swój projekt.
  2. Wybierz opcję Zdalna konfiguracja z menu, aby wyświetlić pulpit nawigacyjny Zdalnej konfiguracji.
  3. Zdefiniuj parametry o takich samych nazwach, jak parametry zdefiniowane w aplikacji. Dla każdego parametru możesz ustawić wartość domyślną (która ostatecznie zastąpi odpowiednią wartość domyślną w aplikacji), możesz także ustawić wartości warunkowe. Aby dowiedzieć się więcej, zobacz Parametry i warunki zdalnej konfiguracji .

Krok 6: Pobierz i aktywuj wartości

  1. Aby pobrać wartości parametrów z zaplecza Remote Config, wywołaj metodę fetch() . Wszelkie wartości ustawione w backendie są pobierane i przechowywane w obiekcie Remote Config.

  2. Aby udostępnić aplikacji pobrane wartości parametrów, wywołaj metodę activate() .

    W przypadkach, gdy chcesz pobrać i aktywować wartości w jednym wywołaniu, możesz użyć żądania fetchAndActivate() w celu pobrania wartości z zaplecza zdalnej konfiguracji i udostępnienia ich aplikacji:

    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();
            }
        });

Ponieważ te zaktualizowane wartości parametrów wpływają na zachowanie i wygląd aplikacji, należy aktywować pobrane wartości w czasie zapewniającym użytkownikowi bezproblemową obsługę, na przykład przy następnym otwarciu aplikacji. Więcej informacji i przykładów można znaleźć w artykule Strategie ładowania zdalnej konfiguracji .

Krok 7: Słuchaj aktualizacji w czasie rzeczywistym

Po pobraniu wartości parametrów można używać funkcji Remote Config w czasie rzeczywistym do nasłuchiwania aktualizacji z zaplecza Remote Config. Zdalna konfiguracja w czasie rzeczywistym sygnalizuje podłączonym urządzeniom dostępność aktualizacji i automatycznie pobiera zmiany po opublikowaniu nowej wersji Zdalnej konfiguracji.

Aktualizacje w czasie rzeczywistym są obsługiwane przez pakiet SDK Firebase dla Androida w wersji 21.3.0+ (Firebase BoM v31.2.4+).

  1. W swojej aplikacji użyj addOnConfigUpdateListener() , aby rozpocząć nasłuchiwanie aktualizacji i automatycznie pobierać nowe wartości parametrów. Zaimplementuj wywołanie zwrotne onUpdate() , aby aktywować zaktualizowaną konfigurację.

    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. Następnym razem, gdy opublikujesz nową wersję zdalnej konfiguracji, urządzenia, na których działa Twoja aplikacja i nasłuchują zmian, wywołają ConfigUpdateListener .

Dławienie

Jeśli aplikacja zostanie pobrana zbyt wiele razy w krótkim czasie, wywołania pobierania zostaną ograniczone, a zestaw SDK zwróci FirebaseRemoteConfigFetchThrottledException . Przed wersją SDK 17.0.0 limit wynosił 5 żądań pobrania w 60-minutowym oknie (nowsze wersje mają bardziej liberalne limity).

Podczas tworzenia aplikacji możesz chcieć bardzo często pobierać i aktywować konfiguracje (wiele razy na godzinę), aby móc szybko wykonywać iteracje podczas opracowywania i testowania aplikacji. Aktualizacje zdalnej konfiguracji w czasie rzeczywistym automatycznie omijają pamięć podręczną, gdy konfiguracja jest aktualizowana na serwerze. Aby umożliwić szybką iterację projektu z maksymalnie 10 programistami, możesz tymczasowo ustawić w swojej aplikacji obiekt FirebaseRemoteConfigSettings z niskim minimalnym interwałem pobierania ( setMinimumFetchIntervalInSeconds ).

Domyślny minimalny interwał pobierania dla Zdalnej konfiguracji wynosi 12 godzin, co oznacza, że ​​konfiguracje nie będą pobierane z zaplecza częściej niż raz w ciągu 12 godzin, niezależnie od liczby faktycznie wykonanych wywołań pobierania. W szczególności minimalny interwał pobierania jest określany w następującej kolejności:

  1. Parametr w fetch(long)
  2. Parametr w FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
  3. Wartość domyślna to 12 godzin

Aby ustawić minimalny interwał pobierania na wartość niestandardową, użyj FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long) .

Następne kroki

Jeśli jeszcze tego nie zrobiłeś, zbadaj zdalne przypadki użycia konfiguracji i spójrz na niektóre z kluczowych koncepcji i zaawansowanych dokumentacji strategii, w tym: