Fazer login em jogos Android

Para acessar a funcionalidade dos serviços relacionados a jogos do Google Play, seu jogo precisa fornecer o na conta do jogador que fez login. Se o jogador não estiver autenticado, o jogo poderá encontrar erros ao fazer chamadas às APIs dos serviços relacionados a jogos do Google Play. Esta documentação descreve como implementar uma experiência de login perfeita no seu jogo.

Como implementar o login do jogador

A classe GoogleSignInClient é o principal ponto de entrada para recuperar a conta do atual jogador conectado e para fazer login do jogador caso ainda não tenha feito isso no seu app na dispositivo.

Para criar um cliente de login, siga estas etapas:

1. Crie um cliente de login pelo GoogleSignInOptions conforme mostrado no snippet de código a seguir. Na GoogleSignInOptions.Builder para configurar seu login, é preciso especificar GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN

   GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;

2. Se você quiser usar um SnapshotsClient, Depois, adicione .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) GoogleSignInOptions.Builder conforme mostrado neste snippet de código:

   GoogleSignInOptions  signInOptions =
       new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
           .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
           .build();

3. Chame o método GoogleSignIn.getClient() e transmita as opções que você configurou nas etapas anteriores. Se a chamada for bem-sucedido, a API de Login do Google retornará uma instância do GoogleSignInClient

Verificar se o jogador já fez login

É possível verificar se uma conta já está conectada no dispositivo atual usando GoogleSignIn.getLastSignedInAccount() e se essa conta já tem as permissões necessárias concedidas usando o GoogleSignIn.hasPermissions() Se ambas as condições forem verdadeiras, ou seja, getLastSignedInAccount() retornará uma um valor não nulo e hasPermissions() retorna true. Você pode usar a conta retornada de getLastSignedInAccount(), mesmo se o dispositivo estiver off-line.

Como fazer login silencioso

Você pode chamar silentSignIn() para recuperar a conta do jogador conectado no momento. e tentar fazer login dos jogadores sem exibir uma interface do usuário se eles tiverem fez login no app em outro dispositivo.

O método silentSignIn() retorna um Task<GoogleSignInAccount>. Quando a tarefa for concluída, defina o campo GoogleSignInAccount declarado anteriormente na conta de login que a tarefa retorna como resultado, ou para null, indicando que não há um usuário conectado.

Se a tentativa silenciosa de login falhar, você poderá enviar a intent de login para exibir uma interface do usuário de login, conforme descrito em Como fazer login interativo.

Como o estado do player conectado pode mudar quando a atividade não está em primeiro plano, nós recomendamos chamar silentSignIn() no onResume() .

Para fazer o login silenciosamente, siga estas etapas:

1. Chame o método silentSignIn() na GoogleSignInClient para iniciar o fluxo de login silencioso. Essa chamada retorna um objeto Task<GoogleSignInAccount> que contém um GoogleSignInAccount se login silencioso seja bem-sucedido.
2. Processar o sucesso ou falha do login do jogador substituindo OnCompleteListener
   • Se a tarefa de login tiver sido bem-sucedida, acesse o GoogleSignInAccount objeto chamando getResult().
   • Se o login não foi bem-sucedido, você pode enviar uma intent de login para iniciar um fluxo de login interativo. Para obter uma lista de listeners de retorno de chamada adicionais, consulte o Guia da API Tasks para desenvolvedores e Task Referência da API.

O snippet de código a seguir mostra como seu app pode realizar o login silencioso:

private void signInSilently() {
  GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
  GoogleSignInAccount account = GoogleSignIn.getLastSignedInAccount(this);
  if (GoogleSignIn.hasPermissions(account, signInOptions.getScopeArray())) {
    // Already signed in.
    // The signed in account is stored in the 'account' variable.
    GoogleSignInAccount signedInAccount = account;
  } else {
    // Haven't been signed-in before. Try the silent sign-in first.
    GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOptions);
    signInClient
        .silentSignIn()
        .addOnCompleteListener(
            this,
            new OnCompleteListener<GoogleSignInAccount>() {
              @Override
              public void onComplete(@NonNull Task<GoogleSignInAccount> task) {
                if (task.isSuccessful()) {
                  // The signed in account is stored in the task's result.
                  GoogleSignInAccount signedInAccount = task.getResult();
                } else {
                  // Player will need to sign-in explicitly using via UI.
                  // See [sign-in best practices](http://developers.google.com/games/services/checklist) for guidance on how and when to implement Interactive Sign-in,
                  // and [Performing Interactive Sign-in](http://developers.google.com/games/services/android/signin#performing_interactive_sign-in) for details on how to implement
                  // Interactive Sign-in.
                }
              }
            });
  }
}

@Override
protected void onResume() {
  super.onResume();
  signInSilently();
}

Se a tentativa silenciosa de login falhar, você poderá chamar getException() para conseguir um ApiException com o código de status detalhado. Um código de status de CommonStatusCodes.SIGN_IN_REQUIRED indica que o jogador precisa realizar uma ação explícita para fazer login. Nesse caso, o app deve iniciar um fluxo de login interativo, conforme descrito na próxima seção.

