Instrumente seu jogo Unity com o Firebase Remote Config

1. Introdução

Você pode usar o Firebase Remote Config para definir pares de valores-chave , também conhecidos como 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.

Você adicionará essa nova funcionalidade a um jogo de amostra, MechaHamster: Level Up with Firebase Edition . Este jogo de exemplo é uma nova versão do jogo clássico do Firebase, MechaHamster, que remove a maior parte de sua funcionalidade integrada do Firebase, dando a você a oportunidade de implementar novos usos do Firebase em seu lugar.

Para garantir que seu aplicativo se comporte conforme esperado, você definirá configurações padrão para valores no exemplo de código do jogo, e esses valores poderão ser substituídos por valores definidos na Configuração remota no console do Firebase .

O que você aprenderá

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

O que você precisará

• Unity 2019.1.0f1 ou superior com suporte para compilação iOS e/ou Android
• Um dispositivo físico Android/iOS ou um simulador/emulador para construir e executar o jogo

2. Configure seu ambiente de desenvolvimento

As seções a seguir descrevem como fazer download do código do Level Up with Firebase , abri-lo no Unity e adicionar um projeto do Firebase. Este jogo de amostra Level Up with Firebase é usado por vários outros codelabs Firebase + Unity, então talvez você já tenha concluído as tarefas nesta seção. Nesse caso, você pode pular essas etapas e prosseguir para Adicionar SDKs do Firebase para Unity para adicionar a Configuração remota ao exemplo de código do jogo.

Baixe o código

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

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

Alternativamente, se você não tiver o git instalado, poderá baixar o repositório como um arquivo ZIP .

Abra Level Up com Firebase no editor Unity

1. Inicie o Unity Hub e, na guia Projetos , clique na seta suspensa ao lado de Abrir .
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 Unity para usar e sua plataforma de destino (Android ou iOS).
5. Clique no nome do projeto, level-up-with-firebase e o projeto será aberto no editor Unity.
6. Se o seu editor não abri-lo automaticamente, abra MainGameScene em Assets > Hamster na guia Project do Unity Editor.
   

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

3. Adicione o Firebase ao seu projeto Unity

Crie um projeto do Firebase

1. No console do Firebase , clique em Adicionar projeto .
2. Para criar um novo projeto, insira o nome do projeto desejado.
   Isso também definirá o ID do projeto (exibido abaixo do nome do projeto) como algo baseado no nome do projeto. Opcionalmente, você pode clicar no ícone de edição no ID do projeto para personalizá-lo ainda mais.
3. Se solicitado, revise e aceite os termos do Firebase .
4. Clique em Continuar .
5. Selecione a opção Ativar 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 para criar uma nova conta.
7. Clique em Criar projeto .
8. Quando o projeto for criado, clique em Continuar .

Registre seu aplicativo 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 ou, se você já adicionou um aplicativo ao seu projeto do Firebase, clique em Adicionar aplicativo para exibir as opções da plataforma.
2. Selecione para registrar os destinos de compilação Apple (iOS) e Android.
3. Insira os IDs específicos da plataforma do seu projeto Unity. Para este codelab, insira o seguinte:
   • Para Apple (iOS) – Digite com.google.firebase.level-up no campo ID do pacote iOS .
   • Para Android – digite com.google.firebase.level_up no campo de nome do pacote Android .
4. Opcionalmente, insira os apelidos específicos da plataforma do seu projeto Unity.
5. Clique em Registrar aplicativo e prossiga para a seção Baixar arquivo de configuração .
6. Repita o processo para qualquer destino de construção que você não fez na primeira vez.

Adicionar arquivos de configuração do Firebase

Depois de clicar em Register app , você será solicitado a baixar 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. Baixe os dois arquivos de configuração disponíveis:
   • Para Apple (iOS) : Baixe GoogleService-Info.plist .
   • Para Android : Baixe google-services.json .
