Instrumentar seu jogo do Unity com a Configuração remota do Firebase

1. Introdução

Use a Configuração remota do Firebase para definir pares de chave-valor, também conhecidos como parâmetros, no app e atualizar os valores na nuvem, permitindo modificar a aparência e o comportamento do app sem precisar distribuir uma atualização.

Essa nova funcionalidade será adicionada a um jogo de exemplo, MechaHamster: Level Up com o Firebase Edition. Este jogo de exemplo é uma nova versão do MechaHamster clássico do Firebase que remove a maior parte das funcionalidades integradas do Firebase, oferecendo a você a chance de implementar novos usos da plataforma.

Para garantir que seu app se comporte conforme o esperado, defina as configurações padrão para valores no código de jogo de exemplo, e esses valores podem ser substituídos por valores definidos na Configuração remota no Console do Firebase.

Conteúdo

• Como definir valores da Configuração remota na nuvem e recuperá-los
• Como instrumentar seu código do Unity C# para usar automaticamente os valores recuperados.
• Como armazenar, instrumentar e substituir valores/objetos compostos como valores JSON.
• Como usar as condições da Configuração remota para exibir variantes de valor diferentes a grupos de usuários distintos.

Pré-requisitos

• Unity 2019.1.0f1 ou versão mais recente com suporte ao build iOS e/ou Android
• Um dispositivo físico Android/iOS ou um simulador/emulador para criar e executar o jogo

2. Configurar o ambiente de desenvolvimento

As seções a seguir descrevem como fazer o download do código avançar de nível com o Firebase, abri-lo no Unity e adicionar um projeto do Firebase. Este jogo de exemplo Level Up with Firebase é usado por vários outros codelabs do Firebase e do Unity, então talvez você já tenha concluído as tarefas desta seção. Nesse caso, pule estas etapas e prossiga para Adicionar SDKs do Firebase para Unity a fim de acrescentar a Configuração remota ao código do jogo de amostra.

Fazer o download do código

Clone o repositório do GitHub deste codelab na linha de comando:

git clone https://github.com/firebase/level-up-with-firebase

Se você não tiver o git instalado, faça o download do repositório como um arquivo ZIP (link em inglês).

Abra Avance de nível com o Firebase no editor do Unity.

1. Inicie o Unity Hub e, na guia Projects, clique na seta suspensa ao lado de Open.
2. Clique em Adicionar projeto do disco.
3. Navegue até o diretório que contém o código e clique em OK.
4. Se solicitado, selecione uma versão do editor do Unity e a plataforma de destino (Android ou iOS).
5. Clique no nome do projeto, level-up-with-firebase, para abrir o projeto no editor do Unity.
6. Caso seu editor não abra o arquivo automaticamente, abra MainGameScene em Assets > Hamster na guia Project do editor do Unity.
   

Para mais informações sobre como instalar e usar o Unity, consulte Como trabalhar no Unity.

3. Adicionar o Firebase ao seu projeto do Unity

criar um projeto do Firebase

1. No Console do Firebase, clique em Adicionar projeto.
2. Para criar um novo projeto, digite o nome dele.
   Isso também definirá o ID do projeto (exibido abaixo do nome do projeto) como algo baseado no nome dele. Clique no ícone de edição no ID do projeto para personalizá-lo ainda mais.
3. Se solicitado, leia e aceite os Termos do Firebase.
4. Clique em Continuar.
5. Selecione a opção Ativar o Google Analytics para este projeto e clique em Continuar.
6. Selecione uma conta existente do Google Analytics para usar ou selecione Criar uma nova conta.
7. Clique em Criar projeto.
8. Quando o projeto for criado, clique em Continuar.

Registrar o app no Firebase

