Fazer login em jogos Android

Após a descontinuação da API Login do Google, vamos remover o SDK dos serviços relacionados a jogos v1 em 2026. A partir de fevereiro de 2025, não será mais possível publicar no Google Play títulos que foram integrados ao SDK dos serviços relacionados a jogos do Google Play V1. Recomendamos que você use o SDK do Google Play Games v2.
Embora os títulos atuais com as integrações anteriores da v1 de jogos continuem funcionando por alguns anos, recomendamos que você migre para a v2 a partir de junho de 2025.
Este guia é para usar o SDK dos serviços relacionados a jogos do Google Play v1. Para informações sobre a versão mais recente do SDK, consulte a documentação da v2.

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 poderá 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.

Implementar o login do jogador

A classe GoogleSignInClient é o principal ponto de entrada para recuperar a conta do jogador conectado no momento e fazer login se ele ainda não tiver feito isso 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. No 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 a seguir:

    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 configuradas nas etapas anteriores. Se a chamada for bem-sucedida, a API Google Sign-In vai retornar uma instância de GoogleSignInClient.

Verificar se o jogador já fez login

Você pode verificar se uma conta já está conectada no dispositivo atual usando GoogleSignIn.getLastSignedInAccount() e se ela já tem as permissões necessárias 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.

Fazer um login silencioso

Você pode chamar silentSignIn() para recuperar a conta do jogador conectado no momento e tentar fazer login sem mostrar uma interface de usuário se ele tiver feito login no seu app em outro dispositivo.

O método silentSignIn() retorna um Task<GoogleSignInAccount>. Quando a tarefa for concluída, defina o campo GoogleSignInAccount declarado anteriormente como 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 silencioso falhar, você poderá enviar a intent de login para mostrar uma interface do usuário de login, conforme descrito em Fazer um login interativo.

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

Para fazer login silenciosamente, siga estas etapas:

  1. Chame o método silentSignIn() no GoogleSignInClient para iniciar o fluxo de login silencioso. Essa chamada retorna um objeto Task<GoogleSignInAccount> que contém um GoogleSignInAccount se o login silencioso for bem-sucedido.
  2. Substitua OnCompleteListener para processar o sucesso ou a falha do login do jogador.
    • Se a tarefa de login for bem-sucedida, chame getResult() para receber o objeto GoogleSignInAccount.
    • Se o login não tiver sido bem-sucedido, envie uma intent de login para iniciar um fluxo de login interativo. Para conferir uma lista de listeners de callback adicionais que podem ser usados, consulte o guia para desenvolvedores da API Tasks e a referência da API Task.

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 silencioso falhar, chame getException() para receber um ApiException com o código de status detalhado. Um código de status CommonStatusCodes.SIGN_IN_REQUIRED indica que o player 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.

Fazer login interativo

Para fazer login com a interação do jogador, seu app precisa iniciar a intent de login. Se for bem-sucedido, a API Google Sign-In vai mostrar uma interface do usuário que pede ao jogador para inserir as credenciais e 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 seu app. O resultado é retornado pelo callback onActivityResult.

Para fazer login de forma interativa, siga estas etapas:

  1. Chame getSigninIntent() no GoogleSignInClient para receber uma intent de login. Depois, chame startActivity() e transmita 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 callback onActivityResult(), processe o resultado do intent retornado.

    • Se o resultado do login for bem-sucedido, receba o objeto GoogleSignInAccount do GoogleSignInResult.
    • Se o resultado do login não for bem-sucedido, processe o erro de login. Por exemplo, mostre 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();
    }
  }
}

Recuperar informações do jogador

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

  1. Para conseguir um objeto PlayersClient, chame o método getPlayersClient() e transmita o GoogleSignInAccount como um parâmetro.
  2. Use os métodos PlayersClient para carregar de forma 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 no momento. Se a tarefa retornar um ApiException com código de status SIGN_IN_REQUIRED, isso indica que o jogador precisa ser autenticado novamente. Para fazer isso, chame GoogleSignInClient.getSignInIntent() para fazer login do jogador de maneira interativa.
  3. Se a tarefa retornar o objeto Player, chame os métodos do objeto Player para recuperar detalhes específicos do jogador (por exemplo, getDisplayName() ou getPlayerId().

Ofereça um botão de login

Para fornecer um botão de login do Google padrão no seu jogo, use uma destas abordagens:

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 Realizar um login interativo.

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

É possível mostrar visualizações pop-up no jogo usando a classe GamesClient. Por exemplo, o jogo pode mostrar 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 seu jogo, chame o método setViewForPopups(). Você pode personalizar ainda mais onde o pop-up aparece na tela chamando setGravityForPopups().

Desconectar o jogador

Para sair, chame 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.
        }
      });
}