2. Abra a janela Projeto do seu projeto Unity e mova os dois arquivos de configuração para a pasta Assets .

   Importante: Mesmo que você esteja planejando construir apenas iOS ou Android, você deve baixar ambos os arquivos e adicioná-los ao seu projeto.

3. De volta ao console do Firebase, no fluxo de trabalho de configuração, clique em Avançar e prossiga para Adicionar SDKs do Firebase para Unity.

Observação: você pode baixar novamente esses arquivos posteriormente abrindo as configurações gerais do seu projeto, rolando para baixo até a seção Seus aplicativos e clicando no botão de download do arquivo de configuração desejado.

Adicionar SDKs do Firebase para Unity

1. Clique em Baixar Firebase Unity SDK no console do Firebase.

   Observação: o download deste SDK pode demorar um pouco. Visualize as próximas etapas ou faça uma pequena pausa.

2. Descompacte o SDK em algum lugar conveniente.
3. Em seu projeto Unity aberto, navegue até Assets > Import Package > Custom Package .
4. Na caixa de diálogo Importar pacote , navegue até o diretório que contém o SDK descompactado, selecione FirebaseAnalytics.unitypackage e clique em Abrir .
5. Na caixa de diálogo Importar pacote do Unity que aparece, clique em Importar .
6. Repita as etapas anteriores para importar os dois pacotes a seguir:
   • FirebaseRemoteConfig.unitypackage
   • FirebaseCrashlytics.unitypackage
     Crashlytics é um repórter de falhas leve e em tempo real que ajuda você a rastrear, priorizar e corrigir problemas de estabilidade que prejudicam a qualidade do seu aplicativo. Se você ainda não o usou, considere concluir o Caminho de aprendizagem do Crashlytics para Unity .
7. Retorne ao console do Firebase e, no fluxo de trabalho de configuração, clique em Avançar .

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

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

Neste codelab, você atualizará objetos que usam valores definidos no código ou são serializados no editor do Unity para usar valores instrumentados com o Configuração remota. Você configurará valores padrão para cada parâmetro usando SetDefaultsAsync para que seu aplicativo se comporte conforme esperado antes de se conectar ao back-end do Configuração remota. Seu aplicativo permanecerá atualizado buscando novos valores do Configuração remota e ativando-os para torná-los utilizáveis ​​no código.

Para buscar novos valores do Configuração remota, há vários métodos não implementados já presentes no arquivo Assets/Hamster/Scripts/MainGame.cs que devem 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 de tarefas C# que ajudarão a simplificar o gerenciamento do processo de inicialização com retornos de chamada.
2. Adicione a inicialização do Firebase ao método MainGame.cs Start() substituindo o método InitializeCommonDataAndStartGame() existente pelo método atualmente não implementado, InitializeFirebaseAndStartGame() :

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

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

   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 aplicativo. 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. Busque e ative novos valores (conforme necessário)

Agora precisamos concluir o método FetchRemoteConfig existente. Isso encadeará chamadas para os métodos FetchAsync (que busca novos valores do Configuração remota) e ActivateAsync (que ativa os valores obtidos para disponibilizá-los no código) do Configuração remota usando um parâmetro de retorno de chamada chamado onFetchAndActivateSuccessful .

O código de inicialização que adicionamos na etapa anterior chama FetchRemoteConfig com InitializeCommonDataAndStartGame como retorno de chamada para iniciar o jogo no final da sequência. Você pode passar retornos de chamada alternativos para FetchRemoteConfig para invocar a busca com resultados diferentes. Um exemplo (que você implementará mais tarde) é passar um método que abre novos menus de IU, que dependem dos valores do 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);
         });
   }
   

   Nota: O valor cacheExpiration passado para FetchAsync define por quanto tempo os valores recuperados anteriormente devem ser armazenados em cache. Durante o desenvolvimento, você pode definir isso como System.TimeSpan.Zero conforme mostrado acima. Isso garante que o aplicativo sempre reflita os valores mais atualizados. No entanto, quando liberado para produção, você deve definir cacheExpiration com um valor mais alto para evitar 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 retorno de chamada transmitido, onFetchAndActivateSuccessful . Quando a ativação terminar, o retorno de chamada 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 inicial anterior, InitializeCommonDataAndStartGame , para iniciar o jogo abrindo o menu principal.