1. Abra o Console do Firebase e, no centro da página de visão geral do projeto, clique no ícone do Unity para iniciar o fluxo de trabalho de configuração. Se você já tiver adicionado um app ao projeto do Firebase, clique em Adicionar app para exibir as opções da plataforma.
2. Selecione para registrar os destinos de build para Apple (iOS) e Android.
3. Insira os IDs específicos da plataforma do seu projeto do Unity. Para este codelab, digite o seguinte:
   • Para Apple (iOS): insira com.google.firebase.level-up no campo ID do pacote do iOS.
   • For Android: digite com.google.firebase.level_up no campo Android package name.
4. Se quiser, insira os apelidos específicos da plataforma do seu projeto do Unity.
5. Clique em Registrar app e avance para a seção Fazer o download do arquivo de configuração.
6. Repita o processo para qualquer destino de build que você não tenha executado na primeira vez.

Adicionar arquivos de configuração do Firebase

Depois de clicar em Registrar app, será feito o download de dois arquivos de configuração (um arquivo de configuração para cada destino de compilação). Seu projeto do Unity precisa dos metadados do Firebase nesses arquivos para se conectar ao Firebase.

1. Faça download dos dois arquivos de configuração disponíveis:
   • Para Apple (iOS): faça o download de GoogleService-Info.plist.
   • Para Android: faça o download do google-services.json.
2. Abra a janela Project do projeto do Unity e mova os dois arquivos de configuração para a pasta Assets.

   Importante:mesmo que você pretenda criar apenas o iOS ou o Android, faça o download dos dois arquivos e adicione-os ao projeto.

3. De volta ao fluxo de trabalho de configuração no Console do Firebase, clique em Próxima e selecione "Adicionar SDKs do Firebase para Unity".

Observação:para fazer o download desses arquivos de novo depois, abra as configurações gerais do seu projeto, role para baixo até a seção Seus apps e clique no botão de download do arquivo de configuração desejado.

Adicionar SDKs do Firebase para Unity

1. Clique em Fazer o download do SDK do Firebase para Unity no Console do Firebase.

   Observação:o download desse SDK pode demorar um pouco. Confira uma prévia das próximas etapas ou faça uma pequena pausa.

2. Descompacte o SDK em um local prático.
3. No seu projeto aberto do Unity, acesse Assets > Import Package > Custom Package.
4. Na caixa de diálogo Import package, navegue até o diretório que contém o SDK descompactado, selecione FirebaseAnalytics.unitypackage e clique em Open.
5. Na caixa de diálogo Import Unity Package exibida, clique em Import.
6. Repita as etapas anteriores para importar os dois pacotes a seguir:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     O Crashlytics é uma ferramenta de relatório de erros leve e em tempo real que ajuda a monitorar, priorizar e corrigir problemas de estabilidade que comprometem a qualidade do seu app. Conclua o Programa de aprendizado do Crashlytics para Unity, caso ainda não tenha usado.
7. Retorne ao Console do Firebase e, no fluxo de trabalho de configuração, clique em Próxima.

Para mais informações sobre como adicionar SDKs do Firebase a projetos do Unity, consulte Outras opções de instalação do Unity.

4. Defina os padrões da Configuração remota e busque novos valores

Neste codelab, você vai atualizar objetos que usam valores definidos no código ou são serializados no editor do Unity para usar valores instrumentados com a Configuração remota. Configure os valores padrão de cada parâmetro usando SetDefaultsAsync. Assim, o app se comporta conforme o esperado antes de se conectar ao back-end da Configuração remota. O app vai se manter atualizado buscando novos valores da Configuração remota e ativando-os para torná-los utilizáveis no código.

Para buscar novos valores da Configuração remota, há vários métodos não implementados já presentes no arquivo Assets/Hamster/Scripts/MainGame.cs que precisam ser concluídos.

1. Adicione as seguintes instruções using a MainGame.cs:

   using Firebase.Crashlytics;
   using Firebase.Extensions;
   using Firebase.RemoteConfig;
   

   O módulo Firebase.Extensions contém algumas extensões para a API C# Tasks que vão ajudar a simplificar o gerenciamento do processo de inicialização com callbacks.
