Permite que los usuarios accedan con sus credenciales guardadas

Usa el cliente de acceso con One Tap para solicitar permiso al usuario para recuperar una de las credenciales que usó anteriormente para acceder a tu app. Estas credenciales pueden ser una Cuenta de Google o una combinación de nombre de usuario y contraseña que guardó con Google usando Chrome, Autocompletar de Android o Smart Lock para contraseñas.

IU de acceso con un solo toque

Cuando se recuperan las credenciales correctamente, puedes usarlas para permitir que el usuario acceda a tu app sin inconvenientes.

Si el usuario no guardó ninguna credencial, no se mostrará ninguna IU y podrás proporcionar tu experiencia normal sin acceso.

¿Dónde debo usar el acceso con One Tap?

Si tu app requiere que los usuarios accedan, muestra la IU de One Tap en la pantalla de acceso. Esto puede ser útil incluso si ya tienes un botón de "Acceder con Google", ya que la IU de One Tap se puede configurar para que muestre solo las credenciales que el usuario usó anteriormente para acceder. Esto puede recordarles a los usuarios que acceden con poca frecuencia cómo accedieron la última vez y evitar que creen accidentalmente cuentas nuevas con tu app.

Si el acceso es opcional para tu app, considera usar el acceso con One Tap en cualquier pantalla que tenga una experiencia mejorada por el acceso. Por ejemplo, si los usuarios pueden navegar por el contenido con tu app sin acceder, pero solo pueden publicar comentarios o agregar elementos a un carrito de compras después de acceder, ese sería un contexto adecuado para el acceso con One Tap.

Las apps con acceso opcional también deben usar el acceso con One Tap en sus pantallas de acceso por los motivos mencionados anteriormente.

Antes de comenzar

1. Configura el cliente de acceso con One Tap

Puedes configurar el cliente de acceso con One Tap para que los usuarios accedan con contraseñas guardadas, Cuentas de Google guardadas o ambas. (Se recomienda admitir ambos métodos para habilitar la creación de cuentas con un solo toque para los usuarios nuevos y el acceso automático o con un solo toque para la mayor cantidad posible de usuarios recurrentes).

Si tu app usa el acceso con contraseña, usa setPasswordRequestOptions() para habilitar las solicitudes de credenciales de contraseña.

Si tu app usa Acceder con Google, usa setGoogleIdTokenRequestOptions() para habilitar y configurar las solicitudes de tokens de ID de Google:

  • Establece el ID de cliente del servidor en el ID que creaste en la consola de APIs de Google. Ten en cuenta que este es el ID de cliente de tu servidor, no el de tu cliente de Android.

  • Configura el cliente para que filtre por cuentas autorizadas. Cuando habilitas esta opción, el cliente de One Tap solo les solicita a los usuarios que accedan a tu app con las Cuentas de Google que ya usaron en el pasado. Esto puede ayudar a los usuarios a acceder correctamente cuando no saben si ya tienen una cuenta o qué Cuenta de Google usaron, y evita que creen accidentalmente cuentas nuevas con tu app.

  • Si quieres que los usuarios accedan automáticamente cuando eso sea posible, habilita la función con setAutoSelectEnabled(). El acceso automático es posible cuando se cumplen los siguientes criterios:

    • El usuario tiene exactamente una credencial guardada para tu app. Es decir, una contraseña guardada o una Cuenta de Google guardada.
    • El usuario no inhabilitó el acceso automático en la configuración de su Cuenta de Google.

  • Si bien es opcional, te recomendamos que consideres seriamente usar un nonce para mejorar la seguridad del acceso y evitar ataques de reproducción. Usa setNonce para incluir un nonce en cada solicitud. Consulta la sección Cómo obtener un nonce de SafetyNet para obtener sugerencias y detalles adicionales sobre cómo generar un nonce.

Java

public class YourActivity extends AppCompatActivity {
  // ...

  private SignInClient oneTapClient;
  private BeginSignInRequest signInRequest;

  @Override
  public void onCreate(@Nullable Bundle savedInstanceState,
                       @Nullable PersistableBundle persistentState) {
      super.onCreate(savedInstanceState, persistentState);

      oneTapClient = Identity.getSignInClient(this);
      signInRequest = BeginSignInRequest.builder()
              .setPasswordRequestOptions(PasswordRequestOptions.builder()
                      .setSupported(true)
                      .build())
              .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
                      .setSupported(true)
                      // Your server's client ID, not your Android client ID.
                      .setServerClientId(getString(R.string.default_web_client_id))
                      // Only show accounts previously used to sign in.
                      .setFilterByAuthorizedAccounts(true)
                      .build())
              // Automatically sign in when exactly one credential is retrieved.
              .setAutoSelectEnabled(true)
              .build();
      // ...
  }
  // ...
}

Kotlin

class YourActivity : AppCompatActivity() {
    // ...