6. Configure uma estratégia de carregamento do Configuração remota

Para buscar e ativar valores em outro momento durante o uso do app, é necessário chamar essas funções novamente e, caso algum objeto tenha armazenado os valores em cache, ele deverá ser notificado para realizar uma atualização. Para desenvolver uma estratégia para buscar novamente os valores da Configuração remota, considere quando os novos valores serão necessários e quando iniciar a busca e a ativação de novos valores para evitar sua alteração durante o uso.

Conforme implementado atualmente, os valores do Configuração remota são buscados e ativados quando o aplicativo é iniciado. As buscas podem ser ocultadas durante as alterações de menu, ao mesmo tempo que bloqueiam a interação durante a transição. Além disso, este é muitas vezes o momento mais relevante para obter novos valores, já que uma mudança no estado do menu pode muitas vezes ser usada para saber “para onde” o jogador está indo e prever que um valor seria usado.

Examinando o sistema de menu do Mechahamster, a maneira mais fácil de adicionar atualizações de menu de bloqueio de IU é chamá-lo antes que o menu principal seja retomado (especificamente quando ele é acessado saindo de outro menu) e passar o método de exibição da IU como o retorno de chamada onFetchAndActivateSuccessful . O mesmo pode ser feito para o menu Level Select .

Com o carregamento inicial como parte da inicialização do aplicativo, qualquer navegação no menu que passe pelo menu principal será tratada pelo primeiro deles, enquanto qualquer reentrada no menu de seleção de nível também causará uma atualização. A entrada inicial no menu de seleção de nível não importa, pois só pode ser acessado a partir do menu principal e, portanto, já está coberto.

Para habilitar isso no aplicativo, conclua os métodos relevantes no menu principal e nos arquivos de seleção de nível, que bloquearão a exibição da IU até que FetchAsync e ActivateAsync sejam concluídos:

1. Abra Assets/Hamster/Scripts/States/MainMenu.cs e substitua o método Resume existente 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 , substitua o método Resume existente pelo seguinte:

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

4. Salve o arquivo.

Observação: embora este codelab forneça uma maneira de carregar valores do Configuração remota quando o menu principal e as visualizações de seleção de nível estão ativos, outras estratégias de carregamento estão disponíveis. Consulte Estratégias de carregamento do Firebase Remote Config para mais informações.

7. Depurar/validar comportamentos de busca

Neste ponto, é benéfico fazer uma verificação de diagnóstico/validação. O procedimento a seguir permitirá que você teste manualmente seu aplicativo e como/se ele busca e ativa os valores da Configuração remota.

As informações serão impressas como parte dos registros do seu simulador, dispositivo ou editor. Para iOS, você pode visualizar logs de dispositivos e simuladores no Xcode. Para Android, visualize os registros executando adb logcat . Se você executar o código no Unity pressionando Play no editor, os logs aparecerão na guia Console.

1. Reconstrua e execute o aplicativo (no Editor, usando um dispositivo ou simulador).
2. Depois que o menu principal do jogo aparecer, revise a saída de log do jogo, que deve conter os logs gerados por Debug.Log em FetchRemoteConfig e ActivateRetrievedRemoteConfigValues ​​. Eles devem mostrar as mensagens "Buscando dados..." e "Dados remotos carregados e prontos". Observe os carimbos de data e hora no início dessas mensagens.
3. No jogo, pressione Licença .
4. Pressione OK .
5. Aguarde até que o menu principal do jogo apareça.
6. Revise a saída de log do seu jogo, que deve ser semelhante à da etapa anterior, com novos carimbos de data e hora (correspondendo ao horário definido no relógio do sistema em que você está executando o jogo).
7. No jogo, pressione Play .
8. Pressione Vamos rolar .
9. Navegue com a bola até o gol usando as setas do teclado, o que abrirá um menu de nível completo.
10. Pressione Níveis .
11. Aguarde o carregamento do menu de seleção de nível .
12. Revise a saída de log do seu jogo novamente. Ele deve corresponder às mensagens de log das etapas anteriores, com carimbos de data e hora mais recentes (correspondendo à hora definida no relógio do sistema onde você está executando o jogo).

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

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

