Si tu juego usa un servidor de backend, te recomendamos que uses el Acceso con Google para autenticar a los jugadores y pasar su identidad de forma segura al servidor de backend. Esto también permite que el juego recupere de forma segura la identidad del jugador y otros datos sin exponerse a posibles manipulaciones mientras pasa por el dispositivo.
En este caso, el juego solicita al jugador que acceda a los servicios de juego de Google Play como de costumbre. Cuando el jugador accede correctamente, el objeto GoogleSignInAccount
contiene un código especial de un solo uso (llamado código de Auth del servidor) que el cliente le pasa al servidor. Luego, en el servidor, intercambia el código de Auth del servidor por un token de OAuth 2.0 que el servidor pueda usar para realizar llamadas a la API de los Servicios de juego de Google Play.
Para obtener orientación adicional sobre cómo agregar acceso a tus juegos, consulta Acceso en juegos para Android.
Para ver un ejemplo de código detallado que muestre cómo usar el Acceso con Google para autenticar jugadores, consulta el ejemplo de clientserverskeleton
en GitHub.
Sigue estos pasos para acceder sin conexión:
- En Google Play Console: Crea una credencial para tu servidor de juegos. El tipo de cliente de OAuth de la credencial será “web”.
- En la app para Android: Como parte del acceso, solicita un código de Auth del servidor para la credencial de este y pásalo al servidor.
- En el servidor de tu juego: Intercambia el código de Auth del servidor por un token de acceso de OAuth mediante los servicios de autenticación de Google y, luego, úsalo para llamar a las API de REST de los Servicios de juego de Play.
Antes de comenzar
Antes de poder integrar el Acceso con Google en tu juego, primero deberás agregarlo en Google Play Console, como se describe en Cómo configurar los Servicios de juego de Google Play.
Crea una aplicación web asociada del servidor para tu juego
Los Servicios de juego de Google Play no ofrecen compatibilidad con backend para juegos de navegador. Sin embargo, sí es compatible con el servidor de backend para el servidor de tu juego de Android.
Si deseas usar las APIs de REST para los Servicios de juego de Google Play en tu app del servidor, sigue estos pasos:
- Crea una app web asociada para tu juego en la sección Apps vinculadas de Google Play Console. Ten en cuenta que
launch_url
no se usa para este flujo y se puede dejar en blanco. - Para obtener la información de las credenciales de tu app, sigue estos pasos:
- En Google Play Console, haz clic en Detalles del juego.
- Desplázate hasta la sección Proyecto de la Consola de API y haz clic en el vínculo al proyecto de la Consola de API.
- En la pantalla API y servicios & gt; Credenciales de la Consola de API de Google, descarga el archivo
client_secret.json
de tu aplicación web y guárdalo en una ubicación a la que tu servidor pueda acceder. Registra el ID de cliente de la credencial para referencia futura.
- Reinicia la app del servidor para que pueda aceptar solicitudes de la app cliente del juego.
Realizar el acceso en el cliente
La clase GoogleSignInClient
es el punto de entrada principal a fin de recuperar la cuenta del jugador actualmente conectado y para acceder si aún no lo ha hecho en tu app en el dispositivo.
Para crear un cliente de acceso, sigue estos pasos:
- Crea un cliente de acceso a través del objeto
GoogleSignInOptions
. EnGoogleSignInOptions.Builder
, para configurar tu acceso, debes especificarGoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
. - También debes especificar que el juego requiere un código de Auth para tu servidor de backend mediante una llamada al método
GoogleSignInOptions.Builder.requestServerAuthCode()
con el ID de cliente del servidor como parámetro. Recuperas el código de Auth más tarde para los tokens de acceso en tu servidor de backend, como se describe en Obtén el código de Auth del servidor. - Llama al método
GoogleSignIn.getClient()
y pasa las opciones que configuraste antes. Si la llamada se ejecuta correctamente, la API de Acceso con Google muestra una instancia deGoogleSignInClient
. - Una vez que hayas obtenido la instancia
GoogleSignInClient
, deberás hacer que el jugador acceda sin emitir un sonido desde el objetoonResume()
de la actividad, como se describe en Cómo realizar un acceso silencioso.
Por ejemplo:
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); }
Obtén el código de Auth del servidor
A fin de recuperar un código de Auth del servidor que tu juego puede usar para tokens de acceso en tu servidor de backend, llama al método getServerAuthCode()
en el objeto GoogleSignInAccount
que muestra el Acceso con Google cuando el jugador acceda de forma correcta.
Por ejemplo:
// 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(); } } }
Intercambia el código de Auth del servidor por un token de acceso en el servidor
Envía el código de Auth del servidor a tu servidor de backend para intercambiar tokens de acceso y actualización. Usa el token de acceso para llamar a la API de Servicios de juego de Google Play en nombre del jugador y, de manera opcional, almacena el token de actualización a fin de adquirir un nuevo token de acceso cuando este venza.
En el siguiente fragmento de código, se muestra cómo podrías implementar el código del servidor en el lenguaje de programación Java para intercambiar el código de Auth del servidor por tokens de acceso. Usa la app de ejemplo 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 obtener más información sobre cómo acceder a las API de Google desde un servidor de backend en nombre de un jugador conectado, consulta Habilita el acceso al servidor.
Controla el cierre de sesión del jugador
Para cerrar la sesión de los jugadores, llama al método signOut()
en el GoogleSignInClient
. Para ver un ejemplo de fragmento de código, consulta Cómo salir del reproductor.
Llama a las APIs de REST desde el servidor
Consulta las APIs de REST para los Servicios de juego de Google Play a fin de obtener una descripción completa de las llamadas a la API disponibles.
Estos son algunos ejemplos de llamadas a la API de REST que pueden resultarte útiles:
Jugador
- ¿Deseas obtener el ID y los datos de perfil del jugador que accedió? Llama a Players.get con
'me'
como ID.
Amigos
Asegúrate de revisar la guía de Amigos, donde se explican los amigos en más detalle.
- ¿Deseas recuperar la lista de amigos del jugador? Llama a Players.list con
'friends_all'
comocollection
. - ¿Deseas verificar si tienes acceso a la lista de amigos? Llama a Players.get para
me
y observa el campoprofileSettings.friendsListVisibility
en la respuesta.
Logros
Asegúrate de revisar la guía de Logros, donde se explican los logros en más detalle.
- ¿Deseas obtener una lista de los logros actuales? Puedes realizar una llamada a AchievementDefinitions.list.
- Combínala con una llamada a Achievements.list para averiguar cuáles consiguió el jugador.
- ¿El jugador obtuvo un logro? Usa Achievements.unlock para desbloquearla.
- ¿El jugador progresó hacia un logro parcial? Usa Achievements.increment para informar el progreso (y averiguar si el jugador lo consiguió).
- ¿Estás depurando un juego que aún no está en producción? Llama a Achievements.reset o Achievements.resetAll desde las API de Management para restablecer los logros a su estado original.
Tablas de clasificación
Asegúrate de revisar la guía de tablas de clasificación, que explica las tablas de clasificación con más detalle.
- ¿Quieres obtener una lista de todos los marcadores del juego? Realiza una llamada a Leaderboards.list.
- ¿El jugador terminó con un juego? Puedes enviar su puntuación a Scores.submit y averiguar si se trata de una nueva puntuación alta.
- ¿Quieres mostrar una tabla de clasificación? Obtén los datos de Scores.list y muéstraselos al usuario.
- Usa Scores.listWindow para buscar una clasificación de puntuaciones cercanas a la puntuación alta del usuario.
- Para obtener más información acerca del puntaje del jugador en una tabla de clasificación específica (por ejemplo, si el jugador se encuentra entre los jugadores que componen el 12% superior), realiza una llamada a Scores.get.
- ¿Estás depurando un juego? Intenta llamar a Scores.reset desde las API de Management a fin de restablecer todas las puntuaciones para ese jugador desde una tabla de clasificación en particular.