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

Caso seu jogo use um servidor de back-end, recomendamos usar 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 com segurança sem estar exposto a possíveis adulterações durante a transmissão pelo dispositivo.

Nesse cenário, o jogo solicita que o jogador faça login nos serviços relacionados a jogos do Google Play normalmente. Quando o jogador faz login, o objeto GoogleSignInAccount contém um código de uso único especial chamado 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 ver outras orientações sobre como adicionar login nos seus jogos, consulte Login em jogos Android.

Para ver uma amostra de código detalhada que mostra como usar o Login do Google para autenticar jogadores, consulte a amostra de clientserverskeleton (link em inglês) no GitHub.

Siga estas etapas para acesso off-line:

  1. No Google Play Console: crie uma credencial para seu servidor de jogos. O tipo de cliente OAuth da credencial será "Web".
  2. 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.
  3. 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 esse código para chamar as APIs REST dos serviços relacionados a jogos do Google Play.

Antes de começar

Antes de integrar o Login do Google no seu jogo, você precisa adicionar o jogo ao Google Play Console, conforme descrito em Como configurar os serviços relacionados a jogos do Google Play.

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

Os serviços relacionados a jogos do Google Play não oferecem suporte de back-end para jogos na Web. No entanto, ele oferece 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:

  1. Crie um app da Web associado para o jogo na seção Apps vinculados do Google Play Console. Observe que launch_url não é usado para esse fluxo e pode ser deixado em branco.
  2. Para conseguir as informações de credencial do app, siga estas etapas:
    1. No seu jogo no Google Play Console, clique em Detalhes do jogo.
    2. Role para baixo até a seção Projeto do Console de APIs e clique no link para o projeto.
    3. Na tela APIs e serviços & gt; Credenciais do Console de APIs do Google, faça o download do arquivo client_secret.json do app da Web e salve-o em um local que o servidor possa acessar. Registre o ID de cliente da credencial para referência posterior.
  3. Reinicie o app do lado do servidor para que ele esteja pronto para aceitar solicitações do app cliente do jogo.

Como fazer login no cliente

A classe GoogleSignInClient é o principal ponto de entrada para recuperar a conta do jogador conectado e fazer login dele, caso isso ainda não tenha sido feito no app no dispositivo.

Para criar um cliente de login, siga estas etapas:

  1. Crie um cliente de login usando o objeto GoogleSignInOptions. Em GoogleSignInOptions.Builder para configurar o login, especifique GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
  2. Também é necessário especificar que o jogo exige 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 parâmetro. Você recuperará o código de autenticação posteriormente para os tokens de acesso no servidor de back-end, conforme descrito em Receber o código de autenticação do servidor.
  3. Chame o método GoogleSignIn.getClient() e transmita as opções configuradas anteriormente. Se a chamada for bem-sucedida, a API Login do Google retornará uma instância de GoogleSignInClient.
  4. Depois de receber a instância GoogleSignInClient, faça login do jogador silenciosamente 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 seu jogo possa usar para tokens de acesso no servidor de back-end, chame o método getServerAuthCode() no objeto GoogleSignInAccount que o Login do Google retorna no login do jogador.

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 por um token de acesso no servidor

Envie o código de autenticação ao servidor de back-end para trocar por acesso e atualizar os tokens. Use o token de acesso para chamar a API Google Play Games Services em nome do jogador e, opcionalmente, 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 por tokens de acesso. Ele está usando o app de exemplo clientserverbone:

/**
 * 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 em 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 jogadores do jogo, chame o método signOut() na GoogleSignInClient. Para ver um exemplo de snippet de código, consulte Desconectar o jogador.

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

Amigos

Leia o guia Amigos, que explica a seção Amigos em mais detalhes.

Conquistas

Consulte o guia Conquistas, que explica as conquistas com mais detalhes.

Placares

Consulte o guia Placares, que explica detalhadamente os placares.

  • Quer uma lista de todos os placares no jogo? Faça uma chamada para Leaderboards.list.
  • O jogador terminou um jogo? É possível enviar a pontuação dele para Scores.submit e descobrir se essa é a nova pontuação mais alta.
  • Quer exibir um placar? 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.
  • Você está depurando um jogo? Tente chamar Scores.reset nas APIs Management para redefinir todas as pontuações desse jogador em um placar específico.