Si admites el acceso con Cuentas de Google, puedes usar el cliente de acceso con un toque para brindarles a los usuarios una experiencia de creación de cuentas sin inconvenientes que nunca los saque del contexto de tu app.
Cuando muestras la IU de One Tap, se les solicita a los usuarios que creen una cuenta nueva con tu app usando una de las Cuentas de Google en su dispositivo. Si el usuario elige continuar, obtienes un token de ID con información básica del perfil (su nombre, foto de perfil y dirección de correo electrónico verificada), que puedes usar para crear la cuenta nueva.
La implementación de la creación de cuentas con One Tap tiene dos partes:
- Integrar el cliente de One Tap en tu app, como se describe en esta página Esto es casi lo mismo que usar el acceso con One Tap, pero con algunas diferencias en la configuración.
- Agrega a tu backend la capacidad de crear cuentas de usuario a partir de tokens de ID de Google, como se explica en Cómo usar tokens de ID en el backend.
¿Dónde debo usar el registro con One Tap?
El lugar más eficaz para ofrecer el registro con One Tap a los usuarios es en un contexto en el que el acceso habilite funciones nuevas. Primero, intenta que el usuario acceda con una credencial guardada. Si no se encuentran credenciales guardadas, ofrécele crear una cuenta nueva al usuario.
Antes de comenzar
Configura tu proyecto de la Consola de APIs de Google y tu proyecto de Android como se describe en Comienza a usar el Acceso con un toque.
1. Configura el cliente de One Tap
Para configurar el cliente de One Tap para la creación de cuentas, haz lo siguiente:
- No habilites las solicitudes de credenciales de contraseña. (El registro con One Tap solo es posible con la autenticación basada en tokens).
Habilita las solicitudes de token de ID de Google con
setGoogleIdTokenRequestOptions()y esta configuración:- 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 Android.
- Configura el cliente para que muestre todas las Cuentas de Google en el dispositivo, es decir, no filtres por cuentas autorizadas.
- De manera opcional, también puedes solicitar el número de teléfono verificado de la cuenta.
Java
public class YourActivity extends AppCompatActivity { // ... private SignInClient oneTapClient; private BeginSignInRequest signUpRequest; @Override public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) { super.onCreate(savedInstanceState, persistentState); oneTapClient = Identity.getSignInClient(this); signUpRequest = BeginSignInRequest.builder() .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder() .setSupported(true) // Your server's client ID, not your Android client ID. .setServerClientId(getString(R.string.your_web_client_id)) // Show all accounts on the device. .setFilterByAuthorizedAccounts(false) .build()) .build(); // ... } }
Kotlin
class YourActivity : AppCompatActivity() { // ... private lateinit var oneTapClient: SignInClient private lateinit var signUpRequest: BeginSignInRequest override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) oneTapClient = Identity.getSignInClient(this) signUpRequest = BeginSignInRequest.builder() .setGoogleIdTokenRequestOptions( BeginSignInRequest.GoogleIdTokenRequestOptions.builder() .setSupported(true) // Your server's client ID, not your Android client ID. .setServerClientId(getString(R.string.your_web_client_id)) // Show all accounts on the device. .setFilterByAuthorizedAccounts(false) .build()) .build() // ... } // ... }
2. Hacer un seguimiento de la cancelación de la IU de One Tap
Debes hacer un seguimiento de si el usuario ya rechazó usar el registro con un toque. Para ello, cierra el mensaje o presiona 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 a continuación).
3. Muestra la IU de registro con One Tap
Si el usuario no rechazó usar One Tap para crear una cuenta nueva, llama al método beginSignIn() del objeto cliente y adjunta objetos de escucha al Task que devuelve. Por lo general, las apps realizan este paso cuando una solicitud de acceso con un toque no encuentra credenciales guardadas, es decir, en el objeto de escucha de fallas de la solicitud de acceso.
El cliente de One Tap llamará al objeto de escucha de éxito si el usuario tiene una o más
Cuentas de Google configuradas en el dispositivo. 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 One Tap.
Si el usuario no tiene ninguna Cuenta de Google en el dispositivo, el cliente de One Tap llamará al objeto de escucha de fallas. En este caso, no es necesario que realices ninguna acción: puedes seguir presentando la experiencia de la app sin acceso, y el usuario puede registrarse con tu flujo normal de creación de cuentas.
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 Google Accounts found. Just continue presenting the signed-out UI.
Log.d(TAG, e.getLocalizedMessage());
}
});
Kotlin
oneTapClient.beginSignIn(signUpRequest)
.addOnSuccessListener(this) { result ->
try {
startIntentSenderForResult(
result.pendingIntent.intentSender, REQ_ONE_TAP,
null, 0, 0, 0)
} catch (e: IntentSender.SendIntentException) {
Log.e(TAG, "Couldn't start One Tap UI: ${e.localizedMessage}")
}
}
.addOnFailureListener(this) { e ->
// No Google Accounts found. Just continue presenting the signed-out UI.
Log.d(TAG, e.localizedMessage)
}
4. Controla la respuesta del usuario
La respuesta del usuario a la solicitud de registro con un toque se informará a tu app con el método onActivityResult() de tu actividad. Si el usuario elige crear una cuenta, el resultado será un token de ID de Google. Si el usuario rechazó registrarse, 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 controlar ambas posibilidades.
Crea una cuenta con un token de ID de Google
Si el usuario eligió registrarse con una Cuenta de Google, puedes obtener un token de ID para el usuario pasando los datos del intent de onActivityResult() al método getSignInCredentialFromIntent() del cliente de One Tap. La credencial tendrá una propiedad googleIdToken no nula.
Usa el token de ID para crear una cuenta en tu backend (consulta Cómo autenticar con un backend usando tokens de ID) y haz que el usuario acceda.
La credencial también contiene los detalles adicionales que solicitaste, como el número de teléfono verificado de la cuenta, si está disponible.
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(); if (idToken != null) { // Got an ID token from Google. Use it to authenticate // with your backend. Log.d(TAG, "Got ID token."); } } 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 when { idToken != null -> { // Got an ID token from Google. Use it to authenticate // with your backend. Log.d(TAG, "Got ID token.") } else -> { // Shouldn't happen. Log.d(TAG, "No ID token!") } } } catch (e: ApiException) { // ... } } } // ... }
Deja de mostrar la IU de One Tap
Si el usuario rechazó acceder, la llamada a getSignInCredentialFromIntent() arrojará un ApiException con un código de estado CommonStatusCodes.CANCELED.
Cuando esto suceda, debes dejar de mostrar temporalmente la IU de acceso con un toque para no molestar a los usuarios con mensajes repetidos. En el siguiente ejemplo, se logra esto configurando una propiedad en la actividad, que se usa para determinar si se le ofrece al usuario el acceso con un toque. Sin embargo, también puedes guardar un valor en SharedPreferences o usar algún otro método.
Es importante implementar tu propio límite de frecuencia de las indicaciones de acceso con un toque. Si no lo haces y un usuario cancela varias indicaciones seguidas, el cliente de One Tap no le hará preguntas 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})") } } } } } } // ... }
Próximos pasos
Cuando un usuario completa el flujo de registro de One Tap, obtienes un token de ID de Google, que incluye información básica del perfil: la dirección de correo electrónico, el nombre completo y la URL de la foto de perfil del usuario. Para muchas apps, esta información es suficiente para que autentiques al usuario en el backend y crees una cuenta nueva.
Si necesitas información adicional para completar la creación de la cuenta, por ejemplo, la fecha de nacimiento del usuario, preséntale un flujo de detalles de registro en el que le solicites esta información adicional. Luego, envíala a tu backend para completar la creación de la cuenta.