8. Instrumente seu código

Agora que você configurou valores de parâmetros no aplicativo em SetDefaultsAsync() e disponibilizou as versões mais atualizadas com FetchAsync() e ActivateAsync() , você fará referência e usará esses valores no código.

Depois de definir valores no back-end do Configuração remota, buscá-los e ativá-los ( ou fazer as duas coisas ao mesmo tempo ), esses valores estarão disponíveis para seu aplicativo. Para usar esses valores, chame GetValue(string key ) e escolha uma chave de parâmetro como argumento. Isso retorna um ConfigValue , que possui propriedades para acessar o valor como vários tipos suportados: string , bool , long , double . Neste projeto e na maioria dos casos de uso de jogos, você deve converter os dois últimos tipos para os mais idiomáticos int e float . 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ê usará no código do seu aplicativo.

1. Importe o Remote Config adicionando using Firebase.RemoteConfig; no topo 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 alteração, a quantidade de força transmitida pelo bloco de aceleração será alterada para aquela recebida da Configuração remota.
3. Edite o corpo do método InitializeUI de 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 está configurado para alterar a legenda na tela do menu principal se todos os seus campos na nuvem estiverem definidos como valores diferentes dos valores padrão de seu tipo .

Nota: SubtitleOverrideKey é uma const string definida em MainMenu.cs definida como o parâmetro subtitle_override .

9. Defina os valores dos parâmetros remotamente

Agora que seu aplicativo está totalmente instrumentado, você está pronto para configurar parâmetros e valores no servidor do Configuração remota. Neste codelab, configuraremos isso usando o console do Firebase.

1. No console do Firebase , abra seu projeto.
2. Selecione Configuração remota no menu para visualizar o painel do Configuração remota.
3. Para cada parâmetro definido em seu aplicativo e listado 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 padrão no aplicativo e cole no novo valor padrão:

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

   

   Observação: para cada parâmetro, você pode definir um valor padrão, que substitui o valor padrão do aplicativo. Para saber mais, consulte Parâmetros e condições do Configuração remota .

4. Clique em Salvar para salvar suas alterações.
5. Clique em Publicar para publicar a nova configuração e disponibilizar os novos valores para o seu jogo.
6. Execute seu aplicativo novamente após definir esses parâmetros remotos e observe como eles substituem os padrões originais.

   Dica: para valores mais difíceis de observar, como valores físicos, você pode atualizar o código para registrar o valor de ConfigValue.Source para determinar se os valores são os padrões configurados ou se foram buscados no servidor do Configuração remota .

Nota: Use os métodos ToJson e FromJson<T> do JsonUtility do Unity para codificar e decodificar um objeto de dados Serializable de e para 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 do Configuração remota para veicular variantes

Você pode querer oferecer a experiência do aplicativo ao usuário com base no idioma que ele fala, onde está, a hora do dia ou a plataforma que usa. As condições da Configuração remota permitem usar esses e outros atributos individualmente ou em combinação para fornecer valores diferentes (chamados de variantes) ao usuário.

Um uso comum das condições é alterar o conteúdo entre as plataformas iOS e Android. Siga as etapas abaixo para implementar uma condição que forneça um valor diferente para subtitle_override dependendo da plataforma em uso.

