Esta página foi traduzida pela API Cloud Translation.

Acesso no lado do servidor aos serviços relacionados a jogos do Google Play

Recomendamos que você autentique os jogadores e transmita com segurança a identidade do jogador para o servidor de back-end. Isso 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, quando o jogador faz o login, é possível solicitar um código de uso único especial (chamado de código de autenticação do servidor) ao SDK dos serviços relacionados a jogos do Google Play v2, 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 ver outras orientações sobre como adicionar login nos seus jogos, consulte Login para jogos no Android.

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

Primeiro, adicione seu jogo ao Google Play Console, conforme descrito em Configurar os serviços relacionados a jogos do Google Play. Depois, faça a integração do Login nos serviços relacionados a jogos do Google Play ao seu jogo.

Criar um app da Web do lado do servidor

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:

No seu jogo no Google Play Console, acesse Serviços relacionados a jogos do Google Play > Configuração e gerenciamento > Configuração.
Selecione Adicionar credencial para acessar a página Adicionar credencial. Selecione Servidor de jogos como o tipo de credencial e siga para a seção Autorização.
1. Se o servidor de jogos já tiver um ID do cliente OAuth, selecione-o no menu suspenso. Depois de salvar as mudanças, siga para a próxima seção.
2. Você pode criar um ID do cliente OAuth se ainda não tiver um.
  1. Clique em Criar um cliente OAuth e siga o link Criar ID do cliente OAuth.
  2. Isso leva você à página Criar ID do cliente OAuth do Google Cloud Platform do projeto do Cloud Platform associado ao jogo.
  3. Preencha o formulário da página e clique em "Criar". Defina o tipo como "aplicativo da Web".
  4. Volte para a seção "Autorização" da página "Adicionar credencial". Selecione o cliente OAuth recém-criado e salve as mudanças.

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 requestServerSideAccess do cliente.

Use o ID do cliente OAuth registrado para o servidor do jogo, e não o ID do cliente OAuth do app Android.
Opcional: caso o servidor do jogo exija acesso off-line, isto é, acesso de longa duração usando um token de atualização para os serviços relacionados a jogos do Google Play, defina o parâmetro como verdadeiro.

GamesSignInClient gamesSignInClient = PlayGames.getGamesSignInClient(this);
gamesSignInClient
  .requestServerSideAccess(OAUTH_2_WEB_CLIENT_ID, /* forceRefreshToken= */ false)
  .addOnCompleteListener( task -> {
    if (task.isSuccessful()) {
      String serverAuthToken = task.getResult();
      // Send authentication code to the backend game server to be
      // exchanged for an access token and used to verify the player
      // via the Play Games Services REST APIs.
    } else {
      // Failed to retrieve authentication code.
    }
});

Envie o token do código de autenticação OAuth ao servidor de back-end para que seja possível trocá-lo. O ID do jogador nas APIs REST dos serviços relacionados a jogos do Google Play será verificado e autenticado no jogo.

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

Envie o código de autenticação do servidor ao servidor de back-end para trocar por acesso e atualizar tokens. 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;
}

Chamar APIs REST do servidor

Consulte APIs REST para serviços do Google Play Games para ver 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 para mais detalhes.

Para recuperar a lista de amigos do jogador, chame Players.list com friends_all como collection.
Para verificar se você tem acesso a uma lista de amigos, chame Players.get com me como o playerID e visualize o campo profileSettings.friendsListVisibility na resposta.

Conquistas

Consulte o guia de Conquistas para ver mais detalhes.

Para acessar uma lista das conquistas atuais, chame AchievementDefinitions.list.
Combine com uma chamada para Achievements.list para descobrir quais o jogador desbloqueou.
Chame Conquistas.unlock para desbloquear uma conquista do jogador.
Chame Conquistas.increment para informar o progresso em uma conquista e descobrir se o jogador a desbloqueou.
Se você estiver depurando um jogo que não foi para o estágio de produção, vai poder chamar Achievements.reset ou Achievements.resetAll nas APIs de gerenciamento para redefinir as conquistas ao estado original.

Placares

Consulte o guia Placares para mais detalhes.

Quer uma lista de todos os placares no jogo? Faça uma chamada para Leaderboards.list.
Se um jogador tiver terminado um jogo, envie a pontuação dele para Scores.submit e descubra se ele está entre as maiores pontuações do jogo.
Para exibir um placar, acesse os dados de Scores.list e mostre-os ao usuário.
Use Scores.listWindow para descobrir 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.
Se você estiver depurando um jogo, vai poder chamar Scores.reset nas APIs de gerenciamento para redefinir todas as pontuações desse jogador em um placar específico.