Primeiros passos com a Configuração remota do Firebase


Você pode usar o Firebase Remote Config para definir parâmetros no seu aplicativo e atualizar seus valores na nuvem, permitindo modificar a aparência e o comportamento do seu aplicativo sem distribuir uma atualização do aplicativo. Este guia orienta você nas etapas de introdução e fornece alguns exemplos de código, todos disponíveis para clonagem ou download no repositório GitHub firebase/quickstart-android .

Etapa 1: adicionar o Firebase e o SDK da Configuração remota ao seu aplicativo

  1. Adicione o Firebase ao seu projeto Android , caso ainda não o tenha feito.

  2. Para a Configuração remota, o Google Analytics é necessário para a segmentação condicional de instâncias de aplicativos para propriedades de usuários e públicos-alvo. Certifique-se de ativar o Google Analytics em seu projeto.

  3. No arquivo Gradle do módulo (nível do aplicativo) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle ), adicione a dependência para a Configuração remota biblioteca para Android. Recomendamos usar o Firebase Android BoM para controlar o controle de versão da biblioteca.

    Além disso, como parte da configuração do Analytics, você precisa adicionar o SDK do Firebase para Google Analytics ao seu aplicativo.

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

    Ao usar o Firebase Android BoM , seu aplicativo sempre usará versões compatíveis das bibliotecas do Firebase Android.

    (Alternativa) Adicionar dependências da biblioteca Firebase sem usar o BoM

    Se você optar por não usar o Firebase BoM, deverá especificar cada versão da biblioteca do Firebase em sua linha de dependência.

    Observe que se você usa várias bibliotecas do Firebase no seu aplicativo, é altamente recomendável usar a BoM para gerenciar as versões da biblioteca, o que garante que todas as versões sejam compatíveis.

    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.2")
        implementation("com.google.firebase:firebase-analytics:21.5.1")
    }
    
    Procurando um módulo de biblioteca específico para Kotlin? A partir de outubro de 2023 (Firebase BoM 32.5.0) , tanto os desenvolvedores Kotlin quanto os Java podem depender do módulo da biblioteca principal (para obter detalhes, consulte o FAQ sobre esta iniciativa ).

Etapa 2: obter o objeto singleton do Configuração remota

Obtenha uma instância do objeto do Configuração remota e defina o intervalo mínimo de busca para permitir atualizações frequentes:

Kotlin+KTX

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

O objeto singleton é usado para armazenar valores de parâmetros padrão no aplicativo, buscar valores de parâmetros atualizados do back-end e controlar quando os valores buscados são disponibilizados para seu aplicativo.

Durante o desenvolvimento, é recomendado definir um intervalo mínimo de busca relativamente baixo. Consulte Limitação para obter mais informações.

Etapa 3: definir valores de parâmetros padrão no aplicativo

Você pode definir valores de parâmetros padrão no aplicativo no objeto do Configuração remota, para que seu aplicativo se comporte conforme esperado antes de se conectar ao back-end do Configuração remota e para que os valores padrão estejam disponíveis se nenhum for definido no back-end.

  1. Defina um conjunto de nomes de parâmetros e valores de parâmetros padrão usando um objeto Map ou um arquivo de recurso XML armazenado na pasta res/xml do seu aplicativo. O aplicativo de exemplo de início rápido do Configuração remota usa um arquivo XML para definir nomes e valores de parâmetros padrão.

    Se você já tiver configurado os valores dos parâmetros de back-end do Configuração remota, poderá fazer download de um arquivo XML gerado que inclua todos os valores padrão e salvá-lo no diretório res/xml do seu aplicativo:

    DESCANSAR

    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
    

    Console do Firebase

    1. Na guia Parâmetros , abra o menu e selecione Baixar valores padrão .

    2. Quando solicitado, habilite .xml para Android e clique em Baixar arquivo .

  2. Adicione esses valores ao objeto do Configuração remota usando setDefaultsAsync(int) , conforme mostrado:

    Kotlin+KTX

    remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java

    mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Etapa 4: obtenha valores de parâmetros para usar em seu aplicativo

Agora você pode obter valores de parâmetros do objeto do Configuração remota. Se você definir valores no back-end, buscá-los e ativá-los, esses valores estarão disponíveis para seu aplicativo. Caso contrário, você obterá os valores dos parâmetros no aplicativo configurados usando setDefaultsAsync(int) . Para obter esses valores, chame o método listado abaixo que mapeia o tipo de dados esperado pelo seu aplicativo, fornecendo a chave do parâmetro como argumento:

Etapa 5: definir valores de parâmetros no back-end do Configuração remota

Usando o console do Firebase ou as APIs de back-end do Configuração remota , você pode criar novos valores padrão no servidor que substituem os valores no aplicativo de acordo com a lógica condicional desejada ou a segmentação do usuário. Esta seção descreve as etapas do Firebase Console para criar esses valores.

  1. No console do Firebase , abra seu projeto.
  2. Selecione Configuração remota no menu para visualizar o painel do Configuração remota.
  3. Defina parâmetros com os mesmos nomes dos parâmetros definidos em seu aplicativo. Para cada parâmetro, você pode definir um valor padrão (que eventualmente substituirá o valor padrão correspondente no aplicativo) e também pode definir valores condicionais. Para saber mais, consulte Parâmetros e condições da configuração remota .

Etapa 6: buscar e ativar valores

  1. Para buscar valores de parâmetros do back-end do Configuração remota, chame o método fetch() . Todos os valores definidos no back-end são buscados e armazenados no objeto do Configuração remota.
  2. Para disponibilizar valores de parâmetros buscados para seu aplicativo, chame o método activate() .

    Nos casos em que você deseja buscar e ativar valores em uma chamada, você pode usar uma solicitação fetchAndActivate() para buscar valores do back-end do Configuração remota e disponibilizá-los para o aplicativo:

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

Como esses valores de parâmetro atualizados afetam o comportamento e a aparência do seu aplicativo, você deve ativar os valores buscados em um momento que garanta uma experiência tranquila para o usuário, como na próxima vez que o usuário abrir o aplicativo. Consulte Estratégias de carregamento do Configuração remota para mais informações e exemplos.

Etapa 7: ouça atualizações em tempo real

Depois de buscar os valores dos parâmetros, você poderá usar o Configuração remota em tempo real para detectar atualizações do back-end do Configuração remota. A Configuração remota em tempo real sinaliza aos dispositivos conectados quando há atualizações disponíveis e busca automaticamente as alterações após a publicação de uma nova versão da Configuração remota.

As atualizações em tempo real são compatíveis com o SDK do Firebase para Android v21.3.0+ (Firebase BoM v31.2.4+).

  1. No seu aplicativo, use addOnConfigUpdateListener() para começar a escutar atualizações e buscar automaticamente quaisquer novos valores de parâmetro. Implemente o retorno de chamada onUpdate() para ativar a configuração atualizada.

    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. Na próxima vez que você publicar uma nova versão do Configuração remota, os dispositivos que estiverem executando seu aplicativo e ouvindo alterações chamarão o ConfigUpdateListener .

Estrangulamento

Se um aplicativo buscar muitas vezes em um curto período, as chamadas de busca serão limitadas e o SDK retornará FirebaseRemoteConfigFetchThrottledException . Antes da versão 17.0.0 do SDK, o limite era de cinco solicitações de busca em uma janela de 60 minutos (as versões mais recentes têm limites mais permissivos).

Durante o desenvolvimento do aplicativo, você pode querer buscar e ativar configurações com muita frequência (muitas vezes por hora) para permitir iterar rapidamente à medida que desenvolve e testa seu aplicativo. As atualizações da Configuração remota em tempo real ignoram automaticamente o cache quando a configuração é atualizada no servidor. Para acomodar a iteração rápida em um projeto com até 10 desenvolvedores, você pode definir temporariamente um objeto FirebaseRemoteConfigSettings com um intervalo de busca mínimo baixo ( setMinimumFetchIntervalInSeconds ) no seu aplicativo.

O intervalo mínimo de busca padrão para o Configuração remota é de 12 horas, o que significa que as configurações não serão buscadas no back-end mais de uma vez em uma janela de 12 horas, independentemente de quantas chamadas de busca forem realmente feitas. Especificamente, o intervalo mínimo de busca é determinado na seguinte ordem:

  1. O parâmetro em fetch(long)
  2. O parâmetro em FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
  3. O valor padrão de 12 horas

Para definir o intervalo mínimo de busca para um valor personalizado, use FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long) .

Próximos passos

Se você ainda não o fez, explore os casos de uso da configuração remota e dê uma olhada em alguns dos principais conceitos e documentação de estratégias avançadas, incluindo: