Cómo habilitar el acceso del servidor a los Servicios de juego de Google Play

Si tu juego utiliza un servidor de backend, te recomendamos que uses Acceso con Google para autenticar a los jugadores la identidad del jugador de forma segura al servidor de backend. Esto también permite para recuperar de forma segura la identidad del jugador y otros datos queden expuestos a posibles manipulaciones mientras pasan por el dispositivo.

En este caso, el juego le 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 autenticación del servidor) que el cliente pasa al servidor. Luego, en el servidor, intercambia el código de Auth del servidor para un token de OAuth 2.0 que el servidor puede usar para hacer llamadas al API de Servicios de juego de Google Play.

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

Para ver una muestra de código detallada que muestra cómo usar Acceso con Google para autenticar jugadores, consulta el Ejemplo de clientserverskeleton en GitHub.

Sigue estos pasos para acceder sin conexión:

  1. En Google Play Console: Crea una credencial para tu servidor de juegos. El El tipo de cliente de OAuth de la credencial será "Web".
  2. 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.
  3. En tu servidor de juegos: Intercambia el código de Auth del servidor por un acceso OAuth. token usando los servicios de autenticación de Google y, luego, úsalo para llamar al APIs de REST de los Servicios de juego de Play

Antes de comenzar

Para poder integrar el Acceso con Google en tu juego, primero deberás agregarlo en la Google Play Console, como se describe en Cómo configurar los Servicios de juego de Google Play.

Crea una aplicación web del servidor asociada 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:

  1. 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 puede dejarse en blanco.
  2. Para obtener la información de credenciales de tu app, sigue estos pasos:
    1. En tu juego de Google Play Console, haz clic en Detalles del juego.
    2. Desplázate hasta la sección Proyecto Consola de APIs y haz clic en el vínculo. al proyecto de la Consola de APIs.
    3. Desde la Herramienta de APIs y Servicios > Pantalla Credentials en la API de Google Console, descarga el archivo client_secret.json para tu app web y guárdala en una ubicación a la que tu servidor pueda acceder. Grabar el cliente Es el ID de la credencial para referencia futura.
  3. Reinicia la app del servidor para que esté lista para aceptar solicitudes de tu la app cliente del juego.

Realiza el acceso en el cliente

La clase GoogleSignInClient es el punto de entrada principal para recuperar la cuenta de la biblioteca actual un jugador que accedió a su cuenta y que acceda a él si aún no lo ha hecho en tu app en la dispositivo.

Para crear un cliente de acceso, sigue estos pasos:

  1. Crea un cliente de acceso a través del objeto GoogleSignInOptions. En la GoogleSignInOptions.Builder para configurar tu acceso, debes especificar GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
  2. También debes especificar que el juego requiere una autenticación código para tu servidor de backend llamando al Método GoogleSignInOptions.Builder.requestServerAuthCode() con el ID de cliente del servidor como valor parámetro. Más adelante, recuperarás el código de Auth para los tokens de acceso en tu servidor de backend, como se describe. en Obtén el código de Auth del servidor.
  3. Llama al método GoogleSignIn.getClient() y pasa las opciones que configuraste anteriormente. Si la llamada se realiza de forma correcta, la API de Acceso con Google muestra una instancia de GoogleSignInClient.
  4. Una vez que obtengas la instancia de GoogleSignInClient, debes proceder con el acceso del jugador silenciosamente desde el onResume() 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

Para recuperar un código de Auth del servidor que tu juego pueda usar para tokens de acceso en tu servidor de backend, haz lo siguiente: llamar a getServerAuthCode() en el método GoogleSignInAccount que el Acceso con Google muestra cuando un jugador accede correctamente.

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 Google Play Games Services en nombre del jugador y, de forma opcional, almacenar el token de actualización para adquirir un nuevo token de acceso cuando caduque.

En el siguiente fragmento de código, se muestra cómo implementar el código del servidor en el lenguaje de programación para intercambiar el código de Auth del servidor por tokens de acceso. Sí con el 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 APIs de Google desde un servidor de backend en nombre de un jugador que accedió a su cuenta, consulta Cómo habilitar el acceso al servidor.

Controla el cierre de sesión de los jugadores

Para hacer que los jugadores salgan de tu juego, llama al método signOut() en GoogleSignInClient. Para un ejemplo del fragmento de código, consulta Cierra la sesión del jugador.

Llama a las APIs de REST desde el servidor

Consulta las APIs de REST para los Servicios de juego de Google Play para obtener encontrarás 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 el ID.

Amigos

Asegúrate de consultar la guía de Amigos, donde se explica la función de forma más detallada.

Logros

Asegúrate de consultar la guía Logros, en la que se explican los logros. en más detalle.

  • ¿Quieres obtener una lista de tus logros actuales? Puedes hacer una llamada a AchievementDefinitions.list.
  • Combínala con una llamada a Achievements.list para averiguar cuáles consiguió el jugador.
  • ¿Ganó el jugador un logro? Usa Achievements.unlock para desbloquearla.
  • ¿Avanzó el jugador hacia un logro parcial? Usa Achievements.increment para: informar el progreso (y averiguar si el jugador lo desbloqueó).
  • ¿Estás depurando un juego que aún no está en producción? Prueba las llamadas Achievements.reset o Achievements.resetAll desde las APIs de Management para restablecer los logros a su estado original.

Tablas de clasificación

Asegúrate de consultar la guía Tablas de clasificación, en la que se explican 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.
  • ¿Terminó el jugador de jugar? Puedes enviar su puntuación a Scores.submit y averiguar si esta es una nueva puntuación alta.
  • ¿Quieres mostrar una tabla de clasificación? Obtén los datos de Scores.list y muéstraselos al usuario.
  • Utiliza Scores.listWindow para encontrar una clasificación de puntuaciones cercanas a la puntuación alta del usuario.
  • Para obtener más información sobre el puntaje del jugador en una tabla de clasificación en particular (por ejemplo, si el jugador se encuentra entre el 12% superior de todos los jugadores), llama a Scores.get.
  • ¿Estás depurando un juego? Intenta llamar a Scores.reset desde Management APIs para restablecer todas las puntuaciones de un jugador en una tabla de clasificación específica