1. Abra a guia Configuração remota do seu projeto no console do Firebase .
2. Clique no botão de edição para subtitle_override.
3. No canto inferior esquerdo, clique em Adicionar novo .
4. No menu suspenso exibido, passe o mouse sobre Valor condicional e clique em Criar nova condição.
5. Quando solicitado, nomeie a condição como "é iOS" se você estiver direcionando para iOS ou "is Android" se estiver direcionando para Android. Se você estiver segmentando ambos, basta escolher um aqui e usá-lo no restante do codelab.
6. Em Aplica-se se... , clique no menu suspenso Selecionar... e selecione Plataforma . Em seguida, selecione a plataforma apropriada.
7. Clique em Criar condição para criar a condição. A caixa de diálogo Editar parâmetro reaparece e agora você pode definir um valor:
   • Se você estiver direcionando para 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ê estiver direcionando para 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 para salvar suas alterações.
9. Clique em Publicar para publicar a nova configuração e disponibilizar os novos valores para o seu jogo.

Se você construir e executar o jogo novamente, verá a legenda do jogo substituída por sua variante específica da plataforma.

11. Configure o Remote Config para receber atualizações em tempo real

Observação: as atualizações do Configuração remota em tempo real são compatíveis com o SDK versão 11.0.0 e superior para plataformas Android e Apple. Atualmente não é compatível com o Unity Play Mode.

O Configuração remota agora pode detectar e gerenciar atualizações de modelos do Configuração remota em tempo real . Os aplicativos podem assinar a nova API de configuração remota em tempo real para ouvir alterações de configuração e valores atualizados.

Como funciona

Para escutar atualizações, seu aplicativo precisa implementar um método que assine o evento OnConfigUpdateListener . Enquanto um ou mais listeners de atualização de configuração estiverem inscritos, novos modelos do Configuração remota serão buscados automaticamente, os manipuladores inscritos serão chamados e poderão 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 de OnConfigUpdateListener , ele deixará de escutar alterações no modelo do Configuração remota do seu projeto.

Implemente a Configuração remota em tempo real

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

Crie um manipulador de atualização de configuração

A primeira etapa para usar o evento Config Update é criar um método capaz de ouvi-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.");
         });
   }

Este método imprimirá uma lista de chaves atualizadas e uma mensagem de sucesso no log quando ativar os novos valores.

Inscreva-se no evento de atualização

Para ativar ActivateValuesOnConfigUpdate quando o evento for chamado, inscreva-o no evento. 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 (terminando com += ActivateValuesOnConfigUpdate; ) inscreve o manipulador de eventos no evento.

Cancelar assinatura quando o objeto proprietário do manipulador for destruído

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

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

Teste a nova funcionalidade

Para validar a nova funcionalidade, experimente seu aplicativo criado. O procedimento a seguir requer que você possa ler o log e depurar usando um dispositivo real .

Altere acceleration_tile_force e observe

Depois de iniciar seu aplicativo, na seção Configuração remota do console do Firebase:

1. Pressione o botão de edição próximo a acceleration_tile_force .

2. Altere 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 log que começa com "Ocorreu um erro durante a escuta", leia o restante e tente depurar com a mensagem de erro impressa.
6. Se você vir um registro que começa com "Chaves atualizadas", seu aplicativo recebeu os valores alterados.
7. Se você não vir nada disso, examine o restante dos seus logs e revise novamente as instruções em Criar um manipulador de atualização de configuração , teste novamente e verifique novamente os logs para determinar se algo está errado.

Aviso: observe que isso não buscará um novo valor condicional se você alterar a avaliação de sua condição (como se um usuário tem determinadas propriedades de usuário do Analytics definidas ou se faz parte de um público do Analytics). Portanto, 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 remotamente os valores do jogo, buscando-os no seu aplicativo e usando condições para exibir diferentes variantes.

O que cobrimos

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

Próximos passos

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

Continue para a próxima etapa do caminho, onde você usará esses valores instrumentados para testar A/B diferentes variantes para entender melhor como elas afetam o comportamento do usuário.