    private lateinit var oneTapClient: SignInClient
    private lateinit var signInRequest: BeginSignInRequest

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        oneTapClient = Identity.getSignInClient(this)
        signInRequest = BeginSignInRequest.builder()
            .setPasswordRequestOptions(BeginSignInRequest.PasswordRequestOptions.builder()
                .setSupported(true)
                .build())
            .setGoogleIdTokenRequestOptions(
                BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
                    .setSupported(true)
                    // Your server's client ID, not your Android client ID.
                    .setServerClientId(getString(R.string.your_web_client_id))
                    // Only show accounts previously used to sign in.
                    .setFilterByAuthorizedAccounts(true)
                    .build())
            // Automatically sign in when exactly one credential is retrieved.
            .setAutoSelectEnabled(true)
            .build()
        // ...
    }
    // ...
}

2. Cómo verificar si un usuario accedió a su cuenta

Si tu Activity puede ser utilizada por un usuario que accedió a su cuenta o por un usuario que no lo hizo, verifica el estado del usuario antes de mostrar la IU de acceso con One Tap.

También debes hacer un seguimiento para saber si el usuario ya rechazó el uso del acceso con One Tap cerrando el mensaje o presionando fuera de él. Esto puede ser tan simple como una propiedad booleana de tu actividad. (Consulta Cómo dejar de mostrar la IU de One Tap más abajo).

3. Muestra la IU de acceso con One Tap

Si el usuario no accedió y aún no rechazó el uso del acceso con One Tap, llama al método beginSignIn() del objeto cliente y adjunta objetos de escucha al Task que devuelve. Por lo general, las apps hacen esto en el método onCreate() de la actividad o después de las transiciones de pantalla cuando se usa una arquitectura de una sola actividad.

El cliente de One Tap llamará al objeto de escucha de éxito si el usuario tiene credenciales guardadas para tu app. En el objeto de escucha de éxito, obtén el intent pendiente del resultado Task y pásalo a startIntentSenderForResult() para iniciar la IU de acceso con One Tap.

Si el usuario no tiene credenciales guardadas, el cliente de One Tap llamará al objeto de escucha de errores. En este caso, no es necesario que realices ninguna acción: simplemente puedes seguir presentando la experiencia de la app para usuarios que no accedieron a su cuenta. Sin embargo, si admites el registro con un solo toque, puedes iniciar ese flujo aquí para brindar una experiencia de creación de cuentas fluida. Consulta Cómo crear cuentas nuevas con un solo toque.

Java

oneTapClient.beginSignIn(signUpRequest)
        .addOnSuccessListener(this, new OnSuccessListener<BeginSignInResult>() {
            @Override
            public void onSuccess(BeginSignInResult result) {
                try {
                    startIntentSenderForResult(
                            result.getPendingIntent().getIntentSender(), REQ_ONE_TAP,
                            null, 0, 0, 0);
                } catch (IntentSender.SendIntentException e) {
                    Log.e(TAG, "Couldn't start One Tap UI: " + e.getLocalizedMessage());
                }
            }
        })
        .addOnFailureListener(this, new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // No saved credentials found. Launch the One Tap sign-up flow, or
                // do nothing and continue presenting the signed-out UI.
                Log.d(TAG, e.getLocalizedMessage());
            }
        });

Kotlin

oneTapClient.beginSignIn(signInRequest)
    .addOnSuccessListener(this) { result ->
        try {
            startIntentSenderForResult(
                result.pendingIntent.intentSender, REQ_ONE_TAP,
                null, 0, 0, 0, null)
        } catch (e: IntentSender.SendIntentException) {
            Log.e(TAG, "Couldn't start One Tap UI: ${e.localizedMessage}")
        }
    }
    .addOnFailureListener(this) { e ->
        // No saved credentials found. Launch the One Tap sign-up flow, or
        // do nothing and continue presenting the signed-out UI.
        Log.d(TAG, e.localizedMessage)
    }

4. Cómo controlar la respuesta del usuario

La respuesta del usuario a la solicitud de acceso con One Tap se informará a tu app a través del método onActivityResult() de tu Activity. Si el usuario eligió acceder, el resultado será una credencial guardada. Si el usuario rechazó el acceso, ya sea cerrando la IU de One Tap o presionando fuera de ella, el resultado se devolverá con el código RESULT_CANCELED. Tu app debe controlar ambas posibilidades.

Accede con las credenciales recuperadas

Si el usuario eligió compartir credenciales con tu app, puedes recuperarlas pasando los datos de la intent de onActivityResult() al método getSignInCredentialFromIntent() del cliente de One Tap. La credencial tendrá una propiedad googleIdToken no nula si el usuario compartió una credencial de Cuenta de Google con tu app, o una propiedad password no nula si el usuario compartió una contraseña guardada.

Usa la credencial para autenticarte en el backend de tu app.

  • Si se recuperó un par de nombre de usuario y contraseña, úsalos para acceder de la misma manera que lo harías si el usuario los hubiera proporcionado manualmente.

  • Si se recuperaron las credenciales de la Cuenta de Google, usa el token de ID para autenticarte con tu backend. Si elegiste usar un nonce para evitar ataques de reproducción, verifica el valor de respuesta en tu servidor de backend. Consulta Cómo autenticar con un backend usando tokens de ID.

Java

public class YourActivity extends AppCompatActivity {

