Usa el cliente de acceso con One Tap a fin de solicitarle 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ó en Google con Chrome, Autocompletar de Android o Smart Lock para contraseñas.
Cuando las credenciales se recuperan correctamente, puedes usarlas para que el usuario acceda a tu app sin inconvenientes.
Si el usuario no guardó ninguna credencial, no se presenta ninguna IU, y puedes proporcionar una experiencia normal sin acceder a su cuenta.
¿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 “Acceder con Google”. Como la IU de One Tap se puede configurar para mostrar solo las credenciales que el usuario usó anteriormente para acceder, puede ser un recordatorio para los usuarios que accedieron con poca frecuencia a través de cómo lo hicieron la última vez y evitar que creen cuentas nuevas por accidente 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 mediante el acceso. Por ejemplo, si los usuarios pueden explorar contenido con la app sin acceder a sus cuentas, pero solo pueden publicar comentarios o agregar elementos a un carrito de compras después de acceder, sería un contexto razonable para acceder con One Tap.
Las apps de acceso opcionales también deben usar el acceso con One Tap en sus pantallas de acceso, por los motivos mencionados anteriormente.
Antes de comenzar
- Configura el proyecto de la Consola de APIs de Google y el de Android como se describe en Cómo comenzar a usar el acceso con One Tap.
- Si admites el acceso basado en contraseñas, optimiza tu app para el autocompletado (o usa Smart Lock para contraseñas) para que los usuarios puedan guardar sus credenciales de contraseña después de acceder.
1. Cómo configurar el cliente de acceso con One Tap
Puedes configurar el cliente de acceso con One Tap para que los usuarios accedan con sus contraseñas guardadas, Cuentas de Google guardadas o cualquiera de las dos. (Se recomienda admitir ambos para habilitar la creación de cuentas con un toque para usuarios nuevos y el acceso automático o con un 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 el Acceso con Google, usa setGoogleIdTokenRequestOptions() para habilitar y configurar las solicitudes de token de ID de Google:
Configura el ID de cliente del servidor como 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 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 Cuentas de Google que ya hayan usado en el pasado. Esto puede ayudar a los usuarios a acceder correctamente cuando no están seguros de si ya tienen una cuenta o de qué Cuenta de Google usaron, y evita que los usuarios creen cuentas nuevas por accidente con tu app.
Si quieres que los usuarios accedan automáticamente cuando 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.
Aunque es opcional, te recomendamos que consideres usar un nonce para mejorar la seguridad de acceso y evitar ataques de repetició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. Busca un usuario que haya accedido
Si un usuario que accedió a su cuenta o un usuario que salió de su cuenta puede usar tu actividad, verifica el estado del usuario antes de mostrar la IU de acceso con One Tap.
También debes cerrar el mensaje o presionar fuera de él para hacer un seguimiento de si el usuario ya rechazó el acceso con One Tap. Esto puede ser tan simple como una propiedad booleana de tu actividad. (Consulta Dejar de mostrar la IU de One Tap a continuación).
3. Mostrar la IU de acceso con One Tap
Si el usuario no accedió y no rechazó usar el acceso con One Tap, llama al método beginSignIn() del objeto del cliente y adjunta objetos de escucha al Task que muestra. Por lo general, las apps hacen esto en el método onCreate() de la actividad o después de las transiciones de pantalla cuando usan una arquitectura de actividad única.
El cliente de One Tap llamará al objeto de escucha que detecta el resultado correcto si el usuario tiene credenciales guardadas para tu app. En el objeto de escucha que detecta el resultado correcto, 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 ninguna credencial guardada, el cliente de One Tap llamará al objeto de escucha de fallas. En este caso, no es necesario realizar ninguna acción: puedes continuar presentando la experiencia de salida de la app. Sin embargo, si admites el registro con One Tap, puedes iniciar ese flujo aquí para una experiencia de creación de cuenta fluida. Consulta Crear cuentas nuevas con un 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 al mensaje de acceso con One Tap se informará a tu app a través del método onActivityResult() de tu actividad. Si el usuario elige 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 mostrará con el código RESULT_CANCELED. Tu app debe abarcar ambas posibilidades.
Acceder con credenciales recuperadas
Si el usuario eligió compartir credenciales con tu app, puedes recuperarlas pasando los datos del 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 compartió una contraseña guardada.
Usa la credencial para autenticar con 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 realizar la autenticación con tu backend. Si decidiste usar un nonce para evitar ataques de repetición, verifica el valor de respuesta en tu servidor de backend. Consulta Autenticación con un backend mediante 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) {
// ...
}
}
}
}
// ...
}
Dejar de mostrar la IU de One Tap
Si el usuario rechazó el acceso, la llamada a getSignInCredentialFromIntent()
arrojará una ApiException con el código de estado CommonStatusCodes.CANCELED.
Cuando esto sucede, debes inhabilitar temporalmente la IU de acceso con One Tap para no molestar a los usuarios con mensajes repetidos. En el siguiente ejemplo,
se puede configurar una propiedad en la actividad, que se usa para determinar si
debe ofrecer acceso con One Tap al usuario. Sin embargo, también puedes guardar un valor en
SharedPreferences o usar otro método.
Es importante que implementes tu propio límite de frecuencia de los mensajes de acceso con One Tap. Si no lo haces y un usuario cancela varios mensajes seguidos, el cliente de One Tap no le solicitará permiso durante las siguientes 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.
Si llamas a signOut(), se 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 Servicios de Play que uses.
Próximos pasos
Si configuraste el cliente de One Tap para que recupere las credenciales de Google, tu app ahora podrá obtener tokens de ID de Google que representen las Cuentas de Google de tus usuarios. Aprende a 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 inconvenientes a tu app.