Si admites el acceso con Cuentas de Google, puedes usar el acceso con One Tap también ofrece a los usuarios una experiencia de creación de cuentas sin inconvenientes que nunca los quita del contexto de tu app.
Cuando muestras la IU de One Tap, se les indica a los usuarios que creen una cuenta nueva con la app con una de las Cuentas de Google de su dispositivo. Si el usuario elige para continuar, obtienes un token de ID con información básica de perfil; su nombre, foto de perfil y su dirección de correo electrónico verificada, que puedes usar para crea la cuenta nueva.
La implementación de la creación de cuentas con One Tap tiene dos partes:
- Cómo 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 configuración.
- Agregar a tu backend la capacidad de crear cuentas de usuario a partir del ID de Google tokens, que se analiza en Cómo usar tokens de ID en el backend.
¿Dónde debo usar el registro con One Tap?
El lugar de mayor impacto para ofrecerles a los usuarios el registro con One Tap es aquel en el que el acceso habilitaría nuevas funciones. Primero, intenta que el usuario acceda con un la credencial guardada. Si no se encuentran credenciales guardadas, ofrece crear una nueva. cuenta del usuario.
Antes de comenzar
Configura el proyecto de la consola de las APIs de Google y el proyecto de Android como se describe en Cómo comenzar a usar el acceso con One Tap.
1. Configura el cliente de One Tap
Si deseas configurar el cliente de One Tap para la creación de cuentas, haz lo siguiente:
- No habilites las solicitudes de credenciales de contraseñas. (Solo se puede presionar una vez para registrarte 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 como el ID que creaste en las APIs de Google. Console. Ten en cuenta que este es el ID de cliente de tu servidor, no tu ID de cliente de Android.
- Configura el cliente para que muestre todas las Cuentas de Google en el dispositivo, que no filtre por cuentas autorizadas.
- Si lo deseas, también puedes solicitar el teléfono verificado. número para 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. Realiza un seguimiento de la cancelación de la IU de One Tap
Debes realizar un seguimiento para saber si el usuario ya rechazó el uso de One Tap. para registrarte, ya sea cerrando el mensaje o presionando fuera de él. Esto puede ser lo siguiente: simple como una propiedad booleana de tu actividad. (Consulta Dejar de mostrar el botón One Tap de usuario a continuación).
3. Muestra la IU de registro con One Tap
Si el usuario no rechazó el uso de One Tap para crear una cuenta nueva, llama al
método beginSignIn() del objeto de cliente y adjuntar objetos de escucha al Task que
de retorno. Por lo general, las apps realizan este paso cuando una solicitud de acceso con One Tap no encuentra
las credenciales guardadas, es decir, en el objeto de escucha de errores del controlador de acceso
para cada solicitud.
El cliente de One Tap llamará al objeto de escucha que detecta el resultado correcto si el usuario tiene uno o más.
Cuentas de Google configuradas en el dispositivo. En el objeto de escucha que detecta el resultado correcto, obtén el estado
intent del resultado Task y pásalo a startIntentSenderForResult() al
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 errores. En este caso, no es necesario que realices ninguna acción: puedes continuar presentando la experiencia de sesión cerrada de la aplicación, y el usuario registrarte siguiendo tu proceso 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. Cómo controlar la respuesta del usuario
Se informará a tu app la respuesta del usuario al mensaje de registro con One Tap
usando el método onActivityResult() de tu Activity. Si el usuario eligió crear un
, el resultado será un token de ID de Google. Si el usuario rechazó el registro,
cerrando la IU de One Tap o presionando fuera de ella, el resultado
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 elige registrarse con una Cuenta de Google, usted puede obtener un token de ID para
el usuario pasando los datos del intent de onActivityResult() a One Tap
método getSignInCredentialFromIntent() del cliente. La credencial tendrá un
propiedad googleIdToken no nula.
Usa el token de ID para crear una cuenta en tu backend (consulta Autentica con un backend con tokens de ID) y haz que el usuario acceda.
La credencial también contiene cualquier detalle adicional que hayas solicitado, 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) { // ... } } } // ... }
Dejar de mostrar la IU de One Tap
Si el usuario rechazó el acceso, la llamada a getSignInCredentialFromIntent()
arrojará una ApiException con un código de estado CommonStatusCodes.CANCELED.
Cuando esto sucede, debes dejar de mostrar temporalmente la IU de acceso con One Tap
de modo que no molestes a tus usuarios con solicitudes repetidas. El siguiente ejemplo
lo logra estableciendo una propiedad en la actividad, que usa para
determinar si se le debe ofrecer al usuario el acceso con One Tap Sin embargo, también podrías
guarda un valor en SharedPreferences o usa algún otro método.
Es importante que implementes tu propio límite de frecuencia de mensajes de acceso con One Tap. De lo contrario, y un usuario cancela varios mensajes seguidos, el cliente de One Tap no solicitará permiso 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 con One Tap, obtienes un token de ID de Google, que incluya información básica del perfil: la dirección de correo electrónico del usuario, el nombre completo, y la URL de la foto de perfil. En muchas apps, esta información es suficiente para autenticar al usuario en el backend y crear una cuenta nueva
Si necesitas información adicional para completar la creación de la cuenta, por ejemplo, la fecha de nacimiento del usuario: se le presenta un flujo de detalles de registro, en el que solicitas esta información adicional. Luego, envíala a tu backend para completar la creación de la cuenta.