2. Adicione a inicialização do Firebase ao método MainGame.cs Start(), substituindo o método InitializeCommonDataAndStartGame() atual pelo método não implementado no momento, InitializeFirebaseAndStartGame():

   void Start()
   {
      Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
      InitializeFirebaseAndStartGame();
   }
   

3. No MainGame.cs, encontre InitializeFirebaseAndStartGame(). Declare uma variável de app e substitua a implementação do método da seguinte maneira:

   public Firebase.FirebaseApp app = null;
   
   // Begins the firebase initialization process and afterwards, opens the main menu.
   private void InitializeFirebaseAndStartGame()
   {
      Firebase.FirebaseApp.CheckAndFixDependenciesAsync()
      .ContinueWithOnMainThread(
         previousTask =>
         {
            var dependencyStatus = previousTask.Result;
            if (dependencyStatus == Firebase.DependencyStatus.Available) {
            // Create and hold a reference to your FirebaseApp,
            app = Firebase.FirebaseApp.DefaultInstance;
            // Set the recommended Crashlytics uncaught exception behavior.
            Crashlytics.ReportUncaughtExceptionsAsFatal = true;
            SetRemoteConfigDefaults();
            } else {
            UnityEngine.Debug.LogError(
               $"Could not resolve all Firebase dependencies: {dependencyStatus}\n" +
               "Firebase Unity SDK is not safe to use here");
            }
         });
   }
   

4. A inicialização do Firebase chama SetRemoteConfigDefaults em caso de sucesso para definir valores padrão no app. Substitua o método SetRemoteConfigDefaults não implementado pelo seguinte:

   private void SetRemoteConfigDefaults()
   {
      var defaults = new System.Collections.Generic.Dictionary < string, object > ();
      defaults.Add(
         Hamster.MapObjects.AccelerationTile.AccelerationTileForceKey,
         Hamster.MapObjects.AccelerationTile.AccelerationTileForceDefault);
      defaults.Add(
         Hamster.States.MainMenu.SubtitleOverrideKey,
         Hamster.States.MainMenu.SubtitleOverrideDefault);
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      remoteConfig.SetDefaultsAsync(defaults).ContinueWithOnMainThread(
         previousTask =>
         {
            FetchRemoteConfig(InitializeCommonDataAndStartGame);
         }
      );
   }
   

5. Buscar e ativar novos valores (conforme necessário)

Agora, precisamos concluir o método FetchRemoteConfig existente. Isso vai encadear chamadas aos métodos FetchAsync da Configuração remota (que busca novos valores da Configuração remota) e ActivateAsync (que ativa os valores recebidos para disponibilizá-los em código) usando um parâmetro de callback chamado onFetchAndActivateSuccessful.

O código de inicialização que adicionamos na etapa anterior chama FetchRemoteConfig com InitializeCommonDataAndStartGame como callback para iniciar o jogo no final da sequência. É possível transmitir callbacks alternativos para FetchRemoteConfig a fim de invocar a busca com resultados diferentes. Um exemplo (que você implementará mais tarde) é a transmissão de um método que abre novos menus de IU, que dependem dos valores da Configuração remota. Isso fará com que os menus sejam abertos somente depois que esses valores forem buscados e ativados.

