Fazer login em jogos do Android

Para acessar a funcionalidade dos serviços relacionados a jogos do Google Play, seu jogo precisa fornecer a conta do jogador conectado. Se o jogador não estiver autenticado, o jogo pode encontrar erros ao fazer chamadas para as 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 jogador conectado e fazer login dele, caso isso ainda não tenha sido feito no app no dispositivo.

Para criar um cliente de login, siga estas etapas:

  1. Crie um cliente de login usando o objeto GoogleSignInOptions, conforme mostrado no snippet de código a seguir. Em GoogleSignInOptions.Builder para configurar o login, especifique GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.

    GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;

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

    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-sucedida, a API Google Sign-In retornará uma instância de GoogleSignInClient.

Conferir se o jogador já fez login

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

Como fazer login silencioso

Você pode chamar silentSignIn() para recuperar a conta do jogador conectado no momento e tentar fazer login sem exibir uma interface do usuário se o login no app foi feito em um dispositivo diferente.

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

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

Como o estado do jogador conectado pode mudar quando a atividade não está em primeiro plano, recomendamos chamar silentSignIn() no método onResume() da atividade.

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 retornará um objeto Task<GoogleSignInAccount> que contém um GoogleSignInAccount se o login silencioso for bem-sucedido.
  2. Gerencie o sucesso ou a falha do login do jogador substituindo OnCompleteListener.

O snippet de código abaixo mostra como o app pode fazer 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 de login silenciosa falhar, você poderá chamar getException() para receber uma 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 precisa 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, seu app precisa iniciar a intent de login. Se for bem-sucedida, a API Google Sign-In exibirá 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 cenários, como a necessidade de atualizar o Google Play Services ou mostrar solicitações de consentimento, em nome do app. O resultado é retornado pelo callback onActivityResult.

Para fazer login de maneira interativa, siga estas etapas:

  1. Chame getSigninIntent() na GoogleSignInClient para conseguir uma intent de login, chame startActivity() e transmita essa intent. O snippet de código abaixo 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 callback onActivityResult(), processe o resultado da intent retornada.

    • Se o resultado do login for bem-sucedido, consiga o objeto GoogleSignInAccount no GoogleSignInResult.
    • Se o resultado do login não for bem-sucedido, você precisará lidar com o erro de login, por exemplo, exibindo uma mensagem de erro em um alerta. O snippet de código abaixo mostra como o app pode processar 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();
    }
  }
}

Como recuperar informações do jogador

O GoogleSignInAccount retornado pela API Google Sign-In não contém informações do jogador. Se o jogo usa informações do jogador, como o nome de exibição e o ID, siga estas etapas para recuperá-las.

  1. Consiga um objeto PlayersClient chamando o método getPlayersClient() e transmitindo o GoogleSignInAccount como um parâmetro.
  2. Use os métodos PlayersClient para carregar de maneira assíncrona o objeto Player que contém as informações de um jogador. Por exemplo, você pode chamar getCurrentPlayer() para carregar o jogador conectado. Se a tarefa retornar um 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 do jogador de forma interativa.
  3. Se a tarefa retornar com êxito o objeto Player, você vai poder chamar os métodos do objeto Player para recuperar detalhes específicos do jogador, por exemplo, getDisplayName() ou getPlayerId().

Como fornecer um botão de login

Para oferecer um botão de Login padrão do Google no jogo, use uma destas abordagens:

Quando os usuários clicam no botão de login, seu jogo precisa iniciar o fluxo de login enviando uma intent de login, conforme descrito em Fazer login interativo.

Este snippet de código mostra como adicionar um botão de login no método onCreate() da 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 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);
  }
}

Mostrando pop-ups do jogo

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

Como desconectar o player

Para sair da conta, use o método signOut() na 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.
        }
      });
}