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

Habilita el acceso del servidor a los Servicios de juego de Google Play

Tras la baja de la API de Google Sign-In, quitaremos el SDK de juegos de la versión 1 en 2026. Después de febrero de 2025, no podrás publicar títulos que se hayan integrado recientemente con la versión 1 del SDK de juegos en Google Play. Te recomendamos que uses la versión 2 del SDK de juegos.
Si bien los títulos existentes con las integraciones anteriores de la versión 1 de los juegos seguirán funcionando durante un par de años, te recomendamos que migres a la versión 2 a partir de junio de 2025.
Esta guía se aplica al uso del SDK de la versión 1 de los Servicios de juego de Play. Si deseas obtener información sobre la versión más reciente del SDK, consulta la documentación de la versión 2.

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 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 esta situación, tu 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 (denominado código de Auth del servidor) que el cliente pasa al servidor. Luego, en el servidor, intercambia el código de autorización 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 en juegos para Android.

Para ver un ejemplo de código detallado que muestra cómo usar el Acceso con Google para autenticar a los 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 autorización del servidor por un token de acceso de OAuth con los servicios de autorización de Google y, luego, úsalo para llamar a las APIs de REST de los Servicios de juego de Play.

Antes de comenzar

Antes de integrar el acceso con Google en tu juego, primero deberás agregarlo en Google Play Console, como se describe en Configura 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 no se usa launch_url para este flujo y se puede dejar en blanco.
Para obtener la información de las credenciales de tu app, sigue estos pasos:
1. En tu juego, en Google Play Console, haz clic en Detalles del juego.
2. Desplázate hacia abajo hasta la sección API Console Project y haz clic en el vínculo al proyecto de la Consola de APIs.
3. En la pantalla APIs & Services > Credentials de la consola de APIs de Google, descarga el archivo client_secret.json para tu app web y guárdalo en una ubicación a la que pueda acceder tu servidor. Registra el ID de cliente de la credencial para consultarlo más adelante.
Reinicia tu app del servidor para que esté lista para aceptar solicitudes de la app cliente de tu juego.

La clase GoogleSignInClient es el punto de entrada principal para recuperar la cuenta del jugador que accedió actualmente y para que el jugador acceda si no lo hizo previamente 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. En el objeto GoogleSignInOptions.Builder para configurar tu acceso, debes especificar GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
También debes especificar que tu juego requiere un código de autorización para tu servidor de backend llamando al método GoogleSignInOptions.Builder.requestServerAuthCode() con el ID de cliente del servidor como parámetro. Recuperarás el código de autorización más adelante para obtener tokens de acceso en tu servidor de backend, como se describe en Obtén el código de autorización del servidor.
Llama al método GoogleSignIn.getClient() y pasa las opciones que configuraste anteriormente. Si la llamada se realiza correctamente, la API de Google Sign-In devuelve una instancia de GoogleSignInClient.
Una vez que obtengas la instancia de GoogleSignInClient, debes acceder de forma silenciosa desde el onResume() de la actividad, como se describe en Cómo realizar el 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 puede usar para tokens de acceso en tu servidor de backend, llama al método getServerAuthCode() en el objeto GoogleSignInAccount que Acceder con Google devuelve cuando el 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 autorización del servidor por un token de acceso en el servidor

Envía el código de autorización 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 los Servicios de juego de Google Play en nombre del jugador y, de manera opcional, almacena el token de actualización para 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 para intercambiar el código de autorización 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;
}

Si deseas obtener más información para acceder a las APIs de Google desde un servidor de backend en nombre de un jugador que accedió, consulta Cómo habilitar el acceso al servidor.

Controla la salida del jugador

Para cerrar la sesión de los jugadores en tu juego, llama al método signOut() en GoogleSignInClient. Para ver un ejemplo de fragmento de código, consulta Cómo cerrar 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 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, en la que se explica esta función con más detalle.

¿Quieres recuperar la lista de amigos del jugador? Llama a Players.list con 'friends_all' como collection.
¿Tienes acceso a la lista de amigos? Llama a Players.get para me y observa el campo profileSettings.friendsListVisibility en la respuesta.

Logros

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

¿Quieres obtener una lista de los logros actuales? Puedes llamar a AchievementDefinitions.list.
Combínala con una llamada a Achievements.list para averiguar cuáles consiguió el jugador.
¿Consiguió algún logro el jugador? Usa Achievements.unlock para desbloquearlo.
¿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? Intenta llamar a 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 revisar la guía de tablas de clasificación, en la que se explican 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 el juego? Puedes enviar su puntuación a Scores.submit y averiguar si alcanzó una nueva puntuación alta.
¿Quieres mostrar una tabla de posiciones? 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 sobre el 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.
¿Estás depurando un juego? Intenta llamar a Scores.reset desde las APIs de Management para restablecer todas las puntuaciones de ese jugador desde una tabla de clasificación en particular.