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

Acceso a juegos para Android

Para acceder a la funcionalidad de los Servicios de juego de Google Play, tu juego debe proporcionar la del jugador que accedió. Si el jugador no está autenticado, es posible que el juego genere errores. cuando se realizan llamadas a las APIs de los servicios de juego de Google Play. En esta documentación, se describe cómo implementar una experiencia perfecta de acceso en tu juego.

Cómo implementar el acceso de jugadores

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:

Crea un cliente de acceso mediante el GoogleSignInOptions como se muestra en el siguiente fragmento de código. En la GoogleSignInOptions.Builder para configurar el acceso, debes especificar GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Si quieres usar un SnapshotsClient: luego, agrega .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) a tu GoogleSignInOptions.Builder como se muestra en el siguiente fragmento de código:
```
GoogleSignInOptions  signInOptions =
    new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
        .build();
```
Precaución: No solicites ningún otro permiso ni datos del perfil de Google, a menos que son esenciales para tu caso de uso. Cualquier otro alcance causa la primera vez el acceso silencioso fallará, excepto para los usuarios que ya accedieron correctamente en otro dispositivo.
Llama al método GoogleSignIn.getClient() y pasa las opciones que configuraste en los pasos anteriores. Si la llamada es exitosa, la API de Google Sign-In devuelve una instancia de GoogleSignInClient

Comprueba si el jugador ya accedió

Puedes verificar si ya accediste a una cuenta. en el dispositivo actual con GoogleSignIn.getLastSignedInAccount() y si esta cuenta ya tiene los permisos necesarios otorgados mediante GoogleSignIn.hasPermissions() Si ambas condiciones son verdaderas, es decir, getLastSignedInAccount() muestra un valor no nulo y hasPermissions() muestra true; puedes usar la cuenta que devolvió getLastSignedInAccount(), incluso si el dispositivo está sin conexión.

Acceso silencioso

Puedes llamar a silentSignIn() para recuperar la cuenta del jugador que accedió. e intentar que los jugadores accedan sin mostrar una interfaz de usuario si tienen accediste correctamente a tu app en otro dispositivo.

El método silentSignIn() muestra un objeto Task<GoogleSignInAccount>. Cuando se complete la tarea, debes establecer el campo GoogleSignInAccount que declaraste antes en la cuenta de acceso que la tarea muestra como resultado, o a null, lo que indica que no hay un usuario que accedió.

Si falla el intento de acceso silencioso, tienes la opción de enviar el intent de acceso para que muestre un de inicio de sesión, tal como se describe en Cómo realizar el acceso interactivo.

Como el estado del jugador que accedió puede cambiar cuando la actividad no está en primer plano, se recomienda llamar a silentSignIn() desde el directorio onResume() .

Para acceder de forma silenciosa, sigue estos pasos:

Llama al método silentSignIn() en GoogleSignInClient para iniciar el flujo de acceso silencioso. Esta llamada muestra un objeto Task<GoogleSignInAccount> que contiene un GoogleSignInAccount si el acceso silencioso se realiza correctamente.
Maneja el éxito o el fracaso del acceso del jugador anulando OnCompleteListener
- Si la tarea de acceso se realizó correctamente, obtén la GoogleSignInAccount. llamando a getResult().
- Si no se pudo acceder, puedes enviar un intent de acceso para iniciar un flujo de acceso interactivo. Para obtener una lista de los objetos de escucha de devolución de llamada adicionales que puedes usar, consulta el Guía para desarrolladores de la API de Tasks y Task Referencia de la API.

En el siguiente fragmento de código, se muestra cómo tu app puede realizar un acceso silencioso:

private void signInSilently() {
  GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
  GoogleSignInAccount account = GoogleSignIn.getLastSignedInAccount(this);
  if (GoogleSignIn.hasPermissions(account, signInOptions.getScopeArray())) {
    // Already signed in.
    // The signed in account is stored in the 'account' variable.
    GoogleSignInAccount signedInAccount = account;
  } else {
    // Haven't been signed-in before. Try the silent sign-in first.
    GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOptions);
    signInClient
        .silentSignIn()
        .addOnCompleteListener(
            this,
            new OnCompleteListener<GoogleSignInAccount>() {
              @Override
              public void onComplete(@NonNull Task<GoogleSignInAccount> task) {
                if (task.isSuccessful()) {
                  // The signed in account is stored in the task's result.
                  GoogleSignInAccount signedInAccount = task.getResult();
                } else {
                  // Player will need to sign-in explicitly using via UI.
                  // See [sign-in best practices](http://developers.google.com/games/services/checklist) for guidance on how and when to implement Interactive Sign-in,
                  // and [Performing Interactive Sign-in](http://developers.google.com/games/services/android/signin#performing_interactive_sign-in) for details on how to implement
                  // Interactive Sign-in.
                }
              }
            });
  }
}

@Override
protected void onResume() {
  super.onResume();
  signInSilently();
}