1. Cole o código abaixo em FetchRemoteConfig:

   public void FetchRemoteConfig(System.Action onFetchAndActivateSuccessful)
   {
      if(app==null)
      {
         Debug.LogError($"Do not use Firebase until it is properly initialized by calling {nameof(InitializeFirebaseAndStartGame)}.");
         return;
      }
   
      Debug.Log("Fetching data...");
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      remoteConfig.FetchAsync(System.TimeSpan.Zero).ContinueWithOnMainThread(
         previousTask=>
         {
            if (!previousTask.IsCompleted)
            {
            Debug.LogError($"{nameof(remoteConfig.FetchAsync)} incomplete: Status '{previousTask.Status}'");
            return;
            }
            ActivateRetrievedRemoteConfigValues(onFetchAndActivateSuccessful);
         });
   }
   

   Observação:o valor cacheExpiration transmitido para FetchAsync define por quanto tempo os valores recuperados anteriormente devem ser armazenados em cache. Durante o desenvolvimento, é possível defini-lo como System.TimeSpan.Zero, conforme mostrado acima. Isso garante que o aplicativo sempre reflita os valores mais atualizados. No entanto, quando for lançado para produção, defina cacheExpiration como um valor mais alto para evitar a limitação. O período padrão (quando FetchAsync é chamado sem parâmetros) é de 12 horas.

2. Em seguida, conclua o método ActivateRetrievedRemoteConfigValues, que recebe um callback transmitido, onFetchAndActivateSuccessful. Quando a ativação for concluída, o callback especificado será invocado:

   private void ActivateRetrievedRemoteConfigValues(System.Action onFetchAndActivateSuccessful)
   {
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      var info = remoteConfig.Info;
      if(info.LastFetchStatus == LastFetchStatus.Success)
      {
         remoteConfig.ActivateAsync().ContinueWithOnMainThread(
            previousTask =>
            {
            Debug.Log($"Remote data loaded and ready (last fetch time {info.FetchTime}).");
            onFetchAndActivateSuccessful();
            });
      }
   }
   

Quando chamado downstream por SetRemoteConfigDefaults do contexto de inicialização, ActivateRetrievedRemoteConfigValues chama o ponto de partida anterior, InitializeCommonDataAndStartGame, para iniciar o jogo abrindo o menu principal.

6. Definir uma estratégia de carregamento da Configuração remota

Para buscar e ativar valores em outro momento durante o uso do app, é necessário chamar essas funções novamente. Se algum objeto tiver os valores armazenados em cache, eles precisarão ser notificados para executar uma atualização. Para desenvolver uma estratégia para recuperar novamente os valores da Configuração remota, considere quando os novos valores são necessários e quando iniciar a busca e a ativação de novos valores para evitar alterações durante o uso.

Conforme implementado, os valores da Configuração remota são buscados e ativados quando o app é iniciado. As buscas podem ficar ocultas durante as mudanças no menu e, ao mesmo tempo, bloquear a interação durante a transição. Além disso, esse geralmente é o momento mais relevante para conseguir novos valores, já que uma mudança no estado do menu geralmente pode ser usada para saber "para onde" o jogador está indo e prever que um valor seria usado.

Analisando o sistema de menus do Mechahamster, a maneira mais fácil de adicionar atualizações do menu de bloqueio de interface é chamá-lo antes da retomada do menu principal (especificamente quando ele é acessado por um outro menu) e transmitir o método de exibição da interface como o callback onFetchAndActivateSuccessful. O mesmo pode ser feito para o menu Seleção de nível.

Com o carregamento inicial como parte da inicialização do app, qualquer navegação pelo menu que passar pelo menu principal será processada pela primeira delas, enquanto qualquer reentrada no menu Seleção de nível também causa uma atualização. A entrada inicial no menu de seleção de nível não importa, já que ela só pode ser acessada pelo menu principal e, portanto, já está coberta.

Para ativar isso no app, conclua os métodos relevantes no menu principal e selecione os arquivos de nível, o que vai bloquear a exibição da interface até que FetchAsync e ActivateAsync sejam concluídas:

1. Abra Assets/Hamster/Scripts/States/MainMenu.cs e substitua o método Resume atual pelo seguinte:

   public override void Resume(StateExitValue results) {
      CommonData.mainGame.SelectAndPlayMusic(CommonData.prefabs.menuMusic, true);
      CommonData.mainGame.FetchRemoteConfig(InitializeUI);
   }
   

