Pierwsze kroki ze Zdalną konfiguracją na Androidzie

Wybierz platformę: iOS+ Android Web Flutter Unity C++


Za pomocą Firebase Remote Config możesz definiować parametry w aplikacji i aktualizować ich wartości w chmurze, co pozwala modyfikować wygląd i działanie aplikacji bez konieczności rozpowszechniania aktualizacji aplikacji. W tym przewodniku znajdziesz instrukcje, które pomogą Ci rozpocząć korzystanie z tej usługi, oraz przykładowy kod, który możesz sklonować lub pobrać z repozytorium firebase/quickstart-android na GitHubie.

Krok 1. Dodaj do aplikacji Firebase i pakiet SDK Zdalnej konfiguracji

  1. Dodaj Firebase do projektu aplikacji na Androida, jeśli nie korzystasz w nim jeszcze z tej usługi.

  2. W przypadku Remote Config usługa Google Analytics jest wymagana do kierowania warunkowego instancji aplikacji na odbiorców i właściwości użytkowników. Upewnij się, że w projekcie włączono Google Analytics.

  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ści dla bibliotek Remote Config i Analytics na Androida. Zalecamy używanie Firebase Android BoM do kontrolowania obsługi wersji biblioteki.

    W ramach konfigurowania usługi Analytics musisz też dodać do aplikacji pakiet SDK Firebase dla Google Analytics.

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:35.0.2"))

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

    Gdy korzystasz z Firebase Android BoM, aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

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

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

    Jeśli w aplikacji używasz kilku bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek, co zapewni zgodność wszystkich wersji. 

    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.0")
        implementation("com.google.firebase:firebase-analytics:24.0.0")    
}

Krok 2. Pobierz obiekt klasy typu singleton Remote Config

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

Kotlin 

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

Java 

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

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

Podczas programowania zalecamy ustawienie stosunkowo krótkiego minimalnego interwału pobierania. Więcej informacji znajdziesz w sekcji 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, aby aplikacja działała zgodnie z oczekiwaniami, zanim połączy się z backendem Remote Config, i aby wartości domyślne były dostępne, jeśli nie zostały ustawione w backendzie.

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

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

    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

    Token okaziciela możesz wygenerować, uruchamiając to polecenie za pomocą Google Cloud CLI lub Cloud Shell:

    gcloud auth print-access-token

    Ten token jest krótkotrwały, więc jeśli pojawi się błąd uwierzytelniania, może być konieczne jego ponowne wygenerowanie.

    Konsola Firebase

    1. W konsoli Firebase otwórz stronę DevOps i zaangażowanie > Zdalna konfiguracja > Parametry.

    2. Otwórz Menu i wybierz Pobierz wartości domyślne.

    3. Gdy pojawi się prośba, włącz .xml na Androida, a następnie kliknij Pobierz plik.

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

    Kotlin 

    remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java 

    mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Krok 4. Uzyskaj wartości parametrów, które będą używane w Twojej aplikacji

Teraz możesz pobierać wartości parametrów z obiektu Remote Config. Jeśli ustawisz wartości w backendzie, pobierzesz je, a następnie aktywujesz, będą one dostępne dla aplikacji. W przeciwnym razie otrzymasz wartości parametrów w aplikacji skonfigurowane za pomocą setDefaultsAsync(int). Aby uzyskać te wartości, wywołaj metodę wymienioną w poniższym kodzie, która jest mapowana na typ danych oczekiwany przez aplikację, podając klucz parametru jako argument:

Krok 5. Ustaw wartości parametrów w backendzie Remote Config

Za pomocą konsoli Firebase lub interfejsów API backendu Remote Config możesz tworzyć nowe wartości domyślne po stronie serwera, które zastępują wartości w aplikacji zgodnie z wybraną logiką warunkową lub kierowaniem na użytkowników. W tej sekcji opisano, jak utworzyć te wartości w konsoli Firebase.

  1. W konsoli Firebase otwórz stronę DevOps i zaangażowanie > Zdalna konfiguracja > Parametry.

  2. 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), a także wartości warunkowe. Więcej informacji znajdziesz w artykule Parametry i warunki Remote Config.

  3. Jeśli używasz warunków sygnałów niestandardowych, zdefiniuj atrybuty i ich wartości. Poniższe przykłady pokazują, jak zdefiniować warunek sygnału niestandardowego.

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

Krok 6. Pobierz i aktywuj wartości

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

  2. Aby pobrane wartości parametrów były dostępne dla aplikacji, wywołaj metodę activate().

    Jeśli chcesz pobrać i aktywować wartości w jednym wywołaniu, możesz użyć żądania fetchAndActivate(), aby pobrać wartości z backendu Remote Config i udostępnić je aplikacji:

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

Zaktualizowane wartości parametrów wpływają na zachowanie i wygląd aplikacji, dlatego należy je aktywować w momencie, który zapewni użytkownikowi płynne działanie aplikacji, np. przy następnym jej otwarciu. Więcej informacji i przykłady znajdziesz w artykule o strategiach wczytywania Zdalnej konfiguracji.

Krok 7. Słuchaj aktualizacji w czasie rzeczywistym

Po pobraniu wartości parametrów możesz używać Remote Config w czasie rzeczywistym, aby nasłuchiwać aktualizacji z backendu Remote Config. Remote Config wysyła sygnały do połączonych urządzeń w czasie rzeczywistym, gdy dostępne są aktualizacje, i automatycznie pobiera zmiany po opublikowaniu nowej wersji Remote Config.

Aktualizacje w czasie rzeczywistym są obsługiwane przez pakiet SDK Firebase na platformę Android w wersji 21.3.0 lub nowszej (Firebase BoM w wersji 31.2.4 lub nowszej).

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

    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. Gdy następnym razem opublikujesz nową wersję Remote Config, urządzenia, na których działa Twoja aplikacja i które nasłuchują zmian, wywołają ConfigUpdateListener.

Ograniczenia

Jeśli aplikacja pobiera dane zbyt wiele razy w krótkim czasie, wywołania pobierania są ograniczane, a pakiet SDK zwraca wartość FirebaseRemoteConfigFetchThrottledException. Przed wersją 17.0.0 pakietu SDK limit wynosił 5 żądań pobrania w ciągu 60 minut (nowsze wersje mają bardziej liberalne limity).

Podczas tworzenia aplikacji możesz pobierać i aktywować konfiguracje bardzo często (wiele razy na godzinę), aby szybko wprowadzać zmiany podczas tworzenia i testowania aplikacji. Aktualizacje Remote Config w czasie rzeczywistym automatycznie pomijają pamięć podręczną, gdy konfiguracja jest aktualizowana na serwerze. Aby umożliwić szybkie iteracje w projekcie, nad którym pracuje maksymalnie 10 programistów, możesz tymczasowo ustawić w aplikacji obiekt FirebaseRemoteConfigSettings z krótkim minimalnym interwałem pobierania ustawień (setMinimumFetchIntervalInSeconds).

Domyślny minimalny interwał pobierania dla Remote Config wynosi 12 godzin, co oznacza, że konfiguracje nie będą pobierane z backendu częściej niż raz na 12 godzin, niezależnie od tego, ile wywołań pobierania zostanie faktycznie wykonanych. 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ć minimalną częstotliwość pobierania na wartość niestandardową, użyj FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long).