Como fazer login interativo

Para fazer login com a interação do jogador, o app precisa iniciar a intent de login. Em caso de sucesso, a API de Login do Google exibe uma interface do usuário que solicita que o jogador insira as credenciais. para fazer login. Essa abordagem simplifica o desenvolvimento do app, já que a atividade de login processa como a necessidade de atualizar o Google Play Services ou mostrar solicitações de consentimento, na nome de usuário. O resultado é retornado pela função onActivityResult o retorno de chamada.

Para fazer login de forma interativa, siga estas etapas:

1. Chame getSigninIntent() no GoogleSignInClient para receber uma intent de login e chame startActivity() e transmitir essa intent. O snippet de código a seguir mostra como o app pode iniciar um fluxo de login interativo:

   private void startSignInIntent() {
     GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
         GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
     Intent intent = signInClient.getSignInIntent();
     startActivityForResult(intent, RC_SIGN_IN);
   }

2. No onActivityResult() , lida com o resultado da intent retornada.

   • Se o resultado do login der certo, acesse a Objeto GoogleSignInAccount do GoogleSignInResult.
   • Se o resultado do login não for bem-sucedido, você deverá lidar com o erro de login (por exemplo, exibir uma mensagem de erro em um alerta). O snippet de código a seguir mostra como seu app pode lidar com os resultados do login do jogador:

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
     super.onActivityResult(requestCode, resultCode, data);
     if (requestCode == RC_SIGN_IN) {
       GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
       if (result.isSuccess()) {
         // The signed in account is stored in the result.
         GoogleSignInAccount signedInAccount = result.getSignInAccount();
       } else {
         String message = result.getStatus().getStatusMessage();
         if (message == null || message.isEmpty()) {
           message = getString(R.string.signin_other_error);
         }
         new AlertDialog.Builder(this).setMessage(message)
             .setNeutralButton(android.R.string.ok, null).show();
       }
     }
   }

Recuperar informações do jogador

O GoogleSignInAccount que a API de Login do Google retorna não contém nenhum player informações imprecisas ou inadequadas. Se o jogo usa informações do jogador, como o nome de exibição e o ID dele, siga estas etapas para recuperar essas informações.

1. Consiga um objeto PlayersClient chamando o método getPlayersClient() e transmitindo: GoogleSignInAccount como parâmetro.
2. Use os métodos PlayersClient para carregar a Player de forma assíncrona. que contém as informações de um jogador. Por exemplo, é possível chamar getCurrentPlayer(). para carregar o jogador conectado no momento. Se a tarefa retornar uma ApiException com o código de status de SIGN_IN_REQUIRED, isso indica que o jogador precisa ser autenticado novamente. Para fazer isso, chame GoogleSignInClient.getSignInIntent() para fazer login no player de forma interativa.
3. Se a tarefa retornar o objeto Player, você poderá chamar os métodos da Objeto Player para recuperar detalhes específicos do jogador (por exemplo, getDisplayName() ou getPlayerId().

Fornecer um botão de login

Para oferecer um botão de login padrão do Google no jogo, use um dos estas abordagens:

• Incluir um com.google.android.gms.common.SignInButton no layout da atividade principal; ou
• Criar um botão de login personalizado de acordo com a marca do Login do Google diretrizes.

Quando os usuários clicarem no botão de login, o jogo vai iniciar o fluxo de login enviando uma intent de login, conforme descrito em Como realizar login interativo.

Este snippet de código mostra como adicionar um botão de login no onCreate() para sua atividade.

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_sign_in);
  findViewById(R.id.sign_in_button).setOnClickListener(this);
  findViewById(R.id.sign_out_button).setOnClickListener(this);
}

O snippet de código a seguir mostra como enviar a intent de login quando o usuário clica no botão botão de login.

@Override
public void onClick(View view) {
  if (view.getId() == R.id.sign_in_button) {
    // start the asynchronous sign in flow
    startSignInIntent();
  } else if (view.getId() == R.id.sign_out_button) {
    // sign out.
    signOut();
    // show sign-in button, hide the sign-out button
    findViewById(R.id.sign_in_button).setVisibility(View.VISIBLE);
    findViewById(R.id.sign_out_button).setVisibility(View.GONE);
  }
}

Mostrar pop-ups do jogo

Você pode mostrar visualizações de pop-up no jogo usando a classe GamesClient. Por exemplo, seu jogo pode exibir um pop-up de "Boas-vindas de volta" ou "Conquistas desbloqueadas". Para permitir os serviços relacionados a jogos do Google Play para abrir pop-ups em visualizações no seu jogo, chame o método setViewForPopups() . É possível personalizar ainda mais onde o pop-up aparece na tela chamando setGravityForPopups()

Como desconectar o jogador

O logout é feito chamando o método signOut() no GoogleSignInClient.

private void signOut() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  signInClient.signOut().addOnCompleteListener(this,
      new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
          // at this point, the user is signed out.
        }
      });
}