Introdução à Configuração remota do Firebase

iOS+ Android Web Flutter Unity C++

Importante: nesta seção, descrevemos as etapas para definir a Configuração remota com clientes de dispositivos móveis e da Web. Para ambientes de servidor, consulte Usar a Configuração remota em ambientes de servidor.

Use o Configuração remota do Firebase para definir parâmetros no seu app e atualizar os valores na nuvem, permitindo modificar a aparência e o comportamento do app sem a necessidade de distribuir uma atualização. Este guia contém as etapas para começar a usar o recurso e alguns exemplos de código que estão disponíveis para clonagem ou download no repositório do GitHub firebase/quickstart-ios.

Etapa 1: adicionar a Configuração remota ao seu app

1. Adicione o Firebase ao seu projeto da Apple caso ainda não tenha feito isso.

2. Na Configuração remota, o Google Analytics é necessário para a segmentação condicional de instâncias de apps para propriedades do usuário e públicos-alvo. Ative o Google Analytics no seu projeto.

3. Crie o objeto Singleton do Configuração remota, conforme mostrado no exemplo a seguir:

   Swift

   remoteConfig = RemoteConfig.remoteConfig()
   let settings = RemoteConfigSettings()
   settings.minimumFetchInterval = 0
   remoteConfig.configSettings = settings
   ViewController.swift

   Objective-C

   self.remoteConfig = [FIRRemoteConfig remoteConfig];
   FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init];
   remoteConfigSettings.minimumFetchInterval = 0;
   self.remoteConfig.configSettings = remoteConfigSettings;
   ViewController.m

Esse objeto é usado para armazenar valores de parâmetro padrão no app, buscar valores de parâmetros atualizados no back-end da Configuração remota e controlar quando eles são disponibilizados para o app.

Durante o desenvolvimento, recomendamos definir um intervalo de busca mínimo relativamente baixo. Para mais informações, consulte Limitação.

Etapa 2: definir valores de parâmetro padrão no app

Você pode definir os valores de parâmetro padrão no app no objeto da Configuração remota. Assim, o app se comporta de maneira previsível antes de se conectar ao back-end da Configuração remota, e os valores padrão vão estar disponíveis se nenhum tiver sido definido no back-end.

Importante: não armazene dados confidenciais em chaves ou valores de parâmetros da Configuração remota. Os dados da Configuração remota são criptografados em trânsito, mas os usuários finais podem acessar qualquer parâmetro padrão ou buscado do recurso que esteja disponível para a instância do app cliente.

1. Defina um conjunto de nomes e valores de parâmetros padrão usando um objeto NSDictionary ou um arquivo plist (links em inglês).

   Depois de configurar os valores de parâmetro do back-end da Configuração remota, é possível fazer o download de um arquivo plist gerado com todos os valores padrão e salvar esse arquivo no projeto do Xcode.

   REST

   curl --compressed -D headers -H "Authorization: Bearer token -X GET https://firebaseremoteconfig.googleapis.com/v1/projects/my-project-id/remoteConfig:downloadDefaults?format=PLIST -o RemoteConfigDefaults.plist
   

   Console do Firebase

   1. Na guia Parâmetros, abra o Menu e selecione Fazer o download dos valores padrão.

   2. Quando solicitado, ative a opção .plist para iOS, e clique em Fazer o download do arquivo.

2. Adicione esses valores ao objeto da Configuração remota usando setDefaults:. O exemplo a seguir define valores padrão no aplicativo de um arquivo plist:

   Swift

   remoteConfig.setDefaults(fromPlist: "RemoteConfigDefaults")
   ViewController.swift

   Objective-C

   [self.remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];
   ViewController.m

Observação: esses snippets de código são referentes ao arquivo RemoteConfigDefaults.plist do projeto quickstart-ios de exemplo. Se você usar o arquivo padrão salvo, é possível utilizar remote_config_defaults.

Etapa 3: receber valores de parâmetro para uso no app