2. Salve o arquivo.
3. Abra Assets/Hamster/Scripts/States/BaseLevelSelect.cs e substitua o método Resume atual pelo seguinte:

   public override void Resume(StateExitValue results) {
      CommonData.mainGame.FetchRemoteConfig(ShowUI);
   }
   

4. Salve o arquivo.

Observação:este codelab oferece uma maneira de carregar valores da Configuração remota quando as visualizações de seleção do menu principal e do nível estão ativas, mas outras estratégias de carregamento estão disponíveis. Consulte as estratégias de carregamento da Configuração remota do Firebase para mais informações.

7. Depurar/validar comportamentos de busca

Nesse ponto, é recomendável fazer uma verificação de diagnóstico/validação. O procedimento a seguir permite testar manualmente o app e como/se ele busca e ativa os valores da Configuração remota.

As informações serão impressas como parte dos registros do simulador, dispositivo ou editor. Para iOS, é possível visualizar os registros do dispositivo e do simulador no Xcode. No Android, confira os registros executando adb logcat. Se você executar o código no Unity pressionando "Play" no editor, os registros vão aparecer na guia Console.

1. Recrie e execute o app (no Editor, usando um dispositivo ou simulador).
2. Depois que o Menu principal for exibido, analise a saída do registro do jogo, que deve conter os registros gerados por Debug.Log em FetchRemoteConfig e ActivateRetrievedRemoteConfigValues. Elas devem exibir as mensagens "Buscando dados..." e "Dados remotos carregados e prontos". Observe os carimbos de data/hora no início dessas mensagens.
3. No jogo, pressione Licença.
4. Pressione OK.
5. Aguarde até que o Menu principal do jogo seja exibido.
6. Analise a saída de registro do jogo, que é semelhante à da etapa anterior, com novos carimbos de data/hora (correspondentes ao horário definido no relógio do sistema em que você está executando o jogo).
7. No jogo, pressione Jogar.
8. Pressione Let's Roll.
9. Navegue a bola até o objetivo usando as setas do teclado, que abrirá um menu “Nível concluído”.
10. Pressione Níveis.
11. Aguarde o menu Level Select ser carregado.
12. Analise a saída do registro do jogo de novo. Ele deve corresponder às mensagens de registro das etapas anteriores, com carimbos de data/hora mais recentes, que correspondem ao horário definido no relógio do sistema em que você está executando o jogo.

Se algum desses itens não aparecer no seu app, é possível que alguma parte do fluxo de busca e ativação (ou do seu dispositivo) esteja configurada incorretamente. Se o primeiro registro não aparecer, é possível que o jogo não inicie. Revise os registros do console do Editor ou do dispositivo/emulador em busca de avisos e erros sobre seu projeto/ambiente e investigue-os. O problema pode ser tão simples quanto se conectar à Internet.

Se os registros iniciais do carregamento do menu aparecerem, mas um dos subsequentes não aparecer, investigue/implemente novamente os métodos Resume em Assets/Hamster/Scripts/States/MainMenu.cs e Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

8. Instrumentar o código

Agora que você configurou os valores de parâmetro no app no SetDefaultsAsync() e disponibilizou as versões mais atualizadas com FetchAsync() e ActivateAsync(), faça referência e use esses valores no código.

Depois de definir valores no back-end da Configuração remota, buscá-los e ativá-los (ou fazer ambos ao mesmo tempo), eles vão ficar disponíveis para o app. Para usar esses valores, chame GetValue(string key) e escolha uma chave de parâmetro como argumento. Isso retorna um ConfigValue, que tem propriedades para acessar o valor como vários tipos compatíveis: string, bool, long, double. Neste projeto e na maioria dos casos de uso de jogos, é necessário transmitir os dois últimos tipos para int e float, que são mais idiomáticos. Para garantir que essas conversões não causem problemas, verifique se os valores iniciais definidos na Configuração remota estão dentro do intervalo válido dos tipos que você vai usar no código do app.

