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, uma vez que o jogador fizer login com sucesso, você pode solicitar um código especial de uso único (chamado de código de autenticação do servidor) do SDK dos serviços relacionados a jogos do Google Play v2, que o cliente transmite ao servidor. Depois, no servidor, troque o código de autenticação do servidor para um token OAuth 2.0 que o servidor pode usar para fazer chamadas para o API Google Play Games Services.
Para mais orientações sobre como adicionar o login aos seus jogos, consulte Faça login em jogos Android.
Siga estas etapas para acesso off-line:
- No Google Play Console: crie uma credencial para seu servidor de jogos. A 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 acesso OAuth token usando os serviços de autenticação do Google e, em seguida, use-o para chamar a APIs REST dos serviços relacionados a jogos do Google Play
Antes de começar
Primeiro, você precisa adicionar seu jogo na Google Play Console, conforme descrito em Configure os serviços relacionados a jogos do Google Play e integre o Login dos serviços relacionados a jogos do Google Play ao seu jogo.
Criar um aplicativo da Web do lado do servidor associado 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, 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.
- 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.
- Você pode criar um ID do cliente OAuth se ainda não tiver um.
- Clique em Criar um cliente OAuth e siga o link Criar ID do cliente OAuth.
- Isso leva você à página Criar ID do cliente OAuth do Google Cloud Platform do projeto do Cloud Platform associado ao jogo.
- Preencha o formulário da página e clique em "Criar". Defina o tipo como "aplicativo da Web".
- 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
requestServerSideAccessdo 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.
Trocar o código de autenticação do servidor por um token de acesso no servidor
Enviar o código de autenticação ao servidor de back-end para trocar por acesso e atualizar tokens. Use o token de acesso para chamar a API dos serviços relacionados a jogos do Google Play em nome do jogador e, opcionalmente, armazenar o token de atualização para adquirir um novo token de acesso quando ele expirar.
O snippet de código a seguir mostra como implementar o código do lado do servidor na classe de programação para trocar o código de autenticação do servidor por tokens de acesso. É usando o método 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;
}
Chamar APIs REST do servidor
Consulte APIs REST para serviços relacionados a jogos do Google Play 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 o ID.
Amigos
Consulte o guia Amigos, que explica tudo sobre amigos em mais detalhes.
- Quer recuperar a lista de amigos do jogador? Chame Players.list com
'friends_all'comocollection. - Verifique se você tem acesso à lista de amigos. Chame Players.get para
mee confira o campoprofileSettings.friendsListVisibilityna resposta.
Conquistas
Consulte o guia Conquistas, que explica as conquistas. com mais detalhes.
- Quer receber 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 ganhou uma conquista? Use Achievements.unlock para desbloqueá-la.
- O jogador fez progresso em direção a uma conquista parcial? Use Achievements.increment para informe o progresso e descubra se o jogador a desbloqueou.
- Você está depurando um jogo que ainda não está em produção? Ligar Achievements.reset ou Achievements.resetAll nas APIs de gerenciamento para redefinir as conquistas ao estado original.
Placares
Consulte o guia Placares, que explica os placares em mais detalhes.
- Quer uma lista de todos os placares no jogo? Faça uma chamada para Leaderboards.list.
- O jogador acabou de jogar? Envie a pontuação para Scores.submit e descubra se essa é uma nova pontuação alta.
- Quer exibir um quadro de liderança? Obtenha 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 obter mais informações sobre a pontuação do jogador em um quadro de liderança específico (por exemplo, se o jogador está entre os 12% melhores de todos os jogadores), chame Scores.get.
- Você está depurando um jogo? Tente chamar Scores.reset no menu "Gerenciamento" APIs para redefinir todas as pontuações desse jogador em um placar específico.