Se usó la API de Cloud Translation para traducir esta página.

Acceso del servidor a los Servicios de juego de Google Play

Te recomendamos que autentiques jugadores y pases su identidad al servidor de backend de forma segura. De esta manera, el juego puede recuperar de forma segura la identidad del jugador y otros datos sin exponerse a posibles manipulaciones mientras pasa por el dispositivo.

En este caso, una vez que el jugador acceda de forma correcta, podrás solicitar un código especial de un solo uso (que se denomina código de Auth del servidor) desde el SDK de la versión 2 de los Servicios de juego de Play, que el cliente 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 Google Play Games Services.

Para obtener orientación adicional sobre cómo agregar acceso a tus juegos, consulta Acceso para juegos de Android.

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 APIs de REST de los Servicios de juego de Play.

Antes de comenzar

Primero, deberás agregar tu juego en Google Play Console, como se describe en Configura los Servicios de juego de Google Play, y, luego, integrar Acceso de los Servicios de juego de Play a tu juego.

Crea una app web del servidor

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:

En tu juego, en Google Play Console, ve a Servicios de juego de Play > Configuración y administración > Configuración.
Selecciona Agregar credencial para ir a la página Agregar credencial. Selecciona Servidor de juego como el tipo de credencial y continúa con la sección Autorización.
1. Si el servidor del juego ya tiene un ID de cliente de OAuth, selecciónalo en el menú desplegable. Después de guardar los cambios, continúa con la siguiente sección.
2. Si no tienes un ID de cliente de OAuth existente para el servidor de tu juego, puedes crear uno.
  1. Haz clic en Crear cliente de OAuth y sigue el vínculo Crear ID de cliente de OAuth.
  2. Esto te llevará a la página Crear ID de cliente de OAuth de Google Cloud Platform para el proyecto asociado a Cloud Platform de tu juego.
  3. Llena el formulario de la página y haz clic en Crear. Asegúrate de establecer el tipo Aplicación en Aplicación web.
  4. Regresa a la sección Autorización de la página Agregar credenciales, selecciona el cliente de OAuth recién creado y guarda los cambios.

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, haz lo siguiente:

Llama a requestServerSideAccess desde el cliente.

Asegúrate de usar el ID de cliente de OAuth registrado para el servidor de tu juego, y no el de tu aplicación para Android.
(Opcional) Si el servidor de tu juego requiere acceso sin conexión (acceso de larga duración mediante un token de actualización) a los Servicios de juego de Play, puedes establecer el parámetro forceRefreshToken en true.

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.
    }
});

Envía el token de código de autenticación OAuth a tu servidor de backend para que este pueda intercambiarse, el ID del jugador se verifique con las APIs de REST de los Servicios de juego de Play y se autentique en tu juego.

Envía el código de Auth del 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 Play Games Services en nombre del jugador y, de manera opcional, almacena el token de actualización a fin de adquirir un token de acceso nuevo cuando este venza.

En el siguiente fragmento de código, se muestra cómo implementar el código del servidor en el lenguaje de programación Java a fin de 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;
}

Llama a las APIs de REST desde el servidor

Consulta las APIs de REST para los Servicios de juego de Google Play para 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ó? Prueba realizar una llamada al [Players.get][] con 'me' como ID.

Amigos

Consulta la guía de amigos para obtener más detalles.

Para recuperar la lista de amigos del jugador, llama a Players.list con friends_all como collection.
Para verificar si tienes acceso a una lista de amigos, llama a Players.get con me como playerID y observa el campo profileSettings.friendsListVisibility en la respuesta.

Logros

Consulta la guía de logros para obtener más detalles.

Para obtener una lista de los logros actuales, llama a AchievementDefinitions.list.
Combínala con una llamada a Achievements.list para averiguar cuáles consiguió el jugador.
Llama a Achievements.unlock para desbloquear un logro del jugador.
Llama a Achievements.increment para informar el progreso de un logro y averiguar si el jugador lo desbloqueó.
Si depuras un juego que no alcanzó la producción, puedes llamar a Achievements.reset o Achievements.resetAll desde las APIs de Management para restablecer los logros a su estado original.

Tablas de clasificación

Consulta la guía de tablas de clasificación para obtener más detalles.

¿Quieres obtener una lista de todos los marcadores del juego? Realiza una llamada a Leaderboards.list.
Si un jugador termina de jugar, puedes enviar su puntuación a Scores.submit y averiguar si alcanzó una nueva puntuación alta.
Para mostrar una tabla de clasificación, obtén los datos de Scores.list y muéstraselos al usuario.
Utiliza Scores.listWindow para buscar una clasificación de puntajes cercanos al puntaje alto del usuario.
Para obtener más información acerca del puntaje del jugador en una tabla de posiciones específica (por ejemplo, si el jugador se encuentra entre los jugadores que componen el 12% superior), realiza una llamada a Scores.get.
Si depuras un juego, puedes llamar a Scores.reset desde las APIs de Management a fin de restablecer todas las puntuaciones para ese jugador desde una tabla de clasificación en particular.