1. Importe a Configuração remota adicionando using Firebase.RemoteConfig; à parte superior dos seguintes arquivos:
   • Assets/Hamster/Scripts/States/MainMenu.cs
   • Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
2. Substitua o método Start de AccelerationTile.cs:

   private void Start() {
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      Acceleration = (float)remoteConfig.GetValue(AccelerationTileForceKey).DoubleValue;
   }
   

   Com essa mudança, a quantidade de força transmitida pelo bloco de aceleração vai ser alterada para uma recebida da Configuração remota.
3. Edite o corpo do método InitializeUI da MainMenu.cs:

   private void InitializeUI() {
      if (menuComponent == null) {
         menuComponent = SpawnUI<Menus.MainMenuGUI>(StringConstants.PrefabMainMenu);
      }
   
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      var subtitleOverride = JsonUtility.FromJson<Menus.MainMenuGUI.SubtitleOverride>(
         remoteConfig.GetValue(SubtitleOverrideKey).StringValue);
      // Only sets values if all fields of the override are non-default.
      if(subtitleOverride != null && subtitleOverride.IsValidOverride())
      {
         menuComponent.MenuSubtitleText.text = subtitleOverride.text;
         menuComponent.MenuSubtitleText.fontSize = subtitleOverride.fontSize;
         menuComponent.MenuSubtitleText.color = subtitleOverride.textColor;
      }
      ShowUI();
   }
   

   Aqui, subtitleOverride é configurado para mudar o subtítulo na tela do menu principal se todos os campos na nuvem estiverem definidos como valores diferentes dos valores padrão do tipo.

Observação : SubtitleOverrideKey é um const string definido em MainMenu.cs definido como o parâmetro subtitle_override.

9. Definir valores de parâmetros remotamente

Agora que seu app está totalmente instrumentado, você já pode configurar parâmetros e valores no servidor da Configuração remota. Neste codelab, vamos configurar isso usando o Console do Firebase.