Si falla el intento de acceso silencioso, puedes llamar getException() a obtén un ApiException con el código de estado detallado. Un código de estado de CommonStatusCodes.SIGN_IN_REQUIRED indica que el jugador debe realizar una acción explícita para acceder. En este caso, tu app debería iniciar un flujo de acceso interactivo como se describe en la siguiente sección

Realiza un acceso interactivo

Para acceder con la interacción del jugador, la app debe iniciar el intent de acceso. Si tiene éxito, La API de Acceso con Google muestra una interfaz de usuario que le solicita al jugador que ingrese sus credenciales. para acceder. Este enfoque simplifica el desarrollo de tu app, ya que la actividad de acceso controla como la necesidad de actualizar los Servicios de Google Play o mostrar solicitudes de consentimiento, en la nombre. El resultado se devuelve mediante el onActivityResult devolución de llamada.

Para acceder de forma interactiva, sigue estos pasos:

Llama a getSigninIntent() en el GoogleSignInClient para obtener un intent de acceso y, luego, llama a startActivity() y pasar esa intent. En el siguiente fragmento de código, se muestra cómo tu app puede inicia un flujo de acceso interactivo:

private void startSignInIntent() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  Intent intent = signInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);
}

En la onActivityResult() o la devolución de llamada, controla el resultado del intent que se muestra.

Si el resultado de acceso fue exitoso, obtén la El objeto GoogleSignInAccount de GoogleSignInResult
Si el resultado de acceso no funciona correctamente, debes solucionar el error de acceso (por ejemplo, mostrar un mensaje de error en una alerta). En el siguiente fragmento de código, se muestra cómo tu app puede controlar los resultados de acceso del jugador:

@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()) {
      // The signed in account is stored in the result.
      GoogleSignInAccount signedInAccount = result.getSignInAccount();
    } 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();
    }
  }
}

Cómo recuperar información de un jugador

El GoogleSignInAccount que muestra la API de Acceso con Google no contiene ningún reproductor. información. Si tu juego usa información del jugador, como el nombre visible y el ID, puedes seguir estos pasos para recuperar esta información.

Obtén un objeto PlayersClient llamando al método getPlayersClient() y pasando y el GoogleSignInAccount como parámetro.
Usa los métodos PlayersClient para cargar de forma asíncrona la Player. que contiene la información del jugador. Por ejemplo, puedes llamar a getCurrentPlayer(). para cargar el reproductor con sesión activa. Si la tarea muestra un ApiException con código de estado de SIGN_IN_REQUIRED, Esto indica que se debe volver a autenticar el jugador. Para hacerlo, llama a GoogleSignInClient.getSignInIntent() para acceder al reproductor de manera interactiva.
Si la tarea muestra correctamente el objeto Player, puedes llamar a los métodos del objeto Un objeto Player para recuperar detalles específicos del jugador (por ejemplo, getDisplayName() o getPlayerId().

Proporcionar un botón de acceso

Para proporcionar un botón estándar de Acceso con Google en tu juego, puedes usar uno de estos enfoques:

Incluye un com.google.android.gms.common.SignInButton. en el diseño de la actividad principal; o
Diseña un botón de acceso personalizado de acuerdo con el desarrollo de la marca de Acceso con Google. lineamientos.

Cuando los usuarios hacen clic en el botón de acceso, el juego debe iniciar el flujo de acceso mediante el envío de un el intent de acceso, como se describe en Cómo realizar un acceso interactivo.

En este fragmento de código, se muestra cómo puedes agregar un botón de acceso en el onCreate() método para tu actividad.

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_sign_in);
  findViewById(R.id.sign_in_button).setOnClickListener(this);
  findViewById(R.id.sign_out_button).setOnClickListener(this);
}

El siguiente fragmento de código muestra cómo puedes enviar el intent de acceso cuando el usuario hace clic en el botón de acceso.

@Override
public void onClick(View view) {
  if (view.getId() == R.id.sign_in_button) {
    // start the asynchronous sign in flow
    startSignInIntent();
  } else if (view.getId() == R.id.sign_out_button) {
    // sign out.
    signOut();
    // show sign-in button, hide the sign-out button
    findViewById(R.id.sign_in_button).setVisibility(View.VISIBLE);
    findViewById(R.id.sign_out_button).setVisibility(View.GONE);
  }
}

Cómo mostrar ventanas emergentes de juegos

Puedes mostrar vistas emergentes en tu juego con la clase GamesClient. Por ejemplo, tu juego puedes mostrar una ventana emergente de "Bienvenido de nuevo" o "Logros desbloqueados". Para permitir los Servicios de juego de Google Play, haz lo siguiente: para mostrar ventanas emergentes en las vistas del juego, llama al setViewForPopups() . Puedes personalizar aún más el lugar en el que aparece la ventana emergente en la pantalla llamando setGravityForPopups()

Cómo cerrar la sesión del jugador

Para salir, debes llamar al método signOut() en GoogleSignInClient.

private void signOut() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  signInClient.signOut().addOnCompleteListener(this,
      new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
          // at this point, the user is signed out.
        }
      });
}