  // ...
  private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
  private boolean showOneTapUI = true;
  // ...

  @Override
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
      super.onActivityResult(requestCode, resultCode, data);

      switch (requestCode) {
          case REQ_ONE_TAP:
              try {
                  SignInCredential credential = oneTapClient.getSignInCredentialFromIntent(data);
                  String idToken = credential.getGoogleIdToken();
                  String username = credential.getId();
                  String password = credential.getPassword();
                  if (idToken !=  null) {
                      // Got an ID token from Google. Use it to authenticate
                      // with your backend.
                      Log.d(TAG, "Got ID token.");
                  } else if (password != null) {
                      // Got a saved username and password. Use them to authenticate
                      // with your backend.
                      Log.d(TAG, "Got password.");
                  }
              } catch (ApiException e) {
                  // ...
              }
              break;
      }
  }
}

Kotlin

class YourActivity : AppCompatActivity() {

    // ...
    private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
    private var showOneTapUI = true
    // ...

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        when (requestCode) {
             REQ_ONE_TAP -> {
                try {
                    val credential = oneTapClient.getSignInCredentialFromIntent(data)
                    val idToken = credential.googleIdToken
                    val username = credential.id
                    val password = credential.password
                    when {
                        idToken != null -> {
                            // Got an ID token from Google. Use it to authenticate
                            // with your backend.
                            Log.d(TAG, "Got ID token.")
                        }
                        password != null -> {
                            // Got a saved username and password. Use them to authenticate
                            // with your backend.
                            Log.d(TAG, "Got password.")
                        }
                        else -> {
                            // Shouldn't happen.
                            Log.d(TAG, "No ID token or password!")
                        }
                    }
                } catch (e: ApiException) {
                    // ...
                }
            }
        }
    }
    // ...
}

Deja de mostrar la IU de One Tap

Si el usuario rechazó el acceso, la llamada a getSignInCredentialFromIntent() arrojará un ApiException con un código de estado CommonStatusCodes.CANCELED. Cuando esto suceda, debes inhabilitar temporalmente la IU de acceso con One Tap para no molestar a los usuarios con mensajes repetidos. En el siguiente ejemplo, se establece una propiedad en la Activity, que se usa para determinar si se le ofrece al usuario el acceso con One Tap. Sin embargo, también puedes guardar un valor en SharedPreferences o usar algún otro método.

Es importante que implementes tu propio límite de frecuencia para las indicaciones de acceso con One Tap. Si no lo haces y un usuario cancela varias indicaciones seguidas, el cliente de One Tap no le mostrará indicaciones al usuario durante las próximas 24 horas.

Java

public class YourActivity extends AppCompatActivity {

  // ...
  private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
  private boolean showOneTapUI = true;
  // ...

  @Override
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
      super.onActivityResult(requestCode, resultCode, data);

      switch (requestCode) {
          case REQ_ONE_TAP:
              try {
                  // ...
              } catch (ApiException e) {
                  switch (e.getStatusCode()) {
                      case CommonStatusCodes.CANCELED:
                          Log.d(TAG, "One-tap dialog was closed.");
                          // Don't re-prompt the user.
                          showOneTapUI = false;
                          break;
                      case CommonStatusCodes.NETWORK_ERROR:
                          Log.d(TAG, "One-tap encountered a network error.");
                          // Try again or just ignore.
                          break;
                      default:
                          Log.d(TAG, "Couldn't get credential from result."
                                  + e.getLocalizedMessage());
                          break;
                  }
              }
              break;
      }
  }
}

Kotlin

class YourActivity : AppCompatActivity() {

    // ...
    private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
    private var showOneTapUI = true
    // ...

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        when (requestCode) {
            REQ_ONE_TAP -> {
                try {
                    // ...
                } catch (e: ApiException) {
                    when (e.statusCode) {
                        CommonStatusCodes.CANCELED -> {
                            Log.d(TAG, "One-tap dialog was closed.")
                            // Don't re-prompt the user.
                            showOneTapUI = false
                        }
                        CommonStatusCodes.NETWORK_ERROR -> {
                            Log.d(TAG, "One-tap encountered a network error.")
                            // Try again or just ignore.
                        }
                        else -> {
                            Log.d(TAG, "Couldn't get credential from result." +
                                " (${e.localizedMessage})")
                        }
                    }
                }
            }
        }
    }
    // ...
}

5. Controla el cierre de sesión

Cuando un usuario salga de tu app, llama al método signOut() del cliente de One Tap. Llamar a signOut() inhabilita el acceso automático hasta que el usuario vuelva a acceder.

Incluso si no usas el acceso automático, este paso es importante porque garantiza que, cuando los usuarios salgan de tu app, también se restablezca el estado de autenticación de las APIs de los Servicios de Play que uses.

Próximos pasos

Si configuraste el cliente de One Tap para recuperar credenciales de Google, tu app ahora puede obtener tokens de ID de Google que representan las Cuentas de Google de tus usuarios. Obtén más información sobre cómo usar estos tokens en el backend.

Si admites el Acceso con Google, también puedes usar el cliente de One Tap para agregar flujos de creación de cuentas sin problemas a tu app.