1. Abra seu projeto no Console do Firebase.
2. Selecione Configuração remota no menu para ver o painel do recurso.
3. Para cada um dos parâmetros que você definiu no app e listados na tabela a seguir, clique em Adicionar parâmetro, cole o nome do parâmetro (chave), selecione o Tipo de dados listado na tabela, desative Usar no app padrão e cole o novo valor padrão:

   Nome do parâmetro (chave)	Tipo de dado	Valor padrão
   aceleração_tile_force	Número	100
   legenda_substituir	JSON	{"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}

   

   Observação:é possível definir um valor padrão para cada parâmetro, que substitui o valor padrão no app. Saiba mais em Parâmetros e condições da Configuração remota.

4. Clique em Salvar.
5. Clique em Publicar para publicar a nova configuração e disponibilizar os novos valores para o jogo.
6. Execute o app novamente depois de definir esses parâmetros remotos e observe como eles substituem os padrões originais.

   Dica: no caso de valores mais difíceis de observar, como os de física, atualize o código para registrar o valor de ConfigValue.Sourceto determine se os valores são os padrões configurados ou se foram buscados no servidor da Configuração remota.

Observação:use os métodos ToJson e FromJson<T> do JsonUtility (link em inglês) do Unity para codificar e decodificar um objeto de dados serializável para e de uma string, como é feito atualmente na inicialização de SubtitleOverrideDefault em MainMenu.cs. A documentação Serializável do Unity descreve as restrições do Unity em relação à serialização de objetos.

10. Use as condições da Configuração remota para exibir variantes

Você pode adaptar a experiência do app aos usuários com base no idioma que eles falam, onde estão, na hora do dia ou na plataforma que usam. As condições da Configuração remota permitem usar esses e outros atributos individualmente ou em combinação para mostrar valores diferentes (chamados de variantes) ao usuário.

Um uso comum para condições é na alteração de conteúdo entre as plataformas iOS e Android. Siga as etapas abaixo para implementar uma condição que exibe um valor diferente para subtitle_override, dependendo de qual plataforma está em uso.

1. Abra a guia Configuração remota do seu projeto no Console do Firebase.
2. Clique no botão de edição de subtitle_override.
3. No canto inferior esquerdo, clique em Adicionar novo.
4. No menu suspenso exibido, passe o cursor sobre Valor condicional e clique em Criar nova condição.
5. Quando solicitado, nomeie a condição como "é iOS" se você estiver segmentando iOS, ou "é Android" se você estiver segmentando Android. Se você segmentar os dois, basta escolher um aqui e usá-lo no restante do codelab.
6. Em Aplicável se..., clique no menu suspenso Selecionar... e escolha Plataforma. Em seguida, selecione a plataforma adequada.
7. Clique em Criar condição para criar a condição. A caixa de diálogo "Editar parâmetro" reaparece e você já pode definir um valor:
   • Se você segmentar Android, defina o Valor como:

     {"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
     

   • Se você segmentar iOS, defina o Valor como:

     {"text":"Level Up iOS Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
     

8. Clique em Salvar.
9. Clique em Publicar para publicar a nova configuração e disponibilizar os novos valores para o jogo.

Se você criar e executar o jogo novamente, o subtítulo dele será substituído pela variante específica da plataforma.

11. Defina a Configuração remota para receber atualizações em tempo real

Observação:as atualizações da Configuração remota em tempo real são compatíveis com a versão 11.0.0 ou mais recente do SDK para plataformas Android e Apple. No momento, ele não tem suporte no modo de jogo do Unity.

A Configuração remota agora pode detectar e processar atualizações dos modelos da Configuração remota em tempo real. Os apps podem se inscrever na nova API de Configuração remota em tempo real para detectar alterações de configuração e valores atualizados.

Como funciona

Para detectar atualizações, o app precisa implementar um método inscrito no evento OnConfigUpdateListener. Enquanto um ou mais listeners de atualização de configuração estão inscritos, os novos modelos da Configuração remota serão buscados automaticamente, os gerenciadores inscritos são chamados e podem ser usados para executar a lógica em resposta, como ativar os novos valores e disponibilizá-los para o restante do aplicativo.

Observação:se todos os assinantes forem removidos do OnConfigUpdateListener, ele não vai mais detectar mudanças no modelo da Configuração remota do seu projeto.

Implementar a Configuração remota em tempo real

Para ilustrar como isso funciona no jogo, faça as seguintes alterações no seu código.

Criar um gerenciador de atualização de configuração

A primeira etapa para usar o evento Config Update é criar um método capaz de detectá-lo. Coloque o seguinte método em Assets/Hamster/Scripts/MainGame.cs:

   void ActivateValuesOnConfigUpdate( object sender, ConfigUpdateEventArgs args)
   {
      if (args.Error != RemoteConfigError.None) {
         Debug.Log($"Error occurred while listening: {args.Error}");
         return;
      }

      Debug.Log("Updated keys: " + string.Join(", ", args.UpdatedKeys));
      // Activate all fetched values and then logs.
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      remoteConfig.ActivateAsync().ContinueWithOnMainThread(
         task => {
            Debug.Log($"Keys from {nameof(ActivateValuesOnConfigUpdate)} activated.");
         });
   }

Esse método vai imprimir uma lista de chaves atualizadas e uma mensagem de êxito no registro quando os novos valores forem ativados.

Inscrever-se no evento de atualização

Inscreva-se no evento para ativar ActivateValuesOnConfigUpdate quando o evento for chamado. Substitua o método InitializeCommonDataAndStartGame() em Assets/Hamster/Scripts/MainGame.cs pelo seguinte:

   void InitializeCommonDataAndStartGame()
   {
      CommonData.prefabs = FindObjectOfType<PrefabList>();
      CommonData.mainCamera = FindObjectOfType<CameraController>();
      CommonData.mainGame = this;

      Screen.orientation = ScreenOrientation.LandscapeLeft;

      musicPlayer = CommonData.mainCamera.GetComponentInChildren<AudioSource>();

      CommonData.gameWorld = FindObjectOfType<GameWorld>();

      // Set up volume settings.
      MusicVolume = PlayerPrefs.GetInt(StringConstants.MusicVolume, MaxVolumeValue);
      // Set the music to ignore the listeners volume, which is used for sound effects.
      CommonData.mainCamera.GetComponentInChildren<AudioSource>().ignoreListenerVolume = true;
      SoundFxVolume = PlayerPrefs.GetInt(StringConstants.SoundFxVolume, MaxVolumeValue);

      // Subscribes to on config update after first initial fetch and activate
      FirebaseRemoteConfig.DefaultInstance.OnConfigUpdateListener += ActivateValuesOnConfigUpdate;

      stateManager.PushState(new States.MainMenu());
   }

A nova linha (que termina com += ActivateValuesOnConfigUpdate;) inscreve o manipulador de eventos no evento.

Cancelar inscrição quando o objeto proprietário do gerenciador for destruído

Para evitar erros de referência nula, objetos com métodos inscritos em eventos precisam cancelar a inscrição desse método quando são destruídos. Adicione o seguinte método a Assets/Hamster/Scripts/MainGame.cs:

   private void OnDestroy() 
   {
      FirebaseRemoteConfig.DefaultInstance.OnConfigUpdateListener -= ActivateValuesOnConfigUpdate;
   }

Testar a nova funcionalidade

Para validar a nova funcionalidade, teste o app criado. O procedimento a seguir exige que você leia o registro e depure usando um dispositivo real.

Mude acceleration_tile_force e observe

Depois de iniciar o app, faça o seguinte na seção "Configuração remota" do Console do Firebase:

1. Pressione o botão de edição ao lado de acceleration_tile_force.

2. Mude o valor para "120" e pressione Salvar.

3. Clique no botão Publicar alterações.

4. Inspecione o registro.
5. Se você vir uma mensagem de registro que comece com "Error failed when listening" (Ocorreu um erro ao ouvir), leia o restante e tente depurar com a mensagem de erro exibida.
6. Caso você veja um registro que comece com "Chaves atualizadas", seu app recebeu os valores alterados.
7. Se você não encontrar nada disso, analise o restante dos registros e revise novamente as instruções em Criar um gerenciador de atualização de configuração. Em seguida, teste e verifique os registros outra vez para determinar se algo está errado.

Aviso:isso não vai buscar um novo valor condicional se você mudar a avaliação da condição (por exemplo, se um usuário tem uma determinada propriedade do usuário do Analytics definida ou se faz parte de um público-alvo do Analytics). Por enquanto, mantenha as chamadas para FetchRemoteConfig (que chama FetchAndActivate) em Assets/Hamster/Scripts/States/MainMenu.cs e Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

12. Parabéns!

Você usou a Configuração remota para controlar os valores no jogo de forma remota, buscando-os no app e usando condições para disponibilizar variantes diferentes.

O que aprendemos

• Como definir e recuperar valores da Configuração remota
• Como instrumentar seu código do Unity C# para usar os valores recuperados.
• Como armazenar, instrumentar e substituir valores/objetos compostos como valores JSON.
• Como usar as condições da Configuração remota para exibir variantes de valor diferentes

Próximas etapas

Leia sobre a prioridade de valores de parâmetros para entender melhor a lógica de quais valores são obtidos por uma instância de app quando ela usa um parâmetro com diversos valores (devido a condições ou localidade).

Siga para a próxima etapa do Programa de treinamentos,em que você vai usar esses valores instrumentados para fazer testes A/B em diferentes variantes e entender melhor como elas afetam o comportamento do usuário.