Agora você pode receber valores de parâmetro do objeto da Configuração remota. Se mais tarde você definir valores no back-end da Configuração remota, buscá-los e ativá-los, eles vão estar disponíveis para o app. Caso contrário, receba os valores de parâmetro no app usando setDefaults:. Para receber esses valores, chame o método configValueForKey: fornecendo a chave de parâmetro como um argumento.

Etapa 4: definir os valores de parâmetro

Com o Console do Firebase ou as APIs de back-end da Configuração remota, crie valores padrão do back-end que substituem os valores no app conforme a lógica condicional ou a segmentação de usuário necessárias. Esta seção traz as etapas do Console do Firebase para criar esses valores.

1. Abra seu projeto no Console do Firebase.
2. Selecione Configuração remota no menu para explorar o painel do recurso.
3. Defina os parâmetros com os mesmos nomes dos definidos no seu app. Para cada um, é possível definir um valor padrão (que, por fim, vai substituir o valor padrão no app) e valores condicionais. Saiba mais em Parâmetros e condições da Configuração remota.

Etapa 5: buscar e ativar valores

Para buscar os valores de parâmetro da Configuração remota, chame o método fetchWithCompletionHandler: ou fetchWithExpirationDuration:completionHandler:. Todos os valores definidos no back-end são buscados e armazenados em cache no objeto da Configuração remota.

Para buscar e ativar valores com uma chamada, use fetchAndActivateWithCompletionHandler:.

Este exemplo busca valores no back-end da Configuração remota (não valores em cache) e chama activateWithCompletionHandler: para disponibilizá-los para o app:

Swift

remoteConfig.fetch { (status, error) -> Void in
  if status == .success {
    print("Config fetched!")
    self.remoteConfig.activate { changed, error in
      // ...
    }
  } else {
    print("Config not fetched")
    print("Error: \(error?.localizedDescription ?? "No error available.")")
  }
  self.displayWelcome()
}
ViewController.swift

Objective-C

[self.remoteConfig fetchWithCompletionHandler:^(FIRRemoteConfigFetchStatus status, NSError *error) {
    if (status == FIRRemoteConfigFetchStatusSuccess) {
        NSLog(@"Config fetched!");
      [self.remoteConfig activateWithCompletion:^(BOOL changed, NSError * _Nullable error) {
        if (error != nil) {
          NSLog(@"Activate error: %@", error.localizedDescription);
        } else {
          dispatch_async(dispatch_get_main_queue(), ^{
            [self displayWelcome];
          });
        }
      }];
    } else {
        NSLog(@"Config not fetched");
        NSLog(@"Error %@", error.localizedDescription);
    }
}];
ViewController.m

Esses valores de parâmetro atualizados afetam o comportamento e a aparência do app. Por isso, ative-os sem prejudicar a experiência do usuário, como da próxima vez que ele abrir o app. Confira informações e exemplos em Estratégias de carregamento da Configuração remota.

Etapa 6: detectar atualizações em tempo real

Depois de buscar valores de parâmetros, é possível usar a Configuração remota em tempo real para detectar atualizações do back-end. A Configuração remota em tempo real sinaliza para dispositivos conectados quando atualizações estão disponíveis e busca mudanças automaticamente depois que você publica uma nova versão da Configuração remota.

O SDK do Firebase para plataformas da Apple v10.7.0 e as versões mais recentes oferecem suporte para atualizações em tempo real.

Importante: a Configuração remota em tempo real também exige a API Realtime da Configuração remota do Firebase, que já deve estar ativada. Para verificar, abra o console do Google Cloud, selecione o projeto e abra a página de APIs e serviços. A API precisa aparecer como ativada. Se ela estiver ausente ou desativada, clique em Ativar APIs e serviços, encontre a API Realtime da Configuração remota do Firebase e faça a ativação dela.

