Caso seu jogo use um servidor de back-end, recomendamos o uso de 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 seu jogo para recuperar com segurança a identidade do jogador e outros dados sem exposição a possíveis adulterações durante a passagem pelo dispositivo.
Nesse cenário, o jogo solicita que o jogador faça login nos serviços relacionados a jogos do Google Play como de costume. Quando o
o jogador fizer login com sucesso, o objeto GoogleSignInAccount conterá um código especial de uso único.
(chamado de código de autenticação do servidor) 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.
Para ver um exemplo de código detalhado mostrando como usar o Login do Google para autenticar jogadores, consulte a
Exemplo clientserverskeleton (em inglês) no GitHub.
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
Antes de integrar o Login do Google ao seu jogo, adicione o jogo à Google Play Console, conforme descrito em Como configurar os serviços relacionados a jogos do Google Play.
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:
- Crie um app da Web associado para o jogo na seção Apps vinculados do
o Google Play Console. Observe que
o
launch_urlnão é usado para esse fluxo e pode ser deixado em branco. - Para acessar as informações das credenciais do seu app, siga estas etapas:
- No seu jogo no Google Play Console, clique em Detalhes do jogo.
- Role para baixo até a seção Projeto do console de API e clique no link ao projeto do Console de APIs.
- Na página APIs e Serviços > Tela de credenciais na API do Google
Console, faça o download do arquivo
client_secret.jsonpara seu app da Web e salvá-lo em um local que possa ser acessado pelo servidor. Gravar o cliente ID da credencial para referência futura.
- Reinicie o app do lado do servidor para que ele esteja pronto para aceitar solicitações app cliente do jogo.
Como fazer login no cliente
A classe GoogleSignInClient é o principal ponto de entrada para recuperar a conta do atual
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 usando o objeto
GoogleSignInOptions. NaGoogleSignInOptions.Builderpara configurar o login, é necessário especificarGoogleSignInOptions.DEFAULT_GAMES_SIGN_IN - Também é necessário especificar que o jogo exige uma autenticação
para seu servidor de back-end chamando o método
Método
GoogleSignInOptions.Builder.requestServerAuthCode()com o ID do cliente do servidor como o . Você vai recuperar o código de autenticação mais tarde para os 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 ligação for bem-sucedido, a API de Login do Google retornará uma instância deGoogleSignInClient. - Quando você tiver a instância
GoogleSignInClient, faça o login do jogador. silenciosamente noonResume()da atividade, conforme descrito em Como 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 que o jogo possa usar para tokens de acesso no servidor de back-end, faça o seguinte:
chamar getServerAuthCode()
em GoogleSignInAccount
que o Login do Google retorna após o 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 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;
}
Para saber como acessar as APIs do Google por um servidor de back-end em nome de um jogador conectado, consulte Ativar o acesso do lado do servidor.
Processar a saída do jogador
Para desconectar os jogadores do jogo, chame o método signOut() no GoogleSignInClient. Para um
exemplo de snippet de código, consulte
Desconectar o jogador
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.