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, seu 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.

Como implementar o login do jogador

A classe GoogleSignInClient é o principal ponto de entrada para recuperar a conta do 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:

Crie um cliente de login pelo objeto GoogleSignInOptions, conforme mostrado no snippet de código abaixo. Na GoogleSignInOptions.Builder para configurar seu login, é preciso especificar 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-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 ela já tem as permissões necessárias concedidas usando 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

É 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, 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 de login silencioso falhar, você pode enviar a intent de login para mostrar uma interface do usuário de login, conforme descrito em Como fazer o 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() na 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 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 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 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 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 onActivityResult o retorno de chamada.

Para fazer login de forma interativa, siga estas etapas:

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);
}

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

Consiga um objeto PlayersClient chamando o método getPlayersClient() e transmitindo: GoogleSignInAccount como parâmetro.
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 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 no player de forma 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().

Oferecer um botão de login

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
Projete 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 Fazer 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 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().

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.
        }
      });
}