1. No seu app, chame addOnConfigUpdateListener para detectar atualizações e buscar novos valores de parâmetros automaticamente. O exemplo a seguir detecta atualizações e usa os valores recém-buscados quando activateWithCompletionHandler é chamado para mostrar uma mensagem de boas-vindas atualizada.

   Swift

   remoteConfig.addOnConfigUpdateListener { configUpdate, error in
     guard let configUpdate, error == nil else {
       print("Error listening for config updates: \(error)")
     }
   
     print("Updated keys: \(configUpdate.updatedKeys)")
   
     self.remoteConfig.activate { changed, error in
       guard error == nil else { return self.displayError(error) }
       DispatchQueue.main.async {
         self.displayWelcome()
       }
     }
   }
   

   Objective-C

   __weak __typeof__(self) weakSelf = self;
   [self.remoteConfig addOnConfigUpdateListener:^(FIRRemoteConfigUpdate * _Nonnull configUpdate, NSError * _Nullable error) {
     if (error != nil) {
       NSLog(@"Error listening for config updates %@", error.localizedDescription);
     } else {
       NSLog(@"Updated keys: %@", configUpdate.updatedKeys);
   
       __typeof__(self) strongSelf = weakSelf;
       [strongSelf.remoteConfig activateWithCompletion:^(BOOL changed, NSError * _Nullable error) {
         if (error != nil) {
           NSLog(@"Activate error %@", error.localizedDescription);
         }
   
         dispatch_async(dispatch_get_main_queue(), ^{
           [strongSelf displayWelcome];
         });
       }];
     }
   }];
   

2. Na próxima vez que você publicar uma nova versão da Configuração remota, os dispositivos que estão executando seu app e detectando as mudanças vão chamar o gerenciador de conclusão.

Limitação

Se um aplicativo fizer muitas buscas em um curto período, as chamadas de busca serão limitadas, e o SDK retornará FIRRemoteConfigFetchStatusThrottled. Antes da versão 6.3.0 do SDK, o limite era de cinco solicitações de busca em um intervalo de 60 minutos. As versões mais recentes têm limites mais flexíveis.

Dica: com o SDK das plataformas Apple v10.7.0 ou mais recente, é possível usar a Configuração remota em tempo real para buscar automaticamente valores de parâmetro atualizados do back-end da Configuração remota assim que eles são publicados, ignorando qualquer configuração mínima do intervalo de busca. É possível usar as atualizações em tempo real em vez de fazer buscas com frequência para atualizar o cache. Para mais informações, consulte Detectar atualizações em tempo real.

Durante o desenvolvimento de apps, sempre faça buscas para atualizar o cache com mais frequência (muitas vezes por hora) para permitir a iteração rápida enquanto você desenvolve e testa seu app. As atualizações da Configuração remota em tempo real ignoram automaticamente o cache quando a configuração é atualizada no servidor. Caso queira acomodar a iteração rápida em um projeto com vários desenvolvedores, é possível adicionar temporariamente uma propriedade FIRRemoteConfigSettings com um intervalo de busca mínimo baixo (MinimumFetchInterval) no app.

O intervalo de busca de produção padrão e recomendado da Configuração remota é de 12 horas. Portanto, a busca pelas configurações no back-end não vai acontecer mais de uma vez em 12 horas, e isso independe de quantas chamadas de busca forem realmente realizadas. O intervalo mínimo de busca é determinado especificamente na seguinte ordem:

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

Essa configuração deve ser usada apenas para desenvolvimento e não para um app em execução na produção. Se você está apenas testando seu aplicativo com uma equipe de desenvolvimento pequena de 10 pessoas, é improvável que atinja os limites de cota do serviço por hora. No entanto, se você transferiu seu aplicativo para milhares de usuários de teste com um intervalo de busca mínimo muito baixo, seu app provavelmente atingirá essa cota.

Próximas etapas

Se ainda não tiver feito isso, confira os casos de uso da Configuração remota, bem como alguns dos conceitos principais e a documentação de estratégias avançadas, que incluem:

• Gerenciar versões do modelo da Configuração remota
• Estratégias de carregamento de configuração