Esta página foi traduzida pela API Cloud Translation.

Fazer login em jogos 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 for 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 player

A classe GoogleSignInClient é o ponto de entrada principal para recuperar a conta do jogador que fez login e para fazer login no jogador, caso ele não tenha feito isso no seu app no dispositivo.

Para criar um cliente de login, siga estas etapas:

Crie um cliente de login pelo objeto GoogleSignInOptions, conforme mostrado no snippet de código abaixo. No GoogleSignInOptions.Builder, para configurar o login, especifique GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Se você quiser usar um SnapshotsClient, adicione .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) à 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();
```
Atenção :não solicite outros escopos ou dados de perfil do Google, a menos que eles sejam essenciais para seu caso de uso. Qualquer outro escopo faz com que o primeiro login silencioso falhe, exceto para usuários que já fizeram login em um dispositivo diferente.
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

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

É possível chamar silentSignIn() para recuperar a conta do jogador conectado no momento e tentar fazer login sem mostrar uma interface do 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, você vai definir o campo GoogleSignInAccount declarado anteriormente para a conta de login que a tarefa retorna como resultado ou para null, indicando que não há um usuário conectado.

Se a tentativa de login silencioso falhar, você pode 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() no método onResume() da atividade.

Para fazer o login em segundo plano, siga estas etapas:

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.
Processe o sucesso ou a falha do login do jogador substituindo OnCompleteListener.
- Se a tarefa de login tiver sido concluída, receba o objeto GoogleSignInAccount chamando getResult().
- Se o login não for bem-sucedido, você poderá enviar uma intent de login para iniciar um fluxo interativo. Para conferir uma lista de outros listeners de callback que você pode usar, 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 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 de login silencioso falhar, chame getException() para receber 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 precisa iniciar um fluxo de login interativo, conforme descrito na próxima seção.

Para fazer login com a interação do jogador, o app precisa iniciar a intent de login. Se for bem-sucedida, a API Google Sign-In vai mostrar 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 situações como a necessidade de atualizar os serviços do Google Play ou mostrar solicitações de consentimento em nome do app. O resultado é retornado pelo callback onActivityResult.

Para fazer login de forma interativa, siga estas etapas:

Chame getSigninIntent() no GoogleSignInClient para receber uma intent de login e, em seguida, 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);
}

No callback onActivityResult(), processe o resultado da intent retornada.

Se o resultado de login for bem-sucedido, receba o objeto GoogleSignInAccount do GoogleSignInResult.
Se o resultado da autenticação não for bem-sucedido, processe 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();
    }
  }
}

Recuperar informações do jogador

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

Para conseguir um objeto PlayersClient, chame o método getPlayersClient() e transmita o GoogleSignInAccount como parâmetro.
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, é possível chamar getCurrentPlayer() para carregar o jogador conectado no momento. Se a tarefa retornar um ApiException com o 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.
Se a tarefa retornar o objeto Player, será possível chamar os métodos do objeto Player para recuperar detalhes específicos do jogador, por exemplo, getDisplayName() ou getPlayerId().

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

Inclua um com.google.android.gms.common.SignInButton no layout da atividade principal; ou
Crie um botão de login personalizado de acordo com as diretrizes de marca do Login do Google.

Quando os usuários clicarem no botão de login, o jogo vai precisar 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 abaixo 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 de "Bem-vindo de volta" ou "Conquistas desbloqueadas". Para permitir que os serviços relacionados a jogos do Google Play iniciem pop-ups nas visualizações do jogo, chame o método setViewForPopups(). É possível personalizar ainda mais onde o pop-up aparece na tela chamando setGravityForPopups().

Fazer logout do jogador

A desativação é feita 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.
        }
      });
}