Esta página foi traduzida pela API Cloud Translation.

Ativar o acesso do lado do servidor aos serviços relacionados a jogos do Google Play

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.

Se o jogo usar um servidor de back-end, recomendamos que você use o Login do Google para autenticar jogadores e transmitir com segurança a identidade do jogador para o servidor de back-end. Isso também permite que o jogo recupere a identidade do jogador e outros dados de maneira segura, sem estar exposto a possíveis adulterações durante a transmissão pelo dispositivo.

Nesse cenário, o jogo pede que o jogador faça login nos serviços relacionados a jogos do Google Play como de costume. Quando o jogador faz login, o objeto GoogleSignInAccount contém um código especial de uso único (chamado de código de autenticação do servidor) que o cliente transmite para o servidor. Depois, no servidor, troque o código de autenticação por um token OAuth 2.0 que o servidor pode usar para fazer chamadas para a API Google Play Games Services.

Para mais orientações sobre como adicionar login nos seus jogos, consulte Login em jogos do Android.

Para conferir um exemplo de código detalhado que mostra como usar o Login do Google para autenticar jogadores, consulte o exemplo clientserverskeleton no GitHub (link em inglês).

Siga estas etapas para acesso off-line:

No Google Play Console: crie uma credencial para seu servidor de jogos. O tipo de cliente OAuth da credencial será "Web".
No app Android: como parte do login, solicite um código de autenticação para a credencial do seu servidor e transmita-o para ele.
No servidor de jogos: troque o código de autenticação por um token de acesso OAuth usando os serviços de autenticação do Google. Depois, use-o para chamar as APIs REST dos serviços relacionados a jogos do Google Play.

Antes de começar

Antes de integrar o Google Sign-In ao seu jogo, adicione o jogo ao Google Play Console, conforme descrito em Configurar os serviços relacionados a jogos do Google Play.

Criar um aplicativo da Web associado do lado do servidor para seu jogo

Os serviços relacionados a jogos do Google Play não oferecem suporte de back-end para jogos na Web. No entanto, eles oferecem suporte do servidor de back-end para o servidor do seu jogo Android.

Se você quiser usar as APIs REST para serviços do Google Play Games no seu app do lado do servidor, siga estas etapas:

Crie um app da Web associado ao jogo na seção Apps vinculados do Google Play Console. O launch_url não é usado nesse fluxo e pode ficar em branco.
Para acessar as informações de credencial do seu app, siga estas etapas:
1. No seu jogo no Google Play Console, clique em Detalhes do jogo.
2. Role a tela para baixo até a seção Projeto do Console de APIs e clique no link para o projeto do Console de APIs.
3. Na tela APIs e serviços > Credenciais do Console de APIs do Google, baixe o arquivo client_secret.json para seu app da Web e salve em um local acessível ao servidor. Registre o ID do cliente da credencial para referência futura.
Reinicie o app do lado do servidor para que ele esteja pronto para aceitar solicitações do app cliente do jogo.

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:

Crie um cliente de login usando o objeto GoogleSignInOptions. Na GoogleSignInOptions.Builder para configurar o login, especifique GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
Você também precisa especificar que o jogo requer um código de autenticação para o servidor de back-end chamando o método GoogleSignInOptions.Builder.requestServerAuthCode() com o ID do cliente do servidor como o parâmetro. Você vai recuperar o código de autenticação mais tarde para tokens de acesso no servidor de back-end, conforme descrito em Receber o código de autenticação do servidor.
Chame o método GoogleSignIn.getClient() e transmita as opções configuradas anteriormente. Se a chamada for bem-sucedida, a API Google Sign-In vai retornar uma instância de GoogleSignInClient.
Depois de receber a instância GoogleSignInClient, faça o login silencioso do jogador no onResume() da atividade, conforme descrito em Fazer login silencioso.

Veja um exemplo:

private static final int RC_SIGN_IN = 9001;
private GoogleSignInClient mGoogleSignInClient;

private void startSignInForAuthCode() {

  // Client ID for your backend server.
  String webClientId = getString(R.string.webclient_id);

  GoogleSignInOptions signInOption = new
      GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
      .requestServerAuthCode(webClientId)
      .build();

  GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOption);
  Intent intent = signInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);
}

Receber o código de autenticação do servidor

Para recuperar um código de autenticação do servidor que o jogo possa usar para tokens de acesso no servidor de back-end, chame o método getServerAuthCode() no objeto GoogleSignInAccount que o Google Sign-In retorna quando o jogador faz login.

Veja um exemplo:

// Auth code to send to backend server.
private String mServerAuthCode;

@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()) {
      mServerAuthCode = result.getSignInAccount().getServerAuthCode();
    } 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();
    }
  }
}

Trocar o código de autenticação do servidor por um token de acesso no servidor

Envie o código de autenticação do servidor ao servidor de back-end para trocar por tokens de acesso e atualização. Use o token de acesso para chamar a API Play Games Services em nome do jogador e, como opção, armazene o token de atualização para receber um novo token de acesso quando ele expirar.

O snippet de código a seguir mostra como implementar o código no lado do servidor na linguagem de programação Java para trocar o código de autenticação do servidor por tokens de acesso. Ele usa o app de exemplo clientserverskeleton:

/**
 * Exchanges the authcode for an access token credential.  The credential
 * is the associated with the given player.
 *
 * @param authCode - the non-null authcode passed from the client.
 * @param player   - the player object which the given authcode is
 *                 associated with.
 * @return the HTTP response code indicating the outcome of the exchange.
 */
private int exchangeAuthCode(String authCode, Player player) {
try {

    // The client_secret.json file is downloaded from the Google API
    // console.  This is used to identify your web application.  The
    // contents of this file should not be shared.
    //
    File secretFile = new File("client_secret.json");

    // If we don't have the file, we can't access any APIs, so return
    // an error.
    if (!secretFile.exists()) {
        log("Secret file : " + secretFile
                .getAbsolutePath() + "  does not exist!");
        return HttpServletResponse.SC_FORBIDDEN;
    }

    GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(
            JacksonFactory.getDefaultInstance(), new
            FileReader(secretFile));

    // Extract the application id of the game from the client id.
    String applicationId = extractApplicationId(clientSecrets
            .getDetails().getClientId());

    GoogleTokenResponse tokenResponse =
            new GoogleAuthorizationCodeTokenRequest(
            HTTPTransport,
            JacksonFactory.getDefaultInstance(),
            "https://oauth2.googleapis.com/token",
            clientSecrets.getDetails().getClientId(),
            clientSecrets.getDetails().getClientSecret(),
            authCode,
            "")
            .execute();

    log("hasRefresh == " + (tokenResponse.getRefreshToken() != null));
    log("Exchanging authCode: " + authCode + " for token");
    Credential credential = new Credential
            .Builder(BearerToken.authorizationHeaderAccessMethod())
            .setJsonFactory(JacksonFactory.getDefaultInstance())
            .setTransport(HTTPTransport)
            .setTokenServerEncodedUrl("https://www.googleapis.com/oauth2/v4/token")
            .setClientAuthentication(new HttpExecuteInterceptor() {
                @Override
                public void intercept(HttpRequest request)
                        throws IOException {
                        }
            })
            .build()
            .setFromTokenResponse(tokenResponse);

    player.setCredential(credential);

    // Now that we have a credential, we can access the Games API.
    PlayGamesAPI api = new PlayGamesAPI(player, applicationId,
            HTTPTransport, JacksonFactory.getDefaultInstance());

    // Call the verify method, which checks that the access token has
    // access to the Games API, and that the player id used by the
    // client matches the playerId associated with the accessToken.
    boolean ok = api.verifyPlayer();

    // Call a Games API on the server.
    if (ok) {
        ok = api.updatePlayerInfo();
        if (ok) {
            // persist the player.
            savePlayer(api.getPlayer());
        }
    }

    return ok ? HttpServletResponse.SC_OK :
            HttpServletResponse.SC_INTERNAL_SERVER_ERROR;

  } catch (IOException e) {
    e.printStackTrace();
  }
  return HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
}

Para saber mais sobre como acessar as APIs do Google de um servidor de back-end em nome de um jogador conectado, consulte Como ativar o acesso do lado do servidor.

Processar a saída do jogador

Para desconectar os jogadores do seu jogo, chame o método signOut() no GoogleSignInClient. Para ver um exemplo de snippet de código, consulte Fazer logout do jogador.

Chamar APIs REST do servidor

Consulte APIs REST para serviços do Google Play Games para uma descrição completa das chamadas de API disponíveis.

Veja abaixo alguns exemplos de chamadas de APIs REST que podem ser úteis:

Jogador

Quer receber o ID do jogador conectado e os dados do perfil? Chame Players.get com 'me' como ID.

Amigos

Consulte o guia Amigos, que explica esse recurso em mais detalhes.

Quer recuperar a lista de amigos do jogador? Chame Players.list com 'friends_all' como collection.
Verifique se você tem acesso à lista de amigos. Chame Players.get para me e confira o campo profileSettings.friendsListVisibility na resposta.

Conquistas

Consulte o guia de Conquistas, que explica esse recurso com mais detalhes.

Deseja obter uma lista das conquistas atuais? Você pode fazer uma chamada para AchievementDefinitions.list.
Combine isso com uma chamada para Achievements.list para descobrir quais o jogador desbloqueou.
O jogador recebeu uma conquista? Use Achievements.unlock para desbloquear.
O jogador fez progresso em direção a uma conquista parcial? Use Achievements.increment para informar o progresso e descobrir se o jogador desbloqueou a conquista.
Está depurando um jogo que ainda não está em produção? Tente chamar Achievements.reset ou Achievements.resetAll nas APIs de gerenciamento para redefinir as conquistas ao estado original.

Placares

Consulte o guia Placares, que explica esse recurso com mais detalhes.

Quer uma lista de todos os placares no jogo? Faça uma chamada para Leaderboards.list.
O jogador acabou de jogar? Você pode enviar a pontuação para Scores.submit e descobrir se é uma nova pontuação máxima.
Deseja exibir um placar de líderes? Acesse os dados de Scores.list e mostre-os ao usuário.
Use Scores.listWindow para encontrar uma variedade de pontuações próximas à pontuação mais alta do usuário.
Para ver mais informações sobre a pontuação do jogador em um placar específico (por exemplo, se o jogador está entre os 12% dos melhores jogadores), chame Scores.get.
Está depurando um jogo? Chame Scores.reset nas APIs de gerenciamento para redefinir todas as pontuações desse jogador em um placar específico.